i64listi64.go

// Autogenerated by Thrift Compiler (0.11.0)
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING

package i64listi64

import (
	"bytes"
	"reflect"
	"database/sql/driver"
	"errors"
	"context"
	"fmt"
	"git.apache.org/thrift.git/lib/go/thrift"
)

// (needed to ensure safety because of naive import list construction.)
var _ = thrift.ZERO
var _ = fmt.Printf
var _ = context.Background
var _ = reflect.DeepEqual
var _ = bytes.Equal

type LimitPolicy int64
const (
  LimitPolicy_REJECT LimitPolicy = 0
  LimitPolicy_EVICT_FRONT LimitPolicy = 1
  LimitPolicy_EVICT_BACK LimitPolicy = 2
)

func (p LimitPolicy) String() string {
  switch p {
  case LimitPolicy_REJECT: return "REJECT"
  case LimitPolicy_EVICT_FRONT: return "EVICT_FRONT"
  case LimitPolicy_EVICT_BACK: return "EVICT_BACK"
  }
  return "<UNSET>"
}

func LimitPolicyFromString(s string) (LimitPolicy, error) {
  switch s {
  case "REJECT": return LimitPolicy_REJECT, nil 
  case "EVICT_FRONT": return LimitPolicy_EVICT_FRONT, nil 
  case "EVICT_BACK": return LimitPolicy_EVICT_BACK, nil 
  }
  return LimitPolicy(0), fmt.Errorf("not a valid LimitPolicy string")
}


func LimitPolicyPtr(v LimitPolicy) *LimitPolicy { return &v }

func (p LimitPolicy) MarshalText() ([]byte, error) {
return []byte(p.String()), nil
}

func (p *LimitPolicy) UnmarshalText(text []byte) error {
q, err := LimitPolicyFromString(string(text))
if (err != nil) {
return err
}
*p = q
return nil
}

func (p *LimitPolicy) Scan(value interface{}) error {
v, ok := value.(int64)
if !ok {
return errors.New("Scan value is not int64")
}
*p = LimitPolicy(v)
return nil
}

func (p * LimitPolicy) Value() (driver.Value, error) {
  if p == nil {
    return nil, nil
  }
return int64(*p), nil
}
type TEntry int64

func TEntryPtr(v TEntry) *TEntry { return &v }

type TKey int64

func TKeyPtr(v TKey) *TKey { return &v }

type TKeyList []TKey

func TKeyListPtr(v TKeyList) *TKeyList { return &v }

type TEntryList []TEntry

func TEntryListPtr(v TEntryList) *TEntryList { return &v }

// Attributes:
//  - Entries
type TValue struct {
  Entries TEntryList `thrift:"entries,1" db:"entries" json:"entries"`
}

func NewTValue() *TValue {
  return &TValue{}
}


