// File: /workspace/github_cpp_makefile_star2_O2/zyLiu6707[P]Arknights-Pull-Simulation/./utils.h
// Function: process_cmd_input_and_set_corres_var(int, char**, ProbabilityWrapper&, unsigned long long&, unsigned int&, unsigned long long&)
bool process_cmd_input_and_set_corres_var(
    int argc, char* argv[], ProbabilityWrapper& probability_wrapper,
    unsigned long long int& total_pull_time,
    unsigned int& pity_starting_point, unsigned long long int& current_pull) {
  const int expected_max_arg_num = 10;
  if (argc > expected_max_arg_num) {
    std::cerr << "\nToo many arguments!\n" << std::endl;
    display_help_message();
    return false;
  }
  if (argc == 1) {
    std::cerr << "\nNote: No arguments are provided. Will simulate a double-rate-up limited banner.\n" << std::endl;
    return true;
  }

  // Control arguments are those that can specify the behavior of the
  // program, i.e., display help message, simulate a standard banner or
  // a limited banner, etc. Starts with at lease one dash '-'
  std::unordered_set<std::string> expected_control_arg(
      {"--help", "-t", "--total-pull-time", "--limited", "--standard", "-p",
       "--pity", "-n", "--num-rate-up", "-c", "--current-pull"});

  // Store control argument as arg_map's key, and ctrl arg's value as arg_map's
  // value. 
  // The content in this map will be checked and conrresponding error
  // flag will be set if corresponding type of error is detected.
  std::unordered_map<std::string, std::vector<std::string>> arg_map;

  // A wrapper class for different kinds of error flags
  ErrorFlag error_flag;

  // Parse the inputs
  int curr_ctrl_arg_idx = 0;
  bool skip_identical_ctrl_arg = false;
  for (int i = 1; i < argc; ++i) {
    // Starts with a '-' and the second char (if exists) is not a number,
    // then we regards this is an (attempted) control arugments
    // Note: isdigit will regard the '\0' in argv as a non-number character
    if (argv[i][0] == '-' && !isdigit(argv[i][1])) {
      if (arg_map.count(argv[i]) > 0) {
        skip_identical_ctrl_arg = true;
        if (expected_control_arg.find(argv[i]) != expected_control_arg.end()) {
          error_flag.err_redundant_identical_ctrl_arg = true;
        }
        continue;
      }
      arg_map[argv[i]];
      curr_ctrl_arg_idx = i;
      skip_identical_ctrl_arg = false;
    } else if (!skip_identical_ctrl_arg &&
               arg_map.size() > 0)  // to avoid the case like "./<prog_name> 2"
                                    // that will insert the value 2 into arg_map
    {
      arg_map[argv[curr_ctrl_arg_idx]].push_back(argv[i]);
    }
  }

#ifdef DEBUG  // this function will be executed when debugging
  print_arg_map_contents(arg_map);
#endif

  // If --help is specified, ignore all other arguments and print the help
  // message
  if (arg_map.find("--help") != arg_map.end()) {
    if (argc == 2) {
      display_help_message();
      return false;
    } else {
      // If --help and other arguments are specified at the same time, show the
      // appropriate message
      error_flag.err_help_ctrl_arg_with_other_args = true;
    }
  }

  // Now check whether the command line arguments are invalid
  const auto iter_total_pull_time = arg_map.find("-t");
  const auto iter_total_pull_time_long_name = arg_map.find("--total-pull-time");
  const auto iter_pity = arg_map.find("-p");
  const auto iter_pity_long_name = arg_map.find("--pity");
  const auto iter_num_rate_up = arg_map.find("-n");
  const auto iter_num_rate_up_long_name = arg_map.find("--num-rate-up");
  const auto iter_current_pull = arg_map.find("-c");
  const auto iter_current_pull_long_name = arg_map.find("--current-pull");

  // Check whether the first argument (i.e., argv[1]) is an unexpected arg
  if (argv[1][0] != '-' || isdigit(argv[1][1])) {
    error_flag.err_unexpected_arguments_at_the_beginning = true;
  }
  // Check whether there is invalid control arg
  for (const auto& p : arg_map) {
    if (expected_control_arg.find(p.first) == expected_control_arg.end()) {
      error_flag.err_invalid_ctrl_args = true;
      error_flag.invalid_ctrl_args_list.push_back(p.first);
    }
  }
  // Check whether the short name and the long name of the same type of ctrl
  // arg are specified at the same time
  if (iter_total_pull_time != arg_map.end() &&
      iter_total_pull_time_long_name != arg_map.end()) {
    error_flag.err_redundant_total_pull_time_ctrl_arg = true;
  }
  if (iter_pity != arg_map.end() && iter_pity_long_name != arg_map.end()) {
    error_flag.err_redundant_pity_ctrl_arg = true;
  }
  if (iter_num_rate_up != arg_map.end() &&
      iter_num_rate_up_long_name != arg_map.end()) {
    error_flag.err_redundant_num_rate_up_ctrl_arg = true;
  }
  if (iter_current_pull != arg_map.end() &&
      iter_current_pull_long_name != arg_map.end()) {
    error_flag.err_redundant_current_pull_ctrl_arg = true;
  }

  // Check whether conflict control arguments are provided,
  // i.e., --standard and --limited are both provided
  if (arg_map.find("--standard") != arg_map.end() &&
      arg_map.find("--limited") != arg_map.end()) {
    error_flag.err_conflict_ctrl_arg_flag = true;
  }

  // Check whether missing a specific value for control arguments that expect one,
  // i.e., -t/--total-pull-time, -p/--pity, -n/--num-rate-up and -c/--current-pull
  if (iter_total_pull_time != arg_map.cend() &&
      iter_total_pull_time->second.size() == 0) {
    error_flag.err_missing_value_for_total_pull_time_ctrl_arg = true;
  } else if (iter_total_pull_time_long_name != arg_map.cend() &&
             iter_total_pull_time_long_name->second.size() == 0) {
    error_flag.err_missing_value_for_total_pull_time_long_name_ctrl_arg = true;
  }

  if (iter_pity != arg_map.cend() && iter_pity->second.size() == 0) {
    error_flag.err_missing_value_for_pity_ctrl_arg = true;
  } else if (iter_pity_long_name != arg_map.cend() &&
             iter_pity_long_name->second.size() == 0) {
    error_flag.err_missing_value_for_pity_long_name_ctrl_arg = true;
  }

  if (iter_num_rate_up != arg_map.cend() &&
      iter_num_rate_up->second.size() == 0) {
    error_flag.err_missing_value_for_num_rate_up_ctrl_arg = true;
  } else if (iter_num_rate_up_long_name != arg_map.cend() &&
             iter_num_rate_up_long_name->second.size() == 0) {
    error_flag.err_missing_value_for_num_rate_up_long_name_ctrl_arg = true;
  }

  if (iter_current_pull != arg_map.cend() &&
      iter_current_pull->second.size() == 0) {
    error_flag.err_missing_value_for_current_pull_ctrl_arg = true;
  } else if (iter_current_pull_long_name != arg_map.cend() &&
             iter_current_pull_long_name->second.size() == 0) {
    error_flag.err_missing_value_for_current_pull_long_name_ctrl_arg = true;
  }

  // Check the format of specific value for control arguments that expect one.
  // If the format is correct, then retrieve the argument value by converting
  // string to integer
  // To receive the final value if valid, max value is 2^64 - 1
  unsigned long long int total_pull_time_temp = 0;
  // To check whether provided a negative value
  long long int total_pull_time_temp_compare = 0;
  if (iter_total_pull_time != arg_map.cend()) {
    if (iter_total_pull_time->second.size() > 1) {
      error_flag.err_invalid_value_for_total_pull_time_ctrl_arg = true;
    }
    // Must be a non-empty vector to be able call strtol
    else if (iter_total_pull_time->second.size() > 0) {
      char* p_end = nullptr;
      char* p_end_compare = nullptr;
      total_pull_time_temp =
          strtoull(iter_total_pull_time->second[0].c_str(), &p_end, 10);
      total_pull_time_temp_compare =
          strtoll(iter_total_pull_time->second[0].c_str(), &p_end_compare, 10);
      if (*p_end != '\0' || *p_end_compare != '\0' ||  // not a number
          total_pull_time_temp_compare <= 0            // non positive value
      ) {
        error_flag.err_invalid_value_for_total_pull_time_ctrl_arg = true;
      }
    }
  }
  if (iter_total_pull_time_long_name != arg_map.cend()) {
    if (iter_total_pull_time_long_name->second.size() > 1) {
      error_flag.err_invalid_value_for_total_pull_time_long_name_ctrl_arg = true;
    } else if (iter_total_pull_time_long_name->second.size() > 0) {
      char* p_end = nullptr;
      char* p_end_compare = nullptr;
      total_pull_time_temp = strtoull(
          iter_total_pull_time_long_name->second[0].c_str(), &p_end, 10);
      total_pull_time_temp_compare =
          strtoll(iter_total_pull_time_long_name->second[0].c_str(),
                  &p_end_compare, 10);
      if (*p_end != '\0' || *p_end_compare != '\0' ||  // not a number
          total_pull_time_temp_compare <= 0            // non positive value
      ) {
        error_flag.err_invalid_value_for_total_pull_time_long_name_ctrl_arg =
            true;
      }
    }
  }

  unsigned long long int pity_starting_temp = 50;
  long long int pity_starting_temp_compare = 50;
  if (iter_pity != arg_map.cend()) {
    if (iter_pity->second.size() > 1) {
      error_flag.err_invalid_value_for_pity_ctrl_arg = true;
    } else if (iter_pity->second.size() > 0) {
      char* p_end = nullptr;
      char* p_end_compare = nullptr;
      pity_starting_temp = strtoull(iter_pity->second[0].c_str(), &p_end, 10);
      pity_starting_temp_compare =
          strtoll(iter_pity->second[0].c_str(), &p_end_compare, 10);
      if (*p_end != '\0' || *p_end_compare != '\0' ||
          pity_starting_temp_compare < 0) {
        error_flag.err_invalid_value_for_pity_ctrl_arg = true;
      }
      // Shrink the big value to atmost 2^32 - 1
      pity_starting_temp = (pity_starting_temp <= max_pity_starting_point)
                                ? pity_starting_temp
                                : max_pity_starting_point;
    }
  }
  if (iter_pity_long_name != arg_map.cend()) {
    if (iter_pity_long_name->second.size() > 1) {
      error_flag.err_invalid_value_for_pity_long_name_ctrl_arg = true;
    } else if (iter_pity_long_name->second.size() > 0) {
      char* p_end = nullptr;
      char* p_end_compare = nullptr;
      pity_starting_temp =
          strtoul(iter_pity_long_name->second[0].c_str(), &p_end, 10);
      pity_starting_temp_compare =
          strtol(iter_pity_long_name->second[0].c_str(), &p_end_compare, 10);
      if (*p_end != '\0' || *p_end_compare != '\0' ||
          pity_starting_temp_compare < 0) {
        error_flag.err_invalid_value_for_pity_long_name_ctrl_arg = true;
      }
      // Shrink the big value to atmost 2^32 - 1
      pity_starting_temp = (pity_starting_temp <= max_pity_starting_point)
                                ? pity_starting_temp
                                : max_pity_starting_point;
    }
  }

  long int num_rate_up_temp = -1;
  if (iter_num_rate_up != arg_map.cend()) {
    if (iter_num_rate_up->second.size() > 1) {
      error_flag.err_invalid_value_for_num_rate_up_ctrl_arg = true;
    } else if (iter_num_rate_up->second.size() > 0) {
      char* p_end = nullptr;
      num_rate_up_temp =
          strtol(iter_num_rate_up->second[0].c_str(), &p_end, 10);
      if (*p_end != '\0' || (num_rate_up_temp != 1 && num_rate_up_temp != 2)) {
        error_flag.err_invalid_value_for_num_rate_up_ctrl_arg = true;
      }
    }
  }
  if (iter_num_rate_up_long_name != arg_map.cend()) {
    if (iter_num_rate_up_long_name->second.size() > 1) {
      error_flag.err_invalid_value_for_num_rate_up_long_name_ctrl_arg = true;
    } else if (iter_num_rate_up_long_name->second.size() > 0) {
      char* p_end = nullptr;
      num_rate_up_temp =
          strtol(iter_num_rate_up_long_name->second[0].c_str(), &p_end, 10);
      if (*p_end != '\0' || (num_rate_up_temp != 1 && num_rate_up_temp != 2)) {
        error_flag.err_invalid_value_for_num_rate_up_long_name_ctrl_arg = true;
      }
    }
  }

  unsigned long long int current_pull_temp = 0;
  long long int current_pull_temp_compare = 0;
  if (iter_current_pull != arg_map.cend()) {
    if (iter_current_pull->second.size() > 1) {
      error_flag.err_invalid_value_for_current_pull_ctrl_arg = true;
    } else if (iter_current_pull->second.size() > 0) {
      char* p_end = nullptr;
      char* p_end_compare = nullptr;
      current_pull_temp =
          strtoull(iter_current_pull->second[0].c_str(), &p_end, 10);
      current_pull_temp_compare =
          strtoll(iter_current_pull->second[0].c_str(), &p_end_compare, 10);
      if (*p_end != '\0' || *p_end_compare != '\0' ||
          current_pull_temp_compare < 0) {
        error_flag.err_invalid_value_for_current_pull_ctrl_arg = true;
      }
      // Now we need to check whether the value of -c|--current-pull exceeds its
      // biggest valid value, i.e., <-p|--pity + 49>
      if (current_pull_temp >= pity_starting_temp + steps_to_guaranteed_star6) {
        error_flag.err_invalid_value_for_current_pull_ctrl_arg = true;
      }
    }
  }
  if (iter_current_pull_long_name != arg_map.cend()) {
    if (iter_current_pull_long_name->second.size() > 1) {
      error_flag.err_invalid_value_for_current_pull_ctrl_arg = true;
    } else if (iter_current_pull_long_name->second.size() > 0) {
      char* p_end = nullptr;
      char* p_end_compare = nullptr;
      current_pull_temp =
          strtoull(iter_current_pull_long_name->second[0].c_str(), &p_end, 10);
      current_pull_temp_compare = strtoll(
          iter_current_pull_long_name->second[0].c_str(), &p_end_compare, 10);
      if (*p_end != '\0' || *p_end_compare != '\0' ||
          current_pull_temp_compare < 0) {
        error_flag.err_invalid_value_for_current_pull_ctrl_arg = true;
      }
      if (current_pull_temp >= pity_starting_temp + steps_to_guaranteed_star6) {
        error_flag.err_invalid_value_for_current_pull_long_name_ctrl_arg = true;
      }
    }
  }

  // Check whether there is unexpected values for the control
  // arguments --standard and --limited
  if (arg_map.count("--standard") == 1 && arg_map["--standard"].size() != 0) {
    error_flag.err_unexpected_value_for_ctrl_arg_standard = true;
  }
  if (arg_map.count("--limited") == 1 && arg_map["--limited"].size() != 0) {
    error_flag.err_unexpected_value_for_ctrl_arg_limited = true;
  }

  display_error_detail(error_flag);

  // Command line input is valid, now set the fields ProbabilityWrapper
  if (!error_flag.check_err()) {
    if (arg_map.find("--standard") != arg_map.end()) {
      probability_wrapper.set_on_banner_star6_conditional_rate(
          standard_banner_on_banner_star6_conditional_rate);
    } else if (arg_map.find("--limited") != arg_map.end()) {
      probability_wrapper.set_on_banner_star6_conditional_rate(
          limited_banner_on_banner_star6_conditional_rate);
    }
    // Set the value of -t|--total-pull-time
    if (iter_total_pull_time != arg_map.cend()) {
      assert(iter_total_pull_time->second.size() == 1);
      total_pull_time = total_pull_time_temp;
    }
    if (iter_total_pull_time_long_name != arg_map.cend()) {
      assert(iter_total_pull_time_long_name->second.size() == 1);
      total_pull_time = total_pull_time_temp;
    }
    // Set the value of -p|--pity
    if (iter_pity != arg_map.cend()) {
      assert(iter_pity->second.size() == 1);
      assert(pity_starting_point <= max_pity_starting_point);
      pity_starting_point = static_cast<unsigned int>(pity_starting_temp);
    }
    if (iter_pity_long_name != arg_map.cend()) {
      assert(iter_pity_long_name->second.size() == 1);
      assert(pity_starting_point <= max_pity_starting_point);
      pity_starting_point = static_cast<unsigned int>(pity_starting_temp);
    }
    // Set the value of -n|--num-rate-up
    if (iter_num_rate_up != arg_map.cend()) {
      assert(iter_num_rate_up->second.size() == 1);
      probability_wrapper.set_banner_operator_num(num_rate_up_temp);
    }
    if (iter_num_rate_up_long_name != arg_map.cend()) {
      assert(iter_num_rate_up_long_name->second.size() == 1);
      probability_wrapper.set_banner_operator_num(num_rate_up_temp);
    }
    // Set the value of -c|--current-pull
    if (iter_current_pull != arg_map.end()) {
      assert(iter_current_pull->second.size() == 1);
      current_pull = current_pull_temp;
    }
    if (iter_current_pull_long_name != arg_map.end()) {
      assert(iter_current_pull_long_name->second.size() == 1);
      current_pull = current_pull_temp;
    }
  }

  return !error_flag.check_err();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp            # imm = 0x298
cmpl $0xb, %edi
jl 0x2848
movq 0x87c8(%rip), %rdi      # 0xaff0
leaq 0x46ad(%rip), %rsi      # 0x6edc
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
callq 0x2488
xorl %ebx, %ebx
jmp 0x382f
cmpl $0x1, %edi
jne 0x286f
movq 0x879c(%rip), %rdi      # 0xaff0
leaq 0x4697(%rip), %rsi      # 0x6ef2
callq 0x21a0
movq %rax, %rdi
callq 0x20c0
movb $0x1, %bl
jmp 0x382f
movq %r9, %rbx
movq %rdx, %r12
movq %rsi, %r13
movl %edi, 0x40(%rsp)
movq %rcx, 0xf8(%rsp)
movq %r8, 0xf0(%rsp)
leaq 0x46b1(%rip), %rsi      # 0x6f44
leaq 0x100(%rsp), %r14
leaq 0x80(%rsp), %rdx
movq %r14, %rdi
callq 0x46f8
leaq 0x120(%rsp), %r15
leaq 0x4691(%rip), %rsi      # 0x6f4b
leaq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x46f8
leaq 0x140(%rsp), %r15
leaq 0x4678(%rip), %rsi      # 0x6f4e
leaq 0x48(%rsp), %rdx
movq %r15, %rdi
callq 0x46f8
leaq 0x160(%rsp), %r15
leaq 0x466e(%rip), %rsi      # 0x6f60
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x46f8
leaq 0x180(%rsp), %r15
leaq 0x465c(%rip), %rsi      # 0x6f6a
leaq 0xe(%rsp), %rdx
movq %r15, %rdi
callq 0x46f8
leaq 0x1a0(%rsp), %r15
leaq 0x464b(%rip), %rsi      # 0x6f75
leaq 0x7f(%rsp), %rdx
movq %r15, %rdi
callq 0x46f8
leaq 0x1c0(%rsp), %r15
leaq 0x4632(%rip), %rsi      # 0x6f78
leaq 0x7e(%rsp), %rdx
movq %r15, %rdi
callq 0x46f8
leaq 0x1e0(%rsp), %r15
leaq 0x461d(%rip), %rsi      # 0x6f7f
leaq 0x7d(%rsp), %rdx
movq %r15, %rdi
callq 0x46f8
leaq 0x200(%rsp), %r15
leaq 0x4604(%rip), %rsi      # 0x6f82
leaq 0x7c(%rsp), %rdx
movq %r15, %rdi
callq 0x46f8
leaq 0x220(%rsp), %r15
leaq 0x45f6(%rip), %rsi      # 0x6f90
leaq 0x7b(%rsp), %rdx
movq %r15, %rdi
callq 0x46f8
leaq 0x240(%rsp), %r15
leaq 0x45dd(%rip), %rsi      # 0x6f93
leaq 0x7a(%rsp), %rdx
movq %r15, %rdi
callq 0x46f8
leaq 0x260(%rsp), %rdx
leaq 0x77(%rsp), %rax
movq %rax, (%rsp)
leaq 0x260(%rsp), %rdi
leaq 0x100(%rsp), %rsi
leaq 0x79(%rsp), %r8
leaq 0x78(%rsp), %r9
xorl %ecx, %ecx
callq 0x4c3c
movq %r12, 0xd8(%rsp)
movq %rbx, 0xe8(%rsp)
movl $0x140, %ebx            # imm = 0x140
leaq (%rsp,%rbx), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x20b0
addq $-0x20, %rbx
cmpq $-0x20, %rbx
jne 0x2a0a
leaq 0x130(%rsp), %rax
movq %rax, -0x30(%rax)
movq $0x1, -0x28(%rax)
xorps %xmm0, %xmm0
movups %xmm0, -0x20(%rax)
movl $0x3f800000, -0x10(%rax) # imm = 0x3F800000
movups %xmm0, -0x8(%rax)
leaq 0xa0(%rsp), %rax
movaps %xmm0, (%rax)
andq $0x0, 0x10(%rax)
movaps %xmm0, -0x20(%rax)
movups %xmm0, -0x15(%rax)
movslq 0x40(%rsp), %rbx
movl $0x0, 0x38(%rsp)
pushq $0x1
popq %r12
leaq 0x10(%rsp), %r14
leaq 0x48(%rsp), %r15
xorl %eax, %eax
cmpq %rbx, %r12
jge 0x2bb1
movq (%r13,%r12,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x2a9e
movsbl 0x1(%rsi), %ecx
addl $-0x30, %ecx
cmpl $0xa, %ecx
jae 0x2b13
cmpq $0x0, 0x118(%rsp)
sete %cl
orb %al, %cl
testb $0x1, %cl
jne 0x2ba9
movslq 0x38(%rsp), %rax
movq (%r13,%rax,8), %rsi
movq %r14, %rdi
leaq 0xf(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
movq %r14, %rsi
callq 0x527a
movq %rax, %rbp
movq (%r13,%r12,8), %rsi
movq %r15, %rdi
leaq 0xe(%rsp), %rdx
callq 0x46f8
movq %rbp, %rdi
movq %r15, %rsi
callq 0x55e0
movq %r15, %rdi
callq 0x20b0
movq %r14, %rdi
callq 0x20b0
xorl %eax, %eax
jmp 0x2ba9
movq %r14, %rdi
movq %r15, %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
movq %r14, %rsi
callq 0x5168
movq %rax, %rbp
movq %r14, %rdi
callq 0x20b0
testq %rbp, %rbp
je 0x2b7a
movq (%r13,%r12,8), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x46f8
leaq 0x260(%rsp), %rdi
movq %r14, %rsi
callq 0x524c
movq %rax, %rbp
movq %r14, %rdi
callq 0x20b0
movb $0x1, %al
testq %rbp, %rbp
je 0x2ba9
movb $0x1, 0x80(%rsp)
jmp 0x2ba9
movq (%r13,%r12,8), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
movq %r14, %rsi
callq 0x527a
movq %r14, %rdi
callq 0x20b0
xorl %eax, %eax
movl %r12d, 0x38(%rsp)
incq %r12
jmp 0x2a7f
leaq 0x438c(%rip), %rsi      # 0x6f44
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xa0(%rsp), %r12
callq 0x57a8
movl 0x40(%rsp), %ebp
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20b0
testq %rbx, %rbx
je 0x2c10
cmpl $0x2, %ebp
jne 0x2c08
callq 0x2488
xorl %ebx, %ebx
jmp 0x380d
movb $0x1, 0x99(%rsp)
leaq 0x4334(%rip), %rsi      # 0x6f4b
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57a8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x4302(%rip), %rsi      # 0x6f4e
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57a8
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x42f4(%rip), %rsi      # 0x6f75
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57a8
movq %rax, 0xc8(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x42bd(%rip), %rsi      # 0x6f78
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57a8
movq %rax, 0xc0(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x428a(%rip), %rsi      # 0x6f7f
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57a8
movq %rax, 0xd0(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x4253(%rip), %rsi      # 0x6f82
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57a8
movq %rax, 0x40(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x422a(%rip), %rsi      # 0x6f90
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57a8
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x41f8(%rip), %rsi      # 0x6f93
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57a8
movq %rax, 0x38(%rsp)
movq %rbx, 0x30(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x20b0
movq 0x8(%r13), %rax
cmpb $0x2d, (%rax)
jne 0x2de5
movsbl 0x1(%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x2ded
movb $0x1, 0x98(%rsp)
movq 0x110(%rsp), %rbx
leaq 0x260(%rsp), %r13
testq %rbx, %rbx
je 0x2e2e
leaq 0x8(%rbx), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x524c
testq %rax, %rax
jne 0x2e29
movb $0x1, 0x9a(%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0x4734
movq (%rbx), %rbx
jmp 0x2dfd
movq 0x30(%rsp), %rbx
testq %rbx, %rbx
setne %al
testq %r15, %r15
setne %cl
testb %cl, %al
je 0x2e4b
movb $0x1, 0x81(%rsp)
cmpq $0x0, 0xc8(%rsp)
setne %al
cmpq $0x0, 0xc0(%rsp)
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2e72
movb $0x1, 0x86(%rsp)
cmpq $0x0, 0xd0(%rsp)
setne %al
cmpq $0x0, 0x40(%rsp)
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2e96
movb $0x1, 0x8b(%rsp)
testq %r14, %r14
setne %al
cmpq $0x0, 0x38(%rsp)
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x2eb4
movb $0x1, 0x90(%rsp)
leaq 0x40af(%rip), %rsi      # 0x6f6a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57a8
testq %rax, %rax
je 0x2f2f
leaq 0x4078(%rip), %rsi      # 0x6f60
leaq 0x48(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x57a8
movq %rax, %r13
leaq 0x48(%rsp), %rdi
callq 0x20b0
leaq 0x10(%rsp), %rdi
callq 0x20b0
testq %r13, %r13
je 0x2f39
movb $0x1, 0x95(%rsp)
jmp 0x2f39
leaq 0x10(%rsp), %rdi
callq 0x20b0
testq %rbx, %rbx
je 0x2f48
movq 0x30(%rbx), %rax
cmpq 0x28(%rbx), %rax
je 0x2f61
testq %r15, %r15
je 0x2f69
movq 0x30(%r15), %rax
cmpq 0x28(%r15), %rax
jne 0x2f69
movb $0x1, 0x85(%rsp)
jmp 0x2f69
movb $0x1, 0x84(%rsp)
movq 0xc8(%rsp), %rcx
testq %rcx, %rcx
je 0x2f80
movq 0x30(%rcx), %rax
cmpq 0x28(%rcx), %rax
je 0x2fa7
cmpq $0x0, 0xc0(%rsp)
je 0x2faf
movq 0xc0(%rsp), %rcx
movq 0x30(%rcx), %rax
cmpq 0x28(%rcx), %rax
jne 0x2faf
movb $0x1, 0x8a(%rsp)
jmp 0x2faf
movb $0x1, 0x89(%rsp)
movq 0xd0(%rsp), %rcx
testq %rcx, %rcx
je 0x2fc6
movq 0x30(%rcx), %rax
cmpq 0x28(%rcx), %rax
je 0x2fe7
cmpq $0x0, 0x40(%rsp)
je 0x2fef
movq 0x40(%rsp), %rcx
movq 0x30(%rcx), %rax
cmpq 0x28(%rcx), %rax
jne 0x2fef
movb $0x1, 0x8f(%rsp)
jmp 0x2fef
movb $0x1, 0x8e(%rsp)
testq %r14, %r14
je 0x2ffe
movq 0x30(%r14), %rax
cmpq 0x28(%r14), %rax
je 0x301f
cmpq $0x0, 0x38(%rsp)
je 0x3027
movq 0x38(%rsp), %rcx
movq 0x30(%rcx), %rax
cmpq 0x28(%rcx), %rax
jne 0x3027
movb $0x1, 0x94(%rsp)
jmp 0x3027
movb $0x1, 0x93(%rsp)
testq %rbx, %rbx
je 0x30b9
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x304e
movb $0x1, 0x82(%rsp)
jmp 0x30b9
cmpq %rax, %rcx
je 0x30b9
movq %r15, 0x68(%rsp)
leaq 0x10(%rsp), %r13
andq $0x0, (%r13)
leaq 0x48(%rsp), %rbp
andq $0x0, (%rbp)
movq (%rax), %rdi
pushq $0xa
popq %r15
movq %r13, %rsi
movl %r15d, %edx
callq 0x2200
movq %rax, 0xb8(%rsp)
movq 0x28(%rbx), %rax
movq (%rax), %rdi
movq %rbp, %rsi
movl %r15d, %edx
callq 0x2030
movq (%r13), %rcx
cmpb $0x0, (%rcx)
je 0x3843
movb $0x1, 0x82(%rsp)
movq 0x30(%rsp), %rbx
movq 0x68(%rsp), %r15
jmp 0x30c5
movq $0x0, 0xb8(%rsp)
testq %r15, %r15
je 0x3142
movq 0x28(%r15), %rax
movq 0x30(%r15), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x30e8
movb $0x1, 0x83(%rsp)
jmp 0x3142
cmpq %rax, %rcx
je 0x3142
leaq 0x10(%rsp), %rbx
andq $0x0, (%rbx)
leaq 0x48(%rsp), %r13
andq $0x0, (%r13)
movq (%rax), %rdi
pushq $0xa
popq %rbp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2200
movq %rax, 0xb8(%rsp)
movq 0x28(%r15), %rax
movq (%rax), %rdi
movq %r13, %rsi
movl %ebp, %edx
callq 0x2030
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x385f
movb $0x1, 0x83(%rsp)
movq 0x30(%rsp), %rbx
pushq $0x32
popq %rax
movq %rax, 0x68(%rsp)
movq 0xc8(%rsp), %rcx
testq %rcx, %rcx
je 0x31f2
movq 0x28(%rcx), %rax
movq 0x30(%rcx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x3179
movb $0x1, 0x87(%rsp)
jmp 0x31f2
cmpq %rax, %rcx
je 0x31f2
leaq 0x10(%rsp), %rbx
andq $0x0, (%rbx)
leaq 0x48(%rsp), %rbp
andq $0x0, (%rbp)
movq (%rax), %rdi
pushq $0xa
popq %r12
movq %rbx, %rsi
movl %r12d, %edx
callq 0x2200
movq %rax, %r13
movq 0xc8(%rsp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq %rbp, %rsi
movl %r12d, %edx
callq 0x2030
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x387b
movb $0x1, 0x87(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r13
cmovbq %r13, %rax
movq %rax, 0x68(%rsp)
leaq 0xa0(%rsp), %r12
movq 0x30(%rsp), %rbx
movq 0xc0(%rsp), %rcx
testq %rcx, %rcx
je 0x3297
movq 0x28(%rcx), %rax
movq 0x30(%rcx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x3221
movb $0x1, 0x88(%rsp)
jmp 0x3297
cmpq %rax, %rcx
je 0x3297
leaq 0x10(%rsp), %rbx
andq $0x0, (%rbx)
leaq 0x48(%rsp), %r12
andq $0x0, (%r12)
movq (%rax), %rdi
pushq $0xa
popq %rbp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2060
movq %rax, %r13
movq 0xc0(%rsp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x2230
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x3897
movb $0x1, 0x88(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r13
cmovbq %r13, %rax
movq %rax, 0x68(%rsp)
leaq 0xa0(%rsp), %r12
movq 0x30(%rsp), %rbx
pushq $-0x1
popq %rax
movq 0xd0(%rsp), %rcx
testq %rcx, %rcx
je 0x3300
movq 0x28(%rcx), %rsi
movq 0x30(%rcx), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
cmpq $0x21, %rdx
jb 0x32c5
movb $0x1, 0x8c(%rsp)
jmp 0x3300
cmpq %rsi, %rcx
je 0x3300
leaq 0x10(%rsp), %rbx
andq $0x0, (%rbx)
movq (%rsi), %rdi
pushq $0xa
popq %rdx
movq %rbx, %rsi
callq 0x2230
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
jne 0x32f3
leaq -0x3(%rax), %rcx
cmpq $-0x3, %rcx
ja 0x32fb
movb $0x1, 0x8c(%rsp)
movq 0x30(%rsp), %rbx
movq 0x40(%rsp), %rcx
testq %rcx, %rcx
je 0x3363
movq 0x28(%rcx), %rsi
movq 0x30(%rcx), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
cmpq $0x21, %rdx
jb 0x3328
movb $0x1, 0x8d(%rsp)
jmp 0x3363
cmpq %rsi, %rcx
je 0x3363
leaq 0x10(%rsp), %rbx
andq $0x0, (%rbx)
movq (%rsi), %rdi
pushq $0xa
popq %rdx
movq %rbx, %rsi
callq 0x2230
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
jne 0x3356
leaq -0x3(%rax), %rcx
cmpq $-0x3, %rcx
ja 0x335e
movb $0x1, 0x8d(%rsp)
movq 0x30(%rsp), %rbx
testq %r14, %r14
movq %rax, 0xe0(%rsp)
je 0x3407
movq 0x28(%r14), %rsi
movq 0x30(%r14), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
cmpq $0x21, %rdx
jb 0x3392
movb $0x1, 0x91(%rsp)
jmp 0x3407
cmpq %rsi, %rcx
je 0x3407
leaq 0x10(%rsp), %rbx
andq $0x0, (%rbx)
leaq 0x48(%rsp), %r12
andq $0x0, (%r12)
movq (%rsi), %rdi
pushq $0xa
popq %rbp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2200
movq %rax, %r13
movq 0x28(%r14), %rax
movq (%rax), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x2030
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x38b3
movb $0x1, 0x91(%rsp)
movq 0x68(%rsp), %rax
addq $0x31, %rax
cmpq %rax, %r13
leaq 0xa0(%rsp), %r12
movq 0x30(%rsp), %rbx
jb 0x340a
movb $0x1, 0x91(%rsp)
jmp 0x340a
xorl %r13d, %r13d
movq 0x38(%rsp), %rcx
testq %rcx, %rcx
je 0x34ae
movq 0x28(%rcx), %rax
movq 0x30(%rcx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x3436
movb $0x1, 0x91(%rsp)
jmp 0x34ae
cmpq %rax, %rcx
je 0x34ae
leaq 0x10(%rsp), %rbx
andq $0x0, (%rbx)
leaq 0x48(%rsp), %r12
andq $0x0, (%r12)
movq (%rax), %rdi
pushq $0xa
popq %rbp
movq %rbx, %rsi
movl %ebp, %edx
callq 0x2200
movq %rax, %r13
movq 0x38(%rsp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq %r12, %rsi
movl %ebp, %edx
callq 0x2030
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x38cf
movb $0x1, 0x91(%rsp)
movq 0x68(%rsp), %rax
addq $0x31, %rax
cmpq %rax, %r13
jb 0x34a1
movb $0x1, 0x92(%rsp)
leaq 0xa0(%rsp), %r12
movq 0x30(%rsp), %rbx
leaq 0x3ab5(%rip), %rsi      # 0x6f6a
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5168
cmpq $0x1, %rax
jne 0x353b
leaq 0x3a87(%rip), %rsi      # 0x6f6a
leaq 0x48(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x527a
movq 0x8(%rax), %rbx
movq (%rax), %r12
leaq 0x48(%rsp), %rdi
callq 0x20b0
leaq 0x10(%rsp), %rdi
callq 0x20b0
cmpq %r12, %rbx
leaq 0xa0(%rsp), %r12
movq 0x30(%rsp), %rbx
je 0x3545
movb $0x1, 0x97(%rsp)
jmp 0x3545
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x3a14(%rip), %rsi      # 0x6f60
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x5168
cmpq $0x1, %rax
jne 0x35d2
leaq 0x39e6(%rip), %rsi      # 0x6f60
leaq 0x48(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x527a
movq 0x8(%rax), %rbx
movq (%rax), %r12
leaq 0x48(%rsp), %rdi
callq 0x20b0
leaq 0x10(%rsp), %rdi
callq 0x20b0
cmpq %r12, %rbx
leaq 0xa0(%rsp), %r12
movq 0x30(%rsp), %rbx
je 0x35dc
movb $0x1, 0x96(%rsp)
jmp 0x35dc
leaq 0x10(%rsp), %rdi
callq 0x20b0
leaq 0x80(%rsp), %rdi
callq 0x24a5
leaq 0x80(%rsp), %rdi
callq 0x4642
testb %al, %al
jne 0x37fb
leaq 0x3965(%rip), %rsi      # 0x6f6a
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57a8
movq %rax, %rbp
leaq 0x10(%rsp), %rdi
callq 0x20b0
testq %rbp, %rbp
je 0x3642
movsd 0x29d0(%rip), %xmm0     # 0x6010
jmp 0x3684
leaq 0x3917(%rip), %rsi      # 0x6f60
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x46f8
leaq 0x100(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57a8
movq %rax, %rbp
leaq 0x10(%rsp), %rdi
callq 0x20b0
testq %rbp, %rbp
je 0x3691
movsd 0x2994(%rip), %xmm0     # 0x6018
movq 0xd8(%rsp), %rdi
callq 0x5dba
testq %rbx, %rbx
je 0x36bb
movq 0x30(%rbx), %rax
subq 0x28(%rbx), %rax
cmpq $0x20, %rax
jne 0x38eb
movq 0xf8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movq %rcx, (%rax)
testq %r15, %r15
je 0x36e5
movq 0x30(%r15), %rax
subq 0x28(%r15), %rax
cmpq $0x20, %rax
jne 0x390a
movq 0xf8(%rsp), %rax
movq 0xb8(%rsp), %rcx
movq %rcx, (%rax)
movq 0xc8(%rsp), %rcx
testq %rcx, %rcx
movq 0xc0(%rsp), %rdx
je 0x371b
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
cmpq $0x20, %rax
jne 0x3929
movq 0xf0(%rsp), %rax
movq 0x68(%rsp), %rcx
movl %ecx, (%rax)
testq %rdx, %rdx
je 0x3741
movq 0x30(%rdx), %rax
subq 0x28(%rdx), %rax
cmpq $0x20, %rax
jne 0x3948
movq 0xf0(%rsp), %rax
movq 0x68(%rsp), %rcx
movl %ecx, (%rax)
cmpq $0x0, 0xd0(%rsp)
je 0x377b
movq 0xd0(%rsp), %rcx
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
cmpq $0x20, %rax
jne 0x3967
movq 0xd8(%rsp), %rdi
movq 0xe0(%rsp), %rsi
callq 0x5dc0
cmpq $0x0, 0x40(%rsp)
je 0x37af
movq 0x40(%rsp), %rcx
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
cmpq $0x20, %rax
jne 0x3986
movq 0xd8(%rsp), %rdi
movq 0xe0(%rsp), %rsi
callq 0x5dc0
testq %r14, %r14
je 0x37d1
movq 0x30(%r14), %rax
subq 0x28(%r14), %rax
cmpq $0x20, %rax
jne 0x39a5
movq 0xe8(%rsp), %rax
movq %r13, (%rax)
cmpq $0x0, 0x38(%rsp)
je 0x37fb
movq 0x38(%rsp), %rcx
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
cmpq $0x20, %rax
jne 0x39c4
movq 0xe8(%rsp), %rax
movq %r13, (%rax)
leaq 0x80(%rsp), %rdi
callq 0x4642
movl %eax, %ebx
xorb $0x1, %bl
movq %r12, %rdi
callq 0x47c6
leaq 0x100(%rsp), %rdi
callq 0x4842
leaq 0x260(%rsp), %rdi
callq 0x4916
movl %ebx, %eax
addq $0x298, %rsp            # imm = 0x298
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x48(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x30a5
testq %rax, %rax
jg 0x30ad
jmp 0x30a5
movq 0x48(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x3135
testq %rax, %rax
jg 0x313d
jmp 0x3135
movq 0x48(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x31cc
testq %rax, %rax
jns 0x31d4
jmp 0x31cc
movq 0x48(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x3271
testq %rax, %rax
jns 0x3279
jmp 0x3271
movq 0x48(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x33da
testq %rax, %rax
jns 0x33e2
jmp 0x33da
movq 0x48(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x3483
testq %rax, %rax
jns 0x348b
jmp 0x3483
leaq 0x36b0(%rip), %rdi      # 0x6fa2
leaq 0x36d2(%rip), %rsi      # 0x6fcb
leaq 0x36d5(%rip), %rcx      # 0x6fd5
movl $0x229, %edx            # imm = 0x229
callq 0x20f0
leaq 0x374e(%rip), %rdi      # 0x705f
leaq 0x36b3(%rip), %rsi      # 0x6fcb
leaq 0x36b6(%rip), %rcx      # 0x6fd5
movl $0x22d, %edx            # imm = 0x22D
callq 0x20f0
leaq 0x3762(%rip), %rdi      # 0x7092
leaq 0x3694(%rip), %rsi      # 0x6fcb
leaq 0x3697(%rip), %rcx      # 0x6fd5
movl $0x232, %edx            # imm = 0x232
callq 0x20f0
leaq 0x3761(%rip), %rdi      # 0x70b0
leaq 0x3675(%rip), %rsi      # 0x6fcb
leaq 0x3678(%rip), %rcx      # 0x6fd5
movl $0x237, %edx            # imm = 0x237
callq 0x20f0
leaq 0x376a(%rip), %rdi      # 0x70d8
leaq 0x3656(%rip), %rsi      # 0x6fcb
leaq 0x3659(%rip), %rcx      # 0x6fd5
movl $0x23d, %edx            # imm = 0x23D
callq 0x20f0
leaq 0x3770(%rip), %rdi      # 0x70fd
leaq 0x3637(%rip), %rsi      # 0x6fcb
leaq 0x363a(%rip), %rcx      # 0x6fd5
movl $0x241, %edx            # imm = 0x241
callq 0x20f0
leaq 0x3780(%rip), %rdi      # 0x712c
leaq 0x3618(%rip), %rsi      # 0x6fcb
leaq 0x361b(%rip), %rcx      # 0x6fd5
movl $0x246, %edx            # imm = 0x246
callq 0x20f0
leaq 0x3787(%rip), %rdi      # 0x7152
leaq 0x35f9(%rip), %rsi      # 0x6fcb
leaq 0x35fc(%rip), %rcx      # 0x6fd5
movl $0x24a, %edx            # imm = 0x24A
callq 0x20f0
jmp 0x3b19
jmp 0x3b28
jmp 0x3b28
jmp 0x3b19
jmp 0x3b28
jmp 0x3b06
jmp 0x3b19
jmp 0x3b06
jmp 0x3b19
jmp 0x3b06
jmp 0x3b19
jmp 0x3b19
jmp 0x3b28
jmp 0x3b19
jmp 0x3b28
jmp 0x3b19
jmp 0x3b28
jmp 0x3b19
jmp 0x3b28
jmp 0x3b19
jmp 0x3b28
jmp 0x3b19
jmp 0x3b28
jmp 0x3b19
jmp 0x3b28
jmp 0x3b19
jmp 0x3b28
jmp 0x3b19
jmp 0x3b28
jmp 0x3b19
jmp 0x3b28
jmp 0x3b19
jmp 0x3b28
jmp 0x3b19
jmp 0x3b28
movq %rax, %rbx
movl $0x140, %r12d           # imm = 0x140
leaq (%rsp,%r12), %rdi
addq $0x100, %rdi            # imm = 0x100
callq 0x20b0
addq $-0x20, %r12
cmpq $-0x20, %r12
jne 0x3a9b
movb $0x1, %al
jmp 0x3ad0
jmp 0x3acb
jmp 0x3acb
jmp 0x3acb
jmp 0x3acb
jmp 0x3acb
jmp 0x3acb
jmp 0x3acb
jmp 0x3acb
jmp 0x3acb
movq %rax, %rbx
xorl %eax, %eax
cmpq %r15, %r14
sete %cl
testb %al, %al
jne 0x3b52
testb %cl, %cl
jne 0x3b52
addq $-0x20, %r15
movq %r15, %rdi
callq 0x20b0
cmpq %r14, %r15
jne 0x3ade
jmp 0x3b52
movq %rax, %rbx
jmp 0x3b52
jmp 0x3b28
jmp 0x3b28
jmp 0x3b19
jmp 0x3b28
jmp 0x3b19
jmp 0x3b19
jmp 0x3b28
jmp 0x3b28
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20b0
jmp 0x3b1c
jmp 0x3b19
jmp 0x3b28
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20b0
jmp 0x3b2b
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x47c6
leaq 0x100(%rsp), %rdi
callq 0x4842
leaq 0x260(%rsp), %rdi
callq 0x4916
movq %rbx, %rdi
callq 0x2290