text:
from thrift.Thrift import TType, TMessageType, TException, TApplicationException

from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol, TProtocol
try:
  from thrift.protocol import fastbinary
except:
  fastbinary = None

class PartialKey:
  ROW = 0
  ROW_COLFAM = 1
  ROW_COLFAM_COLQUAL = 2
  ROW_COLFAM_COLQUAL_COLVIS = 3
  ROW_COLFAM_COLQUAL_COLVIS_TIME = 4
  ROW_COLFAM_COLQUAL_COLVIS_TIME_DEL = 5

  _VALUES_TO_NAMES = {
    0: "ROW",
    1: "ROW_COLFAM",
    2: "ROW_COLFAM_COLQUAL",
    3: "ROW_COLFAM_COLQUAL_COLVIS",
    4: "ROW_COLFAM_COLQUAL_COLVIS_TIME",
    5: "ROW_COLFAM_COLQUAL_COLVIS_TIME_DEL",
  }

  _NAMES_TO_VALUES = {
    "ROW": 0,
    "ROW_COLFAM": 1,
    "ROW_COLFAM_COLQUAL": 2,
    "ROW_COLFAM_COLQUAL_COLVIS": 3,
    "ROW_COLFAM_COLQUAL_COLVIS_TIME": 4,
    "ROW_COLFAM_COLQUAL_COLVIS_TIME_DEL": 5,
  }

class TablePermission:
  READ = 2
  WRITE = 3
  BULK_IMPORT = 4
  ALTER_TABLE = 5
  GRANT = 6
  DROP_TABLE = 7

  _VALUES_TO_NAMES = {
    2: "READ",
    3: "WRITE",
    4: "BULK_IMPORT",
    5: "ALTER_TABLE",
    6: "GRANT",
    7: "DROP_TABLE",
  }

  _NAMES_TO_VALUES = {
    "READ": 2,
    "WRITE": 3,
    "BULK_IMPORT": 4,
    "ALTER_TABLE": 5,
    "GRANT": 6,
    "DROP_TABLE": 7,
  }

class SystemPermission:
  GRANT = 0
  CREATE_TABLE = 1
  DROP_TABLE = 2
  ALTER_TABLE = 3
  CREATE_USER = 4
  DROP_USER = 5
  ALTER_USER = 6
  SYSTEM = 7

  _VALUES_TO_NAMES = {
    0: "GRANT",
    1: "CREATE_TABLE",
    2: "DROP_TABLE",
    3: "ALTER_TABLE",
    4: "CREATE_USER",
    5: "DROP_USER",
    6: "ALTER_USER",
    7: "SYSTEM",
  }

  _NAMES_TO_VALUES = {
    "GRANT": 0,
    "CREATE_TABLE": 1,
    "DROP_TABLE": 2,
    "ALTER_TABLE": 3,
    "CREATE_USER": 4,
    "DROP_USER": 5,
    "ALTER_USER": 6,
    "SYSTEM": 7,
  }

class ScanType:
  SINGLE = 0
  BATCH = 1

  _VALUES_TO_NAMES = {
    0: "SINGLE",
    1: "BATCH",
  }

  _NAMES_TO_VALUES = {
    "SINGLE": 0,
    "BATCH": 1,
  }

class ScanState:
  IDLE = 0
  RUNNING = 1
  QUEUED = 2

  _VALUES_TO_NAMES = {
    0: "IDLE",
    1: "RUNNING",
    2: "QUEUED",
  }

  _NAMES_TO_VALUES = {
    "IDLE": 0,
    "RUNNING": 1,
    "QUEUED": 2,
  }

class CompactionType:
  MINOR = 0
  MERGE = 1
  MAJOR = 2
  FULL = 3

  _VALUES_TO_NAMES = {
    0: "MINOR",
    1: "MERGE",
    2: "MAJOR",
    3: "FULL",
  }

  _NAMES_TO_VALUES = {
    "MINOR": 0,
    "MERGE": 1,
    "MAJOR": 2,
    "FULL": 3,
  }

class CompactionReason:
  USER = 0
  SYSTEM = 1
  CHOP = 2
  IDLE = 3
  CLOSE = 4

  _VALUES_TO_NAMES = {
    0: "USER",
    1: "SYSTEM",
    2: "CHOP",
    3: "IDLE",
    4: "CLOSE",
  }

  _NAMES_TO_VALUES = {
    "USER": 0,
    "SYSTEM": 1,
    "CHOP": 2,
    "IDLE": 3,
    "CLOSE": 4,
  }

class IteratorScope:
  MINC = 0
  MAJC = 1
  SCAN = 2

  _VALUES_TO_NAMES = {
    0: "MINC",
    1: "MAJC",
    2: "SCAN",
  }

  _NAMES_TO_VALUES = {
    "MINC": 0,
    "MAJC": 1,
    "SCAN": 2,
  }

class TimeType:
  LOGICAL = 0
  MILLIS = 1

  _VALUES_TO_NAMES = {
    0: "LOGICAL",
    1: "MILLIS",
  }

  _NAMES_TO_VALUES = {
    "LOGICAL": 0,
    "MILLIS": 1,
  }

