// File: /workspace/github_cpp_makefile_star2_O1/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 $0x2b8, %rsp            # imm = 0x2B8
movq %rsi, 0x28(%rsp)
cmpl $0xb, %edi
jl 0x2a30
movq 0x8607(%rip), %rbx      # 0xaff0
leaq 0x54dc(%rip), %rsi      # 0x7ecc
movl $0x15, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
callq 0x24fe
xorl %ebx, %ebx
jmp 0x3cbb
cmpl $0x1, %edi
jne 0x2a7e
movq 0x85b4(%rip), %rbx      # 0xaff0
leaq 0x549f(%rip), %rsi      # 0x7ee2
movl $0x51, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2180
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2100
movb $0x1, %bl
jmp 0x3cbb
movq %r8, %r13
movq %rcx, %rbp
movl %edi, 0x30(%rsp)
movq %rdx, 0xf8(%rsp)
movq %r9, 0xf0(%rsp)
leaq 0x130(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x5489(%rip), %rsi      # 0x7f34
leaq 0x5488(%rip), %rdx      # 0x7f3a
leaq 0x120(%rsp), %r12
movq %r12, %rdi
callq 0x552e
leaq 0x140(%rsp), %r14
leaq 0x150(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x545e(%rip), %rsi      # 0x7f3b
leaq 0x5459(%rip), %rdx      # 0x7f3d
movq %r14, %rdi
callq 0x552e
leaq 0x160(%rsp), %r14
leaq 0x170(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x5437(%rip), %rsi      # 0x7f3e
leaq 0x5441(%rip), %rdx      # 0x7f4f
movq %r14, %rdi
callq 0x552e
leaq 0x180(%rsp), %r14
leaq 0x190(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x541f(%rip), %rsi      # 0x7f50
leaq 0x5421(%rip), %rdx      # 0x7f59
movq %r14, %rdi
callq 0x552e
leaq 0x1a0(%rsp), %r14
leaq 0x1b0(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x53ff(%rip), %rsi      # 0x7f5a
leaq 0x5402(%rip), %rdx      # 0x7f64
movq %r14, %rdi
callq 0x552e
leaq 0x1c0(%rsp), %r14
leaq 0x1d0(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x53e0(%rip), %rsi      # 0x7f65
leaq 0x53db(%rip), %rdx      # 0x7f67
movq %r14, %rdi
callq 0x552e
leaq 0x1e0(%rsp), %r14
leaq 0x1f0(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x53b9(%rip), %rsi      # 0x7f68
leaq 0x53b8(%rip), %rdx      # 0x7f6e
movq %r14, %rdi
callq 0x552e
leaq 0x200(%rsp), %r14
leaq 0x210(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x5396(%rip), %rsi      # 0x7f6f
leaq 0x5391(%rip), %rdx      # 0x7f71
movq %r14, %rdi
callq 0x552e
leaq 0x220(%rsp), %r14
leaq 0x230(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x536f(%rip), %rsi      # 0x7f72
leaq 0x5375(%rip), %rdx      # 0x7f7f
movq %r14, %rdi
callq 0x552e
movq %rbp, 0xe8(%rsp)
leaq 0x240(%rsp), %r14
leaq 0x250(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x534b(%rip), %rsi      # 0x7f80
leaq 0x5346(%rip), %rdx      # 0x7f82
movq %r14, %rdi
callq 0x552e
movq %r13, 0xe0(%rsp)
leaq 0x260(%rsp), %r14
leaq 0x270(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x531c(%rip), %rsi      # 0x7f83
leaq 0x5323(%rip), %rdx      # 0x7f91
movq %r14, %rdi
callq 0x552e
leaq 0x280(%rsp), %r13
leaq 0xc0(%rsp), %rax
movq %rax, (%rsp)
leaq 0x280(%rsp), %rdi
leaq 0x120(%rsp), %rsi
leaq 0x50(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %r13, %rdx
xorl %ecx, %ecx
callq 0x56aa
movq $-0x160, %r14           # imm = 0xFEA0
movq -0x10(%rbp), %rdi
cmpq %rdi, %rbp
je 0x2cca
movq (%rbp), %rsi
incq %rsi
callq 0x21a0
addq $-0x20, %rbp
addq $0x20, %r14
jne 0x2cb5
movq %rbx, 0x120(%rsp)
movq $0x1, 0x128(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x130(%rsp)
movl $0x3f800000, 0x140(%rsp) # imm = 0x3F800000
movups %xmm0, 0x148(%rsp)
leaq 0x70(%rsp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movaps %xmm0, -0x20(%rax)
movups %xmm0, -0x15(%rax)
cmpl $0x2, 0x30(%rsp)
jl 0x2f0e
movl 0x30(%rsp), %ebx
xorl %r12d, %r12d
movl $0x1, %r13d
leaq 0x8(%rsp), %r14
movl $0x0, 0x38(%rsp)
movq 0x28(%rsp), %rax
movq (%rax,%r13,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x2d61
movsbl 0x1(%rsi), %eax
addl $-0x30, %eax
cmpl $0xa, %eax
jae 0x2e21
testb $0x1, %r12b
jne 0x2f02
cmpq $0x0, 0x138(%rsp)
je 0x2f02
movslq 0x38(%rsp), %rax
movq 0x28(%rsp), %rcx
movq (%rcx,%rax,8), %rsi
movq %r14, %rdi
leaq 0x90(%rsp), %rdx
callq 0x5278
leaq 0x120(%rsp), %rdi
movq %r14, %rsi
callq 0x5d90
movq %rax, %rbp
movq 0x28(%rsp), %rax
movq (%rax,%r13,8), %rsi
leaq 0xc0(%rsp), %r15
movq %r15, %rdi
leaq 0x100(%rsp), %rdx
callq 0x5278
movq %rbp, %rdi
movq %r15, %rsi
callq 0x60be
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x2dfc
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2f02
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x2f02
movq %r14, %rdi
leaq 0xc0(%rsp), %r12
movq %r12, %rdx
callq 0x5278
leaq 0x120(%rsp), %rdi
movq %r14, %rsi
callq 0x5c5a
movq %rax, %rbp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2e63
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testq %rbp, %rbp
je 0x2eba
movq 0x28(%rsp), %rax
movq (%rax,%r13,8), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x5278
leaq 0x280(%rsp), %rdi
movq %r14, %rsi
callq 0x5d56
movq %rax, %rbp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2eab
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movb $0x1, %r12b
testq %rbp, %rbp
je 0x2f02
movb $0x1, 0x50(%rsp)
jmp 0x2f02
movq 0x28(%rsp), %rax
movq (%rax,%r13,8), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x5278
leaq 0x120(%rsp), %rdi
movq %r14, %rsi
callq 0x5d90
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2efa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
xorl %r12d, %r12d
movl %r13d, 0x38(%rsp)
incq %r13
cmpq %r13, %rbx
jne 0x2d43
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x5012(%rip), %rsi      # 0x7f34
leaq 0x5011(%rip), %rdx      # 0x7f3a
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6326
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2f5f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testq %r14, %r14
je 0x2f7c
cmpl $0x2, 0x30(%rsp)
jne 0x2f77
callq 0x24fe
xorl %ebx, %ebx
jmp 0x3c97
movb $0x1, 0x69(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4fab(%rip), %rsi      # 0x7f3b
leaq 0x4fa6(%rip), %rdx      # 0x7f3d
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6326
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2fcd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4f5d(%rip), %rsi      # 0x7f3e
leaq 0x4f67(%rip), %rdx      # 0x7f4f
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6326
movq %rax, 0x40(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3020
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4f31(%rip), %rsi      # 0x7f65
leaq 0x4f2c(%rip), %rdx      # 0x7f67
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6326
movq %rax, 0x88(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3076
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4ede(%rip), %rsi      # 0x7f68
leaq 0x4edd(%rip), %rdx      # 0x7f6e
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6326
movq %rax, %r13
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x30c7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4e94(%rip), %rsi      # 0x7f6f
leaq 0x4e8f(%rip), %rdx      # 0x7f71
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6326
movq %rax, %r12
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3118
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4e46(%rip), %rsi      # 0x7f72
leaq 0x4e4c(%rip), %rdx      # 0x7f7f
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6326
movq %rax, 0x38(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x316b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4e01(%rip), %rsi      # 0x7f80
leaq 0x4dfc(%rip), %rdx      # 0x7f82
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6326
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x31bc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4db3(%rip), %rsi      # 0x7f83
leaq 0x4dba(%rip), %rdx      # 0x7f91
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6326
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x320f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, 0xb8(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
cmpb $0x2d, (%rax)
jne 0x3231
movsbl 0x1(%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x3236
movb $0x1, 0x68(%rsp)
movq 0x130(%rsp), %rbx
testq %rbx, %rbx
je 0x3279
leaq 0x280(%rsp), %r15
leaq 0x8(%rbx), %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x5d56
testq %rax, %rax
jne 0x3271
movb $0x1, 0x6a(%rsp)
leaq 0x70(%rsp), %rdi
movq %rbp, %rsi
callq 0x52b6
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x324b
cmpq $0x0, 0xb8(%rsp)
setne %al
cmpq $0x0, 0x40(%rsp)
setne %cl
testb %cl, %al
je 0x3297
movb $0x1, 0x51(%rsp)
cmpq $0x0, 0x88(%rsp)
setne %al
testq %r13, %r13
setne %cl
andb %al, %cl
cmpb $0x1, %cl
movq 0x38(%rsp), %rcx
movq 0x30(%rsp), %rdx
jne 0x32bf
movb $0x1, 0x56(%rsp)
testq %r12, %r12
setne %al
testq %rcx, %rcx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x32d7
movb $0x1, 0x5b(%rsp)
testq %r14, %r14
setne %al
testq %rdx, %rdx
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x32ef
movb $0x1, 0x60(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4c57(%rip), %rsi      # 0x7f5a
leaq 0x4c5a(%rip), %rdx      # 0x7f64
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6326
movq %rax, %r15
testq %rax, %rax
je 0x336d
leaq 0xd0(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x4c14(%rip), %rsi      # 0x7f50
leaq 0x4c16(%rip), %rdx      # 0x7f59
leaq 0xc0(%rsp), %rdi
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x6326
testq %rax, %rax
setne %bl
jmp 0x336f
xorl %ebx, %ebx
testq %r15, %r15
je 0x3395
leaq 0xd0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3395
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x33b1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testb %bl, %bl
je 0x33ba
movb $0x1, 0x65(%rsp)
movq 0xb8(%rsp), %rbx
testq %rbx, %rbx
movq 0x30(%rsp), %rdx
je 0x33d6
movq 0x30(%rbx), %rax
cmpq 0x28(%rbx), %rax
je 0x33f4
cmpq $0x0, 0x40(%rsp)
je 0x33f9
movq 0x40(%rsp), %rcx
movq 0x30(%rcx), %rax
cmpq 0x28(%rcx), %rax
jne 0x33f9
movb $0x1, 0x55(%rsp)
jmp 0x33f9
movb $0x1, 0x54(%rsp)
movq 0x88(%rsp), %rcx
testq %rcx, %rcx
je 0x3410
movq 0x30(%rcx), %rax
cmpq 0x28(%rcx), %rax
je 0x3426
testq %r13, %r13
je 0x342b
movq 0x30(%r13), %rax
cmpq 0x28(%r13), %rax
jne 0x342b
movb $0x1, 0x5a(%rsp)
jmp 0x342b
movb $0x1, 0x59(%rsp)
testq %r12, %r12
je 0x343c
movq 0x30(%r12), %rax
cmpq 0x28(%r12), %rax
je 0x345a
cmpq $0x0, 0x38(%rsp)
je 0x345f
movq 0x38(%rsp), %rcx
movq 0x30(%rcx), %rax
cmpq 0x28(%rcx), %rax
jne 0x345f
movb $0x1, 0x5f(%rsp)
jmp 0x345f
movb $0x1, 0x5e(%rsp)
testq %r14, %r14
je 0x346e
movq 0x30(%r14), %rax
cmpq 0x28(%r14), %rax
je 0x3484
testq %rdx, %rdx
je 0x3489
movq 0x30(%rdx), %rax
cmpq 0x28(%rdx), %rax
jne 0x3489
movb $0x1, 0x64(%rsp)
jmp 0x3489
movb $0x1, 0x63(%rsp)
testq %rbx, %rbx
je 0x3500
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x34a9
movb $0x1, 0x52(%rsp)
jmp 0x3500
cmpq %rax, %rcx
je 0x3500
xorl %ecx, %ecx
leaq 0x8(%rsp), %r15
movq %rcx, (%r15)
leaq 0x90(%rsp), %rbp
movq %rcx, (%rbp)
movq (%rax), %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x21e0
movq %rax, 0x48(%rsp)
movq 0x28(%rbx), %rax
movq (%rax), %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x2040
movq (%r15), %rcx
cmpb $0x0, (%rcx)
je 0x3ccf
movb $0x1, 0x52(%rsp)
jmp 0x3509
movq $0x0, 0x48(%rsp)
movq 0x40(%rsp), %rbx
testq %rbx, %rbx
je 0x357c
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jae 0x3577
cmpq %rax, %rcx
je 0x357c
xorl %ecx, %ecx
leaq 0x8(%rsp), %r15
movq %rcx, (%r15)
leaq 0x90(%rsp), %rbp
movq %rcx, (%rbp)
movq (%rax), %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x21e0
movq %rax, 0x48(%rsp)
movq 0x28(%rbx), %rax
movq (%rax), %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x2040
movq (%r15), %rcx
cmpb $0x0, (%rcx)
je 0x3cee
movb $0x1, 0x53(%rsp)
movl $0x32, %ebp
movq 0x88(%rsp), %rsi
testq %rsi, %rsi
je 0x3625
movq 0x28(%rsi), %rax
movq 0x30(%rsi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
movq 0x38(%rsp), %rdi
jb 0x35b2
movb $0x1, 0x57(%rsp)
jmp 0x362a
cmpq %rax, %rcx
je 0x362a
movq %r12, 0x28(%rsp)
movq %r13, %r12
xorl %ecx, %ecx
leaq 0x8(%rsp), %rbp
movq %rcx, (%rbp)
movq %rsi, %r13
leaq 0x90(%rsp), %rbx
movq %rcx, (%rbx)
movq (%rax), %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x21e0
movq %rax, %r15
movq 0x28(%r13), %rax
movq (%rax), %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x2040
movq (%rbp), %rcx
cmpb $0x0, (%rcx)
je 0x3d0d
movb $0x1, 0x57(%rsp)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq %rbp, %r15
cmovbq %r15, %rbp
movq %r12, %r13
movq 0x28(%rsp), %r12
movq 0x38(%rsp), %rdi
testq %r13, %r13
je 0x36ae
movq 0x28(%r13), %rax
movq 0x30(%r13), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x364a
movb $0x1, 0x58(%rsp)
jmp 0x36ae
cmpq %rax, %rcx
je 0x36ae
xorl %ecx, %ecx
leaq 0x8(%rsp), %rbx
movq %rcx, (%rbx)
leaq 0x90(%rsp), %rbp
movq %rcx, (%rbp)
movq (%rax), %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x2070
movq %rax, %r15
movq 0x28(%r13), %rax
movq (%rax), %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x2200
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x3d2c
movb $0x1, 0x58(%rsp)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq %rbp, %r15
cmovbq %r15, %rbp
movq 0x38(%rsp), %rdi
movq $-0x1, %rax
testq %r12, %r12
je 0x3714
movq 0x28(%r12), %rsi
movq 0x30(%r12), %rcx
movq %rcx, %rdx
subq %rsi, %rdx
cmpq $0x21, %rdx
jb 0x36d7
movb $0x1, 0x5c(%rsp)
jmp 0x3714
cmpq %rsi, %rcx
je 0x3714
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq (%rsi), %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x2200
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
jne 0x370a
leaq -0x3(%rax), %rcx
cmpq $-0x3, %rcx
ja 0x370f
movb $0x1, 0x5c(%rsp)
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
movq %rax, 0xb0(%rsp)
je 0x3781
movq 0x28(%rdi), %rax
movq 0x30(%rdi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x373c
movb $0x1, 0x5d(%rsp)
jmp 0x3781
cmpq %rax, %rcx
movq 0x30(%rsp), %rsi
je 0x3786
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq (%rax), %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x2200
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
jne 0x3774
leaq -0x3(%rax), %rcx
cmpq $-0x3, %rcx
ja 0x3779
movb $0x1, 0x5d(%rsp)
movq %rax, 0xb0(%rsp)
movq 0x30(%rsp), %rsi
testq %r14, %r14
je 0x3815
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x37aa
movb $0x1, 0x61(%rsp)
jmp 0x3815
cmpq %rax, %rcx
je 0x3815
xorl %ecx, %ecx
leaq 0x8(%rsp), %rbx
movq %rcx, (%rbx)
leaq 0x90(%rsp), %r15
movq %rcx, (%r15)
movq (%rax), %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x21e0
movq %rax, 0x28(%rsp)
movq 0x28(%r14), %rax
movq (%rax), %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x2040
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x3d4b
movb $0x1, 0x61(%rsp)
leaq 0x31(%rbp), %rax
cmpq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rsi
jb 0x381e
movb $0x1, 0x61(%rsp)
jmp 0x381e
movq $0x0, 0x28(%rsp)
testq %rsi, %rsi
je 0x38ab
movq 0x28(%rsi), %rax
movq 0x30(%rsi), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x3842
movb $0x1, 0x61(%rsp)
jmp 0x38ab
cmpq %rax, %rcx
je 0x38ab
xorl %ecx, %ecx
leaq 0x8(%rsp), %rbx
movq %rcx, (%rbx)
leaq 0x90(%rsp), %r15
movq %rcx, (%r15)
movq (%rax), %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x21e0
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x2040
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x3d6a
movb $0x1, 0x61(%rsp)
leaq 0x31(%rbp), %rax
cmpq %rax, 0x28(%rsp)
jb 0x38ab
movb $0x1, 0x62(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x469b(%rip), %rsi      # 0x7f5a
leaq 0x469e(%rip), %rdx      # 0x7f64
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5c5a
movq %rax, %r15
testq %rax, %rax
je 0x392d
leaq 0xa0(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x4662(%rip), %rsi      # 0x7f5a
leaq 0x4665(%rip), %rdx      # 0x7f64
leaq 0x90(%rsp), %rdi
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x5d90
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
setne %bl
jmp 0x392f
xorl %ebx, %ebx
testq %r15, %r15
je 0x3955
leaq 0xa0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3955
movq 0xa0(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3971
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testb %bl, %bl
je 0x397a
movb $0x1, 0x67(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x45c2(%rip), %rsi      # 0x7f50
leaq 0x45c4(%rip), %rdx      # 0x7f59
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5c5a
movq %rax, %r15
testq %rax, %rax
je 0x39fc
leaq 0x110(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x4589(%rip), %rsi      # 0x7f50
leaq 0x458b(%rip), %rdx      # 0x7f59
leaq 0x100(%rsp), %rdi
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x5d90
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
setne %bl
jmp 0x39fe
xorl %ebx, %ebx
testq %r15, %r15
je 0x3a24
leaq 0x110(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3a24
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3a40
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testb %bl, %bl
je 0x3a49
movb $0x1, 0x66(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x2542
movq 0xf8(%rsp), %rbx
leaq 0x50(%rsp), %rdi
callq 0x51c2
testb %al, %al
jne 0x3c88
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x44d9(%rip), %rsi      # 0x7f5a
leaq 0x44dc(%rip), %rdx      # 0x7f64
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6326
movq %rax, %r15
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3abe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testq %r15, %r15
je 0x3acd
movsd 0x3545(%rip), %xmm0     # 0x7010
jmp 0x3b2b
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x446f(%rip), %rsi      # 0x7f50
leaq 0x4471(%rip), %rdx      # 0x7f59
callq 0x552e
leaq 0x120(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x6326
movq %rax, %r15
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3b1e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testq %r15, %r15
je 0x3b33
movsd 0x34ed(%rip), %xmm0     # 0x7018
movq %rbx, %rdi
callq 0x689a
movq 0xb8(%rsp), %rcx
testq %rcx, %rcx
je 0x3b62
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
cmpq $0x20, %rax
jne 0x3d89
movq 0xe8(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rcx
testq %rcx, %rcx
je 0x3b8e
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
cmpq $0x20, %rax
jne 0x3da8
movq 0xe8(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, (%rax)
movq 0x88(%rsp), %rcx
testq %rcx, %rcx
je 0x3bb7
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
cmpq $0x20, %rax
jne 0x3dc7
movq 0xe0(%rsp), %rax
movl %ebp, (%rax)
testq %r13, %r13
je 0x3bd8
movq 0x30(%r13), %rax
subq 0x28(%r13), %rax
cmpq $0x20, %rax
jne 0x3de6
movq 0xe0(%rsp), %rax
movl %ebp, (%rax)
testq %r12, %r12
je 0x3c01
movq 0x30(%r12), %rax
subq 0x28(%r12), %rax
cmpq $0x20, %rax
movq 0xb0(%rsp), %rsi
jne 0x3e05
movq %rbx, %rdi
callq 0x68a0
cmpq $0x0, 0x38(%rsp)
je 0x3c30
movq 0x38(%rsp), %rcx
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
cmpq $0x20, %rax
jne 0x3e24
movq %rbx, %rdi
movq 0xb0(%rsp), %rsi
callq 0x68a0
testq %r14, %r14
movq 0x30(%rsp), %rcx
je 0x3c5c
movq 0x30(%r14), %rax
subq 0x28(%r14), %rax
cmpq $0x20, %rax
jne 0x3e43
movq 0xf0(%rsp), %rax
movq 0x28(%rsp), %rdx
movq %rdx, (%rax)
testq %rcx, %rcx
je 0x3c88
movq 0x30(%rsp), %rcx
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
cmpq $0x20, %rax
jne 0x3e62
movq 0xf0(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, (%rax)
leaq 0x50(%rsp), %rdi
callq 0x51c2
movl %eax, %ebx
xorb $0x1, %bl
leaq 0x70(%rsp), %rdi
callq 0x52fe
leaq 0x120(%rsp), %rdi
callq 0x535a
leaq 0x280(%rsp), %rdi
callq 0x5420
movl %ebx, %eax
addq $0x2b8, %rsp            # imm = 0x2B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x90(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x34f9
testq %rax, %rax
jg 0x3509
jmp 0x34f9
movq 0x90(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x3577
testq %rax, %rax
jg 0x357c
jmp 0x3577
movq 0x90(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x360c
testq %rax, %rax
jns 0x3611
jmp 0x360c
movq 0x90(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x3698
testq %rax, %rax
jns 0x369d
jmp 0x3698
movq 0x90(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x37f9
testq %rax, %rax
jns 0x37fe
jmp 0x37f9
movq 0x90(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x3896
testq %rax, %rax
jns 0x389b
jmp 0x3896
leaq 0x4202(%rip), %rdi      # 0x7f92
leaq 0x4224(%rip), %rsi      # 0x7fbb
leaq 0x4227(%rip), %rcx      # 0x7fc5
movl $0x229, %edx            # imm = 0x229
callq 0x20d0
leaq 0x42a0(%rip), %rdi      # 0x804f
leaq 0x4205(%rip), %rsi      # 0x7fbb
leaq 0x4208(%rip), %rcx      # 0x7fc5
movl $0x22d, %edx            # imm = 0x22D
callq 0x20d0
leaq 0x42b4(%rip), %rdi      # 0x8082
leaq 0x41e6(%rip), %rsi      # 0x7fbb
leaq 0x41e9(%rip), %rcx      # 0x7fc5
movl $0x232, %edx            # imm = 0x232
callq 0x20d0
leaq 0x42b3(%rip), %rdi      # 0x80a0
leaq 0x41c7(%rip), %rsi      # 0x7fbb
leaq 0x41ca(%rip), %rcx      # 0x7fc5
movl $0x237, %edx            # imm = 0x237
callq 0x20d0
leaq 0x42bc(%rip), %rdi      # 0x80c8
leaq 0x41a8(%rip), %rsi      # 0x7fbb
leaq 0x41ab(%rip), %rcx      # 0x7fc5
movl $0x23d, %edx            # imm = 0x23D
callq 0x20d0
leaq 0x42c2(%rip), %rdi      # 0x80ed
leaq 0x4189(%rip), %rsi      # 0x7fbb
leaq 0x418c(%rip), %rcx      # 0x7fc5
movl $0x241, %edx            # imm = 0x241
callq 0x20d0
leaq 0x42d2(%rip), %rdi      # 0x811c
leaq 0x416a(%rip), %rsi      # 0x7fbb
leaq 0x416d(%rip), %rcx      # 0x7fc5
movl $0x246, %edx            # imm = 0x246
callq 0x20d0
leaq 0x42d9(%rip), %rdi      # 0x8142
leaq 0x414b(%rip), %rsi      # 0x7fbb
leaq 0x414e(%rip), %rcx      # 0x7fc5
movl $0x24a, %edx            # imm = 0x24A
callq 0x20d0
jmp 0x4009
jmp 0x4056
jmp 0x4056
jmp 0x4009
jmp 0x4056
movq %rax, %r15
movq 0x100(%rsp), %rdi
cmpq %rbx, %rdi
je 0x400c
movq 0x110(%rsp), %rsi
jmp 0x404c
jmp 0x4009
movq %rax, %r15
movq 0x90(%rsp), %rdi
cmpq %rbx, %rdi
je 0x400c
movq 0xa0(%rsp), %rsi
jmp 0x404c
jmp 0x4009
movq %rax, %r15
movq 0xc0(%rsp), %rdi
cmpq %rbp, %rdi
je 0x400c
jmp 0x4044
jmp 0x4009
jmp 0x4009
jmp 0x4056
jmp 0x4009
jmp 0x4056
jmp 0x4009
jmp 0x4056
jmp 0x4009
jmp 0x4056
jmp 0x4009
jmp 0x4056
jmp 0x4009
jmp 0x4056
jmp 0x4009
jmp 0x4056
jmp 0x4009
jmp 0x4056
jmp 0x4009
jmp 0x4056
jmp 0x4009
jmp 0x4056
jmp 0x4009
jmp 0x4056
jmp 0x4009
jmp 0x4056
movq %rax, %r15
leaq 0x120(%rsp), %rsi
movq %r13, %rdi
callq 0x2290
movb $0x1, %al
jmp 0x3faa
jmp 0x3fa5
jmp 0x3fa5
jmp 0x3fa5
jmp 0x3fa5
jmp 0x3fa5
jmp 0x3fa5
jmp 0x3fa5
jmp 0x3fa5
jmp 0x3fa5
movq %rax, %r15
xorl %eax, %eax
cmpq %r14, %r12
sete %cl
orb %al, %cl
jne 0x407d
addq $-0x10, %r14
leaq 0x120(%rsp), %rbx
movq -0x10(%r14), %rdi
cmpq %rdi, %r14
je 0x3fd8
movq (%r14), %rsi
incq %rsi
callq 0x21a0
leaq -0x20(%r14), %rax
addq $-0x10, %r14
cmpq %rbx, %r14
movq %rax, %r14
jne 0x3fc4
jmp 0x407d
movq %rax, %r15
xorl %eax, %eax
movq %r12, %r14
jmp 0x3faa
jmp 0x4056
jmp 0x4009
jmp 0x4056
jmp 0x4009
jmp 0x4056
jmp 0x4009
jmp 0x4056
jmp 0x4056
jmp 0x4009
movq %rax, %r15
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x4059
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x4059
jmp 0x4056
movq %rax, %r15
movq 0xc0(%rsp), %rdi
leaq 0xd0(%rsp), %rax
cmpq %rax, %rdi
je 0x400c
movq 0xd0(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x400c
movq %rax, %r15
leaq 0x70(%rsp), %rdi
callq 0x52fe
leaq 0x120(%rsp), %rdi
callq 0x535a
leaq 0x280(%rsp), %rdi
callq 0x5420
movq %r15, %rdi
callq 0x2260