/**
 * Autogenerated by Thrift Compiler (0.14.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using Microsoft.Extensions.Logging;
using Thrift;
using Thrift.Collections;
using System.ServiceModel;
using System.Runtime.Serialization;

using Thrift.Protocol;
using Thrift.Protocol.Entities;
using Thrift.Protocol.Utilities;
using Thrift.Transport;
using Thrift.Transport.Client;
using Thrift.Transport.Server;
using Thrift.Processor;


#pragma warning disable IDE0079  // remove unnecessary pragmas
#pragma warning disable IDE1006  // parts of the code use IDL spelling

namespace OptReqDefTest
{

  [DataContract(Namespace="")]
  public partial class RaceDetails : TBase
  {
    private global::OptReqDefTest.Distance _opt_one;
    private double _opt_two;
    private short _opt_three;
    private string _opt_four;
    private byte[] _opt_five;
    private List<int> _opt_six;
    private THashSet<long> _opt_seven;
    private Dictionary<sbyte, short> _opt_eight;
    private global::OptReqDefTest.Distance _def_one;
    private double _def_two;
    private short _def_three;
    private string _def_four;
    private byte[] _def_five;
    private List<int> _def_six;
    private THashSet<long> _def_seven;
    private Dictionary<sbyte, short> _def_eight;
    private global::OptReqDefTest.Distance _opt_one_with_value;
    private double _opt_two_with_value;
    private short _opt_three_with_value;
    private string _opt_four_with_value;
    private byte[] _opt_five_with_value;
    private List<int> _opt_six_with_value;
    private THashSet<long> _opt_seven_with_value;
    private Dictionary<sbyte, short> _opt_eight_with_value;
    private global::OptReqDefTest.Distance _def_one_with_value;
    private double _def_two_with_value;
    private short _def_three_with_value;
    private string _def_four_with_value;
    private byte[] _def_five_with_value;
    private List<int> _def_six_with_value;
    private THashSet<long> _def_seven_with_value;
    private Dictionary<sbyte, short> _def_eight_with_value;
    private bool _last_of_the_mohicans;
    private THashSet<global::OptReqDefTest.Distance> _far_set;
    private Dictionary<global::OptReqDefTest.Distance, global::OptReqDefTest.Distance> _far_map;
    private List<Dictionary<sbyte, THashSet<global::OptReqDefTest.Distance>>> _far_list_map_set;
    private Dictionary<global::OptReqDefTest.Distance, List<global::OptReqDefTest.RaceDetails>> _far_map_dist_to_rds;
    private global::OptReqDefTest.RaceDetails _opt_nested;
    private global::OptReqDefTest.RaceDetails _def_nested;
    private global::OptReqDefTest.jack _opt_union;
    private global::OptReqDefTest.jack _def_union;

    /// <summary>
    /// 
    /// <seealso cref="global::OptReqDefTest.Distance"/>
    /// </summary>
    [DataMember(Order = 0)]
    public global::OptReqDefTest.Distance Triplesix { get; set; }

    /// <summary>
    /// 
    /// <seealso cref="global::OptReqDefTest.Distance"/>
    /// </summary>
    [DataMember(Order = 0)]
    public global::OptReqDefTest.Distance Opt_one
    {
      get
      {
        return _opt_one;
      }
      set
      {
        __isset.opt_one = true;
        this._opt_one = value;
      }
    }

    [DataMember(Order = 0)]
    public double Opt_two
    {
      get
      {
        return _opt_two;
      }
      set
      {
        __isset.opt_two = true;
        this._opt_two = value;
      }
    }

    [DataMember(Order = 0)]
    public short Opt_three
    {
      get
      {
        return _opt_three;
      }
      set
      {
        __isset.opt_three = true;
        this._opt_three = value;
      }
    }

    [DataMember(Order = 0)]
    public string Opt_four
    {
      get
      {
        return _opt_four;
      }
      set
      {
        __isset.opt_four = true;
        this._opt_four = value;
      }
    }

    [DataMember(Order = 0)]
    public byte[] Opt_five
    {
      get
      {
        return _opt_five;
      }
      set
      {
        __isset.opt_five = true;
        this._opt_five = value;
      }
    }

    [DataMember(Order = 0)]
    public List<int> Opt_six
    {
      get
      {
        return _opt_six;
      }
      set
      {
        __isset.opt_six = true;
        this._opt_six = value;
      }
    }

    [DataMember(Order = 0)]
    public THashSet<long> Opt_seven
    {
      get
      {
        return _opt_seven;
      }
      set
      {
        __isset.opt_seven = true;
        this._opt_seven = value;
      }
    }

    [DataMember(Order = 0)]
    public Dictionary<sbyte, short> Opt_eight
    {
      get
      {
        return _opt_eight;
      }
      set
      {
        __isset.opt_eight = true;
        this._opt_eight = value;
      }
    }

    /// <summary>
    /// 
    /// <seealso cref="global::OptReqDefTest.Distance"/>
    /// </summary>
    [DataMember(Order = 0)]
    public global::OptReqDefTest.Distance Req_one { get; set; }

    [DataMember(Order = 0)]
    public double Req_two { get; set; }

    [DataMember(Order = 0)]
    public short Req_three { get; set; }

    [DataMember(Order = 0)]
    public string Req_four { get; set; }

    [DataMember(Order = 0)]
    public byte[] Req_five { get; set; }

    [DataMember(Order = 0)]
    public List<int> Req_six { get; set; }

    [DataMember(Order = 0)]
    public THashSet<long> Req_seven { get; set; }

    [DataMember(Order = 0)]
    public Dictionary<sbyte, short> Req_eight { get; set; }

    /// <summary>
    /// 
    /// <seealso cref="global::OptReqDefTest.Distance"/>
    /// </summary>
    [DataMember(Order = 0)]
    public global::OptReqDefTest.Distance Def_one
    {
      get
      {
        return _def_one;
      }
      set
      {
        __isset.def_one = true;
        this._def_one = value;
      }
    }

    [DataMember(Order = 0)]
    public double Def_two
    {
      get
      {
        return _def_two;
      }
      set
      {
        __isset.def_two = true;
        this._def_two = value;
      }
    }

    [DataMember(Order = 0)]
    public short Def_three
    {
      get
      {
        return _def_three;
      }
      set
      {
        __isset.def_three = true;
        this._def_three = value;
      }
    }

    [DataMember(Order = 0)]
    public string Def_four
    {
      get
      {
        return _def_four;
      }
      set
      {
        __isset.def_four = true;
        this._def_four = value;
      }
    }

    [DataMember(Order = 0)]
    public byte[] Def_five
    {
      get
      {
        return _def_five;
      }
      set
      {
        __isset.def_five = true;
        this._def_five = value;
      }
    }

    [DataMember(Order = 0)]
    public List<int> Def_six
    {
      get
      {
        return _def_six;
      }
      set
      {
        __isset.def_six = true;
        this._def_six = value;
      }
    }

    [DataMember(Order = 0)]
    public THashSet<long> Def_seven
    {
      get
      {
        return _def_seven;
      }
      set
      {
        __isset.def_seven = true;
        this._def_seven = value;
      }
    }

    [DataMember(Order = 0)]
    public Dictionary<sbyte, short> Def_eight
    {
      get
      {
        return _def_eight;
      }
      set
      {
        __isset.def_eight = true;
        this._def_eight = value;
      }
    }

    /// <summary>
    /// 
    /// <seealso cref="global::OptReqDefTest.Distance"/>
    /// </summary>
    [DataMember(Order = 0)]
    public global::OptReqDefTest.Distance Opt_one_with_value
    {
      get
      {
        return _opt_one_with_value;
      }
      set
      {
        __isset.opt_one_with_value = true;
        this._opt_one_with_value = value;
      }
    }

    [DataMember(Order = 0)]
    public double Opt_two_with_value
    {
      get
      {
        return _opt_two_with_value;
      }
      set
      {
        __isset.opt_two_with_value = true;
        this._opt_two_with_value = value;
      }
    }

    [DataMember(Order = 0)]
    public short Opt_three_with_value
    {
      get
      {
        return _opt_three_with_value;
      }
      set
      {
        __isset.opt_three_with_value = true;
        this._opt_three_with_value = value;
      }
    }

    [DataMember(Order = 0)]
    public string Opt_four_with_value
    {
      get
      {
        return _opt_four_with_value;
      }
      set
      {
        __isset.opt_four_with_value = true;
        this._opt_four_with_value = value;
      }
    }

    [DataMember(Order = 0)]
    public byte[] Opt_five_with_value
    {
      get
      {
        return _opt_five_with_value;
      }
      set
      {
        __isset.opt_five_with_value = true;
        this._opt_five_with_value = value;
      }
    }

    [DataMember(Order = 0)]
    public List<int> Opt_six_with_value
    {
      get
      {
        return _opt_six_with_value;
      }
      set
      {
        __isset.opt_six_with_value = true;
        this._opt_six_with_value = value;
      }
    }

    [DataMember(Order = 0)]
    public THashSet<long> Opt_seven_with_value
    {
      get
      {
        return _opt_seven_with_value;
      }
      set
      {
        __isset.opt_seven_with_value = true;
        this._opt_seven_with_value = value;
      }
    }

    [DataMember(Order = 0)]
    public Dictionary<sbyte, short> Opt_eight_with_value
    {
      get
      {
        return _opt_eight_with_value;
      }
      set
      {
        __isset.opt_eight_with_value = true;
        this._opt_eight_with_value = value;
      }
    }

    /// <summary>
    /// 
    /// <seealso cref="global::OptReqDefTest.Distance"/>
    /// </summary>
    [DataMember(Order = 0)]
    public global::OptReqDefTest.Distance Req_one_with_value { get; set; }

    [DataMember(Order = 0)]
    public double Req_two_with_value { get; set; }

    [DataMember(Order = 0)]
    public short Req_three_with_value { get; set; }

    [DataMember(Order = 0)]
    public string Req_four_with_value { get; set; }

    [DataMember(Order = 0)]
    public byte[] Req_five_with_value { get; set; }

    [DataMember(Order = 0)]
    public List<int> Req_six_with_value { get; set; }

    [DataMember(Order = 0)]
    public THashSet<long> Req_seven_with_value { get; set; }

    [DataMember(Order = 0)]
    public Dictionary<sbyte, short> Req_eight_with_value { get; set; }

    /// <summary>
    /// 
    /// <seealso cref="global::OptReqDefTest.Distance"/>
    /// </summary>
    [DataMember(Order = 0)]
    public global::OptReqDefTest.Distance Def_one_with_value
    {
      get
      {
        return _def_one_with_value;
      }
      set
      {
        __isset.def_one_with_value = true;
        this._def_one_with_value = value;
      }
    }

    [DataMember(Order = 0)]
    public double Def_two_with_value
    {
      get
      {
        return _def_two_with_value;
      }
      set
      {
        __isset.def_two_with_value = true;
        this._def_two_with_value = value;
      }
    }

    [DataMember(Order = 0)]
    public short Def_three_with_value
    {
      get
      {
        return _def_three_with_value;
      }
      set
      {
        __isset.def_three_with_value = true;
        this._def_three_with_value = value;
      }
    }

    [DataMember(Order = 0)]
    public string Def_four_with_value
    {
      get
      {
        return _def_four_with_value;
      }
      set
      {
        __isset.def_four_with_value = true;
        this._def_four_with_value = value;
      }
    }

    [DataMember(Order = 0)]
    public byte[] Def_five_with_value
    {
      get
      {
        return _def_five_with_value;
      }
      set
      {
        __isset.def_five_with_value = true;
        this._def_five_with_value = value;
      }
    }

    [DataMember(Order = 0)]
    public List<int> Def_six_with_value
    {
      get
      {
        return _def_six_with_value;
      }
      set
      {
        __isset.def_six_with_value = true;
        this._def_six_with_value = value;
      }
    }

    [DataMember(Order = 0)]
    public THashSet<long> Def_seven_with_value
    {
      get
      {
        return _def_seven_with_value;
      }
      set
      {
        __isset.def_seven_with_value = true;
        this._def_seven_with_value = value;
      }
    }

    [DataMember(Order = 0)]
    public Dictionary<sbyte, short> Def_eight_with_value
    {
      get
      {
        return _def_eight_with_value;
      }
      set
      {
        __isset.def_eight_with_value = true;
        this._def_eight_with_value = value;
      }
    }

    [DataMember(Order = 0)]
    public bool Last_of_the_mohicans
    {
      get
      {
        return _last_of_the_mohicans;
      }
      set
      {
        __isset.last_of_the_mohicans = true;
        this._last_of_the_mohicans = value;
      }
    }

    [DataMember(Order = 0)]
    public List<global::OptReqDefTest.Distance> Far_list { get; set; }

    [DataMember(Order = 0)]
    public THashSet<global::OptReqDefTest.Distance> Far_set
    {
      get
      {
        return _far_set;
      }
      set
      {
        __isset.far_set = true;
        this._far_set = value;
      }
    }

    [DataMember(Order = 0)]
    public Dictionary<global::OptReqDefTest.Distance, global::OptReqDefTest.Distance> Far_map
    {
      get
      {
        return _far_map;
      }
      set
      {
        __isset.far_map = true;
        this._far_map = value;
      }
    }

    [DataMember(Order = 0)]
    public THashSet<List<global::OptReqDefTest.Distance>> Far_set_list { get; set; }

    [DataMember(Order = 0)]
    public List<Dictionary<sbyte, THashSet<global::OptReqDefTest.Distance>>> Far_list_map_set
    {
      get
      {
        return _far_list_map_set;
      }
      set
      {
        __isset.far_list_map_set = true;
        this._far_list_map_set = value;
      }
    }

    [DataMember(Order = 0)]
    public Dictionary<global::OptReqDefTest.Distance, List<global::OptReqDefTest.RaceDetails>> Far_map_dist_to_rds
    {
      get
      {
        return _far_map_dist_to_rds;
      }
      set
      {
        __isset.far_map_dist_to_rds = true;
        this._far_map_dist_to_rds = value;
      }
    }

    [DataMember(Order = 0)]
    public global::OptReqDefTest.RaceDetails Req_nested { get; set; }

    [DataMember(Order = 0)]
    public global::OptReqDefTest.RaceDetails Opt_nested
    {
      get
      {
        return _opt_nested;
      }
      set
      {
        __isset.opt_nested = true;
        this._opt_nested = value;
      }
    }

    [DataMember(Order = 0)]
    public global::OptReqDefTest.RaceDetails Def_nested
    {
      get
      {
        return _def_nested;
      }
      set
      {
        __isset.def_nested = true;
        this._def_nested = value;
      }
    }

    [DataMember(Order = 0)]
    public global::OptReqDefTest.jack Req_union { get; set; }

    [DataMember(Order = 0)]
    public global::OptReqDefTest.jack Opt_union
    {
      get
      {
        return _opt_union;
      }
      set
      {
        __isset.opt_union = true;
        this._opt_union = value;
      }
    }

    [DataMember(Order = 0)]
    public global::OptReqDefTest.jack Def_union
    {
      get
      {
        return _def_union;
      }
      set
      {
        __isset.def_union = true;
        this._def_union = value;
      }
    }


    [DataMember(Order = 1)]
    public Isset __isset;
    [DataContract]
    public struct Isset
    {
      [DataMember]
      public bool opt_one;
      [DataMember]
      public bool opt_two;
      [DataMember]
      public bool opt_three;
      [DataMember]
      public bool opt_four;
      [DataMember]
      public bool opt_five;
      [DataMember]
      public bool opt_six;
      [DataMember]
      public bool opt_seven;
      [DataMember]
      public bool opt_eight;
      [DataMember]
      public bool def_one;
      [DataMember]
      public bool def_two;
      [DataMember]
      public bool def_three;
      [DataMember]
      public bool def_four;
      [DataMember]
      public bool def_five;
      [DataMember]
      public bool def_six;
      [DataMember]
      public bool def_seven;
      [DataMember]
      public bool def_eight;
      [DataMember]
      public bool opt_one_with_value;
      [DataMember]
      public bool opt_two_with_value;
      [DataMember]
      public bool opt_three_with_value;
      [DataMember]
      public bool opt_four_with_value;
      [DataMember]
      public bool opt_five_with_value;
      [DataMember]
      public bool opt_six_with_value;
      [DataMember]
      public bool opt_seven_with_value;
      [DataMember]
      public bool opt_eight_with_value;
      [DataMember]
      public bool def_one_with_value;
      [DataMember]
      public bool def_two_with_value;
      [DataMember]
      public bool def_three_with_value;
      [DataMember]
      public bool def_four_with_value;
      [DataMember]
      public bool def_five_with_value;
      [DataMember]
      public bool def_six_with_value;
      [DataMember]
      public bool def_seven_with_value;
      [DataMember]
      public bool def_eight_with_value;
      [DataMember]
      public bool last_of_the_mohicans;
      [DataMember]
      public bool far_set;
      [DataMember]
      public bool far_map;
      [DataMember]
      public bool far_list_map_set;
      [DataMember]
      public bool far_map_dist_to_rds;
      [DataMember]
      public bool opt_nested;
      [DataMember]
      public bool def_nested;
      [DataMember]
      public bool opt_union;
      [DataMember]
      public bool def_union;
    }

    #region XmlSerializer support

    public bool ShouldSerializeOpt_one()
    {
      return __isset.opt_one;
    }

    public bool ShouldSerializeOpt_two()
    {
      return __isset.opt_two;
    }

    public bool ShouldSerializeOpt_three()
    {
      return __isset.opt_three;
    }

    public bool ShouldSerializeOpt_four()
    {
      return __isset.opt_four;
    }

    public bool ShouldSerializeOpt_five()
    {
      return __isset.opt_five;
    }

    public bool ShouldSerializeOpt_six()
    {
      return __isset.opt_six;
    }

    public bool ShouldSerializeOpt_seven()
    {
      return __isset.opt_seven;
    }

    public bool ShouldSerializeOpt_eight()
    {
      return __isset.opt_eight;
    }

    public bool ShouldSerializeDef_one()
    {
      return __isset.def_one;
    }

    public bool ShouldSerializeDef_two()
    {
      return __isset.def_two;
    }

    public bool ShouldSerializeDef_three()
    {
      return __isset.def_three;
    }

    public bool ShouldSerializeDef_four()
    {
      return __isset.def_four;
    }

    public bool ShouldSerializeDef_five()
    {
      return __isset.def_five;
    }

    public bool ShouldSerializeDef_six()
    {
      return __isset.def_six;
    }

    public bool ShouldSerializeDef_seven()
    {
      return __isset.def_seven;
    }

    public bool ShouldSerializeDef_eight()
    {
      return __isset.def_eight;
    }

    public bool ShouldSerializeOpt_one_with_value()
    {
      return __isset.opt_one_with_value;
    }

    public bool ShouldSerializeOpt_two_with_value()
    {
      return __isset.opt_two_with_value;
    }

    public bool ShouldSerializeOpt_three_with_value()
    {
      return __isset.opt_three_with_value;
    }

    public bool ShouldSerializeOpt_four_with_value()
    {
      return __isset.opt_four_with_value;
    }

    public bool ShouldSerializeOpt_five_with_value()
    {
      return __isset.opt_five_with_value;
    }

    public bool ShouldSerializeOpt_six_with_value()
    {
      return __isset.opt_six_with_value;
    }

    public bool ShouldSerializeOpt_seven_with_value()
    {
      return __isset.opt_seven_with_value;
    }

    public bool ShouldSerializeOpt_eight_with_value()
    {
      return __isset.opt_eight_with_value;
    }

    public bool ShouldSerializeDef_one_with_value()
    {
      return __isset.def_one_with_value;
    }

    public bool ShouldSerializeDef_two_with_value()
    {
      return __isset.def_two_with_value;
    }

    public bool ShouldSerializeDef_three_with_value()
    {
      return __isset.def_three_with_value;
    }

    public bool ShouldSerializeDef_four_with_value()
    {
      return __isset.def_four_with_value;
    }

    public bool ShouldSerializeDef_five_with_value()
    {
      return __isset.def_five_with_value;
    }

    public bool ShouldSerializeDef_six_with_value()
    {
      return __isset.def_six_with_value;
    }

    public bool ShouldSerializeDef_seven_with_value()
    {
      return __isset.def_seven_with_value;
    }

    public bool ShouldSerializeDef_eight_with_value()
    {
      return __isset.def_eight_with_value;
    }

    public bool ShouldSerializeLast_of_the_mohicans()
    {
      return __isset.last_of_the_mohicans;
    }

    public bool ShouldSerializeFar_set()
    {
      return __isset.far_set;
    }

    public bool ShouldSerializeFar_map()
    {
      return __isset.far_map;
    }

    public bool ShouldSerializeFar_list_map_set()
    {
      return __isset.far_list_map_set;
    }

    public bool ShouldSerializeFar_map_dist_to_rds()
    {
      return __isset.far_map_dist_to_rds;
    }

    public bool ShouldSerializeOpt_nested()
    {
      return __isset.opt_nested;
    }

    public bool ShouldSerializeDef_nested()
    {
      return __isset.def_nested;
    }

    public bool ShouldSerializeOpt_union()
    {
      return __isset.opt_union;
    }

    public bool ShouldSerializeDef_union()
    {
      return __isset.def_union;
    }

    #endregion XmlSerializer support

    public RaceDetails()
    {
      this._opt_one_with_value = global::OptReqDefTest.Distance.bar;
      this.__isset.opt_one_with_value = true;
      this._opt_two_with_value = 2.22;
      this.__isset.opt_two_with_value = true;
      this._opt_three_with_value = 3;
      this.__isset.opt_three_with_value = true;
      this._opt_four_with_value = "four";
      this.__isset.opt_four_with_value = true;
      this._opt_five_with_value = System.Text.Encoding.UTF8.GetBytes("five\t");
      this.__isset.opt_five_with_value = true;
      this._opt_six_with_value = new List<int>();
      this._opt_six_with_value.Add(6);
      this.__isset.opt_six_with_value = true;
      this._opt_seven_with_value = new THashSet<long>();
      this._opt_seven_with_value.Add(7);
      this.__isset.opt_seven_with_value = true;
      this._opt_eight_with_value = new Dictionary<sbyte, short>();
      this._opt_eight_with_value[8] = 8;
      this.__isset.opt_eight_with_value = true;
      this.Req_one_with_value = global::OptReqDefTest.Distance.bar;
      this.Req_two_with_value = 2.22;
      this.Req_three_with_value = 3;
      this.Req_four_with_value = "four";
      this.Req_five_with_value = System.Text.Encoding.UTF8.GetBytes("five");
      this.Req_six_with_value = new List<int>();
      this.Req_six_with_value.Add(6);
      this.Req_seven_with_value = new THashSet<long>();
      this.Req_seven_with_value.Add(7);
      this.Req_eight_with_value = new Dictionary<sbyte, short>();
      this.Req_eight_with_value[8] = 8;
      this._def_one_with_value = global::OptReqDefTest.Distance.bar;
      this.__isset.def_one_with_value = true;
      this._def_two_with_value = 2.22;
      this.__isset.def_two_with_value = true;
      this._def_three_with_value = 3;
      this.__isset.def_three_with_value = true;
      this._def_four_with_value = "four";
      this.__isset.def_four_with_value = true;
      this._def_five_with_value = System.Text.Encoding.UTF8.GetBytes("five");
      this.__isset.def_five_with_value = true;
      this._def_six_with_value = new List<int>();
      this._def_six_with_value.Add(6);
      this.__isset.def_six_with_value = true;
      this._def_seven_with_value = new THashSet<long>();
      this._def_seven_with_value.Add(7);
      this.__isset.def_seven_with_value = true;
      this._def_eight_with_value = new Dictionary<sbyte, short>();
      this._def_eight_with_value[8] = 8;
      this.__isset.def_eight_with_value = true;
    }

    public RaceDetails(global::OptReqDefTest.Distance triplesix, global::OptReqDefTest.Distance req_one, double req_two, short req_three, string req_four, byte[] req_five, List<int> req_six, THashSet<long> req_seven, Dictionary<sbyte, short> req_eight, global::OptReqDefTest.Distance req_one_with_value, double req_two_with_value, short req_three_with_value, string req_four_with_value, byte[] req_five_with_value, List<int> req_six_with_value, THashSet<long> req_seven_with_value, Dictionary<sbyte, short> req_eight_with_value, List<global::OptReqDefTest.Distance> far_list, THashSet<List<global::OptReqDefTest.Distance>> far_set_list, global::OptReqDefTest.RaceDetails req_nested, global::OptReqDefTest.jack req_union) : this()
    {
      this.Triplesix = triplesix;
      this.Req_one = req_one;
      this.Req_two = req_two;
      this.Req_three = req_three;
      this.Req_four = req_four;
      this.Req_five = req_five;
      this.Req_six = req_six;
      this.Req_seven = req_seven;
      this.Req_eight = req_eight;
      this.Req_one_with_value = req_one_with_value;
      this.Req_two_with_value = req_two_with_value;
      this.Req_three_with_value = req_three_with_value;
      this.Req_four_with_value = req_four_with_value;
      this.Req_five_with_value = req_five_with_value;
      this.Req_six_with_value = req_six_with_value;
      this.Req_seven_with_value = req_seven_with_value;
      this.Req_eight_with_value = req_eight_with_value;
      this.Far_list = far_list;
      this.Far_set_list = far_set_list;
      this.Req_nested = req_nested;
      this.Req_union = req_union;
    }

    public RaceDetails DeepCopy()
    {
      var tmp0 = new RaceDetails();
      tmp0.Triplesix = this.Triplesix;
      if(__isset.opt_one)
      {
        tmp0.Opt_one = this.Opt_one;
      }
      tmp0.__isset.opt_one = this.__isset.opt_one;
      if(__isset.opt_two)
      {
        tmp0.Opt_two = this.Opt_two;
      }
      tmp0.__isset.opt_two = this.__isset.opt_two;
      if(__isset.opt_three)
      {
        tmp0.Opt_three = this.Opt_three;
      }
      tmp0.__isset.opt_three = this.__isset.opt_three;
      if((Opt_four != null) && __isset.opt_four)
      {
        tmp0.Opt_four = this.Opt_four;
      }
      tmp0.__isset.opt_four = this.__isset.opt_four;
      if((Opt_five != null) && __isset.opt_five)
      {
        tmp0.Opt_five = this.Opt_five.ToArray();
      }
      tmp0.__isset.opt_five = this.__isset.opt_five;
      if((Opt_six != null) && __isset.opt_six)
      {
        tmp0.Opt_six = this.Opt_six.DeepCopy();
      }
      tmp0.__isset.opt_six = this.__isset.opt_six;
      if((Opt_seven != null) && __isset.opt_seven)
      {
        tmp0.Opt_seven = this.Opt_seven.DeepCopy();
      }
      tmp0.__isset.opt_seven = this.__isset.opt_seven;
      if((Opt_eight != null) && __isset.opt_eight)
      {
        tmp0.Opt_eight = this.Opt_eight.DeepCopy();
      }
      tmp0.__isset.opt_eight = this.__isset.opt_eight;
      tmp0.Req_one = this.Req_one;
      tmp0.Req_two = this.Req_two;
      tmp0.Req_three = this.Req_three;
      if((Req_four != null))
      {
        tmp0.Req_four = this.Req_four;
      }
      if((Req_five != null))
      {
        tmp0.Req_five = this.Req_five.ToArray();
      }
      if((Req_six != null))
      {
        tmp0.Req_six = this.Req_six.DeepCopy();
      }
      if((Req_seven != null))
      {
        tmp0.Req_seven = this.Req_seven.DeepCopy();
      }
      if((Req_eight != null))
      {
        tmp0.Req_eight = this.Req_eight.DeepCopy();
      }
      if(__isset.def_one)
      {
        tmp0.Def_one = this.Def_one;
      }
      tmp0.__isset.def_one = this.__isset.def_one;
      if(__isset.def_two)
      {
        tmp0.Def_two = this.Def_two;
      }
      tmp0.__isset.def_two = this.__isset.def_two;
      if(__isset.def_three)
      {
        tmp0.Def_three = this.Def_three;
      }
      tmp0.__isset.def_three = this.__isset.def_three;
      if((Def_four != null) && __isset.def_four)
      {
        tmp0.Def_four = this.Def_four;
      }
      tmp0.__isset.def_four = this.__isset.def_four;
      if((Def_five != null) && __isset.def_five)
      {
        tmp0.Def_five = this.Def_five.ToArray();
      }
      tmp0.__isset.def_five = this.__isset.def_five;
      if((Def_six != null) && __isset.def_six)
      {
        tmp0.Def_six = this.Def_six.DeepCopy();
      }
      tmp0.__isset.def_six = this.__isset.def_six;
      if((Def_seven != null) && __isset.def_seven)
      {
        tmp0.Def_seven = this.Def_seven.DeepCopy();
      }
      tmp0.__isset.def_seven = this.__isset.def_seven;
      if((Def_eight != null) && __isset.def_eight)
      {
        tmp0.Def_eight = this.Def_eight.DeepCopy();
      }
      tmp0.__isset.def_eight = this.__isset.def_eight;
      if(__isset.opt_one_with_value)
      {
        tmp0.Opt_one_with_value = this.Opt_one_with_value;
      }
      tmp0.__isset.opt_one_with_value = this.__isset.opt_one_with_value;
      if(__isset.opt_two_with_value)
      {
        tmp0.Opt_two_with_value = this.Opt_two_with_value;
      }
      tmp0.__isset.opt_two_with_value = this.__isset.opt_two_with_value;
      if(__isset.opt_three_with_value)
      {
        tmp0.Opt_three_with_value = this.Opt_three_with_value;
      }
      tmp0.__isset.opt_three_with_value = this.__isset.opt_three_with_value;
      if((Opt_four_with_value != null) && __isset.opt_four_with_value)
      {
        tmp0.Opt_four_with_value = this.Opt_four_with_value;
      }
      tmp0.__isset.opt_four_with_value = this.__isset.opt_four_with_value;
      if((Opt_five_with_value != null) && __isset.opt_five_with_value)
      {
        tmp0.Opt_five_with_value = this.Opt_five_with_value.ToArray();
      }
      tmp0.__isset.opt_five_with_value = this.__isset.opt_five_with_value;
      if((Opt_six_with_value != null) && __isset.opt_six_with_value)
      {
        tmp0.Opt_six_with_value = this.Opt_six_with_value.DeepCopy();
      }
      tmp0.__isset.opt_six_with_value = this.__isset.opt_six_with_value;
      if((Opt_seven_with_value != null) && __isset.opt_seven_with_value)
      {
        tmp0.Opt_seven_with_value = this.Opt_seven_with_value.DeepCopy();
      }
      tmp0.__isset.opt_seven_with_value = this.__isset.opt_seven_with_value;
      if((Opt_eight_with_value != null) && __isset.opt_eight_with_value)
      {
        tmp0.Opt_eight_with_value = this.Opt_eight_with_value.DeepCopy();
      }
      tmp0.__isset.opt_eight_with_value = this.__isset.opt_eight_with_value;
      tmp0.Req_one_with_value = this.Req_one_with_value;
      tmp0.Req_two_with_value = this.Req_two_with_value;
      tmp0.Req_three_with_value = this.Req_three_with_value;
      if((Req_four_with_value != null))
      {
        tmp0.Req_four_with_value = this.Req_four_with_value;
      }
      if((Req_five_with_value != null))
      {
        tmp0.Req_five_with_value = this.Req_five_with_value.ToArray();
      }
      if((Req_six_with_value != null))
      {
        tmp0.Req_six_with_value = this.Req_six_with_value.DeepCopy();
      }
      if((Req_seven_with_value != null))
      {
        tmp0.Req_seven_with_value = this.Req_seven_with_value.DeepCopy();
      }
      if((Req_eight_with_value != null))
      {
        tmp0.Req_eight_with_value = this.Req_eight_with_value.DeepCopy();
      }
      if(__isset.def_one_with_value)
      {
        tmp0.Def_one_with_value = this.Def_one_with_value;
      }
      tmp0.__isset.def_one_with_value = this.__isset.def_one_with_value;
      if(__isset.def_two_with_value)
      {
        tmp0.Def_two_with_value = this.Def_two_with_value;
      }
      tmp0.__isset.def_two_with_value = this.__isset.def_two_with_value;
      if(__isset.def_three_with_value)
      {
        tmp0.Def_three_with_value = this.Def_three_with_value;
      }
      tmp0.__isset.def_three_with_value = this.__isset.def_three_with_value;
      if((Def_four_with_value != null) && __isset.def_four_with_value)
      {
        tmp0.Def_four_with_value = this.Def_four_with_value;
      }
      tmp0.__isset.def_four_with_value = this.__isset.def_four_with_value;
      if((Def_five_with_value != null) && __isset.def_five_with_value)
      {
        tmp0.Def_five_with_value = this.Def_five_with_value.ToArray();
      }
      tmp0.__isset.def_five_with_value = this.__isset.def_five_with_value;
      if((Def_six_with_value != null) && __isset.def_six_with_value)
      {
        tmp0.Def_six_with_value = this.Def_six_with_value.DeepCopy();
      }
      tmp0.__isset.def_six_with_value = this.__isset.def_six_with_value;
      if((Def_seven_with_value != null) && __isset.def_seven_with_value)
      {
        tmp0.Def_seven_with_value = this.Def_seven_with_value.DeepCopy();
      }
      tmp0.__isset.def_seven_with_value = this.__isset.def_seven_with_value;
      if((Def_eight_with_value != null) && __isset.def_eight_with_value)
      {
        tmp0.Def_eight_with_value = this.Def_eight_with_value.DeepCopy();
      }
      tmp0.__isset.def_eight_with_value = this.__isset.def_eight_with_value;
      if(__isset.last_of_the_mohicans)
      {
        tmp0.Last_of_the_mohicans = this.Last_of_the_mohicans;
      }
      tmp0.__isset.last_of_the_mohicans = this.__isset.last_of_the_mohicans;
      if((Far_list != null))
      {
        tmp0.Far_list = this.Far_list.DeepCopy();
      }
      if((Far_set != null) && __isset.far_set)
      {
        tmp0.Far_set = this.Far_set.DeepCopy();
      }
      tmp0.__isset.far_set = this.__isset.far_set;
      if((Far_map != null) && __isset.far_map)
      {
        tmp0.Far_map = this.Far_map.DeepCopy();
      }
      tmp0.__isset.far_map = this.__isset.far_map;
      if((Far_set_list != null))
      {
        tmp0.Far_set_list = this.Far_set_list.DeepCopy();
      }
      if((Far_list_map_set != null) && __isset.far_list_map_set)
      {
        tmp0.Far_list_map_set = this.Far_list_map_set.DeepCopy();
      }
      tmp0.__isset.far_list_map_set = this.__isset.far_list_map_set;
      if((Far_map_dist_to_rds != null) && __isset.far_map_dist_to_rds)
      {
        tmp0.Far_map_dist_to_rds = this.Far_map_dist_to_rds.DeepCopy();
      }
      tmp0.__isset.far_map_dist_to_rds = this.__isset.far_map_dist_to_rds;
      if((Req_nested != null))
      {
        tmp0.Req_nested = (global::OptReqDefTest.RaceDetails)this.Req_nested.DeepCopy();
      }
      if((Opt_nested != null) && __isset.opt_nested)
      {
        tmp0.Opt_nested = (global::OptReqDefTest.RaceDetails)this.Opt_nested.DeepCopy();
      }
      tmp0.__isset.opt_nested = this.__isset.opt_nested;
      if((Def_nested != null) && __isset.def_nested)
      {
        tmp0.Def_nested = (global::OptReqDefTest.RaceDetails)this.Def_nested.DeepCopy();
      }
      tmp0.__isset.def_nested = this.__isset.def_nested;
      if((Req_union != null))
      {
        tmp0.Req_union = (global::OptReqDefTest.jack)this.Req_union.DeepCopy();
      }
      if((Opt_union != null) && __isset.opt_union)
      {
        tmp0.Opt_union = (global::OptReqDefTest.jack)this.Opt_union.DeepCopy();
      }
      tmp0.__isset.opt_union = this.__isset.opt_union;
      if((Def_union != null) && __isset.def_union)
      {
        tmp0.Def_union = (global::OptReqDefTest.jack)this.Def_union.DeepCopy();
      }
      tmp0.__isset.def_union = this.__isset.def_union;
      return tmp0;
    }

    public async global::System.Threading.Tasks.Task ReadAsync(TProtocol iprot, CancellationToken cancellationToken)
    {
      iprot.IncrementRecursionDepth();
      try
      {
        bool isset_triplesix = false;
        bool isset_req_one = false;
        bool isset_req_two = false;
        bool isset_req_three = false;
        bool isset_req_four = false;
        bool isset_req_five = false;
        bool isset_req_six = false;
        bool isset_req_seven = false;
        bool isset_req_eight = false;
        bool isset_req_one_with_value = false;
        bool isset_req_two_with_value = false;
        bool isset_req_three_with_value = false;
        bool isset_req_four_with_value = false;
        bool isset_req_five_with_value = false;
        bool isset_req_six_with_value = false;
        bool isset_req_seven_with_value = false;
        bool isset_req_eight_with_value = false;
        bool isset_far_list = false;
        bool isset_far_set_list = false;
        bool isset_req_nested = false;
        bool isset_req_union = false;
        TField field;
        await iprot.ReadStructBeginAsync(cancellationToken);
        while (true)
        {
          field = await iprot.ReadFieldBeginAsync(cancellationToken);
          if (field.Type == TType.Stop)
          {
            break;
          }

          switch (field.ID)
          {
            case 666:
              if (field.Type == TType.I32)
              {
                Triplesix = (global::OptReqDefTest.Distance)await iprot.ReadI32Async(cancellationToken);
                isset_triplesix = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 1:
              if (field.Type == TType.I32)
              {
                Opt_one = (global::OptReqDefTest.Distance)await iprot.ReadI32Async(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 2:
              if (field.Type == TType.Double)
              {
                Opt_two = await iprot.ReadDoubleAsync(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 3:
              if (field.Type == TType.I16)
              {
                Opt_three = await iprot.ReadI16Async(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 4:
              if (field.Type == TType.String)
              {
                Opt_four = await iprot.ReadStringAsync(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 5:
              if (field.Type == TType.String)
              {
                Opt_five = await iprot.ReadBinaryAsync(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 6:
              if (field.Type == TType.List)
              {
                {
                  TList _list1 = await iprot.ReadListBeginAsync(cancellationToken);
                  Opt_six = new List<int>(_list1.Count);
                  for(int _i2 = 0; _i2 < _list1.Count; ++_i2)
                  {
                    int _elem3;
                    _elem3 = await iprot.ReadI32Async(cancellationToken);
                    Opt_six.Add(_elem3);
                  }
                  await iprot.ReadListEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 7:
              if (field.Type == TType.Set)
              {
                {
                  TSet _set4 = await iprot.ReadSetBeginAsync(cancellationToken);
                  Opt_seven = new THashSet<long>(_set4.Count);
                  for(int _i5 = 0; _i5 < _set4.Count; ++_i5)
                  {
                    long _elem6;
                    _elem6 = await iprot.ReadI64Async(cancellationToken);
                    Opt_seven.Add(_elem6);
                  }
                  await iprot.ReadSetEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 8:
              if (field.Type == TType.Map)
              {
                {
                  TMap _map7 = await iprot.ReadMapBeginAsync(cancellationToken);
                  Opt_eight = new Dictionary<sbyte, short>(_map7.Count);
                  for(int _i8 = 0; _i8 < _map7.Count; ++_i8)
                  {
                    sbyte _key9;
                    short _val10;
                    _key9 = await iprot.ReadByteAsync(cancellationToken);
                    _val10 = await iprot.ReadI16Async(cancellationToken);
                    Opt_eight[_key9] = _val10;
                  }
                  await iprot.ReadMapEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 11:
              if (field.Type == TType.I32)
              {
                Req_one = (global::OptReqDefTest.Distance)await iprot.ReadI32Async(cancellationToken);
                isset_req_one = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 12:
              if (field.Type == TType.Double)
              {
                Req_two = await iprot.ReadDoubleAsync(cancellationToken);
                isset_req_two = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 13:
              if (field.Type == TType.I16)
              {
                Req_three = await iprot.ReadI16Async(cancellationToken);
                isset_req_three = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 14:
              if (field.Type == TType.String)
              {
                Req_four = await iprot.ReadStringAsync(cancellationToken);
                isset_req_four = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 15:
              if (field.Type == TType.String)
              {
                Req_five = await iprot.ReadBinaryAsync(cancellationToken);
                isset_req_five = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 16:
              if (field.Type == TType.List)
              {
                {
                  TList _list11 = await iprot.ReadListBeginAsync(cancellationToken);
                  Req_six = new List<int>(_list11.Count);
                  for(int _i12 = 0; _i12 < _list11.Count; ++_i12)
                  {
                    int _elem13;
                    _elem13 = await iprot.ReadI32Async(cancellationToken);
                    Req_six.Add(_elem13);
                  }
                  await iprot.ReadListEndAsync(cancellationToken);
                }
                isset_req_six = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 17:
              if (field.Type == TType.Set)
              {
                {
                  TSet _set14 = await iprot.ReadSetBeginAsync(cancellationToken);
                  Req_seven = new THashSet<long>(_set14.Count);
                  for(int _i15 = 0; _i15 < _set14.Count; ++_i15)
                  {
                    long _elem16;
                    _elem16 = await iprot.ReadI64Async(cancellationToken);
                    Req_seven.Add(_elem16);
                  }
                  await iprot.ReadSetEndAsync(cancellationToken);
                }
                isset_req_seven = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 18:
              if (field.Type == TType.Map)
              {
                {
                  TMap _map17 = await iprot.ReadMapBeginAsync(cancellationToken);
                  Req_eight = new Dictionary<sbyte, short>(_map17.Count);
                  for(int _i18 = 0; _i18 < _map17.Count; ++_i18)
                  {
                    sbyte _key19;
                    short _val20;
                    _key19 = await iprot.ReadByteAsync(cancellationToken);
                    _val20 = await iprot.ReadI16Async(cancellationToken);
                    Req_eight[_key19] = _val20;
                  }
                  await iprot.ReadMapEndAsync(cancellationToken);
                }
                isset_req_eight = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 21:
              if (field.Type == TType.I32)
              {
                Def_one = (global::OptReqDefTest.Distance)await iprot.ReadI32Async(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 22:
              if (field.Type == TType.Double)
              {
                Def_two = await iprot.ReadDoubleAsync(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 23:
              if (field.Type == TType.I16)
              {
                Def_three = await iprot.ReadI16Async(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 24:
              if (field.Type == TType.String)
              {
                Def_four = await iprot.ReadStringAsync(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 25:
              if (field.Type == TType.String)
              {
                Def_five = await iprot.ReadBinaryAsync(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 26:
              if (field.Type == TType.List)
              {
                {
                  TList _list21 = await iprot.ReadListBeginAsync(cancellationToken);
                  Def_six = new List<int>(_list21.Count);
                  for(int _i22 = 0; _i22 < _list21.Count; ++_i22)
                  {
                    int _elem23;
                    _elem23 = await iprot.ReadI32Async(cancellationToken);
                    Def_six.Add(_elem23);
                  }
                  await iprot.ReadListEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 27:
              if (field.Type == TType.Set)
              {
                {
                  TSet _set24 = await iprot.ReadSetBeginAsync(cancellationToken);
                  Def_seven = new THashSet<long>(_set24.Count);
                  for(int _i25 = 0; _i25 < _set24.Count; ++_i25)
                  {
                    long _elem26;
                    _elem26 = await iprot.ReadI64Async(cancellationToken);
                    Def_seven.Add(_elem26);
                  }
                  await iprot.ReadSetEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 28:
              if (field.Type == TType.Map)
              {
                {
                  TMap _map27 = await iprot.ReadMapBeginAsync(cancellationToken);
                  Def_eight = new Dictionary<sbyte, short>(_map27.Count);
                  for(int _i28 = 0; _i28 < _map27.Count; ++_i28)
                  {
                    sbyte _key29;
                    short _val30;
                    _key29 = await iprot.ReadByteAsync(cancellationToken);
                    _val30 = await iprot.ReadI16Async(cancellationToken);
                    Def_eight[_key29] = _val30;
                  }
                  await iprot.ReadMapEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 31:
              if (field.Type == TType.I32)
              {
                Opt_one_with_value = (global::OptReqDefTest.Distance)await iprot.ReadI32Async(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 32:
              if (field.Type == TType.Double)
              {
                Opt_two_with_value = await iprot.ReadDoubleAsync(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 33:
              if (field.Type == TType.I16)
              {
                Opt_three_with_value = await iprot.ReadI16Async(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 34:
              if (field.Type == TType.String)
              {
                Opt_four_with_value = await iprot.ReadStringAsync(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 35:
              if (field.Type == TType.String)
              {
                Opt_five_with_value = await iprot.ReadBinaryAsync(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 36:
              if (field.Type == TType.List)
              {
                {
                  TList _list31 = await iprot.ReadListBeginAsync(cancellationToken);
                  Opt_six_with_value = new List<int>(_list31.Count);
                  for(int _i32 = 0; _i32 < _list31.Count; ++_i32)
                  {
                    int _elem33;
                    _elem33 = await iprot.ReadI32Async(cancellationToken);
                    Opt_six_with_value.Add(_elem33);
                  }
                  await iprot.ReadListEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 37:
              if (field.Type == TType.Set)
              {
                {
                  TSet _set34 = await iprot.ReadSetBeginAsync(cancellationToken);
                  Opt_seven_with_value = new THashSet<long>(_set34.Count);
                  for(int _i35 = 0; _i35 < _set34.Count; ++_i35)
                  {
                    long _elem36;
                    _elem36 = await iprot.ReadI64Async(cancellationToken);
                    Opt_seven_with_value.Add(_elem36);
                  }
                  await iprot.ReadSetEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 38:
              if (field.Type == TType.Map)
              {
                {
                  TMap _map37 = await iprot.ReadMapBeginAsync(cancellationToken);
                  Opt_eight_with_value = new Dictionary<sbyte, short>(_map37.Count);
                  for(int _i38 = 0; _i38 < _map37.Count; ++_i38)
                  {
                    sbyte _key39;
                    short _val40;
                    _key39 = await iprot.ReadByteAsync(cancellationToken);
                    _val40 = await iprot.ReadI16Async(cancellationToken);
                    Opt_eight_with_value[_key39] = _val40;
                  }
                  await iprot.ReadMapEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 41:
              if (field.Type == TType.I32)
              {
                Req_one_with_value = (global::OptReqDefTest.Distance)await iprot.ReadI32Async(cancellationToken);
                isset_req_one_with_value = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 42:
              if (field.Type == TType.Double)
              {
                Req_two_with_value = await iprot.ReadDoubleAsync(cancellationToken);
                isset_req_two_with_value = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 43:
              if (field.Type == TType.I16)
              {
                Req_three_with_value = await iprot.ReadI16Async(cancellationToken);
                isset_req_three_with_value = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 44:
              if (field.Type == TType.String)
              {
                Req_four_with_value = await iprot.ReadStringAsync(cancellationToken);
                isset_req_four_with_value = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 45:
              if (field.Type == TType.String)
              {
                Req_five_with_value = await iprot.ReadBinaryAsync(cancellationToken);
                isset_req_five_with_value = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 46:
              if (field.Type == TType.List)
              {
                {
                  TList _list41 = await iprot.ReadListBeginAsync(cancellationToken);
                  Req_six_with_value = new List<int>(_list41.Count);
                  for(int _i42 = 0; _i42 < _list41.Count; ++_i42)
                  {
                    int _elem43;
                    _elem43 = await iprot.ReadI32Async(cancellationToken);
                    Req_six_with_value.Add(_elem43);
                  }
                  await iprot.ReadListEndAsync(cancellationToken);
                }
                isset_req_six_with_value = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 47:
              if (field.Type == TType.Set)
              {
                {
                  TSet _set44 = await iprot.ReadSetBeginAsync(cancellationToken);
                  Req_seven_with_value = new THashSet<long>(_set44.Count);
                  for(int _i45 = 0; _i45 < _set44.Count; ++_i45)
                  {
                    long _elem46;
                    _elem46 = await iprot.ReadI64Async(cancellationToken);
                    Req_seven_with_value.Add(_elem46);
                  }
                  await iprot.ReadSetEndAsync(cancellationToken);
                }
                isset_req_seven_with_value = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 48:
              if (field.Type == TType.Map)
              {
                {
                  TMap _map47 = await iprot.ReadMapBeginAsync(cancellationToken);
                  Req_eight_with_value = new Dictionary<sbyte, short>(_map47.Count);
                  for(int _i48 = 0; _i48 < _map47.Count; ++_i48)
                  {
                    sbyte _key49;
                    short _val50;
                    _key49 = await iprot.ReadByteAsync(cancellationToken);
                    _val50 = await iprot.ReadI16Async(cancellationToken);
                    Req_eight_with_value[_key49] = _val50;
                  }
                  await iprot.ReadMapEndAsync(cancellationToken);
                }
                isset_req_eight_with_value = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 51:
              if (field.Type == TType.I32)
              {
                Def_one_with_value = (global::OptReqDefTest.Distance)await iprot.ReadI32Async(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 52:
              if (field.Type == TType.Double)
              {
                Def_two_with_value = await iprot.ReadDoubleAsync(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 53:
              if (field.Type == TType.I16)
              {
                Def_three_with_value = await iprot.ReadI16Async(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 54:
              if (field.Type == TType.String)
              {
                Def_four_with_value = await iprot.ReadStringAsync(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 55:
              if (field.Type == TType.String)
              {
                Def_five_with_value = await iprot.ReadBinaryAsync(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 56:
              if (field.Type == TType.List)
              {
                {
                  TList _list51 = await iprot.ReadListBeginAsync(cancellationToken);
                  Def_six_with_value = new List<int>(_list51.Count);
                  for(int _i52 = 0; _i52 < _list51.Count; ++_i52)
                  {
                    int _elem53;
                    _elem53 = await iprot.ReadI32Async(cancellationToken);
                    Def_six_with_value.Add(_elem53);
                  }
                  await iprot.ReadListEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 57:
              if (field.Type == TType.Set)
              {
                {
                  TSet _set54 = await iprot.ReadSetBeginAsync(cancellationToken);
                  Def_seven_with_value = new THashSet<long>(_set54.Count);
                  for(int _i55 = 0; _i55 < _set54.Count; ++_i55)
                  {
                    long _elem56;
                    _elem56 = await iprot.ReadI64Async(cancellationToken);
                    Def_seven_with_value.Add(_elem56);
                  }
                  await iprot.ReadSetEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 58:
              if (field.Type == TType.Map)
              {
                {
                  TMap _map57 = await iprot.ReadMapBeginAsync(cancellationToken);
                  Def_eight_with_value = new Dictionary<sbyte, short>(_map57.Count);
                  for(int _i58 = 0; _i58 < _map57.Count; ++_i58)
                  {
                    sbyte _key59;
                    short _val60;
                    _key59 = await iprot.ReadByteAsync(cancellationToken);
                    _val60 = await iprot.ReadI16Async(cancellationToken);
                    Def_eight_with_value[_key59] = _val60;
                  }
                  await iprot.ReadMapEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 90:
              if (field.Type == TType.Bool)
              {
                Last_of_the_mohicans = await iprot.ReadBoolAsync(cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 300:
              if (field.Type == TType.List)
              {
                {
                  TList _list61 = await iprot.ReadListBeginAsync(cancellationToken);
                  Far_list = new List<global::OptReqDefTest.Distance>(_list61.Count);
                  for(int _i62 = 0; _i62 < _list61.Count; ++_i62)
                  {
                    global::OptReqDefTest.Distance _elem63;
                    _elem63 = (global::OptReqDefTest.Distance)await iprot.ReadI32Async(cancellationToken);
                    Far_list.Add(_elem63);
                  }
                  await iprot.ReadListEndAsync(cancellationToken);
                }
                isset_far_list = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 301:
              if (field.Type == TType.Set)
              {
                {
                  TSet _set64 = await iprot.ReadSetBeginAsync(cancellationToken);
                  Far_set = new THashSet<global::OptReqDefTest.Distance>(_set64.Count);
                  for(int _i65 = 0; _i65 < _set64.Count; ++_i65)
                  {
                    global::OptReqDefTest.Distance _elem66;
                    _elem66 = (global::OptReqDefTest.Distance)await iprot.ReadI32Async(cancellationToken);
                    Far_set.Add(_elem66);
                  }
                  await iprot.ReadSetEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 302:
              if (field.Type == TType.Map)
              {
                {
                  TMap _map67 = await iprot.ReadMapBeginAsync(cancellationToken);
                  Far_map = new Dictionary<global::OptReqDefTest.Distance, global::OptReqDefTest.Distance>(_map67.Count);
                  for(int _i68 = 0; _i68 < _map67.Count; ++_i68)
                  {
                    global::OptReqDefTest.Distance _key69;
                    global::OptReqDefTest.Distance _val70;
                    _key69 = (global::OptReqDefTest.Distance)await iprot.ReadI32Async(cancellationToken);
                    _val70 = (global::OptReqDefTest.Distance)await iprot.ReadI32Async(cancellationToken);
                    Far_map[_key69] = _val70;
                  }
                  await iprot.ReadMapEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 310:
              if (field.Type == TType.Set)
              {
                {
                  TSet _set71 = await iprot.ReadSetBeginAsync(cancellationToken);
                  Far_set_list = new THashSet<List<global::OptReqDefTest.Distance>>(_set71.Count);
                  for(int _i72 = 0; _i72 < _set71.Count; ++_i72)
                  {
                    List<global::OptReqDefTest.Distance> _elem73;
                    {
                      TList _list74 = await iprot.ReadListBeginAsync(cancellationToken);
                      _elem73 = new List<global::OptReqDefTest.Distance>(_list74.Count);
                      for(int _i75 = 0; _i75 < _list74.Count; ++_i75)
                      {
                        global::OptReqDefTest.Distance _elem76;
                        _elem76 = (global::OptReqDefTest.Distance)await iprot.ReadI32Async(cancellationToken);
                        _elem73.Add(_elem76);
                      }
                      await iprot.ReadListEndAsync(cancellationToken);
                    }
                    Far_set_list.Add(_elem73);
                  }
                  await iprot.ReadSetEndAsync(cancellationToken);
                }
                isset_far_set_list = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 311:
              if (field.Type == TType.List)
              {
                {
                  TList _list77 = await iprot.ReadListBeginAsync(cancellationToken);
                  Far_list_map_set = new List<Dictionary<sbyte, THashSet<global::OptReqDefTest.Distance>>>(_list77.Count);
                  for(int _i78 = 0; _i78 < _list77.Count; ++_i78)
                  {
                    Dictionary<sbyte, THashSet<global::OptReqDefTest.Distance>> _elem79;
                    {
                      TMap _map80 = await iprot.ReadMapBeginAsync(cancellationToken);
                      _elem79 = new Dictionary<sbyte, THashSet<global::OptReqDefTest.Distance>>(_map80.Count);
                      for(int _i81 = 0; _i81 < _map80.Count; ++_i81)
                      {
                        sbyte _key82;
                        THashSet<global::OptReqDefTest.Distance> _val83;
                        _key82 = await iprot.ReadByteAsync(cancellationToken);
                        {
                          TSet _set84 = await iprot.ReadSetBeginAsync(cancellationToken);
                          _val83 = new THashSet<global::OptReqDefTest.Distance>(_set84.Count);
                          for(int _i85 = 0; _i85 < _set84.Count; ++_i85)
                          {
                            global::OptReqDefTest.Distance _elem86;
                            _elem86 = (global::OptReqDefTest.Distance)await iprot.ReadI32Async(cancellationToken);
                            _val83.Add(_elem86);
                          }
                          await iprot.ReadSetEndAsync(cancellationToken);
                        }
                        _elem79[_key82] = _val83;
                      }
                      await iprot.ReadMapEndAsync(cancellationToken);
                    }
                    Far_list_map_set.Add(_elem79);
                  }
                  await iprot.ReadListEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 312:
              if (field.Type == TType.Map)
              {
                {
                  TMap _map87 = await iprot.ReadMapBeginAsync(cancellationToken);
                  Far_map_dist_to_rds = new Dictionary<global::OptReqDefTest.Distance, List<global::OptReqDefTest.RaceDetails>>(_map87.Count);
                  for(int _i88 = 0; _i88 < _map87.Count; ++_i88)
                  {
                    global::OptReqDefTest.Distance _key89;
                    List<global::OptReqDefTest.RaceDetails> _val90;
                    _key89 = (global::OptReqDefTest.Distance)await iprot.ReadI32Async(cancellationToken);
                    {
                      TList _list91 = await iprot.ReadListBeginAsync(cancellationToken);
                      _val90 = new List<global::OptReqDefTest.RaceDetails>(_list91.Count);
                      for(int _i92 = 0; _i92 < _list91.Count; ++_i92)
                      {
                        global::OptReqDefTest.RaceDetails _elem93;
                        _elem93 = new global::OptReqDefTest.RaceDetails();
                        await _elem93.ReadAsync(iprot, cancellationToken);
                        _val90.Add(_elem93);
                      }
                      await iprot.ReadListEndAsync(cancellationToken);
                    }
                    Far_map_dist_to_rds[_key89] = _val90;
                  }
                  await iprot.ReadMapEndAsync(cancellationToken);
                }
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 320:
              if (field.Type == TType.Struct)
              {
                Req_nested = new global::OptReqDefTest.RaceDetails();
                await Req_nested.ReadAsync(iprot, cancellationToken);
                isset_req_nested = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 321:
              if (field.Type == TType.Struct)
              {
                Opt_nested = new global::OptReqDefTest.RaceDetails();
                await Opt_nested.ReadAsync(iprot, cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 322:
              if (field.Type == TType.Struct)
              {
                Def_nested = new global::OptReqDefTest.RaceDetails();
                await Def_nested.ReadAsync(iprot, cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 330:
              if (field.Type == TType.Struct)
              {
                Req_union = await global::OptReqDefTest.jack.ReadAsync(iprot, cancellationToken);
                isset_req_union = true;
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 331:
              if (field.Type == TType.Struct)
              {
                Opt_union = await global::OptReqDefTest.jack.ReadAsync(iprot, cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            case 332:
              if (field.Type == TType.Struct)
              {
                Def_union = await global::OptReqDefTest.jack.ReadAsync(iprot, cancellationToken);
              }
              else
              {
                await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              }
              break;
            default: 
              await TProtocolUtil.SkipAsync(iprot, field.Type, cancellationToken);
              break;
          }

          await iprot.ReadFieldEndAsync(cancellationToken);
        }

        await iprot.ReadStructEndAsync(cancellationToken);
        if (!isset_triplesix)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_one)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_two)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_three)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_four)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_five)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_six)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_seven)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_eight)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_one_with_value)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_two_with_value)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_three_with_value)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_four_with_value)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_five_with_value)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_six_with_value)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_seven_with_value)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_eight_with_value)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_far_list)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_far_set_list)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_nested)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
        if (!isset_req_union)
        {
          throw new TProtocolException(TProtocolException.INVALID_DATA);
        }
      }
      finally
      {
        iprot.DecrementRecursionDepth();
      }
    }

    public async global::System.Threading.Tasks.Task WriteAsync(TProtocol oprot, CancellationToken cancellationToken)
    {
      oprot.IncrementRecursionDepth();
      try
      {
        var struc = new TStruct("RaceDetails");
        await oprot.WriteStructBeginAsync(struc, cancellationToken);
        var field = new TField();
        if(__isset.opt_one)
        {
          field.Name = "opt_one";
          field.Type = TType.I32;
          field.ID = 1;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteI32Async((int)Opt_one, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if(__isset.opt_two)
        {
          field.Name = "opt_two";
          field.Type = TType.Double;
          field.ID = 2;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteDoubleAsync(Opt_two, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if(__isset.opt_three)
        {
          field.Name = "opt_three";
          field.Type = TType.I16;
          field.ID = 3;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteI16Async(Opt_three, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Opt_four != null) && __isset.opt_four)
        {
          field.Name = "opt_four";
          field.Type = TType.String;
          field.ID = 4;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteStringAsync(Opt_four, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Opt_five != null) && __isset.opt_five)
        {
          field.Name = "opt_five";
          field.Type = TType.String;
          field.ID = 5;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteBinaryAsync(Opt_five, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Opt_six != null) && __isset.opt_six)
        {
          field.Name = "opt_six";
          field.Type = TType.List;
          field.ID = 6;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteListBeginAsync(new TList(TType.I32, Opt_six.Count), cancellationToken);
            foreach (int _iter94 in Opt_six)
            {
              await oprot.WriteI32Async(_iter94, cancellationToken);
            }
            await oprot.WriteListEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Opt_seven != null) && __isset.opt_seven)
        {
          field.Name = "opt_seven";
          field.Type = TType.Set;
          field.ID = 7;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteSetBeginAsync(new TSet(TType.I64, Opt_seven.Count), cancellationToken);
            foreach (long _iter95 in Opt_seven)
            {
              await oprot.WriteI64Async(_iter95, cancellationToken);
            }
            await oprot.WriteSetEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Opt_eight != null) && __isset.opt_eight)
        {
          field.Name = "opt_eight";
          field.Type = TType.Map;
          field.ID = 8;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteMapBeginAsync(new TMap(TType.Byte, TType.I16, Opt_eight.Count), cancellationToken);
            foreach (sbyte _iter96 in Opt_eight.Keys)
            {
              await oprot.WriteByteAsync(_iter96, cancellationToken);
              await oprot.WriteI16Async(Opt_eight[_iter96], cancellationToken);
            }
            await oprot.WriteMapEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        field.Name = "req_one";
        field.Type = TType.I32;
        field.ID = 11;
        await oprot.WriteFieldBeginAsync(field, cancellationToken);
        await oprot.WriteI32Async((int)Req_one, cancellationToken);
        await oprot.WriteFieldEndAsync(cancellationToken);
        field.Name = "req_two";
        field.Type = TType.Double;
        field.ID = 12;
        await oprot.WriteFieldBeginAsync(field, cancellationToken);
        await oprot.WriteDoubleAsync(Req_two, cancellationToken);
        await oprot.WriteFieldEndAsync(cancellationToken);
        field.Name = "req_three";
        field.Type = TType.I16;
        field.ID = 13;
        await oprot.WriteFieldBeginAsync(field, cancellationToken);
        await oprot.WriteI16Async(Req_three, cancellationToken);
        await oprot.WriteFieldEndAsync(cancellationToken);
        if((Req_four != null))
        {
          field.Name = "req_four";
          field.Type = TType.String;
          field.ID = 14;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteStringAsync(Req_four, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Req_five != null))
        {
          field.Name = "req_five";
          field.Type = TType.String;
          field.ID = 15;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteBinaryAsync(Req_five, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Req_six != null))
        {
          field.Name = "req_six";
          field.Type = TType.List;
          field.ID = 16;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteListBeginAsync(new TList(TType.I32, Req_six.Count), cancellationToken);
            foreach (int _iter97 in Req_six)
            {
              await oprot.WriteI32Async(_iter97, cancellationToken);
            }
            await oprot.WriteListEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Req_seven != null))
        {
          field.Name = "req_seven";
          field.Type = TType.Set;
          field.ID = 17;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteSetBeginAsync(new TSet(TType.I64, Req_seven.Count), cancellationToken);
            foreach (long _iter98 in Req_seven)
            {
              await oprot.WriteI64Async(_iter98, cancellationToken);
            }
            await oprot.WriteSetEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Req_eight != null))
        {
          field.Name = "req_eight";
          field.Type = TType.Map;
          field.ID = 18;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteMapBeginAsync(new TMap(TType.Byte, TType.I16, Req_eight.Count), cancellationToken);
            foreach (sbyte _iter99 in Req_eight.Keys)
            {
              await oprot.WriteByteAsync(_iter99, cancellationToken);
              await oprot.WriteI16Async(Req_eight[_iter99], cancellationToken);
            }
            await oprot.WriteMapEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if(__isset.def_one)
        {
          field.Name = "def_one";
          field.Type = TType.I32;
          field.ID = 21;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteI32Async((int)Def_one, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if(__isset.def_two)
        {
          field.Name = "def_two";
          field.Type = TType.Double;
          field.ID = 22;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteDoubleAsync(Def_two, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if(__isset.def_three)
        {
          field.Name = "def_three";
          field.Type = TType.I16;
          field.ID = 23;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteI16Async(Def_three, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Def_four != null) && __isset.def_four)
        {
          field.Name = "def_four";
          field.Type = TType.String;
          field.ID = 24;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteStringAsync(Def_four, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Def_five != null) && __isset.def_five)
        {
          field.Name = "def_five";
          field.Type = TType.String;
          field.ID = 25;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteBinaryAsync(Def_five, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Def_six != null) && __isset.def_six)
        {
          field.Name = "def_six";
          field.Type = TType.List;
          field.ID = 26;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteListBeginAsync(new TList(TType.I32, Def_six.Count), cancellationToken);
            foreach (int _iter100 in Def_six)
            {
              await oprot.WriteI32Async(_iter100, cancellationToken);
            }
            await oprot.WriteListEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Def_seven != null) && __isset.def_seven)
        {
          field.Name = "def_seven";
          field.Type = TType.Set;
          field.ID = 27;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteSetBeginAsync(new TSet(TType.I64, Def_seven.Count), cancellationToken);
            foreach (long _iter101 in Def_seven)
            {
              await oprot.WriteI64Async(_iter101, cancellationToken);
            }
            await oprot.WriteSetEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Def_eight != null) && __isset.def_eight)
        {
          field.Name = "def_eight";
          field.Type = TType.Map;
          field.ID = 28;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteMapBeginAsync(new TMap(TType.Byte, TType.I16, Def_eight.Count), cancellationToken);
            foreach (sbyte _iter102 in Def_eight.Keys)
            {
              await oprot.WriteByteAsync(_iter102, cancellationToken);
              await oprot.WriteI16Async(Def_eight[_iter102], cancellationToken);
            }
            await oprot.WriteMapEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if(__isset.opt_one_with_value)
        {
          field.Name = "opt_one_with_value";
          field.Type = TType.I32;
          field.ID = 31;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteI32Async((int)Opt_one_with_value, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if(__isset.opt_two_with_value)
        {
          field.Name = "opt_two_with_value";
          field.Type = TType.Double;
          field.ID = 32;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteDoubleAsync(Opt_two_with_value, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if(__isset.opt_three_with_value)
        {
          field.Name = "opt_three_with_value";
          field.Type = TType.I16;
          field.ID = 33;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteI16Async(Opt_three_with_value, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Opt_four_with_value != null) && __isset.opt_four_with_value)
        {
          field.Name = "opt_four_with_value";
          field.Type = TType.String;
          field.ID = 34;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteStringAsync(Opt_four_with_value, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Opt_five_with_value != null) && __isset.opt_five_with_value)
        {
          field.Name = "opt_five_with_value";
          field.Type = TType.String;
          field.ID = 35;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteBinaryAsync(Opt_five_with_value, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Opt_six_with_value != null) && __isset.opt_six_with_value)
        {
          field.Name = "opt_six_with_value";
          field.Type = TType.List;
          field.ID = 36;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteListBeginAsync(new TList(TType.I32, Opt_six_with_value.Count), cancellationToken);
            foreach (int _iter103 in Opt_six_with_value)
            {
              await oprot.WriteI32Async(_iter103, cancellationToken);
            }
            await oprot.WriteListEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Opt_seven_with_value != null) && __isset.opt_seven_with_value)
        {
          field.Name = "opt_seven_with_value";
          field.Type = TType.Set;
          field.ID = 37;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteSetBeginAsync(new TSet(TType.I64, Opt_seven_with_value.Count), cancellationToken);
            foreach (long _iter104 in Opt_seven_with_value)
            {
              await oprot.WriteI64Async(_iter104, cancellationToken);
            }
            await oprot.WriteSetEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Opt_eight_with_value != null) && __isset.opt_eight_with_value)
        {
          field.Name = "opt_eight_with_value";
          field.Type = TType.Map;
          field.ID = 38;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteMapBeginAsync(new TMap(TType.Byte, TType.I16, Opt_eight_with_value.Count), cancellationToken);
            foreach (sbyte _iter105 in Opt_eight_with_value.Keys)
            {
              await oprot.WriteByteAsync(_iter105, cancellationToken);
              await oprot.WriteI16Async(Opt_eight_with_value[_iter105], cancellationToken);
            }
            await oprot.WriteMapEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        field.Name = "req_one_with_value";
        field.Type = TType.I32;
        field.ID = 41;
        await oprot.WriteFieldBeginAsync(field, cancellationToken);
        await oprot.WriteI32Async((int)Req_one_with_value, cancellationToken);
        await oprot.WriteFieldEndAsync(cancellationToken);
        field.Name = "req_two_with_value";
        field.Type = TType.Double;
        field.ID = 42;
        await oprot.WriteFieldBeginAsync(field, cancellationToken);
        await oprot.WriteDoubleAsync(Req_two_with_value, cancellationToken);
        await oprot.WriteFieldEndAsync(cancellationToken);
        field.Name = "req_three_with_value";
        field.Type = TType.I16;
        field.ID = 43;
        await oprot.WriteFieldBeginAsync(field, cancellationToken);
        await oprot.WriteI16Async(Req_three_with_value, cancellationToken);
        await oprot.WriteFieldEndAsync(cancellationToken);
        if((Req_four_with_value != null))
        {
          field.Name = "req_four_with_value";
          field.Type = TType.String;
          field.ID = 44;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteStringAsync(Req_four_with_value, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Req_five_with_value != null))
        {
          field.Name = "req_five_with_value";
          field.Type = TType.String;
          field.ID = 45;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteBinaryAsync(Req_five_with_value, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Req_six_with_value != null))
        {
          field.Name = "req_six_with_value";
          field.Type = TType.List;
          field.ID = 46;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteListBeginAsync(new TList(TType.I32, Req_six_with_value.Count), cancellationToken);
            foreach (int _iter106 in Req_six_with_value)
            {
              await oprot.WriteI32Async(_iter106, cancellationToken);
            }
            await oprot.WriteListEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Req_seven_with_value != null))
        {
          field.Name = "req_seven_with_value";
          field.Type = TType.Set;
          field.ID = 47;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteSetBeginAsync(new TSet(TType.I64, Req_seven_with_value.Count), cancellationToken);
            foreach (long _iter107 in Req_seven_with_value)
            {
              await oprot.WriteI64Async(_iter107, cancellationToken);
            }
            await oprot.WriteSetEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Req_eight_with_value != null))
        {
          field.Name = "req_eight_with_value";
          field.Type = TType.Map;
          field.ID = 48;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteMapBeginAsync(new TMap(TType.Byte, TType.I16, Req_eight_with_value.Count), cancellationToken);
            foreach (sbyte _iter108 in Req_eight_with_value.Keys)
            {
              await oprot.WriteByteAsync(_iter108, cancellationToken);
              await oprot.WriteI16Async(Req_eight_with_value[_iter108], cancellationToken);
            }
            await oprot.WriteMapEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if(__isset.def_one_with_value)
        {
          field.Name = "def_one_with_value";
          field.Type = TType.I32;
          field.ID = 51;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteI32Async((int)Def_one_with_value, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if(__isset.def_two_with_value)
        {
          field.Name = "def_two_with_value";
          field.Type = TType.Double;
          field.ID = 52;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteDoubleAsync(Def_two_with_value, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if(__isset.def_three_with_value)
        {
          field.Name = "def_three_with_value";
          field.Type = TType.I16;
          field.ID = 53;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteI16Async(Def_three_with_value, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Def_four_with_value != null) && __isset.def_four_with_value)
        {
          field.Name = "def_four_with_value";
          field.Type = TType.String;
          field.ID = 54;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteStringAsync(Def_four_with_value, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Def_five_with_value != null) && __isset.def_five_with_value)
        {
          field.Name = "def_five_with_value";
          field.Type = TType.String;
          field.ID = 55;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteBinaryAsync(Def_five_with_value, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Def_six_with_value != null) && __isset.def_six_with_value)
        {
          field.Name = "def_six_with_value";
          field.Type = TType.List;
          field.ID = 56;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteListBeginAsync(new TList(TType.I32, Def_six_with_value.Count), cancellationToken);
            foreach (int _iter109 in Def_six_with_value)
            {
              await oprot.WriteI32Async(_iter109, cancellationToken);
            }
            await oprot.WriteListEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Def_seven_with_value != null) && __isset.def_seven_with_value)
        {
          field.Name = "def_seven_with_value";
          field.Type = TType.Set;
          field.ID = 57;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteSetBeginAsync(new TSet(TType.I64, Def_seven_with_value.Count), cancellationToken);
            foreach (long _iter110 in Def_seven_with_value)
            {
              await oprot.WriteI64Async(_iter110, cancellationToken);
            }
            await oprot.WriteSetEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Def_eight_with_value != null) && __isset.def_eight_with_value)
        {
          field.Name = "def_eight_with_value";
          field.Type = TType.Map;
          field.ID = 58;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteMapBeginAsync(new TMap(TType.Byte, TType.I16, Def_eight_with_value.Count), cancellationToken);
            foreach (sbyte _iter111 in Def_eight_with_value.Keys)
            {
              await oprot.WriteByteAsync(_iter111, cancellationToken);
              await oprot.WriteI16Async(Def_eight_with_value[_iter111], cancellationToken);
            }
            await oprot.WriteMapEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if(__isset.last_of_the_mohicans)
        {
          field.Name = "last_of_the_mohicans";
          field.Type = TType.Bool;
          field.ID = 90;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await oprot.WriteBoolAsync(Last_of_the_mohicans, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Far_list != null))
        {
          field.Name = "far_list";
          field.Type = TType.List;
          field.ID = 300;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteListBeginAsync(new TList(TType.I32, Far_list.Count), cancellationToken);
            foreach (global::OptReqDefTest.Distance _iter112 in Far_list)
            {
              await oprot.WriteI32Async((int)_iter112, cancellationToken);
            }
            await oprot.WriteListEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Far_set != null) && __isset.far_set)
        {
          field.Name = "far_set";
          field.Type = TType.Set;
          field.ID = 301;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteSetBeginAsync(new TSet(TType.I32, Far_set.Count), cancellationToken);
            foreach (global::OptReqDefTest.Distance _iter113 in Far_set)
            {
              await oprot.WriteI32Async((int)_iter113, cancellationToken);
            }
            await oprot.WriteSetEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Far_map != null) && __isset.far_map)
        {
          field.Name = "far_map";
          field.Type = TType.Map;
          field.ID = 302;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteMapBeginAsync(new TMap(TType.I32, TType.I32, Far_map.Count), cancellationToken);
            foreach (global::OptReqDefTest.Distance _iter114 in Far_map.Keys)
            {
              await oprot.WriteI32Async((int)_iter114, cancellationToken);
              await oprot.WriteI32Async((int)Far_map[_iter114], cancellationToken);
            }
            await oprot.WriteMapEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Far_set_list != null))
        {
          field.Name = "far_set_list";
          field.Type = TType.Set;
          field.ID = 310;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteSetBeginAsync(new TSet(TType.List, Far_set_list.Count), cancellationToken);
            foreach (List<global::OptReqDefTest.Distance> _iter115 in Far_set_list)
            {
              {
                await oprot.WriteListBeginAsync(new TList(TType.I32, _iter115.Count), cancellationToken);
                foreach (global::OptReqDefTest.Distance _iter116 in _iter115)
                {
                  await oprot.WriteI32Async((int)_iter116, cancellationToken);
                }
                await oprot.WriteListEndAsync(cancellationToken);
              }
            }
            await oprot.WriteSetEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Far_list_map_set != null) && __isset.far_list_map_set)
        {
          field.Name = "far_list_map_set";
          field.Type = TType.List;
          field.ID = 311;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteListBeginAsync(new TList(TType.Map, Far_list_map_set.Count), cancellationToken);
            foreach (Dictionary<sbyte, THashSet<global::OptReqDefTest.Distance>> _iter117 in Far_list_map_set)
            {
              {
                await oprot.WriteMapBeginAsync(new TMap(TType.Byte, TType.Set, _iter117.Count), cancellationToken);
                foreach (sbyte _iter118 in _iter117.Keys)
                {
                  await oprot.WriteByteAsync(_iter118, cancellationToken);
                  {
                    await oprot.WriteSetBeginAsync(new TSet(TType.I32, _iter117[_iter118].Count), cancellationToken);
                    foreach (global::OptReqDefTest.Distance _iter119 in _iter117[_iter118])
                    {
                      await oprot.WriteI32Async((int)_iter119, cancellationToken);
                    }
                    await oprot.WriteSetEndAsync(cancellationToken);
                  }
                }
                await oprot.WriteMapEndAsync(cancellationToken);
              }
            }
            await oprot.WriteListEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Far_map_dist_to_rds != null) && __isset.far_map_dist_to_rds)
        {
          field.Name = "far_map_dist_to_rds";
          field.Type = TType.Map;
          field.ID = 312;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          {
            await oprot.WriteMapBeginAsync(new TMap(TType.I32, TType.List, Far_map_dist_to_rds.Count), cancellationToken);
            foreach (global::OptReqDefTest.Distance _iter120 in Far_map_dist_to_rds.Keys)
            {
              await oprot.WriteI32Async((int)_iter120, cancellationToken);
              {
                await oprot.WriteListBeginAsync(new TList(TType.Struct, Far_map_dist_to_rds[_iter120].Count), cancellationToken);
                foreach (global::OptReqDefTest.RaceDetails _iter121 in Far_map_dist_to_rds[_iter120])
                {
                  await _iter121.WriteAsync(oprot, cancellationToken);
                }
                await oprot.WriteListEndAsync(cancellationToken);
              }
            }
            await oprot.WriteMapEndAsync(cancellationToken);
          }
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Req_nested != null))
        {
          field.Name = "req_nested";
          field.Type = TType.Struct;
          field.ID = 320;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await Req_nested.WriteAsync(oprot, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Opt_nested != null) && __isset.opt_nested)
        {
          field.Name = "opt_nested";
          field.Type = TType.Struct;
          field.ID = 321;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await Opt_nested.WriteAsync(oprot, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Def_nested != null) && __isset.def_nested)
        {
          field.Name = "def_nested";
          field.Type = TType.Struct;
          field.ID = 322;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await Def_nested.WriteAsync(oprot, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Req_union != null))
        {
          field.Name = "req_union";
          field.Type = TType.Struct;
          field.ID = 330;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await Req_union.WriteAsync(oprot, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Opt_union != null) && __isset.opt_union)
        {
          field.Name = "opt_union";
          field.Type = TType.Struct;
          field.ID = 331;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await Opt_union.WriteAsync(oprot, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        if((Def_union != null) && __isset.def_union)
        {
          field.Name = "def_union";
          field.Type = TType.Struct;
          field.ID = 332;
          await oprot.WriteFieldBeginAsync(field, cancellationToken);
          await Def_union.WriteAsync(oprot, cancellationToken);
          await oprot.WriteFieldEndAsync(cancellationToken);
        }
        field.Name = "triplesix";
        field.Type = TType.I32;
        field.ID = 666;
        await oprot.WriteFieldBeginAsync(field, cancellationToken);
        await oprot.WriteI32Async((int)Triplesix, cancellationToken);
        await oprot.WriteFieldEndAsync(cancellationToken);
        await oprot.WriteFieldStopAsync(cancellationToken);
        await oprot.WriteStructEndAsync(cancellationToken);
      }
      finally
      {
        oprot.DecrementRecursionDepth();
      }
    }

    public override bool Equals(object that)
    {
      if (!(that is RaceDetails other)) return false;
      if (ReferenceEquals(this, other)) return true;
      return System.Object.Equals(Triplesix, other.Triplesix)
        && ((__isset.opt_one == other.__isset.opt_one) && ((!__isset.opt_one) || (System.Object.Equals(Opt_one, other.Opt_one))))
        && ((__isset.opt_two == other.__isset.opt_two) && ((!__isset.opt_two) || (System.Object.Equals(Opt_two, other.Opt_two))))
        && ((__isset.opt_three == other.__isset.opt_three) && ((!__isset.opt_three) || (System.Object.Equals(Opt_three, other.Opt_three))))
        && ((__isset.opt_four == other.__isset.opt_four) && ((!__isset.opt_four) || (System.Object.Equals(Opt_four, other.Opt_four))))
        && ((__isset.opt_five == other.__isset.opt_five) && ((!__isset.opt_five) || (TCollections.Equals(Opt_five, other.Opt_five))))
        && ((__isset.opt_six == other.__isset.opt_six) && ((!__isset.opt_six) || (TCollections.Equals(Opt_six, other.Opt_six))))
        && ((__isset.opt_seven == other.__isset.opt_seven) && ((!__isset.opt_seven) || (TCollections.Equals(Opt_seven, other.Opt_seven))))
        && ((__isset.opt_eight == other.__isset.opt_eight) && ((!__isset.opt_eight) || (TCollections.Equals(Opt_eight, other.Opt_eight))))
        && System.Object.Equals(Req_one, other.Req_one)
        && System.Object.Equals(Req_two, other.Req_two)
        && System.Object.Equals(Req_three, other.Req_three)
        && System.Object.Equals(Req_four, other.Req_four)
        && TCollections.Equals(Req_five, other.Req_five)
        && TCollections.Equals(Req_six, other.Req_six)
        && TCollections.Equals(Req_seven, other.Req_seven)
        && TCollections.Equals(Req_eight, other.Req_eight)
        && ((__isset.def_one == other.__isset.def_one) && ((!__isset.def_one) || (System.Object.Equals(Def_one, other.Def_one))))
        && ((__isset.def_two == other.__isset.def_two) && ((!__isset.def_two) || (System.Object.Equals(Def_two, other.Def_two))))
        && ((__isset.def_three == other.__isset.def_three) && ((!__isset.def_three) || (System.Object.Equals(Def_three, other.Def_three))))
        && ((__isset.def_four == other.__isset.def_four) && ((!__isset.def_four) || (System.Object.Equals(Def_four, other.Def_four))))
        && ((__isset.def_five == other.__isset.def_five) && ((!__isset.def_five) || (TCollections.Equals(Def_five, other.Def_five))))
        && ((__isset.def_six == other.__isset.def_six) && ((!__isset.def_six) || (TCollections.Equals(Def_six, other.Def_six))))
        && ((__isset.def_seven == other.__isset.def_seven) && ((!__isset.def_seven) || (TCollections.Equals(Def_seven, other.Def_seven))))
        && ((__isset.def_eight == other.__isset.def_eight) && ((!__isset.def_eight) || (TCollections.Equals(Def_eight, other.Def_eight))))
        && ((__isset.opt_one_with_value == other.__isset.opt_one_with_value) && ((!__isset.opt_one_with_value) || (System.Object.Equals(Opt_one_with_value, other.Opt_one_with_value))))
        && ((__isset.opt_two_with_value == other.__isset.opt_two_with_value) && ((!__isset.opt_two_with_value) || (System.Object.Equals(Opt_two_with_value, other.Opt_two_with_value))))
        && ((__isset.opt_three_with_value == other.__isset.opt_three_with_value) && ((!__isset.opt_three_with_value) || (System.Object.Equals(Opt_three_with_value, other.Opt_three_with_value))))
        && ((__isset.opt_four_with_value == other.__isset.opt_four_with_value) && ((!__isset.opt_four_with_value) || (System.Object.Equals(Opt_four_with_value, other.Opt_four_with_value))))
        && ((__isset.opt_five_with_value == other.__isset.opt_five_with_value) && ((!__isset.opt_five_with_value) || (TCollections.Equals(Opt_five_with_value, other.Opt_five_with_value))))
        && ((__isset.opt_six_with_value == other.__isset.opt_six_with_value) && ((!__isset.opt_six_with_value) || (TCollections.Equals(Opt_six_with_value, other.Opt_six_with_value))))
        && ((__isset.opt_seven_with_value == other.__isset.opt_seven_with_value) && ((!__isset.opt_seven_with_value) || (TCollections.Equals(Opt_seven_with_value, other.Opt_seven_with_value))))
        && ((__isset.opt_eight_with_value == other.__isset.opt_eight_with_value) && ((!__isset.opt_eight_with_value) || (TCollections.Equals(Opt_eight_with_value, other.Opt_eight_with_value))))
        && System.Object.Equals(Req_one_with_value, other.Req_one_with_value)
        && System.Object.Equals(Req_two_with_value, other.Req_two_with_value)
        && System.Object.Equals(Req_three_with_value, other.Req_three_with_value)
        && System.Object.Equals(Req_four_with_value, other.Req_four_with_value)
        && TCollections.Equals(Req_five_with_value, other.Req_five_with_value)
        && TCollections.Equals(Req_six_with_value, other.Req_six_with_value)
        && TCollections.Equals(Req_seven_with_value, other.Req_seven_with_value)
        && TCollections.Equals(Req_eight_with_value, other.Req_eight_with_value)
        && ((__isset.def_one_with_value == other.__isset.def_one_with_value) && ((!__isset.def_one_with_value) || (System.Object.Equals(Def_one_with_value, other.Def_one_with_value))))
        && ((__isset.def_two_with_value == other.__isset.def_two_with_value) && ((!__isset.def_two_with_value) || (System.Object.Equals(Def_two_with_value, other.Def_two_with_value))))
        && ((__isset.def_three_with_value == other.__isset.def_three_with_value) && ((!__isset.def_three_with_value) || (System.Object.Equals(Def_three_with_value, other.Def_three_with_value))))
        && ((__isset.def_four_with_value == other.__isset.def_four_with_value) && ((!__isset.def_four_with_value) || (System.Object.Equals(Def_four_with_value, other.Def_four_with_value))))
        && ((__isset.def_five_with_value == other.__isset.def_five_with_value) && ((!__isset.def_five_with_value) || (TCollections.Equals(Def_five_with_value, other.Def_five_with_value))))
        && ((__isset.def_six_with_value == other.__isset.def_six_with_value) && ((!__isset.def_six_with_value) || (TCollections.Equals(Def_six_with_value, other.Def_six_with_value))))
        && ((__isset.def_seven_with_value == other.__isset.def_seven_with_value) && ((!__isset.def_seven_with_value) || (TCollections.Equals(Def_seven_with_value, other.Def_seven_with_value))))
        && ((__isset.def_eight_with_value == other.__isset.def_eight_with_value) && ((!__isset.def_eight_with_value) || (TCollections.Equals(Def_eight_with_value, other.Def_eight_with_value))))
        && ((__isset.last_of_the_mohicans == other.__isset.last_of_the_mohicans) && ((!__isset.last_of_the_mohicans) || (System.Object.Equals(Last_of_the_mohicans, other.Last_of_the_mohicans))))
        && TCollections.Equals(Far_list, other.Far_list)
        && ((__isset.far_set == other.__isset.far_set) && ((!__isset.far_set) || (TCollections.Equals(Far_set, other.Far_set))))
        && ((__isset.far_map == other.__isset.far_map) && ((!__isset.far_map) || (TCollections.Equals(Far_map, other.Far_map))))
        && TCollections.Equals(Far_set_list, other.Far_set_list)
        && ((__isset.far_list_map_set == other.__isset.far_list_map_set) && ((!__isset.far_list_map_set) || (TCollections.Equals(Far_list_map_set, other.Far_list_map_set))))
        && ((__isset.far_map_dist_to_rds == other.__isset.far_map_dist_to_rds) && ((!__isset.far_map_dist_to_rds) || (TCollections.Equals(Far_map_dist_to_rds, other.Far_map_dist_to_rds))))
        && System.Object.Equals(Req_nested, other.Req_nested)
        && ((__isset.opt_nested == other.__isset.opt_nested) && ((!__isset.opt_nested) || (System.Object.Equals(Opt_nested, other.Opt_nested))))
        && ((__isset.def_nested == other.__isset.def_nested) && ((!__isset.def_nested) || (System.Object.Equals(Def_nested, other.Def_nested))))
        && System.Object.Equals(Req_union, other.Req_union)
        && ((__isset.opt_union == other.__isset.opt_union) && ((!__isset.opt_union) || (System.Object.Equals(Opt_union, other.Opt_union))))
        && ((__isset.def_union == other.__isset.def_union) && ((!__isset.def_union) || (System.Object.Equals(Def_union, other.Def_union))));
    }

    public override int GetHashCode() {
      int hashcode = 157;
      unchecked {
        hashcode = (hashcode * 397) + Triplesix.GetHashCode();
        if(__isset.opt_one)
        {
          hashcode = (hashcode * 397) + Opt_one.GetHashCode();
        }
        if(__isset.opt_two)
        {
          hashcode = (hashcode * 397) + Opt_two.GetHashCode();
        }
        if(__isset.opt_three)
        {
          hashcode = (hashcode * 397) + Opt_three.GetHashCode();
        }
        if((Opt_four != null) && __isset.opt_four)
        {
          hashcode = (hashcode * 397) + Opt_four.GetHashCode();
        }
        if((Opt_five != null) && __isset.opt_five)
        {
          hashcode = (hashcode * 397) + Opt_five.GetHashCode();
        }
        if((Opt_six != null) && __isset.opt_six)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Opt_six);
        }
        if((Opt_seven != null) && __isset.opt_seven)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Opt_seven);
        }
        if((Opt_eight != null) && __isset.opt_eight)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Opt_eight);
        }
        hashcode = (hashcode * 397) + Req_one.GetHashCode();
        hashcode = (hashcode * 397) + Req_two.GetHashCode();
        hashcode = (hashcode * 397) + Req_three.GetHashCode();
        if((Req_four != null))
        {
          hashcode = (hashcode * 397) + Req_four.GetHashCode();
        }
        if((Req_five != null))
        {
          hashcode = (hashcode * 397) + Req_five.GetHashCode();
        }
        if((Req_six != null))
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Req_six);
        }
        if((Req_seven != null))
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Req_seven);
        }
        if((Req_eight != null))
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Req_eight);
        }
        if(__isset.def_one)
        {
          hashcode = (hashcode * 397) + Def_one.GetHashCode();
        }
        if(__isset.def_two)
        {
          hashcode = (hashcode * 397) + Def_two.GetHashCode();
        }
        if(__isset.def_three)
        {
          hashcode = (hashcode * 397) + Def_three.GetHashCode();
        }
        if((Def_four != null) && __isset.def_four)
        {
          hashcode = (hashcode * 397) + Def_four.GetHashCode();
        }
        if((Def_five != null) && __isset.def_five)
        {
          hashcode = (hashcode * 397) + Def_five.GetHashCode();
        }
        if((Def_six != null) && __isset.def_six)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Def_six);
        }
        if((Def_seven != null) && __isset.def_seven)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Def_seven);
        }
        if((Def_eight != null) && __isset.def_eight)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Def_eight);
        }
        if(__isset.opt_one_with_value)
        {
          hashcode = (hashcode * 397) + Opt_one_with_value.GetHashCode();
        }
        if(__isset.opt_two_with_value)
        {
          hashcode = (hashcode * 397) + Opt_two_with_value.GetHashCode();
        }
        if(__isset.opt_three_with_value)
        {
          hashcode = (hashcode * 397) + Opt_three_with_value.GetHashCode();
        }
        if((Opt_four_with_value != null) && __isset.opt_four_with_value)
        {
          hashcode = (hashcode * 397) + Opt_four_with_value.GetHashCode();
        }
        if((Opt_five_with_value != null) && __isset.opt_five_with_value)
        {
          hashcode = (hashcode * 397) + Opt_five_with_value.GetHashCode();
        }
        if((Opt_six_with_value != null) && __isset.opt_six_with_value)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Opt_six_with_value);
        }
        if((Opt_seven_with_value != null) && __isset.opt_seven_with_value)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Opt_seven_with_value);
        }
        if((Opt_eight_with_value != null) && __isset.opt_eight_with_value)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Opt_eight_with_value);
        }
        hashcode = (hashcode * 397) + Req_one_with_value.GetHashCode();
        hashcode = (hashcode * 397) + Req_two_with_value.GetHashCode();
        hashcode = (hashcode * 397) + Req_three_with_value.GetHashCode();
        if((Req_four_with_value != null))
        {
          hashcode = (hashcode * 397) + Req_four_with_value.GetHashCode();
        }
        if((Req_five_with_value != null))
        {
          hashcode = (hashcode * 397) + Req_five_with_value.GetHashCode();
        }
        if((Req_six_with_value != null))
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Req_six_with_value);
        }
        if((Req_seven_with_value != null))
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Req_seven_with_value);
        }
        if((Req_eight_with_value != null))
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Req_eight_with_value);
        }
        if(__isset.def_one_with_value)
        {
          hashcode = (hashcode * 397) + Def_one_with_value.GetHashCode();
        }
        if(__isset.def_two_with_value)
        {
          hashcode = (hashcode * 397) + Def_two_with_value.GetHashCode();
        }
        if(__isset.def_three_with_value)
        {
          hashcode = (hashcode * 397) + Def_three_with_value.GetHashCode();
        }
        if((Def_four_with_value != null) && __isset.def_four_with_value)
        {
          hashcode = (hashcode * 397) + Def_four_with_value.GetHashCode();
        }
        if((Def_five_with_value != null) && __isset.def_five_with_value)
        {
          hashcode = (hashcode * 397) + Def_five_with_value.GetHashCode();
        }
        if((Def_six_with_value != null) && __isset.def_six_with_value)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Def_six_with_value);
        }
        if((Def_seven_with_value != null) && __isset.def_seven_with_value)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Def_seven_with_value);
        }
        if((Def_eight_with_value != null) && __isset.def_eight_with_value)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Def_eight_with_value);
        }
        if(__isset.last_of_the_mohicans)
        {
          hashcode = (hashcode * 397) + Last_of_the_mohicans.GetHashCode();
        }
        if((Far_list != null))
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Far_list);
        }
        if((Far_set != null) && __isset.far_set)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Far_set);
        }
        if((Far_map != null) && __isset.far_map)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Far_map);
        }
        if((Far_set_list != null))
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Far_set_list);
        }
        if((Far_list_map_set != null) && __isset.far_list_map_set)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Far_list_map_set);
        }
        if((Far_map_dist_to_rds != null) && __isset.far_map_dist_to_rds)
        {
          hashcode = (hashcode * 397) + TCollections.GetHashCode(Far_map_dist_to_rds);
        }
        if((Req_nested != null))
        {
          hashcode = (hashcode * 397) + Req_nested.GetHashCode();
        }
        if((Opt_nested != null) && __isset.opt_nested)
        {
          hashcode = (hashcode * 397) + Opt_nested.GetHashCode();
        }
        if((Def_nested != null) && __isset.def_nested)
        {
          hashcode = (hashcode * 397) + Def_nested.GetHashCode();
        }
        if((Req_union != null))
        {
          hashcode = (hashcode * 397) + Req_union.GetHashCode();
        }
        if((Opt_union != null) && __isset.opt_union)
        {
          hashcode = (hashcode * 397) + Opt_union.GetHashCode();
        }
        if((Def_union != null) && __isset.def_union)
        {
          hashcode = (hashcode * 397) + Def_union.GetHashCode();
        }
      }
      return hashcode;
    }

    public override string ToString()
    {
      var sb = new StringBuilder("RaceDetails(");
      sb.Append(", Triplesix: ");
      Triplesix.ToString(sb);
      if(__isset.opt_one)
      {
        sb.Append(", Opt_one: ");
        Opt_one.ToString(sb);
      }
      if(__isset.opt_two)
      {
        sb.Append(", Opt_two: ");
        Opt_two.ToString(sb);
      }
      if(__isset.opt_three)
      {
        sb.Append(", Opt_three: ");
        Opt_three.ToString(sb);
      }
      if((Opt_four != null) && __isset.opt_four)
      {
        sb.Append(", Opt_four: ");
        Opt_four.ToString(sb);
      }
      if((Opt_five != null) && __isset.opt_five)
      {
        sb.Append(", Opt_five: ");
        Opt_five.ToString(sb);
      }
      if((Opt_six != null) && __isset.opt_six)
      {
        sb.Append(", Opt_six: ");
        Opt_six.ToString(sb);
      }
      if((Opt_seven != null) && __isset.opt_seven)
      {
        sb.Append(", Opt_seven: ");
        Opt_seven.ToString(sb);
      }
      if((Opt_eight != null) && __isset.opt_eight)
      {
        sb.Append(", Opt_eight: ");
        Opt_eight.ToString(sb);
      }
      sb.Append(", Req_one: ");
      Req_one.ToString(sb);
      sb.Append(", Req_two: ");
      Req_two.ToString(sb);
      sb.Append(", Req_three: ");
      Req_three.ToString(sb);
      if((Req_four != null))
      {
        sb.Append(", Req_four: ");
        Req_four.ToString(sb);
      }
      if((Req_five != null))
      {
        sb.Append(", Req_five: ");
        Req_five.ToString(sb);
      }
      if((Req_six != null))
      {
        sb.Append(", Req_six: ");
        Req_six.ToString(sb);
      }
      if((Req_seven != null))
      {
        sb.Append(", Req_seven: ");
        Req_seven.ToString(sb);
      }
      if((Req_eight != null))
      {
        sb.Append(", Req_eight: ");
        Req_eight.ToString(sb);
      }
      if(__isset.def_one)
      {
        sb.Append(", Def_one: ");
        Def_one.ToString(sb);
      }
      if(__isset.def_two)
      {
        sb.Append(", Def_two: ");
        Def_two.ToString(sb);
      }
      if(__isset.def_three)
      {
        sb.Append(", Def_three: ");
        Def_three.ToString(sb);
      }
      if((Def_four != null) && __isset.def_four)
      {
        sb.Append(", Def_four: ");
        Def_four.ToString(sb);
      }
      if((Def_five != null) && __isset.def_five)
      {
        sb.Append(", Def_five: ");
        Def_five.ToString(sb);
      }
      if((Def_six != null) && __isset.def_six)
      {
        sb.Append(", Def_six: ");
        Def_six.ToString(sb);
      }
      if((Def_seven != null) && __isset.def_seven)
      {
        sb.Append(", Def_seven: ");
        Def_seven.ToString(sb);
      }
      if((Def_eight != null) && __isset.def_eight)
      {
        sb.Append(", Def_eight: ");
        Def_eight.ToString(sb);
      }
      if(__isset.opt_one_with_value)
      {
        sb.Append(", Opt_one_with_value: ");
        Opt_one_with_value.ToString(sb);
      }
      if(__isset.opt_two_with_value)
      {
        sb.Append(", Opt_two_with_value: ");
        Opt_two_with_value.ToString(sb);
      }
      if(__isset.opt_three_with_value)
      {
        sb.Append(", Opt_three_with_value: ");
        Opt_three_with_value.ToString(sb);
      }
      if((Opt_four_with_value != null) && __isset.opt_four_with_value)
      {
        sb.Append(", Opt_four_with_value: ");
        Opt_four_with_value.ToString(sb);
      }
      if((Opt_five_with_value != null) && __isset.opt_five_with_value)
      {
        sb.Append(", Opt_five_with_value: ");
        Opt_five_with_value.ToString(sb);
      }
      if((Opt_six_with_value != null) && __isset.opt_six_with_value)
      {
        sb.Append(", Opt_six_with_value: ");
        Opt_six_with_value.ToString(sb);
      }
      if((Opt_seven_with_value != null) && __isset.opt_seven_with_value)
      {
        sb.Append(", Opt_seven_with_value: ");
        Opt_seven_with_value.ToString(sb);
      }
      if((Opt_eight_with_value != null) && __isset.opt_eight_with_value)
      {
        sb.Append(", Opt_eight_with_value: ");
        Opt_eight_with_value.ToString(sb);
      }
      sb.Append(", Req_one_with_value: ");
      Req_one_with_value.ToString(sb);
      sb.Append(", Req_two_with_value: ");
      Req_two_with_value.ToString(sb);
      sb.Append(", Req_three_with_value: ");
      Req_three_with_value.ToString(sb);
      if((Req_four_with_value != null))
      {
        sb.Append(", Req_four_with_value: ");
        Req_four_with_value.ToString(sb);
      }
      if((Req_five_with_value != null))
      {
        sb.Append(", Req_five_with_value: ");
        Req_five_with_value.ToString(sb);
      }
      if((Req_six_with_value != null))
      {
        sb.Append(", Req_six_with_value: ");
        Req_six_with_value.ToString(sb);
      }
      if((Req_seven_with_value != null))
      {
        sb.Append(", Req_seven_with_value: ");
        Req_seven_with_value.ToString(sb);
      }
      if((Req_eight_with_value != null))
      {
        sb.Append(", Req_eight_with_value: ");
        Req_eight_with_value.ToString(sb);
      }
      if(__isset.def_one_with_value)
      {
        sb.Append(", Def_one_with_value: ");
        Def_one_with_value.ToString(sb);
      }
      if(__isset.def_two_with_value)
      {
        sb.Append(", Def_two_with_value: ");
        Def_two_with_value.ToString(sb);
      }
      if(__isset.def_three_with_value)
      {
        sb.Append(", Def_three_with_value: ");
        Def_three_with_value.ToString(sb);
      }
      if((Def_four_with_value != null) && __isset.def_four_with_value)
      {
        sb.Append(", Def_four_with_value: ");
        Def_four_with_value.ToString(sb);
      }
      if((Def_five_with_value != null) && __isset.def_five_with_value)
      {
        sb.Append(", Def_five_with_value: ");
        Def_five_with_value.ToString(sb);
      }
      if((Def_six_with_value != null) && __isset.def_six_with_value)
      {
        sb.Append(", Def_six_with_value: ");
        Def_six_with_value.ToString(sb);
      }
      if((Def_seven_with_value != null) && __isset.def_seven_with_value)
      {
        sb.Append(", Def_seven_with_value: ");
        Def_seven_with_value.ToString(sb);
      }
      if((Def_eight_with_value != null) && __isset.def_eight_with_value)
      {
        sb.Append(", Def_eight_with_value: ");
        Def_eight_with_value.ToString(sb);
      }
      if(__isset.last_of_the_mohicans)
      {
        sb.Append(", Last_of_the_mohicans: ");
        Last_of_the_mohicans.ToString(sb);
      }
      if((Far_list != null))
      {
        sb.Append(", Far_list: ");
        Far_list.ToString(sb);
      }
      if((Far_set != null) && __isset.far_set)
      {
        sb.Append(", Far_set: ");
        Far_set.ToString(sb);
      }
      if((Far_map != null) && __isset.far_map)
      {
        sb.Append(", Far_map: ");
        Far_map.ToString(sb);
      }
      if((Far_set_list != null))
      {
        sb.Append(", Far_set_list: ");
        Far_set_list.ToString(sb);
      }
      if((Far_list_map_set != null) && __isset.far_list_map_set)
      {
        sb.Append(", Far_list_map_set: ");
        Far_list_map_set.ToString(sb);
      }
      if((Far_map_dist_to_rds != null) && __isset.far_map_dist_to_rds)
      {
        sb.Append(", Far_map_dist_to_rds: ");
        Far_map_dist_to_rds.ToString(sb);
      }
      if((Req_nested != null))
      {
        sb.Append(", Req_nested: ");
        Req_nested.ToString(sb);
      }
      if((Opt_nested != null) && __isset.opt_nested)
      {
        sb.Append(", Opt_nested: ");
        Opt_nested.ToString(sb);
      }
      if((Def_nested != null) && __isset.def_nested)
      {
        sb.Append(", Def_nested: ");
        Def_nested.ToString(sb);
      }
      if((Req_union != null))
      {
        sb.Append(", Req_union: ");
        Req_union.ToString(sb);
      }
      if((Opt_union != null) && __isset.opt_union)
      {
        sb.Append(", Opt_union: ");
        Opt_union.ToString(sb);
      }
      if((Def_union != null) && __isset.def_union)
      {
        sb.Append(", Def_union: ");
        Def_union.ToString(sb);
      }
      sb.Append(')');
      return sb.ToString();
    }
  }

}
