//
// Autogenerated by Thrift Compiler (0.7.0)
//
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
//
var Thrift = require('helenus-thrift').Thrift;
var ttypes = module.exports = {};
ttypes.ConsistencyLevel = {
'ONE' : 1,
'QUORUM' : 2,
'LOCAL_QUORUM' : 3,
'EACH_QUORUM' : 4,
'ALL' : 5,
'ANY' : 6,
'TWO' : 7,
'THREE' : 8
};
ttypes.IndexOperator = {
'EQ' : 0,
'GTE' : 1,
'GT' : 2,
'LTE' : 3,
'LT' : 4
};
ttypes.IndexType = {
'KEYS' : 0,
'CUSTOM' : 1,
'COMPOSITES' : 2
};
ttypes.Compression = {
'GZIP' : 1,
'NONE' : 2
};
ttypes.CqlResultType = {
'ROWS' : 1,
'VOID' : 2,
'INT' : 3
};
ttypes.VERSION = '19.35.0';
var Column = module.exports.Column = function(args) {
  this.name = null;
  this.value = null;
  this.timestamp = null;
  this.ttl = null;
  if (args) {
    if (args.name !== undefined) {
      this.name = args.name;
    }
    if (args.value !== undefined) {
      this.value = args.value;
    }
    if (args.timestamp !== undefined) {
      this.timestamp = args.timestamp;
    }
    if (args.ttl !== undefined) {
      this.ttl = args.ttl;
    }
  }
};
Column.prototype = {};
Column.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.name = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.value = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.I64) {
        this.timestamp = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.I32) {
        this.ttl = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Column.prototype.write = function(output) {
  output.writeStructBegin('Column');
  if (this.name !== null) {
    output.writeFieldBegin('name', Thrift.Type.STRING, 1);
    output.writeString(this.name);
    output.writeFieldEnd();
  }
  if (this.value !== null) {
    output.writeFieldBegin('value', Thrift.Type.STRING, 2);
    output.writeString(this.value);
    output.writeFieldEnd();
  }
  if (this.timestamp !== null) {
    output.writeFieldBegin('timestamp', Thrift.Type.I64, 3);
    output.writeI64(this.timestamp);
    output.writeFieldEnd();
  }
  if (this.ttl !== null) {
    output.writeFieldBegin('ttl', Thrift.Type.I32, 4);
    output.writeI32(this.ttl);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var SuperColumn = module.exports.SuperColumn = function(args) {
  this.name = null;
  this.columns = null;
  if (args) {
    if (args.name !== undefined) {
      this.name = args.name;
    }
    if (args.columns !== undefined) {
      this.columns = args.columns;
    }
  }
};
SuperColumn.prototype = {};
SuperColumn.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.name = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.LIST) {
        var _size0 = 0;
        var _rtmp34;
        this.columns = [];
        var _etype3 = 0;
        _rtmp34 = input.readListBegin();
        _etype3 = _rtmp34.etype;
        _size0 = _rtmp34.size;
        for (var _i5 = 0; _i5 < _size0; ++_i5)
        {
          var elem6 = null;
          elem6 = new ttypes.Column();
          elem6.read(input);
          this.columns.push(elem6);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

SuperColumn.prototype.write = function(output) {
  output.writeStructBegin('SuperColumn');
  if (this.name) {
    output.writeFieldBegin('name', Thrift.Type.STRING, 1);
    output.writeString(this.name);
    output.writeFieldEnd();
  }
  if (this.columns) {
    output.writeFieldBegin('columns', Thrift.Type.LIST, 2);
    output.writeListBegin(Thrift.Type.STRUCT, this.columns.length);
    for (var iter7 in this.columns)
    {
      if (this.columns.hasOwnProperty(iter7))
      {
        iter7 = this.columns[iter7];
        iter7.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var CounterColumn = module.exports.CounterColumn = function(args) {
  this.name = null;
  this.value = null;
  if (args) {
    if (args.name !== undefined) {
      this.name = args.name;
    }
    if (args.value !== undefined) {
      this.value = args.value;
    }
  }
};
CounterColumn.prototype = {};
CounterColumn.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.name = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I64) {
        this.value = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

CounterColumn.prototype.write = function(output) {
  output.writeStructBegin('CounterColumn');
  if (this.name) {
    output.writeFieldBegin('name', Thrift.Type.STRING, 1);
    output.writeString(this.name);
    output.writeFieldEnd();
  }
  if (this.value) {
    output.writeFieldBegin('value', Thrift.Type.I64, 2);
    output.writeI64(this.value);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var CounterSuperColumn = module.exports.CounterSuperColumn = function(args) {
  this.name = null;
  this.columns = null;
  if (args) {
    if (args.name !== undefined) {
      this.name = args.name;
    }
    if (args.columns !== undefined) {
      this.columns = args.columns;
    }
  }
};
CounterSuperColumn.prototype = {};
CounterSuperColumn.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.name = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.LIST) {
        var _size8 = 0;
        var _rtmp312;
        this.columns = [];
        var _etype11 = 0;
        _rtmp312 = input.readListBegin();
        _etype11 = _rtmp312.etype;
        _size8 = _rtmp312.size;
        for (var _i13 = 0; _i13 < _size8; ++_i13)
        {
          var elem14 = null;
          elem14 = new ttypes.CounterColumn();
          elem14.read(input);
          this.columns.push(elem14);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

CounterSuperColumn.prototype.write = function(output) {
  output.writeStructBegin('CounterSuperColumn');
  if (this.name) {
    output.writeFieldBegin('name', Thrift.Type.STRING, 1);
    output.writeString(this.name);
    output.writeFieldEnd();
  }
  if (this.columns) {
    output.writeFieldBegin('columns', Thrift.Type.LIST, 2);
    output.writeListBegin(Thrift.Type.STRUCT, this.columns.length);
    for (var iter15 in this.columns)
    {
      if (this.columns.hasOwnProperty(iter15))
      {
        iter15 = this.columns[iter15];
        iter15.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var ColumnOrSuperColumn = module.exports.ColumnOrSuperColumn = function(args) {
  this.column = null;
  this.super_column = null;
  this.counter_column = null;
  this.counter_super_column = null;
  if (args) {
    if (args.column !== undefined) {
      this.column = args.column;
    }
    if (args.super_column !== undefined) {
      this.super_column = args.super_column;
    }
    if (args.counter_column !== undefined) {
      this.counter_column = args.counter_column;
    }
    if (args.counter_super_column !== undefined) {
      this.counter_super_column = args.counter_super_column;
    }
  }
};
ColumnOrSuperColumn.prototype = {};
ColumnOrSuperColumn.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.column = new ttypes.Column();
        this.column.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.super_column = new ttypes.SuperColumn();
        this.super_column.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRUCT) {
        this.counter_column = new ttypes.CounterColumn();
        this.counter_column.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRUCT) {
        this.counter_super_column = new ttypes.CounterSuperColumn();
        this.counter_super_column.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

ColumnOrSuperColumn.prototype.write = function(output) {
  output.writeStructBegin('ColumnOrSuperColumn');
  if (this.column) {
    output.writeFieldBegin('column', Thrift.Type.STRUCT, 1);
    this.column.write(output);
    output.writeFieldEnd();
  }
  if (this.super_column) {
    output.writeFieldBegin('super_column', Thrift.Type.STRUCT, 2);
    this.super_column.write(output);
    output.writeFieldEnd();
  }
  if (this.counter_column) {
    output.writeFieldBegin('counter_column', Thrift.Type.STRUCT, 3);
    this.counter_column.write(output);
    output.writeFieldEnd();
  }
  if (this.counter_super_column) {
    output.writeFieldBegin('counter_super_column', Thrift.Type.STRUCT, 4);
    this.counter_super_column.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var NotFoundException = module.exports.NotFoundException = function(args) {
  Thrift.TException.call(this, "NotFoundException")
  this.name = "NotFoundException"
};
Thrift.inherits(NotFoundException, Thrift.TException);
NotFoundException.prototype.name = 'NotFoundException';
NotFoundException.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    input.skip(ftype);
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

NotFoundException.prototype.write = function(output) {
  output.writeStructBegin('NotFoundException');
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var InvalidRequestException = module.exports.InvalidRequestException = function(args) {
  Thrift.TException.call(this, "InvalidRequestException")
  this.name = "InvalidRequestException"
  this.why = null;
  if (args) {
    if (args.why !== undefined) {
      this.why = args.why;
    }
  }
};
Thrift.inherits(InvalidRequestException, Thrift.TException);
InvalidRequestException.prototype.name = 'InvalidRequestException';
InvalidRequestException.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.why = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

InvalidRequestException.prototype.write = function(output) {
  output.writeStructBegin('InvalidRequestException');
  if (this.why) {
    output.writeFieldBegin('why', Thrift.Type.STRING, 1);
    output.writeString(this.why);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var UnavailableException = module.exports.UnavailableException = function(args) {
  Thrift.TException.call(this, "UnavailableException")
  this.name = "UnavailableException"
};
Thrift.inherits(UnavailableException, Thrift.TException);
UnavailableException.prototype.name = 'UnavailableException';
UnavailableException.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    input.skip(ftype);
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

UnavailableException.prototype.write = function(output) {
  output.writeStructBegin('UnavailableException');
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TimedOutException = module.exports.TimedOutException = function(args) {
  Thrift.TException.call(this, "TimedOutException")
  this.name = "TimedOutException"
  this.acknowledged_by = null;
  this.acknowledged_by_batchlog = null;
  if (args) {
    if (args.acknowledged_by !== undefined) {
      this.acknowledged_by = args.acknowledged_by;
    }
    if (args.acknowledged_by_batchlog !== undefined) {
      this.acknowledged_by_batchlog = args.acknowledged_by_batchlog;
    }
  }
};
Thrift.inherits(TimedOutException, Thrift.TException);
TimedOutException.prototype.name = 'TimedOutException';
TimedOutException.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.I32) {
        this.acknowledged_by = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.BOOL) {
        this.acknowledged_by_batchlog = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TimedOutException.prototype.write = function(output) {
  output.writeStructBegin('TimedOutException');
  if (this.acknowledged_by) {
    output.writeFieldBegin('acknowledged_by', Thrift.Type.I32, 1);
    output.writeI32(this.acknowledged_by);
    output.writeFieldEnd();
  }
  if (this.acknowledged_by_batchlog) {
    output.writeFieldBegin('acknowledged_by_batchlog', Thrift.Type.BOOL, 2);
    output.writeBool(this.acknowledged_by_batchlog);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var AuthenticationException = module.exports.AuthenticationException = function(args) {
  Thrift.TException.call(this, "AuthenticationException")
  this.name = "AuthenticationException"
  this.why = null;
  if (args) {
    if (args.why !== undefined) {
      this.why = args.why;
    }
  }
};
Thrift.inherits(AuthenticationException, Thrift.TException);
AuthenticationException.prototype.name = 'AuthenticationException';
AuthenticationException.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.why = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

AuthenticationException.prototype.write = function(output) {
  output.writeStructBegin('AuthenticationException');
  if (this.why) {
    output.writeFieldBegin('why', Thrift.Type.STRING, 1);
    output.writeString(this.why);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var AuthorizationException = module.exports.AuthorizationException = function(args) {
  Thrift.TException.call(this, "AuthorizationException")
  this.name = "AuthorizationException"
  this.why = null;
  if (args) {
    if (args.why !== undefined) {
      this.why = args.why;
    }
  }
};
Thrift.inherits(AuthorizationException, Thrift.TException);
AuthorizationException.prototype.name = 'AuthorizationException';
AuthorizationException.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.why = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

AuthorizationException.prototype.write = function(output) {
  output.writeStructBegin('AuthorizationException');
  if (this.why) {
    output.writeFieldBegin('why', Thrift.Type.STRING, 1);
    output.writeString(this.why);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var SchemaDisagreementException = module.exports.SchemaDisagreementException = function(args) {
  Thrift.TException.call(this, "SchemaDisagreementException")
  this.name = "SchemaDisagreementException"
};
Thrift.inherits(SchemaDisagreementException, Thrift.TException);
SchemaDisagreementException.prototype.name = 'SchemaDisagreementException';
SchemaDisagreementException.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    input.skip(ftype);
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

SchemaDisagreementException.prototype.write = function(output) {
  output.writeStructBegin('SchemaDisagreementException');
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var ColumnParent = module.exports.ColumnParent = function(args) {
  this.column_family = null;
  this.super_column = null;
  if (args) {
    if (args.column_family !== undefined) {
      this.column_family = args.column_family;
    }
    if (args.super_column !== undefined) {
      this.super_column = args.super_column;
    }
  }
};
ColumnParent.prototype = {};
ColumnParent.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.column_family = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRING) {
        this.super_column = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

ColumnParent.prototype.write = function(output) {
  output.writeStructBegin('ColumnParent');
  if (this.column_family) {
    output.writeFieldBegin('column_family', Thrift.Type.STRING, 3);
    output.writeString(this.column_family);
    output.writeFieldEnd();
  }
  if (this.super_column) {
    output.writeFieldBegin('super_column', Thrift.Type.STRING, 4);
    output.writeString(this.super_column);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var ColumnPath = module.exports.ColumnPath = function(args) {
  this.column_family = null;
  this.super_column = null;
  this.column = null;
  if (args) {
    if (args.column_family !== undefined) {
      this.column_family = args.column_family;
    }
    if (args.super_column !== undefined) {
      this.super_column = args.super_column;
    }
    if (args.column !== undefined) {
      this.column = args.column;
    }
  }
};
ColumnPath.prototype = {};
ColumnPath.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.column_family = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRING) {
        this.super_column = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.STRING) {
        this.column = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

ColumnPath.prototype.write = function(output) {
  output.writeStructBegin('ColumnPath');
  if (this.column_family) {
    output.writeFieldBegin('column_family', Thrift.Type.STRING, 3);
    output.writeString(this.column_family);
    output.writeFieldEnd();
  }
  if (this.super_column) {
    output.writeFieldBegin('super_column', Thrift.Type.STRING, 4);
    output.writeString(this.super_column);
    output.writeFieldEnd();
  }
  if (this.column) {
    output.writeFieldBegin('column', Thrift.Type.STRING, 5);
    output.writeString(this.column);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var SliceRange = module.exports.SliceRange = function(args) {
  this.start = null;
  this.finish = null;
  this.reversed = false;
  this.count = 100;
  if (args) {
    if (args.start !== undefined) {
      this.start = args.start;
    }
    if (args.finish !== undefined) {
      this.finish = args.finish;
    }
    if (args.reversed !== undefined) {
      this.reversed = args.reversed;
    }
    if (args.count !== undefined) {
      this.count = args.count;
    }
  }
};
SliceRange.prototype = {};
SliceRange.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.start = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.finish = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.BOOL) {
        this.reversed = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.I32) {
        this.count = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

SliceRange.prototype.write = function(output) {
  output.writeStructBegin('SliceRange');
  if (this.start !== null) {
    output.writeFieldBegin('start', Thrift.Type.STRING, 1);
    output.writeString(this.start);
    output.writeFieldEnd();
  }
  if (this.finish !== null) {
    output.writeFieldBegin('finish', Thrift.Type.STRING, 2);
    output.writeString(this.finish);
    output.writeFieldEnd();
  }
  if (this.reversed !== null) {
    output.writeFieldBegin('reversed', Thrift.Type.BOOL, 3);
    output.writeBool(this.reversed);
    output.writeFieldEnd();
  }
  if (this.count !== null) {
    output.writeFieldBegin('count', Thrift.Type.I32, 4);
    output.writeI32(this.count);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var SlicePredicate = module.exports.SlicePredicate = function(args) {
  this.column_names = null;
  this.slice_range = null;
  if (args) {
    if (args.column_names !== undefined) {
      this.column_names = args.column_names;
    }
    if (args.slice_range !== undefined) {
      this.slice_range = args.slice_range;
    }
  }
};
SlicePredicate.prototype = {};
SlicePredicate.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.LIST) {
        var _size16 = 0;
        var _rtmp320;
        this.column_names = [];
        var _etype19 = 0;
        _rtmp320 = input.readListBegin();
        _etype19 = _rtmp320.etype;
        _size16 = _rtmp320.size;
        for (var _i21 = 0; _i21 < _size16; ++_i21)
        {
          var elem22 = null;
          elem22 = input.readString();
          this.column_names.push(elem22);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.slice_range = new ttypes.SliceRange();
        this.slice_range.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

SlicePredicate.prototype.write = function(output) {
  output.writeStructBegin('SlicePredicate');
  if (this.column_names) {
    output.writeFieldBegin('column_names', Thrift.Type.LIST, 1);
    output.writeListBegin(Thrift.Type.STRING, this.column_names.length);
    for (var iter23 in this.column_names)
    {
      if (this.column_names.hasOwnProperty(iter23))
      {
        iter23 = this.column_names[iter23];
        output.writeString(iter23);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.slice_range) {
    output.writeFieldBegin('slice_range', Thrift.Type.STRUCT, 2);
    this.slice_range.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var IndexExpression = module.exports.IndexExpression = function(args) {
  this.column_name = null;
  this.op = null;
  this.value = null;
  if (args) {
    if (args.column_name !== undefined) {
      this.column_name = args.column_name;
    }
    if (args.op !== undefined) {
      this.op = args.op;
    }
    if (args.value !== undefined) {
      this.value = args.value;
    }
  }
};
IndexExpression.prototype = {};
IndexExpression.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.column_name = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I32) {
        this.op = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.value = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

IndexExpression.prototype.write = function(output) {
  output.writeStructBegin('IndexExpression');
  if (this.column_name) {
    output.writeFieldBegin('column_name', Thrift.Type.STRING, 1);
    output.writeString(this.column_name);
    output.writeFieldEnd();
  }
  if (this.op !== null) {
    output.writeFieldBegin('op', Thrift.Type.I32, 2);
    output.writeI32(this.op);
    output.writeFieldEnd();
  }
  if (this.value) {
    output.writeFieldBegin('value', Thrift.Type.STRING, 3);
    output.writeString(this.value);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var IndexClause = module.exports.IndexClause = function(args) {
  this.expressions = null;
  this.start_key = null;
  this.count = 100;
  if (args) {
    if (args.expressions !== undefined) {
      this.expressions = args.expressions;
    }
    if (args.start_key !== undefined) {
      this.start_key = args.start_key;
    }
    if (args.count !== undefined) {
      this.count = args.count;
    }
  }
};
IndexClause.prototype = {};
IndexClause.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.LIST) {
        var _size24 = 0;
        var _rtmp328;
        this.expressions = [];
        var _etype27 = 0;
        _rtmp328 = input.readListBegin();
        _etype27 = _rtmp328.etype;
        _size24 = _rtmp328.size;
        for (var _i29 = 0; _i29 < _size24; ++_i29)
        {
          var elem30 = null;
          elem30 = new ttypes.IndexExpression();
          elem30.read(input);
          this.expressions.push(elem30);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.start_key = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.I32) {
        this.count = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

IndexClause.prototype.write = function(output) {
  output.writeStructBegin('IndexClause');
  if (this.expressions) {
    output.writeFieldBegin('expressions', Thrift.Type.LIST, 1);
    output.writeListBegin(Thrift.Type.STRUCT, this.expressions.length);
    for (var iter31 in this.expressions)
    {
      if (this.expressions.hasOwnProperty(iter31))
      {
        iter31 = this.expressions[iter31];
        iter31.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.start_key !== null) {
    output.writeFieldBegin('start_key', Thrift.Type.STRING, 2);
    output.writeString(this.start_key);
    output.writeFieldEnd();
  }
  if (this.count !== null) {
    output.writeFieldBegin('count', Thrift.Type.I32, 3);
    output.writeI32(this.count);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var KeyRange = module.exports.KeyRange = function(args) {
  this.start_key = null;
  this.end_key = null;
  this.start_token = null;
  this.end_token = null;
  this.row_filter = null;
  this.count = 100;
  if (args) {
    if (args.start_key !== undefined) {
      this.start_key = args.start_key;
    }
    if (args.end_key !== undefined) {
      this.end_key = args.end_key;
    }
    if (args.start_token !== undefined) {
      this.start_token = args.start_token;
    }
    if (args.end_token !== undefined) {
      this.end_token = args.end_token;
    }
    if (args.row_filter !== undefined) {
      this.row_filter = args.row_filter;
    }
    if (args.count !== undefined) {
      this.count = args.count;
    }
  }
};
KeyRange.prototype = {};
KeyRange.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.start_key = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.end_key = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.start_token = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRING) {
        this.end_token = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 6:
      if (ftype == Thrift.Type.LIST) {
        var _size32 = 0;
        var _rtmp336;
        this.row_filter = [];
        var _etype35 = 0;
        _rtmp336 = input.readListBegin();
        _etype35 = _rtmp336.etype;
        _size32 = _rtmp336.size;
        for (var _i37 = 0; _i37 < _size32; ++_i37)
        {
          var elem38 = null;
          elem38 = new ttypes.IndexExpression();
          elem38.read(input);
          this.row_filter.push(elem38);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.I32) {
        this.count = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

KeyRange.prototype.write = function(output) {
  output.writeStructBegin('KeyRange');
  if (this.start_key) {
    output.writeFieldBegin('start_key', Thrift.Type.STRING, 1);
    output.writeString(this.start_key);
    output.writeFieldEnd();
  }
  if (this.end_key) {
    output.writeFieldBegin('end_key', Thrift.Type.STRING, 2);
    output.writeString(this.end_key);
    output.writeFieldEnd();
  }
  if (this.start_token) {
    output.writeFieldBegin('start_token', Thrift.Type.STRING, 3);
    output.writeString(this.start_token);
    output.writeFieldEnd();
  }
  if (this.end_token) {
    output.writeFieldBegin('end_token', Thrift.Type.STRING, 4);
    output.writeString(this.end_token);
    output.writeFieldEnd();
  }
  if (this.row_filter) {
    output.writeFieldBegin('row_filter', Thrift.Type.LIST, 6);
    output.writeListBegin(Thrift.Type.STRUCT, this.row_filter.length);
    for (var iter39 in this.row_filter)
    {
      if (this.row_filter.hasOwnProperty(iter39))
      {
        iter39 = this.row_filter[iter39];
        iter39.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.count) {
    output.writeFieldBegin('count', Thrift.Type.I32, 5);
    output.writeI32(this.count);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var KeySlice = module.exports.KeySlice = function(args) {
  this.key = null;
  this.columns = null;
  if (args) {
    if (args.key !== undefined) {
      this.key = args.key;
    }
    if (args.columns !== undefined) {
      this.columns = args.columns;
    }
  }
};
KeySlice.prototype = {};
KeySlice.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.key = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.LIST) {
        var _size40 = 0;
        var _rtmp344;
        this.columns = [];
        var _etype43 = 0;
        _rtmp344 = input.readListBegin();
        _etype43 = _rtmp344.etype;
        _size40 = _rtmp344.size;
        for (var _i45 = 0; _i45 < _size40; ++_i45)
        {
          var elem46 = null;
          elem46 = new ttypes.ColumnOrSuperColumn();
          elem46.read(input);
          this.columns.push(elem46);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

KeySlice.prototype.write = function(output) {
  output.writeStructBegin('KeySlice');
  if (this.key) {
    output.writeFieldBegin('key', Thrift.Type.STRING, 1);
    output.writeString(this.key);
    output.writeFieldEnd();
  }
  if (this.columns) {
    output.writeFieldBegin('columns', Thrift.Type.LIST, 2);
    output.writeListBegin(Thrift.Type.STRUCT, this.columns.length);
    for (var iter47 in this.columns)
    {
      if (this.columns.hasOwnProperty(iter47))
      {
        iter47 = this.columns[iter47];
        iter47.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var KeyCount = module.exports.KeyCount = function(args) {
  this.key = null;
  this.count = null;
  if (args) {
    if (args.key !== undefined) {
      this.key = args.key;
    }
    if (args.count !== undefined) {
      this.count = args.count;
    }
  }
};
KeyCount.prototype = {};
KeyCount.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.key = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I32) {
        this.count = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

KeyCount.prototype.write = function(output) {
  output.writeStructBegin('KeyCount');
  if (this.key) {
    output.writeFieldBegin('key', Thrift.Type.STRING, 1);
    output.writeString(this.key);
    output.writeFieldEnd();
  }
  if (this.count) {
    output.writeFieldBegin('count', Thrift.Type.I32, 2);
    output.writeI32(this.count);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var Deletion = module.exports.Deletion = function(args) {
  this.timestamp = null;
  this.super_column = null;
  this.predicate = null;
  if (args) {
    if (args.timestamp !== undefined) {
      this.timestamp = args.timestamp;
    }
    if (args.super_column !== undefined) {
      this.super_column = args.super_column;
    }
    if (args.predicate !== undefined) {
      this.predicate = args.predicate;
    }
  }
};
Deletion.prototype = {};
Deletion.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.I64) {
        this.timestamp = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.super_column = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRUCT) {
        this.predicate = new ttypes.SlicePredicate();
        this.predicate.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Deletion.prototype.write = function(output) {
  output.writeStructBegin('Deletion');
  if (this.timestamp) {
    output.writeFieldBegin('timestamp', Thrift.Type.I64, 1);
    output.writeI64(this.timestamp);
    output.writeFieldEnd();
  }
  if (this.super_column) {
    output.writeFieldBegin('super_column', Thrift.Type.STRING, 2);
    output.writeString(this.super_column);
    output.writeFieldEnd();
  }
  if (this.predicate) {
    output.writeFieldBegin('predicate', Thrift.Type.STRUCT, 3);
    this.predicate.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var Mutation = module.exports.Mutation = function(args) {
  this.column_or_supercolumn = null;
  this.deletion = null;
  if (args) {
    if (args.column_or_supercolumn !== undefined) {
      this.column_or_supercolumn = args.column_or_supercolumn;
    }
    if (args.deletion !== undefined) {
      this.deletion = args.deletion;
    }
  }
};
Mutation.prototype = {};
Mutation.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRUCT) {
        this.column_or_supercolumn = new ttypes.ColumnOrSuperColumn();
        this.column_or_supercolumn.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRUCT) {
        this.deletion = new ttypes.Deletion();
        this.deletion.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

Mutation.prototype.write = function(output) {
  output.writeStructBegin('Mutation');
  if (this.column_or_supercolumn) {
    output.writeFieldBegin('column_or_supercolumn', Thrift.Type.STRUCT, 1);
    this.column_or_supercolumn.write(output);
    output.writeFieldEnd();
  }
  if (this.deletion) {
    output.writeFieldBegin('deletion', Thrift.Type.STRUCT, 2);
    this.deletion.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var EndpointDetails = module.exports.EndpointDetails = function(args) {
  this.host = null;
  this.datacenter = null;
  this.rack = null;
  if (args) {
    if (args.host !== undefined) {
      this.host = args.host;
    }
    if (args.datacenter !== undefined) {
      this.datacenter = args.datacenter;
    }
    if (args.rack !== undefined) {
      this.rack = args.rack;
    }
  }
};
EndpointDetails.prototype = {};
EndpointDetails.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.host = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.datacenter = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.rack = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

EndpointDetails.prototype.write = function(output) {
  output.writeStructBegin('EndpointDetails');
  if (this.host) {
    output.writeFieldBegin('host', Thrift.Type.STRING, 1);
    output.writeString(this.host);
    output.writeFieldEnd();
  }
  if (this.datacenter) {
    output.writeFieldBegin('datacenter', Thrift.Type.STRING, 2);
    output.writeString(this.datacenter);
    output.writeFieldEnd();
  }
  if (this.rack) {
    output.writeFieldBegin('rack', Thrift.Type.STRING, 3);
    output.writeString(this.rack);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var TokenRange = module.exports.TokenRange = function(args) {
  this.start_token = null;
  this.end_token = null;
  this.endpoints = null;
  this.rpc_endpoints = null;
  this.endpoint_details = null;
  if (args) {
    if (args.start_token !== undefined) {
      this.start_token = args.start_token;
    }
    if (args.end_token !== undefined) {
      this.end_token = args.end_token;
    }
    if (args.endpoints !== undefined) {
      this.endpoints = args.endpoints;
    }
    if (args.rpc_endpoints !== undefined) {
      this.rpc_endpoints = args.rpc_endpoints;
    }
    if (args.endpoint_details !== undefined) {
      this.endpoint_details = args.endpoint_details;
    }
  }
};
TokenRange.prototype = {};
TokenRange.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.start_token = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.end_token = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.LIST) {
        var _size48 = 0;
        var _rtmp352;
        this.endpoints = [];
        var _etype51 = 0;
        _rtmp352 = input.readListBegin();
        _etype51 = _rtmp352.etype;
        _size48 = _rtmp352.size;
        for (var _i53 = 0; _i53 < _size48; ++_i53)
        {
          var elem54 = null;
          elem54 = input.readString();
          this.endpoints.push(elem54);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.LIST) {
        var _size55 = 0;
        var _rtmp359;
        this.rpc_endpoints = [];
        var _etype58 = 0;
        _rtmp359 = input.readListBegin();
        _etype58 = _rtmp359.etype;
        _size55 = _rtmp359.size;
        for (var _i60 = 0; _i60 < _size55; ++_i60)
        {
          var elem61 = null;
          elem61 = input.readString();
          this.rpc_endpoints.push(elem61);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.LIST) {
        var _size62 = 0;
        var _rtmp366;
        this.endpoint_details = [];
        var _etype65 = 0;
        _rtmp366 = input.readListBegin();
        _etype65 = _rtmp366.etype;
        _size62 = _rtmp366.size;
        for (var _i67 = 0; _i67 < _size62; ++_i67)
        {
          var elem68 = null;
          elem68 = new ttypes.EndpointDetails();
          elem68.read(input);
          this.endpoint_details.push(elem68);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

TokenRange.prototype.write = function(output) {
  output.writeStructBegin('TokenRange');
  if (this.start_token) {
    output.writeFieldBegin('start_token', Thrift.Type.STRING, 1);
    output.writeString(this.start_token);
    output.writeFieldEnd();
  }
  if (this.end_token) {
    output.writeFieldBegin('end_token', Thrift.Type.STRING, 2);
    output.writeString(this.end_token);
    output.writeFieldEnd();
  }
  if (this.endpoints) {
    output.writeFieldBegin('endpoints', Thrift.Type.LIST, 3);
    output.writeListBegin(Thrift.Type.STRING, this.endpoints.length);
    for (var iter69 in this.endpoints)
    {
      if (this.endpoints.hasOwnProperty(iter69))
      {
        iter69 = this.endpoints[iter69];
        output.writeString(iter69);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.rpc_endpoints) {
    output.writeFieldBegin('rpc_endpoints', Thrift.Type.LIST, 4);
    output.writeListBegin(Thrift.Type.STRING, this.rpc_endpoints.length);
    for (var iter70 in this.rpc_endpoints)
    {
      if (this.rpc_endpoints.hasOwnProperty(iter70))
      {
        iter70 = this.rpc_endpoints[iter70];
        output.writeString(iter70);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.endpoint_details) {
    output.writeFieldBegin('endpoint_details', Thrift.Type.LIST, 5);
    output.writeListBegin(Thrift.Type.STRUCT, this.endpoint_details.length);
    for (var iter71 in this.endpoint_details)
    {
      if (this.endpoint_details.hasOwnProperty(iter71))
      {
        iter71 = this.endpoint_details[iter71];
        iter71.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var AuthenticationRequest = module.exports.AuthenticationRequest = function(args) {
  this.credentials = null;
  if (args) {
    if (args.credentials !== undefined) {
      this.credentials = args.credentials;
    }
  }
};
AuthenticationRequest.prototype = {};
AuthenticationRequest.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.MAP) {
        var _size72 = 0;
        var _rtmp376;
        this.credentials = {};
        var _ktype73 = 0;
        var _vtype74 = 0;
        _rtmp376 = input.readMapBegin();
        _ktype73 = _rtmp376.ktype;
        _vtype74 = _rtmp376.vtype;
        _size72 = _rtmp376.size;
        for (var _i77 = 0; _i77 < _size72; ++_i77)
        {
          var key78 = null;
          var val79 = null;
          key78 = input.readString();
          val79 = input.readString();
          this.credentials[key78] = val79;
        }
        input.readMapEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 0:
        input.skip(ftype);
        break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

AuthenticationRequest.prototype.write = function(output) {
  output.writeStructBegin('AuthenticationRequest');
  if (this.credentials) {
    output.writeFieldBegin('credentials', Thrift.Type.MAP, 1);
    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRING, Thrift.objectLength(this.credentials));
    for (var kiter80 in this.credentials)
    {
      if (this.credentials.hasOwnProperty(kiter80))
      {
        var viter81 = this.credentials[kiter80];
        output.writeString(kiter80);
        output.writeString(viter81);
      }
    }
    output.writeMapEnd();
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var ColumnDef = module.exports.ColumnDef = function(args) {
  this.name = null;
  this.validation_class = null;
  this.index_type = null;
  this.index_name = null;
  this.index_options = null;
  if (args) {
    if (args.name !== undefined) {
      this.name = args.name;
    }
    if (args.validation_class !== undefined) {
      this.validation_class = args.validation_class;
    }
    if (args.index_type !== undefined) {
      this.index_type = args.index_type;
    }
    if (args.index_name !== undefined) {
      this.index_name = args.index_name;
    }
    if (args.index_options !== undefined) {
      this.index_options = args.index_options;
    }
  }
};
ColumnDef.prototype = {};
ColumnDef.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.name = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.validation_class = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.I32) {
        this.index_type = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRING) {
        this.index_name = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.MAP) {
        var _size82 = 0;
        var _rtmp386;
        this.index_options = {};
        var _ktype83 = 0;
        var _vtype84 = 0;
        _rtmp386 = input.readMapBegin();
        _ktype83 = _rtmp386.ktype;
        _vtype84 = _rtmp386.vtype;
        _size82 = _rtmp386.size;
        for (var _i87 = 0; _i87 < _size82; ++_i87)
        {
          var key88 = null;
          var val89 = null;
          key88 = input.readString();
          val89 = input.readString();
          this.index_options[key88] = val89;
        }
        input.readMapEnd();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

ColumnDef.prototype.write = function(output) {
  output.writeStructBegin('ColumnDef');
  if (this.name) {
    output.writeFieldBegin('name', Thrift.Type.STRING, 1);
    output.writeString(this.name);
    output.writeFieldEnd();
  }
  if (this.validation_class) {
    output.writeFieldBegin('validation_class', Thrift.Type.STRING, 2);
    output.writeString(this.validation_class);
    output.writeFieldEnd();
  }
  if (this.index_type !== null) {
    output.writeFieldBegin('index_type', Thrift.Type.I32, 3);
    output.writeI32(this.index_type);
    output.writeFieldEnd();
  }
  if (this.index_name) {
    output.writeFieldBegin('index_name', Thrift.Type.STRING, 4);
    output.writeString(this.index_name);
    output.writeFieldEnd();
  }
  if (this.index_options) {
    output.writeFieldBegin('index_options', Thrift.Type.MAP, 5);
    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRING, Thrift.objectLength(this.index_options));
    for (var kiter90 in this.index_options)
    {
      if (this.index_options.hasOwnProperty(kiter90))
      {
        var viter91 = this.index_options[kiter90];
        output.writeString(kiter90);
        output.writeString(viter91);
      }
    }
    output.writeMapEnd();
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var CfDef = module.exports.CfDef = function(args) {
  this.keyspace = null;
  this.name = null;
  this.column_type = 'Standard';
  this.comparator_type = 'BytesType';
  this.subcomparator_type = null;
  this.comment = null;
  this.read_repair_chance = null;
  this.column_metadata = null;
  this.gc_grace_seconds = null;
  this.default_validation_class = null;
  this.id = null;
  this.min_compaction_threshold = null;
  this.max_compaction_threshold = null;
  this.replicate_on_write = null;
  this.key_validation_class = null;
  this.key_alias = null;
  this.compaction_strategy = null;
  this.compaction_strategy_options = null;
  this.compression_options = null;
  this.bloom_filter_fp_chance = null;
  this.caching = 'keys_only';
  this.dclocal_read_repair_chance = 0;
  this.row_cache_size = null;
  this.key_cache_size = null;
  this.row_cache_save_period_in_seconds = null;
  this.key_cache_save_period_in_seconds = null;
  this.memtable_flush_after_mins = null;
  this.memtable_throughput_in_mb = null;
  this.memtable_operations_in_millions = null;
  this.merge_shards_chance = null;
  this.row_cache_provider = null;
  this.row_cache_keys_to_save = null;
  if (args) {
    if (args.keyspace !== undefined) {
      this.keyspace = args.keyspace;
    }
    if (args.name !== undefined) {
      this.name = args.name;
    }
    if (args.column_type !== undefined) {
      this.column_type = args.column_type;
    }
    if (args.comparator_type !== undefined) {
      this.comparator_type = args.comparator_type;
    }
    if (args.subcomparator_type !== undefined) {
      this.subcomparator_type = args.subcomparator_type;
    }
    if (args.comment !== undefined) {
      this.comment = args.comment;
    }
    if (args.read_repair_chance !== undefined) {
      this.read_repair_chance = args.read_repair_chance;
    }
    if (args.column_metadata !== undefined) {
      this.column_metadata = args.column_metadata;
    }
    if (args.gc_grace_seconds !== undefined) {
      this.gc_grace_seconds = args.gc_grace_seconds;
    }
    if (args.default_validation_class !== undefined) {
      this.default_validation_class = args.default_validation_class;
    }
    if (args.id !== undefined) {
      this.id = args.id;
    }
    if (args.min_compaction_threshold !== undefined) {
      this.min_compaction_threshold = args.min_compaction_threshold;
    }
    if (args.max_compaction_threshold !== undefined) {
      this.max_compaction_threshold = args.max_compaction_threshold;
    }
    if (args.replicate_on_write !== undefined) {
      this.replicate_on_write = args.replicate_on_write;
    }
    if (args.key_validation_class !== undefined) {
      this.key_validation_class = args.key_validation_class;
    }
    if (args.key_alias !== undefined) {
      this.key_alias = args.key_alias;
    }
    if (args.compaction_strategy !== undefined) {
      this.compaction_strategy = args.compaction_strategy;
    }
    if (args.compaction_strategy_options !== undefined) {
      this.compaction_strategy_options = args.compaction_strategy_options;
    }
    if (args.compression_options !== undefined) {
      this.compression_options = args.compression_options;
    }
    if (args.bloom_filter_fp_chance !== undefined) {
      this.bloom_filter_fp_chance = args.bloom_filter_fp_chance;
    }
    if (args.caching !== undefined) {
      this.caching = args.caching;
    }
    if (args.dclocal_read_repair_chance !== undefined) {
      this.dclocal_read_repair_chance = args.dclocal_read_repair_chance;
    }
    if (args.row_cache_size !== undefined) {
      this.row_cache_size = args.row_cache_size;
    }
    if (args.key_cache_size !== undefined) {
      this.key_cache_size = args.key_cache_size;
    }
    if (args.row_cache_save_period_in_seconds !== undefined) {
      this.row_cache_save_period_in_seconds = args.row_cache_save_period_in_seconds;
    }
    if (args.key_cache_save_period_in_seconds !== undefined) {
      this.key_cache_save_period_in_seconds = args.key_cache_save_period_in_seconds;
    }
    if (args.memtable_flush_after_mins !== undefined) {
      this.memtable_flush_after_mins = args.memtable_flush_after_mins;
    }
    if (args.memtable_throughput_in_mb !== undefined) {
      this.memtable_throughput_in_mb = args.memtable_throughput_in_mb;
    }
    if (args.memtable_operations_in_millions !== undefined) {
      this.memtable_operations_in_millions = args.memtable_operations_in_millions;
    }
    if (args.merge_shards_chance !== undefined) {
      this.merge_shards_chance = args.merge_shards_chance;
    }
    if (args.row_cache_provider !== undefined) {
      this.row_cache_provider = args.row_cache_provider;
    }
    if (args.row_cache_keys_to_save !== undefined) {
      this.row_cache_keys_to_save = args.row_cache_keys_to_save;
    }
  }
};
CfDef.prototype = {};
CfDef.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.keyspace = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.name = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.column_type = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.STRING) {
        this.comparator_type = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 6:
      if (ftype == Thrift.Type.STRING) {
        this.subcomparator_type = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 8:
      if (ftype == Thrift.Type.STRING) {
        this.comment = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 12:
      if (ftype == Thrift.Type.DOUBLE) {
        this.read_repair_chance = input.readDouble();
      } else {
        input.skip(ftype);
      }
      break;
      case 13:
      if (ftype == Thrift.Type.LIST) {
        var _size92 = 0;
        var _rtmp396;
        this.column_metadata = [];
        var _etype95 = 0;
        _rtmp396 = input.readListBegin();
        _etype95 = _rtmp396.etype;
        _size92 = _rtmp396.size;
        for (var _i97 = 0; _i97 < _size92; ++_i97)
        {
          var elem98 = null;
          elem98 = new ttypes.ColumnDef();
          elem98.read(input);
          this.column_metadata.push(elem98);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 14:
      if (ftype == Thrift.Type.I32) {
        this.gc_grace_seconds = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 15:
      if (ftype == Thrift.Type.STRING) {
        this.default_validation_class = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 16:
      if (ftype == Thrift.Type.I32) {
        this.id = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 17:
      if (ftype == Thrift.Type.I32) {
        this.min_compaction_threshold = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 18:
      if (ftype == Thrift.Type.I32) {
        this.max_compaction_threshold = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 24:
      if (ftype == Thrift.Type.BOOL) {
        this.replicate_on_write = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      case 26:
      if (ftype == Thrift.Type.STRING) {
        this.key_validation_class = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 28:
      if (ftype == Thrift.Type.STRING) {
        this.key_alias = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 29:
      if (ftype == Thrift.Type.STRING) {
        this.compaction_strategy = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 30:
      if (ftype == Thrift.Type.MAP) {
        var _size99 = 0;
        var _rtmp3103;
        this.compaction_strategy_options = {};
        var _ktype100 = 0;
        var _vtype101 = 0;
        _rtmp3103 = input.readMapBegin();
        _ktype100 = _rtmp3103.ktype;
        _vtype101 = _rtmp3103.vtype;
        _size99 = _rtmp3103.size;
        for (var _i104 = 0; _i104 < _size99; ++_i104)
        {
          var key105 = null;
          var val106 = null;
          key105 = input.readString();
          val106 = input.readString();
          this.compaction_strategy_options[key105] = val106;
        }
        input.readMapEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 32:
      if (ftype == Thrift.Type.MAP) {
        var _size107 = 0;
        var _rtmp3111;
        this.compression_options = {};
        var _ktype108 = 0;
        var _vtype109 = 0;
        _rtmp3111 = input.readMapBegin();
        _ktype108 = _rtmp3111.ktype;
        _vtype109 = _rtmp3111.vtype;
        _size107 = _rtmp3111.size;
        for (var _i112 = 0; _i112 < _size107; ++_i112)
        {
          var key113 = null;
          var val114 = null;
          key113 = input.readString();
          val114 = input.readString();
          this.compression_options[key113] = val114;
        }
        input.readMapEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 33:
      if (ftype == Thrift.Type.DOUBLE) {
        this.bloom_filter_fp_chance = input.readDouble();
      } else {
        input.skip(ftype);
      }
      break;
      case 34:
      if (ftype == Thrift.Type.STRING) {
        this.caching = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 37:
      if (ftype == Thrift.Type.DOUBLE) {
        this.dclocal_read_repair_chance = input.readDouble();
      } else {
        input.skip(ftype);
      }
      break;
      case 9:
      if (ftype == Thrift.Type.DOUBLE) {
        this.row_cache_size = input.readDouble();
      } else {
        input.skip(ftype);
      }
      break;
      case 11:
      if (ftype == Thrift.Type.DOUBLE) {
        this.key_cache_size = input.readDouble();
      } else {
        input.skip(ftype);
      }
      break;
      case 19:
      if (ftype == Thrift.Type.I32) {
        this.row_cache_save_period_in_seconds = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 20:
      if (ftype == Thrift.Type.I32) {
        this.key_cache_save_period_in_seconds = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 21:
      if (ftype == Thrift.Type.I32) {
        this.memtable_flush_after_mins = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 22:
      if (ftype == Thrift.Type.I32) {
        this.memtable_throughput_in_mb = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 23:
      if (ftype == Thrift.Type.DOUBLE) {
        this.memtable_operations_in_millions = input.readDouble();
      } else {
        input.skip(ftype);
      }
      break;
      case 25:
      if (ftype == Thrift.Type.DOUBLE) {
        this.merge_shards_chance = input.readDouble();
      } else {
        input.skip(ftype);
      }
      break;
      case 27:
      if (ftype == Thrift.Type.STRING) {
        this.row_cache_provider = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 31:
      if (ftype == Thrift.Type.I32) {
        this.row_cache_keys_to_save = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

CfDef.prototype.write = function(output) {
  output.writeStructBegin('CfDef');
  if (this.keyspace) {
    output.writeFieldBegin('keyspace', Thrift.Type.STRING, 1);
    output.writeString(this.keyspace);
    output.writeFieldEnd();
  }
  if (this.name) {
    output.writeFieldBegin('name', Thrift.Type.STRING, 2);
    output.writeString(this.name);
    output.writeFieldEnd();
  }
  if (this.column_type) {
    output.writeFieldBegin('column_type', Thrift.Type.STRING, 3);
    output.writeString(this.column_type);
    output.writeFieldEnd();
  }
  if (this.comparator_type) {
    output.writeFieldBegin('comparator_type', Thrift.Type.STRING, 5);
    output.writeString(this.comparator_type);
    output.writeFieldEnd();
  }
  if (this.subcomparator_type) {
    output.writeFieldBegin('subcomparator_type', Thrift.Type.STRING, 6);
    output.writeString(this.subcomparator_type);
    output.writeFieldEnd();
  }
  if (this.comment) {
    output.writeFieldBegin('comment', Thrift.Type.STRING, 8);
    output.writeString(this.comment);
    output.writeFieldEnd();
  }
  if (this.read_repair_chance) {
    output.writeFieldBegin('read_repair_chance', Thrift.Type.DOUBLE, 12);
    output.writeDouble(this.read_repair_chance);
    output.writeFieldEnd();
  }
  if (this.column_metadata) {
    output.writeFieldBegin('column_metadata', Thrift.Type.LIST, 13);
    output.writeListBegin(Thrift.Type.STRUCT, this.column_metadata.length);
    for (var iter115 in this.column_metadata)
    {
      if (this.column_metadata.hasOwnProperty(iter115))
      {
        iter115 = this.column_metadata[iter115];
        iter115.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.gc_grace_seconds) {
    output.writeFieldBegin('gc_grace_seconds', Thrift.Type.I32, 14);
    output.writeI32(this.gc_grace_seconds);
    output.writeFieldEnd();
  }
  if (this.default_validation_class) {
    output.writeFieldBegin('default_validation_class', Thrift.Type.STRING, 15);
    output.writeString(this.default_validation_class);
    output.writeFieldEnd();
  }
  if (this.id) {
    output.writeFieldBegin('id', Thrift.Type.I32, 16);
    output.writeI32(this.id);
    output.writeFieldEnd();
  }
  if (this.min_compaction_threshold) {
    output.writeFieldBegin('min_compaction_threshold', Thrift.Type.I32, 17);
    output.writeI32(this.min_compaction_threshold);
    output.writeFieldEnd();
  }
  if (this.max_compaction_threshold) {
    output.writeFieldBegin('max_compaction_threshold', Thrift.Type.I32, 18);
    output.writeI32(this.max_compaction_threshold);
    output.writeFieldEnd();
  }
  if (this.replicate_on_write) {
    output.writeFieldBegin('replicate_on_write', Thrift.Type.BOOL, 24);
    output.writeBool(this.replicate_on_write);
    output.writeFieldEnd();
  }
  if (this.key_validation_class) {
    output.writeFieldBegin('key_validation_class', Thrift.Type.STRING, 26);
    output.writeString(this.key_validation_class);
    output.writeFieldEnd();
  }
  if (this.key_alias) {
    output.writeFieldBegin('key_alias', Thrift.Type.STRING, 28);
    output.writeString(this.key_alias);
    output.writeFieldEnd();
  }
  if (this.compaction_strategy) {
    output.writeFieldBegin('compaction_strategy', Thrift.Type.STRING, 29);
    output.writeString(this.compaction_strategy);
    output.writeFieldEnd();
  }
  if (this.compaction_strategy_options) {
    output.writeFieldBegin('compaction_strategy_options', Thrift.Type.MAP, 30);
    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRING, Thrift.objectLength(this.compaction_strategy_options));
    for (var kiter116 in this.compaction_strategy_options)
    {
      if (this.compaction_strategy_options.hasOwnProperty(kiter116))
      {
        var viter117 = this.compaction_strategy_options[kiter116];
        output.writeString(kiter116);
        output.writeString(viter117);
      }
    }
    output.writeMapEnd();
    output.writeFieldEnd();
  }
  if (this.compression_options) {
    output.writeFieldBegin('compression_options', Thrift.Type.MAP, 32);
    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRING, Thrift.objectLength(this.compression_options));
    for (var kiter118 in this.compression_options)
    {
      if (this.compression_options.hasOwnProperty(kiter118))
      {
        var viter119 = this.compression_options[kiter118];
        output.writeString(kiter118);
        output.writeString(viter119);
      }
    }
    output.writeMapEnd();
    output.writeFieldEnd();
  }
  if (this.bloom_filter_fp_chance) {
    output.writeFieldBegin('bloom_filter_fp_chance', Thrift.Type.DOUBLE, 33);
    output.writeDouble(this.bloom_filter_fp_chance);
    output.writeFieldEnd();
  }
  if (this.caching) {
    output.writeFieldBegin('caching', Thrift.Type.STRING, 34);
    output.writeString(this.caching);
    output.writeFieldEnd();
  }
  if (this.dclocal_read_repair_chance) {
    output.writeFieldBegin('dclocal_read_repair_chance', Thrift.Type.DOUBLE, 37);
    output.writeDouble(this.dclocal_read_repair_chance);
    output.writeFieldEnd();
  }
  if (this.row_cache_size) {
    output.writeFieldBegin('row_cache_size', Thrift.Type.DOUBLE, 9);
    output.writeDouble(this.row_cache_size);
    output.writeFieldEnd();
  }
  if (this.key_cache_size) {
    output.writeFieldBegin('key_cache_size', Thrift.Type.DOUBLE, 11);
    output.writeDouble(this.key_cache_size);
    output.writeFieldEnd();
  }
  if (this.row_cache_save_period_in_seconds) {
    output.writeFieldBegin('row_cache_save_period_in_seconds', Thrift.Type.I32, 19);
    output.writeI32(this.row_cache_save_period_in_seconds);
    output.writeFieldEnd();
  }
  if (this.key_cache_save_period_in_seconds) {
    output.writeFieldBegin('key_cache_save_period_in_seconds', Thrift.Type.I32, 20);
    output.writeI32(this.key_cache_save_period_in_seconds);
    output.writeFieldEnd();
  }
  if (this.memtable_flush_after_mins) {
    output.writeFieldBegin('memtable_flush_after_mins', Thrift.Type.I32, 21);
    output.writeI32(this.memtable_flush_after_mins);
    output.writeFieldEnd();
  }
  if (this.memtable_throughput_in_mb) {
    output.writeFieldBegin('memtable_throughput_in_mb', Thrift.Type.I32, 22);
    output.writeI32(this.memtable_throughput_in_mb);
    output.writeFieldEnd();
  }
  if (this.memtable_operations_in_millions) {
    output.writeFieldBegin('memtable_operations_in_millions', Thrift.Type.DOUBLE, 23);
    output.writeDouble(this.memtable_operations_in_millions);
    output.writeFieldEnd();
  }
  if (this.merge_shards_chance) {
    output.writeFieldBegin('merge_shards_chance', Thrift.Type.DOUBLE, 25);
    output.writeDouble(this.merge_shards_chance);
    output.writeFieldEnd();
  }
  if (this.row_cache_provider) {
    output.writeFieldBegin('row_cache_provider', Thrift.Type.STRING, 27);
    output.writeString(this.row_cache_provider);
    output.writeFieldEnd();
  }
  if (this.row_cache_keys_to_save) {
    output.writeFieldBegin('row_cache_keys_to_save', Thrift.Type.I32, 31);
    output.writeI32(this.row_cache_keys_to_save);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var KsDef = module.exports.KsDef = function(args) {
  this.name = null;
  this.strategy_class = null;
  this.strategy_options = null;
  this.replication_factor = null;
  this.cf_defs = null;
  this.durable_writes = true;
  if (args) {
    if (args.name !== undefined) {
      this.name = args.name;
    }
    if (args.strategy_class !== undefined) {
      this.strategy_class = args.strategy_class;
    }
    if (args.strategy_options !== undefined) {
      this.strategy_options = args.strategy_options;
    }
    if (args.replication_factor !== undefined) {
      this.replication_factor = args.replication_factor;
    }
    if (args.cf_defs !== undefined) {
      this.cf_defs = args.cf_defs;
    }
    if (args.durable_writes !== undefined) {
      this.durable_writes = args.durable_writes;
    }
  }
};
KsDef.prototype = {};
KsDef.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.name = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.strategy_class = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.MAP) {
        var _size120 = 0;
        var _rtmp3124;
        this.strategy_options = {};
        var _ktype121 = 0;
        var _vtype122 = 0;
        _rtmp3124 = input.readMapBegin();
        _ktype121 = _rtmp3124.ktype;
        _vtype122 = _rtmp3124.vtype;
        _size120 = _rtmp3124.size;
        for (var _i125 = 0; _i125 < _size120; ++_i125)
        {
          var key126 = null;
          var val127 = null;
          key126 = input.readString();
          val127 = input.readString();
          this.strategy_options[key126] = val127;
        }
        input.readMapEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.I32) {
        this.replication_factor = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 5:
      if (ftype == Thrift.Type.LIST) {
        var _size128 = 0;
        var _rtmp3132;
        this.cf_defs = [];
        var _etype131 = 0;
        _rtmp3132 = input.readListBegin();
        _etype131 = _rtmp3132.etype;
        _size128 = _rtmp3132.size;
        for (var _i133 = 0; _i133 < _size128; ++_i133)
        {
          var elem134 = null;
          elem134 = new ttypes.CfDef();
          elem134.read(input);
          this.cf_defs.push(elem134);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 6:
      if (ftype == Thrift.Type.BOOL) {
        this.durable_writes = input.readBool();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

KsDef.prototype.write = function(output) {
  output.writeStructBegin('KsDef');
  if (this.name) {
    output.writeFieldBegin('name', Thrift.Type.STRING, 1);
    output.writeString(this.name);
    output.writeFieldEnd();
  }
  if (this.strategy_class) {
    output.writeFieldBegin('strategy_class', Thrift.Type.STRING, 2);
    output.writeString(this.strategy_class);
    output.writeFieldEnd();
  }
  if (this.strategy_options) {
    output.writeFieldBegin('strategy_options', Thrift.Type.MAP, 3);
    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRING, Thrift.objectLength(this.strategy_options));
    for (var kiter135 in this.strategy_options)
    {
      if (this.strategy_options.hasOwnProperty(kiter135))
      {
        var viter136 = this.strategy_options[kiter135];
        output.writeString(kiter135);
        output.writeString(viter136);
      }
    }
    output.writeMapEnd();
    output.writeFieldEnd();
  }
  if (this.replication_factor) {
    output.writeFieldBegin('replication_factor', Thrift.Type.I32, 4);
    output.writeI32(this.replication_factor);
    output.writeFieldEnd();
  }
  if (this.cf_defs) {
    output.writeFieldBegin('cf_defs', Thrift.Type.LIST, 5);
    output.writeListBegin(Thrift.Type.STRUCT, this.cf_defs.length);
    for (var iter137 in this.cf_defs)
    {
      if (this.cf_defs.hasOwnProperty(iter137))
      {
        iter137 = this.cf_defs[iter137];
        iter137.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.durable_writes) {
    output.writeFieldBegin('durable_writes', Thrift.Type.BOOL, 6);
    output.writeBool(this.durable_writes);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var CqlRow = module.exports.CqlRow = function(args) {
  this.key = null;
  this.columns = null;
  if (args) {
    if (args.key !== undefined) {
      this.key = args.key;
    }
    if (args.columns !== undefined) {
      this.columns = args.columns;
    }
  }
};
CqlRow.prototype = {};
CqlRow.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.key = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.LIST) {
        var _size138 = 0;
        var _rtmp3142;
        this.columns = [];
        var _etype141 = 0;
        _rtmp3142 = input.readListBegin();
        _etype141 = _rtmp3142.etype;
        _size138 = _rtmp3142.size;
        for (var _i143 = 0; _i143 < _size138; ++_i143)
        {
          var elem144 = null;
          elem144 = new ttypes.Column();
          elem144.read(input);
          this.columns.push(elem144);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

CqlRow.prototype.write = function(output) {
  output.writeStructBegin('CqlRow');
  if (this.key) {
    output.writeFieldBegin('key', Thrift.Type.STRING, 1);
    output.writeString(this.key);
    output.writeFieldEnd();
  }
  if (this.columns) {
    output.writeFieldBegin('columns', Thrift.Type.LIST, 2);
    output.writeListBegin(Thrift.Type.STRUCT, this.columns.length);
    for (var iter145 in this.columns)
    {
      if (this.columns.hasOwnProperty(iter145))
      {
        iter145 = this.columns[iter145];
        iter145.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var CqlMetadata = module.exports.CqlMetadata = function(args) {
  this.name_types = null;
  this.value_types = null;
  this.default_name_type = null;
  this.default_value_type = null;
  if (args) {
    if (args.name_types !== undefined) {
      this.name_types = args.name_types;
    }
    if (args.value_types !== undefined) {
      this.value_types = args.value_types;
    }
    if (args.default_name_type !== undefined) {
      this.default_name_type = args.default_name_type;
    }
    if (args.default_value_type !== undefined) {
      this.default_value_type = args.default_value_type;
    }
  }
};
CqlMetadata.prototype = {};
CqlMetadata.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.MAP) {
        var _size146 = 0;
        var _rtmp3150;
        this.name_types = {};
        var _ktype147 = 0;
        var _vtype148 = 0;
        _rtmp3150 = input.readMapBegin();
        _ktype147 = _rtmp3150.ktype;
        _vtype148 = _rtmp3150.vtype;
        _size146 = _rtmp3150.size;
        for (var _i151 = 0; _i151 < _size146; ++_i151)
        {
          var key152 = null;
          var val153 = null;
          key152 = input.readString();
          val153 = input.readString();
          this.name_types[key152] = val153;
        }
        input.readMapEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.MAP) {
        var _size154 = 0;
        var _rtmp3158;
        this.value_types = {};
        var _ktype155 = 0;
        var _vtype156 = 0;
        _rtmp3158 = input.readMapBegin();
        _ktype155 = _rtmp3158.ktype;
        _vtype156 = _rtmp3158.vtype;
        _size154 = _rtmp3158.size;
        for (var _i159 = 0; _i159 < _size154; ++_i159)
        {
          var key160 = null;
          var val161 = null;
          key160 = input.readString();
          val161 = input.readString();
          this.value_types[key160] = val161;
        }
        input.readMapEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.STRING) {
        this.default_name_type = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRING) {
        this.default_value_type = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

CqlMetadata.prototype.write = function(output) {
  output.writeStructBegin('CqlMetadata');
  if (this.name_types) {
    output.writeFieldBegin('name_types', Thrift.Type.MAP, 1);
    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRING, Thrift.objectLength(this.name_types));
    for (var kiter162 in this.name_types)
    {
      if (this.name_types.hasOwnProperty(kiter162))
      {
        var viter163 = this.name_types[kiter162];
        output.writeString(kiter162);
        output.writeString(viter163);
      }
    }
    output.writeMapEnd();
    output.writeFieldEnd();
  }
  if (this.value_types) {
    output.writeFieldBegin('value_types', Thrift.Type.MAP, 2);
    output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRING, Thrift.objectLength(this.value_types));
    for (var kiter164 in this.value_types)
    {
      if (this.value_types.hasOwnProperty(kiter164))
      {
        var viter165 = this.value_types[kiter164];
        output.writeString(kiter164);
        output.writeString(viter165);
      }
    }
    output.writeMapEnd();
    output.writeFieldEnd();
  }
  if (this.default_name_type) {
    output.writeFieldBegin('default_name_type', Thrift.Type.STRING, 3);
    output.writeString(this.default_name_type);
    output.writeFieldEnd();
  }
  if (this.default_value_type) {
    output.writeFieldBegin('default_value_type', Thrift.Type.STRING, 4);
    output.writeString(this.default_value_type);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var CqlResult = module.exports.CqlResult = function(args) {
  this.type = null;
  this.rows = null;
  this.num = null;
  this.schema = null;
  if (args) {
    if (args.type !== undefined) {
      this.type = args.type;
    }
    if (args.rows !== undefined) {
      this.rows = args.rows;
    }
    if (args.num !== undefined) {
      this.num = args.num;
    }
    if (args.schema !== undefined) {
      this.schema = args.schema;
    }
  }
};
CqlResult.prototype = {};
CqlResult.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.I32) {
        this.type = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.LIST) {
        var _size166 = 0;
        var _rtmp3170;
        this.rows = [];
        var _etype169 = 0;
        _rtmp3170 = input.readListBegin();
        _etype169 = _rtmp3170.etype;
        _size166 = _rtmp3170.size;
        for (var _i171 = 0; _i171 < _size166; ++_i171)
        {
          var elem172 = null;
          elem172 = new ttypes.CqlRow();
          elem172.read(input);
          this.rows.push(elem172);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.I32) {
        this.num = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.STRUCT) {
        this.schema = new ttypes.CqlMetadata();
        this.schema.read(input);
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

CqlResult.prototype.write = function(output) {
  output.writeStructBegin('CqlResult');
  if (this.type) {
    output.writeFieldBegin('type', Thrift.Type.I32, 1);
    output.writeI32(this.type);
    output.writeFieldEnd();
  }
  if (this.rows) {
    output.writeFieldBegin('rows', Thrift.Type.LIST, 2);
    output.writeListBegin(Thrift.Type.STRUCT, this.rows.length);
    for (var iter173 in this.rows)
    {
      if (this.rows.hasOwnProperty(iter173))
      {
        iter173 = this.rows[iter173];
        iter173.write(output);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.num) {
    output.writeFieldBegin('num', Thrift.Type.I32, 3);
    output.writeI32(this.num);
    output.writeFieldEnd();
  }
  if (this.schema) {
    output.writeFieldBegin('schema', Thrift.Type.STRUCT, 4);
    this.schema.write(output);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var CqlPreparedResult = module.exports.CqlPreparedResult = function(args) {
  this.itemId = null;
  this.count = null;
  this.variable_types = null;
  this.variable_names = null;
  if (args) {
    if (args.itemId !== undefined) {
      this.itemId = args.itemId;
    }
    if (args.count !== undefined) {
      this.count = args.count;
    }
    if (args.variable_types !== undefined) {
      this.variable_types = args.variable_types;
    }
    if (args.variable_names !== undefined) {
      this.variable_names = args.variable_names;
    }
  }
};
CqlPreparedResult.prototype = {};
CqlPreparedResult.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.I32) {
        this.itemId = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.I32) {
        this.count = input.readI32();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.LIST) {
        var _size174 = 0;
        var _rtmp3178;
        this.variable_types = [];
        var _etype177 = 0;
        _rtmp3178 = input.readListBegin();
        _etype177 = _rtmp3178.etype;
        _size174 = _rtmp3178.size;
        for (var _i179 = 0; _i179 < _size174; ++_i179)
        {
          var elem180 = null;
          elem180 = input.readString();
          this.variable_types.push(elem180);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      case 4:
      if (ftype == Thrift.Type.LIST) {
        var _size181 = 0;
        var _rtmp3185;
        this.variable_names = [];
        var _etype184 = 0;
        _rtmp3185 = input.readListBegin();
        _etype184 = _rtmp3185.etype;
        _size181 = _rtmp3185.size;
        for (var _i186 = 0; _i186 < _size181; ++_i186)
        {
          var elem187 = null;
          elem187 = input.readString();
          this.variable_names.push(elem187);
        }
        input.readListEnd();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

CqlPreparedResult.prototype.write = function(output) {
  output.writeStructBegin('CqlPreparedResult');
  if (this.itemId) {
    output.writeFieldBegin('itemId', Thrift.Type.I32, 1);
    output.writeI32(this.itemId);
    output.writeFieldEnd();
  }
  if (this.count) {
    output.writeFieldBegin('count', Thrift.Type.I32, 2);
    output.writeI32(this.count);
    output.writeFieldEnd();
  }
  if (this.variable_types) {
    output.writeFieldBegin('variable_types', Thrift.Type.LIST, 3);
    output.writeListBegin(Thrift.Type.STRING, this.variable_types.length);
    for (var iter188 in this.variable_types)
    {
      if (this.variable_types.hasOwnProperty(iter188))
      {
        iter188 = this.variable_types[iter188];
        output.writeString(iter188);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  if (this.variable_names) {
    output.writeFieldBegin('variable_names', Thrift.Type.LIST, 4);
    output.writeListBegin(Thrift.Type.STRING, this.variable_names.length);
    for (var iter189 in this.variable_names)
    {
      if (this.variable_names.hasOwnProperty(iter189))
      {
        iter189 = this.variable_names[iter189];
        output.writeString(iter189);
      }
    }
    output.writeListEnd();
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

var CfSplit = module.exports.CfSplit = function(args) {
  this.start_token = null;
  this.end_token = null;
  this.row_count = null;
  if (args) {
    if (args.start_token !== undefined) {
      this.start_token = args.start_token;
    }
    if (args.end_token !== undefined) {
      this.end_token = args.end_token;
    }
    if (args.row_count !== undefined) {
      this.row_count = args.row_count;
    }
  }
};
CfSplit.prototype = {};
CfSplit.prototype.read = function(input) {
  input.readStructBegin();
  while (true)
  {
    var ret = input.readFieldBegin();
    var fname = ret.fname;
    var ftype = ret.ftype;
    var fid = ret.fid;
    if (ftype == Thrift.Type.STOP) {
      break;
    }
    switch (fid)
    {
      case 1:
      if (ftype == Thrift.Type.STRING) {
        this.start_token = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 2:
      if (ftype == Thrift.Type.STRING) {
        this.end_token = input.readString();
      } else {
        input.skip(ftype);
      }
      break;
      case 3:
      if (ftype == Thrift.Type.I64) {
        this.row_count = input.readI64();
      } else {
        input.skip(ftype);
      }
      break;
      default:
        input.skip(ftype);
    }
    input.readFieldEnd();
  }
  input.readStructEnd();
  return;
};

CfSplit.prototype.write = function(output) {
  output.writeStructBegin('CfSplit');
  if (this.start_token) {
    output.writeFieldBegin('start_token', Thrift.Type.STRING, 1);
    output.writeString(this.start_token);
    output.writeFieldEnd();
  }
  if (this.end_token) {
    output.writeFieldBegin('end_token', Thrift.Type.STRING, 2);
    output.writeString(this.end_token);
    output.writeFieldEnd();
  }
  if (this.row_count) {
    output.writeFieldBegin('row_count', Thrift.Type.I64, 3);
    output.writeI64(this.row_count);
    output.writeFieldEnd();
  }
  output.writeFieldStop();
  output.writeStructEnd();
  return;
};