class Key:
  """
  Attributes:
   - row
   - colFamily
   - colQualifier
   - colVisibility
   - timestamp
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'row', None, None, ), # 1
    (2, TType.STRING, 'colFamily', None, None, ), # 2
    (3, TType.STRING, 'colQualifier', None, None, ), # 3
    (4, TType.STRING, 'colVisibility', None, None, ), # 4
    (5, TType.I64, 'timestamp', None, None, ), # 5
  )

  def __init__(self, row=None, colFamily=None, colQualifier=None, colVisibility=None, timestamp=None,):
    self.row = row
    self.colFamily = colFamily
    self.colQualifier = colQualifier
    self.colVisibility = colVisibility
    self.timestamp = timestamp

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.row = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.colFamily = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.colQualifier = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.colVisibility = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I64:
          self.timestamp = iprot.readI64();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('Key')
    if self.row is not None:
      oprot.writeFieldBegin('row', TType.STRING, 1)
      oprot.writeString(self.row)
      oprot.writeFieldEnd()
    if self.colFamily is not None:
      oprot.writeFieldBegin('colFamily', TType.STRING, 2)
      oprot.writeString(self.colFamily)
      oprot.writeFieldEnd()
    if self.colQualifier is not None:
      oprot.writeFieldBegin('colQualifier', TType.STRING, 3)
      oprot.writeString(self.colQualifier)
      oprot.writeFieldEnd()
    if self.colVisibility is not None:
      oprot.writeFieldBegin('colVisibility', TType.STRING, 4)
      oprot.writeString(self.colVisibility)
      oprot.writeFieldEnd()
    if self.timestamp is not None:
      oprot.writeFieldBegin('timestamp', TType.I64, 5)
      oprot.writeI64(self.timestamp)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class ColumnUpdate:
  """
  Attributes:
   - colFamily
   - colQualifier
   - colVisibility
   - timestamp
   - value
   - deleteCell
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'colFamily', None, None, ), # 1
    (2, TType.STRING, 'colQualifier', None, None, ), # 2
    (3, TType.STRING, 'colVisibility', None, None, ), # 3
    (4, TType.I64, 'timestamp', None, None, ), # 4
    (5, TType.STRING, 'value', None, None, ), # 5
    (6, TType.BOOL, 'deleteCell', None, None, ), # 6
  )

  def __init__(self, colFamily=None, colQualifier=None, colVisibility=None, timestamp=None, value=None, deleteCell=None,):
    self.colFamily = colFamily
    self.colQualifier = colQualifier
    self.colVisibility = colVisibility
    self.timestamp = timestamp
    self.value = value
    self.deleteCell = deleteCell

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.colFamily = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.colQualifier = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.colVisibility = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I64:
          self.timestamp = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.STRING:
          self.value = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.BOOL:
          self.deleteCell = iprot.readBool();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('ColumnUpdate')
    if self.colFamily is not None:
      oprot.writeFieldBegin('colFamily', TType.STRING, 1)
      oprot.writeString(self.colFamily)
      oprot.writeFieldEnd()
    if self.colQualifier is not None:
      oprot.writeFieldBegin('colQualifier', TType.STRING, 2)
      oprot.writeString(self.colQualifier)
      oprot.writeFieldEnd()
    if self.colVisibility is not None:
      oprot.writeFieldBegin('colVisibility', TType.STRING, 3)
      oprot.writeString(self.colVisibility)
      oprot.writeFieldEnd()
    if self.timestamp is not None:
      oprot.writeFieldBegin('timestamp', TType.I64, 4)
      oprot.writeI64(self.timestamp)
      oprot.writeFieldEnd()
    if self.value is not None:
      oprot.writeFieldBegin('value', TType.STRING, 5)
      oprot.writeString(self.value)
      oprot.writeFieldEnd()
    if self.deleteCell is not None:
      oprot.writeFieldBegin('deleteCell', TType.BOOL, 6)
      oprot.writeBool(self.deleteCell)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class KeyValue:
  """
  Attributes:
   - key
   - value
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'key', (Key, Key.thrift_spec), None, ), # 1
    (2, TType.STRING, 'value', None, None, ), # 2
  )

  def __init__(self, key=None, value=None,):
    self.key = key
    self.value = value

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.key = Key()
          self.key.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.value = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('KeyValue')
    if self.key is not None:
      oprot.writeFieldBegin('key', TType.STRUCT, 1)
      self.key.write(oprot)
      oprot.writeFieldEnd()
    if self.value is not None:
      oprot.writeFieldBegin('value', TType.STRING, 2)
      oprot.writeString(self.value)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class ScanResult:
  """
  Attributes:
   - results
   - more
  """

  thrift_spec = (
    None, # 0
    (1, TType.LIST, 'results', (TType.STRUCT,(KeyValue, KeyValue.thrift_spec)), None, ), # 1
    (2, TType.BOOL, 'more', None, None, ), # 2
  )

  def __init__(self, results=None, more=None,):
    self.results = results
    self.more = more

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.LIST:
          self.results = []
          (_etype3, _size0) = iprot.readListBegin()
          for _i4 in xrange(_size0):
            _elem5 = KeyValue()
            _elem5.read(iprot)
            self.results.append(_elem5)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.BOOL:
          self.more = iprot.readBool();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('ScanResult')
    if self.results is not None:
      oprot.writeFieldBegin('results', TType.LIST, 1)
      oprot.writeListBegin(TType.STRUCT, len(self.results))
      for iter6 in self.results:
        iter6.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.more is not None:
      oprot.writeFieldBegin('more', TType.BOOL, 2)
      oprot.writeBool(self.more)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class Range:
  """
  Attributes:
   - start
   - startInclusive
   - stop
   - stopInclusive
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'start', (Key, Key.thrift_spec), None, ), # 1
    (2, TType.BOOL, 'startInclusive', None, None, ), # 2
    (3, TType.STRUCT, 'stop', (Key, Key.thrift_spec), None, ), # 3
    (4, TType.BOOL, 'stopInclusive', None, None, ), # 4
  )

  def __init__(self, start=None, startInclusive=None, stop=None, stopInclusive=None,):
    self.start = start
    self.startInclusive = startInclusive
    self.stop = stop
    self.stopInclusive = stopInclusive

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.start = Key()
          self.start.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.BOOL:
          self.startInclusive = iprot.readBool();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRUCT:
          self.stop = Key()
          self.stop.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.BOOL:
          self.stopInclusive = iprot.readBool();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('Range')
    if self.start is not None:
      oprot.writeFieldBegin('start', TType.STRUCT, 1)
      self.start.write(oprot)
      oprot.writeFieldEnd()
    if self.startInclusive is not None:
      oprot.writeFieldBegin('startInclusive', TType.BOOL, 2)
      oprot.writeBool(self.startInclusive)
      oprot.writeFieldEnd()
    if self.stop is not None:
      oprot.writeFieldBegin('stop', TType.STRUCT, 3)
      self.stop.write(oprot)
      oprot.writeFieldEnd()
    if self.stopInclusive is not None:
      oprot.writeFieldBegin('stopInclusive', TType.BOOL, 4)
      oprot.writeBool(self.stopInclusive)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class ScanColumn:
  """
  Attributes:
   - colFamily
   - colQualifier
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'colFamily', None, None, ), # 1
    (2, TType.STRING, 'colQualifier', None, None, ), # 2
  )

  def __init__(self, colFamily=None, colQualifier=None,):
    self.colFamily = colFamily
    self.colQualifier = colQualifier

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.colFamily = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.colQualifier = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('ScanColumn')
    if self.colFamily is not None:
      oprot.writeFieldBegin('colFamily', TType.STRING, 1)
      oprot.writeString(self.colFamily)
      oprot.writeFieldEnd()
    if self.colQualifier is not None:
      oprot.writeFieldBegin('colQualifier', TType.STRING, 2)
      oprot.writeString(self.colQualifier)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class IteratorSetting:
  """
  Attributes:
   - priority
   - name
   - iteratorClass
   - properties
  """

  thrift_spec = (
    None, # 0
    (1, TType.I32, 'priority', None, None, ), # 1
    (2, TType.STRING, 'name', None, None, ), # 2
    (3, TType.STRING, 'iteratorClass', None, None, ), # 3
    (4, TType.MAP, 'properties', (TType.STRING,None,TType.STRING,None), None, ), # 4
  )

  def __init__(self, priority=None, name=None, iteratorClass=None, properties=None,):
    self.priority = priority
    self.name = name
    self.iteratorClass = iteratorClass
    self.properties = properties

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I32:
          self.priority = iprot.readI32();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.name = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.iteratorClass = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.MAP:
          self.properties = {}
          (_ktype8, _vtype9, _size7 ) = iprot.readMapBegin()
          for _i11 in xrange(_size7):
            _key12 = iprot.readString();
            _val13 = iprot.readString();
            self.properties[_key12] = _val13
          iprot.readMapEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('IteratorSetting')
    if self.priority is not None:
      oprot.writeFieldBegin('priority', TType.I32, 1)
      oprot.writeI32(self.priority)
      oprot.writeFieldEnd()
    if self.name is not None:
      oprot.writeFieldBegin('name', TType.STRING, 2)
      oprot.writeString(self.name)
      oprot.writeFieldEnd()
    if self.iteratorClass is not None:
      oprot.writeFieldBegin('iteratorClass', TType.STRING, 3)
      oprot.writeString(self.iteratorClass)
      oprot.writeFieldEnd()
    if self.properties is not None:
      oprot.writeFieldBegin('properties', TType.MAP, 4)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.properties))
      for kiter14,viter15 in self.properties.items():
        oprot.writeString(kiter14)
        oprot.writeString(viter15)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class ScanOptions:
  """
  Attributes:
   - authorizations
   - range
   - columns
   - iterators
   - bufferSize
  """

  thrift_spec = (
    None, # 0
    (1, TType.SET, 'authorizations', (TType.STRING,None), None, ), # 1
    (2, TType.STRUCT, 'range', (Range, Range.thrift_spec), None, ), # 2
    (3, TType.LIST, 'columns', (TType.STRUCT,(ScanColumn, ScanColumn.thrift_spec)), None, ), # 3
    (4, TType.LIST, 'iterators', (TType.STRUCT,(IteratorSetting, IteratorSetting.thrift_spec)), None, ), # 4
    (5, TType.I32, 'bufferSize', None, None, ), # 5
  )

  def __init__(self, authorizations=None, range=None, columns=None, iterators=None, bufferSize=None,):
    self.authorizations = authorizations
    self.range = range
    self.columns = columns
    self.iterators = iterators
    self.bufferSize = bufferSize

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.SET:
          self.authorizations = set()
          (_etype19, _size16) = iprot.readSetBegin()
          for _i20 in xrange(_size16):
            _elem21 = iprot.readString();
            self.authorizations.add(_elem21)
          iprot.readSetEnd()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRUCT:
          self.range = Range()
          self.range.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.LIST:
          self.columns = []
          (_etype25, _size22) = iprot.readListBegin()
          for _i26 in xrange(_size22):
            _elem27 = ScanColumn()
            _elem27.read(iprot)
            self.columns.append(_elem27)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.LIST:
          self.iterators = []
          (_etype31, _size28) = iprot.readListBegin()
          for _i32 in xrange(_size28):
            _elem33 = IteratorSetting()
            _elem33.read(iprot)
            self.iterators.append(_elem33)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.bufferSize = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('ScanOptions')
    if self.authorizations is not None:
      oprot.writeFieldBegin('authorizations', TType.SET, 1)
      oprot.writeSetBegin(TType.STRING, len(self.authorizations))
      for iter34 in self.authorizations:
        oprot.writeString(iter34)
      oprot.writeSetEnd()
      oprot.writeFieldEnd()
    if self.range is not None:
      oprot.writeFieldBegin('range', TType.STRUCT, 2)
      self.range.write(oprot)
      oprot.writeFieldEnd()
    if self.columns is not None:
      oprot.writeFieldBegin('columns', TType.LIST, 3)
      oprot.writeListBegin(TType.STRUCT, len(self.columns))
      for iter35 in self.columns:
        iter35.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.iterators is not None:
      oprot.writeFieldBegin('iterators', TType.LIST, 4)
      oprot.writeListBegin(TType.STRUCT, len(self.iterators))
      for iter36 in self.iterators:
        iter36.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.bufferSize is not None:
      oprot.writeFieldBegin('bufferSize', TType.I32, 5)
      oprot.writeI32(self.bufferSize)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class BatchScanOptions:
  """
  Attributes:
   - authorizations
   - ranges
   - columns
   - iterators
   - threads
  """

  thrift_spec = (
    None, # 0
    (1, TType.SET, 'authorizations', (TType.STRING,None), None, ), # 1
    (2, TType.LIST, 'ranges', (TType.STRUCT,(Range, Range.thrift_spec)), None, ), # 2
    (3, TType.LIST, 'columns', (TType.STRUCT,(ScanColumn, ScanColumn.thrift_spec)), None, ), # 3
    (4, TType.LIST, 'iterators', (TType.STRUCT,(IteratorSetting, IteratorSetting.thrift_spec)), None, ), # 4
    (5, TType.I32, 'threads', None, None, ), # 5
  )

  def __init__(self, authorizations=None, ranges=None, columns=None, iterators=None, threads=None,):
    self.authorizations = authorizations
    self.ranges = ranges
    self.columns = columns
    self.iterators = iterators
    self.threads = threads

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.SET:
          self.authorizations = set()
          (_etype40, _size37) = iprot.readSetBegin()
          for _i41 in xrange(_size37):
            _elem42 = iprot.readString();
            self.authorizations.add(_elem42)
          iprot.readSetEnd()
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.LIST:
          self.ranges = []
          (_etype46, _size43) = iprot.readListBegin()
          for _i47 in xrange(_size43):
            _elem48 = Range()
            _elem48.read(iprot)
            self.ranges.append(_elem48)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.LIST:
          self.columns = []
          (_etype52, _size49) = iprot.readListBegin()
          for _i53 in xrange(_size49):
            _elem54 = ScanColumn()
            _elem54.read(iprot)
            self.columns.append(_elem54)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.LIST:
          self.iterators = []
          (_etype58, _size55) = iprot.readListBegin()
          for _i59 in xrange(_size55):
            _elem60 = IteratorSetting()
            _elem60.read(iprot)
            self.iterators.append(_elem60)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.threads = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('BatchScanOptions')
    if self.authorizations is not None:
      oprot.writeFieldBegin('authorizations', TType.SET, 1)
      oprot.writeSetBegin(TType.STRING, len(self.authorizations))
      for iter61 in self.authorizations:
        oprot.writeString(iter61)
      oprot.writeSetEnd()
      oprot.writeFieldEnd()
    if self.ranges is not None:
      oprot.writeFieldBegin('ranges', TType.LIST, 2)
      oprot.writeListBegin(TType.STRUCT, len(self.ranges))
      for iter62 in self.ranges:
        iter62.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.columns is not None:
      oprot.writeFieldBegin('columns', TType.LIST, 3)
      oprot.writeListBegin(TType.STRUCT, len(self.columns))
      for iter63 in self.columns:
        iter63.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.iterators is not None:
      oprot.writeFieldBegin('iterators', TType.LIST, 4)
      oprot.writeListBegin(TType.STRUCT, len(self.iterators))
      for iter64 in self.iterators:
        iter64.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.threads is not None:
      oprot.writeFieldBegin('threads', TType.I32, 5)
      oprot.writeI32(self.threads)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class KeyValueAndPeek:
  """
  Attributes:
   - keyValue
   - hasNext
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'keyValue', (KeyValue, KeyValue.thrift_spec), None, ), # 1
    (2, TType.BOOL, 'hasNext', None, None, ), # 2
  )

  def __init__(self, keyValue=None, hasNext=None,):
    self.keyValue = keyValue
    self.hasNext = hasNext

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.keyValue = KeyValue()
          self.keyValue.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.BOOL:
          self.hasNext = iprot.readBool();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('KeyValueAndPeek')
    if self.keyValue is not None:
      oprot.writeFieldBegin('keyValue', TType.STRUCT, 1)
      self.keyValue.write(oprot)
      oprot.writeFieldEnd()
    if self.hasNext is not None:
      oprot.writeFieldBegin('hasNext', TType.BOOL, 2)
      oprot.writeBool(self.hasNext)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class KeyExtent:
  """
  Attributes:
   - tableId
   - endRow
   - prevEndRow
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'tableId', None, None, ), # 1
    (2, TType.STRING, 'endRow', None, None, ), # 2
    (3, TType.STRING, 'prevEndRow', None, None, ), # 3
  )

  def __init__(self, tableId=None, endRow=None, prevEndRow=None,):
    self.tableId = tableId
    self.endRow = endRow
    self.prevEndRow = prevEndRow

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.tableId = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.endRow = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.prevEndRow = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('KeyExtent')
    if self.tableId is not None:
      oprot.writeFieldBegin('tableId', TType.STRING, 1)
      oprot.writeString(self.tableId)
      oprot.writeFieldEnd()
    if self.endRow is not None:
      oprot.writeFieldBegin('endRow', TType.STRING, 2)
      oprot.writeString(self.endRow)
      oprot.writeFieldEnd()
    if self.prevEndRow is not None:
      oprot.writeFieldBegin('prevEndRow', TType.STRING, 3)
      oprot.writeString(self.prevEndRow)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class Column:
  """
  Attributes:
   - colFamily
   - colQualifier
   - colVisibility
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'colFamily', None, None, ), # 1
    (2, TType.STRING, 'colQualifier', None, None, ), # 2
    (3, TType.STRING, 'colVisibility', None, None, ), # 3
  )

  def __init__(self, colFamily=None, colQualifier=None, colVisibility=None,):
    self.colFamily = colFamily
    self.colQualifier = colQualifier
    self.colVisibility = colVisibility

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.colFamily = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.colQualifier = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.colVisibility = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('Column')
    if self.colFamily is not None:
      oprot.writeFieldBegin('colFamily', TType.STRING, 1)
      oprot.writeString(self.colFamily)
      oprot.writeFieldEnd()
    if self.colQualifier is not None:
      oprot.writeFieldBegin('colQualifier', TType.STRING, 2)
      oprot.writeString(self.colQualifier)
      oprot.writeFieldEnd()
    if self.colVisibility is not None:
      oprot.writeFieldBegin('colVisibility', TType.STRING, 3)
      oprot.writeString(self.colVisibility)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class ActiveScan:
  """
  Attributes:
   - client
   - user
   - table
   - age
   - idleTime
   - type
   - state
   - extent
   - columns
   - iterators
   - authorizations
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'client', None, None, ), # 1
    (2, TType.STRING, 'user', None, None, ), # 2
    (3, TType.STRING, 'table', None, None, ), # 3
    (4, TType.I64, 'age', None, None, ), # 4
    (5, TType.I64, 'idleTime', None, None, ), # 5
    (6, TType.I32, 'type', None, None, ), # 6
    (7, TType.I32, 'state', None, None, ), # 7
    (8, TType.STRUCT, 'extent', (KeyExtent, KeyExtent.thrift_spec), None, ), # 8
    (9, TType.LIST, 'columns', (TType.STRUCT,(Column, Column.thrift_spec)), None, ), # 9
    (10, TType.LIST, 'iterators', (TType.STRUCT,(IteratorSetting, IteratorSetting.thrift_spec)), None, ), # 10
    (11, TType.LIST, 'authorizations', (TType.STRING,None), None, ), # 11
  )

  def __init__(self, client=None, user=None, table=None, age=None, idleTime=None, type=None, state=None, extent=None, columns=None, iterators=None, authorizations=None,):
    self.client = client
    self.user = user
    self.table = table
    self.age = age
    self.idleTime = idleTime
    self.type = type
    self.state = state
    self.extent = extent
    self.columns = columns
    self.iterators = iterators
    self.authorizations = authorizations

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.client = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.STRING:
          self.user = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.STRING:
          self.table = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I64:
          self.age = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I64:
          self.idleTime = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.I32:
          self.type = iprot.readI32();
        else:
          iprot.skip(ftype)
      elif fid == 7:
        if ftype == TType.I32:
          self.state = iprot.readI32();
        else:
          iprot.skip(ftype)
      elif fid == 8:
        if ftype == TType.STRUCT:
          self.extent = KeyExtent()
          self.extent.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 9:
        if ftype == TType.LIST:
          self.columns = []
          (_etype68, _size65) = iprot.readListBegin()
          for _i69 in xrange(_size65):
            _elem70 = Column()
            _elem70.read(iprot)
            self.columns.append(_elem70)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 10:
        if ftype == TType.LIST:
          self.iterators = []
          (_etype74, _size71) = iprot.readListBegin()
          for _i75 in xrange(_size71):
            _elem76 = IteratorSetting()
            _elem76.read(iprot)
            self.iterators.append(_elem76)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 11:
        if ftype == TType.LIST:
          self.authorizations = []
          (_etype80, _size77) = iprot.readListBegin()
          for _i81 in xrange(_size77):
            _elem82 = iprot.readString();
            self.authorizations.append(_elem82)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('ActiveScan')
    if self.client is not None:
      oprot.writeFieldBegin('client', TType.STRING, 1)
      oprot.writeString(self.client)
      oprot.writeFieldEnd()
    if self.user is not None:
      oprot.writeFieldBegin('user', TType.STRING, 2)
      oprot.writeString(self.user)
      oprot.writeFieldEnd()
    if self.table is not None:
      oprot.writeFieldBegin('table', TType.STRING, 3)
      oprot.writeString(self.table)
      oprot.writeFieldEnd()
    if self.age is not None:
      oprot.writeFieldBegin('age', TType.I64, 4)
      oprot.writeI64(self.age)
      oprot.writeFieldEnd()
    if self.idleTime is not None:
      oprot.writeFieldBegin('idleTime', TType.I64, 5)
      oprot.writeI64(self.idleTime)
      oprot.writeFieldEnd()
    if self.type is not None:
      oprot.writeFieldBegin('type', TType.I32, 6)
      oprot.writeI32(self.type)
      oprot.writeFieldEnd()
    if self.state is not None:
      oprot.writeFieldBegin('state', TType.I32, 7)
      oprot.writeI32(self.state)
      oprot.writeFieldEnd()
    if self.extent is not None:
      oprot.writeFieldBegin('extent', TType.STRUCT, 8)
      self.extent.write(oprot)
      oprot.writeFieldEnd()
    if self.columns is not None:
      oprot.writeFieldBegin('columns', TType.LIST, 9)
      oprot.writeListBegin(TType.STRUCT, len(self.columns))
      for iter83 in self.columns:
        iter83.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.iterators is not None:
      oprot.writeFieldBegin('iterators', TType.LIST, 10)
      oprot.writeListBegin(TType.STRUCT, len(self.iterators))
      for iter84 in self.iterators:
        iter84.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.authorizations is not None:
      oprot.writeFieldBegin('authorizations', TType.LIST, 11)
      oprot.writeListBegin(TType.STRING, len(self.authorizations))
      for iter85 in self.authorizations:
        oprot.writeString(iter85)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class ActiveCompaction:
  """
  Attributes:
   - extent
   - age
   - inputFiles
   - outputFile
   - type
   - reason
   - localityGroup
   - entriesRead
   - entriesWritten
   - iterators
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRUCT, 'extent', (KeyExtent, KeyExtent.thrift_spec), None, ), # 1
    (2, TType.I64, 'age', None, None, ), # 2
    (3, TType.LIST, 'inputFiles', (TType.STRING,None), None, ), # 3
    (4, TType.STRING, 'outputFile', None, None, ), # 4
    (5, TType.I32, 'type', None, None, ), # 5
    (6, TType.I32, 'reason', None, None, ), # 6
    (7, TType.STRING, 'localityGroup', None, None, ), # 7
    (8, TType.I64, 'entriesRead', None, None, ), # 8
    (9, TType.I64, 'entriesWritten', None, None, ), # 9
    (10, TType.LIST, 'iterators', (TType.STRUCT,(IteratorSetting, IteratorSetting.thrift_spec)), None, ), # 10
  )

  def __init__(self, extent=None, age=None, inputFiles=None, outputFile=None, type=None, reason=None, localityGroup=None, entriesRead=None, entriesWritten=None, iterators=None,):
    self.extent = extent
    self.age = age
    self.inputFiles = inputFiles
    self.outputFile = outputFile
    self.type = type
    self.reason = reason
    self.localityGroup = localityGroup
    self.entriesRead = entriesRead
    self.entriesWritten = entriesWritten
    self.iterators = iterators

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRUCT:
          self.extent = KeyExtent()
          self.extent.read(iprot)
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.age = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.LIST:
          self.inputFiles = []
          (_etype89, _size86) = iprot.readListBegin()
          for _i90 in xrange(_size86):
            _elem91 = iprot.readString();
            self.inputFiles.append(_elem91)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.STRING:
          self.outputFile = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 5:
        if ftype == TType.I32:
          self.type = iprot.readI32();
        else:
          iprot.skip(ftype)
      elif fid == 6:
        if ftype == TType.I32:
          self.reason = iprot.readI32();
        else:
          iprot.skip(ftype)
      elif fid == 7:
        if ftype == TType.STRING:
          self.localityGroup = iprot.readString();
        else:
          iprot.skip(ftype)
      elif fid == 8:
        if ftype == TType.I64:
          self.entriesRead = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 9:
        if ftype == TType.I64:
          self.entriesWritten = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 10:
        if ftype == TType.LIST:
          self.iterators = []
          (_etype95, _size92) = iprot.readListBegin()
          for _i96 in xrange(_size92):
            _elem97 = IteratorSetting()
            _elem97.read(iprot)
            self.iterators.append(_elem97)
          iprot.readListEnd()
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('ActiveCompaction')
    if self.extent is not None:
      oprot.writeFieldBegin('extent', TType.STRUCT, 1)
      self.extent.write(oprot)
      oprot.writeFieldEnd()
    if self.age is not None:
      oprot.writeFieldBegin('age', TType.I64, 2)
      oprot.writeI64(self.age)
      oprot.writeFieldEnd()
    if self.inputFiles is not None:
      oprot.writeFieldBegin('inputFiles', TType.LIST, 3)
      oprot.writeListBegin(TType.STRING, len(self.inputFiles))
      for iter98 in self.inputFiles:
        oprot.writeString(iter98)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.outputFile is not None:
      oprot.writeFieldBegin('outputFile', TType.STRING, 4)
      oprot.writeString(self.outputFile)
      oprot.writeFieldEnd()
    if self.type is not None:
      oprot.writeFieldBegin('type', TType.I32, 5)
      oprot.writeI32(self.type)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.I32, 6)
      oprot.writeI32(self.reason)
      oprot.writeFieldEnd()
    if self.localityGroup is not None:
      oprot.writeFieldBegin('localityGroup', TType.STRING, 7)
      oprot.writeString(self.localityGroup)
      oprot.writeFieldEnd()
    if self.entriesRead is not None:
      oprot.writeFieldBegin('entriesRead', TType.I64, 8)
      oprot.writeI64(self.entriesRead)
      oprot.writeFieldEnd()
    if self.entriesWritten is not None:
      oprot.writeFieldBegin('entriesWritten', TType.I64, 9)
      oprot.writeI64(self.entriesWritten)
      oprot.writeFieldEnd()
    if self.iterators is not None:
      oprot.writeFieldBegin('iterators', TType.LIST, 10)
      oprot.writeListBegin(TType.STRUCT, len(self.iterators))
      for iter99 in self.iterators:
        iter99.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class WriterOptions:
  """
  Attributes:
   - maxMemory
   - latencyMs
   - timeoutMs
   - threads
  """

  thrift_spec = (
    None, # 0
    (1, TType.I64, 'maxMemory', None, None, ), # 1
    (2, TType.I64, 'latencyMs', None, None, ), # 2
    (3, TType.I64, 'timeoutMs', None, None, ), # 3
    (4, TType.I32, 'threads', None, None, ), # 4
  )

  def __init__(self, maxMemory=None, latencyMs=None, timeoutMs=None, threads=None,):
    self.maxMemory = maxMemory
    self.latencyMs = latencyMs
    self.timeoutMs = timeoutMs
    self.threads = threads

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.I64:
          self.maxMemory = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 2:
        if ftype == TType.I64:
          self.latencyMs = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 3:
        if ftype == TType.I64:
          self.timeoutMs = iprot.readI64();
        else:
          iprot.skip(ftype)
      elif fid == 4:
        if ftype == TType.I32:
          self.threads = iprot.readI32();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('WriterOptions')
    if self.maxMemory is not None:
      oprot.writeFieldBegin('maxMemory', TType.I64, 1)
      oprot.writeI64(self.maxMemory)
      oprot.writeFieldEnd()
    if self.latencyMs is not None:
      oprot.writeFieldBegin('latencyMs', TType.I64, 2)
      oprot.writeI64(self.latencyMs)
      oprot.writeFieldEnd()
    if self.timeoutMs is not None:
      oprot.writeFieldBegin('timeoutMs', TType.I64, 3)
      oprot.writeI64(self.timeoutMs)
      oprot.writeFieldEnd()
    if self.threads is not None:
      oprot.writeFieldBegin('threads', TType.I32, 4)
      oprot.writeI32(self.threads)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class UnknownScanner(TException):
  """
  Attributes:
   - msg
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'msg', None, None, ), # 1
  )

  def __init__(self, msg=None,):
    self.msg = msg

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.msg = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('UnknownScanner')
    if self.msg is not None:
      oprot.writeFieldBegin('msg', TType.STRING, 1)
      oprot.writeString(self.msg)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __str__(self):
    return repr(self)

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class UnknownWriter(TException):
  """
  Attributes:
   - msg
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'msg', None, None, ), # 1
  )

  def __init__(self, msg=None,):
    self.msg = msg

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.msg = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('UnknownWriter')
    if self.msg is not None:
      oprot.writeFieldBegin('msg', TType.STRING, 1)
      oprot.writeString(self.msg)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __str__(self):
    return repr(self)

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class NoMoreEntriesException(TException):
  """
  Attributes:
   - msg
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'msg', None, None, ), # 1
  )

  def __init__(self, msg=None,):
    self.msg = msg

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.msg = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('NoMoreEntriesException')
    if self.msg is not None:
      oprot.writeFieldBegin('msg', TType.STRING, 1)
      oprot.writeString(self.msg)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __str__(self):
    return repr(self)

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class AccumuloException(TException):
  """
  Attributes:
   - msg
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'msg', None, None, ), # 1
  )

  def __init__(self, msg=None,):
    self.msg = msg

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.msg = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('AccumuloException')
    if self.msg is not None:
      oprot.writeFieldBegin('msg', TType.STRING, 1)
      oprot.writeString(self.msg)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __str__(self):
    return repr(self)

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class AccumuloSecurityException(TException):
  """
  Attributes:
   - msg
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'msg', None, None, ), # 1
  )

  def __init__(self, msg=None,):
    self.msg = msg

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.msg = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('AccumuloSecurityException')
    if self.msg is not None:
      oprot.writeFieldBegin('msg', TType.STRING, 1)
      oprot.writeString(self.msg)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __str__(self):
    return repr(self)

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class TableNotFoundException(TException):
  """
  Attributes:
   - msg
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'msg', None, None, ), # 1
  )

  def __init__(self, msg=None,):
    self.msg = msg

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.msg = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('TableNotFoundException')
    if self.msg is not None:
      oprot.writeFieldBegin('msg', TType.STRING, 1)
      oprot.writeString(self.msg)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __str__(self):
    return repr(self)

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)

