ttypes.go

// Copyright (c) 2016 Uber Technologies, Inc.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.

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

package gauntlet_tchannel

import (
	"bytes"
	"fmt"
	"github.com/apache/thrift/lib/go/thrift"
)

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

var GoUnusedProtection__ int

//Docstring!
type Numberz int64

const (
	Numberz_ONE   Numberz = 1
	Numberz_TWO   Numberz = 2
	Numberz_THREE Numberz = 3
	Numberz_FIVE  Numberz = 5
	Numberz_SIX   Numberz = 6
	Numberz_EIGHT Numberz = 8
)

func (p Numberz) String() string {
	switch p {
	case Numberz_ONE:
		return "ONE"
	case Numberz_TWO:
		return "TWO"
	case Numberz_THREE:
		return "THREE"
	case Numberz_FIVE:
		return "FIVE"
	case Numberz_SIX:
		return "SIX"
	case Numberz_EIGHT:
		return "EIGHT"
	}
	return "<UNSET>"
}

func NumberzFromString(s string) (Numberz, error) {
	switch s {
	case "ONE":
		return Numberz_ONE, nil
	case "TWO":
		return Numberz_TWO, nil
	case "THREE":
		return Numberz_THREE, nil
	case "FIVE":
		return Numberz_FIVE, nil
	case "SIX":
		return Numberz_SIX, nil
	case "EIGHT":
		return Numberz_EIGHT, nil
	}
	return Numberz(0), fmt.Errorf("not a valid Numberz string")
}

func NumberzPtr(v Numberz) *Numberz { return &v }

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

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

type UserId int64

func UserIdPtr(v UserId) *UserId { return &v }

type MapType map[string]*Bonk

func MapTypePtr(v MapType) *MapType { return &v }

// Attributes:
//  - Message
//  - Type
type Bonk struct {
	Message *string `thrift:"message,1" json:"message,omitempty"`
	Type    *int32  `thrift:"type,2" json:"type,omitempty"`
}

func NewBonk() *Bonk {
	return &Bonk{}
}

var Bonk_Message_DEFAULT string

func (p *Bonk) GetMessage() string {
	if !p.IsSetMessage() {
		return Bonk_Message_DEFAULT
	}
	return *p.Message
}

var Bonk_Type_DEFAULT int32

func (p *Bonk) GetType() int32 {
	if !p.IsSetType() {
		return Bonk_Type_DEFAULT
	}
	return *p.Type
}
func (p *Bonk) IsSetMessage() bool {
	return p.Message != nil
}

func (p *Bonk) IsSetType() bool {
	return p.Type != nil
}

func (p *Bonk) 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
			}
		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 *Bonk) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Message = &v
	}
	return nil
}

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

func (p *Bonk) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("Bonk"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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 *Bonk) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetMessage() {
		if err := oprot.WriteFieldBegin("message", thrift.STRING, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:message: ", p), err)
		}
		if err := oprot.WriteString(string(*p.Message)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.message (1) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1:message: ", p), err)
		}
	}
	return err
}

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

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

// Attributes:
//  - ImTrue
//  - ImFalse
type Bools struct {
	ImTrue  *bool `thrift:"im_true,1" json:"im_true,omitempty"`
	ImFalse *bool `thrift:"im_false,2" json:"im_false,omitempty"`
}

func NewBools() *Bools {
	return &Bools{}
}

var Bools_ImTrue_DEFAULT bool

func (p *Bools) GetImTrue() bool {
	if !p.IsSetImTrue() {
		return Bools_ImTrue_DEFAULT
	}
	return *p.ImTrue
}

var Bools_ImFalse_DEFAULT bool

func (p *Bools) GetImFalse() bool {
	if !p.IsSetImFalse() {
		return Bools_ImFalse_DEFAULT
	}
	return *p.ImFalse
}
func (p *Bools) IsSetImTrue() bool {
	return p.ImTrue != nil
}

func (p *Bools) IsSetImFalse() bool {
	return p.ImFalse != nil
}

func (p *Bools) 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
			}
		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 *Bools) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.ImTrue = &v
	}
	return nil
}

func (p *Bools) readField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.ImFalse = &v
	}
	return nil
}

func (p *Bools) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("Bools"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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 *Bools) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetImTrue() {
		if err := oprot.WriteFieldBegin("im_true", thrift.BOOL, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:im_true: ", p), err)
		}
		if err := oprot.WriteBool(bool(*p.ImTrue)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.im_true (1) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1:im_true: ", p), err)
		}
	}
	return err
}

func (p *Bools) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetImFalse() {
		if err := oprot.WriteFieldBegin("im_false", thrift.BOOL, 2); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:im_false: ", p), err)
		}
		if err := oprot.WriteBool(bool(*p.ImFalse)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.im_false (2) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 2:im_false: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - StringThing
//  - ByteThing
//  - I32Thing
//  - I64Thing
type Xtruct struct {
	StringThing *string `thrift:"string_thing,1" json:"string_thing,omitempty"`
	// unused fields # 2 to 3
	ByteThing *int8 `thrift:"byte_thing,4" json:"byte_thing,omitempty"`
	// unused fields # 5 to 8
	I32Thing *int32 `thrift:"i32_thing,9" json:"i32_thing,omitempty"`
	// unused field # 10
	I64Thing *int64 `thrift:"i64_thing,11" json:"i64_thing,omitempty"`
}

func NewXtruct() *Xtruct {
	return &Xtruct{}
}

var Xtruct_StringThing_DEFAULT string

func (p *Xtruct) GetStringThing() string {
	if !p.IsSetStringThing() {
		return Xtruct_StringThing_DEFAULT
	}
	return *p.StringThing
}

var Xtruct_ByteThing_DEFAULT int8

func (p *Xtruct) GetByteThing() int8 {
	if !p.IsSetByteThing() {
		return Xtruct_ByteThing_DEFAULT
	}
	return *p.ByteThing
}

var Xtruct_I32Thing_DEFAULT int32

func (p *Xtruct) GetI32Thing() int32 {
	if !p.IsSetI32Thing() {
		return Xtruct_I32Thing_DEFAULT
	}
	return *p.I32Thing
}

var Xtruct_I64Thing_DEFAULT int64

func (p *Xtruct) GetI64Thing() int64 {
	if !p.IsSetI64Thing() {
		return Xtruct_I64Thing_DEFAULT
	}
	return *p.I64Thing
}
func (p *Xtruct) IsSetStringThing() bool {
	return p.StringThing != nil
}

func (p *Xtruct) IsSetByteThing() bool {
	return p.ByteThing != nil
}

func (p *Xtruct) IsSetI32Thing() bool {
	return p.I32Thing != nil
}

func (p *Xtruct) IsSetI64Thing() bool {
	return p.I64Thing != nil
}

func (p *Xtruct) 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 4:
			if err := p.readField4(iprot); err != nil {
				return err
			}
		case 9:
			if err := p.readField9(iprot); err != nil {
				return err
			}
		case 11:
			if err := p.readField11(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 *Xtruct) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.StringThing = &v
	}
	return nil
}

func (p *Xtruct) readField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadByte(); err != nil {
		return thrift.PrependError("error reading field 4: ", err)
	} else {
		temp := int8(v)
		p.ByteThing = &temp
	}
	return nil
}

func (p *Xtruct) readField9(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 9: ", err)
	} else {
		p.I32Thing = &v
	}
	return nil
}

func (p *Xtruct) readField11(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return thrift.PrependError("error reading field 11: ", err)
	} else {
		p.I64Thing = &v
	}
	return nil
}

func (p *Xtruct) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("Xtruct"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField9(oprot); err != nil {
		return err
	}
	if err := p.writeField11(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 *Xtruct) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetStringThing() {
		if err := oprot.WriteFieldBegin("string_thing", thrift.STRING, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:string_thing: ", p), err)
		}
		if err := oprot.WriteString(string(*p.StringThing)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.string_thing (1) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1:string_thing: ", p), err)
		}
	}
	return err
}

func (p *Xtruct) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetByteThing() {
		if err := oprot.WriteFieldBegin("byte_thing", thrift.BYTE, 4); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:byte_thing: ", p), err)
		}
		if err := oprot.WriteByte(int8(*p.ByteThing)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.byte_thing (4) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 4:byte_thing: ", p), err)
		}
	}
	return err
}

func (p *Xtruct) writeField9(oprot thrift.TProtocol) (err error) {
	if p.IsSetI32Thing() {
		if err := oprot.WriteFieldBegin("i32_thing", thrift.I32, 9); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 9:i32_thing: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.I32Thing)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.i32_thing (9) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 9:i32_thing: ", p), err)
		}
	}
	return err
}

func (p *Xtruct) writeField11(oprot thrift.TProtocol) (err error) {
	if p.IsSetI64Thing() {
		if err := oprot.WriteFieldBegin("i64_thing", thrift.I64, 11); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 11:i64_thing: ", p), err)
		}
		if err := oprot.WriteI64(int64(*p.I64Thing)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.i64_thing (11) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 11:i64_thing: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - ByteThing
//  - StructThing
//  - I32Thing
type Xtruct2 struct {
	ByteThing   *int8   `thrift:"byte_thing,1" json:"byte_thing,omitempty"`
	StructThing *Xtruct `thrift:"struct_thing,2" json:"struct_thing,omitempty"`
	I32Thing    *int32  `thrift:"i32_thing,3" json:"i32_thing,omitempty"`
}

func NewXtruct2() *Xtruct2 {
	return &Xtruct2{}
}

var Xtruct2_ByteThing_DEFAULT int8

func (p *Xtruct2) GetByteThing() int8 {
	if !p.IsSetByteThing() {
		return Xtruct2_ByteThing_DEFAULT
	}
	return *p.ByteThing
}

var Xtruct2_StructThing_DEFAULT *Xtruct

func (p *Xtruct2) GetStructThing() *Xtruct {
	if !p.IsSetStructThing() {
		return Xtruct2_StructThing_DEFAULT
	}
	return p.StructThing
}

var Xtruct2_I32Thing_DEFAULT int32

func (p *Xtruct2) GetI32Thing() int32 {
	if !p.IsSetI32Thing() {
		return Xtruct2_I32Thing_DEFAULT
	}
	return *p.I32Thing
}
func (p *Xtruct2) IsSetByteThing() bool {
	return p.ByteThing != nil
}

func (p *Xtruct2) IsSetStructThing() bool {
	return p.StructThing != nil
}

func (p *Xtruct2) IsSetI32Thing() bool {
	return p.I32Thing != nil
}

func (p *Xtruct2) 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
			}
		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 *Xtruct2) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadByte(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		temp := int8(v)
		p.ByteThing = &temp
	}
	return nil
}

