# coding: utf-8
# AUTO-GENERATED FILE -- DO NOT EDIT

""" Functions to convert between Python values and C structs.
Python bytes objects are used to hold the data representing the C struct
and also as format strings (explained below) to describe the layout of data
in the C struct.

The optional first format char indicates byte order, size and alignment:
  @: native order, size & alignment (default)
  =: native order, std. size & alignment
  <: little-endian, std. size & alignment
  >: big-endian, std. size & alignment
  !: same as >

The remaining chars indicate types of args and must match exactly;
these can be preceded by a decimal repeat count:
  x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;
  ?: _Bool (requires C99; if not available, char is used instead)
  h:short; H:unsigned short; i:int; I:unsigned int;
  l:long; L:unsigned long; f:float; d:double; e:half-float.
Special cases (preceding decimal count indicates length):
  s:string (array of char); p: pascal string (with count byte).
Special cases (only available in native format):
  n:ssize_t; N:size_t;
  P:an integer type that is wide enough to hold a pointer.
Special case (not in native mode unless 'long long' in platform C):
  q:long long; Q:unsigned long long
Whitespace between formats is ignored.

The variable struct.error is an exception raised on errors.
 """

class Struct(object):
  """ Struct(fmt) --> compiled struct object
  
  Return a new Struct object which writes and reads binary data according to
  the format string fmt.  See help(struct) for more on format strings. """

  def __init__(self, *args, **kwargs):
    return ""

  format = property(None, None, None,
                    """ struct format string """
                    )


  def iter_unpack(self, buffer):
    """ S.iter_unpack(buffer) -> iterator(v1, v2, ...)
    
    Return an iterator yielding tuples unpacked from the given bytes
    source, like a repeated invocation of unpack_from().  Requires
    that the bytes length be a multiple of the struct size. """
    return None

  def pack(self, v1, v2, *args):
    """ S.pack(v1, v2, ...) -> bytes
    
    Return a bytes object containing values v1, v2, ... packed according
    to the format string S.format.  See help(struct) for more on format
    strings. """
    return None

  def pack_into(self, buffer, offset, v1, v2, *args):
    """ S.pack_into(buffer, offset, v1, v2, ...)
    
    Pack the values v1, v2, ... according to the format string S.format
    and write the packed bytes into the writable buffer buf starting at
    offset.  Note that the offset is a required argument.  See
    help(struct) for more on format strings. """
    pass

  size = property(None, None, None,
                  """ struct size in bytes """
                  )


  def unpack(self, buffer):
    """ S.unpack(buffer) -> (v1, v2, ...)
    
    Return a tuple containing values unpacked according to the format
    string S.format.  The buffer's size in bytes must be S.size.  See
    help(struct) for more on format strings. """
    return ()

  def unpack_from(self, buffer, offset=0):
    """ S.unpack_from(buffer, offset=0) -> (v1, v2, ...)
    
    Return a tuple containing values unpacked according to the format
    string S.format.  The buffer's size in bytes, minus offset, must be at
    least S.size.  See help(struct) for more on format strings. """
    return ()

__doc__ = """Functions to convert between Python values and C structs.
Python bytes objects are used to hold the data representing the C struct
and also as format strings (explained below) to describe the layout of data
in the C struct.

The optional first format char indicates byte order, size and alignment:
  @: native order, size & alignment (default)
  =: native order, std. size & alignment
  <: little-endian, std. size & alignment
  >: big-endian, std. size & alignment
  !: same as >

The remaining chars indicate types of args and must match exactly;
these can be preceded by a decimal repeat count:
  x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;
  ?: _Bool (requires C99; if not available, char is used instead)
  h:short; H:unsigned short; i:int; I:unsigned int;
  l:long; L:unsigned long; f:float; d:double; e:half-float.
Special cases (preceding decimal count indicates length):
  s:string (array of char); p: pascal string (with count byte).
Special cases (only available in native format):
  n:ssize_t; N:size_t;
  P:an integer type that is wide enough to hold a pointer.
Special case (not in native mode unless 'long long' in platform C):
  q:long long; Q:unsigned long long
Whitespace between formats is ignored.

The variable struct.error is an exception raised on errors.
"""
__file__ = '/Users/Shared/src/ide/build-files/build-temp/runtimes-release/__os__/osx/runtime-python3.6/lib/Python.framework/Versions/Current/lib/python3.6/lib-dynload/_struct.cpython-36m-darwin.so'
__loader__ = None
__name__ = '_struct'
__package__ = ''
__spec__ = None

def _clearcache():
  """ Clear the internal cache. """
  pass

def calcsize(fmt):
  """ calcsize(fmt) -> integer
  
  Return size in bytes of the struct described by the format string fmt. """
  return 1

class error(Exception):

  pass

def iter_unpack(fmt, buffer):
  """ iter_unpack(fmt, buffer) -> iterator(v1, v2, ...)
  
  Return an iterator yielding tuples unpacked from the given bytes
  source according to the format string, like a repeated invocation of
  unpack_from().  Requires that the bytes length be a multiple of the
  format struct size. """
  return None

def pack(fmt, v1, v2, *args):
  """ pack(fmt, v1, v2, ...) -> bytes
  
  Return a bytes object containing the values v1, v2, ... packed according
  to the format string fmt.  See help(struct) for more on format strings. """
  return None

def pack_into(fmt, buffer, offset, v1, v2, *args):
  """ pack_into(fmt, buffer, offset, v1, v2, ...)
  
  Pack the values v1, v2, ... according to the format string fmt and write
  the packed bytes into the writable buffer buf starting at offset.  Note
  that the offset is a required argument.  See help(struct) for more
  on format strings. """
  pass

def unpack(fmt, buffer):
  """ unpack(fmt, buffer) -> (v1, v2, ...)
  
  Return a tuple containing values unpacked according to the format string
  fmt.  The buffer's size in bytes must be calcsize(fmt). See help(struct)
  for more on format strings. """
  return ()

def unpack_from(fmt, buffer, offset=0):
  """ unpack_from(fmt, buffer, offset=0) -> (v1, v2, ...)
  
  Return a tuple containing values unpacked according to the format string
  fmt.  The buffer's size, minus offset, must be at least calcsize(fmt).
  See help(struct) for more on format strings. """
  return ()