class TableExistsException(TException):
  """
  Attributes:
   - msg
  """

  thrift_spec = (
    None, # 0
    (1, TType.STRING, 'msg', None, None, ), # 1
  )

  def __init__(self, msg=None,):
    self.msg = msg

  def read(self, iprot):
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
      return
    iprot.readStructBegin()
    while True:
      (fname, ftype, fid) = iprot.readFieldBegin()
      if ftype == TType.STOP:
        break
      if fid == 1:
        if ftype == TType.STRING:
          self.msg = iprot.readString();
        else:
          iprot.skip(ftype)
      else:
        iprot.skip(ftype)
      iprot.readFieldEnd()
    iprot.readStructEnd()

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('TableExistsException')
    if self.msg is not None:
      oprot.writeFieldBegin('msg', TType.STRING, 1)
      oprot.writeString(self.msg)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()

  def validate(self):
    return

  def __str__(self):
    return repr(self)

  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))

  def __eq__(self, other):
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__

  def __ne__(self, other):
    return not (self == other)


The ISO 9000 series family of standards addresses variousstructures of quality management and contains some of the industries well acknowledged standards. The standards provide guidance and tools for all sectors in any industry from production to supply or service. Ensuring that their products and services consistently meet customer's requirements and that quality is consistently improved.
ISO 9001 is a standard that sets out the requirements for a quality management system. It helps businesses and organizations to be more efficient and improve profitability as well the customer satisfaction ratio.
Quality management system is a system based approach of the organisation to manage its processes to well define and meet the requirements of its customers, Risk and stakeholders touched by its work.
ISO 9001 is centered on the concept of internal drive towards continual improvement. Its focus is to meet the objectives of "quality" & "meeting customer needs" from the organizations perspective by defining it has a process approach.
ISO 9001 is designed to suite organizations of all types, sizes and sectors.In fact, one of the key improvements of the newly revised ISO 9001:2015 was to make it more applicable and accessible to all types of enterprises. Smaller companies that do not have staff dedicated to quality can still enjoy the benefits of implementing the standard.
How it will benefit my business or organization?
Adherence to a quality management system will improve organisation performance.
The Organisation undertaking overall Assessment of context in operations to define the affected parties and the scope of operational objectives, will enhance the team capabilities with the diversification and increase in new business opportunity.
Customers first, is the constant striving factor for organization, embracing market trend and to exceed customer expectation driving to delight. Which, in turn leads to more satisfied clients, increased repeat orders and increased business for the organization.
Process inside any organisation needs to be aligned with the work force practice to deliver effective results, the well standardized process will enable work force to align and understand the objectives and drive to increase productivity, delivering efficiency and bringing down the operational cost.
Meeting the national and international statutory and regulatory requirements. Enabling to Expand operations into new locations. Identify and address the risks associated with the operation and brand development for organization.
ISO Certification from Traibcert ensure to the client that products and services are safe, reliable and of superior quality. For business, they are strategic tools that reduce costs by minimizing waste and errors and increasing productivity. ISO Certification from Traibcert help companies assure clients on quality in the new markets, making it easy for having a levelled playing field and facilitate free and fair global trade.
Should I be certified to ISO 9001?
TRAIB CERT Audit assures the clients / stakeholders that you have implemented the standard in a professional manner and the products/ services rendered will meet their expectation, It also increases the trust on the prospective clients to start new ventures with your organisation.
Traibcert certification may be a requirement. For example, some governments or public bodies may only contact suppliers that have been certified to ISO 9001 by reputed organisation like traibcert.
How do I get started with ISO 9001:2015?
1 – Define your objectives. Why do you want to implement the standard?
Tip 2 – Ensure senior management is on board. It is crucial that everyone is supportive of the initiative and its objectives.
Tip 3 – Identify your organization's key processes for meeting your objectives and customers' needs. Within each of these processes, ensure you understand your customers' requirements and can guarantee that these are met.
you need further guidance on implementation and certification immediately visit our website: www.traibcert.org.uk and send us a detailed mail so we will help you to overcome the hurdles with our team of experts and carefully designed training programs.
TRAIBCERT's experienced and highly-skilled auditors would listen to you and perform an initial assessment of the quality management system that is implemented. The audit focuses mainly on the areas of the system that needs further improvements inline with the ISO requirements, in order to achieve the goal of implementing the system. Once identifying and eradicating potential vulnerabilities in the management system, the actual audit in relation to the certification begins.
This phase is comprised of a stage 1 and stage 2 audit consists of detailed review where, TRAIBCERT's auditors with expertise and vast knowledge on the industry sectors,assess your documentation and practical application of your qulaity management system to fulfill the certification requirements. We strive to reveal observations that can add value through reduced costs, increased efficiency, and decreased time to market.
Once our highly competent & qualified auditors who are experts in the sector, identifies that your QMS satisfies the requirements of ISO 9001-2015, we at TRAIBCERT a leading accredited certification body with expertise in Quality management system will Issue the ISO 9001-2015 certificate.
Annual surveillance of the ongoing optimization of your processes and quality management system would be carried out to ensure adherence of the system with that of the ISO standards.
You can transfer the certificate at any stage to us during surveillance/ recertification.
So what I need to do.
Write to us on info@traibcert.org.uk and Attach the scanned copy to the mail and send.
We will review the details and advise on the further steps within two days.
There are many other standards in the ISO 9000 series that can help you reap the full benefits of a quality management system and put customer satisfaction at the heart of your business.
9000 contains detailed explanations of the seven quality management principles with tips on how to ensure these are reflected in the way you work. It also contains many of the terms and definitions used in ISO 9001.
ISO 9004 provides guidance on how to achieve sustained success with your quality management system.
ISO 19011 gives guidance for performing both internal and external audits to ISO 9001. This will help ensure your quality management system delivers on promise and will prepare you for an external audit, should you decide to seek third-party certification.