func (p *Xtruct2) readField2(iprot thrift.TProtocol) error {
	p.StructThing = &Xtruct{}
	if err := p.StructThing.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.StructThing), err)
	}
	return nil
}

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

func (p *Xtruct2) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("Xtruct2"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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 *Xtruct2) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetByteThing() {
		if err := oprot.WriteFieldBegin("byte_thing", thrift.BYTE, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:byte_thing: ", p), err)
		}
		if err := oprot.WriteByte(int8(*p.ByteThing)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.byte_thing (1) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1:byte_thing: ", p), err)
		}
	}
	return err
}

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

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

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

// Attributes:
//  - StringThing
//  - Changed
//  - I32Thing
//  - I64Thing
type Xtruct3 struct {
	StringThing *string `thrift:"string_thing,1" json:"string_thing,omitempty"`
	// unused fields # 2 to 3
	Changed *int32 `thrift:"changed,4" json:"changed,omitempty"`
	// unused fields # 5 to 8
	I32Thing *int32 `thrift:"i32_thing,9" json:"i32_thing,omitempty"`
	// unused field # 10
	I64Thing *int64 `thrift:"i64_thing,11" json:"i64_thing,omitempty"`
}

func NewXtruct3() *Xtruct3 {
	return &Xtruct3{}
}

var Xtruct3_StringThing_DEFAULT string

func (p *Xtruct3) GetStringThing() string {
	if !p.IsSetStringThing() {
		return Xtruct3_StringThing_DEFAULT
	}
	return *p.StringThing
}

var Xtruct3_Changed_DEFAULT int32

func (p *Xtruct3) GetChanged() int32 {
	if !p.IsSetChanged() {
		return Xtruct3_Changed_DEFAULT
	}
	return *p.Changed
}

var Xtruct3_I32Thing_DEFAULT int32

func (p *Xtruct3) GetI32Thing() int32 {
	if !p.IsSetI32Thing() {
		return Xtruct3_I32Thing_DEFAULT
	}
	return *p.I32Thing
}

var Xtruct3_I64Thing_DEFAULT int64

func (p *Xtruct3) GetI64Thing() int64 {
	if !p.IsSetI64Thing() {
		return Xtruct3_I64Thing_DEFAULT
	}
	return *p.I64Thing
}
func (p *Xtruct3) IsSetStringThing() bool {
	return p.StringThing != nil
}

func (p *Xtruct3) IsSetChanged() bool {
	return p.Changed != nil
}

func (p *Xtruct3) IsSetI32Thing() bool {
	return p.I32Thing != nil
}

func (p *Xtruct3) IsSetI64Thing() bool {
	return p.I64Thing != nil
}

func (p *Xtruct3) 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 4:
			if err := p.readField4(iprot); err != nil {
				return err
			}
		case 9:
			if err := p.readField9(iprot); err != nil {
				return err
			}
		case 11:
			if err := p.readField11(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 *Xtruct3) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.StringThing = &v
	}
	return nil
}

func (p *Xtruct3) readField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 4: ", err)
	} else {
		p.Changed = &v
	}
	return nil
}

func (p *Xtruct3) readField9(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 9: ", err)
	} else {
		p.I32Thing = &v
	}
	return nil
}

func (p *Xtruct3) readField11(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI64(); err != nil {
		return thrift.PrependError("error reading field 11: ", err)
	} else {
		p.I64Thing = &v
	}
	return nil
}

func (p *Xtruct3) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("Xtruct3"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField4(oprot); err != nil {
		return err
	}
	if err := p.writeField9(oprot); err != nil {
		return err
	}
	if err := p.writeField11(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 *Xtruct3) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetStringThing() {
		if err := oprot.WriteFieldBegin("string_thing", thrift.STRING, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:string_thing: ", p), err)
		}
		if err := oprot.WriteString(string(*p.StringThing)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.string_thing (1) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1:string_thing: ", p), err)
		}
	}
	return err
}

func (p *Xtruct3) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetChanged() {
		if err := oprot.WriteFieldBegin("changed", thrift.I32, 4); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:changed: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.Changed)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.changed (4) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 4:changed: ", p), err)
		}
	}
	return err
}

func (p *Xtruct3) writeField9(oprot thrift.TProtocol) (err error) {
	if p.IsSetI32Thing() {
		if err := oprot.WriteFieldBegin("i32_thing", thrift.I32, 9); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 9:i32_thing: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.I32Thing)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.i32_thing (9) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 9:i32_thing: ", p), err)
		}
	}
	return err
}

func (p *Xtruct3) writeField11(oprot thrift.TProtocol) (err error) {
	if p.IsSetI64Thing() {
		if err := oprot.WriteFieldBegin("i64_thing", thrift.I64, 11); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 11:i64_thing: ", p), err)
		}
		if err := oprot.WriteI64(int64(*p.I64Thing)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.i64_thing (11) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 11:i64_thing: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - UserMap
//  - Xtructs
type Insanity struct {
	UserMap map[Numberz]UserId `thrift:"userMap,1" json:"userMap,omitempty"`
	Xtructs []*Xtruct          `thrift:"xtructs,2" json:"xtructs,omitempty"`
}

func NewInsanity() *Insanity {
	return &Insanity{}
}

var Insanity_UserMap_DEFAULT map[Numberz]UserId

func (p *Insanity) GetUserMap() map[Numberz]UserId {
	return p.UserMap
}

var Insanity_Xtructs_DEFAULT []*Xtruct

func (p *Insanity) GetXtructs() []*Xtruct {
	return p.Xtructs
}
func (p *Insanity) IsSetUserMap() bool {
	return p.UserMap != nil
}

func (p *Insanity) IsSetXtructs() bool {
	return p.Xtructs != nil
}

func (p *Insanity) 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
			}
		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 *Insanity) readField1(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(map[Numberz]UserId, size)
	p.UserMap = tMap
	for i := 0; i < size; i++ {
		var _key0 Numberz
		if v, err := iprot.ReadI32(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			temp := Numberz(v)
			_key0 = temp
		}
		var _val1 UserId
		if v, err := iprot.ReadI64(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			temp := UserId(v)
			_val1 = temp
		}
		p.UserMap[_key0] = _val1
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

func (p *Insanity) readField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]*Xtruct, 0, size)
	p.Xtructs = tSlice
	for i := 0; i < size; i++ {
		_elem2 := &Xtruct{}
		if err := _elem2.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem2), err)
		}
		p.Xtructs = append(p.Xtructs, _elem2)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *Insanity) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("Insanity"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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 *Insanity) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetUserMap() {
		if err := oprot.WriteFieldBegin("userMap", thrift.MAP, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:userMap: ", p), err)
		}
		if err := oprot.WriteMapBegin(thrift.I32, thrift.I64, len(p.UserMap)); err != nil {
			return thrift.PrependError("error writing map begin: ", err)
		}
		for k, v := range p.UserMap {
			if err := oprot.WriteI32(int32(k)); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
			}
			if err := oprot.WriteI64(int64(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 1:userMap: ", p), err)
		}
	}
	return err
}

func (p *Insanity) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetXtructs() {
		if err := oprot.WriteFieldBegin("xtructs", thrift.LIST, 2); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:xtructs: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Xtructs)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.Xtructs {
			if err := v.Write(oprot); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), 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:xtructs: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - StringField
//  - SetField
//  - BinaryField
type CrazyNesting struct {
	StringField *string            `thrift:"string_field,1" json:"string_field,omitempty"`
	SetField    map[*Insanity]bool `thrift:"set_field,2" json:"set_field,omitempty"`
	// unused field # 3
	BinaryField []byte `thrift:"binary_field,4" json:"binary_field,omitempty"`
}

func NewCrazyNesting() *CrazyNesting {
	return &CrazyNesting{}
}

var CrazyNesting_StringField_DEFAULT string

func (p *CrazyNesting) GetStringField() string {
	if !p.IsSetStringField() {
		return CrazyNesting_StringField_DEFAULT
	}
	return *p.StringField
}

var CrazyNesting_SetField_DEFAULT map[*Insanity]bool

func (p *CrazyNesting) GetSetField() map[*Insanity]bool {
	return p.SetField
}

var CrazyNesting_BinaryField_DEFAULT []byte

func (p *CrazyNesting) GetBinaryField() []byte {
	return p.BinaryField
}
func (p *CrazyNesting) IsSetStringField() bool {
	return p.StringField != nil
}

func (p *CrazyNesting) IsSetSetField() bool {
	return p.SetField != nil
}

func (p *CrazyNesting) IsSetBinaryField() bool {
	return p.BinaryField != nil
}

func (p *CrazyNesting) 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 4:
			if err := p.readField4(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 *CrazyNesting) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.StringField = &v
	}
	return nil
}

func (p *CrazyNesting) readField2(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadSetBegin()
	if err != nil {
		return thrift.PrependError("error reading set begin: ", err)
	}
	tSet := make(map[*Insanity]bool, size)
	p.SetField = tSet
	for i := 0; i < size; i++ {
		_elem3 := &Insanity{}
		if err := _elem3.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem3), err)
		}
		p.SetField[_elem3] = true
	}
	if err := iprot.ReadSetEnd(); err != nil {
		return thrift.PrependError("error reading set end: ", err)
	}
	return nil
}

func (p *CrazyNesting) readField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBinary(); err != nil {
		return thrift.PrependError("error reading field 4: ", err)
	} else {
		p.BinaryField = v
	}
	return nil
}

