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

package main

import (
	"bytes"
	"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 _ = bytes.Equal

// Attributes:
//  - Field1
//  - Field2
//  - Field3
//  - Field4
//  - Field5
//  - Field6
//  - Field7
//  - Field9
//  - Field12
//  - Field13
//  - Field14
//  - Field16
//  - Field17
//  - Field18
//  - Field22
//  - Field23
//  - Field24
//  - Field25
//  - Field29
//  - Field30
//  - Field59
//  - Field60
//  - Field67
//  - Field68
//  - Field78
//  - Field80
//  - Field81
//  - Field100
//  - Field101
//  - Field102
//  - Field103
//  - Field104
//  - Field128
//  - Field129
//  - Field130
//  - Field131
//  - Field150
//  - Field271
//  - Field272
//  - Field280
type BenchmarkMessage struct {
  Field1 string `thrift:"field1,1" db:"field1" json:"field1"`
  Field2 int32 `thrift:"field2,2" db:"field2" json:"field2"`
  Field3 int32 `thrift:"field3,3" db:"field3" json:"field3"`
  Field4 string `thrift:"field4,4" db:"field4" json:"field4"`
  Field5 int64 `thrift:"field5,5" db:"field5" json:"field5"`
  Field6 int32 `thrift:"field6,6" db:"field6" json:"field6"`
  Field7 string `thrift:"field7,7" db:"field7" json:"field7"`
  // unused field # 8
  Field9 string `thrift:"field9,9" db:"field9" json:"field9"`
  // unused fields # 10 to 11
  Field12 bool `thrift:"field12,12" db:"field12" json:"field12"`
  Field13 bool `thrift:"field13,13" db:"field13" json:"field13"`
  Field14 bool `thrift:"field14,14" db:"field14" json:"field14"`
  // unused field # 15
  Field16 int32 `thrift:"field16,16" db:"field16" json:"field16"`
  Field17 bool `thrift:"field17,17" db:"field17" json:"field17"`
  Field18 string `thrift:"field18,18" db:"field18" json:"field18"`
  // unused fields # 19 to 21
  Field22 int64 `thrift:"field22,22" db:"field22" json:"field22"`
  Field23 int32 `thrift:"field23,23" db:"field23" json:"field23"`
  Field24 bool `thrift:"field24,24" db:"field24" json:"field24"`
  Field25 int32 `thrift:"field25,25" db:"field25" json:"field25"`
  // unused fields # 26 to 28
  Field29 int32 `thrift:"field29,29" db:"field29" json:"field29"`
  Field30 bool `thrift:"field30,30" db:"field30" json:"field30"`
  // unused fields # 31 to 58
  Field59 bool `thrift:"field59,59" db:"field59" json:"field59"`
  Field60 int32 `thrift:"field60,60" db:"field60" json:"field60"`
  // unused fields # 61 to 66
  Field67 int32 `thrift:"field67,67" db:"field67" json:"field67"`
  Field68 int32 `thrift:"field68,68" db:"field68" json:"field68"`
  // unused fields # 69 to 77
  Field78 bool `thrift:"field78,78" db:"field78" json:"field78"`
  // unused field # 79
  Field80 bool `thrift:"field80,80" db:"field80" json:"field80"`
  Field81 bool `thrift:"field81,81" db:"field81" json:"field81"`
  // unused fields # 82 to 99
  Field100 int32 `thrift:"field100,100" db:"field100" json:"field100"`
  Field101 int32 `thrift:"field101,101" db:"field101" json:"field101"`
  Field102 string `thrift:"field102,102" db:"field102" json:"field102"`
  Field103 string `thrift:"field103,103" db:"field103" json:"field103"`
  Field104 int32 `thrift:"field104,104" db:"field104" json:"field104"`
  // unused fields # 105 to 127
  Field128 int32 `thrift:"field128,128" db:"field128" json:"field128"`
  Field129 string `thrift:"field129,129" db:"field129" json:"field129"`
  Field130 int32 `thrift:"field130,130" db:"field130" json:"field130"`
  Field131 int32 `thrift:"field131,131" db:"field131" json:"field131"`
  // unused fields # 132 to 149
  Field150 int32 `thrift:"field150,150" db:"field150" json:"field150"`
  // unused fields # 151 to 270
  Field271 int32 `thrift:"field271,271" db:"field271" json:"field271"`
  Field272 int32 `thrift:"field272,272" db:"field272" json:"field272"`
  // unused fields # 273 to 279
  Field280 int32 `thrift:"field280,280" db:"field280" json:"field280"`
}

func NewBenchmarkMessage() *BenchmarkMessage {
  return &BenchmarkMessage{}
}


func (p *BenchmarkMessage) GetField1() string {
  return p.Field1
}

func (p *BenchmarkMessage) GetField2() int32 {
  return p.Field2
}

func (p *BenchmarkMessage) GetField3() int32 {
  return p.Field3
}

func (p *BenchmarkMessage) GetField4() string {
  return p.Field4
}

func (p *BenchmarkMessage) GetField5() int64 {
  return p.Field5
}

func (p *BenchmarkMessage) GetField6() int32 {
  return p.Field6
}

func (p *BenchmarkMessage) GetField7() string {
  return p.Field7
}

func (p *BenchmarkMessage) GetField9() string {
  return p.Field9
}

func (p *BenchmarkMessage) GetField12() bool {
  return p.Field12
}

func (p *BenchmarkMessage) GetField13() bool {
  return p.Field13
}

func (p *BenchmarkMessage) GetField14() bool {
  return p.Field14
}

func (p *BenchmarkMessage) GetField16() int32 {
  return p.Field16
}

func (p *BenchmarkMessage) GetField17() bool {
  return p.Field17
}

func (p *BenchmarkMessage) GetField18() string {
  return p.Field18
}

func (p *BenchmarkMessage) GetField22() int64 {
  return p.Field22
}

func (p *BenchmarkMessage) GetField23() int32 {
  return p.Field23
}

func (p *BenchmarkMessage) GetField24() bool {
  return p.Field24
}

func (p *BenchmarkMessage) GetField25() int32 {
  return p.Field25
}

func (p *BenchmarkMessage) GetField29() int32 {
  return p.Field29
}

func (p *BenchmarkMessage) GetField30() bool {
  return p.Field30
}

func (p *BenchmarkMessage) GetField59() bool {
  return p.Field59
}

func (p *BenchmarkMessage) GetField60() int32 {
  return p.Field60
}

func (p *BenchmarkMessage) GetField67() int32 {
  return p.Field67
}

func (p *BenchmarkMessage) GetField68() int32 {
  return p.Field68
}

func (p *BenchmarkMessage) GetField78() bool {
  return p.Field78
}

func (p *BenchmarkMessage) GetField80() bool {
  return p.Field80
}

func (p *BenchmarkMessage) GetField81() bool {
  return p.Field81
}

func (p *BenchmarkMessage) GetField100() int32 {
  return p.Field100
}

func (p *BenchmarkMessage) GetField101() int32 {
  return p.Field101
}

func (p *BenchmarkMessage) GetField102() string {
  return p.Field102
}

func (p *BenchmarkMessage) GetField103() string {
  return p.Field103
}

func (p *BenchmarkMessage) GetField104() int32 {
  return p.Field104
}

func (p *BenchmarkMessage) GetField128() int32 {
  return p.Field128
}

func (p *BenchmarkMessage) GetField129() string {
  return p.Field129
}

func (p *BenchmarkMessage) GetField130() int32 {
  return p.Field130
}

func (p *BenchmarkMessage) GetField131() int32 {
  return p.Field131
}

func (p *BenchmarkMessage) GetField150() int32 {
  return p.Field150
}

func (p *BenchmarkMessage) GetField271() int32 {
  return p.Field271
}

func (p *BenchmarkMessage) GetField272() int32 {
  return p.Field272
}

func (p *BenchmarkMessage) GetField280() int32 {
  return p.Field280
}
func (p *BenchmarkMessage) 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 err := p.ReadField1(iprot); err != nil {
        return err
      }
    case 2:
      if err := p.ReadField2(iprot); err != nil {
        return err
      }
    case 3:
      if err := p.ReadField3(iprot); err != nil {
        return err
      }
    case 4:
      if err := p.ReadField4(iprot); err != nil {
        return err
      }
    case 5:
      if err := p.ReadField5(iprot); err != nil {
        return err
      }
    case 6:
      if err := p.ReadField6(iprot); err != nil {
        return err
      }
    case 7:
      if err := p.ReadField7(iprot); err != nil {
        return err
      }
    case 9:
      if err := p.ReadField9(iprot); err != nil {
        return err
      }
    case 12:
      if err := p.ReadField12(iprot); err != nil {
        return err
      }
    case 13:
      if err := p.ReadField13(iprot); err != nil {
        return err
      }
    case 14:
      if err := p.ReadField14(iprot); err != nil {
        return err
      }
    case 16:
      if err := p.ReadField16(iprot); err != nil {
        return err
      }
    case 17:
      if err := p.ReadField17(iprot); err != nil {
        return err
      }
    case 18:
      if err := p.ReadField18(iprot); err != nil {
        return err
      }
    case 22:
      if err := p.ReadField22(iprot); err != nil {
        return err
      }
    case 23:
      if err := p.ReadField23(iprot); err != nil {
        return err
      }
    case 24:
      if err := p.ReadField24(iprot); err != nil {
        return err
      }
    case 25:
      if err := p.ReadField25(iprot); err != nil {
        return err
      }
    case 29:
      if err := p.ReadField29(iprot); err != nil {
        return err
      }
    case 30:
      if err := p.ReadField30(iprot); err != nil {
        return err
      }
    case 59:
      if err := p.ReadField59(iprot); err != nil {
        return err
      }
    case 60:
      if err := p.ReadField60(iprot); err != nil {
        return err
      }
    case 67:
      if err := p.ReadField67(iprot); err != nil {
        return err
      }
    case 68:
      if err := p.ReadField68(iprot); err != nil {
        return err
      }
    case 78:
      if err := p.ReadField78(iprot); err != nil {
        return err
      }
    case 80:
      if err := p.ReadField80(iprot); err != nil {
        return err
      }
    case 81:
      if err := p.ReadField81(iprot); err != nil {
        return err
      }
    case 100:
      if err := p.ReadField100(iprot); err != nil {
        return err
      }
    case 101:
      if err := p.ReadField101(iprot); err != nil {
        return err
      }
    case 102:
      if err := p.ReadField102(iprot); err != nil {
        return err
      }
    case 103:
      if err := p.ReadField103(iprot); err != nil {
        return err
      }
    case 104:
      if err := p.ReadField104(iprot); err != nil {
        return err
      }
    case 128:
      if err := p.ReadField128(iprot); err != nil {
        return err
      }
    case 129:
      if err := p.ReadField129(iprot); err != nil {
        return err
      }
    case 130:
      if err := p.ReadField130(iprot); err != nil {
        return err
      }
    case 131:
      if err := p.ReadField131(iprot); err != nil {
        return err
      }
    case 150:
      if err := p.ReadField150(iprot); err != nil {
        return err
      }
    case 271:
      if err := p.ReadField271(iprot); err != nil {
        return err
      }
    case 272:
      if err := p.ReadField272(iprot); err != nil {
        return err
      }
    case 280:
      if err := p.ReadField280(iprot); 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 *BenchmarkMessage)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.Field1 = v
}
  return nil
}

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

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