Very quickly 2 weeks, the color is exactly the same as in the photo, there is no reaper on the pope, the length is excellent. Super thanks! High waist, when driving do not slip.
quite big(long and wide), the material is strong, I wish I could buy xs.
Love the push up effect on these. The medium is true to size, I wear EUR 38 size pants. The shipping was fast and it came within 2 weeks.


We provide duct cleaning services to residential and commercial customers. We contain all the dirt, dust, and debris from the ductwork into our vacuums.
At Reifel Heating and Cooling, we can handle all of your indoor air quality concerns to make you breathe easy again. We carry a full line of parts allowing us to repair and service all makes and models.
Clean air ducts increase the efficiency of your heating and cooling systems, which should lower utility bills and increase money saved. Having clean air lets you breathe easier and wake up feeling better.
You may have a wet, soggy or flooded crawlspace or basement that may have allowed growth of mildew and mold, which may have further penetrated in your HVAC duct system.
Cleaning your ducts will reduce allergy symptoms and improve the indoor air quality of the home. Duct systems also provide the perfect environment for dust mites, fungi, bacteria, molds and other allergens to breed. For instance, dust mites like to breed in temperatures that fall between 72 and 86 degrees.
Up to 40 pounds of dust can accumulate in a six-room house annually. Air duct cleaning will remove the dust that has accumulated over the yeas so that it does not keep circulating back into your home.
If you have young kids or are welcoming a new baby to the home, provide the freshest air possible to them by making sure your HVAC system and ducts are serviced and cleaned regularly.
You have pets in your home. Pet fur has the tendency to get caught in the air vents, which provide fungus, germs, molds, and allergens the right place to live on.
The best services at a price you can afford.
If you're building your new dream home, we will provide for you quality equipment, professional installation and a price that will let you sleep at night. Give us a call!
While we believe in system maintenance, we don't believe in finding something wrong every time we come out.
There really isn't a good time for your equipment to fail. But in the heat of the summer or the cold of the winter, you need to be able to rely on your HVAC provider. Reifel Heating & Cooling are the ones to call.


