/**
 * Autogenerated by Thrift Compiler (0.13.0)
 *
 * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
 *  @generated
 */
#include "DebugProtoTest_constants.h"

namespace thrift { namespace test { namespace debug {

const DebugProtoTestConstants g_DebugProtoTest_constants;

DebugProtoTestConstants::DebugProtoTestConstants() {
  COMPACT_TEST.a_byte = 127;
  COMPACT_TEST.__isset.a_byte = true;
  COMPACT_TEST.a_double = 5.6788999999999996;
  COMPACT_TEST.__isset.a_double = true;
  COMPACT_TEST.a_i16 = 32000;
  COMPACT_TEST.__isset.a_i16 = true;
  COMPACT_TEST.a_i32 = 1000000000;
  COMPACT_TEST.__isset.a_i32 = true;
  COMPACT_TEST.a_i64 = 1099511627775LL;
  COMPACT_TEST.__isset.a_i64 = true;
  COMPACT_TEST.a_string = "my string";
  COMPACT_TEST.__isset.a_string = true;
  std::map<bool, int8_t>  tmp635;
  tmp635.insert(std::make_pair(false, 0));
  tmp635.insert(std::make_pair(true, 1));

  COMPACT_TEST.boolean_byte_map = tmp635;
  COMPACT_TEST.__isset.boolean_byte_map = true;
  std::vector<bool>  tmp636;
  tmp636.push_back(true);
  tmp636.push_back(true);
  tmp636.push_back(true);
  tmp636.push_back(false);
  tmp636.push_back(false);
  tmp636.push_back(false);

  COMPACT_TEST.boolean_list = tmp636;
  COMPACT_TEST.__isset.boolean_list = true;
  std::set<bool>  tmp637;
  tmp637.insert(true);
  tmp637.insert(false);

  COMPACT_TEST.boolean_set = tmp637;
  COMPACT_TEST.__isset.boolean_set = true;
  std::map<int8_t, bool>  tmp638;
  tmp638.insert(std::make_pair(1, true));
  tmp638.insert(std::make_pair(2, false));

  COMPACT_TEST.byte_boolean_map = tmp638;
  COMPACT_TEST.__isset.byte_boolean_map = true;
  std::map<int8_t, int8_t>  tmp639;
  tmp639.insert(std::make_pair(1, 2));

  COMPACT_TEST.byte_byte_map = tmp639;
  COMPACT_TEST.__isset.byte_byte_map = true;
  std::map<int8_t, double>  tmp640;
  tmp640.insert(std::make_pair(1, 0.1000000000000000));
  tmp640.insert(std::make_pair(2, -0.1000000000000000));
  tmp640.insert(std::make_pair(3, 1000000.0999999999767169));

  COMPACT_TEST.byte_double_map = tmp640;
  COMPACT_TEST.__isset.byte_double_map = true;
  std::map<int8_t, int16_t>  tmp641;
  tmp641.insert(std::make_pair(1, 1));
  tmp641.insert(std::make_pair(2, -1));
  tmp641.insert(std::make_pair(3, 32767));

  COMPACT_TEST.byte_i16_map = tmp641;
  COMPACT_TEST.__isset.byte_i16_map = true;
  std::map<int8_t, int32_t>  tmp642;
  tmp642.insert(std::make_pair(1, 1));
  tmp642.insert(std::make_pair(2, -1));
  tmp642.insert(std::make_pair(3, 2147483647));

  COMPACT_TEST.byte_i32_map = tmp642;
  COMPACT_TEST.__isset.byte_i32_map = true;
  std::map<int8_t, int64_t>  tmp643;
  tmp643.insert(std::make_pair(1, 1LL));
  tmp643.insert(std::make_pair(2, -1LL));
  tmp643.insert(std::make_pair(3, 9223372036854775807LL));

  COMPACT_TEST.byte_i64_map = tmp643;
  COMPACT_TEST.__isset.byte_i64_map = true;
  std::vector<int8_t>  tmp644;
  tmp644.push_back(-127);
  tmp644.push_back(-1);
  tmp644.push_back(0);
  tmp644.push_back(1);
  tmp644.push_back(127);

  COMPACT_TEST.byte_list = tmp644;
  COMPACT_TEST.__isset.byte_list = true;
  std::map<int8_t, std::vector<int8_t> >  tmp645;
  std::vector<int8_t>  tmp646;

  tmp645.insert(std::make_pair(0, tmp646));
  std::vector<int8_t>  tmp647;
  tmp647.push_back(1);

  tmp645.insert(std::make_pair(1, tmp647));
  std::vector<int8_t>  tmp648;
  tmp648.push_back(1);
  tmp648.push_back(2);

  tmp645.insert(std::make_pair(2, tmp648));

  COMPACT_TEST.byte_list_map = tmp645;
  COMPACT_TEST.__isset.byte_list_map = true;
  std::map<int8_t, std::map<int8_t, int8_t> >  tmp649;
  std::map<int8_t, int8_t>  tmp650;

  tmp649.insert(std::make_pair(0, tmp650));
  std::map<int8_t, int8_t>  tmp651;
  tmp651.insert(std::make_pair(1, 1));

  tmp649.insert(std::make_pair(1, tmp651));
  std::map<int8_t, int8_t>  tmp652;
  tmp652.insert(std::make_pair(1, 1));
  tmp652.insert(std::make_pair(2, 2));

  tmp649.insert(std::make_pair(2, tmp652));

  COMPACT_TEST.byte_map_map = tmp649;
  COMPACT_TEST.__isset.byte_map_map = true;
  std::set<int8_t>  tmp653;
  tmp653.insert(-127);
  tmp653.insert(-1);
  tmp653.insert(0);
  tmp653.insert(1);
  tmp653.insert(127);

  COMPACT_TEST.byte_set = tmp653;
  COMPACT_TEST.__isset.byte_set = true;
  std::map<int8_t, std::set<int8_t> >  tmp654;
  std::set<int8_t>  tmp655;

  tmp654.insert(std::make_pair(0, tmp655));
  std::set<int8_t>  tmp656;
  tmp656.insert(1);

  tmp654.insert(std::make_pair(1, tmp656));
  std::set<int8_t>  tmp657;
  tmp657.insert(1);
  tmp657.insert(2);

  tmp654.insert(std::make_pair(2, tmp657));

  COMPACT_TEST.byte_set_map = tmp654;
  COMPACT_TEST.__isset.byte_set_map = true;
  std::map<int8_t, std::string>  tmp658;
  tmp658.insert(std::make_pair(1, ""));
  tmp658.insert(std::make_pair(2, "blah"));
  tmp658.insert(std::make_pair(3, "loooooooooooooong string"));

  COMPACT_TEST.byte_string_map = tmp658;
  COMPACT_TEST.__isset.byte_string_map = true;
  std::map<double, int8_t>  tmp659;
  tmp659.insert(std::make_pair(-1.1000000000000001, 1));
  tmp659.insert(std::make_pair(1.1000000000000001, 1));

  COMPACT_TEST.double_byte_map = tmp659;
  COMPACT_TEST.__isset.double_byte_map = true;
  std::vector<double>  tmp660;
  tmp660.push_back(0.1000000000000000);
  tmp660.push_back(0.2000000000000000);
  tmp660.push_back(0.3000000000000000);

  COMPACT_TEST.double_list = tmp660;
  COMPACT_TEST.__isset.double_list = true;
  std::set<double>  tmp661;
  tmp661.insert(0.1000000000000000);
  tmp661.insert(0.2000000000000000);
  tmp661.insert(0.3000000000000000);

  COMPACT_TEST.double_set = tmp661;
  COMPACT_TEST.__isset.double_set = true;
  Empty tmp662;

  COMPACT_TEST.empty_struct_field = tmp662;
  COMPACT_TEST.__isset.empty_struct_field = true;
  COMPACT_TEST.false_field = false;
  COMPACT_TEST.__isset.false_field = true;
  COMPACT_TEST.field20000 = 20000LL;
  COMPACT_TEST.__isset.field20000 = true;
  COMPACT_TEST.field500 = 500LL;
  COMPACT_TEST.__isset.field500 = true;
  COMPACT_TEST.field5000 = 5000LL;
  COMPACT_TEST.__isset.field5000 = true;
  std::map<int16_t, int8_t>  tmp663;
  tmp663.insert(std::make_pair(-1, 1));
  tmp663.insert(std::make_pair(1, 1));
  tmp663.insert(std::make_pair(32767, 1));

  COMPACT_TEST.i16_byte_map = tmp663;
  COMPACT_TEST.__isset.i16_byte_map = true;
  std::vector<int16_t>  tmp664;
  tmp664.push_back(-1);
  tmp664.push_back(0);
  tmp664.push_back(1);
  tmp664.push_back(32767);

  COMPACT_TEST.i16_list = tmp664;
  COMPACT_TEST.__isset.i16_list = true;
  std::set<int16_t>  tmp665;
  tmp665.insert(-1);
  tmp665.insert(0);
  tmp665.insert(1);
  tmp665.insert(32767);

  COMPACT_TEST.i16_set = tmp665;
  COMPACT_TEST.__isset.i16_set = true;
  std::map<int32_t, int8_t>  tmp666;
  tmp666.insert(std::make_pair(-1, 1));
  tmp666.insert(std::make_pair(1, 1));
  tmp666.insert(std::make_pair(2147483647, 1));

  COMPACT_TEST.i32_byte_map = tmp666;
  COMPACT_TEST.__isset.i32_byte_map = true;
  std::vector<int32_t>  tmp667;
  tmp667.push_back(-1);
  tmp667.push_back(0);
  tmp667.push_back(255);
  tmp667.push_back(65535);
  tmp667.push_back(16777215);
  tmp667.push_back(2147483647);

  COMPACT_TEST.i32_list = tmp667;
  COMPACT_TEST.__isset.i32_list = true;
  std::set<int32_t>  tmp668;
  tmp668.insert(1);
  tmp668.insert(2);
  tmp668.insert(3);

  COMPACT_TEST.i32_set = tmp668;
  COMPACT_TEST.__isset.i32_set = true;
  std::map<int64_t, int8_t>  tmp669;
  tmp669.insert(std::make_pair(-1LL, 1));
  tmp669.insert(std::make_pair(0LL, 1));
  tmp669.insert(std::make_pair(1LL, 1));
  tmp669.insert(std::make_pair(9223372036854775807LL, 1));

  COMPACT_TEST.i64_byte_map = tmp669;
  COMPACT_TEST.__isset.i64_byte_map = true;
  std::vector<int64_t>  tmp670;
  tmp670.push_back(-1LL);
  tmp670.push_back(0LL);
  tmp670.push_back(255LL);
  tmp670.push_back(65535LL);
  tmp670.push_back(16777215LL);
  tmp670.push_back(4294967295LL);
  tmp670.push_back(1099511627775LL);
  tmp670.push_back(281474976710655LL);
  tmp670.push_back(72057594037927935LL);
  tmp670.push_back(9223372036854775807LL);

  COMPACT_TEST.i64_list = tmp670;
  COMPACT_TEST.__isset.i64_list = true;
  std::set<int64_t>  tmp671;
  tmp671.insert(-1LL);
  tmp671.insert(0LL);
  tmp671.insert(255LL);
  tmp671.insert(65535LL);
  tmp671.insert(16777215LL);
  tmp671.insert(4294967295LL);
  tmp671.insert(1099511627775LL);
  tmp671.insert(281474976710655LL);
  tmp671.insert(72057594037927935LL);
  tmp671.insert(9223372036854775807LL);

  COMPACT_TEST.i64_set = tmp671;
  COMPACT_TEST.__isset.i64_set = true;
  std::map<std::vector<int8_t> , int8_t>  tmp672;
  std::vector<int8_t>  tmp673;

  tmp672.insert(std::make_pair(tmp673, 0));
  std::vector<int8_t>  tmp674;
  tmp674.push_back(0);
  tmp674.push_back(1);

  tmp672.insert(std::make_pair(tmp674, 2));
  std::vector<int8_t>  tmp675;
  tmp675.push_back(1);
  tmp675.push_back(2);
  tmp675.push_back(3);

  tmp672.insert(std::make_pair(tmp675, 1));

  COMPACT_TEST.list_byte_map = tmp672;
  COMPACT_TEST.__isset.list_byte_map = true;
  std::map<std::map<int8_t, int8_t> , int8_t>  tmp676;
  std::map<int8_t, int8_t>  tmp677;

  tmp676.insert(std::make_pair(tmp677, 0));
  std::map<int8_t, int8_t>  tmp678;
  tmp678.insert(std::make_pair(1, 1));

  tmp676.insert(std::make_pair(tmp678, 1));
  std::map<int8_t, int8_t>  tmp679;
  tmp679.insert(std::make_pair(2, 2));

  tmp676.insert(std::make_pair(tmp679, 2));

  COMPACT_TEST.map_byte_map = tmp676;
  COMPACT_TEST.__isset.map_byte_map = true;
  std::map<std::set<int8_t> , int8_t>  tmp680;
  std::set<int8_t>  tmp681;

  tmp680.insert(std::make_pair(tmp681, 0));
  std::set<int8_t>  tmp682;
  tmp682.insert(0);
  tmp682.insert(1);

  tmp680.insert(std::make_pair(tmp682, 2));
  std::set<int8_t>  tmp683;
  tmp683.insert(1);
  tmp683.insert(2);
  tmp683.insert(3);

  tmp680.insert(std::make_pair(tmp683, 1));

  COMPACT_TEST.set_byte_map = tmp680;
  COMPACT_TEST.__isset.set_byte_map = true;
  std::map<std::string, int8_t>  tmp684;
  tmp684.insert(std::make_pair("", 0));
  tmp684.insert(std::make_pair("first", 1));
  tmp684.insert(std::make_pair("second", 2));
  tmp684.insert(std::make_pair("third", 3));

  COMPACT_TEST.string_byte_map = tmp684;
  COMPACT_TEST.__isset.string_byte_map = true;
  std::vector<std::string>  tmp685;
  tmp685.push_back("first");
  tmp685.push_back("second");
  tmp685.push_back("third");

  COMPACT_TEST.string_list = tmp685;
  COMPACT_TEST.__isset.string_list = true;
  std::set<std::string>  tmp686;
  tmp686.insert("first");
  tmp686.insert("second");
  tmp686.insert("third");

  COMPACT_TEST.string_set = tmp686;
  COMPACT_TEST.__isset.string_set = true;
  std::vector<Empty>  tmp687;
  Empty tmp688;

  tmp687.push_back(tmp688);
  Empty tmp689;

  tmp687.push_back(tmp689);

  COMPACT_TEST.struct_list = tmp687;
  COMPACT_TEST.__isset.struct_list = true;
  std::set<Empty>  tmp690;
  Empty tmp691;

  tmp690.insert(tmp691);

  COMPACT_TEST.struct_set = tmp690;
  COMPACT_TEST.__isset.struct_set = true;
  COMPACT_TEST.true_field = true;
  COMPACT_TEST.__isset.true_field = true;

  MYCONST = 2;

  MY_SOME_ENUM = (SomeEnum::type)1;

  MY_SOME_ENUM_1 = (SomeEnum::type)1;

  MY_ENUM_MAP.insert(std::make_pair((SomeEnum::type)1, (SomeEnum::type)2));

  StructWithSomeEnum tmp692;
  tmp692.blah = (SomeEnum::type)2;
  tmp692.__isset.blah = true;

  EXTRA_CRAZY_MAP.insert(std::make_pair((SomeEnum::type)1, tmp692));

}

}}} // namespace