func (p *CrazyNesting) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("CrazyNesting"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField2(oprot); err != nil {
		return err
	}
	if err := p.writeField4(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 *CrazyNesting) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetStringField() {
		if err := oprot.WriteFieldBegin("string_field", thrift.STRING, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:string_field: ", p), err)
		}
		if err := oprot.WriteString(string(*p.StringField)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.string_field (1) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1:string_field: ", p), err)
		}
	}
	return err
}

func (p *CrazyNesting) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetSetField() {
		if err := oprot.WriteFieldBegin("set_field", thrift.SET, 2); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:set_field: ", p), err)
		}
		if err := oprot.WriteSetBegin(thrift.STRUCT, len(p.SetField)); err != nil {
			return thrift.PrependError("error writing set begin: ", err)
		}
		for v, _ := range p.SetField {
			if err := v.Write(oprot); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
			}
		}
		if err := oprot.WriteSetEnd(); err != nil {
			return thrift.PrependError("error writing set end: ", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 2:set_field: ", p), err)
		}
	}
	return err
}

func (p *CrazyNesting) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetBinaryField() {
		if err := oprot.WriteFieldBegin("binary_field", thrift.STRING, 4); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:binary_field: ", p), err)
		}
		if err := oprot.WriteBinary(p.BinaryField); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.binary_field (4) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 4:binary_field: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - ErrorCode
//  - Message
type Xception struct {
	ErrorCode *int32  `thrift:"errorCode,1" json:"errorCode,omitempty"`
	Message   *string `thrift:"message,2" json:"message,omitempty"`
}

func NewXception() *Xception {
	return &Xception{}
}

var Xception_ErrorCode_DEFAULT int32

func (p *Xception) GetErrorCode() int32 {
	if !p.IsSetErrorCode() {
		return Xception_ErrorCode_DEFAULT
	}
	return *p.ErrorCode
}

var Xception_Message_DEFAULT string

func (p *Xception) GetMessage() string {
	if !p.IsSetMessage() {
		return Xception_Message_DEFAULT
	}
	return *p.Message
}
func (p *Xception) IsSetErrorCode() bool {
	return p.ErrorCode != nil
}

func (p *Xception) IsSetMessage() bool {
	return p.Message != nil
}

func (p *Xception) 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
			}
		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 *Xception) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.ErrorCode = &v
	}
	return nil
}

func (p *Xception) readField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.Message = &v
	}
	return nil
}

func (p *Xception) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("Xception"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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 *Xception) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetErrorCode() {
		if err := oprot.WriteFieldBegin("errorCode", thrift.I32, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:errorCode: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.ErrorCode)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.errorCode (1) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1:errorCode: ", p), err)
		}
	}
	return err
}

func (p *Xception) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetMessage() {
		if err := oprot.WriteFieldBegin("message", thrift.STRING, 2); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:message: ", p), err)
		}
		if err := oprot.WriteString(string(*p.Message)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.message (2) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 2:message: ", p), err)
		}
	}
	return err
}

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

func (p *Xception) Error() string {
	return p.String()
}

// Attributes:
//  - ErrorCode
//  - StructThing
type Xception2 struct {
	ErrorCode   *int32  `thrift:"errorCode,1" json:"errorCode,omitempty"`
	StructThing *Xtruct `thrift:"struct_thing,2" json:"struct_thing,omitempty"`
}

func NewXception2() *Xception2 {
	return &Xception2{}
}

var Xception2_ErrorCode_DEFAULT int32

func (p *Xception2) GetErrorCode() int32 {
	if !p.IsSetErrorCode() {
		return Xception2_ErrorCode_DEFAULT
	}
	return *p.ErrorCode
}

var Xception2_StructThing_DEFAULT *Xtruct

func (p *Xception2) GetStructThing() *Xtruct {
	if !p.IsSetStructThing() {
		return Xception2_StructThing_DEFAULT
	}
	return p.StructThing
}
func (p *Xception2) IsSetErrorCode() bool {
	return p.ErrorCode != nil
}

func (p *Xception2) IsSetStructThing() bool {
	return p.StructThing != nil
}

func (p *Xception2) 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
			}
		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 *Xception2) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.ErrorCode = &v
	}
	return nil
}

func (p *Xception2) readField2(iprot thrift.TProtocol) error {
	p.StructThing = &Xtruct{}
	if err := p.StructThing.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.StructThing), err)
	}
	return nil
}

func (p *Xception2) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("Xception2"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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 *Xception2) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetErrorCode() {
		if err := oprot.WriteFieldBegin("errorCode", thrift.I32, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:errorCode: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.ErrorCode)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.errorCode (1) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1:errorCode: ", p), err)
		}
	}
	return err
}

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

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

func (p *Xception2) Error() string {
	return p.String()
}

type EmptyStruct struct {
}

func NewEmptyStruct() *EmptyStruct {
	return &EmptyStruct{}
}

func (p *EmptyStruct) 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 *EmptyStruct) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("EmptyStruct"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), 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 *EmptyStruct) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("EmptyStruct(%+v)", *p)
}

// Attributes:
//  - Field
type OneField struct {
	Field *EmptyStruct `thrift:"field,1" json:"field,omitempty"`
}

func NewOneField() *OneField {
	return &OneField{}
}

var OneField_Field_DEFAULT *EmptyStruct

func (p *OneField) GetField() *EmptyStruct {
	if !p.IsSetField() {
		return OneField_Field_DEFAULT
	}
	return p.Field
}
func (p *OneField) IsSetField() bool {
	return p.Field != nil
}

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

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

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

// Attributes:
//  - BeginInBoth
//  - OldString
//  - EndInBoth
type VersioningTestV1 struct {
	BeginInBoth *int32 `thrift:"begin_in_both,1" json:"begin_in_both,omitempty"`
	// unused field # 2
	OldString *string `thrift:"old_string,3" json:"old_string,omitempty"`
	// unused fields # 4 to 11
	EndInBoth *int32 `thrift:"end_in_both,12" json:"end_in_both,omitempty"`
}

func NewVersioningTestV1() *VersioningTestV1 {
	return &VersioningTestV1{}
}

var VersioningTestV1_BeginInBoth_DEFAULT int32

func (p *VersioningTestV1) GetBeginInBoth() int32 {
	if !p.IsSetBeginInBoth() {
		return VersioningTestV1_BeginInBoth_DEFAULT
	}
	return *p.BeginInBoth
}

var VersioningTestV1_OldString_DEFAULT string

func (p *VersioningTestV1) GetOldString() string {
	if !p.IsSetOldString() {
		return VersioningTestV1_OldString_DEFAULT
	}
	return *p.OldString
}

var VersioningTestV1_EndInBoth_DEFAULT int32

func (p *VersioningTestV1) GetEndInBoth() int32 {
	if !p.IsSetEndInBoth() {
		return VersioningTestV1_EndInBoth_DEFAULT
	}
	return *p.EndInBoth
}
func (p *VersioningTestV1) IsSetBeginInBoth() bool {
	return p.BeginInBoth != nil
}

func (p *VersioningTestV1) IsSetOldString() bool {
	return p.OldString != nil
}

func (p *VersioningTestV1) IsSetEndInBoth() bool {
	return p.EndInBoth != nil
}

func (p *VersioningTestV1) 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 3:
			if err := p.readField3(iprot); err != nil {
				return err
			}
		case 12:
			if err := p.readField12(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 *VersioningTestV1) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.BeginInBoth = &v
	}
	return nil
}

func (p *VersioningTestV1) readField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		p.OldString = &v
	}
	return nil
}

func (p *VersioningTestV1) readField12(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 12: ", err)
	} else {
		p.EndInBoth = &v
	}
	return nil
}

func (p *VersioningTestV1) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("VersioningTestV1"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField3(oprot); err != nil {
		return err
	}
	if err := p.writeField12(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 *VersioningTestV1) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetBeginInBoth() {
		if err := oprot.WriteFieldBegin("begin_in_both", thrift.I32, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:begin_in_both: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.BeginInBoth)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.begin_in_both (1) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1:begin_in_both: ", p), err)
		}
	}
	return err
}

func (p *VersioningTestV1) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetOldString() {
		if err := oprot.WriteFieldBegin("old_string", thrift.STRING, 3); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:old_string: ", p), err)
		}
		if err := oprot.WriteString(string(*p.OldString)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.old_string (3) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 3:old_string: ", p), err)
		}
	}
	return err
}