text:
Cubs @ White Sox Series Review: Cubs Settle for Another Split against Southsiders
Ryan ThomureJuly 8, 2019
"The Chicago Cubs have won the Crosstown Cup! The Cubs come pouring out of the dugout, jumping up and down like a bunch of delirious 10-year olds…the Cubs have done it!"
Wait, did you not hear that on your broadcast? There must have been something wrong with mine. Maybe the champagne I sprayed all over my radio caused some kind of issue, but those things are going to happen when the Crosstown Cup is on the line.
Sure, the Cubs only won it on the weird technicality of a split resulting in the trophy remaining with the team that most recently won it, but they won it all the same. Surely all of the players are just as thrilled as you and I are. Just look at this shot of Javier Báez holding the cup last year.
To the uninformed observer, it may look like he has no idea what the purpose of the trophy is or why he's been asked to hold it. But, friend, you and I know better: He was simply overwhelmed with emotion.
As far as how this series played out, we got a little bit of everything that has defined this year's Cubs in a tidy two-game package. Saturday featured a win defined by high-octane offense, a solid Jon Lester pitching performance, and the new-look Cubs bullpen doing what it had to do to secure the win. Sunday's follow-up featured the doppelgänger Cubs, the ones that couldn't quite get the hit they needed with a runner in scoring position and weren't able to muster a real threat late in the game.
While Sunday's result surely caused some consternation among fans, I think it's also fair to acknowledge that they got pretty unlucky against Sox starter Iván Nova. The Cubs were smoking line drives early in the game that just didn't get where they needed to. It was a loss, but it felt like a healthier loss than many others that have defined their struggles.
And despite those recent struggles, the best news of all is that the Cubs enter the All-Star break in first place.
Cubs 6, White Sox 3 (box score)
White Sox 3, Cubs 1 (box score)
Saturday's win was defined by the Cubs five run outburst in the fifth inning. It was the kind of "keep the line moving" effort that they've lacked at times of late.
In case you weren't keeping track, that was a Kyle Schwarber double, a Javy double, and an Anthony Rizzo single to plate the Cubs' runs. While you would've liked to see the team add more (they ended up leaving the bases loaded with no outs), a five-run inning is nothing to sneeze at.
Lester's start was the other defining element of the game. The veteran lefty gave up only a single earned run over 6.1 innings pitched. He has suddenly turned things around quite a bit over his last few starts, which we'll dig into a bit more later.
Sunday's loss wasn't defined by the highlights that were made, but those that weren't. The Cubs failed to score on back-to-back leadoff doubles by Albert Almora Jr. and Rizzo in the 3rd and 4th innings. They smoked balls all over the field in the first few innings of the game but the sequencing and luck weren't there.
Because of that, they were only able to tally a single run on Robel Garcia's second career home run in the 7th inning.
Who's hot
Javy is clearly on the rebound after a period of struggle. He smacked two doubles in the series opener and is batting .333/.333/.633 over his last seven. Sure, you might want a walk or two in there, but that's not Javy's game, is it?
Lester is similarly looking better after a rough patch. Over his last three starts, he has surrendered only four earned runs over 18 innings pitched. He must have had the famous Beijing Duck Dinner at Uptown's Sun Wah Barbecue recently, because he's got some serious big duck energy going on.
Who's not
It is not my intent to pick on Craig Kimbrel by placing him here for the second review in a row, but you'd really like to see him record a clean save soon. The new Cubs closer made things more difficult than they needed to be on Saturday, allowing the tying run to reach base via a walk and a hit by pitch. The good news? He struck out three and showed his best velocity as a Cub.
We saw the Cubs at their best and we also saw them repeat so many of the frustrating patterns that have led to their struggles of the last month and a half over these two games. While they weren't able to win their first series in far too long, they managed to get the win they needed to ultimately go into the All-Star break in first place.
You may wish the Cubs had been able to capitalize on a favorable schedule, that they had taken advantage of the rest of the division scuffling, or that they had simply been less maddening over their last month and and a half of play. I certainly wish that they had done all of those things.
With all of that said, I'm glad that I don't have to wish that the Cubs were in first place. Fans of all of the other NL Central teams have to do just that.

