/**
 * Autogenerated by Thrift
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
import java.util.Set;
import java.util.HashSet;
import java.util.Collections;
import java.util.BitSet;
import java.util.Arrays;
import com.facebook.thrift.*;
import com.facebook.thrift.annotations.*;
import com.facebook.thrift.async.*;
import com.facebook.thrift.meta_data.*;
import com.facebook.thrift.server.*;
import com.facebook.thrift.transport.*;
import com.facebook.thrift.protocol.*;

@SuppressWarnings({ "unused", "serial" })
public class ComplexNestedStruct implements TBase, java.io.Serializable, Cloneable {
  private static final TStruct STRUCT_DESC = new TStruct("ComplexNestedStruct");
  private static final TField SET_OF_SET_OF_INT_FIELD_DESC = new TField("setOfSetOfInt", TType.SET, (short)1);
  private static final TField LISTOF_LIST_OF_LIST_OF_LIST_OF_ENUM_FIELD_DESC = new TField("listofListOfListOfListOfEnum", TType.LIST, (short)2);
  private static final TField LIST_OF_LIST_OF_MY_STRUCT_FIELD_DESC = new TField("listOfListOfMyStruct", TType.LIST, (short)3);
  private static final TField SET_OF_LIST_OF_LIST_OF_LONG_FIELD_DESC = new TField("setOfListOfListOfLong", TType.SET, (short)4);
  private static final TField SET_OF_SET_OFSET_OF_LONG_FIELD_DESC = new TField("setOfSetOfsetOfLong", TType.SET, (short)5);
  private static final TField MAP_STRUCT_LIST_OF_LIST_OF_LONG_FIELD_DESC = new TField("mapStructListOfListOfLong", TType.MAP, (short)6);
  private static final TField M_KEY_STRUCT_VAL_INT_FIELD_DESC = new TField("mKeyStructValInt", TType.MAP, (short)7);
  private static final TField LIST_OF_MAP_KEY_INT_VAL_INT_FIELD_DESC = new TField("listOfMapKeyIntValInt", TType.LIST, (short)8);
  private static final TField LIST_OF_MAP_KEY_STR_VAL_LIST_FIELD_DESC = new TField("listOfMapKeyStrValList", TType.LIST, (short)9);
  private static final TField MAP_KEY_SET_VAL_LONG_FIELD_DESC = new TField("mapKeySetValLong", TType.MAP, (short)10);
  private static final TField MAP_KEY_LIST_VAL_LONG_FIELD_DESC = new TField("mapKeyListValLong", TType.MAP, (short)11);
  private static final TField MAP_KEY_MAP_VAL_MAP_FIELD_DESC = new TField("mapKeyMapValMap", TType.MAP, (short)12);
  private static final TField MAP_KEY_SET_VAL_MAP_FIELD_DESC = new TField("mapKeySetValMap", TType.MAP, (short)13);
  private static final TField NESTED_MAPS_FIELD_DESC = new TField("NestedMaps", TType.MAP, (short)14);
  private static final TField MAP_KEY_INT_VAL_LIST_FIELD_DESC = new TField("mapKeyIntValList", TType.MAP, (short)15);
  private static final TField MAP_KEY_INT_VAL_SET_FIELD_DESC = new TField("mapKeyIntValSet", TType.MAP, (short)16);
  private static final TField MAP_KEY_SET_VAL_INT_FIELD_DESC = new TField("mapKeySetValInt", TType.MAP, (short)17);
  private static final TField MAP_KEY_LIST_VAL_SET_FIELD_DESC = new TField("mapKeyListValSet", TType.MAP, (short)18);

  public Set<Set<Integer>> setOfSetOfInt;
  public List<List<List<List<MyEnum>>>> listofListOfListOfListOfEnum;
  public List<List<MyStruct>> listOfListOfMyStruct;
  public Set<List<List<Long>>> setOfListOfListOfLong;
  public Set<Set<Set<Long>>> setOfSetOfsetOfLong;
  public Map<Integer,List<List<MyStruct>>> mapStructListOfListOfLong;
  public Map<MyStruct,Integer> mKeyStructValInt;
  public List<Map<Integer,Integer>> listOfMapKeyIntValInt;
  public List<Map<String,List<MyStruct>>> listOfMapKeyStrValList;
  public Map<Set<Integer>,Long> mapKeySetValLong;
  public Map<List<String>,Integer> mapKeyListValLong;
  public Map<Map<Integer,String>,Map<Integer,String>> mapKeyMapValMap;
  public Map<Set<List<Integer>>,Map<List<Set<String>>,String>> mapKeySetValMap;
  public Map<Map<Map<Integer,String>,String>,Map<Integer,String>> NestedMaps;
  public Map<Integer,List<MyStruct>> mapKeyIntValList;
  public Map<Integer,Set<Boolean>> mapKeyIntValSet;
  public Map<Set<Boolean>,MyEnum> mapKeySetValInt;
  public Map<List<Integer>,Set<Map<Double,String>>> mapKeyListValSet;
  public static final int SETOFSETOFINT = 1;
  public static final int LISTOFLISTOFLISTOFLISTOFENUM = 2;
  public static final int LISTOFLISTOFMYSTRUCT = 3;
  public static final int SETOFLISTOFLISTOFLONG = 4;
  public static final int SETOFSETOFSETOFLONG = 5;
  public static final int MAPSTRUCTLISTOFLISTOFLONG = 6;
  public static final int MKEYSTRUCTVALINT = 7;
  public static final int LISTOFMAPKEYINTVALINT = 8;
  public static final int LISTOFMAPKEYSTRVALLIST = 9;
  public static final int MAPKEYSETVALLONG = 10;
  public static final int MAPKEYLISTVALLONG = 11;
  public static final int MAPKEYMAPVALMAP = 12;
  public static final int MAPKEYSETVALMAP = 13;
  public static final int NESTEDMAPS = 14;
  public static final int MAPKEYINTVALLIST = 15;
  public static final int MAPKEYINTVALSET = 16;
  public static final int MAPKEYSETVALINT = 17;
  public static final int MAPKEYLISTVALSET = 18;

  // isset id assignments

  public static final Map<Integer, FieldMetaData> metaDataMap;

  static {
    Map<Integer, FieldMetaData> tmpMetaDataMap = new HashMap<Integer, FieldMetaData>();
    tmpMetaDataMap.put(SETOFSETOFINT, new FieldMetaData("setOfSetOfInt", TFieldRequirementType.DEFAULT, 
        new SetMetaData(TType.SET, 
            new SetMetaData(TType.SET, 
                new FieldValueMetaData(TType.I32)))));
    tmpMetaDataMap.put(LISTOFLISTOFLISTOFLISTOFENUM, new FieldMetaData("listofListOfListOfListOfEnum", TFieldRequirementType.DEFAULT, 
        new ListMetaData(TType.LIST, 
            new ListMetaData(TType.LIST, 
                new ListMetaData(TType.LIST, 
                    new ListMetaData(TType.LIST, 
                        new FieldValueMetaData(TType.I32)))))));
    tmpMetaDataMap.put(LISTOFLISTOFMYSTRUCT, new FieldMetaData("listOfListOfMyStruct", TFieldRequirementType.DEFAULT, 
        new ListMetaData(TType.LIST, 
            new ListMetaData(TType.LIST, 
                new StructMetaData(TType.STRUCT, MyStruct.class)))));
    tmpMetaDataMap.put(SETOFLISTOFLISTOFLONG, new FieldMetaData("setOfListOfListOfLong", TFieldRequirementType.DEFAULT, 
        new SetMetaData(TType.SET, 
            new ListMetaData(TType.LIST, 
                new ListMetaData(TType.LIST, 
                    new FieldValueMetaData(TType.I64))))));
    tmpMetaDataMap.put(SETOFSETOFSETOFLONG, new FieldMetaData("setOfSetOfsetOfLong", TFieldRequirementType.DEFAULT, 
        new SetMetaData(TType.SET, 
            new SetMetaData(TType.SET, 
                new SetMetaData(TType.SET, 
                    new FieldValueMetaData(TType.I64))))));
    tmpMetaDataMap.put(MAPSTRUCTLISTOFLISTOFLONG, new FieldMetaData("mapStructListOfListOfLong", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new FieldValueMetaData(TType.I32), 
            new ListMetaData(TType.LIST, 
                new ListMetaData(TType.LIST, 
                    new StructMetaData(TType.STRUCT, MyStruct.class))))));
    tmpMetaDataMap.put(MKEYSTRUCTVALINT, new FieldMetaData("mKeyStructValInt", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new StructMetaData(TType.STRUCT, MyStruct.class), 
            new FieldValueMetaData(TType.I32))));
    tmpMetaDataMap.put(LISTOFMAPKEYINTVALINT, new FieldMetaData("listOfMapKeyIntValInt", TFieldRequirementType.DEFAULT, 
        new ListMetaData(TType.LIST, 
            new MapMetaData(TType.MAP, 
                new FieldValueMetaData(TType.I32), 
                new FieldValueMetaData(TType.I32)))));
    tmpMetaDataMap.put(LISTOFMAPKEYSTRVALLIST, new FieldMetaData("listOfMapKeyStrValList", TFieldRequirementType.DEFAULT, 
        new ListMetaData(TType.LIST, 
            new MapMetaData(TType.MAP, 
                new FieldValueMetaData(TType.STRING), 
                new ListMetaData(TType.LIST, 
                    new StructMetaData(TType.STRUCT, MyStruct.class))))));
    tmpMetaDataMap.put(MAPKEYSETVALLONG, new FieldMetaData("mapKeySetValLong", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new SetMetaData(TType.SET, 
                new FieldValueMetaData(TType.I32)), 
            new FieldValueMetaData(TType.I64))));
    tmpMetaDataMap.put(MAPKEYLISTVALLONG, new FieldMetaData("mapKeyListValLong", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new ListMetaData(TType.LIST, 
                new FieldValueMetaData(TType.STRING)), 
            new FieldValueMetaData(TType.I32))));
    tmpMetaDataMap.put(MAPKEYMAPVALMAP, new FieldMetaData("mapKeyMapValMap", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new MapMetaData(TType.MAP, 
                new FieldValueMetaData(TType.I32), 
                new FieldValueMetaData(TType.STRING)), 
            new MapMetaData(TType.MAP, 
                new FieldValueMetaData(TType.I32), 
                new FieldValueMetaData(TType.STRING)))));
    tmpMetaDataMap.put(MAPKEYSETVALMAP, new FieldMetaData("mapKeySetValMap", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new SetMetaData(TType.SET, 
                new ListMetaData(TType.LIST, 
                    new FieldValueMetaData(TType.I32))), 
            new MapMetaData(TType.MAP, 
                new ListMetaData(TType.LIST, 
                    new SetMetaData(TType.SET, 
                        new FieldValueMetaData(TType.STRING))), 
                new FieldValueMetaData(TType.STRING)))));
    tmpMetaDataMap.put(NESTEDMAPS, new FieldMetaData("NestedMaps", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new MapMetaData(TType.MAP, 
                new MapMetaData(TType.MAP, 
                    new FieldValueMetaData(TType.I32), 
                    new FieldValueMetaData(TType.STRING)), 
                new FieldValueMetaData(TType.STRING)), 
            new MapMetaData(TType.MAP, 
                new FieldValueMetaData(TType.I32), 
                new FieldValueMetaData(TType.STRING)))));
    tmpMetaDataMap.put(MAPKEYINTVALLIST, new FieldMetaData("mapKeyIntValList", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new FieldValueMetaData(TType.I32), 
            new ListMetaData(TType.LIST, 
                new StructMetaData(TType.STRUCT, MyStruct.class)))));
    tmpMetaDataMap.put(MAPKEYINTVALSET, new FieldMetaData("mapKeyIntValSet", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new FieldValueMetaData(TType.I32), 
            new SetMetaData(TType.SET, 
                new FieldValueMetaData(TType.BOOL)))));
    tmpMetaDataMap.put(MAPKEYSETVALINT, new FieldMetaData("mapKeySetValInt", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new SetMetaData(TType.SET, 
                new FieldValueMetaData(TType.BOOL)), 
            new FieldValueMetaData(TType.I32))));
    tmpMetaDataMap.put(MAPKEYLISTVALSET, new FieldMetaData("mapKeyListValSet", TFieldRequirementType.DEFAULT, 
        new MapMetaData(TType.MAP, 
            new ListMetaData(TType.LIST, 
                new FieldValueMetaData(TType.I32)), 
            new SetMetaData(TType.SET, 
                new MapMetaData(TType.MAP, 
                    new FieldValueMetaData(TType.DOUBLE), 
                    new FieldValueMetaData(TType.STRING))))));
    metaDataMap = Collections.unmodifiableMap(tmpMetaDataMap);
  }

  static {
    FieldMetaData.addStructMetaDataMap(ComplexNestedStruct.class, metaDataMap);
  }

  public ComplexNestedStruct() {
  }

  public ComplexNestedStruct(
      Set<Set<Integer>> setOfSetOfInt,
      List<List<List<List<MyEnum>>>> listofListOfListOfListOfEnum,
      List<List<MyStruct>> listOfListOfMyStruct,
      Set<List<List<Long>>> setOfListOfListOfLong,
      Set<Set<Set<Long>>> setOfSetOfsetOfLong,
      Map<Integer,List<List<MyStruct>>> mapStructListOfListOfLong,
      Map<MyStruct,Integer> mKeyStructValInt,
      List<Map<Integer,Integer>> listOfMapKeyIntValInt,
      List<Map<String,List<MyStruct>>> listOfMapKeyStrValList,
      Map<Set<Integer>,Long> mapKeySetValLong,
      Map<List<String>,Integer> mapKeyListValLong,
      Map<Map<Integer,String>,Map<Integer,String>> mapKeyMapValMap,
      Map<Set<List<Integer>>,Map<List<Set<String>>,String>> mapKeySetValMap,
      Map<Map<Map<Integer,String>,String>,Map<Integer,String>> NestedMaps,
      Map<Integer,List<MyStruct>> mapKeyIntValList,
      Map<Integer,Set<Boolean>> mapKeyIntValSet,
      Map<Set<Boolean>,MyEnum> mapKeySetValInt,
      Map<List<Integer>,Set<Map<Double,String>>> mapKeyListValSet) {
    this();
    this.setOfSetOfInt = setOfSetOfInt;
    this.listofListOfListOfListOfEnum = listofListOfListOfListOfEnum;
    this.listOfListOfMyStruct = listOfListOfMyStruct;
    this.setOfListOfListOfLong = setOfListOfListOfLong;
    this.setOfSetOfsetOfLong = setOfSetOfsetOfLong;
    this.mapStructListOfListOfLong = mapStructListOfListOfLong;
    this.mKeyStructValInt = mKeyStructValInt;
    this.listOfMapKeyIntValInt = listOfMapKeyIntValInt;
    this.listOfMapKeyStrValList = listOfMapKeyStrValList;
    this.mapKeySetValLong = mapKeySetValLong;
    this.mapKeyListValLong = mapKeyListValLong;
    this.mapKeyMapValMap = mapKeyMapValMap;
    this.mapKeySetValMap = mapKeySetValMap;
    this.NestedMaps = NestedMaps;
    this.mapKeyIntValList = mapKeyIntValList;
    this.mapKeyIntValSet = mapKeyIntValSet;
    this.mapKeySetValInt = mapKeySetValInt;
    this.mapKeyListValSet = mapKeyListValSet;
  }

  public static class Builder {
    private Set<Set<Integer>> setOfSetOfInt;
    private List<List<List<List<MyEnum>>>> listofListOfListOfListOfEnum;
    private List<List<MyStruct>> listOfListOfMyStruct;
    private Set<List<List<Long>>> setOfListOfListOfLong;
    private Set<Set<Set<Long>>> setOfSetOfsetOfLong;
    private Map<Integer,List<List<MyStruct>>> mapStructListOfListOfLong;
    private Map<MyStruct,Integer> mKeyStructValInt;
    private List<Map<Integer,Integer>> listOfMapKeyIntValInt;
    private List<Map<String,List<MyStruct>>> listOfMapKeyStrValList;
    private Map<Set<Integer>,Long> mapKeySetValLong;
    private Map<List<String>,Integer> mapKeyListValLong;
    private Map<Map<Integer,String>,Map<Integer,String>> mapKeyMapValMap;
    private Map<Set<List<Integer>>,Map<List<Set<String>>,String>> mapKeySetValMap;
    private Map<Map<Map<Integer,String>,String>,Map<Integer,String>> NestedMaps;
    private Map<Integer,List<MyStruct>> mapKeyIntValList;
    private Map<Integer,Set<Boolean>> mapKeyIntValSet;
    private Map<Set<Boolean>,MyEnum> mapKeySetValInt;
    private Map<List<Integer>,Set<Map<Double,String>>> mapKeyListValSet;

    public Builder() {
    }

    public Builder setSetOfSetOfInt(final Set<Set<Integer>> setOfSetOfInt) {
      this.setOfSetOfInt = setOfSetOfInt;
      return this;
    }

    public Builder setListofListOfListOfListOfEnum(final List<List<List<List<MyEnum>>>> listofListOfListOfListOfEnum) {
      this.listofListOfListOfListOfEnum = listofListOfListOfListOfEnum;
      return this;
    }

    public Builder setListOfListOfMyStruct(final List<List<MyStruct>> listOfListOfMyStruct) {
      this.listOfListOfMyStruct = listOfListOfMyStruct;
      return this;
    }

    public Builder setSetOfListOfListOfLong(final Set<List<List<Long>>> setOfListOfListOfLong) {
      this.setOfListOfListOfLong = setOfListOfListOfLong;
      return this;
    }

    public Builder setSetOfSetOfsetOfLong(final Set<Set<Set<Long>>> setOfSetOfsetOfLong) {
      this.setOfSetOfsetOfLong = setOfSetOfsetOfLong;
      return this;
    }

    public Builder setMapStructListOfListOfLong(final Map<Integer,List<List<MyStruct>>> mapStructListOfListOfLong) {
      this.mapStructListOfListOfLong = mapStructListOfListOfLong;
      return this;
    }

    public Builder setMKeyStructValInt(final Map<MyStruct,Integer> mKeyStructValInt) {
      this.mKeyStructValInt = mKeyStructValInt;
      return this;
    }

    public Builder setListOfMapKeyIntValInt(final List<Map<Integer,Integer>> listOfMapKeyIntValInt) {
      this.listOfMapKeyIntValInt = listOfMapKeyIntValInt;
      return this;
    }

    public Builder setListOfMapKeyStrValList(final List<Map<String,List<MyStruct>>> listOfMapKeyStrValList) {
      this.listOfMapKeyStrValList = listOfMapKeyStrValList;
      return this;
    }

    public Builder setMapKeySetValLong(final Map<Set<Integer>,Long> mapKeySetValLong) {
      this.mapKeySetValLong = mapKeySetValLong;
      return this;
    }

    public Builder setMapKeyListValLong(final Map<List<String>,Integer> mapKeyListValLong) {
      this.mapKeyListValLong = mapKeyListValLong;
      return this;
    }

    public Builder setMapKeyMapValMap(final Map<Map<Integer,String>,Map<Integer,String>> mapKeyMapValMap) {
      this.mapKeyMapValMap = mapKeyMapValMap;
      return this;
    }

    public Builder setMapKeySetValMap(final Map<Set<List<Integer>>,Map<List<Set<String>>,String>> mapKeySetValMap) {
      this.mapKeySetValMap = mapKeySetValMap;
      return this;
    }

    public Builder setNestedMaps(final Map<Map<Map<Integer,String>,String>,Map<Integer,String>> NestedMaps) {
      this.NestedMaps = NestedMaps;
      return this;
    }

    public Builder setMapKeyIntValList(final Map<Integer,List<MyStruct>> mapKeyIntValList) {
      this.mapKeyIntValList = mapKeyIntValList;
      return this;
    }

    public Builder setMapKeyIntValSet(final Map<Integer,Set<Boolean>> mapKeyIntValSet) {
      this.mapKeyIntValSet = mapKeyIntValSet;
      return this;
    }

    public Builder setMapKeySetValInt(final Map<Set<Boolean>,MyEnum> mapKeySetValInt) {
      this.mapKeySetValInt = mapKeySetValInt;
      return this;
    }

    public Builder setMapKeyListValSet(final Map<List<Integer>,Set<Map<Double,String>>> mapKeyListValSet) {
      this.mapKeyListValSet = mapKeyListValSet;
      return this;
    }

    public ComplexNestedStruct build() {
      ComplexNestedStruct result = new ComplexNestedStruct();
      result.setSetOfSetOfInt(this.setOfSetOfInt);
      result.setListofListOfListOfListOfEnum(this.listofListOfListOfListOfEnum);
      result.setListOfListOfMyStruct(this.listOfListOfMyStruct);
      result.setSetOfListOfListOfLong(this.setOfListOfListOfLong);
      result.setSetOfSetOfsetOfLong(this.setOfSetOfsetOfLong);
      result.setMapStructListOfListOfLong(this.mapStructListOfListOfLong);
      result.setMKeyStructValInt(this.mKeyStructValInt);
      result.setListOfMapKeyIntValInt(this.listOfMapKeyIntValInt);
      result.setListOfMapKeyStrValList(this.listOfMapKeyStrValList);
      result.setMapKeySetValLong(this.mapKeySetValLong);
      result.setMapKeyListValLong(this.mapKeyListValLong);
      result.setMapKeyMapValMap(this.mapKeyMapValMap);
      result.setMapKeySetValMap(this.mapKeySetValMap);
      result.setNestedMaps(this.NestedMaps);
      result.setMapKeyIntValList(this.mapKeyIntValList);
      result.setMapKeyIntValSet(this.mapKeyIntValSet);
      result.setMapKeySetValInt(this.mapKeySetValInt);
      result.setMapKeyListValSet(this.mapKeyListValSet);
      return result;
    }
  }

  public static Builder builder() {
    return new Builder();
  }

  /**
   * Performs a deep copy on <i>other</i>.
   */
  public ComplexNestedStruct(ComplexNestedStruct other) {
    if (other.isSetSetOfSetOfInt()) {
      this.setOfSetOfInt = TBaseHelper.deepCopy(other.setOfSetOfInt);
    }
    if (other.isSetListofListOfListOfListOfEnum()) {
      this.listofListOfListOfListOfEnum = TBaseHelper.deepCopy(other.listofListOfListOfListOfEnum);
    }
    if (other.isSetListOfListOfMyStruct()) {
      this.listOfListOfMyStruct = TBaseHelper.deepCopy(other.listOfListOfMyStruct);
    }
    if (other.isSetSetOfListOfListOfLong()) {
      this.setOfListOfListOfLong = TBaseHelper.deepCopy(other.setOfListOfListOfLong);
    }
    if (other.isSetSetOfSetOfsetOfLong()) {
      this.setOfSetOfsetOfLong = TBaseHelper.deepCopy(other.setOfSetOfsetOfLong);
    }
    if (other.isSetMapStructListOfListOfLong()) {
      this.mapStructListOfListOfLong = TBaseHelper.deepCopy(other.mapStructListOfListOfLong);
    }
    if (other.isSetMKeyStructValInt()) {
      this.mKeyStructValInt = TBaseHelper.deepCopy(other.mKeyStructValInt);
    }
    if (other.isSetListOfMapKeyIntValInt()) {
      this.listOfMapKeyIntValInt = TBaseHelper.deepCopy(other.listOfMapKeyIntValInt);
    }
    if (other.isSetListOfMapKeyStrValList()) {
      this.listOfMapKeyStrValList = TBaseHelper.deepCopy(other.listOfMapKeyStrValList);
    }
    if (other.isSetMapKeySetValLong()) {
      this.mapKeySetValLong = TBaseHelper.deepCopy(other.mapKeySetValLong);
    }
    if (other.isSetMapKeyListValLong()) {
      this.mapKeyListValLong = TBaseHelper.deepCopy(other.mapKeyListValLong);
    }
    if (other.isSetMapKeyMapValMap()) {
      this.mapKeyMapValMap = TBaseHelper.deepCopy(other.mapKeyMapValMap);
    }
    if (other.isSetMapKeySetValMap()) {
      this.mapKeySetValMap = TBaseHelper.deepCopy(other.mapKeySetValMap);
    }
    if (other.isSetNestedMaps()) {
      this.NestedMaps = TBaseHelper.deepCopy(other.NestedMaps);
    }
    if (other.isSetMapKeyIntValList()) {
      this.mapKeyIntValList = TBaseHelper.deepCopy(other.mapKeyIntValList);
    }
    if (other.isSetMapKeyIntValSet()) {
      this.mapKeyIntValSet = TBaseHelper.deepCopy(other.mapKeyIntValSet);
    }
    if (other.isSetMapKeySetValInt()) {
      this.mapKeySetValInt = TBaseHelper.deepCopy(other.mapKeySetValInt);
    }
    if (other.isSetMapKeyListValSet()) {
      this.mapKeyListValSet = TBaseHelper.deepCopy(other.mapKeyListValSet);
    }
  }

  public ComplexNestedStruct deepCopy() {
    return new ComplexNestedStruct(this);
  }

  public Set<Set<Integer>> getSetOfSetOfInt() {
    return this.setOfSetOfInt;
  }

  public ComplexNestedStruct setSetOfSetOfInt(Set<Set<Integer>> setOfSetOfInt) {
    this.setOfSetOfInt = setOfSetOfInt;
    return this;
  }

  public void unsetSetOfSetOfInt() {
    this.setOfSetOfInt = null;
  }

  // Returns true if field setOfSetOfInt is set (has been assigned a value) and false otherwise
  public boolean isSetSetOfSetOfInt() {
    return this.setOfSetOfInt != null;
  }

  public void setSetOfSetOfIntIsSet(boolean __value) {
    if (!__value) {
      this.setOfSetOfInt = null;
    }
  }

  public List<List<List<List<MyEnum>>>> getListofListOfListOfListOfEnum() {
    return this.listofListOfListOfListOfEnum;
  }

  public ComplexNestedStruct setListofListOfListOfListOfEnum(List<List<List<List<MyEnum>>>> listofListOfListOfListOfEnum) {
    this.listofListOfListOfListOfEnum = listofListOfListOfListOfEnum;
    return this;
  }

  public void unsetListofListOfListOfListOfEnum() {
    this.listofListOfListOfListOfEnum = null;
  }

  // Returns true if field listofListOfListOfListOfEnum is set (has been assigned a value) and false otherwise
  public boolean isSetListofListOfListOfListOfEnum() {
    return this.listofListOfListOfListOfEnum != null;
  }

  public void setListofListOfListOfListOfEnumIsSet(boolean __value) {
    if (!__value) {
      this.listofListOfListOfListOfEnum = null;
    }
  }

  public List<List<MyStruct>> getListOfListOfMyStruct() {
    return this.listOfListOfMyStruct;
  }

  public ComplexNestedStruct setListOfListOfMyStruct(List<List<MyStruct>> listOfListOfMyStruct) {
    this.listOfListOfMyStruct = listOfListOfMyStruct;
    return this;
  }

  public void unsetListOfListOfMyStruct() {
    this.listOfListOfMyStruct = null;
  }

  // Returns true if field listOfListOfMyStruct is set (has been assigned a value) and false otherwise
  public boolean isSetListOfListOfMyStruct() {
    return this.listOfListOfMyStruct != null;
  }

  public void setListOfListOfMyStructIsSet(boolean __value) {
    if (!__value) {
      this.listOfListOfMyStruct = null;
    }
  }

  public Set<List<List<Long>>> getSetOfListOfListOfLong() {
    return this.setOfListOfListOfLong;
  }

  public ComplexNestedStruct setSetOfListOfListOfLong(Set<List<List<Long>>> setOfListOfListOfLong) {
    this.setOfListOfListOfLong = setOfListOfListOfLong;
    return this;
  }

  public void unsetSetOfListOfListOfLong() {
    this.setOfListOfListOfLong = null;
  }

  // Returns true if field setOfListOfListOfLong is set (has been assigned a value) and false otherwise
  public boolean isSetSetOfListOfListOfLong() {
    return this.setOfListOfListOfLong != null;
  }

  public void setSetOfListOfListOfLongIsSet(boolean __value) {
    if (!__value) {
      this.setOfListOfListOfLong = null;
    }
  }

  public Set<Set<Set<Long>>> getSetOfSetOfsetOfLong() {
    return this.setOfSetOfsetOfLong;
  }

  public ComplexNestedStruct setSetOfSetOfsetOfLong(Set<Set<Set<Long>>> setOfSetOfsetOfLong) {
    this.setOfSetOfsetOfLong = setOfSetOfsetOfLong;
    return this;
  }

  public void unsetSetOfSetOfsetOfLong() {
    this.setOfSetOfsetOfLong = null;
  }

  // Returns true if field setOfSetOfsetOfLong is set (has been assigned a value) and false otherwise
  public boolean isSetSetOfSetOfsetOfLong() {
    return this.setOfSetOfsetOfLong != null;
  }

  public void setSetOfSetOfsetOfLongIsSet(boolean __value) {
    if (!__value) {
      this.setOfSetOfsetOfLong = null;
    }
  }

  public Map<Integer,List<List<MyStruct>>> getMapStructListOfListOfLong() {
    return this.mapStructListOfListOfLong;
  }

  public ComplexNestedStruct setMapStructListOfListOfLong(Map<Integer,List<List<MyStruct>>> mapStructListOfListOfLong) {
    this.mapStructListOfListOfLong = mapStructListOfListOfLong;
    return this;
  }

  public void unsetMapStructListOfListOfLong() {
    this.mapStructListOfListOfLong = null;
  }

  // Returns true if field mapStructListOfListOfLong is set (has been assigned a value) and false otherwise
  public boolean isSetMapStructListOfListOfLong() {
    return this.mapStructListOfListOfLong != null;
  }

  public void setMapStructListOfListOfLongIsSet(boolean __value) {
    if (!__value) {
      this.mapStructListOfListOfLong = null;
    }
  }

  public Map<MyStruct,Integer> getMKeyStructValInt() {
    return this.mKeyStructValInt;
  }

  public ComplexNestedStruct setMKeyStructValInt(Map<MyStruct,Integer> mKeyStructValInt) {
    this.mKeyStructValInt = mKeyStructValInt;
    return this;
  }

  public void unsetMKeyStructValInt() {
    this.mKeyStructValInt = null;
  }

  // Returns true if field mKeyStructValInt is set (has been assigned a value) and false otherwise
  public boolean isSetMKeyStructValInt() {
    return this.mKeyStructValInt != null;
  }

  public void setMKeyStructValIntIsSet(boolean __value) {
    if (!__value) {
      this.mKeyStructValInt = null;
    }
  }

  public List<Map<Integer,Integer>> getListOfMapKeyIntValInt() {
    return this.listOfMapKeyIntValInt;
  }

  public ComplexNestedStruct setListOfMapKeyIntValInt(List<Map<Integer,Integer>> listOfMapKeyIntValInt) {
    this.listOfMapKeyIntValInt = listOfMapKeyIntValInt;
    return this;
  }

  public void unsetListOfMapKeyIntValInt() {
    this.listOfMapKeyIntValInt = null;
  }

  // Returns true if field listOfMapKeyIntValInt is set (has been assigned a value) and false otherwise
  public boolean isSetListOfMapKeyIntValInt() {
    return this.listOfMapKeyIntValInt != null;
  }

  public void setListOfMapKeyIntValIntIsSet(boolean __value) {
    if (!__value) {
      this.listOfMapKeyIntValInt = null;
    }
  }

  public List<Map<String,List<MyStruct>>> getListOfMapKeyStrValList() {
    return this.listOfMapKeyStrValList;
  }

  public ComplexNestedStruct setListOfMapKeyStrValList(List<Map<String,List<MyStruct>>> listOfMapKeyStrValList) {
    this.listOfMapKeyStrValList = listOfMapKeyStrValList;
    return this;
  }

  public void unsetListOfMapKeyStrValList() {
    this.listOfMapKeyStrValList = null;
  }

  // Returns true if field listOfMapKeyStrValList is set (has been assigned a value) and false otherwise
  public boolean isSetListOfMapKeyStrValList() {
    return this.listOfMapKeyStrValList != null;
  }

  public void setListOfMapKeyStrValListIsSet(boolean __value) {
    if (!__value) {
      this.listOfMapKeyStrValList = null;
    }
  }

  public Map<Set<Integer>,Long> getMapKeySetValLong() {
    return this.mapKeySetValLong;
  }

  public ComplexNestedStruct setMapKeySetValLong(Map<Set<Integer>,Long> mapKeySetValLong) {
    this.mapKeySetValLong = mapKeySetValLong;
    return this;
  }

  public void unsetMapKeySetValLong() {
    this.mapKeySetValLong = null;
  }

  // Returns true if field mapKeySetValLong is set (has been assigned a value) and false otherwise
  public boolean isSetMapKeySetValLong() {
    return this.mapKeySetValLong != null;
  }

  public void setMapKeySetValLongIsSet(boolean __value) {
    if (!__value) {
      this.mapKeySetValLong = null;
    }
  }

  public Map<List<String>,Integer> getMapKeyListValLong() {
    return this.mapKeyListValLong;
  }

  public ComplexNestedStruct setMapKeyListValLong(Map<List<String>,Integer> mapKeyListValLong) {
    this.mapKeyListValLong = mapKeyListValLong;
    return this;
  }

  public void unsetMapKeyListValLong() {
    this.mapKeyListValLong = null;
  }

  // Returns true if field mapKeyListValLong is set (has been assigned a value) and false otherwise
  public boolean isSetMapKeyListValLong() {
    return this.mapKeyListValLong != null;
  }

  public void setMapKeyListValLongIsSet(boolean __value) {
    if (!__value) {
      this.mapKeyListValLong = null;
    }
  }

  public Map<Map<Integer,String>,Map<Integer,String>> getMapKeyMapValMap() {
    return this.mapKeyMapValMap;
  }

  public ComplexNestedStruct setMapKeyMapValMap(Map<Map<Integer,String>,Map<Integer,String>> mapKeyMapValMap) {
    this.mapKeyMapValMap = mapKeyMapValMap;
    return this;
  }

  public void unsetMapKeyMapValMap() {
    this.mapKeyMapValMap = null;
  }

  // Returns true if field mapKeyMapValMap is set (has been assigned a value) and false otherwise
  public boolean isSetMapKeyMapValMap() {
    return this.mapKeyMapValMap != null;
  }

  public void setMapKeyMapValMapIsSet(boolean __value) {
    if (!__value) {
      this.mapKeyMapValMap = null;
    }
  }

  public Map<Set<List<Integer>>,Map<List<Set<String>>,String>> getMapKeySetValMap() {
    return this.mapKeySetValMap;
  }

  public ComplexNestedStruct setMapKeySetValMap(Map<Set<List<Integer>>,Map<List<Set<String>>,String>> mapKeySetValMap) {
    this.mapKeySetValMap = mapKeySetValMap;
    return this;
  }

  public void unsetMapKeySetValMap() {
    this.mapKeySetValMap = null;
  }

  // Returns true if field mapKeySetValMap is set (has been assigned a value) and false otherwise
  public boolean isSetMapKeySetValMap() {
    return this.mapKeySetValMap != null;
  }

  public void setMapKeySetValMapIsSet(boolean __value) {
    if (!__value) {
      this.mapKeySetValMap = null;
    }
  }

  public Map<Map<Map<Integer,String>,String>,Map<Integer,String>> getNestedMaps() {
    return this.NestedMaps;
  }

  public ComplexNestedStruct setNestedMaps(Map<Map<Map<Integer,String>,String>,Map<Integer,String>> NestedMaps) {
    this.NestedMaps = NestedMaps;
    return this;
  }

  public void unsetNestedMaps() {
    this.NestedMaps = null;
  }

  // Returns true if field NestedMaps is set (has been assigned a value) and false otherwise
  public boolean isSetNestedMaps() {
    return this.NestedMaps != null;
  }

  public void setNestedMapsIsSet(boolean __value) {
    if (!__value) {
      this.NestedMaps = null;
    }
  }

  public Map<Integer,List<MyStruct>> getMapKeyIntValList() {
    return this.mapKeyIntValList;
  }

  public ComplexNestedStruct setMapKeyIntValList(Map<Integer,List<MyStruct>> mapKeyIntValList) {
    this.mapKeyIntValList = mapKeyIntValList;
    return this;
  }

  public void unsetMapKeyIntValList() {
    this.mapKeyIntValList = null;
  }

  // Returns true if field mapKeyIntValList is set (has been assigned a value) and false otherwise
  public boolean isSetMapKeyIntValList() {
    return this.mapKeyIntValList != null;
  }

  public void setMapKeyIntValListIsSet(boolean __value) {
    if (!__value) {
      this.mapKeyIntValList = null;
    }
  }

  public Map<Integer,Set<Boolean>> getMapKeyIntValSet() {
    return this.mapKeyIntValSet;
  }

  public ComplexNestedStruct setMapKeyIntValSet(Map<Integer,Set<Boolean>> mapKeyIntValSet) {
    this.mapKeyIntValSet = mapKeyIntValSet;
    return this;
  }

  public void unsetMapKeyIntValSet() {
    this.mapKeyIntValSet = null;
  }

  // Returns true if field mapKeyIntValSet is set (has been assigned a value) and false otherwise
  public boolean isSetMapKeyIntValSet() {
    return this.mapKeyIntValSet != null;
  }

  public void setMapKeyIntValSetIsSet(boolean __value) {
    if (!__value) {
      this.mapKeyIntValSet = null;
    }
  }

  public Map<Set<Boolean>,MyEnum> getMapKeySetValInt() {
    return this.mapKeySetValInt;
  }

  public ComplexNestedStruct setMapKeySetValInt(Map<Set<Boolean>,MyEnum> mapKeySetValInt) {
    this.mapKeySetValInt = mapKeySetValInt;
    return this;
  }

  public void unsetMapKeySetValInt() {
    this.mapKeySetValInt = null;
  }

  // Returns true if field mapKeySetValInt is set (has been assigned a value) and false otherwise
  public boolean isSetMapKeySetValInt() {
    return this.mapKeySetValInt != null;
  }

  public void setMapKeySetValIntIsSet(boolean __value) {
    if (!__value) {
      this.mapKeySetValInt = null;
    }
  }

  public Map<List<Integer>,Set<Map<Double,String>>> getMapKeyListValSet() {
    return this.mapKeyListValSet;
  }

  public ComplexNestedStruct setMapKeyListValSet(Map<List<Integer>,Set<Map<Double,String>>> mapKeyListValSet) {
    this.mapKeyListValSet = mapKeyListValSet;
    return this;
  }

  public void unsetMapKeyListValSet() {
    this.mapKeyListValSet = null;
  }

  // Returns true if field mapKeyListValSet is set (has been assigned a value) and false otherwise
  public boolean isSetMapKeyListValSet() {
    return this.mapKeyListValSet != null;
  }

  public void setMapKeyListValSetIsSet(boolean __value) {
    if (!__value) {
      this.mapKeyListValSet = null;
    }
  }

  @SuppressWarnings("unchecked")
  public void setFieldValue(int fieldID, Object __value) {
    switch (fieldID) {
    case SETOFSETOFINT:
      if (__value == null) {
        unsetSetOfSetOfInt();
      } else {
        setSetOfSetOfInt((Set<Set<Integer>>)__value);
      }
      break;

    case LISTOFLISTOFLISTOFLISTOFENUM:
      if (__value == null) {
        unsetListofListOfListOfListOfEnum();
      } else {
        setListofListOfListOfListOfEnum((List<List<List<List<MyEnum>>>>)__value);
      }
      break;

    case LISTOFLISTOFMYSTRUCT:
      if (__value == null) {
        unsetListOfListOfMyStruct();
      } else {
        setListOfListOfMyStruct((List<List<MyStruct>>)__value);
      }
      break;

    case SETOFLISTOFLISTOFLONG:
      if (__value == null) {
        unsetSetOfListOfListOfLong();
      } else {
        setSetOfListOfListOfLong((Set<List<List<Long>>>)__value);
      }
      break;

    case SETOFSETOFSETOFLONG:
      if (__value == null) {
        unsetSetOfSetOfsetOfLong();
      } else {
        setSetOfSetOfsetOfLong((Set<Set<Set<Long>>>)__value);
      }
      break;

    case MAPSTRUCTLISTOFLISTOFLONG:
      if (__value == null) {
        unsetMapStructListOfListOfLong();
      } else {
        setMapStructListOfListOfLong((Map<Integer,List<List<MyStruct>>>)__value);
      }
      break;

    case MKEYSTRUCTVALINT:
      if (__value == null) {
        unsetMKeyStructValInt();
      } else {
        setMKeyStructValInt((Map<MyStruct,Integer>)__value);
      }
      break;

    case LISTOFMAPKEYINTVALINT:
      if (__value == null) {
        unsetListOfMapKeyIntValInt();
      } else {
        setListOfMapKeyIntValInt((List<Map<Integer,Integer>>)__value);
      }
      break;

    case LISTOFMAPKEYSTRVALLIST:
      if (__value == null) {
        unsetListOfMapKeyStrValList();
      } else {
        setListOfMapKeyStrValList((List<Map<String,List<MyStruct>>>)__value);
      }
      break;

    case MAPKEYSETVALLONG:
      if (__value == null) {
        unsetMapKeySetValLong();
      } else {
        setMapKeySetValLong((Map<Set<Integer>,Long>)__value);
      }
      break;

    case MAPKEYLISTVALLONG:
      if (__value == null) {
        unsetMapKeyListValLong();
      } else {
        setMapKeyListValLong((Map<List<String>,Integer>)__value);
      }
      break;

    case MAPKEYMAPVALMAP:
      if (__value == null) {
        unsetMapKeyMapValMap();
      } else {
        setMapKeyMapValMap((Map<Map<Integer,String>,Map<Integer,String>>)__value);
      }
      break;

    case MAPKEYSETVALMAP:
      if (__value == null) {
        unsetMapKeySetValMap();
      } else {
        setMapKeySetValMap((Map<Set<List<Integer>>,Map<List<Set<String>>,String>>)__value);
      }
      break;

    case NESTEDMAPS:
      if (__value == null) {
        unsetNestedMaps();
      } else {
        setNestedMaps((Map<Map<Map<Integer,String>,String>,Map<Integer,String>>)__value);
      }
      break;

    case MAPKEYINTVALLIST:
      if (__value == null) {
        unsetMapKeyIntValList();
      } else {
        setMapKeyIntValList((Map<Integer,List<MyStruct>>)__value);
      }
      break;

    case MAPKEYINTVALSET:
      if (__value == null) {
        unsetMapKeyIntValSet();
      } else {
        setMapKeyIntValSet((Map<Integer,Set<Boolean>>)__value);
      }
      break;

    case MAPKEYSETVALINT:
      if (__value == null) {
        unsetMapKeySetValInt();
      } else {
        setMapKeySetValInt((Map<Set<Boolean>,MyEnum>)__value);
      }
      break;

    case MAPKEYLISTVALSET:
      if (__value == null) {
        unsetMapKeyListValSet();
      } else {
        setMapKeyListValSet((Map<List<Integer>,Set<Map<Double,String>>>)__value);
      }
      break;

    default:
      throw new IllegalArgumentException("Field " + fieldID + " doesn't exist!");
    }
  }

  public Object getFieldValue(int fieldID) {
    switch (fieldID) {
    case SETOFSETOFINT:
      return getSetOfSetOfInt();

    case LISTOFLISTOFLISTOFLISTOFENUM:
      return getListofListOfListOfListOfEnum();

    case LISTOFLISTOFMYSTRUCT:
      return getListOfListOfMyStruct();

    case SETOFLISTOFLISTOFLONG:
      return getSetOfListOfListOfLong();

    case SETOFSETOFSETOFLONG:
      return getSetOfSetOfsetOfLong();

    case MAPSTRUCTLISTOFLISTOFLONG:
      return getMapStructListOfListOfLong();

    case MKEYSTRUCTVALINT:
      return getMKeyStructValInt();

    case LISTOFMAPKEYINTVALINT:
      return getListOfMapKeyIntValInt();

    case LISTOFMAPKEYSTRVALLIST:
      return getListOfMapKeyStrValList();

    case MAPKEYSETVALLONG:
      return getMapKeySetValLong();

    case MAPKEYLISTVALLONG:
      return getMapKeyListValLong();

    case MAPKEYMAPVALMAP:
      return getMapKeyMapValMap();

    case MAPKEYSETVALMAP:
      return getMapKeySetValMap();

    case NESTEDMAPS:
      return getNestedMaps();

    case MAPKEYINTVALLIST:
      return getMapKeyIntValList();

    case MAPKEYINTVALSET:
      return getMapKeyIntValSet();

    case MAPKEYSETVALINT:
      return getMapKeySetValInt();

    case MAPKEYLISTVALSET:
      return getMapKeyListValSet();

    default:
      throw new IllegalArgumentException("Field " + fieldID + " doesn't exist!");
    }
  }

  @Override
  public boolean equals(Object _that) {
    if (_that == null)
      return false;
    if (this == _that)
      return true;
    if (!(_that instanceof ComplexNestedStruct))
      return false;
    ComplexNestedStruct that = (ComplexNestedStruct)_that;

    if (!TBaseHelper.equalsNobinary(this.isSetSetOfSetOfInt(), that.isSetSetOfSetOfInt(), this.setOfSetOfInt, that.setOfSetOfInt)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetListofListOfListOfListOfEnum(), that.isSetListofListOfListOfListOfEnum(), this.listofListOfListOfListOfEnum, that.listofListOfListOfListOfEnum)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetListOfListOfMyStruct(), that.isSetListOfListOfMyStruct(), this.listOfListOfMyStruct, that.listOfListOfMyStruct)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetSetOfListOfListOfLong(), that.isSetSetOfListOfListOfLong(), this.setOfListOfListOfLong, that.setOfListOfListOfLong)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetSetOfSetOfsetOfLong(), that.isSetSetOfSetOfsetOfLong(), this.setOfSetOfsetOfLong, that.setOfSetOfsetOfLong)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMapStructListOfListOfLong(), that.isSetMapStructListOfListOfLong(), this.mapStructListOfListOfLong, that.mapStructListOfListOfLong)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMKeyStructValInt(), that.isSetMKeyStructValInt(), this.mKeyStructValInt, that.mKeyStructValInt)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetListOfMapKeyIntValInt(), that.isSetListOfMapKeyIntValInt(), this.listOfMapKeyIntValInt, that.listOfMapKeyIntValInt)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetListOfMapKeyStrValList(), that.isSetListOfMapKeyStrValList(), this.listOfMapKeyStrValList, that.listOfMapKeyStrValList)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMapKeySetValLong(), that.isSetMapKeySetValLong(), this.mapKeySetValLong, that.mapKeySetValLong)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMapKeyListValLong(), that.isSetMapKeyListValLong(), this.mapKeyListValLong, that.mapKeyListValLong)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMapKeyMapValMap(), that.isSetMapKeyMapValMap(), this.mapKeyMapValMap, that.mapKeyMapValMap)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMapKeySetValMap(), that.isSetMapKeySetValMap(), this.mapKeySetValMap, that.mapKeySetValMap)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetNestedMaps(), that.isSetNestedMaps(), this.NestedMaps, that.NestedMaps)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMapKeyIntValList(), that.isSetMapKeyIntValList(), this.mapKeyIntValList, that.mapKeyIntValList)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMapKeyIntValSet(), that.isSetMapKeyIntValSet(), this.mapKeyIntValSet, that.mapKeyIntValSet)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMapKeySetValInt(), that.isSetMapKeySetValInt(), this.mapKeySetValInt, that.mapKeySetValInt)) { return false; }

    if (!TBaseHelper.equalsNobinary(this.isSetMapKeyListValSet(), that.isSetMapKeyListValSet(), this.mapKeyListValSet, that.mapKeyListValSet)) { return false; }

    return true;
  }

  @Override
  public int hashCode() {
    return Arrays.deepHashCode(new Object[] {setOfSetOfInt, listofListOfListOfListOfEnum, listOfListOfMyStruct, setOfListOfListOfLong, setOfSetOfsetOfLong, mapStructListOfListOfLong, mKeyStructValInt, listOfMapKeyIntValInt, listOfMapKeyStrValList, mapKeySetValLong, mapKeyListValLong, mapKeyMapValMap, mapKeySetValMap, NestedMaps, mapKeyIntValList, mapKeyIntValSet, mapKeySetValInt, mapKeyListValSet});
  }

  public void read(TProtocol iprot) throws TException {
    TField __field;
    iprot.readStructBegin(metaDataMap);
    while (true)
    {
      __field = iprot.readFieldBegin();
      if (__field.type == TType.STOP) {
        break;
      }
      switch (__field.id)
      {
        case SETOFSETOFINT:
          if (__field.type == TType.SET) {
            {
              TSet _set209 = iprot.readSetBegin();
              this.setOfSetOfInt = new HashSet<Set<Integer>>(Math.max(0, 2*_set209.size));
              for (int _i210 = 0; 
                   (_set209.size < 0) ? iprot.peekSet() : (_i210 < _set209.size); 
                   ++_i210)
              {
                Set<Integer> _elem211;
                {
                  TSet _set212 = iprot.readSetBegin();
                  _elem211 = new HashSet<Integer>(Math.max(0, 2*_set212.size));
                  for (int _i213 = 0; 
                       (_set212.size < 0) ? iprot.peekSet() : (_i213 < _set212.size); 
                       ++_i213)
                  {
                    int _elem214;
                    _elem214 = iprot.readI32();
                    _elem211.add(_elem214);
                  }
                  iprot.readSetEnd();
                }
                this.setOfSetOfInt.add(_elem211);
              }
              iprot.readSetEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case LISTOFLISTOFLISTOFLISTOFENUM:
          if (__field.type == TType.LIST) {
            {
              TList _list215 = iprot.readListBegin();
              this.listofListOfListOfListOfEnum = new ArrayList<List<List<List<MyEnum>>>>(Math.max(0, _list215.size));
              for (int _i216 = 0; 
                   (_list215.size < 0) ? iprot.peekList() : (_i216 < _list215.size); 
                   ++_i216)
              {
                List<List<List<MyEnum>>> _elem217;
                {
                  TList _list218 = iprot.readListBegin();
                  _elem217 = new ArrayList<List<List<MyEnum>>>(Math.max(0, _list218.size));
                  for (int _i219 = 0; 
                       (_list218.size < 0) ? iprot.peekList() : (_i219 < _list218.size); 
                       ++_i219)
                  {
                    List<List<MyEnum>> _elem220;
                    {
                      TList _list221 = iprot.readListBegin();
                      _elem220 = new ArrayList<List<MyEnum>>(Math.max(0, _list221.size));
                      for (int _i222 = 0; 
                           (_list221.size < 0) ? iprot.peekList() : (_i222 < _list221.size); 
                           ++_i222)
                      {
                        List<MyEnum> _elem223;
                        {
                          TList _list224 = iprot.readListBegin();
                          _elem223 = new ArrayList<MyEnum>(Math.max(0, _list224.size));
                          for (int _i225 = 0; 
                               (_list224.size < 0) ? iprot.peekList() : (_i225 < _list224.size); 
                               ++_i225)
                          {
                            MyEnum _elem226;
                            _elem226 = MyEnum.findByValue(iprot.readI32());
                            _elem223.add(_elem226);
                          }
                          iprot.readListEnd();
                        }
                        _elem220.add(_elem223);
                      }
                      iprot.readListEnd();
                    }
                    _elem217.add(_elem220);
                  }
                  iprot.readListEnd();
                }
                this.listofListOfListOfListOfEnum.add(_elem217);
              }
              iprot.readListEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case LISTOFLISTOFMYSTRUCT:
          if (__field.type == TType.LIST) {
            {
              TList _list227 = iprot.readListBegin();
              this.listOfListOfMyStruct = new ArrayList<List<MyStruct>>(Math.max(0, _list227.size));
              for (int _i228 = 0; 
                   (_list227.size < 0) ? iprot.peekList() : (_i228 < _list227.size); 
                   ++_i228)
              {
                List<MyStruct> _elem229;
                {
                  TList _list230 = iprot.readListBegin();
                  _elem229 = new ArrayList<MyStruct>(Math.max(0, _list230.size));
                  for (int _i231 = 0; 
                       (_list230.size < 0) ? iprot.peekList() : (_i231 < _list230.size); 
                       ++_i231)
                  {
                    MyStruct _elem232;
                    _elem232 = new MyStruct();
                    _elem232.read(iprot);
                    _elem229.add(_elem232);
                  }
                  iprot.readListEnd();
                }
                this.listOfListOfMyStruct.add(_elem229);
              }
              iprot.readListEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case SETOFLISTOFLISTOFLONG:
          if (__field.type == TType.SET) {
            {
              TSet _set233 = iprot.readSetBegin();
              this.setOfListOfListOfLong = new HashSet<List<List<Long>>>(Math.max(0, 2*_set233.size));
              for (int _i234 = 0; 
                   (_set233.size < 0) ? iprot.peekSet() : (_i234 < _set233.size); 
                   ++_i234)
              {
                List<List<Long>> _elem235;
                {
                  TList _list236 = iprot.readListBegin();
                  _elem235 = new ArrayList<List<Long>>(Math.max(0, _list236.size));
                  for (int _i237 = 0; 
                       (_list236.size < 0) ? iprot.peekList() : (_i237 < _list236.size); 
                       ++_i237)
                  {
                    List<Long> _elem238;
                    {
                      TList _list239 = iprot.readListBegin();
                      _elem238 = new ArrayList<Long>(Math.max(0, _list239.size));
                      for (int _i240 = 0; 
                           (_list239.size < 0) ? iprot.peekList() : (_i240 < _list239.size); 
                           ++_i240)
                      {
                        long _elem241;
                        _elem241 = iprot.readI64();
                        _elem238.add(_elem241);
                      }
                      iprot.readListEnd();
                    }
                    _elem235.add(_elem238);
                  }
                  iprot.readListEnd();
                }
                this.setOfListOfListOfLong.add(_elem235);
              }
              iprot.readSetEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case SETOFSETOFSETOFLONG:
          if (__field.type == TType.SET) {
            {
              TSet _set242 = iprot.readSetBegin();
              this.setOfSetOfsetOfLong = new HashSet<Set<Set<Long>>>(Math.max(0, 2*_set242.size));
              for (int _i243 = 0; 
                   (_set242.size < 0) ? iprot.peekSet() : (_i243 < _set242.size); 
                   ++_i243)
              {
                Set<Set<Long>> _elem244;
                {
                  TSet _set245 = iprot.readSetBegin();
                  _elem244 = new HashSet<Set<Long>>(Math.max(0, 2*_set245.size));
                  for (int _i246 = 0; 
                       (_set245.size < 0) ? iprot.peekSet() : (_i246 < _set245.size); 
                       ++_i246)
                  {
                    Set<Long> _elem247;
                    {
                      TSet _set248 = iprot.readSetBegin();
                      _elem247 = new HashSet<Long>(Math.max(0, 2*_set248.size));
                      for (int _i249 = 0; 
                           (_set248.size < 0) ? iprot.peekSet() : (_i249 < _set248.size); 
                           ++_i249)
                      {
                        long _elem250;
                        _elem250 = iprot.readI64();
                        _elem247.add(_elem250);
                      }
                      iprot.readSetEnd();
                    }
                    _elem244.add(_elem247);
                  }
                  iprot.readSetEnd();
                }
                this.setOfSetOfsetOfLong.add(_elem244);
              }
              iprot.readSetEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MAPSTRUCTLISTOFLISTOFLONG:
          if (__field.type == TType.MAP) {
            {
              TMap _map251 = iprot.readMapBegin();
              this.mapStructListOfListOfLong = new HashMap<Integer,List<List<MyStruct>>>(Math.max(0, 2*_map251.size));
              for (int _i252 = 0; 
                   (_map251.size < 0) ? iprot.peekMap() : (_i252 < _map251.size); 
                   ++_i252)
              {
                int _key253;
                List<List<MyStruct>> _val254;
                _key253 = iprot.readI32();
                {
                  TList _list255 = iprot.readListBegin();
                  _val254 = new ArrayList<List<MyStruct>>(Math.max(0, _list255.size));
                  for (int _i256 = 0; 
                       (_list255.size < 0) ? iprot.peekList() : (_i256 < _list255.size); 
                       ++_i256)
                  {
                    List<MyStruct> _elem257;
                    {
                      TList _list258 = iprot.readListBegin();
                      _elem257 = new ArrayList<MyStruct>(Math.max(0, _list258.size));
                      for (int _i259 = 0; 
                           (_list258.size < 0) ? iprot.peekList() : (_i259 < _list258.size); 
                           ++_i259)
                      {
                        MyStruct _elem260;
                        _elem260 = new MyStruct();
                        _elem260.read(iprot);
                        _elem257.add(_elem260);
                      }
                      iprot.readListEnd();
                    }
                    _val254.add(_elem257);
                  }
                  iprot.readListEnd();
                }
                this.mapStructListOfListOfLong.put(_key253, _val254);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MKEYSTRUCTVALINT:
          if (__field.type == TType.MAP) {
            {
              TMap _map261 = iprot.readMapBegin();
              this.mKeyStructValInt = new HashMap<MyStruct,Integer>(Math.max(0, 2*_map261.size));
              for (int _i262 = 0; 
                   (_map261.size < 0) ? iprot.peekMap() : (_i262 < _map261.size); 
                   ++_i262)
              {
                MyStruct _key263;
                int _val264;
                _key263 = new MyStruct();
                _key263.read(iprot);
                _val264 = iprot.readI32();
                this.mKeyStructValInt.put(_key263, _val264);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case LISTOFMAPKEYINTVALINT:
          if (__field.type == TType.LIST) {
            {
              TList _list265 = iprot.readListBegin();
              this.listOfMapKeyIntValInt = new ArrayList<Map<Integer,Integer>>(Math.max(0, _list265.size));
              for (int _i266 = 0; 
                   (_list265.size < 0) ? iprot.peekList() : (_i266 < _list265.size); 
                   ++_i266)
              {
                Map<Integer,Integer> _elem267;
                {
                  TMap _map268 = iprot.readMapBegin();
                  _elem267 = new HashMap<Integer,Integer>(Math.max(0, 2*_map268.size));
                  for (int _i269 = 0; 
                       (_map268.size < 0) ? iprot.peekMap() : (_i269 < _map268.size); 
                       ++_i269)
                  {
                    int _key270;
                    int _val271;
                    _key270 = iprot.readI32();
                    _val271 = iprot.readI32();
                    _elem267.put(_key270, _val271);
                  }
                  iprot.readMapEnd();
                }
                this.listOfMapKeyIntValInt.add(_elem267);
              }
              iprot.readListEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case LISTOFMAPKEYSTRVALLIST:
          if (__field.type == TType.LIST) {
            {
              TList _list272 = iprot.readListBegin();
              this.listOfMapKeyStrValList = new ArrayList<Map<String,List<MyStruct>>>(Math.max(0, _list272.size));
              for (int _i273 = 0; 
                   (_list272.size < 0) ? iprot.peekList() : (_i273 < _list272.size); 
                   ++_i273)
              {
                Map<String,List<MyStruct>> _elem274;
                {
                  TMap _map275 = iprot.readMapBegin();
                  _elem274 = new HashMap<String,List<MyStruct>>(Math.max(0, 2*_map275.size));
                  for (int _i276 = 0; 
                       (_map275.size < 0) ? iprot.peekMap() : (_i276 < _map275.size); 
                       ++_i276)
                  {
                    String _key277;
                    List<MyStruct> _val278;
                    _key277 = iprot.readString();
                    {
                      TList _list279 = iprot.readListBegin();
                      _val278 = new ArrayList<MyStruct>(Math.max(0, _list279.size));
                      for (int _i280 = 0; 
                           (_list279.size < 0) ? iprot.peekList() : (_i280 < _list279.size); 
                           ++_i280)
                      {
                        MyStruct _elem281;
                        _elem281 = new MyStruct();
                        _elem281.read(iprot);
                        _val278.add(_elem281);
                      }
                      iprot.readListEnd();
                    }
                    _elem274.put(_key277, _val278);
                  }
                  iprot.readMapEnd();
                }
                this.listOfMapKeyStrValList.add(_elem274);
              }
              iprot.readListEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MAPKEYSETVALLONG:
          if (__field.type == TType.MAP) {
            {
              TMap _map282 = iprot.readMapBegin();
              this.mapKeySetValLong = new HashMap<Set<Integer>,Long>(Math.max(0, 2*_map282.size));
              for (int _i283 = 0; 
                   (_map282.size < 0) ? iprot.peekMap() : (_i283 < _map282.size); 
                   ++_i283)
              {
                Set<Integer> _key284;
                long _val285;
                {
                  TSet _set286 = iprot.readSetBegin();
                  _key284 = new HashSet<Integer>(Math.max(0, 2*_set286.size));
                  for (int _i287 = 0; 
                       (_set286.size < 0) ? iprot.peekSet() : (_i287 < _set286.size); 
                       ++_i287)
                  {
                    int _elem288;
                    _elem288 = iprot.readI32();
                    _key284.add(_elem288);
                  }
                  iprot.readSetEnd();
                }
                _val285 = iprot.readI64();
                this.mapKeySetValLong.put(_key284, _val285);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MAPKEYLISTVALLONG:
          if (__field.type == TType.MAP) {
            {
              TMap _map289 = iprot.readMapBegin();
              this.mapKeyListValLong = new HashMap<List<String>,Integer>(Math.max(0, 2*_map289.size));
              for (int _i290 = 0; 
                   (_map289.size < 0) ? iprot.peekMap() : (_i290 < _map289.size); 
                   ++_i290)
              {
                List<String> _key291;
                int _val292;
                {
                  TList _list293 = iprot.readListBegin();
                  _key291 = new ArrayList<String>(Math.max(0, _list293.size));
                  for (int _i294 = 0; 
                       (_list293.size < 0) ? iprot.peekList() : (_i294 < _list293.size); 
                       ++_i294)
                  {
                    String _elem295;
                    _elem295 = iprot.readString();
                    _key291.add(_elem295);
                  }
                  iprot.readListEnd();
                }
                _val292 = iprot.readI32();
                this.mapKeyListValLong.put(_key291, _val292);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MAPKEYMAPVALMAP:
          if (__field.type == TType.MAP) {
            {
              TMap _map296 = iprot.readMapBegin();
              this.mapKeyMapValMap = new HashMap<Map<Integer,String>,Map<Integer,String>>(Math.max(0, 2*_map296.size));
              for (int _i297 = 0; 
                   (_map296.size < 0) ? iprot.peekMap() : (_i297 < _map296.size); 
                   ++_i297)
              {
                Map<Integer,String> _key298;
                Map<Integer,String> _val299;
                {
                  TMap _map300 = iprot.readMapBegin();
                  _key298 = new HashMap<Integer,String>(Math.max(0, 2*_map300.size));
                  for (int _i301 = 0; 
                       (_map300.size < 0) ? iprot.peekMap() : (_i301 < _map300.size); 
                       ++_i301)
                  {
                    int _key302;
                    String _val303;
                    _key302 = iprot.readI32();
                    _val303 = iprot.readString();
                    _key298.put(_key302, _val303);
                  }
                  iprot.readMapEnd();
                }
                {
                  TMap _map304 = iprot.readMapBegin();
                  _val299 = new HashMap<Integer,String>(Math.max(0, 2*_map304.size));
                  for (int _i305 = 0; 
                       (_map304.size < 0) ? iprot.peekMap() : (_i305 < _map304.size); 
                       ++_i305)
                  {
                    int _key306;
                    String _val307;
                    _key306 = iprot.readI32();
                    _val307 = iprot.readString();
                    _val299.put(_key306, _val307);
                  }
                  iprot.readMapEnd();
                }
                this.mapKeyMapValMap.put(_key298, _val299);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MAPKEYSETVALMAP:
          if (__field.type == TType.MAP) {
            {
              TMap _map308 = iprot.readMapBegin();
              this.mapKeySetValMap = new HashMap<Set<List<Integer>>,Map<List<Set<String>>,String>>(Math.max(0, 2*_map308.size));
              for (int _i309 = 0; 
                   (_map308.size < 0) ? iprot.peekMap() : (_i309 < _map308.size); 
                   ++_i309)
              {
                Set<List<Integer>> _key310;
                Map<List<Set<String>>,String> _val311;
                {
                  TSet _set312 = iprot.readSetBegin();
                  _key310 = new HashSet<List<Integer>>(Math.max(0, 2*_set312.size));
                  for (int _i313 = 0; 
                       (_set312.size < 0) ? iprot.peekSet() : (_i313 < _set312.size); 
                       ++_i313)
                  {
                    List<Integer> _elem314;
                    {
                      TList _list315 = iprot.readListBegin();
                      _elem314 = new ArrayList<Integer>(Math.max(0, _list315.size));
                      for (int _i316 = 0; 
                           (_list315.size < 0) ? iprot.peekList() : (_i316 < _list315.size); 
                           ++_i316)
                      {
                        int _elem317;
                        _elem317 = iprot.readI32();
                        _elem314.add(_elem317);
                      }
                      iprot.readListEnd();
                    }
                    _key310.add(_elem314);
                  }
                  iprot.readSetEnd();
                }
                {
                  TMap _map318 = iprot.readMapBegin();
                  _val311 = new HashMap<List<Set<String>>,String>(Math.max(0, 2*_map318.size));
                  for (int _i319 = 0; 
                       (_map318.size < 0) ? iprot.peekMap() : (_i319 < _map318.size); 
                       ++_i319)
                  {
                    List<Set<String>> _key320;
                    String _val321;
                    {
                      TList _list322 = iprot.readListBegin();
                      _key320 = new ArrayList<Set<String>>(Math.max(0, _list322.size));
                      for (int _i323 = 0; 
                           (_list322.size < 0) ? iprot.peekList() : (_i323 < _list322.size); 
                           ++_i323)
                      {
                        Set<String> _elem324;
                        {
                          TSet _set325 = iprot.readSetBegin();
                          _elem324 = new HashSet<String>(Math.max(0, 2*_set325.size));
                          for (int _i326 = 0; 
                               (_set325.size < 0) ? iprot.peekSet() : (_i326 < _set325.size); 
                               ++_i326)
                          {
                            String _elem327;
                            _elem327 = iprot.readString();
                            _elem324.add(_elem327);
                          }
                          iprot.readSetEnd();
                        }
                        _key320.add(_elem324);
                      }
                      iprot.readListEnd();
                    }
                    _val321 = iprot.readString();
                    _val311.put(_key320, _val321);
                  }
                  iprot.readMapEnd();
                }
                this.mapKeySetValMap.put(_key310, _val311);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case NESTEDMAPS:
          if (__field.type == TType.MAP) {
            {
              TMap _map328 = iprot.readMapBegin();
              this.NestedMaps = new HashMap<Map<Map<Integer,String>,String>,Map<Integer,String>>(Math.max(0, 2*_map328.size));
              for (int _i329 = 0; 
                   (_map328.size < 0) ? iprot.peekMap() : (_i329 < _map328.size); 
                   ++_i329)
              {
                Map<Map<Integer,String>,String> _key330;
                Map<Integer,String> _val331;
                {
                  TMap _map332 = iprot.readMapBegin();
                  _key330 = new HashMap<Map<Integer,String>,String>(Math.max(0, 2*_map332.size));
                  for (int _i333 = 0; 
                       (_map332.size < 0) ? iprot.peekMap() : (_i333 < _map332.size); 
                       ++_i333)
                  {
                    Map<Integer,String> _key334;
                    String _val335;
                    {
                      TMap _map336 = iprot.readMapBegin();
                      _key334 = new HashMap<Integer,String>(Math.max(0, 2*_map336.size));
                      for (int _i337 = 0; 
                           (_map336.size < 0) ? iprot.peekMap() : (_i337 < _map336.size); 
                           ++_i337)
                      {
                        int _key338;
                        String _val339;
                        _key338 = iprot.readI32();
                        _val339 = iprot.readString();
                        _key334.put(_key338, _val339);
                      }
                      iprot.readMapEnd();
                    }
                    _val335 = iprot.readString();
                    _key330.put(_key334, _val335);
                  }
                  iprot.readMapEnd();
                }
                {
                  TMap _map340 = iprot.readMapBegin();
                  _val331 = new HashMap<Integer,String>(Math.max(0, 2*_map340.size));
                  for (int _i341 = 0; 
                       (_map340.size < 0) ? iprot.peekMap() : (_i341 < _map340.size); 
                       ++_i341)
                  {
                    int _key342;
                    String _val343;
                    _key342 = iprot.readI32();
                    _val343 = iprot.readString();
                    _val331.put(_key342, _val343);
                  }
                  iprot.readMapEnd();
                }
                this.NestedMaps.put(_key330, _val331);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MAPKEYINTVALLIST:
          if (__field.type == TType.MAP) {
            {
              TMap _map344 = iprot.readMapBegin();
              this.mapKeyIntValList = new HashMap<Integer,List<MyStruct>>(Math.max(0, 2*_map344.size));
              for (int _i345 = 0; 
                   (_map344.size < 0) ? iprot.peekMap() : (_i345 < _map344.size); 
                   ++_i345)
              {
                int _key346;
                List<MyStruct> _val347;
                _key346 = iprot.readI32();
                {
                  TList _list348 = iprot.readListBegin();
                  _val347 = new ArrayList<MyStruct>(Math.max(0, _list348.size));
                  for (int _i349 = 0; 
                       (_list348.size < 0) ? iprot.peekList() : (_i349 < _list348.size); 
                       ++_i349)
                  {
                    MyStruct _elem350;
                    _elem350 = new MyStruct();
                    _elem350.read(iprot);
                    _val347.add(_elem350);
                  }
                  iprot.readListEnd();
                }
                this.mapKeyIntValList.put(_key346, _val347);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MAPKEYINTVALSET:
          if (__field.type == TType.MAP) {
            {
              TMap _map351 = iprot.readMapBegin();
              this.mapKeyIntValSet = new HashMap<Integer,Set<Boolean>>(Math.max(0, 2*_map351.size));
              for (int _i352 = 0; 
                   (_map351.size < 0) ? iprot.peekMap() : (_i352 < _map351.size); 
                   ++_i352)
              {
                int _key353;
                Set<Boolean> _val354;
                _key353 = iprot.readI32();
                {
                  TSet _set355 = iprot.readSetBegin();
                  _val354 = new HashSet<Boolean>(Math.max(0, 2*_set355.size));
                  for (int _i356 = 0; 
                       (_set355.size < 0) ? iprot.peekSet() : (_i356 < _set355.size); 
                       ++_i356)
                  {
                    boolean _elem357;
                    _elem357 = iprot.readBool();
                    _val354.add(_elem357);
                  }
                  iprot.readSetEnd();
                }
                this.mapKeyIntValSet.put(_key353, _val354);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MAPKEYSETVALINT:
          if (__field.type == TType.MAP) {
            {
              TMap _map358 = iprot.readMapBegin();
              this.mapKeySetValInt = new HashMap<Set<Boolean>,MyEnum>(Math.max(0, 2*_map358.size));
              for (int _i359 = 0; 
                   (_map358.size < 0) ? iprot.peekMap() : (_i359 < _map358.size); 
                   ++_i359)
              {
                Set<Boolean> _key360;
                MyEnum _val361;
                {
                  TSet _set362 = iprot.readSetBegin();
                  _key360 = new HashSet<Boolean>(Math.max(0, 2*_set362.size));
                  for (int _i363 = 0; 
                       (_set362.size < 0) ? iprot.peekSet() : (_i363 < _set362.size); 
                       ++_i363)
                  {
                    boolean _elem364;
                    _elem364 = iprot.readBool();
                    _key360.add(_elem364);
                  }
                  iprot.readSetEnd();
                }
                _val361 = MyEnum.findByValue(iprot.readI32());
                this.mapKeySetValInt.put(_key360, _val361);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        case MAPKEYLISTVALSET:
          if (__field.type == TType.MAP) {
            {
              TMap _map365 = iprot.readMapBegin();
              this.mapKeyListValSet = new HashMap<List<Integer>,Set<Map<Double,String>>>(Math.max(0, 2*_map365.size));
              for (int _i366 = 0; 
                   (_map365.size < 0) ? iprot.peekMap() : (_i366 < _map365.size); 
                   ++_i366)
              {
                List<Integer> _key367;
                Set<Map<Double,String>> _val368;
                {
                  TList _list369 = iprot.readListBegin();
                  _key367 = new ArrayList<Integer>(Math.max(0, _list369.size));
                  for (int _i370 = 0; 
                       (_list369.size < 0) ? iprot.peekList() : (_i370 < _list369.size); 
                       ++_i370)
                  {
                    int _elem371;
                    _elem371 = iprot.readI32();
                    _key367.add(_elem371);
                  }
                  iprot.readListEnd();
                }
                {
                  TSet _set372 = iprot.readSetBegin();
                  _val368 = new HashSet<Map<Double,String>>(Math.max(0, 2*_set372.size));
                  for (int _i373 = 0; 
                       (_set372.size < 0) ? iprot.peekSet() : (_i373 < _set372.size); 
                       ++_i373)
                  {
                    Map<Double,String> _elem374;
                    {
                      TMap _map375 = iprot.readMapBegin();
                      _elem374 = new HashMap<Double,String>(Math.max(0, 2*_map375.size));
                      for (int _i376 = 0; 
                           (_map375.size < 0) ? iprot.peekMap() : (_i376 < _map375.size); 
                           ++_i376)
                      {
                        double _key377;
                        String _val378;
                        _key377 = iprot.readDouble();
                        _val378 = iprot.readString();
                        _elem374.put(_key377, _val378);
                      }
                      iprot.readMapEnd();
                    }
                    _val368.add(_elem374);
                  }
                  iprot.readSetEnd();
                }
                this.mapKeyListValSet.put(_key367, _val368);
              }
              iprot.readMapEnd();
            }
          } else {
            TProtocolUtil.skip(iprot, __field.type);
          }
          break;
        default:
          TProtocolUtil.skip(iprot, __field.type);
          break;
      }
      iprot.readFieldEnd();
    }
    iprot.readStructEnd();


    // check for required fields of primitive type, which can't be checked in the validate method
    validate();
  }

  public void write(TProtocol oprot) throws TException {
    validate();

    oprot.writeStructBegin(STRUCT_DESC);
    if (this.setOfSetOfInt != null) {
      oprot.writeFieldBegin(SET_OF_SET_OF_INT_FIELD_DESC);
      {
        oprot.writeSetBegin(new TSet(TType.SET, this.setOfSetOfInt.size()));
        for (Set<Integer> _iter379 : this.setOfSetOfInt)        {
          {
            oprot.writeSetBegin(new TSet(TType.I32, _iter379.size()));
            for (int _iter380 : _iter379)            {
              oprot.writeI32(_iter380);
            }
            oprot.writeSetEnd();
          }
        }
        oprot.writeSetEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.listofListOfListOfListOfEnum != null) {
      oprot.writeFieldBegin(LISTOF_LIST_OF_LIST_OF_LIST_OF_ENUM_FIELD_DESC);
      {
        oprot.writeListBegin(new TList(TType.LIST, this.listofListOfListOfListOfEnum.size()));
        for (List<List<List<MyEnum>>> _iter381 : this.listofListOfListOfListOfEnum)        {
          {
            oprot.writeListBegin(new TList(TType.LIST, _iter381.size()));
            for (List<List<MyEnum>> _iter382 : _iter381)            {
              {
                oprot.writeListBegin(new TList(TType.LIST, _iter382.size()));
                for (List<MyEnum> _iter383 : _iter382)                {
                  {
                    oprot.writeListBegin(new TList(TType.I32, _iter383.size()));
                    for (MyEnum _iter384 : _iter383)                    {
                      oprot.writeI32(_iter384 == null ? 0 : _iter384.getValue());
                    }
                    oprot.writeListEnd();
                  }
                }
                oprot.writeListEnd();
              }
            }
            oprot.writeListEnd();
          }
        }
        oprot.writeListEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.listOfListOfMyStruct != null) {
      oprot.writeFieldBegin(LIST_OF_LIST_OF_MY_STRUCT_FIELD_DESC);
      {
        oprot.writeListBegin(new TList(TType.LIST, this.listOfListOfMyStruct.size()));
        for (List<MyStruct> _iter385 : this.listOfListOfMyStruct)        {
          {
            oprot.writeListBegin(new TList(TType.STRUCT, _iter385.size()));
            for (MyStruct _iter386 : _iter385)            {
              _iter386.write(oprot);
            }
            oprot.writeListEnd();
          }
        }
        oprot.writeListEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.setOfListOfListOfLong != null) {
      oprot.writeFieldBegin(SET_OF_LIST_OF_LIST_OF_LONG_FIELD_DESC);
      {
        oprot.writeSetBegin(new TSet(TType.LIST, this.setOfListOfListOfLong.size()));
        for (List<List<Long>> _iter387 : this.setOfListOfListOfLong)        {
          {
            oprot.writeListBegin(new TList(TType.LIST, _iter387.size()));
            for (List<Long> _iter388 : _iter387)            {
              {
                oprot.writeListBegin(new TList(TType.I64, _iter388.size()));
                for (long _iter389 : _iter388)                {
                  oprot.writeI64(_iter389);
                }
                oprot.writeListEnd();
              }
            }
            oprot.writeListEnd();
          }
        }
        oprot.writeSetEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.setOfSetOfsetOfLong != null) {
      oprot.writeFieldBegin(SET_OF_SET_OFSET_OF_LONG_FIELD_DESC);
      {
        oprot.writeSetBegin(new TSet(TType.SET, this.setOfSetOfsetOfLong.size()));
        for (Set<Set<Long>> _iter390 : this.setOfSetOfsetOfLong)        {
          {
            oprot.writeSetBegin(new TSet(TType.SET, _iter390.size()));
            for (Set<Long> _iter391 : _iter390)            {
              {
                oprot.writeSetBegin(new TSet(TType.I64, _iter391.size()));
                for (long _iter392 : _iter391)                {
                  oprot.writeI64(_iter392);
                }
                oprot.writeSetEnd();
              }
            }
            oprot.writeSetEnd();
          }
        }
        oprot.writeSetEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mapStructListOfListOfLong != null) {
      oprot.writeFieldBegin(MAP_STRUCT_LIST_OF_LIST_OF_LONG_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.I32, TType.LIST, this.mapStructListOfListOfLong.size()));
        for (Map.Entry<Integer, List<List<MyStruct>>> _iter393 : this.mapStructListOfListOfLong.entrySet())        {
          oprot.writeI32(_iter393.getKey());
          {
            oprot.writeListBegin(new TList(TType.LIST, _iter393.getValue().size()));
            for (List<MyStruct> _iter394 : _iter393.getValue())            {
              {
                oprot.writeListBegin(new TList(TType.STRUCT, _iter394.size()));
                for (MyStruct _iter395 : _iter394)                {
                  _iter395.write(oprot);
                }
                oprot.writeListEnd();
              }
            }
            oprot.writeListEnd();
          }
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mKeyStructValInt != null) {
      oprot.writeFieldBegin(M_KEY_STRUCT_VAL_INT_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.STRUCT, TType.I32, this.mKeyStructValInt.size()));
        for (Map.Entry<MyStruct, Integer> _iter396 : this.mKeyStructValInt.entrySet())        {
          _iter396.getKey().write(oprot);
          oprot.writeI32(_iter396.getValue());
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.listOfMapKeyIntValInt != null) {
      oprot.writeFieldBegin(LIST_OF_MAP_KEY_INT_VAL_INT_FIELD_DESC);
      {
        oprot.writeListBegin(new TList(TType.MAP, this.listOfMapKeyIntValInt.size()));
        for (Map<Integer,Integer> _iter397 : this.listOfMapKeyIntValInt)        {
          {
            oprot.writeMapBegin(new TMap(TType.I32, TType.I32, _iter397.size()));
            for (Map.Entry<Integer, Integer> _iter398 : _iter397.entrySet())            {
              oprot.writeI32(_iter398.getKey());
              oprot.writeI32(_iter398.getValue());
            }
            oprot.writeMapEnd();
          }
        }
        oprot.writeListEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.listOfMapKeyStrValList != null) {
      oprot.writeFieldBegin(LIST_OF_MAP_KEY_STR_VAL_LIST_FIELD_DESC);
      {
        oprot.writeListBegin(new TList(TType.MAP, this.listOfMapKeyStrValList.size()));
        for (Map<String,List<MyStruct>> _iter399 : this.listOfMapKeyStrValList)        {
          {
            oprot.writeMapBegin(new TMap(TType.STRING, TType.LIST, _iter399.size()));
            for (Map.Entry<String, List<MyStruct>> _iter400 : _iter399.entrySet())            {
              oprot.writeString(_iter400.getKey());
              {
                oprot.writeListBegin(new TList(TType.STRUCT, _iter400.getValue().size()));
                for (MyStruct _iter401 : _iter400.getValue())                {
                  _iter401.write(oprot);
                }
                oprot.writeListEnd();
              }
            }
            oprot.writeMapEnd();
          }
        }
        oprot.writeListEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mapKeySetValLong != null) {
      oprot.writeFieldBegin(MAP_KEY_SET_VAL_LONG_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.SET, TType.I64, this.mapKeySetValLong.size()));
        for (Map.Entry<Set<Integer>, Long> _iter402 : this.mapKeySetValLong.entrySet())        {
          {
            oprot.writeSetBegin(new TSet(TType.I32, _iter402.getKey().size()));
            for (int _iter403 : _iter402.getKey())            {
              oprot.writeI32(_iter403);
            }
            oprot.writeSetEnd();
          }
          oprot.writeI64(_iter402.getValue());
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mapKeyListValLong != null) {
      oprot.writeFieldBegin(MAP_KEY_LIST_VAL_LONG_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.LIST, TType.I32, this.mapKeyListValLong.size()));
        for (Map.Entry<List<String>, Integer> _iter404 : this.mapKeyListValLong.entrySet())        {
          {
            oprot.writeListBegin(new TList(TType.STRING, _iter404.getKey().size()));
            for (String _iter405 : _iter404.getKey())            {
              oprot.writeString(_iter405);
            }
            oprot.writeListEnd();
          }
          oprot.writeI32(_iter404.getValue());
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mapKeyMapValMap != null) {
      oprot.writeFieldBegin(MAP_KEY_MAP_VAL_MAP_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.MAP, TType.MAP, this.mapKeyMapValMap.size()));
        for (Map.Entry<Map<Integer,String>, Map<Integer,String>> _iter406 : this.mapKeyMapValMap.entrySet())        {
          {
            oprot.writeMapBegin(new TMap(TType.I32, TType.STRING, _iter406.getKey().size()));
            for (Map.Entry<Integer, String> _iter407 : _iter406.getKey().entrySet())            {
              oprot.writeI32(_iter407.getKey());
              oprot.writeString(_iter407.getValue());
            }
            oprot.writeMapEnd();
          }
          {
            oprot.writeMapBegin(new TMap(TType.I32, TType.STRING, _iter406.getValue().size()));
            for (Map.Entry<Integer, String> _iter408 : _iter406.getValue().entrySet())            {
              oprot.writeI32(_iter408.getKey());
              oprot.writeString(_iter408.getValue());
            }
            oprot.writeMapEnd();
          }
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mapKeySetValMap != null) {
      oprot.writeFieldBegin(MAP_KEY_SET_VAL_MAP_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.SET, TType.MAP, this.mapKeySetValMap.size()));
        for (Map.Entry<Set<List<Integer>>, Map<List<Set<String>>,String>> _iter409 : this.mapKeySetValMap.entrySet())        {
          {
            oprot.writeSetBegin(new TSet(TType.LIST, _iter409.getKey().size()));
            for (List<Integer> _iter410 : _iter409.getKey())            {
              {
                oprot.writeListBegin(new TList(TType.I32, _iter410.size()));
                for (int _iter411 : _iter410)                {
                  oprot.writeI32(_iter411);
                }
                oprot.writeListEnd();
              }
            }
            oprot.writeSetEnd();
          }
          {
            oprot.writeMapBegin(new TMap(TType.LIST, TType.STRING, _iter409.getValue().size()));
            for (Map.Entry<List<Set<String>>, String> _iter412 : _iter409.getValue().entrySet())            {
              {
                oprot.writeListBegin(new TList(TType.SET, _iter412.getKey().size()));
                for (Set<String> _iter413 : _iter412.getKey())                {
                  {
                    oprot.writeSetBegin(new TSet(TType.STRING, _iter413.size()));
                    for (String _iter414 : _iter413)                    {
                      oprot.writeString(_iter414);
                    }
                    oprot.writeSetEnd();
                  }
                }
                oprot.writeListEnd();
              }
              oprot.writeString(_iter412.getValue());
            }
            oprot.writeMapEnd();
          }
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.NestedMaps != null) {
      oprot.writeFieldBegin(NESTED_MAPS_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.MAP, TType.MAP, this.NestedMaps.size()));
        for (Map.Entry<Map<Map<Integer,String>,String>, Map<Integer,String>> _iter415 : this.NestedMaps.entrySet())        {
          {
            oprot.writeMapBegin(new TMap(TType.MAP, TType.STRING, _iter415.getKey().size()));
            for (Map.Entry<Map<Integer,String>, String> _iter416 : _iter415.getKey().entrySet())            {
              {
                oprot.writeMapBegin(new TMap(TType.I32, TType.STRING, _iter416.getKey().size()));
                for (Map.Entry<Integer, String> _iter417 : _iter416.getKey().entrySet())                {
                  oprot.writeI32(_iter417.getKey());
                  oprot.writeString(_iter417.getValue());
                }
                oprot.writeMapEnd();
              }
              oprot.writeString(_iter416.getValue());
            }
            oprot.writeMapEnd();
          }
          {
            oprot.writeMapBegin(new TMap(TType.I32, TType.STRING, _iter415.getValue().size()));
            for (Map.Entry<Integer, String> _iter418 : _iter415.getValue().entrySet())            {
              oprot.writeI32(_iter418.getKey());
              oprot.writeString(_iter418.getValue());
            }
            oprot.writeMapEnd();
          }
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mapKeyIntValList != null) {
      oprot.writeFieldBegin(MAP_KEY_INT_VAL_LIST_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.I32, TType.LIST, this.mapKeyIntValList.size()));
        for (Map.Entry<Integer, List<MyStruct>> _iter419 : this.mapKeyIntValList.entrySet())        {
          oprot.writeI32(_iter419.getKey());
          {
            oprot.writeListBegin(new TList(TType.STRUCT, _iter419.getValue().size()));
            for (MyStruct _iter420 : _iter419.getValue())            {
              _iter420.write(oprot);
            }
            oprot.writeListEnd();
          }
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mapKeyIntValSet != null) {
      oprot.writeFieldBegin(MAP_KEY_INT_VAL_SET_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.I32, TType.SET, this.mapKeyIntValSet.size()));
        for (Map.Entry<Integer, Set<Boolean>> _iter421 : this.mapKeyIntValSet.entrySet())        {
          oprot.writeI32(_iter421.getKey());
          {
            oprot.writeSetBegin(new TSet(TType.BOOL, _iter421.getValue().size()));
            for (boolean _iter422 : _iter421.getValue())            {
              oprot.writeBool(_iter422);
            }
            oprot.writeSetEnd();
          }
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mapKeySetValInt != null) {
      oprot.writeFieldBegin(MAP_KEY_SET_VAL_INT_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.SET, TType.I32, this.mapKeySetValInt.size()));
        for (Map.Entry<Set<Boolean>, MyEnum> _iter423 : this.mapKeySetValInt.entrySet())        {
          {
            oprot.writeSetBegin(new TSet(TType.BOOL, _iter423.getKey().size()));
            for (boolean _iter424 : _iter423.getKey())            {
              oprot.writeBool(_iter424);
            }
            oprot.writeSetEnd();
          }
          oprot.writeI32(_iter423.getValue() == null ? 0 : _iter423.getValue().getValue());
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    if (this.mapKeyListValSet != null) {
      oprot.writeFieldBegin(MAP_KEY_LIST_VAL_SET_FIELD_DESC);
      {
        oprot.writeMapBegin(new TMap(TType.LIST, TType.SET, this.mapKeyListValSet.size()));
        for (Map.Entry<List<Integer>, Set<Map<Double,String>>> _iter425 : this.mapKeyListValSet.entrySet())        {
          {
            oprot.writeListBegin(new TList(TType.I32, _iter425.getKey().size()));
            for (int _iter426 : _iter425.getKey())            {
              oprot.writeI32(_iter426);
            }
            oprot.writeListEnd();
          }
          {
            oprot.writeSetBegin(new TSet(TType.MAP, _iter425.getValue().size()));
            for (Map<Double,String> _iter427 : _iter425.getValue())            {
              {
                oprot.writeMapBegin(new TMap(TType.DOUBLE, TType.STRING, _iter427.size()));
                for (Map.Entry<Double, String> _iter428 : _iter427.entrySet())                {
                  oprot.writeDouble(_iter428.getKey());
                  oprot.writeString(_iter428.getValue());
                }
                oprot.writeMapEnd();
              }
            }
            oprot.writeSetEnd();
          }
        }
        oprot.writeMapEnd();
      }
      oprot.writeFieldEnd();
    }
    oprot.writeFieldStop();
    oprot.writeStructEnd();
  }

  @Override
  public String toString() {
    return toString(1, true);
  }

  @Override
  public String toString(int indent, boolean prettyPrint) {
    String indentStr = prettyPrint ? TBaseHelper.getIndentedString(indent) : "";
    String newLine = prettyPrint ? "\n" : "";
    String space = prettyPrint ? " " : "";
    StringBuilder sb = new StringBuilder("ComplexNestedStruct");
    sb.append(space);
    sb.append("(");
    sb.append(newLine);
    boolean first = true;

    sb.append(indentStr);
    sb.append("setOfSetOfInt");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getSetOfSetOfInt() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getSetOfSetOfInt(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("listofListOfListOfListOfEnum");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getListofListOfListOfListOfEnum() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getListofListOfListOfListOfEnum(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("listOfListOfMyStruct");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getListOfListOfMyStruct() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getListOfListOfMyStruct(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("setOfListOfListOfLong");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getSetOfListOfListOfLong() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getSetOfListOfListOfLong(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("setOfSetOfsetOfLong");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getSetOfSetOfsetOfLong() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getSetOfSetOfsetOfLong(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mapStructListOfListOfLong");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMapStructListOfListOfLong() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMapStructListOfListOfLong(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mKeyStructValInt");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMKeyStructValInt() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMKeyStructValInt(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("listOfMapKeyIntValInt");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getListOfMapKeyIntValInt() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getListOfMapKeyIntValInt(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("listOfMapKeyStrValList");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getListOfMapKeyStrValList() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getListOfMapKeyStrValList(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mapKeySetValLong");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMapKeySetValLong() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMapKeySetValLong(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mapKeyListValLong");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMapKeyListValLong() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMapKeyListValLong(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mapKeyMapValMap");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMapKeyMapValMap() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMapKeyMapValMap(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mapKeySetValMap");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMapKeySetValMap() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMapKeySetValMap(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("NestedMaps");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getNestedMaps() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getNestedMaps(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mapKeyIntValList");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMapKeyIntValList() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMapKeyIntValList(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mapKeyIntValSet");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMapKeyIntValSet() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMapKeyIntValSet(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mapKeySetValInt");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMapKeySetValInt() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMapKeySetValInt(), indent + 1, prettyPrint));
    }
    first = false;
    if (!first) sb.append("," + newLine);
    sb.append(indentStr);
    sb.append("mapKeyListValSet");
    sb.append(space);
    sb.append(":").append(space);
    if (this.getMapKeyListValSet() == null) {
      sb.append("null");
    } else {
      sb.append(TBaseHelper.toString(this.getMapKeyListValSet(), indent + 1, prettyPrint));
    }
    first = false;
    sb.append(newLine + TBaseHelper.reduceIndent(indentStr));
    sb.append(")");
    return sb.toString();
  }

  public void validate() throws TException {
    // check for required fields
  }

}