func (p *VersioningTestV1) writeField12(oprot thrift.TProtocol) (err error) {
	if p.IsSetEndInBoth() {
		if err := oprot.WriteFieldBegin("end_in_both", thrift.I32, 12); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 12:end_in_both: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.EndInBoth)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.end_in_both (12) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 12:end_in_both: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - BeginInBoth
//  - Newint_
//  - Newbyte_
//  - Newshort_
//  - Newlong_
//  - Newdouble_
//  - Newstruct_
//  - Newlist_
//  - Newset_
//  - Newmap_
//  - Newstring_
//  - EndInBoth
type VersioningTestV2 struct {
	BeginInBoth *int32          `thrift:"begin_in_both,1" json:"begin_in_both,omitempty"`
	Newint_     *int32          `thrift:"newint,2" json:"newint,omitempty"`
	Newbyte_    *int8           `thrift:"newbyte,3" json:"newbyte,omitempty"`
	Newshort_   *int16          `thrift:"newshort,4" json:"newshort,omitempty"`
	Newlong_    *int64          `thrift:"newlong,5" json:"newlong,omitempty"`
	Newdouble_  *float64        `thrift:"newdouble,6" json:"newdouble,omitempty"`
	Newstruct_  *Bonk           `thrift:"newstruct,7" json:"newstruct,omitempty"`
	Newlist_    []int32         `thrift:"newlist,8" json:"newlist,omitempty"`
	Newset_     map[int32]bool  `thrift:"newset,9" json:"newset,omitempty"`
	Newmap_     map[int32]int32 `thrift:"newmap,10" json:"newmap,omitempty"`
	Newstring_  *string         `thrift:"newstring,11" json:"newstring,omitempty"`
	EndInBoth   *int32          `thrift:"end_in_both,12" json:"end_in_both,omitempty"`
}

func NewVersioningTestV2() *VersioningTestV2 {
	return &VersioningTestV2{}
}

var VersioningTestV2_BeginInBoth_DEFAULT int32

func (p *VersioningTestV2) GetBeginInBoth() int32 {
	if !p.IsSetBeginInBoth() {
		return VersioningTestV2_BeginInBoth_DEFAULT
	}
	return *p.BeginInBoth
}

var VersioningTestV2_Newint__DEFAULT int32

func (p *VersioningTestV2) GetNewint_() int32 {
	if !p.IsSetNewint_() {
		return VersioningTestV2_Newint__DEFAULT
	}
	return *p.Newint_
}

var VersioningTestV2_Newbyte__DEFAULT int8

func (p *VersioningTestV2) GetNewbyte_() int8 {
	if !p.IsSetNewbyte_() {
		return VersioningTestV2_Newbyte__DEFAULT
	}
	return *p.Newbyte_
}

var VersioningTestV2_Newshort__DEFAULT int16

func (p *VersioningTestV2) GetNewshort_() int16 {
	if !p.IsSetNewshort_() {
		return VersioningTestV2_Newshort__DEFAULT
	}
	return *p.Newshort_
}

var VersioningTestV2_Newlong__DEFAULT int64

func (p *VersioningTestV2) GetNewlong_() int64 {
	if !p.IsSetNewlong_() {
		return VersioningTestV2_Newlong__DEFAULT
	}
	return *p.Newlong_
}

var VersioningTestV2_Newdouble__DEFAULT float64

func (p *VersioningTestV2) GetNewdouble_() float64 {
	if !p.IsSetNewdouble_() {
		return VersioningTestV2_Newdouble__DEFAULT
	}
	return *p.Newdouble_
}

var VersioningTestV2_Newstruct__DEFAULT *Bonk

func (p *VersioningTestV2) GetNewstruct_() *Bonk {
	if !p.IsSetNewstruct_() {
		return VersioningTestV2_Newstruct__DEFAULT
	}
	return p.Newstruct_
}

var VersioningTestV2_Newlist__DEFAULT []int32

func (p *VersioningTestV2) GetNewlist_() []int32 {
	return p.Newlist_
}

var VersioningTestV2_Newset__DEFAULT map[int32]bool

func (p *VersioningTestV2) GetNewset_() map[int32]bool {
	return p.Newset_
}

var VersioningTestV2_Newmap__DEFAULT map[int32]int32

func (p *VersioningTestV2) GetNewmap_() map[int32]int32 {
	return p.Newmap_
}

var VersioningTestV2_Newstring__DEFAULT string

func (p *VersioningTestV2) GetNewstring_() string {
	if !p.IsSetNewstring_() {
		return VersioningTestV2_Newstring__DEFAULT
	}
	return *p.Newstring_
}

var VersioningTestV2_EndInBoth_DEFAULT int32

func (p *VersioningTestV2) GetEndInBoth() int32 {
	if !p.IsSetEndInBoth() {
		return VersioningTestV2_EndInBoth_DEFAULT
	}
	return *p.EndInBoth
}
func (p *VersioningTestV2) IsSetBeginInBoth() bool {
	return p.BeginInBoth != nil
}

func (p *VersioningTestV2) IsSetNewint_() bool {
	return p.Newint_ != nil
}

func (p *VersioningTestV2) IsSetNewbyte_() bool {
	return p.Newbyte_ != nil
}

func (p *VersioningTestV2) IsSetNewshort_() bool {
	return p.Newshort_ != nil
}

func (p *VersioningTestV2) IsSetNewlong_() bool {
	return p.Newlong_ != nil
}

func (p *VersioningTestV2) IsSetNewdouble_() bool {
	return p.Newdouble_ != nil
}

func (p *VersioningTestV2) IsSetNewstruct_() bool {
	return p.Newstruct_ != nil
}

func (p *VersioningTestV2) IsSetNewlist_() bool {
	return p.Newlist_ != nil
}

func (p *VersioningTestV2) IsSetNewset_() bool {
	return p.Newset_ != nil
}

func (p *VersioningTestV2) IsSetNewmap_() bool {
	return p.Newmap_ != nil
}

func (p *VersioningTestV2) IsSetNewstring_() bool {
	return p.Newstring_ != nil
}

func (p *VersioningTestV2) IsSetEndInBoth() bool {
	return p.EndInBoth != nil
}

func (p *VersioningTestV2) 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 8:
			if err := p.readField8(iprot); err != nil {
				return err
			}
		case 9:
			if err := p.readField9(iprot); err != nil {
				return err
			}
		case 10:
			if err := p.readField10(iprot); err != nil {
				return err
			}
		case 11:
			if err := p.readField11(iprot); err != nil {
				return err
			}
		case 12:
			if err := p.readField12(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 *VersioningTestV2) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.BeginInBoth = &v
	}
	return nil
}

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

func (p *VersioningTestV2) readField3(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadByte(); err != nil {
		return thrift.PrependError("error reading field 3: ", err)
	} else {
		temp := int8(v)
		p.Newbyte_ = &temp
	}
	return nil
}

func (p *VersioningTestV2) readField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI16(); err != nil {
		return thrift.PrependError("error reading field 4: ", err)
	} else {
		p.Newshort_ = &v
	}
	return nil
}

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

func (p *VersioningTestV2) readField6(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadDouble(); err != nil {
		return thrift.PrependError("error reading field 6: ", err)
	} else {
		p.Newdouble_ = &v
	}
	return nil
}

func (p *VersioningTestV2) readField7(iprot thrift.TProtocol) error {
	p.Newstruct_ = &Bonk{}
	if err := p.Newstruct_.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Newstruct_), err)
	}
	return nil
}

func (p *VersioningTestV2) readField8(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]int32, 0, size)
	p.Newlist_ = tSlice
	for i := 0; i < size; i++ {
		var _elem4 int32
		if v, err := iprot.ReadI32(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_elem4 = v
		}
		p.Newlist_ = append(p.Newlist_, _elem4)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *VersioningTestV2) readField9(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadSetBegin()
	if err != nil {
		return thrift.PrependError("error reading set begin: ", err)
	}
	tSet := make(map[int32]bool, size)
	p.Newset_ = tSet
	for i := 0; i < size; i++ {
		var _elem5 int32
		if v, err := iprot.ReadI32(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_elem5 = v
		}
		p.Newset_[_elem5] = true
	}
	if err := iprot.ReadSetEnd(); err != nil {
		return thrift.PrependError("error reading set end: ", err)
	}
	return nil
}

func (p *VersioningTestV2) readField10(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(map[int32]int32, size)
	p.Newmap_ = tMap
	for i := 0; i < size; i++ {
		var _key6 int32
		if v, err := iprot.ReadI32(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_key6 = v
		}
		var _val7 int32
		if v, err := iprot.ReadI32(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_val7 = v
		}
		p.Newmap_[_key6] = _val7
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

func (p *VersioningTestV2) readField11(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 11: ", err)
	} else {
		p.Newstring_ = &v
	}
	return nil
}

func (p *VersioningTestV2) readField12(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 12: ", err)
	} else {
		p.EndInBoth = &v
	}
	return nil
}

func (p *VersioningTestV2) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("VersioningTestV2"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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.writeField8(oprot); err != nil {
		return err
	}
	if err := p.writeField9(oprot); err != nil {
		return err
	}
	if err := p.writeField10(oprot); err != nil {
		return err
	}
	if err := p.writeField11(oprot); err != nil {
		return err
	}
	if err := p.writeField12(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 *VersioningTestV2) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetBeginInBoth() {
		if err := oprot.WriteFieldBegin("begin_in_both", thrift.I32, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:begin_in_both: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.BeginInBoth)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.begin_in_both (1) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1:begin_in_both: ", p), err)
		}
	}
	return err
}

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

func (p *VersioningTestV2) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetNewbyte_() {
		if err := oprot.WriteFieldBegin("newbyte", thrift.BYTE, 3); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:newbyte: ", p), err)
		}
		if err := oprot.WriteByte(int8(*p.Newbyte_)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.newbyte (3) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 3:newbyte: ", p), err)
		}
	}
	return err
}

func (p *VersioningTestV2) writeField4(oprot thrift.TProtocol) (err error) {
	if p.IsSetNewshort_() {
		if err := oprot.WriteFieldBegin("newshort", thrift.I16, 4); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:newshort: ", p), err)
		}
		if err := oprot.WriteI16(int16(*p.Newshort_)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.newshort (4) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 4:newshort: ", p), err)
		}
	}
	return err
}

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

func (p *VersioningTestV2) writeField6(oprot thrift.TProtocol) (err error) {
	if p.IsSetNewdouble_() {
		if err := oprot.WriteFieldBegin("newdouble", thrift.DOUBLE, 6); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:newdouble: ", p), err)
		}
		if err := oprot.WriteDouble(float64(*p.Newdouble_)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.newdouble (6) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 6:newdouble: ", p), err)
		}
	}
	return err
}

func (p *VersioningTestV2) writeField7(oprot thrift.TProtocol) (err error) {
	if p.IsSetNewstruct_() {
		if err := oprot.WriteFieldBegin("newstruct", thrift.STRUCT, 7); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:newstruct: ", p), err)
		}
		if err := p.Newstruct_.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Newstruct_), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 7:newstruct: ", p), err)
		}
	}
	return err
}