redpajama_set_name: RedPajamaCommonCrawl


text:
Rosa Johan Uddoh
Rosa-Johan Uddoh (b.1993, Croydon) is an interdisciplinary artist working towards radical self-love. She is inspired by Black feminist practice and writing.
Through performance, writing and multi-media installation, she explores places, objects and celebrities in British popular culture, and their effects on self-formation. Collaboration is key to Rosa's work, often working together with children, activists and other artists to explore themes that impact our communities and share knowledge.
Rosa is a lecturer in Performance at Central Saint Martins. She has been shortlisted for the Jarman Award 2022 for her film making practice. She was a finalist for Arts Foundation Futures Awards 2021. Rosa was the Liverpool Biennial and John Moores Univerity Fellow 2018-2019 and was the Stuart Hall Library Resident for 2020. She was a Sarabande: Lee Alexander Mc Queen Scholar.
Rosa's solo presentations include: 'Practice Makes Perfect', Focal Point Gallery (Southend-on-sea, 2021), '"She is still alive!"', Destiny's (Oslo, 2020), 'Studies for Impartiality', Jupiter Woods and 'Sphinx at the Crystal Palace', Black Tower Projects (both London, 2019). Group shows include: 'Brand New Heavies', Pioneer Works (New York, 2021), 'Learning by Doing', 68 Institute (Copenhagen, 2019), New Contemporaries (London & Liverpool 2018) and 'Black Blossoms', The Royal Standard (Liverpool, 2017). Recently she has screened work at East London Cable's 'TV Dinners E03' at Tate Modern, 2019.
Rosa's first book 'Practice Makes Perfect', co-published with Book Works and Focal Point Gallery was published in July 2022.
Masterclass with Charles Gaines


