1 def capitalize(self): # real signature unknown; restored from __doc__
2         """
3         S.capitalize() -> str
4         
5         Return a capitalized version of S, i.e. make the first character
6         have upper case and the rest lower case.
7         """
8         return ""

1 def casefold(self): # real signature unknown; restored from __doc__
2         """
3         S.casefold() -> str
4         
5         Return a version of S suitable for caseless comparisons.
6         """
7         return ""

1 def lower(self): # real signature unknown; restored from __doc__
2         """
3         S.lower() -> str
4         
5         Return a copy of the string S converted to lowercase.
6         """
7         return ""

1 def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
2         """
3         S.center(width[, fillchar]) -> str
4         
5         Return S centered in a string of length width. Padding is
6         done using the specified fill character (default is a space)
7         """
8         return ""

1 def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
2         """
3         S.count(sub[, start[, end]]) -> int
4         
5         Return the number of non-overlapping occurrences of substring sub in
6         string S[start:end].  Optional arguments start and end are
7         interpreted as in slice notation.
8         """
9         return 0

 1  def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
 2         """
 3         S.endswith(suffix[, start[, end]]) -> bool
 4         
 5         Return True if S ends with the specified suffix, False otherwise.
 6         With optional start, test S beginning at that position.
 7         With optional end, stop comparing S at that position.
 8         suffix can also be a tuple of strings to try.
 9         """
10         return False

1 def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
2         """
3         S.expandtabs(tabsize=8) -> str
4         
5         Return a copy of S where all tab characters are expanded using spaces.
6         If tabsize is not given, a tab size of 8 characters is assumed.
7         """
8         return ""

def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
        """
        S.find(sub[, start[, end]]) -> int
        
        Return the lowest index in S where substring sub is found,
        such that sub is contained within S[start:end].  Optional
        arguments start and end are interpreted as in slice notation.
        
        Return -1 on failure.
        """
        return 0

1 def format(*args, **kwargs): # known special case of str.format
2         """
3         S.format(*args, **kwargs) -> str
4         
5         Return a formatted version of S, using substitutions from args and kwargs.
6         The substitutions are identified by braces (‘{‘ and ‘}‘).
7         """
8         pass

1 def format_map(self, mapping): # real signature unknown; restored from __doc__
2         """
3         S.format_map(mapping) -> str
4         
5         Return a formatted version of S, using substitutions from mapping.
6         The substitutions are identified by braces (‘{‘ and ‘}‘).
7         """
8         return ""

1 def isalnum(self): # real signature unknown; restored from __doc__
2         """
3         S.isalnum() -> bool
4         
5         Return True if all characters in S are alphanumeric
6         and there is at least one character in S, False otherwise.
7         """
8         return False

1 def isalnum(self): # real signature unknown; restored from __doc__
2         """
3         S.isalnum() -> bool
4         
5         Return True if all characters in S are alphanumeric
6         and there is at least one character in S, False otherwise.
7         """
8         return False

1 def isdecimal(self): # real signature unknown; restored from __doc__
2         """
3         S.isdecimal() -> bool
4         
5         Return True if there are only decimal characters in S,
6         False otherwise.
7         """
8         return False

1 def isdigit(self): # real signature unknown; restored from __doc__
2         """
3         S.isdigit() -> bool
4         
5         Return True if all characters in S are digits
6         and there is at least one character in S, False otherwise.
7         """
8         return False

 1 def isidentifier(self): # real signature unknown; restored from __doc__
 2         """
 3         S.isidentifier() -> bool
 4         
 5         Return True if S is a valid identifier according
 6         to the language definition.
 7         
 8         Use keyword.iskeyword() to test for reserved identifiers
 9         such as "def" and "class".
10         """
11         return False

1 def islower(self): # real signature unknown; restored from __doc__
2         """
3         S.islower() -> bool
4         
5         Return True if all cased characters in S are lowercase and there is
6         at least one cased character in S, False otherwise.
7         """
8         return False

1 def isprintable(self): # real signature unknown; restored from __doc__
2         """
3         S.isprintable() -> bool
4         
5         Return True if all characters in S are considered
6         printable in repr() or S is empty, False otherwise.
7         """
8         return False

1 def join(self, iterable): # real signature unknown; restored from __doc__
2         """
3         S.join(iterable) -> str
4         
5         Return a string which is the concatenation of the strings in the
6         iterable.  The separator between elements is S.
7         """
8         return ""

1 def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
2         """
3         S.ljust(width[, fillchar]) -> str
4         
5         Return S left-justified in a Unicode string of length width. Padding is
6         done using the specified fill character (default is a space).
7         """
8         return ""

 1 def maketrans(self, *args, **kwargs): # real signature unknown
 2         """
 3         Return a translation table usable for str.translate().
 4         
 5         If there is only one argument, it must be a dictionary mapping Unicode
 6         ordinals (integers) or characters to Unicode ordinals, strings or None.
 7         Character keys will be then converted to ordinals.
 8         If there are two arguments, they must be strings of equal length, and
 9         in the resulting dictionary, each character in x will be mapped to the
10         character at the same position in y. If there is a third argument, it
11         must be a string, whose characters will be mapped to None in the result.
12         """
13         pass

1 def partition(self, sep): # real signature unknown; restored from __doc__
2         """
3         S.partition(sep) -> (head, sep, tail)
4         
5         Search for the separator sep in S, and return the part before it,
6         the separator itself, and the part after it.  If the separator is not
7         found, return S and two empty strings.
8         """
9         pass

1 def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
2         """
3         S.replace(old, new[, count]) -> str
4         
5         Return a copy of S with all occurrences of substring
6         old replaced by new.  If the optional argument count is
7         given, only the first count occurrences are replaced.
8         """
9         return ""

1 def strip(self, chars=None): # real signature unknown; restored from __doc__
2         """
3         S.strip([chars]) -> str
4         
5         Return a copy of the string S with leading and trailing
6         whitespace removed.
7         If chars is given and not None, remove characters in chars instead.
8         """
9         return ""

1 def zfill(self, width): # real signature unknown; restored from __doc__
2         """
3         S.zfill(width) -> str
4         
5         Pad a numeric string S with zeros on the left, to fill a field
6         of the specified width. The string S is never truncated.
7         """
8         return ""

def bit_length(self): # real signature unknown; restored from __doc__
        """
        int.bit_length() -> int
        
        Number of bits necessary to represent self in binary.
        >>> bin(37)
        ‘0b100101‘
        >>> (37).bit_length()
        6
        """
        return 0

def to_bytes(self, length, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
        """
        int.to_bytes(length, byteorder, *, signed=False) -> bytes
        
        Return an array of bytes representing an integer.
        
        The integer is represented using length bytes.  An OverflowError is
        raised if the integer is not representable with the given number of
        bytes.
        
        The byteorder argument determines the byte order used to represent the
        integer.  If byteorder is ‘big‘, the most significant byte is at the
        beginning of the byte array.  If byteorder is ‘little‘, the most
        significant byte is at the end of the byte array.  To request the native
        byte order of the host system, use `sys.byteorder‘ as the byte order value.
        
        The signed keyword-only argument determines whether two‘s complement is
        used to represent the integer.  If signed is False and a negative integer
        is given, an OverflowError is raised.
        """
        pass

def append(self, p_object): # real signature unknown; restored from __doc__
        """ L.append(object) -> None -- append object to end """
        pass