func (p *VersioningTestV2) writeField8(oprot thrift.TProtocol) (err error) {
	if p.IsSetNewlist_() {
		if err := oprot.WriteFieldBegin("newlist", thrift.LIST, 8); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 8:newlist: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.I32, len(p.Newlist_)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.Newlist_ {
			if err := oprot.WriteI32(int32(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 8:newlist: ", p), err)
		}
	}
	return err
}

func (p *VersioningTestV2) writeField9(oprot thrift.TProtocol) (err error) {
	if p.IsSetNewset_() {
		if err := oprot.WriteFieldBegin("newset", thrift.SET, 9); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 9:newset: ", p), err)
		}
		if err := oprot.WriteSetBegin(thrift.I32, len(p.Newset_)); err != nil {
			return thrift.PrependError("error writing set begin: ", err)
		}
		for v, _ := range p.Newset_ {
			if err := oprot.WriteI32(int32(v)); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
			}
		}
		if err := oprot.WriteSetEnd(); err != nil {
			return thrift.PrependError("error writing set end: ", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 9:newset: ", p), err)
		}
	}
	return err
}

func (p *VersioningTestV2) writeField10(oprot thrift.TProtocol) (err error) {
	if p.IsSetNewmap_() {
		if err := oprot.WriteFieldBegin("newmap", thrift.MAP, 10); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 10:newmap: ", p), err)
		}
		if err := oprot.WriteMapBegin(thrift.I32, thrift.I32, len(p.Newmap_)); err != nil {
			return thrift.PrependError("error writing map begin: ", err)
		}
		for k, v := range p.Newmap_ {
			if err := oprot.WriteI32(int32(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 10:newmap: ", p), err)
		}
	}
	return err
}

func (p *VersioningTestV2) writeField11(oprot thrift.TProtocol) (err error) {
	if p.IsSetNewstring_() {
		if err := oprot.WriteFieldBegin("newstring", thrift.STRING, 11); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 11:newstring: ", p), err)
		}
		if err := oprot.WriteString(string(*p.Newstring_)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.newstring (11) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 11:newstring: ", p), err)
		}
	}
	return err
}

func (p *VersioningTestV2) writeField12(oprot thrift.TProtocol) (err error) {
	if p.IsSetEndInBoth() {
		if err := oprot.WriteFieldBegin("end_in_both", thrift.I32, 12); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 12:end_in_both: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.EndInBoth)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.end_in_both (12) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 12:end_in_both: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Myints
//  - Hello
type ListTypeVersioningV1 struct {
	Myints []int32 `thrift:"myints,1" json:"myints,omitempty"`
	Hello  *string `thrift:"hello,2" json:"hello,omitempty"`
}

func NewListTypeVersioningV1() *ListTypeVersioningV1 {
	return &ListTypeVersioningV1{}
}

var ListTypeVersioningV1_Myints_DEFAULT []int32

func (p *ListTypeVersioningV1) GetMyints() []int32 {
	return p.Myints
}

var ListTypeVersioningV1_Hello_DEFAULT string

func (p *ListTypeVersioningV1) GetHello() string {
	if !p.IsSetHello() {
		return ListTypeVersioningV1_Hello_DEFAULT
	}
	return *p.Hello
}
func (p *ListTypeVersioningV1) IsSetMyints() bool {
	return p.Myints != nil
}

func (p *ListTypeVersioningV1) IsSetHello() bool {
	return p.Hello != nil
}

func (p *ListTypeVersioningV1) 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
			}
		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 *ListTypeVersioningV1) readField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]int32, 0, size)
	p.Myints = tSlice
	for i := 0; i < size; i++ {
		var _elem8 int32
		if v, err := iprot.ReadI32(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_elem8 = v
		}
		p.Myints = append(p.Myints, _elem8)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ListTypeVersioningV1) readField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.Hello = &v
	}
	return nil
}

func (p *ListTypeVersioningV1) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("ListTypeVersioningV1"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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 *ListTypeVersioningV1) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetMyints() {
		if err := oprot.WriteFieldBegin("myints", thrift.LIST, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:myints: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.I32, len(p.Myints)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.Myints {
			if err := oprot.WriteI32(int32(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:myints: ", p), err)
		}
	}
	return err
}

func (p *ListTypeVersioningV1) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetHello() {
		if err := oprot.WriteFieldBegin("hello", thrift.STRING, 2); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:hello: ", p), err)
		}
		if err := oprot.WriteString(string(*p.Hello)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.hello (2) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 2:hello: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Strings
//  - Hello
type ListTypeVersioningV2 struct {
	Strings []string `thrift:"strings,1" json:"strings,omitempty"`
	Hello   *string  `thrift:"hello,2" json:"hello,omitempty"`
}

func NewListTypeVersioningV2() *ListTypeVersioningV2 {
	return &ListTypeVersioningV2{}
}

var ListTypeVersioningV2_Strings_DEFAULT []string

func (p *ListTypeVersioningV2) GetStrings() []string {
	return p.Strings
}

var ListTypeVersioningV2_Hello_DEFAULT string

func (p *ListTypeVersioningV2) GetHello() string {
	if !p.IsSetHello() {
		return ListTypeVersioningV2_Hello_DEFAULT
	}
	return *p.Hello
}
func (p *ListTypeVersioningV2) IsSetStrings() bool {
	return p.Strings != nil
}

func (p *ListTypeVersioningV2) IsSetHello() bool {
	return p.Hello != nil
}

func (p *ListTypeVersioningV2) 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
			}
		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 *ListTypeVersioningV2) readField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]string, 0, size)
	p.Strings = tSlice
	for i := 0; i < size; i++ {
		var _elem9 string
		if v, err := iprot.ReadString(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_elem9 = v
		}
		p.Strings = append(p.Strings, _elem9)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ListTypeVersioningV2) readField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.Hello = &v
	}
	return nil
}

func (p *ListTypeVersioningV2) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("ListTypeVersioningV2"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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 *ListTypeVersioningV2) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetStrings() {
		if err := oprot.WriteFieldBegin("strings", thrift.LIST, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:strings: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.STRING, len(p.Strings)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.Strings {
			if err := oprot.WriteString(string(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:strings: ", p), err)
		}
	}
	return err
}

func (p *ListTypeVersioningV2) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetHello() {
		if err := oprot.WriteFieldBegin("hello", thrift.STRING, 2); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:hello: ", p), err)
		}
		if err := oprot.WriteString(string(*p.Hello)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.hello (2) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 2:hello: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - MapField
type GuessProtocolStruct struct {
	// unused fields # 1 to 6
	MapField map[string]string `thrift:"map_field,7" json:"map_field,omitempty"`
}

func NewGuessProtocolStruct() *GuessProtocolStruct {
	return &GuessProtocolStruct{}
}

var GuessProtocolStruct_MapField_DEFAULT map[string]string

func (p *GuessProtocolStruct) GetMapField() map[string]string {
	return p.MapField
}
func (p *GuessProtocolStruct) IsSetMapField() bool {
	return p.MapField != nil
}

func (p *GuessProtocolStruct) 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 7:
			if err := p.readField7(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 *GuessProtocolStruct) readField7(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(map[string]string, size)
	p.MapField = tMap
	for i := 0; i < size; i++ {
		var _key10 string
		if v, err := iprot.ReadString(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_key10 = v
		}
		var _val11 string
		if v, err := iprot.ReadString(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_val11 = v
		}
		p.MapField[_key10] = _val11
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

func (p *GuessProtocolStruct) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("GuessProtocolStruct"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if err := p.writeField7(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 *GuessProtocolStruct) writeField7(oprot thrift.TProtocol) (err error) {
	if p.IsSetMapField() {
		if err := oprot.WriteFieldBegin("map_field", thrift.MAP, 7); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:map_field: ", p), err)
		}
		if err := oprot.WriteMapBegin(thrift.STRING, thrift.STRING, len(p.MapField)); err != nil {
			return thrift.PrependError("error writing map begin: ", err)
		}
		for k, v := range p.MapField {
			if err := oprot.WriteString(string(k)); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
			}
			if err := oprot.WriteString(string(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 7:map_field: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - B1
//  - B10
//  - B100
//  - CheckTrue
//  - B1000
//  - CheckFalse
//  - Vertwo2000
//  - ASet2500
//  - Vertwo3000
//  - BigNumbers
type LargeDeltas struct {
	B1 *Bools `thrift:"b1,1" json:"b1,omitempty"`
	// unused fields # 2 to 9
	B10 *Bools `thrift:"b10,10" json:"b10,omitempty"`
	// unused fields # 11 to 99
	B100 *Bools `thrift:"b100,100" json:"b100,omitempty"`
	// unused fields # 101 to 499
	CheckTrue *bool `thrift:"check_true,500" json:"check_true,omitempty"`
	// unused fields # 501 to 999
	B1000 *Bools `thrift:"b1000,1000" json:"b1000,omitempty"`
	// unused fields # 1001 to 1499
	CheckFalse *bool `thrift:"check_false,1500" json:"check_false,omitempty"`
	// unused fields # 1501 to 1999
	Vertwo2000 *VersioningTestV2 `thrift:"vertwo2000,2000" json:"vertwo2000,omitempty"`
	// unused fields # 2001 to 2499
	ASet2500 map[string]bool `thrift:"a_set2500,2500" json:"a_set2500,omitempty"`
	// unused fields # 2501 to 2999
	Vertwo3000 *VersioningTestV2 `thrift:"vertwo3000,3000" json:"vertwo3000,omitempty"`
	// unused fields # 3001 to 3999
	BigNumbers []int32 `thrift:"big_numbers,4000" json:"big_numbers,omitempty"`
}

func NewLargeDeltas() *LargeDeltas {
	return &LargeDeltas{}
}

var LargeDeltas_B1_DEFAULT *Bools

func (p *LargeDeltas) GetB1() *Bools {
	if !p.IsSetB1() {
		return LargeDeltas_B1_DEFAULT
	}
	return p.B1
}

var LargeDeltas_B10_DEFAULT *Bools

func (p *LargeDeltas) GetB10() *Bools {
	if !p.IsSetB10() {
		return LargeDeltas_B10_DEFAULT
	}
	return p.B10
}

var LargeDeltas_B100_DEFAULT *Bools

func (p *LargeDeltas) GetB100() *Bools {
	if !p.IsSetB100() {
		return LargeDeltas_B100_DEFAULT
	}
	return p.B100
}

var LargeDeltas_CheckTrue_DEFAULT bool

func (p *LargeDeltas) GetCheckTrue() bool {
	if !p.IsSetCheckTrue() {
		return LargeDeltas_CheckTrue_DEFAULT
	}
	return *p.CheckTrue
}

var LargeDeltas_B1000_DEFAULT *Bools

func (p *LargeDeltas) GetB1000() *Bools {
	if !p.IsSetB1000() {
		return LargeDeltas_B1000_DEFAULT
	}
	return p.B1000
}

var LargeDeltas_CheckFalse_DEFAULT bool

func (p *LargeDeltas) GetCheckFalse() bool {
	if !p.IsSetCheckFalse() {
		return LargeDeltas_CheckFalse_DEFAULT
	}
	return *p.CheckFalse
}

var LargeDeltas_Vertwo2000_DEFAULT *VersioningTestV2

func (p *LargeDeltas) GetVertwo2000() *VersioningTestV2 {
	if !p.IsSetVertwo2000() {
		return LargeDeltas_Vertwo2000_DEFAULT
	}
	return p.Vertwo2000
}

var LargeDeltas_ASet2500_DEFAULT map[string]bool

func (p *LargeDeltas) GetASet2500() map[string]bool {
	return p.ASet2500
}

var LargeDeltas_Vertwo3000_DEFAULT *VersioningTestV2

func (p *LargeDeltas) GetVertwo3000() *VersioningTestV2 {
	if !p.IsSetVertwo3000() {
		return LargeDeltas_Vertwo3000_DEFAULT
	}
	return p.Vertwo3000
}

var LargeDeltas_BigNumbers_DEFAULT []int32

func (p *LargeDeltas) GetBigNumbers() []int32 {
	return p.BigNumbers
}
func (p *LargeDeltas) IsSetB1() bool {
	return p.B1 != nil
}

func (p *LargeDeltas) IsSetB10() bool {
	return p.B10 != nil
}

func (p *LargeDeltas) IsSetB100() bool {
	return p.B100 != nil
}

func (p *LargeDeltas) IsSetCheckTrue() bool {
	return p.CheckTrue != nil
}

func (p *LargeDeltas) IsSetB1000() bool {
	return p.B1000 != nil
}

func (p *LargeDeltas) IsSetCheckFalse() bool {
	return p.CheckFalse != nil
}

func (p *LargeDeltas) IsSetVertwo2000() bool {
	return p.Vertwo2000 != nil
}

func (p *LargeDeltas) IsSetASet2500() bool {
	return p.ASet2500 != nil
}

func (p *LargeDeltas) IsSetVertwo3000() bool {
	return p.Vertwo3000 != nil
}

func (p *LargeDeltas) IsSetBigNumbers() bool {
	return p.BigNumbers != nil
}

func (p *LargeDeltas) 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 10:
			if err := p.readField10(iprot); err != nil {
				return err
			}
		case 100:
			if err := p.readField100(iprot); err != nil {
				return err
			}
		case 500:
			if err := p.readField500(iprot); err != nil {
				return err
			}
		case 1000:
			if err := p.readField1000(iprot); err != nil {
				return err
			}
		case 1500:
			if err := p.readField1500(iprot); err != nil {
				return err
			}
		case 2000:
			if err := p.readField2000(iprot); err != nil {
				return err
			}
		case 2500:
			if err := p.readField2500(iprot); err != nil {
				return err
			}
		case 3000:
			if err := p.readField3000(iprot); err != nil {
				return err
			}
		case 4000:
			if err := p.readField4000(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 *LargeDeltas) readField1(iprot thrift.TProtocol) error {
	p.B1 = &Bools{}
	if err := p.B1.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.B1), err)
	}
	return nil
}

func (p *LargeDeltas) readField10(iprot thrift.TProtocol) error {
	p.B10 = &Bools{}
	if err := p.B10.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.B10), err)
	}
	return nil
}

func (p *LargeDeltas) readField100(iprot thrift.TProtocol) error {
	p.B100 = &Bools{}
	if err := p.B100.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.B100), err)
	}
	return nil
}