func (p *TValue) GetEntries() TEntryList {
  return p.Entries
}
func (p *TValue) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *TValue)  ReadField1(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TEntryList, 0, size)
  p.Entries =  tSlice
  for i := 0; i < size; i ++ {
var _elem0 TEntry
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TEntry(v)
    _elem0 = temp
}
    p.Entries = append(p.Entries, _elem0)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *TValue) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TValue"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *TValue) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entries", thrift.LIST, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:entries: ", p), err) }
  if err := oprot.WriteListBegin(thrift.I64, len(p.Entries)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.Entries {
    if err := oprot.WriteI64(int64(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteListEnd(); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:entries: ", p), err) }
  return err
}

func (p *TValue) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("TValue(%+v)", *p)
}

type I64ListI64Service interface {
  // Count entry number
  // 
  // Parameters:
  //  - Key
  Count(ctx context.Context, key TKey) (r int32, err error)
  // Test entry existence
  // 
  // Parameters:
  //  - Key
  //  - Entry
  Existed(ctx context.Context, key TKey, entry TEntry) (r bool, err error)
  // Get list of all entries
  // 
  // Parameters:
  //  - Key
  GetListAll(ctx context.Context, key TKey) (r TEntryList, err error)
  // Parameters:
  //  - Key
  GetAll(ctx context.Context, key TKey) (r TEntryList, err error)
  // Get list entry slice
  // 
  // Parameters:
  //  - Key
  //  - Start
  //  - Length
  GetSlice(ctx context.Context, key TKey, start int32, length int32) (r TEntryList, err error)
  // Parameters:
  //  - Key
  //  - EntryStart
  //  - Length
  GetSliceFromEntry(ctx context.Context, key TKey, entryStart TEntry, length int32) (r TEntryList, err error)
  // Parameters:
  //  - Key
  //  - EntryStart
  //  - Length
  GetSliceFromId(ctx context.Context, key TKey, entryStart TEntry, length int32) (r TEntryList, err error)
  // Parameters:
  //  - Key
  //  - Start
  //  - Length
  GetSliceReverse(ctx context.Context, key TKey, start int32, length int32) (r TEntryList, err error)
  // Parameters:
  //  - Key
  //  - EntryStart
  //  - Length
  GetSliceFromEntryReverse(ctx context.Context, key TKey, entryStart TEntry, length int32) (r TEntryList, err error)
  // Parameters:
  //  - Key
  //  - EntryStart
  //  - Length
  GetSliceFromIdReverse(ctx context.Context, key TKey, entryStart TEntry, length int32) (r TEntryList, err error)
  // Put an entry, update on entry existence
  // For unsorted list this insert at end()
  // 
  // Parameters:
  //  - Key
  //  - Entry
  Put(ctx context.Context, key TKey, entry TEntry) (r bool, err error)
  // Clear old data, put new value on the key
  // 
  // Parameters:
  //  - Key
  //  - Value
  PutValue(ctx context.Context, key TKey, value *TValue) (r bool, err error)
  // Put list of entry, update on entry existence
  // 
  // Parameters:
  //  - Key
  //  - EntryList
  PutList(ctx context.Context, key TKey, entryList TEntryList) (r bool, err error)
  // Insert an entry, return false on key existence
  // @return true on successful insertion, false otherwise (due to length limit or entry existed on sorted list)
  // For unsorted list this insert at end()
  // 
  // Parameters:
  //  - Key
  //  - Entry
  Insert(ctx context.Context, key TKey, entry TEntry) (r bool, err error)
  // Insert an entry at index
  // @param index considered count from begin if non-negative, count from end otherwise
  // the entry will have index = start after insertion
  // e.g. 0 = push_front, -1 = push_back, -2 = the entry before last entry
  // For sorted list this calls insert
  // 
  // Parameters:
  //  - Key
  //  - Entry
  //  - Index
  InsertAt(ctx context.Context, key TKey, entry TEntry, index int32) (r bool, err error)
  // Remove an entry, return false if entry not found
  // 
  // Parameters:
  //  - Key
  //  - Entry
  Remove(ctx context.Context, key TKey, entry TEntry) (r bool, err error)
  // Remove entry by index
  // @param index similar to insertAt
  // 
  // Parameters:
  //  - Key
  //  - Index
  RemoveAt(ctx context.Context, key TKey, index int32) (r bool, err error)
  // Make an entry the first in unsorted list and return true if it existed, do nothing on sorted list return false
  // 
  // Parameters:
  //  - Key
  //  - Entry
  BumpUp(ctx context.Context, key TKey, entry TEntry) (r bool, err error)
  // Remove entry list
  // 
  // Parameters:
  //  - Key
  //  - EntryList
  RemoveList(ctx context.Context, key TKey, entryList TEntryList) (r bool, err error)
  // Clear data on given key
  // 
  // Parameters:
  //  - Key
  ClearData(ctx context.Context, key TKey) (err error)
  // Split the list into 2, return first entry of new list, or -1 if fails
  // 
  // Parameters:
  //  - OldKey
  //  - NewKey_
  //  - OrigLength
  Split(ctx context.Context, oldKey TKey, newKey TKey, origLength int32) (r TEntry, err error)
  // Parameters:
  //  - KeyList
  MultiCount(ctx context.Context, keyList TKeyList) (r map[TKey]int32, err error)
  // Parameters:
  //  - KeyList
  //  - Entry
  MultiExisted(ctx context.Context, keyList TKeyList, entry TEntry) (r map[TKey]bool, err error)
  // Parameters:
  //  - KeyList
  MultiGetListAll(ctx context.Context, keyList TKeyList) (r map[TKey]TEntryList, err error)
  // Parameters:
  //  - KeyList
  //  - Start
  //  - Length
  MultiGetSlice(ctx context.Context, keyList TKeyList, start int32, length int32) (r map[TKey]TEntryList, err error)
  // Parameters:
  //  - KeyList
  //  - Start
  //  - Length
  MultiGetSliceReverse(ctx context.Context, keyList TKeyList, start int32, length int32) (r map[TKey]TEntryList, err error)
  // Put same entry to multiple keys
  // 
  // Parameters:
  //  - KeyList
  //  - Entry
  MultiPut(ctx context.Context, keyList TKeyList, entry TEntry) (r map[TKey]bool, err error)
  // Parameters:
  //  - Key
  //  - Entry
  PutOw(ctx context.Context, key TKey, entry TEntry) (err error)
  // Parameters:
  //  - UidList
  //  - Entry
  PutMultiKeyOw(ctx context.Context, uidList TKeyList, entry TEntry) (err error)
  // Parameters:
  //  - Key
  //  - Entry
  RemoveOw(ctx context.Context, key TKey, entry TEntry) (err error)
}

type I64ListI64ServiceClient struct {
  c thrift.TClient
}

// Deprecated: Use NewI64ListI64Service instead
func NewI64ListI64ServiceClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *I64ListI64ServiceClient {
  return &I64ListI64ServiceClient{
    c: thrift.NewTStandardClient(f.GetProtocol(t), f.GetProtocol(t)),
  }
}

// Deprecated: Use NewI64ListI64Service instead
func NewI64ListI64ServiceClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *I64ListI64ServiceClient {
  return &I64ListI64ServiceClient{
    c: thrift.NewTStandardClient(iprot, oprot),
  }
}

func NewI64ListI64ServiceClient(c thrift.TClient) *I64ListI64ServiceClient {
  return &I64ListI64ServiceClient{
    c: c,
  }
}

// Count entry number
// 
// Parameters:
//  - Key
func (p *I64ListI64ServiceClient) Count(ctx context.Context, key TKey) (r int32, err error) {
  var _args1 I64ListI64ServiceCountArgs
  _args1.Key = key
  var _result2 I64ListI64ServiceCountResult
  if err = p.c.Call(ctx, "count", &_args1, &_result2); err != nil {
    return
  }
  return _result2.GetSuccess(), nil
}

// Test entry existence
// 
// Parameters:
//  - Key
//  - Entry
func (p *I64ListI64ServiceClient) Existed(ctx context.Context, key TKey, entry TEntry) (r bool, err error) {
  var _args3 I64ListI64ServiceExistedArgs
  _args3.Key = key
  _args3.Entry = entry
  var _result4 I64ListI64ServiceExistedResult
  if err = p.c.Call(ctx, "existed", &_args3, &_result4); err != nil {
    return
  }
  return _result4.GetSuccess(), nil
}

// Get list of all entries
// 
// Parameters:
//  - Key
func (p *I64ListI64ServiceClient) GetListAll(ctx context.Context, key TKey) (r TEntryList, err error) {
  var _args5 I64ListI64ServiceGetListAllArgs
  _args5.Key = key
  var _result6 I64ListI64ServiceGetListAllResult
  if err = p.c.Call(ctx, "getListAll", &_args5, &_result6); err != nil {
    return
  }
  return _result6.GetSuccess(), nil
}

// Parameters:
//  - Key
func (p *I64ListI64ServiceClient) GetAll(ctx context.Context, key TKey) (r TEntryList, err error) {
  var _args7 I64ListI64ServiceGetAllArgs
  _args7.Key = key
  var _result8 I64ListI64ServiceGetAllResult
  if err = p.c.Call(ctx, "getAll", &_args7, &_result8); err != nil {
    return
  }
  return _result8.GetSuccess(), nil
}

// Get list entry slice
// 
// Parameters:
//  - Key
//  - Start
//  - Length
func (p *I64ListI64ServiceClient) GetSlice(ctx context.Context, key TKey, start int32, length int32) (r TEntryList, err error) {
  var _args9 I64ListI64ServiceGetSliceArgs
  _args9.Key = key
  _args9.Start = start
  _args9.Length = length
  var _result10 I64ListI64ServiceGetSliceResult
  if err = p.c.Call(ctx, "getSlice", &_args9, &_result10); err != nil {
    return
  }
  return _result10.GetSuccess(), nil
}

// Parameters:
//  - Key
//  - EntryStart
//  - Length
func (p *I64ListI64ServiceClient) GetSliceFromEntry(ctx context.Context, key TKey, entryStart TEntry, length int32) (r TEntryList, err error) {
  var _args11 I64ListI64ServiceGetSliceFromEntryArgs
  _args11.Key = key
  _args11.EntryStart = entryStart
  _args11.Length = length
  var _result12 I64ListI64ServiceGetSliceFromEntryResult
  if err = p.c.Call(ctx, "getSliceFromEntry", &_args11, &_result12); err != nil {
    return
  }
  return _result12.GetSuccess(), nil
}

// Parameters:
//  - Key
//  - EntryStart
//  - Length
func (p *I64ListI64ServiceClient) GetSliceFromId(ctx context.Context, key TKey, entryStart TEntry, length int32) (r TEntryList, err error) {
  var _args13 I64ListI64ServiceGetSliceFromIdArgs
  _args13.Key = key
  _args13.EntryStart = entryStart
  _args13.Length = length
  var _result14 I64ListI64ServiceGetSliceFromIdResult
  if err = p.c.Call(ctx, "getSliceFromId", &_args13, &_result14); err != nil {
    return
  }
  return _result14.GetSuccess(), nil
}

// Parameters:
//  - Key
//  - Start
//  - Length
func (p *I64ListI64ServiceClient) GetSliceReverse(ctx context.Context, key TKey, start int32, length int32) (r TEntryList, err error) {
  var _args15 I64ListI64ServiceGetSliceReverseArgs
  _args15.Key = key
  _args15.Start = start
  _args15.Length = length
  var _result16 I64ListI64ServiceGetSliceReverseResult
  if err = p.c.Call(ctx, "getSliceReverse", &_args15, &_result16); err != nil {
    return
  }
  return _result16.GetSuccess(), nil
}

// Parameters:
//  - Key
//  - EntryStart
//  - Length
func (p *I64ListI64ServiceClient) GetSliceFromEntryReverse(ctx context.Context, key TKey, entryStart TEntry, length int32) (r TEntryList, err error) {
  var _args17 I64ListI64ServiceGetSliceFromEntryReverseArgs
  _args17.Key = key
  _args17.EntryStart = entryStart
  _args17.Length = length
  var _result18 I64ListI64ServiceGetSliceFromEntryReverseResult
  if err = p.c.Call(ctx, "getSliceFromEntryReverse", &_args17, &_result18); err != nil {
    return
  }
  return _result18.GetSuccess(), nil
}

// Parameters:
//  - Key
//  - EntryStart
//  - Length
func (p *I64ListI64ServiceClient) GetSliceFromIdReverse(ctx context.Context, key TKey, entryStart TEntry, length int32) (r TEntryList, err error) {
  var _args19 I64ListI64ServiceGetSliceFromIdReverseArgs
  _args19.Key = key
  _args19.EntryStart = entryStart
  _args19.Length = length
  var _result20 I64ListI64ServiceGetSliceFromIdReverseResult
  if err = p.c.Call(ctx, "getSliceFromIdReverse", &_args19, &_result20); err != nil {
    return
  }
  return _result20.GetSuccess(), nil
}

// Put an entry, update on entry existence
// For unsorted list this insert at end()
// 
// Parameters:
//  - Key
//  - Entry
func (p *I64ListI64ServiceClient) Put(ctx context.Context, key TKey, entry TEntry) (r bool, err error) {
  var _args21 I64ListI64ServicePutArgs
  _args21.Key = key
  _args21.Entry = entry
  var _result22 I64ListI64ServicePutResult
  if err = p.c.Call(ctx, "put", &_args21, &_result22); err != nil {
    return
  }
  return _result22.GetSuccess(), nil
}

// Clear old data, put new value on the key
// 
// Parameters:
//  - Key
//  - Value
func (p *I64ListI64ServiceClient) PutValue(ctx context.Context, key TKey, value *TValue) (r bool, err error) {
  var _args23 I64ListI64ServicePutValueArgs
  _args23.Key = key
  _args23.Value = value
  var _result24 I64ListI64ServicePutValueResult
  if err = p.c.Call(ctx, "putValue", &_args23, &_result24); err != nil {
    return
  }
  return _result24.GetSuccess(), nil
}

// Put list of entry, update on entry existence
// 
// Parameters:
//  - Key
//  - EntryList
func (p *I64ListI64ServiceClient) PutList(ctx context.Context, key TKey, entryList TEntryList) (r bool, err error) {
  var _args25 I64ListI64ServicePutListArgs
  _args25.Key = key
  _args25.EntryList = entryList
  var _result26 I64ListI64ServicePutListResult
  if err = p.c.Call(ctx, "putList", &_args25, &_result26); err != nil {
    return
  }
  return _result26.GetSuccess(), nil
}

// Insert an entry, return false on key existence
// @return true on successful insertion, false otherwise (due to length limit or entry existed on sorted list)
// For unsorted list this insert at end()
// 
// Parameters:
//  - Key
//  - Entry
func (p *I64ListI64ServiceClient) Insert(ctx context.Context, key TKey, entry TEntry) (r bool, err error) {
  var _args27 I64ListI64ServiceInsertArgs
  _args27.Key = key
  _args27.Entry = entry
  var _result28 I64ListI64ServiceInsertResult
  if err = p.c.Call(ctx, "insert", &_args27, &_result28); err != nil {
    return
  }
  return _result28.GetSuccess(), nil
}

// Insert an entry at index
// @param index considered count from begin if non-negative, count from end otherwise
// the entry will have index = start after insertion
// e.g. 0 = push_front, -1 = push_back, -2 = the entry before last entry
// For sorted list this calls insert
// 
// Parameters:
//  - Key
//  - Entry
//  - Index
func (p *I64ListI64ServiceClient) InsertAt(ctx context.Context, key TKey, entry TEntry, index int32) (r bool, err error) {
  var _args29 I64ListI64ServiceInsertAtArgs
  _args29.Key = key
  _args29.Entry = entry
  _args29.Index = index
  var _result30 I64ListI64ServiceInsertAtResult
  if err = p.c.Call(ctx, "insertAt", &_args29, &_result30); err != nil {
    return
  }
  return _result30.GetSuccess(), nil
}

// Remove an entry, return false if entry not found
// 
// Parameters:
//  - Key
//  - Entry
func (p *I64ListI64ServiceClient) Remove(ctx context.Context, key TKey, entry TEntry) (r bool, err error) {
  var _args31 I64ListI64ServiceRemoveArgs
  _args31.Key = key
  _args31.Entry = entry
  var _result32 I64ListI64ServiceRemoveResult
  if err = p.c.Call(ctx, "remove", &_args31, &_result32); err != nil {
    return
  }
  return _result32.GetSuccess(), nil
}

// Remove entry by index
// @param index similar to insertAt
// 
// Parameters:
//  - Key
//  - Index
func (p *I64ListI64ServiceClient) RemoveAt(ctx context.Context, key TKey, index int32) (r bool, err error) {
  var _args33 I64ListI64ServiceRemoveAtArgs
  _args33.Key = key
  _args33.Index = index
  var _result34 I64ListI64ServiceRemoveAtResult
  if err = p.c.Call(ctx, "removeAt", &_args33, &_result34); err != nil {
    return
  }
  return _result34.GetSuccess(), nil
}

// Make an entry the first in unsorted list and return true if it existed, do nothing on sorted list return false
// 
// Parameters:
//  - Key
//  - Entry
func (p *I64ListI64ServiceClient) BumpUp(ctx context.Context, key TKey, entry TEntry) (r bool, err error) {
  var _args35 I64ListI64ServiceBumpUpArgs
  _args35.Key = key
  _args35.Entry = entry
  var _result36 I64ListI64ServiceBumpUpResult
  if err = p.c.Call(ctx, "bumpUp", &_args35, &_result36); err != nil {
    return
  }
  return _result36.GetSuccess(), nil
}

// Remove entry list
// 
// Parameters:
//  - Key
//  - EntryList
func (p *I64ListI64ServiceClient) RemoveList(ctx context.Context, key TKey, entryList TEntryList) (r bool, err error) {
  var _args37 I64ListI64ServiceRemoveListArgs
  _args37.Key = key
  _args37.EntryList = entryList
  var _result38 I64ListI64ServiceRemoveListResult
  if err = p.c.Call(ctx, "removeList", &_args37, &_result38); err != nil {
    return
  }
  return _result38.GetSuccess(), nil
}

// Clear data on given key
// 
// Parameters:
//  - Key
func (p *I64ListI64ServiceClient) ClearData(ctx context.Context, key TKey) (err error) {
  var _args39 I64ListI64ServiceClearDataArgs
  _args39.Key = key
  var _result40 I64ListI64ServiceClearDataResult
  if err = p.c.Call(ctx, "clearData", &_args39, &_result40); err != nil {
    return
  }
  return nil
}

// Split the list into 2, return first entry of new list, or -1 if fails
// 
// Parameters:
//  - OldKey
//  - NewKey_
//  - OrigLength
func (p *I64ListI64ServiceClient) Split(ctx context.Context, oldKey TKey, newKey TKey, origLength int32) (r TEntry, err error) {
  var _args41 I64ListI64ServiceSplitArgs
  _args41.OldKey = oldKey
  _args41.NewKey_ = newKey
  _args41.OrigLength = origLength
  var _result42 I64ListI64ServiceSplitResult
  if err = p.c.Call(ctx, "split", &_args41, &_result42); err != nil {
    return
  }
  return _result42.GetSuccess(), nil
}

// Parameters:
//  - KeyList
func (p *I64ListI64ServiceClient) MultiCount(ctx context.Context, keyList TKeyList) (r map[TKey]int32, err error) {
  var _args43 I64ListI64ServiceMultiCountArgs
  _args43.KeyList = keyList
  var _result44 I64ListI64ServiceMultiCountResult
  if err = p.c.Call(ctx, "multiCount", &_args43, &_result44); err != nil {
    return
  }
  return _result44.GetSuccess(), nil
}

// Parameters:
//  - KeyList
//  - Entry
func (p *I64ListI64ServiceClient) MultiExisted(ctx context.Context, keyList TKeyList, entry TEntry) (r map[TKey]bool, err error) {
  var _args45 I64ListI64ServiceMultiExistedArgs
  _args45.KeyList = keyList
  _args45.Entry = entry
  var _result46 I64ListI64ServiceMultiExistedResult
  if err = p.c.Call(ctx, "multiExisted", &_args45, &_result46); err != nil {
    return
  }
  return _result46.GetSuccess(), nil
}

// Parameters:
//  - KeyList
func (p *I64ListI64ServiceClient) MultiGetListAll(ctx context.Context, keyList TKeyList) (r map[TKey]TEntryList, err error) {
  var _args47 I64ListI64ServiceMultiGetListAllArgs
  _args47.KeyList = keyList
  var _result48 I64ListI64ServiceMultiGetListAllResult
  if err = p.c.Call(ctx, "multiGetListAll", &_args47, &_result48); err != nil {
    return
  }
  return _result48.GetSuccess(), nil
}

// Parameters:
//  - KeyList
//  - Start
//  - Length
func (p *I64ListI64ServiceClient) MultiGetSlice(ctx context.Context, keyList TKeyList, start int32, length int32) (r map[TKey]TEntryList, err error) {
  var _args49 I64ListI64ServiceMultiGetSliceArgs
  _args49.KeyList = keyList
  _args49.Start = start
  _args49.Length = length
  var _result50 I64ListI64ServiceMultiGetSliceResult
  if err = p.c.Call(ctx, "multiGetSlice", &_args49, &_result50); err != nil {
    return
  }
  return _result50.GetSuccess(), nil
}

// Parameters:
//  - KeyList
//  - Start
//  - Length
func (p *I64ListI64ServiceClient) MultiGetSliceReverse(ctx context.Context, keyList TKeyList, start int32, length int32) (r map[TKey]TEntryList, err error) {
  var _args51 I64ListI64ServiceMultiGetSliceReverseArgs
  _args51.KeyList = keyList
  _args51.Start = start
  _args51.Length = length
  var _result52 I64ListI64ServiceMultiGetSliceReverseResult
  if err = p.c.Call(ctx, "multiGetSliceReverse", &_args51, &_result52); err != nil {
    return
  }
  return _result52.GetSuccess(), nil
}

// Put same entry to multiple keys
// 
// Parameters:
//  - KeyList
//  - Entry
func (p *I64ListI64ServiceClient) MultiPut(ctx context.Context, keyList TKeyList, entry TEntry) (r map[TKey]bool, err error) {
  var _args53 I64ListI64ServiceMultiPutArgs
  _args53.KeyList = keyList
  _args53.Entry = entry
  var _result54 I64ListI64ServiceMultiPutResult
  if err = p.c.Call(ctx, "multiPut", &_args53, &_result54); err != nil {
    return
  }
  return _result54.GetSuccess(), nil
}

// Parameters:
//  - Key
//  - Entry
func (p *I64ListI64ServiceClient) PutOw(ctx context.Context, key TKey, entry TEntry) (err error) {
  var _args55 I64ListI64ServicePutOwArgs
  _args55.Key = key
  _args55.Entry = entry
  if err := p.c.Call(ctx, "put_ow", &_args55, nil); err != nil {
    return err
  }
  return nil
}

// Parameters:
//  - UidList
//  - Entry
func (p *I64ListI64ServiceClient) PutMultiKeyOw(ctx context.Context, uidList TKeyList, entry TEntry) (err error) {
  var _args56 I64ListI64ServicePutMultiKeyOwArgs
  _args56.UidList = uidList
  _args56.Entry = entry
  if err := p.c.Call(ctx, "putMultiKey_ow", &_args56, nil); err != nil {
    return err
  }
  return nil
}

// Parameters:
//  - Key
//  - Entry
func (p *I64ListI64ServiceClient) RemoveOw(ctx context.Context, key TKey, entry TEntry) (err error) {
  var _args57 I64ListI64ServiceRemoveOwArgs
  _args57.Key = key
  _args57.Entry = entry
  if err := p.c.Call(ctx, "remove_ow", &_args57, nil); err != nil {
    return err
  }
  return nil
}

type I64ListI64ServiceProcessor struct {
  processorMap map[string]thrift.TProcessorFunction
  handler I64ListI64Service
}

func (p *I64ListI64ServiceProcessor) AddToProcessorMap(key string, processor thrift.TProcessorFunction) {
  p.processorMap[key] = processor
}

func (p *I64ListI64ServiceProcessor) GetProcessorFunction(key string) (processor thrift.TProcessorFunction, ok bool) {
  processor, ok = p.processorMap[key]
  return processor, ok
}

func (p *I64ListI64ServiceProcessor) ProcessorMap() map[string]thrift.TProcessorFunction {
  return p.processorMap
}

func NewI64ListI64ServiceProcessor(handler I64ListI64Service) *I64ListI64ServiceProcessor {

  self58 := &I64ListI64ServiceProcessor{handler:handler, processorMap:make(map[string]thrift.TProcessorFunction)}
  self58.processorMap["count"] = &i64ListI64ServiceProcessorCount{handler:handler}
  self58.processorMap["existed"] = &i64ListI64ServiceProcessorExisted{handler:handler}
  self58.processorMap["getListAll"] = &i64ListI64ServiceProcessorGetListAll{handler:handler}
  self58.processorMap["getAll"] = &i64ListI64ServiceProcessorGetAll{handler:handler}
  self58.processorMap["getSlice"] = &i64ListI64ServiceProcessorGetSlice{handler:handler}
  self58.processorMap["getSliceFromEntry"] = &i64ListI64ServiceProcessorGetSliceFromEntry{handler:handler}
  self58.processorMap["getSliceFromId"] = &i64ListI64ServiceProcessorGetSliceFromId{handler:handler}
  self58.processorMap["getSliceReverse"] = &i64ListI64ServiceProcessorGetSliceReverse{handler:handler}
  self58.processorMap["getSliceFromEntryReverse"] = &i64ListI64ServiceProcessorGetSliceFromEntryReverse{handler:handler}
  self58.processorMap["getSliceFromIdReverse"] = &i64ListI64ServiceProcessorGetSliceFromIdReverse{handler:handler}
  self58.processorMap["put"] = &i64ListI64ServiceProcessorPut{handler:handler}
  self58.processorMap["putValue"] = &i64ListI64ServiceProcessorPutValue{handler:handler}
  self58.processorMap["putList"] = &i64ListI64ServiceProcessorPutList{handler:handler}
  self58.processorMap["insert"] = &i64ListI64ServiceProcessorInsert{handler:handler}
  self58.processorMap["insertAt"] = &i64ListI64ServiceProcessorInsertAt{handler:handler}
  self58.processorMap["remove"] = &i64ListI64ServiceProcessorRemove{handler:handler}
  self58.processorMap["removeAt"] = &i64ListI64ServiceProcessorRemoveAt{handler:handler}
  self58.processorMap["bumpUp"] = &i64ListI64ServiceProcessorBumpUp{handler:handler}
  self58.processorMap["removeList"] = &i64ListI64ServiceProcessorRemoveList{handler:handler}
  self58.processorMap["clearData"] = &i64ListI64ServiceProcessorClearData{handler:handler}
  self58.processorMap["split"] = &i64ListI64ServiceProcessorSplit{handler:handler}
  self58.processorMap["multiCount"] = &i64ListI64ServiceProcessorMultiCount{handler:handler}
  self58.processorMap["multiExisted"] = &i64ListI64ServiceProcessorMultiExisted{handler:handler}
  self58.processorMap["multiGetListAll"] = &i64ListI64ServiceProcessorMultiGetListAll{handler:handler}
  self58.processorMap["multiGetSlice"] = &i64ListI64ServiceProcessorMultiGetSlice{handler:handler}
  self58.processorMap["multiGetSliceReverse"] = &i64ListI64ServiceProcessorMultiGetSliceReverse{handler:handler}
  self58.processorMap["multiPut"] = &i64ListI64ServiceProcessorMultiPut{handler:handler}
  self58.processorMap["put_ow"] = &i64ListI64ServiceProcessorPutOw{handler:handler}
  self58.processorMap["putMultiKey_ow"] = &i64ListI64ServiceProcessorPutMultiKeyOw{handler:handler}
  self58.processorMap["remove_ow"] = &i64ListI64ServiceProcessorRemoveOw{handler:handler}
return self58
}

func (p *I64ListI64ServiceProcessor) Process(ctx context.Context, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  name, _, seqId, err := iprot.ReadMessageBegin()
  if err != nil { return false, err }
  if processor, ok := p.GetProcessorFunction(name); ok {
    return processor.Process(ctx, seqId, iprot, oprot)
  }
  iprot.Skip(thrift.STRUCT)
  iprot.ReadMessageEnd()
  x59 := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function " + name)
  oprot.WriteMessageBegin(name, thrift.EXCEPTION, seqId)
  x59.Write(oprot)
  oprot.WriteMessageEnd()
  oprot.Flush()
  return false, x59

}

type i64ListI64ServiceProcessorCount struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorCount) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceCountArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("count", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceCountResult{}
var retval int32
  var err2 error
  if retval, err2 = p.handler.Count(ctx, args.Key); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing count: " + err2.Error())
    oprot.WriteMessageBegin("count", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = &retval
}
  if err2 = oprot.WriteMessageBegin("count", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorExisted struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorExisted) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceExistedArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("existed", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceExistedResult{}
var retval bool
  var err2 error
  if retval, err2 = p.handler.Existed(ctx, args.Key, args.Entry); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing existed: " + err2.Error())
    oprot.WriteMessageBegin("existed", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = &retval
}
  if err2 = oprot.WriteMessageBegin("existed", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorGetListAll struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorGetListAll) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceGetListAllArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("getListAll", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceGetListAllResult{}
var retval TEntryList
  var err2 error
  if retval, err2 = p.handler.GetListAll(ctx, args.Key); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getListAll: " + err2.Error())
    oprot.WriteMessageBegin("getListAll", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = retval
}
  if err2 = oprot.WriteMessageBegin("getListAll", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorGetAll struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorGetAll) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceGetAllArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("getAll", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceGetAllResult{}
var retval TEntryList
  var err2 error
  if retval, err2 = p.handler.GetAll(ctx, args.Key); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getAll: " + err2.Error())
    oprot.WriteMessageBegin("getAll", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = retval
}
  if err2 = oprot.WriteMessageBegin("getAll", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorGetSlice struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorGetSlice) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceGetSliceArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("getSlice", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceGetSliceResult{}
var retval TEntryList
  var err2 error
  if retval, err2 = p.handler.GetSlice(ctx, args.Key, args.Start, args.Length); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getSlice: " + err2.Error())
    oprot.WriteMessageBegin("getSlice", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = retval
}
  if err2 = oprot.WriteMessageBegin("getSlice", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorGetSliceFromEntry struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorGetSliceFromEntry) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceGetSliceFromEntryArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("getSliceFromEntry", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceGetSliceFromEntryResult{}
var retval TEntryList
  var err2 error
  if retval, err2 = p.handler.GetSliceFromEntry(ctx, args.Key, args.EntryStart, args.Length); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getSliceFromEntry: " + err2.Error())
    oprot.WriteMessageBegin("getSliceFromEntry", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = retval
}
  if err2 = oprot.WriteMessageBegin("getSliceFromEntry", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorGetSliceFromId struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorGetSliceFromId) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceGetSliceFromIdArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("getSliceFromId", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceGetSliceFromIdResult{}
var retval TEntryList
  var err2 error
  if retval, err2 = p.handler.GetSliceFromId(ctx, args.Key, args.EntryStart, args.Length); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getSliceFromId: " + err2.Error())
    oprot.WriteMessageBegin("getSliceFromId", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = retval
}
  if err2 = oprot.WriteMessageBegin("getSliceFromId", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorGetSliceReverse struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorGetSliceReverse) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceGetSliceReverseArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("getSliceReverse", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceGetSliceReverseResult{}
var retval TEntryList
  var err2 error
  if retval, err2 = p.handler.GetSliceReverse(ctx, args.Key, args.Start, args.Length); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getSliceReverse: " + err2.Error())
    oprot.WriteMessageBegin("getSliceReverse", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = retval
}
  if err2 = oprot.WriteMessageBegin("getSliceReverse", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorGetSliceFromEntryReverse struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorGetSliceFromEntryReverse) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceGetSliceFromEntryReverseArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("getSliceFromEntryReverse", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceGetSliceFromEntryReverseResult{}
var retval TEntryList
  var err2 error
  if retval, err2 = p.handler.GetSliceFromEntryReverse(ctx, args.Key, args.EntryStart, args.Length); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getSliceFromEntryReverse: " + err2.Error())
    oprot.WriteMessageBegin("getSliceFromEntryReverse", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = retval
}
  if err2 = oprot.WriteMessageBegin("getSliceFromEntryReverse", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorGetSliceFromIdReverse struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorGetSliceFromIdReverse) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceGetSliceFromIdReverseArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("getSliceFromIdReverse", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceGetSliceFromIdReverseResult{}
var retval TEntryList
  var err2 error
  if retval, err2 = p.handler.GetSliceFromIdReverse(ctx, args.Key, args.EntryStart, args.Length); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getSliceFromIdReverse: " + err2.Error())
    oprot.WriteMessageBegin("getSliceFromIdReverse", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = retval
}
  if err2 = oprot.WriteMessageBegin("getSliceFromIdReverse", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorPut struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorPut) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServicePutArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("put", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServicePutResult{}
var retval bool
  var err2 error
  if retval, err2 = p.handler.Put(ctx, args.Key, args.Entry); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing put: " + err2.Error())
    oprot.WriteMessageBegin("put", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = &retval
}
  if err2 = oprot.WriteMessageBegin("put", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorPutValue struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorPutValue) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServicePutValueArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("putValue", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServicePutValueResult{}
var retval bool
  var err2 error
  if retval, err2 = p.handler.PutValue(ctx, args.Key, args.Value); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing putValue: " + err2.Error())
    oprot.WriteMessageBegin("putValue", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = &retval
}
  if err2 = oprot.WriteMessageBegin("putValue", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorPutList struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorPutList) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServicePutListArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("putList", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServicePutListResult{}
var retval bool
  var err2 error
  if retval, err2 = p.handler.PutList(ctx, args.Key, args.EntryList); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing putList: " + err2.Error())
    oprot.WriteMessageBegin("putList", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = &retval
}
  if err2 = oprot.WriteMessageBegin("putList", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorInsert struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorInsert) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceInsertArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("insert", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceInsertResult{}
var retval bool
  var err2 error
  if retval, err2 = p.handler.Insert(ctx, args.Key, args.Entry); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing insert: " + err2.Error())
    oprot.WriteMessageBegin("insert", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = &retval
}
  if err2 = oprot.WriteMessageBegin("insert", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorInsertAt struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorInsertAt) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceInsertAtArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("insertAt", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceInsertAtResult{}
var retval bool
  var err2 error
  if retval, err2 = p.handler.InsertAt(ctx, args.Key, args.Entry, args.Index); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing insertAt: " + err2.Error())
    oprot.WriteMessageBegin("insertAt", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = &retval
}
  if err2 = oprot.WriteMessageBegin("insertAt", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorRemove struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorRemove) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceRemoveArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("remove", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceRemoveResult{}
var retval bool
  var err2 error
  if retval, err2 = p.handler.Remove(ctx, args.Key, args.Entry); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing remove: " + err2.Error())
    oprot.WriteMessageBegin("remove", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = &retval
}
  if err2 = oprot.WriteMessageBegin("remove", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorRemoveAt struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorRemoveAt) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceRemoveAtArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("removeAt", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceRemoveAtResult{}
var retval bool
  var err2 error
  if retval, err2 = p.handler.RemoveAt(ctx, args.Key, args.Index); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing removeAt: " + err2.Error())
    oprot.WriteMessageBegin("removeAt", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = &retval
}
  if err2 = oprot.WriteMessageBegin("removeAt", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorBumpUp struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorBumpUp) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceBumpUpArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("bumpUp", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceBumpUpResult{}
var retval bool
  var err2 error
  if retval, err2 = p.handler.BumpUp(ctx, args.Key, args.Entry); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing bumpUp: " + err2.Error())
    oprot.WriteMessageBegin("bumpUp", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = &retval
}
  if err2 = oprot.WriteMessageBegin("bumpUp", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorRemoveList struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorRemoveList) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceRemoveListArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("removeList", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceRemoveListResult{}
var retval bool
  var err2 error
  if retval, err2 = p.handler.RemoveList(ctx, args.Key, args.EntryList); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing removeList: " + err2.Error())
    oprot.WriteMessageBegin("removeList", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = &retval
}
  if err2 = oprot.WriteMessageBegin("removeList", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorClearData struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorClearData) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceClearDataArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("clearData", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceClearDataResult{}
  var err2 error
  if err2 = p.handler.ClearData(ctx, args.Key); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing clearData: " + err2.Error())
    oprot.WriteMessageBegin("clearData", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  }
  if err2 = oprot.WriteMessageBegin("clearData", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorSplit struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorSplit) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceSplitArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("split", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceSplitResult{}
var retval TEntry
  var err2 error
  if retval, err2 = p.handler.Split(ctx, args.OldKey, args.NewKey_, args.OrigLength); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing split: " + err2.Error())
    oprot.WriteMessageBegin("split", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = &retval
}
  if err2 = oprot.WriteMessageBegin("split", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorMultiCount struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorMultiCount) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceMultiCountArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("multiCount", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceMultiCountResult{}
var retval map[TKey]int32
  var err2 error
  if retval, err2 = p.handler.MultiCount(ctx, args.KeyList); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing multiCount: " + err2.Error())
    oprot.WriteMessageBegin("multiCount", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = retval
}
  if err2 = oprot.WriteMessageBegin("multiCount", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorMultiExisted struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorMultiExisted) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceMultiExistedArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("multiExisted", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceMultiExistedResult{}
var retval map[TKey]bool
  var err2 error
  if retval, err2 = p.handler.MultiExisted(ctx, args.KeyList, args.Entry); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing multiExisted: " + err2.Error())
    oprot.WriteMessageBegin("multiExisted", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = retval
}
  if err2 = oprot.WriteMessageBegin("multiExisted", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorMultiGetListAll struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorMultiGetListAll) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceMultiGetListAllArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("multiGetListAll", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceMultiGetListAllResult{}
var retval map[TKey]TEntryList
  var err2 error
  if retval, err2 = p.handler.MultiGetListAll(ctx, args.KeyList); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing multiGetListAll: " + err2.Error())
    oprot.WriteMessageBegin("multiGetListAll", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = retval
}
  if err2 = oprot.WriteMessageBegin("multiGetListAll", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorMultiGetSlice struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorMultiGetSlice) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceMultiGetSliceArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("multiGetSlice", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceMultiGetSliceResult{}
var retval map[TKey]TEntryList
  var err2 error
  if retval, err2 = p.handler.MultiGetSlice(ctx, args.KeyList, args.Start, args.Length); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing multiGetSlice: " + err2.Error())
    oprot.WriteMessageBegin("multiGetSlice", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = retval
}
  if err2 = oprot.WriteMessageBegin("multiGetSlice", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorMultiGetSliceReverse struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorMultiGetSliceReverse) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceMultiGetSliceReverseArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("multiGetSliceReverse", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceMultiGetSliceReverseResult{}
var retval map[TKey]TEntryList
  var err2 error
  if retval, err2 = p.handler.MultiGetSliceReverse(ctx, args.KeyList, args.Start, args.Length); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing multiGetSliceReverse: " + err2.Error())
    oprot.WriteMessageBegin("multiGetSliceReverse", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = retval
}
  if err2 = oprot.WriteMessageBegin("multiGetSliceReverse", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorMultiPut struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorMultiPut) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceMultiPutArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error())
    oprot.WriteMessageBegin("multiPut", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return false, err
  }

  iprot.ReadMessageEnd()
  result := I64ListI64ServiceMultiPutResult{}
var retval map[TKey]bool
  var err2 error
  if retval, err2 = p.handler.MultiPut(ctx, args.KeyList, args.Entry); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing multiPut: " + err2.Error())
    oprot.WriteMessageBegin("multiPut", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = retval
}
  if err2 = oprot.WriteMessageBegin("multiPut", thrift.REPLY, seqId); err2 != nil {
    err = err2
  }
  if err2 = result.Write(oprot); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil {
    err = err2
  }
  if err2 = oprot.Flush(); err == nil && err2 != nil {
    err = err2
  }
  if err != nil {
    return
  }
  return true, err
}

type i64ListI64ServiceProcessorPutOw struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorPutOw) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServicePutOwArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    return false, err
  }

  iprot.ReadMessageEnd()
  var err2 error
  if err2 = p.handler.PutOw(ctx, args.Key, args.Entry); err2 != nil {
    return true, err2
  }
  return true, nil
}

type i64ListI64ServiceProcessorPutMultiKeyOw struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorPutMultiKeyOw) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServicePutMultiKeyOwArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    return false, err
  }

  iprot.ReadMessageEnd()
  var err2 error
  if err2 = p.handler.PutMultiKeyOw(ctx, args.UidList, args.Entry); err2 != nil {
    return true, err2
  }
  return true, nil
}

type i64ListI64ServiceProcessorRemoveOw struct {
  handler I64ListI64Service
}

func (p *i64ListI64ServiceProcessorRemoveOw) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) {
  args := I64ListI64ServiceRemoveOwArgs{}
  if err = args.Read(iprot); err != nil {
    iprot.ReadMessageEnd()
    return false, err
  }

  iprot.ReadMessageEnd()
  var err2 error
  if err2 = p.handler.RemoveOw(ctx, args.Key, args.Entry); err2 != nil {
    return true, err2
  }
  return true, nil
}


// HELPER FUNCTIONS AND STRUCTURES

// Attributes:
//  - Key
type I64ListI64ServiceCountArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
}

func NewI64ListI64ServiceCountArgs() *I64ListI64ServiceCountArgs {
  return &I64ListI64ServiceCountArgs{}
}


func (p *I64ListI64ServiceCountArgs) GetKey() TKey {
  return p.Key
}
func (p *I64ListI64ServiceCountArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceCountArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceCountArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("count_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceCountArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceCountArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceCountArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceCountResult struct {
  Success *int32 `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceCountResult() *I64ListI64ServiceCountResult {
  return &I64ListI64ServiceCountResult{}
}

var I64ListI64ServiceCountResult_Success_DEFAULT int32
func (p *I64ListI64ServiceCountResult) GetSuccess() int32 {
  if !p.IsSetSuccess() {
    return I64ListI64ServiceCountResult_Success_DEFAULT
  }
return *p.Success
}
func (p *I64ListI64ServiceCountResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceCountResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceCountResult)  ReadField0(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 0: ", err)
} else {
  p.Success = &v
}
  return nil
}

func (p *I64ListI64ServiceCountResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("count_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceCountResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.I32, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteI32(int32(*p.Success)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceCountResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceCountResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - Entry
type I64ListI64ServiceExistedArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  Entry TEntry `thrift:"entry,2" db:"entry" json:"entry"`
}

func NewI64ListI64ServiceExistedArgs() *I64ListI64ServiceExistedArgs {
  return &I64ListI64ServiceExistedArgs{}
}


func (p *I64ListI64ServiceExistedArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServiceExistedArgs) GetEntry() TEntry {
  return p.Entry
}
func (p *I64ListI64ServiceExistedArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceExistedArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceExistedArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TEntry(v)
  p.Entry = temp
}
  return nil
}

func (p *I64ListI64ServiceExistedArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("existed_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceExistedArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceExistedArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entry", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entry: ", p), err) }
  if err := oprot.WriteI64(int64(p.Entry)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entry (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entry: ", p), err) }
  return err
}

func (p *I64ListI64ServiceExistedArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceExistedArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceExistedResult struct {
  Success *bool `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceExistedResult() *I64ListI64ServiceExistedResult {
  return &I64ListI64ServiceExistedResult{}
}

var I64ListI64ServiceExistedResult_Success_DEFAULT bool
func (p *I64ListI64ServiceExistedResult) GetSuccess() bool {
  if !p.IsSetSuccess() {
    return I64ListI64ServiceExistedResult_Success_DEFAULT
  }
return *p.Success
}
func (p *I64ListI64ServiceExistedResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceExistedResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceExistedResult)  ReadField0(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 0: ", err)
} else {
  p.Success = &v
}
  return nil
}

func (p *I64ListI64ServiceExistedResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("existed_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceExistedResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.BOOL, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteBool(bool(*p.Success)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceExistedResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceExistedResult(%+v)", *p)
}

// Attributes:
//  - Key
type I64ListI64ServiceGetListAllArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
}

func NewI64ListI64ServiceGetListAllArgs() *I64ListI64ServiceGetListAllArgs {
  return &I64ListI64ServiceGetListAllArgs{}
}


func (p *I64ListI64ServiceGetListAllArgs) GetKey() TKey {
  return p.Key
}
func (p *I64ListI64ServiceGetListAllArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetListAllArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceGetListAllArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getListAll_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetListAllArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetListAllArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetListAllArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceGetListAllResult struct {
  Success TEntryList `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceGetListAllResult() *I64ListI64ServiceGetListAllResult {
  return &I64ListI64ServiceGetListAllResult{}
}

var I64ListI64ServiceGetListAllResult_Success_DEFAULT TEntryList

func (p *I64ListI64ServiceGetListAllResult) GetSuccess() TEntryList {
  return p.Success
}
func (p *I64ListI64ServiceGetListAllResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceGetListAllResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetListAllResult)  ReadField0(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TEntryList, 0, size)
  p.Success =  tSlice
  for i := 0; i < size; i ++ {
var _elem60 TEntry
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TEntry(v)
    _elem60 = temp
}
    p.Success = append(p.Success, _elem60)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceGetListAllResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getListAll_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetListAllResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.LIST, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteListBegin(thrift.I64, len(p.Success)); err != nil {
      return thrift.PrependError("error writing list begin: ", err)
    }
    for _, v := range p.Success {
      if err := oprot.WriteI64(int64(v)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
    }
    if err := oprot.WriteListEnd(); err != nil {
      return thrift.PrependError("error writing list end: ", err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceGetListAllResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetListAllResult(%+v)", *p)
}

// Attributes:
//  - Key
type I64ListI64ServiceGetAllArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
}

func NewI64ListI64ServiceGetAllArgs() *I64ListI64ServiceGetAllArgs {
  return &I64ListI64ServiceGetAllArgs{}
}


func (p *I64ListI64ServiceGetAllArgs) GetKey() TKey {
  return p.Key
}
func (p *I64ListI64ServiceGetAllArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetAllArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceGetAllArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getAll_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetAllArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetAllArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetAllArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceGetAllResult struct {
  Success TEntryList `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceGetAllResult() *I64ListI64ServiceGetAllResult {
  return &I64ListI64ServiceGetAllResult{}
}

var I64ListI64ServiceGetAllResult_Success_DEFAULT TEntryList

func (p *I64ListI64ServiceGetAllResult) GetSuccess() TEntryList {
  return p.Success
}
func (p *I64ListI64ServiceGetAllResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceGetAllResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetAllResult)  ReadField0(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TEntryList, 0, size)
  p.Success =  tSlice
  for i := 0; i < size; i ++ {
var _elem61 TEntry
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TEntry(v)
    _elem61 = temp
}
    p.Success = append(p.Success, _elem61)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceGetAllResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getAll_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetAllResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.LIST, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteListBegin(thrift.I64, len(p.Success)); err != nil {
      return thrift.PrependError("error writing list begin: ", err)
    }
    for _, v := range p.Success {
      if err := oprot.WriteI64(int64(v)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
    }
    if err := oprot.WriteListEnd(); err != nil {
      return thrift.PrependError("error writing list end: ", err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceGetAllResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetAllResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - Start
//  - Length
type I64ListI64ServiceGetSliceArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  Start int32 `thrift:"start,2" db:"start" json:"start"`
  Length int32 `thrift:"length,3" db:"length" json:"length"`
}

func NewI64ListI64ServiceGetSliceArgs() *I64ListI64ServiceGetSliceArgs {
  return &I64ListI64ServiceGetSliceArgs{}
}


func (p *I64ListI64ServiceGetSliceArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServiceGetSliceArgs) GetStart() int32 {
  return p.Start
}

func (p *I64ListI64ServiceGetSliceArgs) GetLength() int32 {
  return p.Length
}
func (p *I64ListI64ServiceGetSliceArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField3(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceGetSliceArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Start = v
}
  return nil
}

func (p *I64ListI64ServiceGetSliceArgs)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Length = v
}
  return nil
}

func (p *I64ListI64ServiceGetSliceArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getSlice_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetSliceArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("start", thrift.I32, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:start: ", p), err) }
  if err := oprot.WriteI32(int32(p.Start)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.start (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:start: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceArgs) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("length", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:length: ", p), err) }
  if err := oprot.WriteI32(int32(p.Length)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.length (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:length: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetSliceArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceGetSliceResult struct {
  Success TEntryList `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceGetSliceResult() *I64ListI64ServiceGetSliceResult {
  return &I64ListI64ServiceGetSliceResult{}
}

var I64ListI64ServiceGetSliceResult_Success_DEFAULT TEntryList

func (p *I64ListI64ServiceGetSliceResult) GetSuccess() TEntryList {
  return p.Success
}
func (p *I64ListI64ServiceGetSliceResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceGetSliceResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceResult)  ReadField0(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TEntryList, 0, size)
  p.Success =  tSlice
  for i := 0; i < size; i ++ {
var _elem62 TEntry
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TEntry(v)
    _elem62 = temp
}
    p.Success = append(p.Success, _elem62)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getSlice_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetSliceResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.LIST, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteListBegin(thrift.I64, len(p.Success)); err != nil {
      return thrift.PrependError("error writing list begin: ", err)
    }
    for _, v := range p.Success {
      if err := oprot.WriteI64(int64(v)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
    }
    if err := oprot.WriteListEnd(); err != nil {
      return thrift.PrependError("error writing list end: ", err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceGetSliceResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetSliceResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - EntryStart
//  - Length
type I64ListI64ServiceGetSliceFromEntryArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  EntryStart TEntry `thrift:"entryStart,2" db:"entryStart" json:"entryStart"`
  Length int32 `thrift:"length,3" db:"length" json:"length"`
}

func NewI64ListI64ServiceGetSliceFromEntryArgs() *I64ListI64ServiceGetSliceFromEntryArgs {
  return &I64ListI64ServiceGetSliceFromEntryArgs{}
}


func (p *I64ListI64ServiceGetSliceFromEntryArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServiceGetSliceFromEntryArgs) GetEntryStart() TEntry {
  return p.EntryStart
}

func (p *I64ListI64ServiceGetSliceFromEntryArgs) GetLength() int32 {
  return p.Length
}
func (p *I64ListI64ServiceGetSliceFromEntryArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField3(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TEntry(v)
  p.EntryStart = temp
}
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryArgs)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Length = v
}
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getSliceFromEntry_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceFromEntryArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entryStart", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entryStart: ", p), err) }
  if err := oprot.WriteI64(int64(p.EntryStart)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entryStart (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entryStart: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceFromEntryArgs) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("length", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:length: ", p), err) }
  if err := oprot.WriteI32(int32(p.Length)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.length (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:length: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceFromEntryArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetSliceFromEntryArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceGetSliceFromEntryResult struct {
  Success TEntryList `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceGetSliceFromEntryResult() *I64ListI64ServiceGetSliceFromEntryResult {
  return &I64ListI64ServiceGetSliceFromEntryResult{}
}

var I64ListI64ServiceGetSliceFromEntryResult_Success_DEFAULT TEntryList

func (p *I64ListI64ServiceGetSliceFromEntryResult) GetSuccess() TEntryList {
  return p.Success
}
func (p *I64ListI64ServiceGetSliceFromEntryResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceGetSliceFromEntryResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryResult)  ReadField0(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TEntryList, 0, size)
  p.Success =  tSlice
  for i := 0; i < size; i ++ {
var _elem63 TEntry
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TEntry(v)
    _elem63 = temp
}
    p.Success = append(p.Success, _elem63)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getSliceFromEntry_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.LIST, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteListBegin(thrift.I64, len(p.Success)); err != nil {
      return thrift.PrependError("error writing list begin: ", err)
    }
    for _, v := range p.Success {
      if err := oprot.WriteI64(int64(v)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
    }
    if err := oprot.WriteListEnd(); err != nil {
      return thrift.PrependError("error writing list end: ", err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceGetSliceFromEntryResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetSliceFromEntryResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - EntryStart
//  - Length
type I64ListI64ServiceGetSliceFromIdArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  EntryStart TEntry `thrift:"entryStart,2" db:"entryStart" json:"entryStart"`
  Length int32 `thrift:"length,3" db:"length" json:"length"`
}

func NewI64ListI64ServiceGetSliceFromIdArgs() *I64ListI64ServiceGetSliceFromIdArgs {
  return &I64ListI64ServiceGetSliceFromIdArgs{}
}


func (p *I64ListI64ServiceGetSliceFromIdArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServiceGetSliceFromIdArgs) GetEntryStart() TEntry {
  return p.EntryStart
}

func (p *I64ListI64ServiceGetSliceFromIdArgs) GetLength() int32 {
  return p.Length
}
func (p *I64ListI64ServiceGetSliceFromIdArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField3(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TEntry(v)
  p.EntryStart = temp
}
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdArgs)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Length = v
}
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getSliceFromId_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceFromIdArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entryStart", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entryStart: ", p), err) }
  if err := oprot.WriteI64(int64(p.EntryStart)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entryStart (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entryStart: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceFromIdArgs) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("length", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:length: ", p), err) }
  if err := oprot.WriteI32(int32(p.Length)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.length (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:length: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceFromIdArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetSliceFromIdArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceGetSliceFromIdResult struct {
  Success TEntryList `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceGetSliceFromIdResult() *I64ListI64ServiceGetSliceFromIdResult {
  return &I64ListI64ServiceGetSliceFromIdResult{}
}

var I64ListI64ServiceGetSliceFromIdResult_Success_DEFAULT TEntryList

func (p *I64ListI64ServiceGetSliceFromIdResult) GetSuccess() TEntryList {
  return p.Success
}
func (p *I64ListI64ServiceGetSliceFromIdResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceGetSliceFromIdResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdResult)  ReadField0(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TEntryList, 0, size)
  p.Success =  tSlice
  for i := 0; i < size; i ++ {
var _elem64 TEntry
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TEntry(v)
    _elem64 = temp
}
    p.Success = append(p.Success, _elem64)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getSliceFromId_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.LIST, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteListBegin(thrift.I64, len(p.Success)); err != nil {
      return thrift.PrependError("error writing list begin: ", err)
    }
    for _, v := range p.Success {
      if err := oprot.WriteI64(int64(v)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
    }
    if err := oprot.WriteListEnd(); err != nil {
      return thrift.PrependError("error writing list end: ", err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceGetSliceFromIdResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetSliceFromIdResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - Start
//  - Length
type I64ListI64ServiceGetSliceReverseArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  Start int32 `thrift:"start,2" db:"start" json:"start"`
  Length int32 `thrift:"length,3" db:"length" json:"length"`
}

func NewI64ListI64ServiceGetSliceReverseArgs() *I64ListI64ServiceGetSliceReverseArgs {
  return &I64ListI64ServiceGetSliceReverseArgs{}
}


func (p *I64ListI64ServiceGetSliceReverseArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServiceGetSliceReverseArgs) GetStart() int32 {
  return p.Start
}

func (p *I64ListI64ServiceGetSliceReverseArgs) GetLength() int32 {
  return p.Length
}
func (p *I64ListI64ServiceGetSliceReverseArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField3(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceReverseArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceGetSliceReverseArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Start = v
}
  return nil
}

func (p *I64ListI64ServiceGetSliceReverseArgs)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Length = v
}
  return nil
}

func (p *I64ListI64ServiceGetSliceReverseArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getSliceReverse_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetSliceReverseArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceReverseArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("start", thrift.I32, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:start: ", p), err) }
  if err := oprot.WriteI32(int32(p.Start)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.start (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:start: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceReverseArgs) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("length", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:length: ", p), err) }
  if err := oprot.WriteI32(int32(p.Length)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.length (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:length: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceReverseArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetSliceReverseArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceGetSliceReverseResult struct {
  Success TEntryList `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceGetSliceReverseResult() *I64ListI64ServiceGetSliceReverseResult {
  return &I64ListI64ServiceGetSliceReverseResult{}
}

var I64ListI64ServiceGetSliceReverseResult_Success_DEFAULT TEntryList

func (p *I64ListI64ServiceGetSliceReverseResult) GetSuccess() TEntryList {
  return p.Success
}
func (p *I64ListI64ServiceGetSliceReverseResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceGetSliceReverseResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceReverseResult)  ReadField0(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TEntryList, 0, size)
  p.Success =  tSlice
  for i := 0; i < size; i ++ {
var _elem65 TEntry
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TEntry(v)
    _elem65 = temp
}
    p.Success = append(p.Success, _elem65)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceReverseResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getSliceReverse_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetSliceReverseResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.LIST, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteListBegin(thrift.I64, len(p.Success)); err != nil {
      return thrift.PrependError("error writing list begin: ", err)
    }
    for _, v := range p.Success {
      if err := oprot.WriteI64(int64(v)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
    }
    if err := oprot.WriteListEnd(); err != nil {
      return thrift.PrependError("error writing list end: ", err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceGetSliceReverseResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetSliceReverseResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - EntryStart
//  - Length
type I64ListI64ServiceGetSliceFromEntryReverseArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  EntryStart TEntry `thrift:"entryStart,2" db:"entryStart" json:"entryStart"`
  Length int32 `thrift:"length,3" db:"length" json:"length"`
}

func NewI64ListI64ServiceGetSliceFromEntryReverseArgs() *I64ListI64ServiceGetSliceFromEntryReverseArgs {
  return &I64ListI64ServiceGetSliceFromEntryReverseArgs{}
}


func (p *I64ListI64ServiceGetSliceFromEntryReverseArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServiceGetSliceFromEntryReverseArgs) GetEntryStart() TEntry {
  return p.EntryStart
}

func (p *I64ListI64ServiceGetSliceFromEntryReverseArgs) GetLength() int32 {
  return p.Length
}
func (p *I64ListI64ServiceGetSliceFromEntryReverseArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField3(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryReverseArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryReverseArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TEntry(v)
  p.EntryStart = temp
}
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryReverseArgs)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Length = v
}
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryReverseArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getSliceFromEntryReverse_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryReverseArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceFromEntryReverseArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entryStart", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entryStart: ", p), err) }
  if err := oprot.WriteI64(int64(p.EntryStart)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entryStart (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entryStart: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceFromEntryReverseArgs) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("length", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:length: ", p), err) }
  if err := oprot.WriteI32(int32(p.Length)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.length (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:length: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceFromEntryReverseArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetSliceFromEntryReverseArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceGetSliceFromEntryReverseResult struct {
  Success TEntryList `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceGetSliceFromEntryReverseResult() *I64ListI64ServiceGetSliceFromEntryReverseResult {
  return &I64ListI64ServiceGetSliceFromEntryReverseResult{}
}

var I64ListI64ServiceGetSliceFromEntryReverseResult_Success_DEFAULT TEntryList

func (p *I64ListI64ServiceGetSliceFromEntryReverseResult) GetSuccess() TEntryList {
  return p.Success
}
func (p *I64ListI64ServiceGetSliceFromEntryReverseResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceGetSliceFromEntryReverseResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryReverseResult)  ReadField0(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TEntryList, 0, size)
  p.Success =  tSlice
  for i := 0; i < size; i ++ {
var _elem66 TEntry
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TEntry(v)
    _elem66 = temp
}
    p.Success = append(p.Success, _elem66)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryReverseResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getSliceFromEntryReverse_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromEntryReverseResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.LIST, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteListBegin(thrift.I64, len(p.Success)); err != nil {
      return thrift.PrependError("error writing list begin: ", err)
    }
    for _, v := range p.Success {
      if err := oprot.WriteI64(int64(v)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
    }
    if err := oprot.WriteListEnd(); err != nil {
      return thrift.PrependError("error writing list end: ", err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceGetSliceFromEntryReverseResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetSliceFromEntryReverseResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - EntryStart
//  - Length
type I64ListI64ServiceGetSliceFromIdReverseArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  EntryStart TEntry `thrift:"entryStart,2" db:"entryStart" json:"entryStart"`
  Length int32 `thrift:"length,3" db:"length" json:"length"`
}

func NewI64ListI64ServiceGetSliceFromIdReverseArgs() *I64ListI64ServiceGetSliceFromIdReverseArgs {
  return &I64ListI64ServiceGetSliceFromIdReverseArgs{}
}


func (p *I64ListI64ServiceGetSliceFromIdReverseArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServiceGetSliceFromIdReverseArgs) GetEntryStart() TEntry {
  return p.EntryStart
}

func (p *I64ListI64ServiceGetSliceFromIdReverseArgs) GetLength() int32 {
  return p.Length
}
func (p *I64ListI64ServiceGetSliceFromIdReverseArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField3(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdReverseArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdReverseArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TEntry(v)
  p.EntryStart = temp
}
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdReverseArgs)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Length = v
}
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdReverseArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getSliceFromIdReverse_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdReverseArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceFromIdReverseArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entryStart", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entryStart: ", p), err) }
  if err := oprot.WriteI64(int64(p.EntryStart)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entryStart (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entryStart: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceFromIdReverseArgs) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("length", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:length: ", p), err) }
  if err := oprot.WriteI32(int32(p.Length)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.length (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:length: ", p), err) }
  return err
}

func (p *I64ListI64ServiceGetSliceFromIdReverseArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetSliceFromIdReverseArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceGetSliceFromIdReverseResult struct {
  Success TEntryList `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceGetSliceFromIdReverseResult() *I64ListI64ServiceGetSliceFromIdReverseResult {
  return &I64ListI64ServiceGetSliceFromIdReverseResult{}
}

var I64ListI64ServiceGetSliceFromIdReverseResult_Success_DEFAULT TEntryList

func (p *I64ListI64ServiceGetSliceFromIdReverseResult) GetSuccess() TEntryList {
  return p.Success
}
func (p *I64ListI64ServiceGetSliceFromIdReverseResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceGetSliceFromIdReverseResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdReverseResult)  ReadField0(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TEntryList, 0, size)
  p.Success =  tSlice
  for i := 0; i < size; i ++ {
var _elem67 TEntry
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TEntry(v)
    _elem67 = temp
}
    p.Success = append(p.Success, _elem67)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdReverseResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("getSliceFromIdReverse_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceGetSliceFromIdReverseResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.LIST, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteListBegin(thrift.I64, len(p.Success)); err != nil {
      return thrift.PrependError("error writing list begin: ", err)
    }
    for _, v := range p.Success {
      if err := oprot.WriteI64(int64(v)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
    }
    if err := oprot.WriteListEnd(); err != nil {
      return thrift.PrependError("error writing list end: ", err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceGetSliceFromIdReverseResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceGetSliceFromIdReverseResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - Entry
type I64ListI64ServicePutArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  Entry TEntry `thrift:"entry,2" db:"entry" json:"entry"`
}

func NewI64ListI64ServicePutArgs() *I64ListI64ServicePutArgs {
  return &I64ListI64ServicePutArgs{}
}


func (p *I64ListI64ServicePutArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServicePutArgs) GetEntry() TEntry {
  return p.Entry
}
func (p *I64ListI64ServicePutArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServicePutArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServicePutArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TEntry(v)
  p.Entry = temp
}
  return nil
}

func (p *I64ListI64ServicePutArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("put_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServicePutArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServicePutArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entry", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entry: ", p), err) }
  if err := oprot.WriteI64(int64(p.Entry)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entry (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entry: ", p), err) }
  return err
}

func (p *I64ListI64ServicePutArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServicePutArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServicePutResult struct {
  Success *bool `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServicePutResult() *I64ListI64ServicePutResult {
  return &I64ListI64ServicePutResult{}
}

var I64ListI64ServicePutResult_Success_DEFAULT bool
func (p *I64ListI64ServicePutResult) GetSuccess() bool {
  if !p.IsSetSuccess() {
    return I64ListI64ServicePutResult_Success_DEFAULT
  }
return *p.Success
}
func (p *I64ListI64ServicePutResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServicePutResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServicePutResult)  ReadField0(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 0: ", err)
} else {
  p.Success = &v
}
  return nil
}

func (p *I64ListI64ServicePutResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("put_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServicePutResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.BOOL, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteBool(bool(*p.Success)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServicePutResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServicePutResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - Value
type I64ListI64ServicePutValueArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  Value *TValue `thrift:"value,2" db:"value" json:"value"`
}

func NewI64ListI64ServicePutValueArgs() *I64ListI64ServicePutValueArgs {
  return &I64ListI64ServicePutValueArgs{}
}


func (p *I64ListI64ServicePutValueArgs) GetKey() TKey {
  return p.Key
}
var I64ListI64ServicePutValueArgs_Value_DEFAULT *TValue
func (p *I64ListI64ServicePutValueArgs) GetValue() *TValue {
  if !p.IsSetValue() {
    return I64ListI64ServicePutValueArgs_Value_DEFAULT
  }
return p.Value
}
func (p *I64ListI64ServicePutValueArgs) IsSetValue() bool {
  return p.Value != nil
}

func (p *I64ListI64ServicePutValueArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.STRUCT {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServicePutValueArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServicePutValueArgs)  ReadField2(iprot thrift.TProtocol) error {
  p.Value = &TValue{}
  if err := p.Value.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Value), err)
  }
  return nil
}

func (p *I64ListI64ServicePutValueArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("putValue_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServicePutValueArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServicePutValueArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("value", thrift.STRUCT, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:value: ", p), err) }
  if err := p.Value.Write(oprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Value), err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:value: ", p), err) }
  return err
}

func (p *I64ListI64ServicePutValueArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServicePutValueArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServicePutValueResult struct {
  Success *bool `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServicePutValueResult() *I64ListI64ServicePutValueResult {
  return &I64ListI64ServicePutValueResult{}
}

var I64ListI64ServicePutValueResult_Success_DEFAULT bool
func (p *I64ListI64ServicePutValueResult) GetSuccess() bool {
  if !p.IsSetSuccess() {
    return I64ListI64ServicePutValueResult_Success_DEFAULT
  }
return *p.Success
}
func (p *I64ListI64ServicePutValueResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServicePutValueResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServicePutValueResult)  ReadField0(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 0: ", err)
} else {
  p.Success = &v
}
  return nil
}

func (p *I64ListI64ServicePutValueResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("putValue_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServicePutValueResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.BOOL, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteBool(bool(*p.Success)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServicePutValueResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServicePutValueResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - EntryList
type I64ListI64ServicePutListArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  EntryList TEntryList `thrift:"entryList,2" db:"entryList" json:"entryList"`
}

func NewI64ListI64ServicePutListArgs() *I64ListI64ServicePutListArgs {
  return &I64ListI64ServicePutListArgs{}
}


func (p *I64ListI64ServicePutListArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServicePutListArgs) GetEntryList() TEntryList {
  return p.EntryList
}
func (p *I64ListI64ServicePutListArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServicePutListArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServicePutListArgs)  ReadField2(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TEntryList, 0, size)
  p.EntryList =  tSlice
  for i := 0; i < size; i ++ {
var _elem68 TEntry
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TEntry(v)
    _elem68 = temp
}
    p.EntryList = append(p.EntryList, _elem68)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServicePutListArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("putList_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServicePutListArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServicePutListArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entryList", thrift.LIST, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entryList: ", p), err) }
  if err := oprot.WriteListBegin(thrift.I64, len(p.EntryList)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.EntryList {
    if err := oprot.WriteI64(int64(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteListEnd(); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entryList: ", p), err) }
  return err
}

func (p *I64ListI64ServicePutListArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServicePutListArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServicePutListResult struct {
  Success *bool `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServicePutListResult() *I64ListI64ServicePutListResult {
  return &I64ListI64ServicePutListResult{}
}

var I64ListI64ServicePutListResult_Success_DEFAULT bool
func (p *I64ListI64ServicePutListResult) GetSuccess() bool {
  if !p.IsSetSuccess() {
    return I64ListI64ServicePutListResult_Success_DEFAULT
  }
return *p.Success
}
func (p *I64ListI64ServicePutListResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServicePutListResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServicePutListResult)  ReadField0(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 0: ", err)
} else {
  p.Success = &v
}
  return nil
}

func (p *I64ListI64ServicePutListResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("putList_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServicePutListResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.BOOL, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteBool(bool(*p.Success)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServicePutListResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServicePutListResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - Entry
type I64ListI64ServiceInsertArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  Entry TEntry `thrift:"entry,2" db:"entry" json:"entry"`
}

func NewI64ListI64ServiceInsertArgs() *I64ListI64ServiceInsertArgs {
  return &I64ListI64ServiceInsertArgs{}
}


func (p *I64ListI64ServiceInsertArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServiceInsertArgs) GetEntry() TEntry {
  return p.Entry
}
func (p *I64ListI64ServiceInsertArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceInsertArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceInsertArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TEntry(v)
  p.Entry = temp
}
  return nil
}

func (p *I64ListI64ServiceInsertArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("insert_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceInsertArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceInsertArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entry", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entry: ", p), err) }
  if err := oprot.WriteI64(int64(p.Entry)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entry (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entry: ", p), err) }
  return err
}

func (p *I64ListI64ServiceInsertArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceInsertArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceInsertResult struct {
  Success *bool `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceInsertResult() *I64ListI64ServiceInsertResult {
  return &I64ListI64ServiceInsertResult{}
}

var I64ListI64ServiceInsertResult_Success_DEFAULT bool
func (p *I64ListI64ServiceInsertResult) GetSuccess() bool {
  if !p.IsSetSuccess() {
    return I64ListI64ServiceInsertResult_Success_DEFAULT
  }
return *p.Success
}
func (p *I64ListI64ServiceInsertResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceInsertResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceInsertResult)  ReadField0(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 0: ", err)
} else {
  p.Success = &v
}
  return nil
}

func (p *I64ListI64ServiceInsertResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("insert_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceInsertResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.BOOL, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteBool(bool(*p.Success)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceInsertResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceInsertResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - Entry
//  - Index
type I64ListI64ServiceInsertAtArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  Entry TEntry `thrift:"entry,2" db:"entry" json:"entry"`
  Index int32 `thrift:"index,3" db:"index" json:"index"`
}

func NewI64ListI64ServiceInsertAtArgs() *I64ListI64ServiceInsertAtArgs {
  return &I64ListI64ServiceInsertAtArgs{}
}


func (p *I64ListI64ServiceInsertAtArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServiceInsertAtArgs) GetEntry() TEntry {
  return p.Entry
}

func (p *I64ListI64ServiceInsertAtArgs) GetIndex() int32 {
  return p.Index
}
func (p *I64ListI64ServiceInsertAtArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField3(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceInsertAtArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceInsertAtArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TEntry(v)
  p.Entry = temp
}
  return nil
}

func (p *I64ListI64ServiceInsertAtArgs)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Index = v
}
  return nil
}

func (p *I64ListI64ServiceInsertAtArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("insertAt_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceInsertAtArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceInsertAtArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entry", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entry: ", p), err) }
  if err := oprot.WriteI64(int64(p.Entry)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entry (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entry: ", p), err) }
  return err
}

func (p *I64ListI64ServiceInsertAtArgs) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("index", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:index: ", p), err) }
  if err := oprot.WriteI32(int32(p.Index)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.index (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:index: ", p), err) }
  return err
}

func (p *I64ListI64ServiceInsertAtArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceInsertAtArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceInsertAtResult struct {
  Success *bool `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceInsertAtResult() *I64ListI64ServiceInsertAtResult {
  return &I64ListI64ServiceInsertAtResult{}
}

var I64ListI64ServiceInsertAtResult_Success_DEFAULT bool
func (p *I64ListI64ServiceInsertAtResult) GetSuccess() bool {
  if !p.IsSetSuccess() {
    return I64ListI64ServiceInsertAtResult_Success_DEFAULT
  }
return *p.Success
}
func (p *I64ListI64ServiceInsertAtResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceInsertAtResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceInsertAtResult)  ReadField0(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 0: ", err)
} else {
  p.Success = &v
}
  return nil
}

func (p *I64ListI64ServiceInsertAtResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("insertAt_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceInsertAtResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.BOOL, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteBool(bool(*p.Success)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceInsertAtResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceInsertAtResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - Entry
type I64ListI64ServiceRemoveArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  Entry TEntry `thrift:"entry,2" db:"entry" json:"entry"`
}

func NewI64ListI64ServiceRemoveArgs() *I64ListI64ServiceRemoveArgs {
  return &I64ListI64ServiceRemoveArgs{}
}


func (p *I64ListI64ServiceRemoveArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServiceRemoveArgs) GetEntry() TEntry {
  return p.Entry
}
func (p *I64ListI64ServiceRemoveArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceRemoveArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceRemoveArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TEntry(v)
  p.Entry = temp
}
  return nil
}

func (p *I64ListI64ServiceRemoveArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("remove_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceRemoveArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceRemoveArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entry", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entry: ", p), err) }
  if err := oprot.WriteI64(int64(p.Entry)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entry (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entry: ", p), err) }
  return err
}

func (p *I64ListI64ServiceRemoveArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceRemoveArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceRemoveResult struct {
  Success *bool `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceRemoveResult() *I64ListI64ServiceRemoveResult {
  return &I64ListI64ServiceRemoveResult{}
}

var I64ListI64ServiceRemoveResult_Success_DEFAULT bool
func (p *I64ListI64ServiceRemoveResult) GetSuccess() bool {
  if !p.IsSetSuccess() {
    return I64ListI64ServiceRemoveResult_Success_DEFAULT
  }
return *p.Success
}
func (p *I64ListI64ServiceRemoveResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceRemoveResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceRemoveResult)  ReadField0(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 0: ", err)
} else {
  p.Success = &v
}
  return nil
}

func (p *I64ListI64ServiceRemoveResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("remove_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceRemoveResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.BOOL, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteBool(bool(*p.Success)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceRemoveResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceRemoveResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - Index
type I64ListI64ServiceRemoveAtArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  Index int32 `thrift:"index,2" db:"index" json:"index"`
}

func NewI64ListI64ServiceRemoveAtArgs() *I64ListI64ServiceRemoveAtArgs {
  return &I64ListI64ServiceRemoveAtArgs{}
}


func (p *I64ListI64ServiceRemoveAtArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServiceRemoveAtArgs) GetIndex() int32 {
  return p.Index
}
func (p *I64ListI64ServiceRemoveAtArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceRemoveAtArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceRemoveAtArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Index = v
}
  return nil
}

func (p *I64ListI64ServiceRemoveAtArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("removeAt_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceRemoveAtArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceRemoveAtArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("index", thrift.I32, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:index: ", p), err) }
  if err := oprot.WriteI32(int32(p.Index)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.index (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:index: ", p), err) }
  return err
}

func (p *I64ListI64ServiceRemoveAtArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceRemoveAtArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceRemoveAtResult struct {
  Success *bool `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceRemoveAtResult() *I64ListI64ServiceRemoveAtResult {
  return &I64ListI64ServiceRemoveAtResult{}
}

var I64ListI64ServiceRemoveAtResult_Success_DEFAULT bool
func (p *I64ListI64ServiceRemoveAtResult) GetSuccess() bool {
  if !p.IsSetSuccess() {
    return I64ListI64ServiceRemoveAtResult_Success_DEFAULT
  }
return *p.Success
}
func (p *I64ListI64ServiceRemoveAtResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceRemoveAtResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceRemoveAtResult)  ReadField0(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 0: ", err)
} else {
  p.Success = &v
}
  return nil
}

func (p *I64ListI64ServiceRemoveAtResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("removeAt_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceRemoveAtResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.BOOL, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteBool(bool(*p.Success)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceRemoveAtResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceRemoveAtResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - Entry
type I64ListI64ServiceBumpUpArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  Entry TEntry `thrift:"entry,2" db:"entry" json:"entry"`
}

func NewI64ListI64ServiceBumpUpArgs() *I64ListI64ServiceBumpUpArgs {
  return &I64ListI64ServiceBumpUpArgs{}
}


func (p *I64ListI64ServiceBumpUpArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServiceBumpUpArgs) GetEntry() TEntry {
  return p.Entry
}
func (p *I64ListI64ServiceBumpUpArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceBumpUpArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceBumpUpArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TEntry(v)
  p.Entry = temp
}
  return nil
}

func (p *I64ListI64ServiceBumpUpArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("bumpUp_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceBumpUpArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceBumpUpArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entry", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entry: ", p), err) }
  if err := oprot.WriteI64(int64(p.Entry)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entry (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entry: ", p), err) }
  return err
}

func (p *I64ListI64ServiceBumpUpArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceBumpUpArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceBumpUpResult struct {
  Success *bool `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceBumpUpResult() *I64ListI64ServiceBumpUpResult {
  return &I64ListI64ServiceBumpUpResult{}
}

var I64ListI64ServiceBumpUpResult_Success_DEFAULT bool
func (p *I64ListI64ServiceBumpUpResult) GetSuccess() bool {
  if !p.IsSetSuccess() {
    return I64ListI64ServiceBumpUpResult_Success_DEFAULT
  }
return *p.Success
}
func (p *I64ListI64ServiceBumpUpResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceBumpUpResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceBumpUpResult)  ReadField0(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 0: ", err)
} else {
  p.Success = &v
}
  return nil
}

func (p *I64ListI64ServiceBumpUpResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("bumpUp_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceBumpUpResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.BOOL, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteBool(bool(*p.Success)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceBumpUpResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceBumpUpResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - EntryList
type I64ListI64ServiceRemoveListArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  EntryList TEntryList `thrift:"entryList,2" db:"entryList" json:"entryList"`
}

func NewI64ListI64ServiceRemoveListArgs() *I64ListI64ServiceRemoveListArgs {
  return &I64ListI64ServiceRemoveListArgs{}
}


func (p *I64ListI64ServiceRemoveListArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServiceRemoveListArgs) GetEntryList() TEntryList {
  return p.EntryList
}
func (p *I64ListI64ServiceRemoveListArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceRemoveListArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceRemoveListArgs)  ReadField2(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TEntryList, 0, size)
  p.EntryList =  tSlice
  for i := 0; i < size; i ++ {
var _elem69 TEntry
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TEntry(v)
    _elem69 = temp
}
    p.EntryList = append(p.EntryList, _elem69)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceRemoveListArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("removeList_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceRemoveListArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceRemoveListArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entryList", thrift.LIST, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entryList: ", p), err) }
  if err := oprot.WriteListBegin(thrift.I64, len(p.EntryList)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.EntryList {
    if err := oprot.WriteI64(int64(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteListEnd(); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entryList: ", p), err) }
  return err
}

func (p *I64ListI64ServiceRemoveListArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceRemoveListArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceRemoveListResult struct {
  Success *bool `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceRemoveListResult() *I64ListI64ServiceRemoveListResult {
  return &I64ListI64ServiceRemoveListResult{}
}

var I64ListI64ServiceRemoveListResult_Success_DEFAULT bool
func (p *I64ListI64ServiceRemoveListResult) GetSuccess() bool {
  if !p.IsSetSuccess() {
    return I64ListI64ServiceRemoveListResult_Success_DEFAULT
  }
return *p.Success
}
func (p *I64ListI64ServiceRemoveListResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceRemoveListResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.BOOL {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceRemoveListResult)  ReadField0(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 0: ", err)
} else {
  p.Success = &v
}
  return nil
}

func (p *I64ListI64ServiceRemoveListResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("removeList_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceRemoveListResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.BOOL, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteBool(bool(*p.Success)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceRemoveListResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceRemoveListResult(%+v)", *p)
}

// Attributes:
//  - Key
type I64ListI64ServiceClearDataArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
}

func NewI64ListI64ServiceClearDataArgs() *I64ListI64ServiceClearDataArgs {
  return &I64ListI64ServiceClearDataArgs{}
}


func (p *I64ListI64ServiceClearDataArgs) GetKey() TKey {
  return p.Key
}
func (p *I64ListI64ServiceClearDataArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceClearDataArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceClearDataArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("clearData_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceClearDataArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceClearDataArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceClearDataArgs(%+v)", *p)
}

type I64ListI64ServiceClearDataResult struct {
}

func NewI64ListI64ServiceClearDataResult() *I64ListI64ServiceClearDataResult {
  return &I64ListI64ServiceClearDataResult{}
}

func (p *I64ListI64ServiceClearDataResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    if err := iprot.Skip(fieldTypeId); err != nil {
      return err
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceClearDataResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("clearData_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceClearDataResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceClearDataResult(%+v)", *p)
}

// Attributes:
//  - OldKey
//  - NewKey_
//  - OrigLength
type I64ListI64ServiceSplitArgs struct {
  OldKey TKey `thrift:"oldKey,1" db:"oldKey" json:"oldKey"`
  NewKey_ TKey `thrift:"newKey,2" db:"newKey" json:"newKey"`
  OrigLength int32 `thrift:"origLength,3" db:"origLength" json:"origLength"`
}

func NewI64ListI64ServiceSplitArgs() *I64ListI64ServiceSplitArgs {
  return &I64ListI64ServiceSplitArgs{}
}


func (p *I64ListI64ServiceSplitArgs) GetOldKey() TKey {
  return p.OldKey
}

func (p *I64ListI64ServiceSplitArgs) GetNewKey_() TKey {
  return p.NewKey_
}

func (p *I64ListI64ServiceSplitArgs) GetOrigLength() int32 {
  return p.OrigLength
}
func (p *I64ListI64ServiceSplitArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField3(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceSplitArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.OldKey = temp
}
  return nil
}

func (p *I64ListI64ServiceSplitArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TKey(v)
  p.NewKey_ = temp
}
  return nil
}

func (p *I64ListI64ServiceSplitArgs)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.OrigLength = v
}
  return nil
}

func (p *I64ListI64ServiceSplitArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("split_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceSplitArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("oldKey", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:oldKey: ", p), err) }
  if err := oprot.WriteI64(int64(p.OldKey)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.oldKey (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:oldKey: ", p), err) }
  return err
}

func (p *I64ListI64ServiceSplitArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("newKey", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:newKey: ", p), err) }
  if err := oprot.WriteI64(int64(p.NewKey_)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.newKey (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:newKey: ", p), err) }
  return err
}

func (p *I64ListI64ServiceSplitArgs) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("origLength", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:origLength: ", p), err) }
  if err := oprot.WriteI32(int32(p.OrigLength)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.origLength (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:origLength: ", p), err) }
  return err
}

func (p *I64ListI64ServiceSplitArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceSplitArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceSplitResult struct {
  Success *TEntry `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceSplitResult() *I64ListI64ServiceSplitResult {
  return &I64ListI64ServiceSplitResult{}
}

var I64ListI64ServiceSplitResult_Success_DEFAULT TEntry
func (p *I64ListI64ServiceSplitResult) GetSuccess() TEntry {
  if !p.IsSetSuccess() {
    return I64ListI64ServiceSplitResult_Success_DEFAULT
  }
return *p.Success
}
func (p *I64ListI64ServiceSplitResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceSplitResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceSplitResult)  ReadField0(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 0: ", err)
} else {
  temp := TEntry(v)
  p.Success = &temp
}
  return nil
}

func (p *I64ListI64ServiceSplitResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("split_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceSplitResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.I64, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteI64(int64(*p.Success)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.success (0) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceSplitResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceSplitResult(%+v)", *p)
}

// Attributes:
//  - KeyList
type I64ListI64ServiceMultiCountArgs struct {
  KeyList TKeyList `thrift:"keyList,1" db:"keyList" json:"keyList"`
}

func NewI64ListI64ServiceMultiCountArgs() *I64ListI64ServiceMultiCountArgs {
  return &I64ListI64ServiceMultiCountArgs{}
}


func (p *I64ListI64ServiceMultiCountArgs) GetKeyList() TKeyList {
  return p.KeyList
}
func (p *I64ListI64ServiceMultiCountArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiCountArgs)  ReadField1(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TKeyList, 0, size)
  p.KeyList =  tSlice
  for i := 0; i < size; i ++ {
var _elem70 TKey
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TKey(v)
    _elem70 = temp
}
    p.KeyList = append(p.KeyList, _elem70)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiCountArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("multiCount_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceMultiCountArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("keyList", thrift.LIST, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:keyList: ", p), err) }
  if err := oprot.WriteListBegin(thrift.I64, len(p.KeyList)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.KeyList {
    if err := oprot.WriteI64(int64(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteListEnd(); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:keyList: ", p), err) }
  return err
}

func (p *I64ListI64ServiceMultiCountArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceMultiCountArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceMultiCountResult struct {
  Success map[TKey]int32 `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceMultiCountResult() *I64ListI64ServiceMultiCountResult {
  return &I64ListI64ServiceMultiCountResult{}
}

var I64ListI64ServiceMultiCountResult_Success_DEFAULT map[TKey]int32

func (p *I64ListI64ServiceMultiCountResult) GetSuccess() map[TKey]int32 {
  return p.Success
}
func (p *I64ListI64ServiceMultiCountResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceMultiCountResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.MAP {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiCountResult)  ReadField0(iprot thrift.TProtocol) error {
  _, _, size, err := iprot.ReadMapBegin()
  if err != nil {
    return thrift.PrependError("error reading map begin: ", err)
  }
  tMap := make(map[TKey]int32, size)
  p.Success =  tMap
  for i := 0; i < size; i ++ {
var _key71 TKey
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TKey(v)
    _key71 = temp
}
var _val72 int32
    if v, err := iprot.ReadI32(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    _val72 = v
}
    p.Success[_key71] = _val72
  }
  if err := iprot.ReadMapEnd(); err != nil {
    return thrift.PrependError("error reading map end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiCountResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("multiCount_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceMultiCountResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.MAP, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteMapBegin(thrift.I64, thrift.I32, len(p.Success)); err != nil {
      return thrift.PrependError("error writing map begin: ", err)
    }
    for k, v := range p.Success {
      if err := oprot.WriteI64(int64(k)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
      if err := oprot.WriteI32(int32(v)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
    }
    if err := oprot.WriteMapEnd(); err != nil {
      return thrift.PrependError("error writing map end: ", err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceMultiCountResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceMultiCountResult(%+v)", *p)
}

// Attributes:
//  - KeyList
//  - Entry
type I64ListI64ServiceMultiExistedArgs struct {
  KeyList TKeyList `thrift:"keyList,1" db:"keyList" json:"keyList"`
  Entry TEntry `thrift:"entry,2" db:"entry" json:"entry"`
}

func NewI64ListI64ServiceMultiExistedArgs() *I64ListI64ServiceMultiExistedArgs {
  return &I64ListI64ServiceMultiExistedArgs{}
}


func (p *I64ListI64ServiceMultiExistedArgs) GetKeyList() TKeyList {
  return p.KeyList
}

func (p *I64ListI64ServiceMultiExistedArgs) GetEntry() TEntry {
  return p.Entry
}
func (p *I64ListI64ServiceMultiExistedArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiExistedArgs)  ReadField1(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TKeyList, 0, size)
  p.KeyList =  tSlice
  for i := 0; i < size; i ++ {
var _elem73 TKey
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TKey(v)
    _elem73 = temp
}
    p.KeyList = append(p.KeyList, _elem73)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiExistedArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TEntry(v)
  p.Entry = temp
}
  return nil
}

func (p *I64ListI64ServiceMultiExistedArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("multiExisted_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceMultiExistedArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("keyList", thrift.LIST, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:keyList: ", p), err) }
  if err := oprot.WriteListBegin(thrift.I64, len(p.KeyList)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.KeyList {
    if err := oprot.WriteI64(int64(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteListEnd(); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:keyList: ", p), err) }
  return err
}

func (p *I64ListI64ServiceMultiExistedArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entry", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entry: ", p), err) }
  if err := oprot.WriteI64(int64(p.Entry)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entry (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entry: ", p), err) }
  return err
}

func (p *I64ListI64ServiceMultiExistedArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceMultiExistedArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceMultiExistedResult struct {
  Success map[TKey]bool `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceMultiExistedResult() *I64ListI64ServiceMultiExistedResult {
  return &I64ListI64ServiceMultiExistedResult{}
}

var I64ListI64ServiceMultiExistedResult_Success_DEFAULT map[TKey]bool

func (p *I64ListI64ServiceMultiExistedResult) GetSuccess() map[TKey]bool {
  return p.Success
}
func (p *I64ListI64ServiceMultiExistedResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceMultiExistedResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.MAP {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiExistedResult)  ReadField0(iprot thrift.TProtocol) error {
  _, _, size, err := iprot.ReadMapBegin()
  if err != nil {
    return thrift.PrependError("error reading map begin: ", err)
  }
  tMap := make(map[TKey]bool, size)
  p.Success =  tMap
  for i := 0; i < size; i ++ {
var _key74 TKey
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TKey(v)
    _key74 = temp
}
var _val75 bool
    if v, err := iprot.ReadBool(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    _val75 = v
}
    p.Success[_key74] = _val75
  }
  if err := iprot.ReadMapEnd(); err != nil {
    return thrift.PrependError("error reading map end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiExistedResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("multiExisted_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceMultiExistedResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.MAP, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteMapBegin(thrift.I64, thrift.BOOL, len(p.Success)); err != nil {
      return thrift.PrependError("error writing map begin: ", err)
    }
    for k, v := range p.Success {
      if err := oprot.WriteI64(int64(k)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
      if err := oprot.WriteBool(bool(v)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
    }
    if err := oprot.WriteMapEnd(); err != nil {
      return thrift.PrependError("error writing map end: ", err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceMultiExistedResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceMultiExistedResult(%+v)", *p)
}

// Attributes:
//  - KeyList
type I64ListI64ServiceMultiGetListAllArgs struct {
  KeyList TKeyList `thrift:"keyList,1" db:"keyList" json:"keyList"`
}

func NewI64ListI64ServiceMultiGetListAllArgs() *I64ListI64ServiceMultiGetListAllArgs {
  return &I64ListI64ServiceMultiGetListAllArgs{}
}


func (p *I64ListI64ServiceMultiGetListAllArgs) GetKeyList() TKeyList {
  return p.KeyList
}
func (p *I64ListI64ServiceMultiGetListAllArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiGetListAllArgs)  ReadField1(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TKeyList, 0, size)
  p.KeyList =  tSlice
  for i := 0; i < size; i ++ {
var _elem76 TKey
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TKey(v)
    _elem76 = temp
}
    p.KeyList = append(p.KeyList, _elem76)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiGetListAllArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("multiGetListAll_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceMultiGetListAllArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("keyList", thrift.LIST, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:keyList: ", p), err) }
  if err := oprot.WriteListBegin(thrift.I64, len(p.KeyList)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.KeyList {
    if err := oprot.WriteI64(int64(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteListEnd(); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:keyList: ", p), err) }
  return err
}

func (p *I64ListI64ServiceMultiGetListAllArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceMultiGetListAllArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceMultiGetListAllResult struct {
  Success map[TKey]TEntryList `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceMultiGetListAllResult() *I64ListI64ServiceMultiGetListAllResult {
  return &I64ListI64ServiceMultiGetListAllResult{}
}

var I64ListI64ServiceMultiGetListAllResult_Success_DEFAULT map[TKey]TEntryList

func (p *I64ListI64ServiceMultiGetListAllResult) GetSuccess() map[TKey]TEntryList {
  return p.Success
}
func (p *I64ListI64ServiceMultiGetListAllResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceMultiGetListAllResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.MAP {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiGetListAllResult)  ReadField0(iprot thrift.TProtocol) error {
  _, _, size, err := iprot.ReadMapBegin()
  if err != nil {
    return thrift.PrependError("error reading map begin: ", err)
  }
  tMap := make(map[TKey]TEntryList, size)
  p.Success =  tMap
  for i := 0; i < size; i ++ {
var _key77 TKey
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TKey(v)
    _key77 = temp
}
    _, size, err := iprot.ReadListBegin()
    if err != nil {
      return thrift.PrependError("error reading list begin: ", err)
    }
    tSlice := make(TEntryList, 0, size)
    _val78 :=  tSlice
    for i := 0; i < size; i ++ {
var _elem79 TEntry
      if v, err := iprot.ReadI64(); err != nil {
      return thrift.PrependError("error reading field 0: ", err)
} else {
      temp := TEntry(v)
      _elem79 = temp
}
      _val78 = append(_val78, _elem79)
    }
    if err := iprot.ReadListEnd(); err != nil {
      return thrift.PrependError("error reading list end: ", err)
    }
    p.Success[_key77] = _val78
  }
  if err := iprot.ReadMapEnd(); err != nil {
    return thrift.PrependError("error reading map end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiGetListAllResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("multiGetListAll_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceMultiGetListAllResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.MAP, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteMapBegin(thrift.I64, thrift.LIST, len(p.Success)); err != nil {
      return thrift.PrependError("error writing map begin: ", err)
    }
    for k, v := range p.Success {
      if err := oprot.WriteI64(int64(k)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
      if err := oprot.WriteListBegin(thrift.I64, len(v)); err != nil {
        return thrift.PrependError("error writing list begin: ", err)
      }
      for _, v := range v {
        if err := oprot.WriteI64(int64(v)); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
      }
      if err := oprot.WriteListEnd(); err != nil {
        return thrift.PrependError("error writing list end: ", err)
      }
    }
    if err := oprot.WriteMapEnd(); err != nil {
      return thrift.PrependError("error writing map end: ", err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceMultiGetListAllResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceMultiGetListAllResult(%+v)", *p)
}

// Attributes:
//  - KeyList
//  - Start
//  - Length
type I64ListI64ServiceMultiGetSliceArgs struct {
  KeyList TKeyList `thrift:"keyList,1" db:"keyList" json:"keyList"`
  Start int32 `thrift:"start,2" db:"start" json:"start"`
  Length int32 `thrift:"length,3" db:"length" json:"length"`
}

func NewI64ListI64ServiceMultiGetSliceArgs() *I64ListI64ServiceMultiGetSliceArgs {
  return &I64ListI64ServiceMultiGetSliceArgs{}
}


func (p *I64ListI64ServiceMultiGetSliceArgs) GetKeyList() TKeyList {
  return p.KeyList
}

func (p *I64ListI64ServiceMultiGetSliceArgs) GetStart() int32 {
  return p.Start
}

func (p *I64ListI64ServiceMultiGetSliceArgs) GetLength() int32 {
  return p.Length
}
func (p *I64ListI64ServiceMultiGetSliceArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField3(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceArgs)  ReadField1(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TKeyList, 0, size)
  p.KeyList =  tSlice
  for i := 0; i < size; i ++ {
var _elem80 TKey
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TKey(v)
    _elem80 = temp
}
    p.KeyList = append(p.KeyList, _elem80)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Start = v
}
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceArgs)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Length = v
}
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("multiGetSlice_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("keyList", thrift.LIST, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:keyList: ", p), err) }
  if err := oprot.WriteListBegin(thrift.I64, len(p.KeyList)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.KeyList {
    if err := oprot.WriteI64(int64(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteListEnd(); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:keyList: ", p), err) }
  return err
}

func (p *I64ListI64ServiceMultiGetSliceArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("start", thrift.I32, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:start: ", p), err) }
  if err := oprot.WriteI32(int32(p.Start)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.start (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:start: ", p), err) }
  return err
}

func (p *I64ListI64ServiceMultiGetSliceArgs) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("length", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:length: ", p), err) }
  if err := oprot.WriteI32(int32(p.Length)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.length (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:length: ", p), err) }
  return err
}

func (p *I64ListI64ServiceMultiGetSliceArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceMultiGetSliceArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceMultiGetSliceResult struct {
  Success map[TKey]TEntryList `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceMultiGetSliceResult() *I64ListI64ServiceMultiGetSliceResult {
  return &I64ListI64ServiceMultiGetSliceResult{}
}

var I64ListI64ServiceMultiGetSliceResult_Success_DEFAULT map[TKey]TEntryList

func (p *I64ListI64ServiceMultiGetSliceResult) GetSuccess() map[TKey]TEntryList {
  return p.Success
}
func (p *I64ListI64ServiceMultiGetSliceResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceMultiGetSliceResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.MAP {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceResult)  ReadField0(iprot thrift.TProtocol) error {
  _, _, size, err := iprot.ReadMapBegin()
  if err != nil {
    return thrift.PrependError("error reading map begin: ", err)
  }
  tMap := make(map[TKey]TEntryList, size)
  p.Success =  tMap
  for i := 0; i < size; i ++ {
var _key81 TKey
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TKey(v)
    _key81 = temp
}
    _, size, err := iprot.ReadListBegin()
    if err != nil {
      return thrift.PrependError("error reading list begin: ", err)
    }
    tSlice := make(TEntryList, 0, size)
    _val82 :=  tSlice
    for i := 0; i < size; i ++ {
var _elem83 TEntry
      if v, err := iprot.ReadI64(); err != nil {
      return thrift.PrependError("error reading field 0: ", err)
} else {
      temp := TEntry(v)
      _elem83 = temp
}
      _val82 = append(_val82, _elem83)
    }
    if err := iprot.ReadListEnd(); err != nil {
      return thrift.PrependError("error reading list end: ", err)
    }
    p.Success[_key81] = _val82
  }
  if err := iprot.ReadMapEnd(); err != nil {
    return thrift.PrependError("error reading map end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("multiGetSlice_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.MAP, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteMapBegin(thrift.I64, thrift.LIST, len(p.Success)); err != nil {
      return thrift.PrependError("error writing map begin: ", err)
    }
    for k, v := range p.Success {
      if err := oprot.WriteI64(int64(k)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
      if err := oprot.WriteListBegin(thrift.I64, len(v)); err != nil {
        return thrift.PrependError("error writing list begin: ", err)
      }
      for _, v := range v {
        if err := oprot.WriteI64(int64(v)); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
      }
      if err := oprot.WriteListEnd(); err != nil {
        return thrift.PrependError("error writing list end: ", err)
      }
    }
    if err := oprot.WriteMapEnd(); err != nil {
      return thrift.PrependError("error writing map end: ", err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceMultiGetSliceResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceMultiGetSliceResult(%+v)", *p)
}

// Attributes:
//  - KeyList
//  - Start
//  - Length
type I64ListI64ServiceMultiGetSliceReverseArgs struct {
  KeyList TKeyList `thrift:"keyList,1" db:"keyList" json:"keyList"`
  Start int32 `thrift:"start,2" db:"start" json:"start"`
  Length int32 `thrift:"length,3" db:"length" json:"length"`
}

func NewI64ListI64ServiceMultiGetSliceReverseArgs() *I64ListI64ServiceMultiGetSliceReverseArgs {
  return &I64ListI64ServiceMultiGetSliceReverseArgs{}
}


func (p *I64ListI64ServiceMultiGetSliceReverseArgs) GetKeyList() TKeyList {
  return p.KeyList
}

func (p *I64ListI64ServiceMultiGetSliceReverseArgs) GetStart() int32 {
  return p.Start
}

func (p *I64ListI64ServiceMultiGetSliceReverseArgs) GetLength() int32 {
  return p.Length
}
func (p *I64ListI64ServiceMultiGetSliceReverseArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 3:
      if fieldTypeId == thrift.I32 {
        if err := p.ReadField3(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceReverseArgs)  ReadField1(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TKeyList, 0, size)
  p.KeyList =  tSlice
  for i := 0; i < size; i ++ {
var _elem84 TKey
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TKey(v)
    _elem84 = temp
}
    p.KeyList = append(p.KeyList, _elem84)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceReverseArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.Start = v
}
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceReverseArgs)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Length = v
}
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceReverseArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("multiGetSliceReverse_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField3(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceReverseArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("keyList", thrift.LIST, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:keyList: ", p), err) }
  if err := oprot.WriteListBegin(thrift.I64, len(p.KeyList)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.KeyList {
    if err := oprot.WriteI64(int64(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteListEnd(); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:keyList: ", p), err) }
  return err
}

func (p *I64ListI64ServiceMultiGetSliceReverseArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("start", thrift.I32, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:start: ", p), err) }
  if err := oprot.WriteI32(int32(p.Start)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.start (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:start: ", p), err) }
  return err
}

func (p *I64ListI64ServiceMultiGetSliceReverseArgs) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("length", thrift.I32, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:length: ", p), err) }
  if err := oprot.WriteI32(int32(p.Length)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.length (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:length: ", p), err) }
  return err
}

func (p *I64ListI64ServiceMultiGetSliceReverseArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceMultiGetSliceReverseArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceMultiGetSliceReverseResult struct {
  Success map[TKey]TEntryList `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceMultiGetSliceReverseResult() *I64ListI64ServiceMultiGetSliceReverseResult {
  return &I64ListI64ServiceMultiGetSliceReverseResult{}
}

var I64ListI64ServiceMultiGetSliceReverseResult_Success_DEFAULT map[TKey]TEntryList

func (p *I64ListI64ServiceMultiGetSliceReverseResult) GetSuccess() map[TKey]TEntryList {
  return p.Success
}
func (p *I64ListI64ServiceMultiGetSliceReverseResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceMultiGetSliceReverseResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.MAP {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceReverseResult)  ReadField0(iprot thrift.TProtocol) error {
  _, _, size, err := iprot.ReadMapBegin()
  if err != nil {
    return thrift.PrependError("error reading map begin: ", err)
  }
  tMap := make(map[TKey]TEntryList, size)
  p.Success =  tMap
  for i := 0; i < size; i ++ {
var _key85 TKey
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TKey(v)
    _key85 = temp
}
    _, size, err := iprot.ReadListBegin()
    if err != nil {
      return thrift.PrependError("error reading list begin: ", err)
    }
    tSlice := make(TEntryList, 0, size)
    _val86 :=  tSlice
    for i := 0; i < size; i ++ {
var _elem87 TEntry
      if v, err := iprot.ReadI64(); err != nil {
      return thrift.PrependError("error reading field 0: ", err)
} else {
      temp := TEntry(v)
      _elem87 = temp
}
      _val86 = append(_val86, _elem87)
    }
    if err := iprot.ReadListEnd(); err != nil {
      return thrift.PrependError("error reading list end: ", err)
    }
    p.Success[_key85] = _val86
  }
  if err := iprot.ReadMapEnd(); err != nil {
    return thrift.PrependError("error reading map end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceReverseResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("multiGetSliceReverse_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceMultiGetSliceReverseResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.MAP, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteMapBegin(thrift.I64, thrift.LIST, len(p.Success)); err != nil {
      return thrift.PrependError("error writing map begin: ", err)
    }
    for k, v := range p.Success {
      if err := oprot.WriteI64(int64(k)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
      if err := oprot.WriteListBegin(thrift.I64, len(v)); err != nil {
        return thrift.PrependError("error writing list begin: ", err)
      }
      for _, v := range v {
        if err := oprot.WriteI64(int64(v)); err != nil {
        return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
      }
      if err := oprot.WriteListEnd(); err != nil {
        return thrift.PrependError("error writing list end: ", err)
      }
    }
    if err := oprot.WriteMapEnd(); err != nil {
      return thrift.PrependError("error writing map end: ", err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceMultiGetSliceReverseResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceMultiGetSliceReverseResult(%+v)", *p)
}

// Attributes:
//  - KeyList
//  - Entry
type I64ListI64ServiceMultiPutArgs struct {
  KeyList TKeyList `thrift:"keyList,1" db:"keyList" json:"keyList"`
  Entry TEntry `thrift:"entry,2" db:"entry" json:"entry"`
}

func NewI64ListI64ServiceMultiPutArgs() *I64ListI64ServiceMultiPutArgs {
  return &I64ListI64ServiceMultiPutArgs{}
}


func (p *I64ListI64ServiceMultiPutArgs) GetKeyList() TKeyList {
  return p.KeyList
}

func (p *I64ListI64ServiceMultiPutArgs) GetEntry() TEntry {
  return p.Entry
}
func (p *I64ListI64ServiceMultiPutArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiPutArgs)  ReadField1(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TKeyList, 0, size)
  p.KeyList =  tSlice
  for i := 0; i < size; i ++ {
var _elem88 TKey
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TKey(v)
    _elem88 = temp
}
    p.KeyList = append(p.KeyList, _elem88)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiPutArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TEntry(v)
  p.Entry = temp
}
  return nil
}

func (p *I64ListI64ServiceMultiPutArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("multiPut_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceMultiPutArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("keyList", thrift.LIST, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:keyList: ", p), err) }
  if err := oprot.WriteListBegin(thrift.I64, len(p.KeyList)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.KeyList {
    if err := oprot.WriteI64(int64(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteListEnd(); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:keyList: ", p), err) }
  return err
}

func (p *I64ListI64ServiceMultiPutArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entry", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entry: ", p), err) }
  if err := oprot.WriteI64(int64(p.Entry)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entry (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entry: ", p), err) }
  return err
}

func (p *I64ListI64ServiceMultiPutArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceMultiPutArgs(%+v)", *p)
}

// Attributes:
//  - Success
type I64ListI64ServiceMultiPutResult struct {
  Success map[TKey]bool `thrift:"success,0" db:"success" json:"success,omitempty"`
}

func NewI64ListI64ServiceMultiPutResult() *I64ListI64ServiceMultiPutResult {
  return &I64ListI64ServiceMultiPutResult{}
}

var I64ListI64ServiceMultiPutResult_Success_DEFAULT map[TKey]bool

func (p *I64ListI64ServiceMultiPutResult) GetSuccess() map[TKey]bool {
  return p.Success
}
func (p *I64ListI64ServiceMultiPutResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *I64ListI64ServiceMultiPutResult) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 0:
      if fieldTypeId == thrift.MAP {
        if err := p.ReadField0(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiPutResult)  ReadField0(iprot thrift.TProtocol) error {
  _, _, size, err := iprot.ReadMapBegin()
  if err != nil {
    return thrift.PrependError("error reading map begin: ", err)
  }
  tMap := make(map[TKey]bool, size)
  p.Success =  tMap
  for i := 0; i < size; i ++ {
var _key89 TKey
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TKey(v)
    _key89 = temp
}
var _val90 bool
    if v, err := iprot.ReadBool(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    _val90 = v
}
    p.Success[_key89] = _val90
  }
  if err := iprot.ReadMapEnd(); err != nil {
    return thrift.PrependError("error reading map end: ", err)
  }
  return nil
}

func (p *I64ListI64ServiceMultiPutResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("multiPut_result"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField0(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceMultiPutResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.MAP, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := oprot.WriteMapBegin(thrift.I64, thrift.BOOL, len(p.Success)); err != nil {
      return thrift.PrependError("error writing map begin: ", err)
    }
    for k, v := range p.Success {
      if err := oprot.WriteI64(int64(k)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
      if err := oprot.WriteBool(bool(v)); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
    }
    if err := oprot.WriteMapEnd(); err != nil {
      return thrift.PrependError("error writing map end: ", err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 0:success: ", p), err) }
  }
  return err
}

func (p *I64ListI64ServiceMultiPutResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceMultiPutResult(%+v)", *p)
}

// Attributes:
//  - Key
//  - Entry
type I64ListI64ServicePutOwArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  Entry TEntry `thrift:"entry,2" db:"entry" json:"entry"`
}

func NewI64ListI64ServicePutOwArgs() *I64ListI64ServicePutOwArgs {
  return &I64ListI64ServicePutOwArgs{}
}


func (p *I64ListI64ServicePutOwArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServicePutOwArgs) GetEntry() TEntry {
  return p.Entry
}
func (p *I64ListI64ServicePutOwArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServicePutOwArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServicePutOwArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TEntry(v)
  p.Entry = temp
}
  return nil
}

func (p *I64ListI64ServicePutOwArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("put_ow_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServicePutOwArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServicePutOwArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entry", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entry: ", p), err) }
  if err := oprot.WriteI64(int64(p.Entry)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entry (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entry: ", p), err) }
  return err
}

func (p *I64ListI64ServicePutOwArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServicePutOwArgs(%+v)", *p)
}

// Attributes:
//  - UidList
//  - Entry
type I64ListI64ServicePutMultiKeyOwArgs struct {
  UidList TKeyList `thrift:"uidList,1" db:"uidList" json:"uidList"`
  Entry TEntry `thrift:"entry,2" db:"entry" json:"entry"`
}

func NewI64ListI64ServicePutMultiKeyOwArgs() *I64ListI64ServicePutMultiKeyOwArgs {
  return &I64ListI64ServicePutMultiKeyOwArgs{}
}


func (p *I64ListI64ServicePutMultiKeyOwArgs) GetUidList() TKeyList {
  return p.UidList
}

func (p *I64ListI64ServicePutMultiKeyOwArgs) GetEntry() TEntry {
  return p.Entry
}
func (p *I64ListI64ServicePutMultiKeyOwArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.LIST {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServicePutMultiKeyOwArgs)  ReadField1(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(TKeyList, 0, size)
  p.UidList =  tSlice
  for i := 0; i < size; i ++ {
var _elem91 TKey
    if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    temp := TKey(v)
    _elem91 = temp
}
    p.UidList = append(p.UidList, _elem91)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *I64ListI64ServicePutMultiKeyOwArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TEntry(v)
  p.Entry = temp
}
  return nil
}

func (p *I64ListI64ServicePutMultiKeyOwArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("putMultiKey_ow_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServicePutMultiKeyOwArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("uidList", thrift.LIST, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:uidList: ", p), err) }
  if err := oprot.WriteListBegin(thrift.I64, len(p.UidList)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.UidList {
    if err := oprot.WriteI64(int64(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteListEnd(); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:uidList: ", p), err) }
  return err
}

func (p *I64ListI64ServicePutMultiKeyOwArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entry", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entry: ", p), err) }
  if err := oprot.WriteI64(int64(p.Entry)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entry (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entry: ", p), err) }
  return err
}

func (p *I64ListI64ServicePutMultiKeyOwArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServicePutMultiKeyOwArgs(%+v)", *p)
}

// Attributes:
//  - Key
//  - Entry
type I64ListI64ServiceRemoveOwArgs struct {
  Key TKey `thrift:"key,1" db:"key" json:"key"`
  Entry TEntry `thrift:"entry,2" db:"entry" json:"entry"`
}

func NewI64ListI64ServiceRemoveOwArgs() *I64ListI64ServiceRemoveOwArgs {
  return &I64ListI64ServiceRemoveOwArgs{}
}


func (p *I64ListI64ServiceRemoveOwArgs) GetKey() TKey {
  return p.Key
}

func (p *I64ListI64ServiceRemoveOwArgs) GetEntry() TEntry {
  return p.Entry
}
func (p *I64ListI64ServiceRemoveOwArgs) Read(iprot thrift.TProtocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField1(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    case 2:
      if fieldTypeId == thrift.I64 {
        if err := p.ReadField2(iprot); err != nil {
          return err
        }
      } else {
        if err := iprot.Skip(fieldTypeId); err != nil {
          return err
        }
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *I64ListI64ServiceRemoveOwArgs)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TKey(v)
  p.Key = temp
}
  return nil
}

func (p *I64ListI64ServiceRemoveOwArgs)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  temp := TEntry(v)
  p.Entry = temp
}
  return nil
}

func (p *I64ListI64ServiceRemoveOwArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("remove_ow_args"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
  }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *I64ListI64ServiceRemoveOwArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("key", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:key: ", p), err) }
  if err := oprot.WriteI64(int64(p.Key)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.key (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:key: ", p), err) }
  return err
}

func (p *I64ListI64ServiceRemoveOwArgs) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("entry", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:entry: ", p), err) }
  if err := oprot.WriteI64(int64(p.Entry)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.entry (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:entry: ", p), err) }
  return err
}

func (p *I64ListI64ServiceRemoveOwArgs) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("I64ListI64ServiceRemoveOwArgs(%+v)", *p)
}