text:
<project
   xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <parent><groupId>mockit</groupId><artifactId>samples</artifactId><version>1</version></parent>
   <artifactId>easymock</artifactId>
   <name>EasyMock Comparison Sample</name>

   <dependencies>
      <dependency>
         <groupId>com.googlecode.jmockit</groupId><artifactId>jmockit</artifactId><version>${jmockit.version}</version>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>junit</groupId><artifactId>junit</artifactId><version>${junit.version}</version>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>org.easymock</groupId><artifactId>easymock</artifactId><version>3.2</version>
         <scope>test</scope>
      </dependency>
   </dependencies>
</project>

redpajama_set_name: RedPajamaGithub


This series of lunch-time mindfulness practice sessions will offer opportunities to practice and learn with a group or to re-connect with your mindfulness practice. You can opt to join us for one or more of the sessions.
Our main focus will 'sitting' for different mindfulness practices, being aware of our experiences. There will be an opportunity for discussion of your mindfulness experiences after the practices but our main aim will be to practice mindfulness approaches and different anchors of our attention with quietness. The sessions will be based on the non-secular approaches of the Mindfulness-based stress reduction (MBSR) and cognitive behavioural (MBCT) courses.
Who will be leading the practices?
The sessions will be led by Dr Jo Bramham, Professional Development (Teacher Development Level 1 in Mindfulness-based teaching).
This session is for staff with an experience of mindfulness practice e.g. through the University's 8-week mindfulness programme.
You may wish to bring a mat, cushion /meditation bench or blanket if that is what you are used to. Sorry, we are unable to provide refreshments at this session so you may wish to eat your lunch before you arrive.
Can I just turn up if I can find the time on the day of the practice?
It helps if you can book in advance so that we can monitor the demand for these sessions. Hopefully, it will help you to find time to practice by having it in the diary!
Dates for future lunchtime sessions from 12:30 - 13:30 hrs in Meeting Room 1, Lakeside Arts Centre are listed below.


The exemplar-based approach to categorisation has recently become perhaps the most influential one within cognitive psychology. Still, it seems to be largely disregarded in other fields of cognitive science, such as philosophy or linguistics. In this article, I describe exemplar models against the background of classical and prototype theories, and try to explain the difficulties concerning wider application of exemplar models to categorisation studies in lexical semantics. I begin with a few general remarks on the nature of categorisation and the necessity to understand this notion in a broader theoretical frame. In a brief discussion of models of categorisation, I focus on the distinction between classical and 'similarity' models (the latter meaning prototype and exemplar models) and its far reaching implications, as well as explain the distinction between categorisation by prototypes and exemplars. By way of conclusion, I venture a suggestion that in thinking about categorisation in humans, different views should be treated as complementary rather than contradictory accounts.


The FAA Reauthorization Act has as many proponents as it has critics. One of the major concerns that various parties have expressed is the government's virtual carte blanche to surveil, seize, or even shoot a drone out of the sky without first obtaining a warrant.
"But critics say the new authority that gives the government the right to "disrupt," "exercise control," or "seize or otherwise confiscate" drones that's deemed a "credible threat" is dangerous and doesn't include enough safeguards. Federal authorities would not need to first obtain a warrant, which rights groups say that authority could be easily abused, making it possible for Homeland Security and the Justice Department and its various law enforcement and immigration agencies to shoot down anyone's drone for any justifiable reason.


