# 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.
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, fmt):
    return ""

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


  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.  Requires len(buffer) == 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.  Requires len(buffer[offset:]) >= 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.
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.3/lib/Python.framework/Versions/3.3/lib/python3.3/lib-dynload/_struct.so'
__loader__ = None
__name__ = '_struct'
__package__ = ''

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 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.  Requires len(buffer) == 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.  Requires len(buffer[offset:]) >= calcsize(fmt).  See help(struct)
  for more on format strings. """
  return ()