func (p *LargeDeltas) readField500(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 500: ", err)
	} else {
		p.CheckTrue = &v
	}
	return nil
}

func (p *LargeDeltas) readField1000(iprot thrift.TProtocol) error {
	p.B1000 = &Bools{}
	if err := p.B1000.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.B1000), err)
	}
	return nil
}

func (p *LargeDeltas) readField1500(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 1500: ", err)
	} else {
		p.CheckFalse = &v
	}
	return nil
}

func (p *LargeDeltas) readField2000(iprot thrift.TProtocol) error {
	p.Vertwo2000 = &VersioningTestV2{}
	if err := p.Vertwo2000.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Vertwo2000), err)
	}
	return nil
}

func (p *LargeDeltas) readField2500(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadSetBegin()
	if err != nil {
		return thrift.PrependError("error reading set begin: ", err)
	}
	tSet := make(map[string]bool, size)
	p.ASet2500 = tSet
	for i := 0; i < size; i++ {
		var _elem12 string
		if v, err := iprot.ReadString(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_elem12 = v
		}
		p.ASet2500[_elem12] = true
	}
	if err := iprot.ReadSetEnd(); err != nil {
		return thrift.PrependError("error reading set end: ", err)
	}
	return nil
}

func (p *LargeDeltas) readField3000(iprot thrift.TProtocol) error {
	p.Vertwo3000 = &VersioningTestV2{}
	if err := p.Vertwo3000.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Vertwo3000), err)
	}
	return nil
}

func (p *LargeDeltas) readField4000(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]int32, 0, size)
	p.BigNumbers = tSlice
	for i := 0; i < size; i++ {
		var _elem13 int32
		if v, err := iprot.ReadI32(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_elem13 = v
		}
		p.BigNumbers = append(p.BigNumbers, _elem13)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *LargeDeltas) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("LargeDeltas"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	if err := p.writeField1(oprot); err != nil {
		return err
	}
	if err := p.writeField10(oprot); err != nil {
		return err
	}
	if err := p.writeField100(oprot); err != nil {
		return err
	}
	if err := p.writeField500(oprot); err != nil {
		return err
	}
	if err := p.writeField1000(oprot); err != nil {
		return err
	}
	if err := p.writeField1500(oprot); err != nil {
		return err
	}
	if err := p.writeField2000(oprot); err != nil {
		return err
	}
	if err := p.writeField2500(oprot); err != nil {
		return err
	}
	if err := p.writeField3000(oprot); err != nil {
		return err
	}
	if err := p.writeField4000(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 *LargeDeltas) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetB1() {
		if err := oprot.WriteFieldBegin("b1", thrift.STRUCT, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:b1: ", p), err)
		}
		if err := p.B1.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.B1), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1:b1: ", p), err)
		}
	}
	return err
}

func (p *LargeDeltas) writeField10(oprot thrift.TProtocol) (err error) {
	if p.IsSetB10() {
		if err := oprot.WriteFieldBegin("b10", thrift.STRUCT, 10); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 10:b10: ", p), err)
		}
		if err := p.B10.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.B10), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 10:b10: ", p), err)
		}
	}
	return err
}

func (p *LargeDeltas) writeField100(oprot thrift.TProtocol) (err error) {
	if p.IsSetB100() {
		if err := oprot.WriteFieldBegin("b100", thrift.STRUCT, 100); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 100:b100: ", p), err)
		}
		if err := p.B100.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.B100), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 100:b100: ", p), err)
		}
	}
	return err
}

func (p *LargeDeltas) writeField500(oprot thrift.TProtocol) (err error) {
	if p.IsSetCheckTrue() {
		if err := oprot.WriteFieldBegin("check_true", thrift.BOOL, 500); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 500:check_true: ", p), err)
		}
		if err := oprot.WriteBool(bool(*p.CheckTrue)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.check_true (500) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 500:check_true: ", p), err)
		}
	}
	return err
}

func (p *LargeDeltas) writeField1000(oprot thrift.TProtocol) (err error) {
	if p.IsSetB1000() {
		if err := oprot.WriteFieldBegin("b1000", thrift.STRUCT, 1000); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1000:b1000: ", p), err)
		}
		if err := p.B1000.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.B1000), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1000:b1000: ", p), err)
		}
	}
	return err
}

func (p *LargeDeltas) writeField1500(oprot thrift.TProtocol) (err error) {
	if p.IsSetCheckFalse() {
		if err := oprot.WriteFieldBegin("check_false", thrift.BOOL, 1500); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1500:check_false: ", p), err)
		}
		if err := oprot.WriteBool(bool(*p.CheckFalse)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.check_false (1500) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1500:check_false: ", p), err)
		}
	}
	return err
}

func (p *LargeDeltas) writeField2000(oprot thrift.TProtocol) (err error) {
	if p.IsSetVertwo2000() {
		if err := oprot.WriteFieldBegin("vertwo2000", thrift.STRUCT, 2000); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 2000:vertwo2000: ", p), err)
		}
		if err := p.Vertwo2000.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Vertwo2000), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 2000:vertwo2000: ", p), err)
		}
	}
	return err
}

func (p *LargeDeltas) writeField2500(oprot thrift.TProtocol) (err error) {
	if p.IsSetASet2500() {
		if err := oprot.WriteFieldBegin("a_set2500", thrift.SET, 2500); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 2500:a_set2500: ", p), err)
		}
		if err := oprot.WriteSetBegin(thrift.STRING, len(p.ASet2500)); err != nil {
			return thrift.PrependError("error writing set begin: ", err)
		}
		for v, _ := range p.ASet2500 {
			if err := oprot.WriteString(string(v)); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
			}
		}
		if err := oprot.WriteSetEnd(); err != nil {
			return thrift.PrependError("error writing set end: ", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 2500:a_set2500: ", p), err)
		}
	}
	return err
}

func (p *LargeDeltas) writeField3000(oprot thrift.TProtocol) (err error) {
	if p.IsSetVertwo3000() {
		if err := oprot.WriteFieldBegin("vertwo3000", thrift.STRUCT, 3000); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 3000:vertwo3000: ", p), err)
		}
		if err := p.Vertwo3000.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Vertwo3000), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 3000:vertwo3000: ", p), err)
		}
	}
	return err
}