This acceptable use policy sets out the terms between you and us under which you may access our website http://keysigns.co.uk (our site). This acceptable use policy applies to all users of, and visitors to, our site.
We operate the website http://keysigns.co.uk. We are Key Signs UK Ltd, a company registered in England and Wales under company number 05659280 and with our registered office at 11-12 Oxford House, Ground Floor, Sixth Avenue, Robin Hood Airport, Doncaster, South Yorkshire, DN9 3GG (which is also our main trading address). Our VAT number is 875 0031 40.
If you wish to complain about any contribution posted to any of the interactive services provided on our site, please contact us at sales@keysigns.co.uk. We will then review the contribution and decide whether it complies with this acceptable use policy. We will deal with any contribution which, in our opinion, violates this acceptable use policy as described above (see section "suspension and termination". We will inform you of the outcome of our review within a reasonable time of receiving your complaint.


Sound grooves and round hammer strikes in a simple circular pattern on the top surface of ZBT cymbals magnify the basic sound of the distinctive ZBT alloy.
ZBT Series Hi-Hats produce a sharp and focused sound with an excellent, bright chick sound.
The ZBT crash ride produces a cutting ride sound with good crash qualities.
The FREE 14in crash has a brilliant finish and a crash sound with easy playability-the perfect first crash cymbal.


The average Canadian household used nearly 15 per cent of its disposable income to meet its debt obligations during the last three months of 2018.
The average Canadian household was using a record 14.9 per cent of its disposable income to meet debt obligations, Statistics Canada said on Wednesday.
The measure was "just a whisker" below the record high reached at the end of 2017, noted BMO economist Priscilla Thiagamoorthy. And a growing share of Canadians' income — 7.3 per cent, the most in nine years — is going toward interest charges, she added.
Total debt repayments outpaced the growth of disposable income in the last three months of the year, StatsCan said. Between October and December, Canadians' household debt reached a seasonally-adjusted average of $1.79 for every dollar of disposable income, up slightly from $1.78 in the June to September period.
Debt is eating up an increasing share of household disposable incomes even as Canadians pull back on borrowing. Although the end of 2018 saw a pick-up in mortgage loans, on an annual basis household borrowing declined 19.5 per cent in 2018 to the lowest level since 2014.
Rising debt-servicing costs will likely continue to squeeze Canadians' wallets for the foreseeable future, RBC economist Josh Nye wrote in a note to clients.
Even if the Bank of Canada keeps rates on hold for the rest of the year, the share of income Canadians will have to devote to mandatory debt repayments will probably keep edging up as homeowners renew fixed-rate mortgages at higher interest rates, he added.
Most Canadians will likely be able to manage higher borrowing costs by trimming consumption, according to Nye.
"We think the increase in debt servicing costs is more of a headwind to consumer spending than a financial stability risk," he wrote.
But while most households will be able to keep up with higher interest payments, they'll have a harder time making an actual dent in their debt. As a result, the debt-to-income ratio is likely to remain roughly stable, as it has been since the central bank began its rate-hiking, according to Nye.
StatsCan's latest report on the health of Canada's household finances delivered another piece of less-than-great news. Household net worth, the value of Canadians' financial and non-financial assets minus liabilities, declined by a collective $304 million, or 2.8 per cent, during the last three months of last year. In dollar terms, it was the largest drop on record, Nye noted.
The drop was in part due to the financial market swoon of the last few months of 2018, which saw major indices in the U.S. and Canada log their biggest annual losses in a decade. But the decline was also the result of a cooler real estate market, with the value of residential real estate property dipping by 1.4 per cent, the weakest quarterly performance since 2008.
Flatter housing prices means that real estate prices "won't provide the wealth boost they have in recent years," Nye said.
Meanwhile, he added, while stocks aren't expected to repeat the sharp decline of late 2018, they're also unlikely to replicate the generous gains of the last decade.


text:
Chapter 23: "Affluence and Anxiety"
The New Era: The 1920s
Republican governments
Business creed
Harding scandals
Prosperity and wealth
Farm and labor problems
Consumerism: automobile, radio, movies
Women, the family
Modern religion
Literature of alienation
Jazz age
Conflict of cultures
Prohibition, bootlegging
Religious fundamentalism versus modernists
Myth of isolation
Replacing the League of Nations
Business and diplomacy
Jazz Online
Photographs From the Golden Age of Jazz
Education First: Black History Activities
New York Library's Schomburg Center: Harlem: 1900–1940
Negro League Baseball
CNN Sports Illustrated: The 1927 Yankees
Automotive History
The Crash of 1929
Sacco and Vanzetti trial
Babbit
Immigration Quota Law
Sheppard-Towner Maternity Act
Alain Locke
National Origins Act
Kellogg-Briand Treaty
Andrew Mellon
Palmer raids
Universal Negro Improvement Association (UNIA)
Teapot Dome Scandal
Naval Disarmament Conference
Fordney-McCumber Tariff
Scopes trial
The New Negro
Home to Harlem
McNary-Haugen Farm Relief Bill
second industrial revolution
John L. Lewis
Clarence Darrow
Charles Dawes
Allow two class periods on a 45-minute traditional bell schedule or one session on a 90-minute block schedule.
By the beginning of the fall semester, the College Board Web site lists the time period for that year's DBQ. Always refer students to the graphs, charts, and maps in the textbook. Be sure students understand that they should be looking for the significance of any documents they read or of the information presented on graphs, charts, and maps. The significance means the change involved.
A major theme of the chapter is the uneven distribution of wealth in the United States during the 1920s. It is important that students understand that the lives of average farmers, African Americans, and Mexican Americans were not touched by the prosperity of the decade. Students should also make the connection between Marcus Garvey's philosophy and those of Booker T. Washington and W.E.B. Du Bois.
Students should also be aware of the international underpinnings of the nation's prosperity. The United States began the decade as the world's creditor nation. While European nations were able to borrow money, they could buy U.S.-made goods, but once the United States began to demand repayment of war loans, the market for U.S. goods began to dry up. The internal market for goods also began to decline because there was a finite number of consumers who could afford to buy goods—even on credit. Business expansion had been fueled by stock prices, and once businesses stopped expanding, prices began to fall. After 1929, the United States joined the depression that had already hit Europe in the early part of the 1920s.
To connect history and literature, design a cross-curricular unit with the Language Arts/English Department in your school. Together plan a unit in which students will read an example of literature from the 1920s, such as The Great Gatsby, in English class and in your class will learn about the society that created the environment that spawned Jay Gatsby. Larger themes to include in the unit would be how writers like Gertrude Stein, T.S. Eliot, F. Scott Fitzgerald, and Ernest Hemingway represent the era. Include African American writers such as Langston Hughes and Zora Neale Hurston and have students research the Harlem Renaissance and its contributions to literature.
American Experiences: Vol. II From 1877, edited by Roberts and Olson (secondary source readings)—Part Four


But has Apple knocked Psystar offline already for EULA violation?
A new online Mac vendor called Psystar has gone offline just hours after announcing that it was selling Mac OS X Leopard on its own brand of desktops.
Until early Monday morning, Psystar was selling 'Open Computer' desktops that feature Intel processors, 2GB of memory, a DVD drive and a copy of Mac OS X Leopard 10.5.2 for just $554 (£227) on its website. Since then, the site has gone offline with no reason given for the closure.
Although Apple has yet to confirm the rumour, most believe Psystar was shuttered by the popular manufacturer for its violation of the company's software agreement, which stipulates that Mac OS X can run only on Apple hardware.
Psystar has yet to comment on its closure, but those who purchased one of its desktops before the site went offline might have a problem on their hands if Apple really is riled.
According to those close to the situation, Apple will not update any version of Mac OS X that is not installed on its own hardware, but will require those users to reinstall the operating system on the company's own computers, which would render Psystar systems inoperable.
Of course, should Psystar challenge Apple's restrictions, any legal success could open the Mac market to all comers, which would be good news for punters worldwide.