func (p *BenchmarkMessage)  ReadField4(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.Field4 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField5(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.Field5 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField6(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 6: ", err)
} else {
  p.Field6 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField7(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 7: ", err)
} else {
  p.Field7 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField9(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 9: ", err)
} else {
  p.Field9 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField12(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 12: ", err)
} else {
  p.Field12 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField13(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 13: ", err)
} else {
  p.Field13 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField14(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 14: ", err)
} else {
  p.Field14 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField16(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 16: ", err)
} else {
  p.Field16 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField17(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 17: ", err)
} else {
  p.Field17 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField18(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 18: ", err)
} else {
  p.Field18 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField22(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 22: ", err)
} else {
  p.Field22 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField23(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 23: ", err)
} else {
  p.Field23 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField24(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 24: ", err)
} else {
  p.Field24 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField25(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 25: ", err)
} else {
  p.Field25 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField29(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 29: ", err)
} else {
  p.Field29 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField30(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 30: ", err)
} else {
  p.Field30 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField59(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 59: ", err)
} else {
  p.Field59 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField60(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 60: ", err)
} else {
  p.Field60 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField67(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 67: ", err)
} else {
  p.Field67 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField68(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 68: ", err)
} else {
  p.Field68 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField78(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 78: ", err)
} else {
  p.Field78 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField80(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 80: ", err)
} else {
  p.Field80 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField81(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadBool(); err != nil {
  return thrift.PrependError("error reading field 81: ", err)
} else {
  p.Field81 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField100(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 100: ", err)
} else {
  p.Field100 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField101(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 101: ", err)
} else {
  p.Field101 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField102(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 102: ", err)
} else {
  p.Field102 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField103(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 103: ", err)
} else {
  p.Field103 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField104(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 104: ", err)
} else {
  p.Field104 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField128(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 128: ", err)
} else {
  p.Field128 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField129(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 129: ", err)
} else {
  p.Field129 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField130(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 130: ", err)
} else {
  p.Field130 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField131(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 131: ", err)
} else {
  p.Field131 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField150(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 150: ", err)
} else {
  p.Field150 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField271(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 271: ", err)
} else {
  p.Field271 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField272(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 272: ", err)
} else {
  p.Field272 = v
}
  return nil
}

func (p *BenchmarkMessage)  ReadField280(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 280: ", err)
} else {
  p.Field280 = v
}
  return nil
}

func (p *BenchmarkMessage) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("BenchmarkMessage"); 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 := p.writeField4(oprot); err != nil { return err }
    if err := p.writeField5(oprot); err != nil { return err }
    if err := p.writeField6(oprot); err != nil { return err }
    if err := p.writeField7(oprot); err != nil { return err }
    if err := p.writeField9(oprot); err != nil { return err }
    if err := p.writeField12(oprot); err != nil { return err }
    if err := p.writeField13(oprot); err != nil { return err }
    if err := p.writeField14(oprot); err != nil { return err }
    if err := p.writeField16(oprot); err != nil { return err }
    if err := p.writeField17(oprot); err != nil { return err }
    if err := p.writeField18(oprot); err != nil { return err }
    if err := p.writeField22(oprot); err != nil { return err }
    if err := p.writeField23(oprot); err != nil { return err }
    if err := p.writeField24(oprot); err != nil { return err }
    if err := p.writeField25(oprot); err != nil { return err }
    if err := p.writeField29(oprot); err != nil { return err }
    if err := p.writeField30(oprot); err != nil { return err }
    if err := p.writeField59(oprot); err != nil { return err }
    if err := p.writeField60(oprot); err != nil { return err }
    if err := p.writeField67(oprot); err != nil { return err }
    if err := p.writeField68(oprot); err != nil { return err }
    if err := p.writeField78(oprot); err != nil { return err }
    if err := p.writeField80(oprot); err != nil { return err }
    if err := p.writeField81(oprot); err != nil { return err }
    if err := p.writeField100(oprot); err != nil { return err }
    if err := p.writeField101(oprot); err != nil { return err }
    if err := p.writeField102(oprot); err != nil { return err }
    if err := p.writeField103(oprot); err != nil { return err }
    if err := p.writeField104(oprot); err != nil { return err }
    if err := p.writeField128(oprot); err != nil { return err }
    if err := p.writeField129(oprot); err != nil { return err }
    if err := p.writeField130(oprot); err != nil { return err }
    if err := p.writeField131(oprot); err != nil { return err }
    if err := p.writeField150(oprot); err != nil { return err }
    if err := p.writeField271(oprot); err != nil { return err }
    if err := p.writeField272(oprot); err != nil { return err }
    if err := p.writeField280(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 *BenchmarkMessage) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field1", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:field1: ", p), err) }
  if err := oprot.WriteString(string(p.Field1)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field1 (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:field1: ", p), err) }
  return err
}

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

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

func (p *BenchmarkMessage) writeField4(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field4", thrift.STRING, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:field4: ", p), err) }
  if err := oprot.WriteString(string(p.Field4)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field4 (4) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:field4: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField5(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field5", thrift.I64, 5); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:field5: ", p), err) }
  if err := oprot.WriteI64(int64(p.Field5)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field5 (5) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 5:field5: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField6(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field6", thrift.I32, 6); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:field6: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field6)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field6 (6) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 6:field6: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField7(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field7", thrift.STRING, 7); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:field7: ", p), err) }
  if err := oprot.WriteString(string(p.Field7)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field7 (7) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 7:field7: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField9(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field9", thrift.STRING, 9); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 9:field9: ", p), err) }
  if err := oprot.WriteString(string(p.Field9)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field9 (9) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 9:field9: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField12(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field12", thrift.BOOL, 12); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 12:field12: ", p), err) }
  if err := oprot.WriteBool(bool(p.Field12)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field12 (12) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 12:field12: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField13(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field13", thrift.BOOL, 13); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 13:field13: ", p), err) }
  if err := oprot.WriteBool(bool(p.Field13)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field13 (13) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 13:field13: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField14(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field14", thrift.BOOL, 14); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 14:field14: ", p), err) }
  if err := oprot.WriteBool(bool(p.Field14)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field14 (14) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 14:field14: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField16(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field16", thrift.I32, 16); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 16:field16: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field16)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field16 (16) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 16:field16: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField17(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field17", thrift.BOOL, 17); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 17:field17: ", p), err) }
  if err := oprot.WriteBool(bool(p.Field17)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field17 (17) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 17:field17: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField18(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field18", thrift.STRING, 18); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 18:field18: ", p), err) }
  if err := oprot.WriteString(string(p.Field18)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field18 (18) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 18:field18: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField22(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field22", thrift.I64, 22); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 22:field22: ", p), err) }
  if err := oprot.WriteI64(int64(p.Field22)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field22 (22) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 22:field22: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField23(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field23", thrift.I32, 23); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 23:field23: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field23)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field23 (23) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 23:field23: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField24(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field24", thrift.BOOL, 24); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 24:field24: ", p), err) }
  if err := oprot.WriteBool(bool(p.Field24)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field24 (24) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 24:field24: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField25(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field25", thrift.I32, 25); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 25:field25: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field25)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field25 (25) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 25:field25: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField29(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field29", thrift.I32, 29); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 29:field29: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field29)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field29 (29) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 29:field29: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField30(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field30", thrift.BOOL, 30); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 30:field30: ", p), err) }
  if err := oprot.WriteBool(bool(p.Field30)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field30 (30) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 30:field30: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField59(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field59", thrift.BOOL, 59); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 59:field59: ", p), err) }
  if err := oprot.WriteBool(bool(p.Field59)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field59 (59) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 59:field59: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField60(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field60", thrift.I32, 60); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 60:field60: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field60)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field60 (60) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 60:field60: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField67(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field67", thrift.I32, 67); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 67:field67: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field67)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field67 (67) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 67:field67: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField68(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field68", thrift.I32, 68); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 68:field68: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field68)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field68 (68) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 68:field68: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField78(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field78", thrift.BOOL, 78); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 78:field78: ", p), err) }
  if err := oprot.WriteBool(bool(p.Field78)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field78 (78) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 78:field78: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField80(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field80", thrift.BOOL, 80); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 80:field80: ", p), err) }
  if err := oprot.WriteBool(bool(p.Field80)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field80 (80) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 80:field80: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField81(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field81", thrift.BOOL, 81); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 81:field81: ", p), err) }
  if err := oprot.WriteBool(bool(p.Field81)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field81 (81) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 81:field81: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField100(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field100", thrift.I32, 100); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 100:field100: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field100)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field100 (100) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 100:field100: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField101(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field101", thrift.I32, 101); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 101:field101: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field101)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field101 (101) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 101:field101: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField102(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field102", thrift.STRING, 102); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 102:field102: ", p), err) }
  if err := oprot.WriteString(string(p.Field102)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field102 (102) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 102:field102: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField103(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field103", thrift.STRING, 103); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 103:field103: ", p), err) }
  if err := oprot.WriteString(string(p.Field103)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field103 (103) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 103:field103: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField104(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field104", thrift.I32, 104); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 104:field104: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field104)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field104 (104) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 104:field104: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField128(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field128", thrift.I32, 128); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 128:field128: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field128)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field128 (128) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 128:field128: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField129(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field129", thrift.STRING, 129); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 129:field129: ", p), err) }
  if err := oprot.WriteString(string(p.Field129)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field129 (129) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 129:field129: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField130(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field130", thrift.I32, 130); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 130:field130: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field130)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field130 (130) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 130:field130: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField131(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field131", thrift.I32, 131); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 131:field131: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field131)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field131 (131) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 131:field131: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField150(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field150", thrift.I32, 150); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 150:field150: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field150)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field150 (150) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 150:field150: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField271(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field271", thrift.I32, 271); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 271:field271: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field271)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field271 (271) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 271:field271: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField272(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field272", thrift.I32, 272); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 272:field272: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field272)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field272 (272) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 272:field272: ", p), err) }
  return err
}

func (p *BenchmarkMessage) writeField280(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("field280", thrift.I32, 280); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 280:field280: ", p), err) }
  if err := oprot.WriteI32(int32(p.Field280)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.field280 (280) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 280:field280: ", p), err) }
  return err
}

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

type Greeter interface {
  // Parameters:
  //  - Name
  Say(name *BenchmarkMessage) (r *BenchmarkMessage, err error)
}

type GreeterClient struct {
  Transport thrift.TTransport
  ProtocolFactory thrift.TProtocolFactory
  InputProtocol thrift.TProtocol
  OutputProtocol thrift.TProtocol
  SeqId int32
}

func NewGreeterClientFactory(t thrift.TTransport, f thrift.TProtocolFactory) *GreeterClient {
  return &GreeterClient{Transport: t,
    ProtocolFactory: f,
    InputProtocol: f.GetProtocol(t),
    OutputProtocol: f.GetProtocol(t),
    SeqId: 0,
  }
}

func NewGreeterClientProtocol(t thrift.TTransport, iprot thrift.TProtocol, oprot thrift.TProtocol) *GreeterClient {
  return &GreeterClient{Transport: t,
    ProtocolFactory: nil,
    InputProtocol: iprot,
    OutputProtocol: oprot,
    SeqId: 0,
  }
}

// Parameters:
//  - Name
func (p *GreeterClient) Say(name *BenchmarkMessage) (r *BenchmarkMessage, err error) {
  if err = p.sendSay(name); err != nil { return }
  return p.recvSay()
}

func (p *GreeterClient) sendSay(name *BenchmarkMessage)(err error) {
  oprot := p.OutputProtocol
  if oprot == nil {
    oprot = p.ProtocolFactory.GetProtocol(p.Transport)
    p.OutputProtocol = oprot
  }
  p.SeqId++
  if err = oprot.WriteMessageBegin("say", thrift.CALL, p.SeqId); err != nil {
      return
  }
  args := GreeterSayArgs{
  Name : name,
  }
  if err = args.Write(oprot); err != nil {
      return
  }
  if err = oprot.WriteMessageEnd(); err != nil {
      return
  }
  return oprot.Flush()
}


func (p *GreeterClient) recvSay() (value *BenchmarkMessage, err error) {
  iprot := p.InputProtocol
  if iprot == nil {
    iprot = p.ProtocolFactory.GetProtocol(p.Transport)
    p.InputProtocol = iprot
  }
  method, mTypeId, seqId, err := iprot.ReadMessageBegin()
  if err != nil {
    return
  }
  if method != "say" {
    err = thrift.NewTApplicationException(thrift.WRONG_METHOD_NAME, "say failed: wrong method name")
    return
  }
  if p.SeqId != seqId {
    err = thrift.NewTApplicationException(thrift.BAD_SEQUENCE_ID, "say failed: out of sequence response")
    return
  }
  if mTypeId == thrift.EXCEPTION {
    error0 := thrift.NewTApplicationException(thrift.UNKNOWN_APPLICATION_EXCEPTION, "Unknown Exception")
    var error1 error
    error1, err = error0.Read(iprot)
    if err != nil {
      return
    }
    if err = iprot.ReadMessageEnd(); err != nil {
      return
    }
    err = error1
    return
  }
  if mTypeId != thrift.REPLY {
    err = thrift.NewTApplicationException(thrift.INVALID_MESSAGE_TYPE_EXCEPTION, "say failed: invalid message type")
    return
  }
  result := GreeterSayResult{}
  if err = result.Read(iprot); err != nil {
    return
  }
  if err = iprot.ReadMessageEnd(); err != nil {
    return
  }
  value = result.GetSuccess()
  return
}


type GreeterProcessor struct {
  processorMap map[string]thrift.TProcessorFunction
  handler Greeter
}

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

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

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

func NewGreeterProcessor(handler Greeter) *GreeterProcessor {

  self2 := &GreeterProcessor{handler:handler, processorMap:make(map[string]thrift.TProcessorFunction)}
  self2.processorMap["say"] = &greeterProcessorSay{handler:handler}
return self2
}

func (p *GreeterProcessor) Process(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(seqId, iprot, oprot)
  }
  iprot.Skip(thrift.STRUCT)
  iprot.ReadMessageEnd()
  x3 := thrift.NewTApplicationException(thrift.UNKNOWN_METHOD, "Unknown function " + name)
  oprot.WriteMessageBegin(name, thrift.EXCEPTION, seqId)
  x3.Write(oprot)
  oprot.WriteMessageEnd()
  oprot.Flush()
  return false, x3

}

type greeterProcessorSay struct {
  handler Greeter
}

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

  iprot.ReadMessageEnd()
  result := GreeterSayResult{}
var retval *BenchmarkMessage
  var err2 error
  if retval, err2 = p.handler.Say(args.Name); err2 != nil {
    x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing say: " + err2.Error())
    oprot.WriteMessageBegin("say", thrift.EXCEPTION, seqId)
    x.Write(oprot)
    oprot.WriteMessageEnd()
    oprot.Flush()
    return true, err2
  } else {
    result.Success = retval
}
  if err2 = oprot.WriteMessageBegin("say", 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
}


// HELPER FUNCTIONS AND STRUCTURES

// Attributes:
//  - Name
type GreeterSayArgs struct {
  Name *BenchmarkMessage `thrift:"name,1" db:"name" json:"name"`
}

func NewGreeterSayArgs() *GreeterSayArgs {
  return &GreeterSayArgs{}
}

var GreeterSayArgs_Name_DEFAULT *BenchmarkMessage
func (p *GreeterSayArgs) GetName() *BenchmarkMessage {
  if !p.IsSetName() {
    return GreeterSayArgs_Name_DEFAULT
  }
return p.Name
}
func (p *GreeterSayArgs) IsSetName() bool {
  return p.Name != nil
}

func (p *GreeterSayArgs) 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 err := p.ReadField1(iprot); 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 *GreeterSayArgs)  ReadField1(iprot thrift.TProtocol) error {
  p.Name = &BenchmarkMessage{}
  if err := p.Name.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Name), err)
  }
  return nil
}

func (p *GreeterSayArgs) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("say_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 *GreeterSayArgs) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("name", thrift.STRUCT, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:name: ", p), err) }
  if err := p.Name.Write(oprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Name), err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:name: ", p), err) }
  return err
}

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

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

func NewGreeterSayResult() *GreeterSayResult {
  return &GreeterSayResult{}
}

var GreeterSayResult_Success_DEFAULT *BenchmarkMessage
func (p *GreeterSayResult) GetSuccess() *BenchmarkMessage {
  if !p.IsSetSuccess() {
    return GreeterSayResult_Success_DEFAULT
  }
return p.Success
}
func (p *GreeterSayResult) IsSetSuccess() bool {
  return p.Success != nil
}

func (p *GreeterSayResult) 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 err := p.ReadField0(iprot); 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 *GreeterSayResult)  ReadField0(iprot thrift.TProtocol) error {
  p.Success = &BenchmarkMessage{}
  if err := p.Success.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Success), err)
  }
  return nil
}

func (p *GreeterSayResult) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("say_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 *GreeterSayResult) writeField0(oprot thrift.TProtocol) (err error) {
  if p.IsSetSuccess() {
    if err := oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 0:success: ", p), err) }
    if err := p.Success.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Success), 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 *GreeterSayResult) String() string {
  if p == nil {
    return "<nil>"
  }
  return fmt.Sprintf("GreeterSayResult(%+v)", *p)
}