func (p *LargeDeltas) writeField4000(oprot thrift.TProtocol) (err error) {
	if p.IsSetBigNumbers() {
		if err := oprot.WriteFieldBegin("big_numbers", thrift.LIST, 4000); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 4000:big_numbers: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.I32, len(p.BigNumbers)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.BigNumbers {
			if err := oprot.WriteI32(int32(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 4000:big_numbers: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Integerlist
type NestedListsI32x2 struct {
	Integerlist [][]int32 `thrift:"integerlist,1" json:"integerlist,omitempty"`
}

func NewNestedListsI32x2() *NestedListsI32x2 {
	return &NestedListsI32x2{}
}

var NestedListsI32x2_Integerlist_DEFAULT [][]int32

func (p *NestedListsI32x2) GetIntegerlist() [][]int32 {
	return p.Integerlist
}
func (p *NestedListsI32x2) IsSetIntegerlist() bool {
	return p.Integerlist != nil
}

func (p *NestedListsI32x2) 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 *NestedListsI32x2) readField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([][]int32, 0, size)
	p.Integerlist = tSlice
	for i := 0; i < size; i++ {
		_, size, err := iprot.ReadListBegin()
		if err != nil {
			return thrift.PrependError("error reading list begin: ", err)
		}
		tSlice := make([]int32, 0, size)
		_elem14 := tSlice
		for i := 0; i < size; i++ {
			var _elem15 int32
			if v, err := iprot.ReadI32(); err != nil {
				return thrift.PrependError("error reading field 0: ", err)
			} else {
				_elem15 = v
			}
			_elem14 = append(_elem14, _elem15)
		}
		if err := iprot.ReadListEnd(); err != nil {
			return thrift.PrependError("error reading list end: ", err)
		}
		p.Integerlist = append(p.Integerlist, _elem14)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *NestedListsI32x2) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("NestedListsI32x2"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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 *NestedListsI32x2) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetIntegerlist() {
		if err := oprot.WriteFieldBegin("integerlist", thrift.LIST, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:integerlist: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.LIST, len(p.Integerlist)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.Integerlist {
			if err := oprot.WriteListBegin(thrift.I32, len(v)); err != nil {
				return thrift.PrependError("error writing list begin: ", err)
			}
			for _, v := range v {
				if err := oprot.WriteI32(int32(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.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:integerlist: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Integerlist
type NestedListsI32x3 struct {
	Integerlist [][][]int32 `thrift:"integerlist,1" json:"integerlist,omitempty"`
}

func NewNestedListsI32x3() *NestedListsI32x3 {
	return &NestedListsI32x3{}
}

var NestedListsI32x3_Integerlist_DEFAULT [][][]int32

func (p *NestedListsI32x3) GetIntegerlist() [][][]int32 {
	return p.Integerlist
}
func (p *NestedListsI32x3) IsSetIntegerlist() bool {
	return p.Integerlist != nil
}

func (p *NestedListsI32x3) 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 *NestedListsI32x3) readField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([][][]int32, 0, size)
	p.Integerlist = tSlice
	for i := 0; i < size; i++ {
		_, size, err := iprot.ReadListBegin()
		if err != nil {
			return thrift.PrependError("error reading list begin: ", err)
		}
		tSlice := make([][]int32, 0, size)
		_elem16 := tSlice
		for i := 0; i < size; i++ {
			_, size, err := iprot.ReadListBegin()
			if err != nil {
				return thrift.PrependError("error reading list begin: ", err)
			}
			tSlice := make([]int32, 0, size)
			_elem17 := tSlice
			for i := 0; i < size; i++ {
				var _elem18 int32
				if v, err := iprot.ReadI32(); err != nil {
					return thrift.PrependError("error reading field 0: ", err)
				} else {
					_elem18 = v
				}
				_elem17 = append(_elem17, _elem18)
			}
			if err := iprot.ReadListEnd(); err != nil {
				return thrift.PrependError("error reading list end: ", err)
			}
			_elem16 = append(_elem16, _elem17)
		}
		if err := iprot.ReadListEnd(); err != nil {
			return thrift.PrependError("error reading list end: ", err)
		}
		p.Integerlist = append(p.Integerlist, _elem16)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *NestedListsI32x3) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("NestedListsI32x3"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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 *NestedListsI32x3) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetIntegerlist() {
		if err := oprot.WriteFieldBegin("integerlist", thrift.LIST, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:integerlist: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.LIST, len(p.Integerlist)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.Integerlist {
			if err := oprot.WriteListBegin(thrift.LIST, len(v)); err != nil {
				return thrift.PrependError("error writing list begin: ", err)
			}
			for _, v := range v {
				if err := oprot.WriteListBegin(thrift.I32, len(v)); err != nil {
					return thrift.PrependError("error writing list begin: ", err)
				}
				for _, v := range v {
					if err := oprot.WriteI32(int32(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.WriteListEnd(); err != nil {
				return thrift.PrependError("error writing list end: ", 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:integerlist: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - IntSetList
//  - MapIntStrset
//  - MapIntStrsetList
type NestedMixedx2 struct {
	IntSetList       []map[int32]bool            `thrift:"int_set_list,1" json:"int_set_list,omitempty"`
	MapIntStrset     map[int32]map[string]bool   `thrift:"map_int_strset,2" json:"map_int_strset,omitempty"`
	MapIntStrsetList []map[int32]map[string]bool `thrift:"map_int_strset_list,3" json:"map_int_strset_list,omitempty"`
}

func NewNestedMixedx2() *NestedMixedx2 {
	return &NestedMixedx2{}
}

var NestedMixedx2_IntSetList_DEFAULT []map[int32]bool

func (p *NestedMixedx2) GetIntSetList() []map[int32]bool {
	return p.IntSetList
}

var NestedMixedx2_MapIntStrset_DEFAULT map[int32]map[string]bool

func (p *NestedMixedx2) GetMapIntStrset() map[int32]map[string]bool {
	return p.MapIntStrset
}

var NestedMixedx2_MapIntStrsetList_DEFAULT []map[int32]map[string]bool

func (p *NestedMixedx2) GetMapIntStrsetList() []map[int32]map[string]bool {
	return p.MapIntStrsetList
}
func (p *NestedMixedx2) IsSetIntSetList() bool {
	return p.IntSetList != nil
}

func (p *NestedMixedx2) IsSetMapIntStrset() bool {
	return p.MapIntStrset != nil
}

func (p *NestedMixedx2) IsSetMapIntStrsetList() bool {
	return p.MapIntStrsetList != nil
}

func (p *NestedMixedx2) 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
			}
		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 *NestedMixedx2) readField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]map[int32]bool, 0, size)
	p.IntSetList = tSlice
	for i := 0; i < size; i++ {
		_, size, err := iprot.ReadSetBegin()
		if err != nil {
			return thrift.PrependError("error reading set begin: ", err)
		}
		tSet := make(map[int32]bool, size)
		_elem19 := tSet
		for i := 0; i < size; i++ {
			var _elem20 int32
			if v, err := iprot.ReadI32(); err != nil {
				return thrift.PrependError("error reading field 0: ", err)
			} else {
				_elem20 = v
			}
			_elem19[_elem20] = true
		}
		if err := iprot.ReadSetEnd(); err != nil {
			return thrift.PrependError("error reading set end: ", err)
		}
		p.IntSetList = append(p.IntSetList, _elem19)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *NestedMixedx2) readField2(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(map[int32]map[string]bool, size)
	p.MapIntStrset = tMap
	for i := 0; i < size; i++ {
		var _key21 int32
		if v, err := iprot.ReadI32(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_key21 = v
		}
		_, size, err := iprot.ReadSetBegin()
		if err != nil {
			return thrift.PrependError("error reading set begin: ", err)
		}
		tSet := make(map[string]bool, size)
		_val22 := tSet
		for i := 0; i < size; i++ {
			var _elem23 string
			if v, err := iprot.ReadString(); err != nil {
				return thrift.PrependError("error reading field 0: ", err)
			} else {
				_elem23 = v
			}
			_val22[_elem23] = true
		}
		if err := iprot.ReadSetEnd(); err != nil {
			return thrift.PrependError("error reading set end: ", err)
		}
		p.MapIntStrset[_key21] = _val22
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

func (p *NestedMixedx2) readField3(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]map[int32]map[string]bool, 0, size)
	p.MapIntStrsetList = tSlice
	for i := 0; i < size; i++ {
		_, _, size, err := iprot.ReadMapBegin()
		if err != nil {
			return thrift.PrependError("error reading map begin: ", err)
		}
		tMap := make(map[int32]map[string]bool, size)
		_elem24 := tMap
		for i := 0; i < size; i++ {
			var _key25 int32
			if v, err := iprot.ReadI32(); err != nil {
				return thrift.PrependError("error reading field 0: ", err)
			} else {
				_key25 = v
			}
			_, size, err := iprot.ReadSetBegin()
			if err != nil {
				return thrift.PrependError("error reading set begin: ", err)
			}
			tSet := make(map[string]bool, size)
			_val26 := tSet
			for i := 0; i < size; i++ {
				var _elem27 string
				if v, err := iprot.ReadString(); err != nil {
					return thrift.PrependError("error reading field 0: ", err)
				} else {
					_elem27 = v
				}
				_val26[_elem27] = true
			}
			if err := iprot.ReadSetEnd(); err != nil {
				return thrift.PrependError("error reading set end: ", err)
			}
			_elem24[_key25] = _val26
		}
		if err := iprot.ReadMapEnd(); err != nil {
			return thrift.PrependError("error reading map end: ", err)
		}
		p.MapIntStrsetList = append(p.MapIntStrsetList, _elem24)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *NestedMixedx2) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("NestedMixedx2"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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 *NestedMixedx2) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetIntSetList() {
		if err := oprot.WriteFieldBegin("int_set_list", thrift.LIST, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:int_set_list: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.SET, len(p.IntSetList)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.IntSetList {
			if err := oprot.WriteSetBegin(thrift.I32, len(v)); err != nil {
				return thrift.PrependError("error writing set begin: ", err)
			}
			for v, _ := range v {
				if err := oprot.WriteI32(int32(v)); err != nil {
					return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
				}
			}
			if err := oprot.WriteSetEnd(); err != nil {
				return thrift.PrependError("error writing set end: ", 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:int_set_list: ", p), err)
		}
	}
	return err
}

func (p *NestedMixedx2) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetMapIntStrset() {
		if err := oprot.WriteFieldBegin("map_int_strset", thrift.MAP, 2); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:map_int_strset: ", p), err)
		}
		if err := oprot.WriteMapBegin(thrift.I32, thrift.SET, len(p.MapIntStrset)); err != nil {
			return thrift.PrependError("error writing map begin: ", err)
		}
		for k, v := range p.MapIntStrset {
			if err := oprot.WriteI32(int32(k)); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
			}
			if err := oprot.WriteSetBegin(thrift.STRING, len(v)); err != nil {
				return thrift.PrependError("error writing set begin: ", err)
			}
			for v, _ := range v {
				if err := oprot.WriteString(string(v)); err != nil {
					return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
				}
			}
			if err := oprot.WriteSetEnd(); err != nil {
				return thrift.PrependError("error writing set 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 2:map_int_strset: ", p), err)
		}
	}
	return err
}

func (p *NestedMixedx2) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetMapIntStrsetList() {
		if err := oprot.WriteFieldBegin("map_int_strset_list", thrift.LIST, 3); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:map_int_strset_list: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.MAP, len(p.MapIntStrsetList)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.MapIntStrsetList {
			if err := oprot.WriteMapBegin(thrift.I32, thrift.SET, len(v)); err != nil {
				return thrift.PrependError("error writing map begin: ", err)
			}
			for k, v := range v {
				if err := oprot.WriteI32(int32(k)); err != nil {
					return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
				}
				if err := oprot.WriteSetBegin(thrift.STRING, len(v)); err != nil {
					return thrift.PrependError("error writing set begin: ", err)
				}
				for v, _ := range v {
					if err := oprot.WriteString(string(v)); err != nil {
						return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
					}
				}
				if err := oprot.WriteSetEnd(); err != nil {
					return thrift.PrependError("error writing set end: ", err)
				}
			}
			if err := oprot.WriteMapEnd(); err != nil {
				return thrift.PrependError("error writing map end: ", 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 3:map_int_strset_list: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Bonk
type ListBonks struct {
	Bonk []*Bonk `thrift:"bonk,1" json:"bonk,omitempty"`
}

func NewListBonks() *ListBonks {
	return &ListBonks{}
}

var ListBonks_Bonk_DEFAULT []*Bonk

func (p *ListBonks) GetBonk() []*Bonk {
	return p.Bonk
}
func (p *ListBonks) IsSetBonk() bool {
	return p.Bonk != nil
}

func (p *ListBonks) 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 *ListBonks) readField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([]*Bonk, 0, size)
	p.Bonk = tSlice
	for i := 0; i < size; i++ {
		_elem28 := &Bonk{}
		if err := _elem28.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem28), err)
		}
		p.Bonk = append(p.Bonk, _elem28)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *ListBonks) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("ListBonks"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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 *ListBonks) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetBonk() {
		if err := oprot.WriteFieldBegin("bonk", thrift.LIST, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:bonk: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Bonk)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.Bonk {
			if err := v.Write(oprot); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), 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:bonk: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - Bonk
type NestedListsBonk struct {
	Bonk [][][]*Bonk `thrift:"bonk,1" json:"bonk,omitempty"`
}

func NewNestedListsBonk() *NestedListsBonk {
	return &NestedListsBonk{}
}

var NestedListsBonk_Bonk_DEFAULT [][][]*Bonk

func (p *NestedListsBonk) GetBonk() [][][]*Bonk {
	return p.Bonk
}
func (p *NestedListsBonk) IsSetBonk() bool {
	return p.Bonk != nil
}

func (p *NestedListsBonk) 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 *NestedListsBonk) readField1(iprot thrift.TProtocol) error {
	_, size, err := iprot.ReadListBegin()
	if err != nil {
		return thrift.PrependError("error reading list begin: ", err)
	}
	tSlice := make([][][]*Bonk, 0, size)
	p.Bonk = tSlice
	for i := 0; i < size; i++ {
		_, size, err := iprot.ReadListBegin()
		if err != nil {
			return thrift.PrependError("error reading list begin: ", err)
		}
		tSlice := make([][]*Bonk, 0, size)
		_elem29 := tSlice
		for i := 0; i < size; i++ {
			_, size, err := iprot.ReadListBegin()
			if err != nil {
				return thrift.PrependError("error reading list begin: ", err)
			}
			tSlice := make([]*Bonk, 0, size)
			_elem30 := tSlice
			for i := 0; i < size; i++ {
				_elem31 := &Bonk{}
				if err := _elem31.Read(iprot); err != nil {
					return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem31), err)
				}
				_elem30 = append(_elem30, _elem31)
			}
			if err := iprot.ReadListEnd(); err != nil {
				return thrift.PrependError("error reading list end: ", err)
			}
			_elem29 = append(_elem29, _elem30)
		}
		if err := iprot.ReadListEnd(); err != nil {
			return thrift.PrependError("error reading list end: ", err)
		}
		p.Bonk = append(p.Bonk, _elem29)
	}
	if err := iprot.ReadListEnd(); err != nil {
		return thrift.PrependError("error reading list end: ", err)
	}
	return nil
}

func (p *NestedListsBonk) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("NestedListsBonk"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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 *NestedListsBonk) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetBonk() {
		if err := oprot.WriteFieldBegin("bonk", thrift.LIST, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:bonk: ", p), err)
		}
		if err := oprot.WriteListBegin(thrift.LIST, len(p.Bonk)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range p.Bonk {
			if err := oprot.WriteListBegin(thrift.LIST, len(v)); err != nil {
				return thrift.PrependError("error writing list begin: ", err)
			}
			for _, v := range v {
				if err := oprot.WriteListBegin(thrift.STRUCT, len(v)); err != nil {
					return thrift.PrependError("error writing list begin: ", err)
				}
				for _, v := range v {
					if err := v.Write(oprot); err != nil {
						return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
					}
				}
				if err := oprot.WriteListEnd(); err != nil {
					return thrift.PrependError("error writing list end: ", err)
				}
			}
			if err := oprot.WriteListEnd(); err != nil {
				return thrift.PrependError("error writing list end: ", 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:bonk: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - B
//  - S
type BoolTest struct {
	B bool   `thrift:"b,1" json:"b,omitempty"`
	S string `thrift:"s,2" json:"s,omitempty"`
}

func NewBoolTest() *BoolTest {
	return &BoolTest{
		B: true,

		S: "true",
	}
}

var BoolTest_B_DEFAULT bool = true

func (p *BoolTest) GetB() bool {
	return p.B
}

var BoolTest_S_DEFAULT string = "true"

func (p *BoolTest) GetS() string {
	return p.S
}
func (p *BoolTest) IsSetB() bool {
	return p.B != BoolTest_B_DEFAULT
}

func (p *BoolTest) IsSetS() bool {
	return p.S != BoolTest_S_DEFAULT
}

func (p *BoolTest) 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
			}
		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 *BoolTest) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadBool(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.B = v
	}
	return nil
}

func (p *BoolTest) readField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		p.S = v
	}
	return nil
}

func (p *BoolTest) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("BoolTest"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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 *BoolTest) writeField1(oprot thrift.TProtocol) (err error) {
	if p.IsSetB() {
		if err := oprot.WriteFieldBegin("b", thrift.BOOL, 1); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:b: ", p), err)
		}
		if err := oprot.WriteBool(bool(p.B)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.b (1) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 1:b: ", p), err)
		}
	}
	return err
}

func (p *BoolTest) writeField2(oprot thrift.TProtocol) (err error) {
	if p.IsSetS() {
		if err := oprot.WriteFieldBegin("s", thrift.STRING, 2); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:s: ", p), err)
		}
		if err := oprot.WriteString(string(p.S)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.s (2) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 2:s: ", p), err)
		}
	}
	return err
}

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

// Attributes:
//  - S
type StructA struct {
	S string `thrift:"s,1,required" json:"s"`
}

func NewStructA() *StructA {
	return &StructA{}
}

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

	var issetS bool = false

	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
			}
			issetS = true
		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)
	}
	if !issetS {
		return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field S is not set"))
	}
	return nil
}

func (p *StructA) readField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.S = v
	}
	return nil
}

func (p *StructA) Write(oprot thrift.TProtocol) error {
	if err := oprot.WriteStructBegin("StructA"); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
	}
	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 *StructA) writeField1(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("s", thrift.STRING, 1); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:s: ", p), err)
	}
	if err := oprot.WriteString(string(p.S)); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T.s (1) field write error: ", p), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 1:s: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Aa
//  - Ab
type StructB struct {
	Aa *StructA `thrift:"aa,1" json:"aa,omitempty"`
	Ab *StructA `thrift:"ab,2,required" json:"ab"`
}

func NewStructB() *StructB {
	return &StructB{}
}

var StructB_Aa_DEFAULT *StructA

func (p *StructB) GetAa() *StructA {
	if !p.IsSetAa() {
		return StructB_Aa_DEFAULT
	}
	return p.Aa
}

var StructB_Ab_DEFAULT *StructA

func (p *StructB) GetAb() *StructA {
	if !p.IsSetAb() {
		return StructB_Ab_DEFAULT
	}
	return p.Ab
}
func (p *StructB) IsSetAa() bool {
	return p.Aa != nil
}

func (p *StructB) IsSetAb() bool {
	return p.Ab != nil
}

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

	var issetAb bool = false

	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
			}
			issetAb = true
		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)
	}
	if !issetAb {
		return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Ab is not set"))
	}
	return nil
}

func (p *StructB) readField1(iprot thrift.TProtocol) error {
	p.Aa = &StructA{}
	if err := p.Aa.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Aa), err)
	}
	return nil
}

func (p *StructB) readField2(iprot thrift.TProtocol) error {
	p.Ab = &StructA{}
	if err := p.Ab.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Ab), err)
	}
	return nil
}

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

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

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