text: //
  // Autogenerated by Thrift Compiler (0.9.0)
  //
  // DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
  //
  
  
  //HELPER FUNCTIONS AND STRUCTURES
  
  Blur_listInstalledCommands_args = function(args) {
  };
  Blur_listInstalledCommands_args.prototype = {};
  Blur_listInstalledCommands_args.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;
  };
  
  Blur_listInstalledCommands_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_listInstalledCommands_args');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_listInstalledCommands_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_listInstalledCommands_result.prototype = {};
  Blur_listInstalledCommands_result.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 0:
        if (ftype == Thrift.Type.LIST) {
          var _size310 = 0;
          var _rtmp3314;
          this.success = [];
          var _etype313 = 0;
          _rtmp3314 = input.readListBegin();
          _etype313 = _rtmp3314.etype;
          _size310 = _rtmp3314.size;
          for (var _i315 = 0; _i315 < _size310; ++_i315)
          {
            var elem316 = null;
            elem316 = new CommandDescriptor();
            elem316.read(input);
            this.success.push(elem316);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_listInstalledCommands_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_listInstalledCommands_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.LIST, 0);
      output.writeListBegin(Thrift.Type.STRUCT, this.success.length);
      for (var iter317 in this.success)
      {
        if (this.success.hasOwnProperty(iter317))
        {
          iter317 = this.success[iter317];
          iter317.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_execute_args = function(args) {
    this.commandName = null;
    this.arguments = null;
    if (args) {
      if (args.commandName !== undefined) {
        this.commandName = args.commandName;
      }
      if (args.arguments !== undefined) {
        this.arguments = args.arguments;
      }
    }
  };
  Blur_execute_args.prototype = {};
  Blur_execute_args.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.commandName = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRUCT) {
          this.arguments = new Arguments();
          this.arguments.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_execute_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_execute_args');
    if (this.commandName !== null && this.commandName !== undefined) {
      output.writeFieldBegin('commandName', Thrift.Type.STRING, 1);
      output.writeString(this.commandName);
      output.writeFieldEnd();
    }
    if (this.arguments !== null && this.arguments !== undefined) {
      output.writeFieldBegin('arguments', Thrift.Type.STRUCT, 2);
      this.arguments.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_execute_result = function(args) {
    this.success = null;
    this.bex = null;
    this.tex = null;
    if (args instanceof BlurException) {
      this.bex = args;
      return;
    }
    if (args instanceof TimeoutException) {
      this.tex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.bex !== undefined) {
        this.bex = args.bex;
      }
      if (args.tex !== undefined) {
        this.tex = args.tex;
      }
    }
  };
  Blur_execute_result.prototype = {};
  Blur_execute_result.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 0:
        if (ftype == Thrift.Type.STRUCT) {
          this.success = new Response();
          this.success.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.bex = new BlurException();
          this.bex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRUCT) {
          this.tex = new TimeoutException();
          this.tex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_execute_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_execute_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
      this.success.write(output);
      output.writeFieldEnd();
    }
    if (this.bex !== null && this.bex !== undefined) {
      output.writeFieldBegin('bex', Thrift.Type.STRUCT, 1);
      this.bex.write(output);
      output.writeFieldEnd();
    }
    if (this.tex !== null && this.tex !== undefined) {
      output.writeFieldBegin('tex', Thrift.Type.STRUCT, 2);
      this.tex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_reconnect_args = function(args) {
    this.instanceExecutionId = null;
    if (args) {
      if (args.instanceExecutionId !== undefined) {
        this.instanceExecutionId = args.instanceExecutionId;
      }
    }
  };
  Blur_reconnect_args.prototype = {};
  Blur_reconnect_args.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.instanceExecutionId = input.readI64().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_reconnect_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_reconnect_args');
    if (this.instanceExecutionId !== null && this.instanceExecutionId !== undefined) {
      output.writeFieldBegin('instanceExecutionId', Thrift.Type.I64, 1);
      output.writeI64(this.instanceExecutionId);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_reconnect_result = function(args) {
    this.success = null;
    this.bex = null;
    this.tex = null;
    if (args instanceof BlurException) {
      this.bex = args;
      return;
    }
    if (args instanceof TimeoutException) {
      this.tex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.bex !== undefined) {
        this.bex = args.bex;
      }
      if (args.tex !== undefined) {
        this.tex = args.tex;
      }
    }
  };
  Blur_reconnect_result.prototype = {};
  Blur_reconnect_result.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 0:
        if (ftype == Thrift.Type.STRUCT) {
          this.success = new Response();
          this.success.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.bex = new BlurException();
          this.bex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRUCT) {
          this.tex = new TimeoutException();
          this.tex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_reconnect_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_reconnect_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
      this.success.write(output);
      output.writeFieldEnd();
    }
    if (this.bex !== null && this.bex !== undefined) {
      output.writeFieldBegin('bex', Thrift.Type.STRUCT, 1);
      this.bex.write(output);
      output.writeFieldEnd();
    }
    if (this.tex !== null && this.tex !== undefined) {
      output.writeFieldBegin('tex', Thrift.Type.STRUCT, 2);
      this.tex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_commandStatusList_args = function(args) {
    this.startingAt = null;
    this.fetch = null;
    if (args) {
      if (args.startingAt !== undefined) {
        this.startingAt = args.startingAt;
      }
      if (args.fetch !== undefined) {
        this.fetch = args.fetch;
      }
    }
  };
  Blur_commandStatusList_args.prototype = {};
  Blur_commandStatusList_args.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.startingAt = input.readI32().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.I16) {
          this.fetch = input.readI16().value;
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_commandStatusList_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_commandStatusList_args');
    if (this.startingAt !== null && this.startingAt !== undefined) {
      output.writeFieldBegin('startingAt', Thrift.Type.I32, 1);
      output.writeI32(this.startingAt);
      output.writeFieldEnd();
    }
    if (this.fetch !== null && this.fetch !== undefined) {
      output.writeFieldBegin('fetch', Thrift.Type.I16, 2);
      output.writeI16(this.fetch);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_commandStatusList_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_commandStatusList_result.prototype = {};
  Blur_commandStatusList_result.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 0:
        if (ftype == Thrift.Type.LIST) {
          var _size318 = 0;
          var _rtmp3322;
          this.success = [];
          var _etype321 = 0;
          _rtmp3322 = input.readListBegin();
          _etype321 = _rtmp3322.etype;
          _size318 = _rtmp3322.size;
          for (var _i323 = 0; _i323 < _size318; ++_i323)
          {
            var elem324 = null;
            elem324 = input.readString().value;
            this.success.push(elem324);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_commandStatusList_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_commandStatusList_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.LIST, 0);
      output.writeListBegin(Thrift.Type.STRING, this.success.length);
      for (var iter325 in this.success)
      {
        if (this.success.hasOwnProperty(iter325))
        {
          iter325 = this.success[iter325];
          output.writeString(iter325);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_commandStatus_args = function(args) {
    this.commandExecutionId = null;
    if (args) {
      if (args.commandExecutionId !== undefined) {
        this.commandExecutionId = args.commandExecutionId;
      }
    }
  };
  Blur_commandStatus_args.prototype = {};
  Blur_commandStatus_args.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.commandExecutionId = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_commandStatus_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_commandStatus_args');
    if (this.commandExecutionId !== null && this.commandExecutionId !== undefined) {
      output.writeFieldBegin('commandExecutionId', Thrift.Type.STRING, 1);
      output.writeString(this.commandExecutionId);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_commandStatus_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_commandStatus_result.prototype = {};
  Blur_commandStatus_result.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 0:
        if (ftype == Thrift.Type.STRUCT) {
          this.success = new CommandStatus();
          this.success.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_commandStatus_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_commandStatus_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
      this.success.write(output);
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_commandCancel_args = function(args) {
    this.commandExecutionId = null;
    if (args) {
      if (args.commandExecutionId !== undefined) {
        this.commandExecutionId = args.commandExecutionId;
      }
    }
  };
  Blur_commandCancel_args.prototype = {};
  Blur_commandCancel_args.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.commandExecutionId = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_commandCancel_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_commandCancel_args');
    if (this.commandExecutionId !== null && this.commandExecutionId !== undefined) {
      output.writeFieldBegin('commandExecutionId', Thrift.Type.STRING, 1);
      output.writeString(this.commandExecutionId);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_commandCancel_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_commandCancel_result.prototype = {};
  Blur_commandCancel_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_commandCancel_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_commandCancel_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_refresh_args = function(args) {
  };
  Blur_refresh_args.prototype = {};
  Blur_refresh_args.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;
  };
  
  Blur_refresh_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_refresh_args');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_refresh_result = function(args) {
  };
  Blur_refresh_result.prototype = {};
  Blur_refresh_result.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;
  };
  
  Blur_refresh_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_refresh_result');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_createTable_args = function(args) {
    this.tableDescriptor = null;
    if (args) {
      if (args.tableDescriptor !== undefined) {
        this.tableDescriptor = args.tableDescriptor;
      }
    }
  };
  Blur_createTable_args.prototype = {};
  Blur_createTable_args.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.tableDescriptor = new TableDescriptor();
          this.tableDescriptor.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_createTable_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_createTable_args');
    if (this.tableDescriptor !== null && this.tableDescriptor !== undefined) {
      output.writeFieldBegin('tableDescriptor', Thrift.Type.STRUCT, 1);
      this.tableDescriptor.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_createTable_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_createTable_result.prototype = {};
  Blur_createTable_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_createTable_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_createTable_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_enableTable_args = function(args) {
    this.table = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
    }
  };
  Blur_enableTable_args.prototype = {};
  Blur_enableTable_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_enableTable_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_enableTable_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_enableTable_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_enableTable_result.prototype = {};
  Blur_enableTable_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_enableTable_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_enableTable_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_disableTable_args = function(args) {
    this.table = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
    }
  };
  Blur_disableTable_args.prototype = {};
  Blur_disableTable_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_disableTable_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_disableTable_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_disableTable_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_disableTable_result.prototype = {};
  Blur_disableTable_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_disableTable_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_disableTable_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_removeTable_args = function(args) {
    this.table = null;
    this.deleteIndexFiles = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.deleteIndexFiles !== undefined) {
        this.deleteIndexFiles = args.deleteIndexFiles;
      }
    }
  };
  Blur_removeTable_args.prototype = {};
  Blur_removeTable_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.BOOL) {
          this.deleteIndexFiles = input.readBool().value;
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_removeTable_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_removeTable_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.deleteIndexFiles !== null && this.deleteIndexFiles !== undefined) {
      output.writeFieldBegin('deleteIndexFiles', Thrift.Type.BOOL, 2);
      output.writeBool(this.deleteIndexFiles);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_removeTable_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_removeTable_result.prototype = {};
  Blur_removeTable_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_removeTable_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_removeTable_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_addColumnDefinition_args = function(args) {
    this.table = null;
    this.columnDefinition = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.columnDefinition !== undefined) {
        this.columnDefinition = args.columnDefinition;
      }
    }
  };
  Blur_addColumnDefinition_args.prototype = {};
  Blur_addColumnDefinition_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRUCT) {
          this.columnDefinition = new ColumnDefinition();
          this.columnDefinition.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_addColumnDefinition_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_addColumnDefinition_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.columnDefinition !== null && this.columnDefinition !== undefined) {
      output.writeFieldBegin('columnDefinition', Thrift.Type.STRUCT, 2);
      this.columnDefinition.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_addColumnDefinition_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_addColumnDefinition_result.prototype = {};
  Blur_addColumnDefinition_result.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 0:
        if (ftype == Thrift.Type.BOOL) {
          this.success = input.readBool().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_addColumnDefinition_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_addColumnDefinition_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.BOOL, 0);
      output.writeBool(this.success);
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_tableList_args = function(args) {
  };
  Blur_tableList_args.prototype = {};
  Blur_tableList_args.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;
  };
  
  Blur_tableList_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_tableList_args');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_tableList_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_tableList_result.prototype = {};
  Blur_tableList_result.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 0:
        if (ftype == Thrift.Type.LIST) {
          var _size326 = 0;
          var _rtmp3330;
          this.success = [];
          var _etype329 = 0;
          _rtmp3330 = input.readListBegin();
          _etype329 = _rtmp3330.etype;
          _size326 = _rtmp3330.size;
          for (var _i331 = 0; _i331 < _size326; ++_i331)
          {
            var elem332 = null;
            elem332 = input.readString().value;
            this.success.push(elem332);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_tableList_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_tableList_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.LIST, 0);
      output.writeListBegin(Thrift.Type.STRING, this.success.length);
      for (var iter333 in this.success)
      {
        if (this.success.hasOwnProperty(iter333))
        {
          iter333 = this.success[iter333];
          output.writeString(iter333);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_tableListByCluster_args = function(args) {
    this.cluster = null;
    if (args) {
      if (args.cluster !== undefined) {
        this.cluster = args.cluster;
      }
    }
  };
  Blur_tableListByCluster_args.prototype = {};
  Blur_tableListByCluster_args.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.cluster = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_tableListByCluster_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_tableListByCluster_args');
    if (this.cluster !== null && this.cluster !== undefined) {
      output.writeFieldBegin('cluster', Thrift.Type.STRING, 1);
      output.writeString(this.cluster);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_tableListByCluster_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_tableListByCluster_result.prototype = {};
  Blur_tableListByCluster_result.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 0:
        if (ftype == Thrift.Type.LIST) {
          var _size334 = 0;
          var _rtmp3338;
          this.success = [];
          var _etype337 = 0;
          _rtmp3338 = input.readListBegin();
          _etype337 = _rtmp3338.etype;
          _size334 = _rtmp3338.size;
          for (var _i339 = 0; _i339 < _size334; ++_i339)
          {
            var elem340 = null;
            elem340 = input.readString().value;
            this.success.push(elem340);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_tableListByCluster_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_tableListByCluster_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.LIST, 0);
      output.writeListBegin(Thrift.Type.STRING, this.success.length);
      for (var iter341 in this.success)
      {
        if (this.success.hasOwnProperty(iter341))
        {
          iter341 = this.success[iter341];
          output.writeString(iter341);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_describe_args = function(args) {
    this.table = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
    }
  };
  Blur_describe_args.prototype = {};
  Blur_describe_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_describe_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_describe_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_describe_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_describe_result.prototype = {};
  Blur_describe_result.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 0:
        if (ftype == Thrift.Type.STRUCT) {
          this.success = new TableDescriptor();
          this.success.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_describe_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_describe_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
      this.success.write(output);
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_schema_args = function(args) {
    this.table = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
    }
  };
  Blur_schema_args.prototype = {};
  Blur_schema_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_schema_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_schema_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_schema_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_schema_result.prototype = {};
  Blur_schema_result.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 0:
        if (ftype == Thrift.Type.STRUCT) {
          this.success = new Schema();
          this.success.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_schema_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_schema_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
      this.success.write(output);
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_parseQuery_args = function(args) {
    this.table = null;
    this.query = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.query !== undefined) {
        this.query = args.query;
      }
    }
  };
  Blur_parseQuery_args.prototype = {};
  Blur_parseQuery_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRUCT) {
          this.query = new Query();
          this.query.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_parseQuery_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_parseQuery_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.query !== null && this.query !== undefined) {
      output.writeFieldBegin('query', Thrift.Type.STRUCT, 2);
      this.query.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_parseQuery_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_parseQuery_result.prototype = {};
  Blur_parseQuery_result.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 0:
        if (ftype == Thrift.Type.STRING) {
          this.success = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_parseQuery_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_parseQuery_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRING, 0);
      output.writeString(this.success);
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_tableStats_args = function(args) {
    this.table = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
    }
  };
  Blur_tableStats_args.prototype = {};
  Blur_tableStats_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_tableStats_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_tableStats_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_tableStats_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_tableStats_result.prototype = {};
  Blur_tableStats_result.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 0:
        if (ftype == Thrift.Type.STRUCT) {
          this.success = new TableStats();
          this.success.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_tableStats_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_tableStats_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
      this.success.write(output);
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_optimize_args = function(args) {
    this.table = null;
    this.numberOfSegmentsPerShard = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.numberOfSegmentsPerShard !== undefined) {
        this.numberOfSegmentsPerShard = args.numberOfSegmentsPerShard;
      }
    }
  };
  Blur_optimize_args.prototype = {};
  Blur_optimize_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.I32) {
          this.numberOfSegmentsPerShard = input.readI32().value;
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_optimize_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_optimize_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.numberOfSegmentsPerShard !== null && this.numberOfSegmentsPerShard !== undefined) {
      output.writeFieldBegin('numberOfSegmentsPerShard', Thrift.Type.I32, 2);
      output.writeI32(this.numberOfSegmentsPerShard);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_optimize_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_optimize_result.prototype = {};
  Blur_optimize_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_optimize_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_optimize_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_createSnapshot_args = function(args) {
    this.table = null;
    this.name = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.name !== undefined) {
        this.name = args.name;
      }
    }
  };
  Blur_createSnapshot_args.prototype = {};
  Blur_createSnapshot_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.name = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_createSnapshot_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_createSnapshot_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.name !== null && this.name !== undefined) {
      output.writeFieldBegin('name', Thrift.Type.STRING, 2);
      output.writeString(this.name);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_createSnapshot_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_createSnapshot_result.prototype = {};
  Blur_createSnapshot_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_createSnapshot_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_createSnapshot_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_removeSnapshot_args = function(args) {
    this.table = null;
    this.name = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.name !== undefined) {
        this.name = args.name;
      }
    }
  };
  Blur_removeSnapshot_args.prototype = {};
  Blur_removeSnapshot_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.name = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_removeSnapshot_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_removeSnapshot_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.name !== null && this.name !== undefined) {
      output.writeFieldBegin('name', Thrift.Type.STRING, 2);
      output.writeString(this.name);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_removeSnapshot_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_removeSnapshot_result.prototype = {};
  Blur_removeSnapshot_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_removeSnapshot_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_removeSnapshot_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_listSnapshots_args = function(args) {
    this.table = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
    }
  };
  Blur_listSnapshots_args.prototype = {};
  Blur_listSnapshots_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_listSnapshots_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_listSnapshots_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_listSnapshots_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_listSnapshots_result.prototype = {};
  Blur_listSnapshots_result.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 0:
        if (ftype == Thrift.Type.MAP) {
          var _size342 = 0;
          var _rtmp3346;
          this.success = {};
          var _ktype343 = 0;
          var _vtype344 = 0;
          _rtmp3346 = input.readMapBegin();
          _ktype343 = _rtmp3346.ktype;
          _vtype344 = _rtmp3346.vtype;
          _size342 = _rtmp3346.size;
          for (var _i347 = 0; _i347 < _size342; ++_i347)
          {
            if (_i347 > 0 ) {
              if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
                input.rstack.pop();
              }
            }
            var key348 = null;
            var val349 = null;
            key348 = input.readString().value;
            var _size350 = 0;
            var _rtmp3354;
            val349 = [];
            var _etype353 = 0;
            _rtmp3354 = input.readListBegin();
            _etype353 = _rtmp3354.etype;
            _size350 = _rtmp3354.size;
            for (var _i355 = 0; _i355 < _size350; ++_i355)
            {
              var elem356 = null;
              elem356 = input.readString().value;
              val349.push(elem356);
            }
            input.readListEnd();
            this.success[key348] = val349;
          }
          input.readMapEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_listSnapshots_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_listSnapshots_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.MAP, 0);
      output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.LIST, Thrift.objectLength(this.success));
      for (var kiter357 in this.success)
      {
        if (this.success.hasOwnProperty(kiter357))
        {
          var viter358 = this.success[kiter357];
          output.writeString(kiter357);
          output.writeListBegin(Thrift.Type.STRING, viter358.length);
          for (var iter359 in viter358)
          {
            if (viter358.hasOwnProperty(iter359))
            {
              iter359 = viter358[iter359];
              output.writeString(iter359);
            }
          }
          output.writeListEnd();
        }
      }
      output.writeMapEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_setUser_args = function(args) {
    this.user = null;
    if (args) {
      if (args.user !== undefined) {
        this.user = args.user;
      }
    }
  };
  Blur_setUser_args.prototype = {};
  Blur_setUser_args.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.user = new User();
          this.user.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_setUser_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_setUser_args');
    if (this.user !== null && this.user !== undefined) {
      output.writeFieldBegin('user', Thrift.Type.STRUCT, 1);
      this.user.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_setUser_result = function(args) {
  };
  Blur_setUser_result.prototype = {};
  Blur_setUser_result.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;
  };
  
  Blur_setUser_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_setUser_result');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_query_args = function(args) {
    this.table = null;
    this.blurQuery = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.blurQuery !== undefined) {
        this.blurQuery = args.blurQuery;
      }
    }
  };
  Blur_query_args.prototype = {};
  Blur_query_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRUCT) {
          this.blurQuery = new BlurQuery();
          this.blurQuery.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_query_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_query_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.blurQuery !== null && this.blurQuery !== undefined) {
      output.writeFieldBegin('blurQuery', Thrift.Type.STRUCT, 2);
      this.blurQuery.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_query_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_query_result.prototype = {};
  Blur_query_result.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 0:
        if (ftype == Thrift.Type.STRUCT) {
          this.success = new BlurResults();
          this.success.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_query_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_query_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
      this.success.write(output);
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_fetchRow_args = function(args) {
    this.table = null;
    this.selector = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.selector !== undefined) {
        this.selector = args.selector;
      }
    }
  };
  Blur_fetchRow_args.prototype = {};
  Blur_fetchRow_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRUCT) {
          this.selector = new Selector();
          this.selector.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_fetchRow_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_fetchRow_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.selector !== null && this.selector !== undefined) {
      output.writeFieldBegin('selector', Thrift.Type.STRUCT, 2);
      this.selector.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_fetchRow_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_fetchRow_result.prototype = {};
  Blur_fetchRow_result.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 0:
        if (ftype == Thrift.Type.STRUCT) {
          this.success = new FetchResult();
          this.success.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_fetchRow_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_fetchRow_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
      this.success.write(output);
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_fetchRowBatch_args = function(args) {
    this.table = null;
    this.selectors = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.selectors !== undefined) {
        this.selectors = args.selectors;
      }
    }
  };
  Blur_fetchRowBatch_args.prototype = {};
  Blur_fetchRowBatch_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.LIST) {
          var _size360 = 0;
          var _rtmp3364;
          this.selectors = [];
          var _etype363 = 0;
          _rtmp3364 = input.readListBegin();
          _etype363 = _rtmp3364.etype;
          _size360 = _rtmp3364.size;
          for (var _i365 = 0; _i365 < _size360; ++_i365)
          {
            var elem366 = null;
            elem366 = new Selector();
            elem366.read(input);
            this.selectors.push(elem366);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_fetchRowBatch_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_fetchRowBatch_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.selectors !== null && this.selectors !== undefined) {
      output.writeFieldBegin('selectors', Thrift.Type.LIST, 2);
      output.writeListBegin(Thrift.Type.STRUCT, this.selectors.length);
      for (var iter367 in this.selectors)
      {
        if (this.selectors.hasOwnProperty(iter367))
        {
          iter367 = this.selectors[iter367];
          iter367.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_fetchRowBatch_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_fetchRowBatch_result.prototype = {};
  Blur_fetchRowBatch_result.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 0:
        if (ftype == Thrift.Type.LIST) {
          var _size368 = 0;
          var _rtmp3372;
          this.success = [];
          var _etype371 = 0;
          _rtmp3372 = input.readListBegin();
          _etype371 = _rtmp3372.etype;
          _size368 = _rtmp3372.size;
          for (var _i373 = 0; _i373 < _size368; ++_i373)
          {
            var elem374 = null;
            elem374 = new FetchResult();
            elem374.read(input);
            this.success.push(elem374);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_fetchRowBatch_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_fetchRowBatch_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.LIST, 0);
      output.writeListBegin(Thrift.Type.STRUCT, this.success.length);
      for (var iter375 in this.success)
      {
        if (this.success.hasOwnProperty(iter375))
        {
          iter375 = this.success[iter375];
          iter375.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_loadData_args = function(args) {
    this.table = null;
    this.location = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.location !== undefined) {
        this.location = args.location;
      }
    }
  };
  Blur_loadData_args.prototype = {};
  Blur_loadData_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.location = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_loadData_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_loadData_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.location !== null && this.location !== undefined) {
      output.writeFieldBegin('location', Thrift.Type.STRING, 2);
      output.writeString(this.location);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_loadData_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_loadData_result.prototype = {};
  Blur_loadData_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_loadData_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_loadData_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_validateIndex_args = function(args) {
    this.table = null;
    this.externalIndexPaths = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.externalIndexPaths !== undefined) {
        this.externalIndexPaths = args.externalIndexPaths;
      }
    }
  };
  Blur_validateIndex_args.prototype = {};
  Blur_validateIndex_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.LIST) {
          var _size376 = 0;
          var _rtmp3380;
          this.externalIndexPaths = [];
          var _etype379 = 0;
          _rtmp3380 = input.readListBegin();
          _etype379 = _rtmp3380.etype;
          _size376 = _rtmp3380.size;
          for (var _i381 = 0; _i381 < _size376; ++_i381)
          {
            var elem382 = null;
            elem382 = input.readString().value;
            this.externalIndexPaths.push(elem382);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_validateIndex_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_validateIndex_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.externalIndexPaths !== null && this.externalIndexPaths !== undefined) {
      output.writeFieldBegin('externalIndexPaths', Thrift.Type.LIST, 2);
      output.writeListBegin(Thrift.Type.STRING, this.externalIndexPaths.length);
      for (var iter383 in this.externalIndexPaths)
      {
        if (this.externalIndexPaths.hasOwnProperty(iter383))
        {
          iter383 = this.externalIndexPaths[iter383];
          output.writeString(iter383);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_validateIndex_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_validateIndex_result.prototype = {};
  Blur_validateIndex_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_validateIndex_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_validateIndex_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_loadIndex_args = function(args) {
    this.table = null;
    this.externalIndexPaths = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.externalIndexPaths !== undefined) {
        this.externalIndexPaths = args.externalIndexPaths;
      }
    }
  };
  Blur_loadIndex_args.prototype = {};
  Blur_loadIndex_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.LIST) {
          var _size384 = 0;
          var _rtmp3388;
          this.externalIndexPaths = [];
          var _etype387 = 0;
          _rtmp3388 = input.readListBegin();
          _etype387 = _rtmp3388.etype;
          _size384 = _rtmp3388.size;
          for (var _i389 = 0; _i389 < _size384; ++_i389)
          {
            var elem390 = null;
            elem390 = input.readString().value;
            this.externalIndexPaths.push(elem390);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_loadIndex_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_loadIndex_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.externalIndexPaths !== null && this.externalIndexPaths !== undefined) {
      output.writeFieldBegin('externalIndexPaths', Thrift.Type.LIST, 2);
      output.writeListBegin(Thrift.Type.STRING, this.externalIndexPaths.length);
      for (var iter391 in this.externalIndexPaths)
      {
        if (this.externalIndexPaths.hasOwnProperty(iter391))
        {
          iter391 = this.externalIndexPaths[iter391];
          output.writeString(iter391);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_loadIndex_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_loadIndex_result.prototype = {};
  Blur_loadIndex_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_loadIndex_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_loadIndex_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_mutate_args = function(args) {
    this.mutation = null;
    if (args) {
      if (args.mutation !== undefined) {
        this.mutation = args.mutation;
      }
    }
  };
  Blur_mutate_args.prototype = {};
  Blur_mutate_args.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.mutation = new RowMutation();
          this.mutation.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_mutate_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_mutate_args');
    if (this.mutation !== null && this.mutation !== undefined) {
      output.writeFieldBegin('mutation', Thrift.Type.STRUCT, 1);
      this.mutation.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_mutate_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_mutate_result.prototype = {};
  Blur_mutate_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_mutate_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_mutate_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_enqueueMutate_args = function(args) {
    this.mutation = null;
    if (args) {
      if (args.mutation !== undefined) {
        this.mutation = args.mutation;
      }
    }
  };
  Blur_enqueueMutate_args.prototype = {};
  Blur_enqueueMutate_args.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.mutation = new RowMutation();
          this.mutation.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_enqueueMutate_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_enqueueMutate_args');
    if (this.mutation !== null && this.mutation !== undefined) {
      output.writeFieldBegin('mutation', Thrift.Type.STRUCT, 1);
      this.mutation.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_enqueueMutate_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_enqueueMutate_result.prototype = {};
  Blur_enqueueMutate_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_enqueueMutate_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_enqueueMutate_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_mutateBatch_args = function(args) {
    this.mutations = null;
    if (args) {
      if (args.mutations !== undefined) {
        this.mutations = args.mutations;
      }
    }
  };
  Blur_mutateBatch_args.prototype = {};
  Blur_mutateBatch_args.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 _size392 = 0;
          var _rtmp3396;
          this.mutations = [];
          var _etype395 = 0;
          _rtmp3396 = input.readListBegin();
          _etype395 = _rtmp3396.etype;
          _size392 = _rtmp3396.size;
          for (var _i397 = 0; _i397 < _size392; ++_i397)
          {
            var elem398 = null;
            elem398 = new RowMutation();
            elem398.read(input);
            this.mutations.push(elem398);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_mutateBatch_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_mutateBatch_args');
    if (this.mutations !== null && this.mutations !== undefined) {
      output.writeFieldBegin('mutations', Thrift.Type.LIST, 1);
      output.writeListBegin(Thrift.Type.STRUCT, this.mutations.length);
      for (var iter399 in this.mutations)
      {
        if (this.mutations.hasOwnProperty(iter399))
        {
          iter399 = this.mutations[iter399];
          iter399.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_mutateBatch_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_mutateBatch_result.prototype = {};
  Blur_mutateBatch_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_mutateBatch_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_mutateBatch_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_enqueueMutateBatch_args = function(args) {
    this.mutations = null;
    if (args) {
      if (args.mutations !== undefined) {
        this.mutations = args.mutations;
      }
    }
  };
  Blur_enqueueMutateBatch_args.prototype = {};
  Blur_enqueueMutateBatch_args.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 _size400 = 0;
          var _rtmp3404;
          this.mutations = [];
          var _etype403 = 0;
          _rtmp3404 = input.readListBegin();
          _etype403 = _rtmp3404.etype;
          _size400 = _rtmp3404.size;
          for (var _i405 = 0; _i405 < _size400; ++_i405)
          {
            var elem406 = null;
            elem406 = new RowMutation();
            elem406.read(input);
            this.mutations.push(elem406);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_enqueueMutateBatch_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_enqueueMutateBatch_args');
    if (this.mutations !== null && this.mutations !== undefined) {
      output.writeFieldBegin('mutations', Thrift.Type.LIST, 1);
      output.writeListBegin(Thrift.Type.STRUCT, this.mutations.length);
      for (var iter407 in this.mutations)
      {
        if (this.mutations.hasOwnProperty(iter407))
        {
          iter407 = this.mutations[iter407];
          iter407.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_enqueueMutateBatch_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_enqueueMutateBatch_result.prototype = {};
  Blur_enqueueMutateBatch_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_enqueueMutateBatch_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_enqueueMutateBatch_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_bulkMutateStart_args = function(args) {
    this.bulkId = null;
    if (args) {
      if (args.bulkId !== undefined) {
        this.bulkId = args.bulkId;
      }
    }
  };
  Blur_bulkMutateStart_args.prototype = {};
  Blur_bulkMutateStart_args.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.bulkId = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_bulkMutateStart_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_bulkMutateStart_args');
    if (this.bulkId !== null && this.bulkId !== undefined) {
      output.writeFieldBegin('bulkId', Thrift.Type.STRING, 1);
      output.writeString(this.bulkId);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_bulkMutateStart_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_bulkMutateStart_result.prototype = {};
  Blur_bulkMutateStart_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_bulkMutateStart_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_bulkMutateStart_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_bulkMutateAdd_args = function(args) {
    this.bulkId = null;
    this.rowMutation = null;
    if (args) {
      if (args.bulkId !== undefined) {
        this.bulkId = args.bulkId;
      }
      if (args.rowMutation !== undefined) {
        this.rowMutation = args.rowMutation;
      }
    }
  };
  Blur_bulkMutateAdd_args.prototype = {};
  Blur_bulkMutateAdd_args.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.bulkId = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRUCT) {
          this.rowMutation = new RowMutation();
          this.rowMutation.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_bulkMutateAdd_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_bulkMutateAdd_args');
    if (this.bulkId !== null && this.bulkId !== undefined) {
      output.writeFieldBegin('bulkId', Thrift.Type.STRING, 1);
      output.writeString(this.bulkId);
      output.writeFieldEnd();
    }
    if (this.rowMutation !== null && this.rowMutation !== undefined) {
      output.writeFieldBegin('rowMutation', Thrift.Type.STRUCT, 2);
      this.rowMutation.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_bulkMutateAdd_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_bulkMutateAdd_result.prototype = {};
  Blur_bulkMutateAdd_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_bulkMutateAdd_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_bulkMutateAdd_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_bulkMutateAddMultiple_args = function(args) {
    this.bulkId = null;
    this.rowMutations = null;
    if (args) {
      if (args.bulkId !== undefined) {
        this.bulkId = args.bulkId;
      }
      if (args.rowMutations !== undefined) {
        this.rowMutations = args.rowMutations;
      }
    }
  };
  Blur_bulkMutateAddMultiple_args.prototype = {};
  Blur_bulkMutateAddMultiple_args.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.bulkId = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.LIST) {
          var _size408 = 0;
          var _rtmp3412;
          this.rowMutations = [];
          var _etype411 = 0;
          _rtmp3412 = input.readListBegin();
          _etype411 = _rtmp3412.etype;
          _size408 = _rtmp3412.size;
          for (var _i413 = 0; _i413 < _size408; ++_i413)
          {
            var elem414 = null;
            elem414 = new RowMutation();
            elem414.read(input);
            this.rowMutations.push(elem414);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_bulkMutateAddMultiple_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_bulkMutateAddMultiple_args');
    if (this.bulkId !== null && this.bulkId !== undefined) {
      output.writeFieldBegin('bulkId', Thrift.Type.STRING, 1);
      output.writeString(this.bulkId);
      output.writeFieldEnd();
    }
    if (this.rowMutations !== null && this.rowMutations !== undefined) {
      output.writeFieldBegin('rowMutations', Thrift.Type.LIST, 2);
      output.writeListBegin(Thrift.Type.STRUCT, this.rowMutations.length);
      for (var iter415 in this.rowMutations)
      {
        if (this.rowMutations.hasOwnProperty(iter415))
        {
          iter415 = this.rowMutations[iter415];
          iter415.write(output);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_bulkMutateAddMultiple_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_bulkMutateAddMultiple_result.prototype = {};
  Blur_bulkMutateAddMultiple_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_bulkMutateAddMultiple_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_bulkMutateAddMultiple_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_bulkMutateFinish_args = function(args) {
    this.bulkId = null;
    this.apply = null;
    this.blockUntilComplete = null;
    if (args) {
      if (args.bulkId !== undefined) {
        this.bulkId = args.bulkId;
      }
      if (args.apply !== undefined) {
        this.apply = args.apply;
      }
      if (args.blockUntilComplete !== undefined) {
        this.blockUntilComplete = args.blockUntilComplete;
      }
    }
  };
  Blur_bulkMutateFinish_args.prototype = {};
  Blur_bulkMutateFinish_args.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.bulkId = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.BOOL) {
          this.apply = input.readBool().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.BOOL) {
          this.blockUntilComplete = input.readBool().value;
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_bulkMutateFinish_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_bulkMutateFinish_args');
    if (this.bulkId !== null && this.bulkId !== undefined) {
      output.writeFieldBegin('bulkId', Thrift.Type.STRING, 1);
      output.writeString(this.bulkId);
      output.writeFieldEnd();
    }
    if (this.apply !== null && this.apply !== undefined) {
      output.writeFieldBegin('apply', Thrift.Type.BOOL, 2);
      output.writeBool(this.apply);
      output.writeFieldEnd();
    }
    if (this.blockUntilComplete !== null && this.blockUntilComplete !== undefined) {
      output.writeFieldBegin('blockUntilComplete', Thrift.Type.BOOL, 3);
      output.writeBool(this.blockUntilComplete);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_bulkMutateFinish_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_bulkMutateFinish_result.prototype = {};
  Blur_bulkMutateFinish_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_bulkMutateFinish_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_bulkMutateFinish_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_cancelQuery_args = function(args) {
    this.table = null;
    this.uuid = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.uuid !== undefined) {
        this.uuid = args.uuid;
      }
    }
  };
  Blur_cancelQuery_args.prototype = {};
  Blur_cancelQuery_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.uuid = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_cancelQuery_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_cancelQuery_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.uuid !== null && this.uuid !== undefined) {
      output.writeFieldBegin('uuid', Thrift.Type.STRING, 2);
      output.writeString(this.uuid);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_cancelQuery_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_cancelQuery_result.prototype = {};
  Blur_cancelQuery_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_cancelQuery_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_cancelQuery_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_queryStatusIdList_args = function(args) {
    this.table = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
    }
  };
  Blur_queryStatusIdList_args.prototype = {};
  Blur_queryStatusIdList_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_queryStatusIdList_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_queryStatusIdList_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_queryStatusIdList_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_queryStatusIdList_result.prototype = {};
  Blur_queryStatusIdList_result.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 0:
        if (ftype == Thrift.Type.LIST) {
          var _size416 = 0;
          var _rtmp3420;
          this.success = [];
          var _etype419 = 0;
          _rtmp3420 = input.readListBegin();
          _etype419 = _rtmp3420.etype;
          _size416 = _rtmp3420.size;
          for (var _i421 = 0; _i421 < _size416; ++_i421)
          {
            var elem422 = null;
            elem422 = input.readString().value;
            this.success.push(elem422);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_queryStatusIdList_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_queryStatusIdList_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.LIST, 0);
      output.writeListBegin(Thrift.Type.STRING, this.success.length);
      for (var iter423 in this.success)
      {
        if (this.success.hasOwnProperty(iter423))
        {
          iter423 = this.success[iter423];
          output.writeString(iter423);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_queryStatusById_args = function(args) {
    this.table = null;
    this.uuid = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.uuid !== undefined) {
        this.uuid = args.uuid;
      }
    }
  };
  Blur_queryStatusById_args.prototype = {};
  Blur_queryStatusById_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.uuid = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_queryStatusById_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_queryStatusById_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.uuid !== null && this.uuid !== undefined) {
      output.writeFieldBegin('uuid', Thrift.Type.STRING, 2);
      output.writeString(this.uuid);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_queryStatusById_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_queryStatusById_result.prototype = {};
  Blur_queryStatusById_result.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 0:
        if (ftype == Thrift.Type.STRUCT) {
          this.success = new BlurQueryStatus();
          this.success.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_queryStatusById_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_queryStatusById_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRUCT, 0);
      this.success.write(output);
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_terms_args = function(args) {
    this.table = null;
    this.columnFamily = null;
    this.columnName = null;
    this.startWith = null;
    this.size = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.columnFamily !== undefined) {
        this.columnFamily = args.columnFamily;
      }
      if (args.columnName !== undefined) {
        this.columnName = args.columnName;
      }
      if (args.startWith !== undefined) {
        this.startWith = args.startWith;
      }
      if (args.size !== undefined) {
        this.size = args.size;
      }
    }
  };
  Blur_terms_args.prototype = {};
  Blur_terms_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.columnFamily = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.STRING) {
          this.columnName = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.STRING) {
          this.startWith = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 5:
        if (ftype == Thrift.Type.I16) {
          this.size = input.readI16().value;
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_terms_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_terms_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.columnFamily !== null && this.columnFamily !== undefined) {
      output.writeFieldBegin('columnFamily', Thrift.Type.STRING, 2);
      output.writeString(this.columnFamily);
      output.writeFieldEnd();
    }
    if (this.columnName !== null && this.columnName !== undefined) {
      output.writeFieldBegin('columnName', Thrift.Type.STRING, 3);
      output.writeString(this.columnName);
      output.writeFieldEnd();
    }
    if (this.startWith !== null && this.startWith !== undefined) {
      output.writeFieldBegin('startWith', Thrift.Type.STRING, 4);
      output.writeString(this.startWith);
      output.writeFieldEnd();
    }
    if (this.size !== null && this.size !== undefined) {
      output.writeFieldBegin('size', Thrift.Type.I16, 5);
      output.writeI16(this.size);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_terms_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_terms_result.prototype = {};
  Blur_terms_result.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 0:
        if (ftype == Thrift.Type.LIST) {
          var _size424 = 0;
          var _rtmp3428;
          this.success = [];
          var _etype427 = 0;
          _rtmp3428 = input.readListBegin();
          _etype427 = _rtmp3428.etype;
          _size424 = _rtmp3428.size;
          for (var _i429 = 0; _i429 < _size424; ++_i429)
          {
            var elem430 = null;
            elem430 = input.readString().value;
            this.success.push(elem430);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_terms_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_terms_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.LIST, 0);
      output.writeListBegin(Thrift.Type.STRING, this.success.length);
      for (var iter431 in this.success)
      {
        if (this.success.hasOwnProperty(iter431))
        {
          iter431 = this.success[iter431];
          output.writeString(iter431);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_recordFrequency_args = function(args) {
    this.table = null;
    this.columnFamily = null;
    this.columnName = null;
    this.value = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
      if (args.columnFamily !== undefined) {
        this.columnFamily = args.columnFamily;
      }
      if (args.columnName !== undefined) {
        this.columnName = args.columnName;
      }
      if (args.value !== undefined) {
        this.value = args.value;
      }
    }
  };
  Blur_recordFrequency_args.prototype = {};
  Blur_recordFrequency_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.columnFamily = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 3:
        if (ftype == Thrift.Type.STRING) {
          this.columnName = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 4:
        if (ftype == Thrift.Type.STRING) {
          this.value = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_recordFrequency_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_recordFrequency_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    if (this.columnFamily !== null && this.columnFamily !== undefined) {
      output.writeFieldBegin('columnFamily', Thrift.Type.STRING, 2);
      output.writeString(this.columnFamily);
      output.writeFieldEnd();
    }
    if (this.columnName !== null && this.columnName !== undefined) {
      output.writeFieldBegin('columnName', Thrift.Type.STRING, 3);
      output.writeString(this.columnName);
      output.writeFieldEnd();
    }
    if (this.value !== null && this.value !== undefined) {
      output.writeFieldBegin('value', Thrift.Type.STRING, 4);
      output.writeString(this.value);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_recordFrequency_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_recordFrequency_result.prototype = {};
  Blur_recordFrequency_result.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 0:
        if (ftype == Thrift.Type.I64) {
          this.success = input.readI64().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_recordFrequency_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_recordFrequency_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.I64, 0);
      output.writeI64(this.success);
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_shardClusterList_args = function(args) {
  };
  Blur_shardClusterList_args.prototype = {};
  Blur_shardClusterList_args.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;
  };
  
  Blur_shardClusterList_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_shardClusterList_args');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_shardClusterList_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_shardClusterList_result.prototype = {};
  Blur_shardClusterList_result.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 0:
        if (ftype == Thrift.Type.LIST) {
          var _size432 = 0;
          var _rtmp3436;
          this.success = [];
          var _etype435 = 0;
          _rtmp3436 = input.readListBegin();
          _etype435 = _rtmp3436.etype;
          _size432 = _rtmp3436.size;
          for (var _i437 = 0; _i437 < _size432; ++_i437)
          {
            var elem438 = null;
            elem438 = input.readString().value;
            this.success.push(elem438);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_shardClusterList_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_shardClusterList_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.LIST, 0);
      output.writeListBegin(Thrift.Type.STRING, this.success.length);
      for (var iter439 in this.success)
      {
        if (this.success.hasOwnProperty(iter439))
        {
          iter439 = this.success[iter439];
          output.writeString(iter439);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_shardServerList_args = function(args) {
    this.cluster = null;
    if (args) {
      if (args.cluster !== undefined) {
        this.cluster = args.cluster;
      }
    }
  };
  Blur_shardServerList_args.prototype = {};
  Blur_shardServerList_args.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.cluster = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_shardServerList_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_shardServerList_args');
    if (this.cluster !== null && this.cluster !== undefined) {
      output.writeFieldBegin('cluster', Thrift.Type.STRING, 1);
      output.writeString(this.cluster);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_shardServerList_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_shardServerList_result.prototype = {};
  Blur_shardServerList_result.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 0:
        if (ftype == Thrift.Type.LIST) {
          var _size440 = 0;
          var _rtmp3444;
          this.success = [];
          var _etype443 = 0;
          _rtmp3444 = input.readListBegin();
          _etype443 = _rtmp3444.etype;
          _size440 = _rtmp3444.size;
          for (var _i445 = 0; _i445 < _size440; ++_i445)
          {
            var elem446 = null;
            elem446 = input.readString().value;
            this.success.push(elem446);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_shardServerList_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_shardServerList_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.LIST, 0);
      output.writeListBegin(Thrift.Type.STRING, this.success.length);
      for (var iter447 in this.success)
      {
        if (this.success.hasOwnProperty(iter447))
        {
          iter447 = this.success[iter447];
          output.writeString(iter447);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_controllerServerList_args = function(args) {
  };
  Blur_controllerServerList_args.prototype = {};
  Blur_controllerServerList_args.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;
  };
  
  Blur_controllerServerList_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_controllerServerList_args');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_controllerServerList_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_controllerServerList_result.prototype = {};
  Blur_controllerServerList_result.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 0:
        if (ftype == Thrift.Type.LIST) {
          var _size448 = 0;
          var _rtmp3452;
          this.success = [];
          var _etype451 = 0;
          _rtmp3452 = input.readListBegin();
          _etype451 = _rtmp3452.etype;
          _size448 = _rtmp3452.size;
          for (var _i453 = 0; _i453 < _size448; ++_i453)
          {
            var elem454 = null;
            elem454 = input.readString().value;
            this.success.push(elem454);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_controllerServerList_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_controllerServerList_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.LIST, 0);
      output.writeListBegin(Thrift.Type.STRING, this.success.length);
      for (var iter455 in this.success)
      {
        if (this.success.hasOwnProperty(iter455))
        {
          iter455 = this.success[iter455];
          output.writeString(iter455);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_shardServerLayout_args = function(args) {
    this.table = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
    }
  };
  Blur_shardServerLayout_args.prototype = {};
  Blur_shardServerLayout_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_shardServerLayout_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_shardServerLayout_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_shardServerLayout_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_shardServerLayout_result.prototype = {};
  Blur_shardServerLayout_result.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 0:
        if (ftype == Thrift.Type.MAP) {
          var _size456 = 0;
          var _rtmp3460;
          this.success = {};
          var _ktype457 = 0;
          var _vtype458 = 0;
          _rtmp3460 = input.readMapBegin();
          _ktype457 = _rtmp3460.ktype;
          _vtype458 = _rtmp3460.vtype;
          _size456 = _rtmp3460.size;
          for (var _i461 = 0; _i461 < _size456; ++_i461)
          {
            if (_i461 > 0 ) {
              if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
                input.rstack.pop();
              }
            }
            var key462 = null;
            var val463 = null;
            key462 = input.readString().value;
            val463 = input.readString().value;
            this.success[key462] = val463;
          }
          input.readMapEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_shardServerLayout_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_shardServerLayout_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.MAP, 0);
      output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRING, Thrift.objectLength(this.success));
      for (var kiter464 in this.success)
      {
        if (this.success.hasOwnProperty(kiter464))
        {
          var viter465 = this.success[kiter464];
          output.writeString(kiter464);
          output.writeString(viter465);
        }
      }
      output.writeMapEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_shardServerLayoutState_args = function(args) {
    this.table = null;
    if (args) {
      if (args.table !== undefined) {
        this.table = args.table;
      }
    }
  };
  Blur_shardServerLayoutState_args.prototype = {};
  Blur_shardServerLayoutState_args.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.table = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_shardServerLayoutState_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_shardServerLayoutState_args');
    if (this.table !== null && this.table !== undefined) {
      output.writeFieldBegin('table', Thrift.Type.STRING, 1);
      output.writeString(this.table);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_shardServerLayoutState_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_shardServerLayoutState_result.prototype = {};
  Blur_shardServerLayoutState_result.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 0:
        if (ftype == Thrift.Type.MAP) {
          var _size466 = 0;
          var _rtmp3470;
          this.success = {};
          var _ktype467 = 0;
          var _vtype468 = 0;
          _rtmp3470 = input.readMapBegin();
          _ktype467 = _rtmp3470.ktype;
          _vtype468 = _rtmp3470.vtype;
          _size466 = _rtmp3470.size;
          for (var _i471 = 0; _i471 < _size466; ++_i471)
          {
            if (_i471 > 0 ) {
              if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
                input.rstack.pop();
              }
            }
            var key472 = null;
            var val473 = null;
            key472 = input.readString().value;
            var _size474 = 0;
            var _rtmp3478;
            val473 = {};
            var _ktype475 = 0;
            var _vtype476 = 0;
            _rtmp3478 = input.readMapBegin();
            _ktype475 = _rtmp3478.ktype;
            _vtype476 = _rtmp3478.vtype;
            _size474 = _rtmp3478.size;
            for (var _i479 = 0; _i479 < _size474; ++_i479)
            {
              if (_i479 > 0 ) {
                if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
                  input.rstack.pop();
                }
              }
              var key480 = null;
              var val481 = null;
              key480 = input.readString().value;
              val481 = input.readI32().value;
              val473[key480] = val481;
            }
            input.readMapEnd();
            this.success[key472] = val473;
          }
          input.readMapEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_shardServerLayoutState_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_shardServerLayoutState_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.MAP, 0);
      output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.MAP, Thrift.objectLength(this.success));
      for (var kiter482 in this.success)
      {
        if (this.success.hasOwnProperty(kiter482))
        {
          var viter483 = this.success[kiter482];
          output.writeString(kiter482);
          output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.I32, Thrift.objectLength(viter483));
          for (var kiter484 in viter483)
          {
            if (viter483.hasOwnProperty(kiter484))
            {
              var viter485 = viter483[kiter484];
              output.writeString(kiter484);
              output.writeI32(viter485);
            }
          }
          output.writeMapEnd();
        }
      }
      output.writeMapEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_isInSafeMode_args = function(args) {
    this.cluster = null;
    if (args) {
      if (args.cluster !== undefined) {
        this.cluster = args.cluster;
      }
    }
  };
  Blur_isInSafeMode_args.prototype = {};
  Blur_isInSafeMode_args.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.cluster = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_isInSafeMode_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_isInSafeMode_args');
    if (this.cluster !== null && this.cluster !== undefined) {
      output.writeFieldBegin('cluster', Thrift.Type.STRING, 1);
      output.writeString(this.cluster);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_isInSafeMode_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_isInSafeMode_result.prototype = {};
  Blur_isInSafeMode_result.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 0:
        if (ftype == Thrift.Type.BOOL) {
          this.success = input.readBool().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_isInSafeMode_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_isInSafeMode_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.BOOL, 0);
      output.writeBool(this.success);
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_configuration_args = function(args) {
  };
  Blur_configuration_args.prototype = {};
  Blur_configuration_args.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;
  };
  
  Blur_configuration_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_configuration_args');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_configuration_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_configuration_result.prototype = {};
  Blur_configuration_result.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 0:
        if (ftype == Thrift.Type.MAP) {
          var _size486 = 0;
          var _rtmp3490;
          this.success = {};
          var _ktype487 = 0;
          var _vtype488 = 0;
          _rtmp3490 = input.readMapBegin();
          _ktype487 = _rtmp3490.ktype;
          _vtype488 = _rtmp3490.vtype;
          _size486 = _rtmp3490.size;
          for (var _i491 = 0; _i491 < _size486; ++_i491)
          {
            if (_i491 > 0 ) {
              if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
                input.rstack.pop();
              }
            }
            var key492 = null;
            var val493 = null;
            key492 = input.readString().value;
            val493 = input.readString().value;
            this.success[key492] = val493;
          }
          input.readMapEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_configuration_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_configuration_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.MAP, 0);
      output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRING, Thrift.objectLength(this.success));
      for (var kiter494 in this.success)
      {
        if (this.success.hasOwnProperty(kiter494))
        {
          var viter495 = this.success[kiter494];
          output.writeString(kiter494);
          output.writeString(viter495);
        }
      }
      output.writeMapEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_configurationPerServer_args = function(args) {
    this.thriftServerPlusPort = null;
    this.configName = null;
    if (args) {
      if (args.thriftServerPlusPort !== undefined) {
        this.thriftServerPlusPort = args.thriftServerPlusPort;
      }
      if (args.configName !== undefined) {
        this.configName = args.configName;
      }
    }
  };
  Blur_configurationPerServer_args.prototype = {};
  Blur_configurationPerServer_args.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.thriftServerPlusPort = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.configName = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_configurationPerServer_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_configurationPerServer_args');
    if (this.thriftServerPlusPort !== null && this.thriftServerPlusPort !== undefined) {
      output.writeFieldBegin('thriftServerPlusPort', Thrift.Type.STRING, 1);
      output.writeString(this.thriftServerPlusPort);
      output.writeFieldEnd();
    }
    if (this.configName !== null && this.configName !== undefined) {
      output.writeFieldBegin('configName', Thrift.Type.STRING, 2);
      output.writeString(this.configName);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_configurationPerServer_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_configurationPerServer_result.prototype = {};
  Blur_configurationPerServer_result.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 0:
        if (ftype == Thrift.Type.STRING) {
          this.success = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_configurationPerServer_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_configurationPerServer_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRING, 0);
      output.writeString(this.success);
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_metrics_args = function(args) {
    this.metrics = null;
    if (args) {
      if (args.metrics !== undefined) {
        this.metrics = args.metrics;
      }
    }
  };
  Blur_metrics_args.prototype = {};
  Blur_metrics_args.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.SET) {
          var _size496 = 0;
          var _rtmp3500;
          this.metrics = [];
          var _etype499 = 0;
          _rtmp3500 = input.readSetBegin();
          _etype499 = _rtmp3500.etype;
          _size496 = _rtmp3500.size;
          for (var _i501 = 0; _i501 < _size496; ++_i501)
          {
            var elem502 = null;
            elem502 = input.readString().value;
            this.metrics.push(elem502);
          }
          input.readSetEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_metrics_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_metrics_args');
    if (this.metrics !== null && this.metrics !== undefined) {
      output.writeFieldBegin('metrics', Thrift.Type.SET, 1);
      output.writeSetBegin(Thrift.Type.STRING, this.metrics.length);
      for (var iter503 in this.metrics)
      {
        if (this.metrics.hasOwnProperty(iter503))
        {
          iter503 = this.metrics[iter503];
          output.writeString(iter503);
        }
      }
      output.writeSetEnd();
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_metrics_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_metrics_result.prototype = {};
  Blur_metrics_result.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 0:
        if (ftype == Thrift.Type.MAP) {
          var _size504 = 0;
          var _rtmp3508;
          this.success = {};
          var _ktype505 = 0;
          var _vtype506 = 0;
          _rtmp3508 = input.readMapBegin();
          _ktype505 = _rtmp3508.ktype;
          _vtype506 = _rtmp3508.vtype;
          _size504 = _rtmp3508.size;
          for (var _i509 = 0; _i509 < _size504; ++_i509)
          {
            if (_i509 > 0 ) {
              if (input.rstack.length > input.rpos[input.rpos.length -1] + 1) {
                input.rstack.pop();
              }
            }
            var key510 = null;
            var val511 = null;
            key510 = input.readString().value;
            val511 = new Metric();
            val511.read(input);
            this.success[key510] = val511;
          }
          input.readMapEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_metrics_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_metrics_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.MAP, 0);
      output.writeMapBegin(Thrift.Type.STRING, Thrift.Type.STRUCT, Thrift.objectLength(this.success));
      for (var kiter512 in this.success)
      {
        if (this.success.hasOwnProperty(kiter512))
        {
          var viter513 = this.success[kiter512];
          output.writeString(kiter512);
          viter513.write(output);
        }
      }
      output.writeMapEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_startTrace_args = function(args) {
    this.traceId = null;
    this.requestId = null;
    if (args) {
      if (args.traceId !== undefined) {
        this.traceId = args.traceId;
      }
      if (args.requestId !== undefined) {
        this.requestId = args.requestId;
      }
    }
  };
  Blur_startTrace_args.prototype = {};
  Blur_startTrace_args.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.traceId = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.requestId = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_startTrace_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_startTrace_args');
    if (this.traceId !== null && this.traceId !== undefined) {
      output.writeFieldBegin('traceId', Thrift.Type.STRING, 1);
      output.writeString(this.traceId);
      output.writeFieldEnd();
    }
    if (this.requestId !== null && this.requestId !== undefined) {
      output.writeFieldBegin('requestId', Thrift.Type.STRING, 2);
      output.writeString(this.requestId);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_startTrace_result = function(args) {
  };
  Blur_startTrace_result.prototype = {};
  Blur_startTrace_result.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;
  };
  
  Blur_startTrace_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_startTrace_result');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_traceList_args = function(args) {
  };
  Blur_traceList_args.prototype = {};
  Blur_traceList_args.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;
  };
  
  Blur_traceList_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_traceList_args');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_traceList_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_traceList_result.prototype = {};
  Blur_traceList_result.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 0:
        if (ftype == Thrift.Type.LIST) {
          var _size514 = 0;
          var _rtmp3518;
          this.success = [];
          var _etype517 = 0;
          _rtmp3518 = input.readListBegin();
          _etype517 = _rtmp3518.etype;
          _size514 = _rtmp3518.size;
          for (var _i519 = 0; _i519 < _size514; ++_i519)
          {
            var elem520 = null;
            elem520 = input.readString().value;
            this.success.push(elem520);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_traceList_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_traceList_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.LIST, 0);
      output.writeListBegin(Thrift.Type.STRING, this.success.length);
      for (var iter521 in this.success)
      {
        if (this.success.hasOwnProperty(iter521))
        {
          iter521 = this.success[iter521];
          output.writeString(iter521);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_traceRequestList_args = function(args) {
    this.traceId = null;
    if (args) {
      if (args.traceId !== undefined) {
        this.traceId = args.traceId;
      }
    }
  };
  Blur_traceRequestList_args.prototype = {};
  Blur_traceRequestList_args.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.traceId = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_traceRequestList_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_traceRequestList_args');
    if (this.traceId !== null && this.traceId !== undefined) {
      output.writeFieldBegin('traceId', Thrift.Type.STRING, 1);
      output.writeString(this.traceId);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_traceRequestList_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_traceRequestList_result.prototype = {};
  Blur_traceRequestList_result.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 0:
        if (ftype == Thrift.Type.LIST) {
          var _size522 = 0;
          var _rtmp3526;
          this.success = [];
          var _etype525 = 0;
          _rtmp3526 = input.readListBegin();
          _etype525 = _rtmp3526.etype;
          _size522 = _rtmp3526.size;
          for (var _i527 = 0; _i527 < _size522; ++_i527)
          {
            var elem528 = null;
            elem528 = input.readString().value;
            this.success.push(elem528);
          }
          input.readListEnd();
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_traceRequestList_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_traceRequestList_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.LIST, 0);
      output.writeListBegin(Thrift.Type.STRING, this.success.length);
      for (var iter529 in this.success)
      {
        if (this.success.hasOwnProperty(iter529))
        {
          iter529 = this.success[iter529];
          output.writeString(iter529);
        }
      }
      output.writeListEnd();
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_traceRequestFetch_args = function(args) {
    this.traceId = null;
    this.requestId = null;
    if (args) {
      if (args.traceId !== undefined) {
        this.traceId = args.traceId;
      }
      if (args.requestId !== undefined) {
        this.requestId = args.requestId;
      }
    }
  };
  Blur_traceRequestFetch_args.prototype = {};
  Blur_traceRequestFetch_args.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.traceId = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.STRING) {
          this.requestId = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_traceRequestFetch_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_traceRequestFetch_args');
    if (this.traceId !== null && this.traceId !== undefined) {
      output.writeFieldBegin('traceId', Thrift.Type.STRING, 1);
      output.writeString(this.traceId);
      output.writeFieldEnd();
    }
    if (this.requestId !== null && this.requestId !== undefined) {
      output.writeFieldBegin('requestId', Thrift.Type.STRING, 2);
      output.writeString(this.requestId);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_traceRequestFetch_result = function(args) {
    this.success = null;
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.success !== undefined) {
        this.success = args.success;
      }
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_traceRequestFetch_result.prototype = {};
  Blur_traceRequestFetch_result.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 0:
        if (ftype == Thrift.Type.STRING) {
          this.success = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 1:
        if (ftype == Thrift.Type.STRUCT) {
          this.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_traceRequestFetch_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_traceRequestFetch_result');
    if (this.success !== null && this.success !== undefined) {
      output.writeFieldBegin('success', Thrift.Type.STRING, 0);
      output.writeString(this.success);
      output.writeFieldEnd();
    }
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_traceRemove_args = function(args) {
    this.traceId = null;
    if (args) {
      if (args.traceId !== undefined) {
        this.traceId = args.traceId;
      }
    }
  };
  Blur_traceRemove_args.prototype = {};
  Blur_traceRemove_args.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.traceId = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_traceRemove_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_traceRemove_args');
    if (this.traceId !== null && this.traceId !== undefined) {
      output.writeFieldBegin('traceId', Thrift.Type.STRING, 1);
      output.writeString(this.traceId);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_traceRemove_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_traceRemove_result.prototype = {};
  Blur_traceRemove_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_traceRemove_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_traceRemove_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_ping_args = function(args) {
  };
  Blur_ping_args.prototype = {};
  Blur_ping_args.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;
  };
  
  Blur_ping_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_ping_args');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_ping_result = function(args) {
  };
  Blur_ping_result.prototype = {};
  Blur_ping_result.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;
  };
  
  Blur_ping_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_ping_result');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_logging_args = function(args) {
    this.classNameOrLoggerName = null;
    this.level = null;
    if (args) {
      if (args.classNameOrLoggerName !== undefined) {
        this.classNameOrLoggerName = args.classNameOrLoggerName;
      }
      if (args.level !== undefined) {
        this.level = args.level;
      }
    }
  };
  Blur_logging_args.prototype = {};
  Blur_logging_args.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.classNameOrLoggerName = input.readString().value;
        } else {
          input.skip(ftype);
        }
        break;
        case 2:
        if (ftype == Thrift.Type.I32) {
          this.level = input.readI32().value;
        } else {
          input.skip(ftype);
        }
        break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_logging_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_logging_args');
    if (this.classNameOrLoggerName !== null && this.classNameOrLoggerName !== undefined) {
      output.writeFieldBegin('classNameOrLoggerName', Thrift.Type.STRING, 1);
      output.writeString(this.classNameOrLoggerName);
      output.writeFieldEnd();
    }
    if (this.level !== null && this.level !== undefined) {
      output.writeFieldBegin('level', Thrift.Type.I32, 2);
      output.writeI32(this.level);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_logging_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_logging_result.prototype = {};
  Blur_logging_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_logging_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_logging_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_resetLogging_args = function(args) {
  };
  Blur_resetLogging_args.prototype = {};
  Blur_resetLogging_args.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;
  };
  
  Blur_resetLogging_args.prototype.write = function(output) {
    output.writeStructBegin('Blur_resetLogging_args');
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  Blur_resetLogging_result = function(args) {
    this.ex = null;
    if (args instanceof BlurException) {
      this.ex = args;
      return;
    }
    if (args) {
      if (args.ex !== undefined) {
        this.ex = args.ex;
      }
    }
  };
  Blur_resetLogging_result.prototype = {};
  Blur_resetLogging_result.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.ex = new BlurException();
          this.ex.read(input);
        } else {
          input.skip(ftype);
        }
        break;
        case 0:
          input.skip(ftype);
          break;
        default:
          input.skip(ftype);
      }
      input.readFieldEnd();
    }
    input.readStructEnd();
    return;
  };
  
  Blur_resetLogging_result.prototype.write = function(output) {
    output.writeStructBegin('Blur_resetLogging_result');
    if (this.ex !== null && this.ex !== undefined) {
      output.writeFieldBegin('ex', Thrift.Type.STRUCT, 1);
      this.ex.write(output);
      output.writeFieldEnd();
    }
    output.writeFieldStop();
    output.writeStructEnd();
    return;
  };
  
  BlurClient = function(input, output) {
      this.input = input;
      this.output = (!output) ? input : output;
      this.seqid = 0;
  };
  BlurClient.prototype = {};
  BlurClient.prototype.listInstalledCommands = function() {
    this.send_listInstalledCommands();
    return this.recv_listInstalledCommands();
  };
  
  BlurClient.prototype.send_listInstalledCommands = function() {
    this.output.writeMessageBegin('listInstalledCommands', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_listInstalledCommands_args();
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_listInstalledCommands = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_listInstalledCommands_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'listInstalledCommands failed: unknown result';
  };
  BlurClient.prototype.execute = function(commandName, arguments) {
    this.send_execute(commandName, arguments);
    return this.recv_execute();
  };
  
  BlurClient.prototype.send_execute = function(commandName, arguments) {
    this.output.writeMessageBegin('execute', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_execute_args();
    args.commandName = commandName;
    args.arguments = arguments;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_execute = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_execute_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.bex) {
      throw result.bex;
    }
    if (null !== result.tex) {
      throw result.tex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'execute failed: unknown result';
  };
  BlurClient.prototype.reconnect = function(instanceExecutionId) {
    this.send_reconnect(instanceExecutionId);
    return this.recv_reconnect();
  };
  
  BlurClient.prototype.send_reconnect = function(instanceExecutionId) {
    this.output.writeMessageBegin('reconnect', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_reconnect_args();
    args.instanceExecutionId = instanceExecutionId;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_reconnect = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_reconnect_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.bex) {
      throw result.bex;
    }
    if (null !== result.tex) {
      throw result.tex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'reconnect failed: unknown result';
  };
  BlurClient.prototype.commandStatusList = function(startingAt, fetch) {
    this.send_commandStatusList(startingAt, fetch);
    return this.recv_commandStatusList();
  };
  
  BlurClient.prototype.send_commandStatusList = function(startingAt, fetch) {
    this.output.writeMessageBegin('commandStatusList', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_commandStatusList_args();
    args.startingAt = startingAt;
    args.fetch = fetch;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_commandStatusList = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_commandStatusList_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'commandStatusList failed: unknown result';
  };
  BlurClient.prototype.commandStatus = function(commandExecutionId) {
    this.send_commandStatus(commandExecutionId);
    return this.recv_commandStatus();
  };
  
  BlurClient.prototype.send_commandStatus = function(commandExecutionId) {
    this.output.writeMessageBegin('commandStatus', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_commandStatus_args();
    args.commandExecutionId = commandExecutionId;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_commandStatus = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_commandStatus_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'commandStatus failed: unknown result';
  };
  BlurClient.prototype.commandCancel = function(commandExecutionId) {
    this.send_commandCancel(commandExecutionId);
    this.recv_commandCancel();
  };
  
  BlurClient.prototype.send_commandCancel = function(commandExecutionId) {
    this.output.writeMessageBegin('commandCancel', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_commandCancel_args();
    args.commandExecutionId = commandExecutionId;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_commandCancel = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_commandCancel_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.refresh = function() {
    this.send_refresh();
  };
  
  BlurClient.prototype.send_refresh = function() {
    this.output.writeMessageBegin('refresh', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_refresh_args();
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  BlurClient.prototype.createTable = function(tableDescriptor) {
    this.send_createTable(tableDescriptor);
    this.recv_createTable();
  };
  
  BlurClient.prototype.send_createTable = function(tableDescriptor) {
    this.output.writeMessageBegin('createTable', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_createTable_args();
    args.tableDescriptor = tableDescriptor;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_createTable = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_createTable_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.enableTable = function(table) {
    this.send_enableTable(table);
    this.recv_enableTable();
  };
  
  BlurClient.prototype.send_enableTable = function(table) {
    this.output.writeMessageBegin('enableTable', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_enableTable_args();
    args.table = table;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_enableTable = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_enableTable_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.disableTable = function(table) {
    this.send_disableTable(table);
    this.recv_disableTable();
  };
  
  BlurClient.prototype.send_disableTable = function(table) {
    this.output.writeMessageBegin('disableTable', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_disableTable_args();
    args.table = table;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_disableTable = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_disableTable_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.removeTable = function(table, deleteIndexFiles) {
    this.send_removeTable(table, deleteIndexFiles);
    this.recv_removeTable();
  };
  
  BlurClient.prototype.send_removeTable = function(table, deleteIndexFiles) {
    this.output.writeMessageBegin('removeTable', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_removeTable_args();
    args.table = table;
    args.deleteIndexFiles = deleteIndexFiles;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_removeTable = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_removeTable_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.addColumnDefinition = function(table, columnDefinition) {
    this.send_addColumnDefinition(table, columnDefinition);
    return this.recv_addColumnDefinition();
  };
  
  BlurClient.prototype.send_addColumnDefinition = function(table, columnDefinition) {
    this.output.writeMessageBegin('addColumnDefinition', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_addColumnDefinition_args();
    args.table = table;
    args.columnDefinition = columnDefinition;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_addColumnDefinition = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_addColumnDefinition_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'addColumnDefinition failed: unknown result';
  };
  BlurClient.prototype.tableList = function() {
    this.send_tableList();
    return this.recv_tableList();
  };
  
  BlurClient.prototype.send_tableList = function() {
    this.output.writeMessageBegin('tableList', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_tableList_args();
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_tableList = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_tableList_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'tableList failed: unknown result';
  };
  BlurClient.prototype.tableListByCluster = function(cluster) {
    this.send_tableListByCluster(cluster);
    return this.recv_tableListByCluster();
  };
  
  BlurClient.prototype.send_tableListByCluster = function(cluster) {
    this.output.writeMessageBegin('tableListByCluster', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_tableListByCluster_args();
    args.cluster = cluster;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_tableListByCluster = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_tableListByCluster_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'tableListByCluster failed: unknown result';
  };
  BlurClient.prototype.describe = function(table) {
    this.send_describe(table);
    return this.recv_describe();
  };
  
  BlurClient.prototype.send_describe = function(table) {
    this.output.writeMessageBegin('describe', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_describe_args();
    args.table = table;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_describe = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_describe_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'describe failed: unknown result';
  };
  BlurClient.prototype.schema = function(table) {
    this.send_schema(table);
    return this.recv_schema();
  };
  
  BlurClient.prototype.send_schema = function(table) {
    this.output.writeMessageBegin('schema', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_schema_args();
    args.table = table;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_schema = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_schema_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'schema failed: unknown result';
  };
  BlurClient.prototype.parseQuery = function(table, query) {
    this.send_parseQuery(table, query);
    return this.recv_parseQuery();
  };
  
  BlurClient.prototype.send_parseQuery = function(table, query) {
    this.output.writeMessageBegin('parseQuery', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_parseQuery_args();
    args.table = table;
    args.query = query;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_parseQuery = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_parseQuery_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'parseQuery failed: unknown result';
  };
  BlurClient.prototype.tableStats = function(table) {
    this.send_tableStats(table);
    return this.recv_tableStats();
  };
  
  BlurClient.prototype.send_tableStats = function(table) {
    this.output.writeMessageBegin('tableStats', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_tableStats_args();
    args.table = table;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_tableStats = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_tableStats_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'tableStats failed: unknown result';
  };
  BlurClient.prototype.optimize = function(table, numberOfSegmentsPerShard) {
    this.send_optimize(table, numberOfSegmentsPerShard);
    this.recv_optimize();
  };
  
  BlurClient.prototype.send_optimize = function(table, numberOfSegmentsPerShard) {
    this.output.writeMessageBegin('optimize', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_optimize_args();
    args.table = table;
    args.numberOfSegmentsPerShard = numberOfSegmentsPerShard;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_optimize = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_optimize_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.createSnapshot = function(table, name) {
    this.send_createSnapshot(table, name);
    this.recv_createSnapshot();
  };
  
  BlurClient.prototype.send_createSnapshot = function(table, name) {
    this.output.writeMessageBegin('createSnapshot', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_createSnapshot_args();
    args.table = table;
    args.name = name;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_createSnapshot = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_createSnapshot_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.removeSnapshot = function(table, name) {
    this.send_removeSnapshot(table, name);
    this.recv_removeSnapshot();
  };
  
  BlurClient.prototype.send_removeSnapshot = function(table, name) {
    this.output.writeMessageBegin('removeSnapshot', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_removeSnapshot_args();
    args.table = table;
    args.name = name;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_removeSnapshot = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_removeSnapshot_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.listSnapshots = function(table) {
    this.send_listSnapshots(table);
    return this.recv_listSnapshots();
  };
  
  BlurClient.prototype.send_listSnapshots = function(table) {
    this.output.writeMessageBegin('listSnapshots', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_listSnapshots_args();
    args.table = table;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_listSnapshots = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_listSnapshots_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'listSnapshots failed: unknown result';
  };
  BlurClient.prototype.setUser = function(user) {
    this.send_setUser(user);
  };
  
  BlurClient.prototype.send_setUser = function(user) {
    this.output.writeMessageBegin('setUser', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_setUser_args();
    args.user = user;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  BlurClient.prototype.query = function(table, blurQuery) {
    this.send_query(table, blurQuery);
    return this.recv_query();
  };
  
  BlurClient.prototype.send_query = function(table, blurQuery) {
    this.output.writeMessageBegin('query', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_query_args();
    args.table = table;
    args.blurQuery = blurQuery;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_query = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_query_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'query failed: unknown result';
  };
  BlurClient.prototype.fetchRow = function(table, selector) {
    this.send_fetchRow(table, selector);
    return this.recv_fetchRow();
  };
  
  BlurClient.prototype.send_fetchRow = function(table, selector) {
    this.output.writeMessageBegin('fetchRow', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_fetchRow_args();
    args.table = table;
    args.selector = selector;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_fetchRow = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_fetchRow_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'fetchRow failed: unknown result';
  };
  BlurClient.prototype.fetchRowBatch = function(table, selectors) {
    this.send_fetchRowBatch(table, selectors);
    return this.recv_fetchRowBatch();
  };
  
  BlurClient.prototype.send_fetchRowBatch = function(table, selectors) {
    this.output.writeMessageBegin('fetchRowBatch', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_fetchRowBatch_args();
    args.table = table;
    args.selectors = selectors;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_fetchRowBatch = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_fetchRowBatch_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'fetchRowBatch failed: unknown result';
  };
  BlurClient.prototype.loadData = function(table, location) {
    this.send_loadData(table, location);
    this.recv_loadData();
  };
  
  BlurClient.prototype.send_loadData = function(table, location) {
    this.output.writeMessageBegin('loadData', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_loadData_args();
    args.table = table;
    args.location = location;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_loadData = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_loadData_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.validateIndex = function(table, externalIndexPaths) {
    this.send_validateIndex(table, externalIndexPaths);
    this.recv_validateIndex();
  };
  
  BlurClient.prototype.send_validateIndex = function(table, externalIndexPaths) {
    this.output.writeMessageBegin('validateIndex', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_validateIndex_args();
    args.table = table;
    args.externalIndexPaths = externalIndexPaths;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_validateIndex = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_validateIndex_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.loadIndex = function(table, externalIndexPaths) {
    this.send_loadIndex(table, externalIndexPaths);
    this.recv_loadIndex();
  };
  
  BlurClient.prototype.send_loadIndex = function(table, externalIndexPaths) {
    this.output.writeMessageBegin('loadIndex', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_loadIndex_args();
    args.table = table;
    args.externalIndexPaths = externalIndexPaths;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_loadIndex = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_loadIndex_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.mutate = function(mutation) {
    this.send_mutate(mutation);
    this.recv_mutate();
  };
  
  BlurClient.prototype.send_mutate = function(mutation) {
    this.output.writeMessageBegin('mutate', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_mutate_args();
    args.mutation = mutation;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_mutate = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_mutate_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.enqueueMutate = function(mutation) {
    this.send_enqueueMutate(mutation);
    this.recv_enqueueMutate();
  };
  
  BlurClient.prototype.send_enqueueMutate = function(mutation) {
    this.output.writeMessageBegin('enqueueMutate', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_enqueueMutate_args();
    args.mutation = mutation;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_enqueueMutate = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_enqueueMutate_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.mutateBatch = function(mutations) {
    this.send_mutateBatch(mutations);
    this.recv_mutateBatch();
  };
  
  BlurClient.prototype.send_mutateBatch = function(mutations) {
    this.output.writeMessageBegin('mutateBatch', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_mutateBatch_args();
    args.mutations = mutations;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_mutateBatch = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_mutateBatch_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.enqueueMutateBatch = function(mutations) {
    this.send_enqueueMutateBatch(mutations);
    this.recv_enqueueMutateBatch();
  };
  
  BlurClient.prototype.send_enqueueMutateBatch = function(mutations) {
    this.output.writeMessageBegin('enqueueMutateBatch', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_enqueueMutateBatch_args();
    args.mutations = mutations;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_enqueueMutateBatch = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_enqueueMutateBatch_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.bulkMutateStart = function(bulkId) {
    this.send_bulkMutateStart(bulkId);
    this.recv_bulkMutateStart();
  };
  
  BlurClient.prototype.send_bulkMutateStart = function(bulkId) {
    this.output.writeMessageBegin('bulkMutateStart', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_bulkMutateStart_args();
    args.bulkId = bulkId;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_bulkMutateStart = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_bulkMutateStart_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.bulkMutateAdd = function(bulkId, rowMutation) {
    this.send_bulkMutateAdd(bulkId, rowMutation);
    this.recv_bulkMutateAdd();
  };
  
  BlurClient.prototype.send_bulkMutateAdd = function(bulkId, rowMutation) {
    this.output.writeMessageBegin('bulkMutateAdd', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_bulkMutateAdd_args();
    args.bulkId = bulkId;
    args.rowMutation = rowMutation;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_bulkMutateAdd = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_bulkMutateAdd_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.bulkMutateAddMultiple = function(bulkId, rowMutations) {
    this.send_bulkMutateAddMultiple(bulkId, rowMutations);
    this.recv_bulkMutateAddMultiple();
  };
  
  BlurClient.prototype.send_bulkMutateAddMultiple = function(bulkId, rowMutations) {
    this.output.writeMessageBegin('bulkMutateAddMultiple', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_bulkMutateAddMultiple_args();
    args.bulkId = bulkId;
    args.rowMutations = rowMutations;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_bulkMutateAddMultiple = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_bulkMutateAddMultiple_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.bulkMutateFinish = function(bulkId, apply, blockUntilComplete) {
    this.send_bulkMutateFinish(bulkId, apply, blockUntilComplete);
    this.recv_bulkMutateFinish();
  };
  
  BlurClient.prototype.send_bulkMutateFinish = function(bulkId, apply, blockUntilComplete) {
    this.output.writeMessageBegin('bulkMutateFinish', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_bulkMutateFinish_args();
    args.bulkId = bulkId;
    args.apply = apply;
    args.blockUntilComplete = blockUntilComplete;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_bulkMutateFinish = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_bulkMutateFinish_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.cancelQuery = function(table, uuid) {
    this.send_cancelQuery(table, uuid);
    this.recv_cancelQuery();
  };
  
  BlurClient.prototype.send_cancelQuery = function(table, uuid) {
    this.output.writeMessageBegin('cancelQuery', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_cancelQuery_args();
    args.table = table;
    args.uuid = uuid;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_cancelQuery = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_cancelQuery_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.queryStatusIdList = function(table) {
    this.send_queryStatusIdList(table);
    return this.recv_queryStatusIdList();
  };
  
  BlurClient.prototype.send_queryStatusIdList = function(table) {
    this.output.writeMessageBegin('queryStatusIdList', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_queryStatusIdList_args();
    args.table = table;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_queryStatusIdList = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_queryStatusIdList_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'queryStatusIdList failed: unknown result';
  };
  BlurClient.prototype.queryStatusById = function(table, uuid) {
    this.send_queryStatusById(table, uuid);
    return this.recv_queryStatusById();
  };
  
  BlurClient.prototype.send_queryStatusById = function(table, uuid) {
    this.output.writeMessageBegin('queryStatusById', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_queryStatusById_args();
    args.table = table;
    args.uuid = uuid;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_queryStatusById = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_queryStatusById_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'queryStatusById failed: unknown result';
  };
  BlurClient.prototype.terms = function(table, columnFamily, columnName, startWith, size) {
    this.send_terms(table, columnFamily, columnName, startWith, size);
    return this.recv_terms();
  };
  
  BlurClient.prototype.send_terms = function(table, columnFamily, columnName, startWith, size) {
    this.output.writeMessageBegin('terms', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_terms_args();
    args.table = table;
    args.columnFamily = columnFamily;
    args.columnName = columnName;
    args.startWith = startWith;
    args.size = size;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_terms = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_terms_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'terms failed: unknown result';
  };
  BlurClient.prototype.recordFrequency = function(table, columnFamily, columnName, value) {
    this.send_recordFrequency(table, columnFamily, columnName, value);
    return this.recv_recordFrequency();
  };
  
  BlurClient.prototype.send_recordFrequency = function(table, columnFamily, columnName, value) {
    this.output.writeMessageBegin('recordFrequency', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_recordFrequency_args();
    args.table = table;
    args.columnFamily = columnFamily;
    args.columnName = columnName;
    args.value = value;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_recordFrequency = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_recordFrequency_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'recordFrequency failed: unknown result';
  };
  BlurClient.prototype.shardClusterList = function() {
    this.send_shardClusterList();
    return this.recv_shardClusterList();
  };
  
  BlurClient.prototype.send_shardClusterList = function() {
    this.output.writeMessageBegin('shardClusterList', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_shardClusterList_args();
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_shardClusterList = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_shardClusterList_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'shardClusterList failed: unknown result';
  };
  BlurClient.prototype.shardServerList = function(cluster) {
    this.send_shardServerList(cluster);
    return this.recv_shardServerList();
  };
  
  BlurClient.prototype.send_shardServerList = function(cluster) {
    this.output.writeMessageBegin('shardServerList', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_shardServerList_args();
    args.cluster = cluster;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_shardServerList = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_shardServerList_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'shardServerList failed: unknown result';
  };
  BlurClient.prototype.controllerServerList = function() {
    this.send_controllerServerList();
    return this.recv_controllerServerList();
  };
  
  BlurClient.prototype.send_controllerServerList = function() {
    this.output.writeMessageBegin('controllerServerList', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_controllerServerList_args();
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_controllerServerList = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_controllerServerList_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'controllerServerList failed: unknown result';
  };
  BlurClient.prototype.shardServerLayout = function(table) {
    this.send_shardServerLayout(table);
    return this.recv_shardServerLayout();
  };
  
  BlurClient.prototype.send_shardServerLayout = function(table) {
    this.output.writeMessageBegin('shardServerLayout', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_shardServerLayout_args();
    args.table = table;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_shardServerLayout = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_shardServerLayout_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'shardServerLayout failed: unknown result';
  };
  BlurClient.prototype.shardServerLayoutState = function(table) {
    this.send_shardServerLayoutState(table);
    return this.recv_shardServerLayoutState();
  };
  
  BlurClient.prototype.send_shardServerLayoutState = function(table) {
    this.output.writeMessageBegin('shardServerLayoutState', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_shardServerLayoutState_args();
    args.table = table;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_shardServerLayoutState = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_shardServerLayoutState_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'shardServerLayoutState failed: unknown result';
  };
  BlurClient.prototype.isInSafeMode = function(cluster) {
    this.send_isInSafeMode(cluster);
    return this.recv_isInSafeMode();
  };
  
  BlurClient.prototype.send_isInSafeMode = function(cluster) {
    this.output.writeMessageBegin('isInSafeMode', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_isInSafeMode_args();
    args.cluster = cluster;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_isInSafeMode = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_isInSafeMode_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'isInSafeMode failed: unknown result';
  };
  BlurClient.prototype.configuration = function() {
    this.send_configuration();
    return this.recv_configuration();
  };
  
  BlurClient.prototype.send_configuration = function() {
    this.output.writeMessageBegin('configuration', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_configuration_args();
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_configuration = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_configuration_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'configuration failed: unknown result';
  };
  BlurClient.prototype.configurationPerServer = function(thriftServerPlusPort, configName) {
    this.send_configurationPerServer(thriftServerPlusPort, configName);
    return this.recv_configurationPerServer();
  };
  
  BlurClient.prototype.send_configurationPerServer = function(thriftServerPlusPort, configName) {
    this.output.writeMessageBegin('configurationPerServer', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_configurationPerServer_args();
    args.thriftServerPlusPort = thriftServerPlusPort;
    args.configName = configName;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_configurationPerServer = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_configurationPerServer_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'configurationPerServer failed: unknown result';
  };
  BlurClient.prototype.metrics = function(metrics) {
    this.send_metrics(metrics);
    return this.recv_metrics();
  };
  
  BlurClient.prototype.send_metrics = function(metrics) {
    this.output.writeMessageBegin('metrics', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_metrics_args();
    args.metrics = metrics;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_metrics = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_metrics_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'metrics failed: unknown result';
  };
  BlurClient.prototype.startTrace = function(traceId, requestId) {
    this.send_startTrace(traceId, requestId);
  };
  
  BlurClient.prototype.send_startTrace = function(traceId, requestId) {
    this.output.writeMessageBegin('startTrace', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_startTrace_args();
    args.traceId = traceId;
    args.requestId = requestId;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  BlurClient.prototype.traceList = function() {
    this.send_traceList();
    return this.recv_traceList();
  };
  
  BlurClient.prototype.send_traceList = function() {
    this.output.writeMessageBegin('traceList', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_traceList_args();
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_traceList = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_traceList_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'traceList failed: unknown result';
  };
  BlurClient.prototype.traceRequestList = function(traceId) {
    this.send_traceRequestList(traceId);
    return this.recv_traceRequestList();
  };
  
  BlurClient.prototype.send_traceRequestList = function(traceId) {
    this.output.writeMessageBegin('traceRequestList', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_traceRequestList_args();
    args.traceId = traceId;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_traceRequestList = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_traceRequestList_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'traceRequestList failed: unknown result';
  };
  BlurClient.prototype.traceRequestFetch = function(traceId, requestId) {
    this.send_traceRequestFetch(traceId, requestId);
    return this.recv_traceRequestFetch();
  };
  
  BlurClient.prototype.send_traceRequestFetch = function(traceId, requestId) {
    this.output.writeMessageBegin('traceRequestFetch', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_traceRequestFetch_args();
    args.traceId = traceId;
    args.requestId = requestId;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_traceRequestFetch = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_traceRequestFetch_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    if (null !== result.success) {
      return result.success;
    }
    throw 'traceRequestFetch failed: unknown result';
  };
  BlurClient.prototype.traceRemove = function(traceId) {
    this.send_traceRemove(traceId);
    this.recv_traceRemove();
  };
  
  BlurClient.prototype.send_traceRemove = function(traceId) {
    this.output.writeMessageBegin('traceRemove', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_traceRemove_args();
    args.traceId = traceId;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_traceRemove = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_traceRemove_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.ping = function() {
    this.send_ping();
    this.recv_ping();
  };
  
  BlurClient.prototype.send_ping = function() {
    this.output.writeMessageBegin('ping', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_ping_args();
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_ping = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_ping_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    return;
  };
  BlurClient.prototype.logging = function(classNameOrLoggerName, level) {
    this.send_logging(classNameOrLoggerName, level);
    this.recv_logging();
  };
  
  BlurClient.prototype.send_logging = function(classNameOrLoggerName, level) {
    this.output.writeMessageBegin('logging', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_logging_args();
    args.classNameOrLoggerName = classNameOrLoggerName;
    args.level = level;
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_logging = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_logging_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  BlurClient.prototype.resetLogging = function() {
    this.send_resetLogging();
    this.recv_resetLogging();
  };
  
  BlurClient.prototype.send_resetLogging = function() {
    this.output.writeMessageBegin('resetLogging', Thrift.MessageType.CALL, this.seqid);
    var args = new Blur_resetLogging_args();
    args.write(this.output);
    this.output.writeMessageEnd();
    return this.output.getTransport().flush();
  };
  
  BlurClient.prototype.recv_resetLogging = function() {
    var ret = this.input.readMessageBegin();
    var fname = ret.fname;
    var mtype = ret.mtype;
    var rseqid = ret.rseqid;
    if (mtype == Thrift.MessageType.EXCEPTION) {
      var x = new Thrift.TApplicationException();
      x.read(this.input);
      this.input.readMessageEnd();
      throw x;
    }
    var result = new Blur_resetLogging_result();
    result.read(this.input);
    this.input.readMessageEnd();
  
    if (null !== result.ex) {
      throw result.ex;
    }
    return;
  };
  