// File: /workspace/github_cpp_makefile_star2_O3/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 $0x288, %rsp            # imm = 0x288
cmpl $0xb, %edi
jl 0x2a2b
movq 0x860c(%rip), %rbx      # 0xaff0
leaq 0x5521(%rip), %rsi      # 0x7f0c
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 0x3c7f
cmpl $0x1, %edi
jne 0x2a79
movq 0x85b9(%rip), %rbx      # 0xaff0
leaq 0x54e4(%rip), %rsi      # 0x7f22
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 0x3c7f
movq %r8, %r13
movq %rsi, %r15
movl %edi, 0x50(%rsp)
movq %rcx, 0xe0(%rsp)
movq %rdx, 0xe8(%rsp)
movq %r9, 0xd8(%rsp)
leaq 0x100(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x54c6(%rip), %rsi      # 0x7f74
leaq 0x54c5(%rip), %rdx      # 0x7f7a
leaq 0xf0(%rsp), %r14
movq %r14, %rdi
callq 0x5480
leaq 0x110(%rsp), %r12
leaq 0x120(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x549b(%rip), %rsi      # 0x7f7b
leaq 0x5496(%rip), %rdx      # 0x7f7d
movq %r12, %rdi
callq 0x5480
leaq 0x130(%rsp), %r12
leaq 0x140(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x5474(%rip), %rsi      # 0x7f7e
leaq 0x547e(%rip), %rdx      # 0x7f8f
movq %r12, %rdi
callq 0x5480
leaq 0x150(%rsp), %r12
leaq 0x160(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x545c(%rip), %rsi      # 0x7f90
leaq 0x545e(%rip), %rdx      # 0x7f99
movq %r12, %rdi
callq 0x5480
leaq 0x170(%rsp), %r12
leaq 0x180(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x543c(%rip), %rsi      # 0x7f9a
leaq 0x543f(%rip), %rdx      # 0x7fa4
movq %r12, %rdi
callq 0x5480
leaq 0x190(%rsp), %r12
leaq 0x1a0(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x541d(%rip), %rsi      # 0x7fa5
leaq 0x5418(%rip), %rdx      # 0x7fa7
movq %r12, %rdi
callq 0x5480
leaq 0x1b0(%rsp), %r12
leaq 0x1c0(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x53f6(%rip), %rsi      # 0x7fa8
leaq 0x53f5(%rip), %rdx      # 0x7fae
movq %r12, %rdi
callq 0x5480
leaq 0x1d0(%rsp), %r12
leaq 0x1e0(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x53d3(%rip), %rsi      # 0x7faf
leaq 0x53ce(%rip), %rdx      # 0x7fb1
movq %r12, %rdi
callq 0x5480
leaq 0x1f0(%rsp), %r12
leaq 0x200(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x53ac(%rip), %rsi      # 0x7fb2
leaq 0x53b2(%rip), %rdx      # 0x7fbf
movq %r12, %rdi
callq 0x5480
movq %r13, 0xd0(%rsp)
leaq 0x210(%rsp), %r12
leaq 0x220(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x5388(%rip), %rsi      # 0x7fc0
leaq 0x5383(%rip), %rdx      # 0x7fc2
movq %r12, %rdi
callq 0x5480
leaq 0x230(%rsp), %r12
leaq 0x240(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x5361(%rip), %rsi      # 0x7fc3
leaq 0x5368(%rip), %rdx      # 0x7fd1
movq %r12, %rdi
callq 0x5480
leaq 0x250(%rsp), %r14
leaq 0x30(%rsp), %rax
movq %rax, (%rsp)
leaq 0x250(%rsp), %rdi
leaq 0xf0(%rsp), %rsi
leaq 0x80(%rsp), %r8
leaq 0x8(%rsp), %r9
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x5628
movq $-0x160, %r14           # imm = 0xFEA0
movq -0x10(%r13), %rdi
cmpq %rdi, %r13
je 0x2cc5
movq (%r13), %rsi
incq %rsi
callq 0x21a0
addq $-0x20, %r13
addq $0x20, %r14
jne 0x2cb0
movq %rbx, 0xf0(%rsp)
movq $0x1, 0xf8(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x100(%rsp)
movl $0x3f800000, 0x110(%rsp) # imm = 0x3F800000
movups %xmm0, 0x118(%rsp)
leaq 0xa0(%rsp), %rax
movaps %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movaps %xmm0, -0x20(%rax)
movups %xmm0, -0x15(%rax)
cmpl $0x2, 0x50(%rsp)
jl 0x2ed5
movl 0x50(%rsp), %ebx
xorl %eax, %eax
movl $0x1, %r13d
leaq 0x8(%rsp), %r14
leaq 0x30(%rsp), %r12
movl $0x0, 0x28(%rsp)
movq (%r15,%r13,8), %rsi
cmpb $0x2d, (%rsi)
jne 0x2d5e
movsbl 0x1(%rsi), %ecx
addl $-0x30, %ecx
cmpl $0xa, %ecx
jae 0x2df9
cmpq $0x0, 0x108(%rsp)
sete %cl
orb %al, %cl
testb $0x1, %cl
jne 0x2ec9
movslq 0x28(%rsp), %rax
movq (%r15,%rax,8), %rsi
movq %r14, %rdi
leaq 0x67(%rsp), %rdx
callq 0x51c8
leaq 0xf0(%rsp), %rdi
movq %r14, %rsi
callq 0x5d12
movq %rax, %rbp
movq (%r15,%r13,8), %rsi
movq %r12, %rdi
leaq 0x66(%rsp), %rdx
callq 0x51c8
movq %rbp, %rdi
movq %r12, %rsi
callq 0x6036
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x2dd6
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2df2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
xorl %eax, %eax
jmp 0x2ec9
movq %r14, %rdi
movq %r12, %rdx
callq 0x51c8
leaq 0xf0(%rsp), %rdi
movq %r14, %rsi
callq 0x5bdc
movq %rax, %rbp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2e33
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testq %rbp, %rbp
je 0x2e87
movq (%r15,%r13,8), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x51c8
leaq 0x250(%rsp), %rdi
movq %r14, %rsi
callq 0x5cd8
movq %rax, %rbp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2e76
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movb $0x1, %al
testq %rbp, %rbp
je 0x2ec9
movb $0x1, 0x80(%rsp)
jmp 0x2ec9
movq (%r15,%r13,8), %rsi
movq %r14, %rdi
movq %r12, %rdx
callq 0x51c8
leaq 0xf0(%rsp), %rdi
movq %r14, %rsi
callq 0x5d12
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2ec2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
xorl %eax, %eax
movl %r13d, 0x28(%rsp)
incq %r13
cmpq %r13, %rbx
jne 0x2d45
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x508b(%rip), %rsi      # 0x7f74
leaq 0x508a(%rip), %rdx      # 0x7f7a
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x62a6
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2f26
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testq %r14, %r14
je 0x2f46
cmpl $0x2, 0x50(%rsp)
jne 0x2f3e
callq 0x24fe
xorl %ebx, %ebx
jmp 0x3c58
movb $0x1, 0x99(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x5021(%rip), %rsi      # 0x7f7b
leaq 0x501c(%rip), %rdx      # 0x7f7d
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x62a6
movq %rax, 0xc8(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2f9c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4fce(%rip), %rsi      # 0x7f7e
leaq 0x4fd8(%rip), %rdx      # 0x7f8f
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x62a6
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2fed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4fa4(%rip), %rsi      # 0x7fa5
leaq 0x4f9f(%rip), %rdx      # 0x7fa7
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x62a6
movq %rax, 0x58(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3040
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4f54(%rip), %rsi      # 0x7fa8
leaq 0x4f53(%rip), %rdx      # 0x7fae
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x62a6
movq %rax, 0x50(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3093
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4f08(%rip), %rsi      # 0x7faf
leaq 0x4f03(%rip), %rdx      # 0x7fb1
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x62a6
movq %rax, %r13
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x30e4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4eba(%rip), %rsi      # 0x7fb2
leaq 0x4ec0(%rip), %rdx      # 0x7fbf
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x62a6
movq %rax, 0x28(%rsp)
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3137
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4e75(%rip), %rsi      # 0x7fc0
leaq 0x4e70(%rip), %rdx      # 0x7fc2
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x62a6
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3188
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4e27(%rip), %rsi      # 0x7fc3
leaq 0x4e2e(%rip), %rdx      # 0x7fd1
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x62a6
movq %rax, %r12
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x31d9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, 0xc0(%rsp)
movq 0x8(%r15), %rax
cmpb $0x2d, (%rax)
jne 0x31f6
movsbl 0x1(%rax), %eax
addl $-0x30, %eax
cmpl $0x9, %eax
ja 0x31fe
movb $0x1, 0x98(%rsp)
movq 0x100(%rsp), %rbx
testq %rbx, %rbx
je 0x3247
leaq 0x250(%rsp), %r15
leaq 0x8(%rbx), %rbp
movq %r15, %rdi
movq %rbp, %rsi
callq 0x5cd8
testq %rax, %rax
jne 0x323f
movb $0x1, 0x9a(%rsp)
leaq 0xa0(%rsp), %rdi
movq %rbp, %rsi
callq 0x5206
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x3213
movq 0xc8(%rsp), %r15
testq %r15, %r15
setne %al
cmpq $0x0, 0xc0(%rsp)
setne %cl
testb %cl, %al
je 0x326d
movb $0x1, 0x81(%rsp)
cmpq $0x0, 0x58(%rsp)
setne %al
cmpq $0x0, 0x50(%rsp)
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x328e
movb $0x1, 0x86(%rsp)
testq %r13, %r13
setne %al
cmpq $0x0, 0x28(%rsp)
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x32ac
movb $0x1, 0x8b(%rsp)
testq %r14, %r14
setne %al
testq %r12, %r12
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x32c7
movb $0x1, 0x90(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4cbf(%rip), %rsi      # 0x7f9a
leaq 0x4cc2(%rip), %rdx      # 0x7fa4
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x62a6
testq %rax, %rax
je 0x3358
leaq 0x40(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4c82(%rip), %rsi      # 0x7f90
leaq 0x4c84(%rip), %rdx      # 0x7f99
leaq 0x30(%rsp), %rdi
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x62a6
testq %rax, %rax
setne %bl
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x334e
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0xc8(%rsp), %r15
jmp 0x335a
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3376
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testb %bl, %bl
je 0x3382
movb $0x1, 0x95(%rsp)
testq %r15, %r15
movq 0xc0(%rsp), %rbx
je 0x3399
movq 0x30(%r15), %rax
cmpq 0x28(%r15), %rax
je 0x33b2
testq %rbx, %rbx
je 0x33ba
movq 0x30(%rbx), %rax
cmpq 0x28(%rbx), %rax
jne 0x33ba
movb $0x1, 0x85(%rsp)
jmp 0x33ba
movb $0x1, 0x84(%rsp)
movq 0x58(%rsp), %rcx
testq %rcx, %rcx
je 0x33ce
movq 0x30(%rcx), %rax
cmpq 0x28(%rcx), %rax
je 0x33ef
cmpq $0x0, 0x50(%rsp)
je 0x33f7
movq 0x50(%rsp), %rcx
movq 0x30(%rcx), %rax
cmpq 0x28(%rcx), %rax
jne 0x33f7
movb $0x1, 0x8a(%rsp)
jmp 0x33f7
movb $0x1, 0x89(%rsp)
testq %r13, %r13
je 0x3406
movq 0x30(%r13), %rax
cmpq 0x28(%r13), %rax
je 0x3427
cmpq $0x0, 0x28(%rsp)
je 0x342f
movq 0x28(%rsp), %rcx
movq 0x30(%rcx), %rax
cmpq 0x28(%rcx), %rax
jne 0x342f
movb $0x1, 0x8f(%rsp)
jmp 0x342f
movb $0x1, 0x8e(%rsp)
testq %r14, %r14
je 0x343e
movq 0x30(%r14), %rax
cmpq 0x28(%r14), %rax
je 0x3459
testq %r12, %r12
je 0x3461
movq 0x30(%r12), %rax
cmpq 0x28(%r12), %rax
jne 0x3461
movb $0x1, 0x94(%rsp)
jmp 0x3461
movb $0x1, 0x93(%rsp)
testq %r15, %r15
je 0x34ea
movq 0x28(%r15), %rax
movq 0x30(%r15), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x3488
movb $0x1, 0x82(%rsp)
jmp 0x34ea
cmpq %rax, %rcx
je 0x34ea
xorl %ecx, %ecx
movq %r15, %rbx
leaq 0x8(%rsp), %r15
movq %rcx, (%r15)
leaq 0x30(%rsp), %rbp
movq %rcx, (%rbp)
movq (%rax), %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x21e0
movq %rax, 0x68(%rsp)
movq 0x28(%rbx), %rax
movq (%rax), %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x2040
movq (%r15), %rcx
cmpb $0x0, (%rcx)
je 0x3c93
movb $0x1, 0x82(%rsp)
movq 0xc0(%rsp), %rbx
jmp 0x34f3
movq $0x0, 0x68(%rsp)
movq 0x58(%rsp), %r15
testq %rbx, %rbx
je 0x3575
movq 0x28(%rbx), %rax
movq 0x30(%rbx), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x351b
movb $0x1, 0x83(%rsp)
jmp 0x3575
cmpq %rax, %rcx
je 0x3575
xorl %ecx, %ecx
leaq 0x8(%rsp), %r15
movq %rcx, (%r15)
leaq 0x30(%rsp), %rbp
movq %rcx, (%rbp)
movq (%rax), %rdi
movq %r15, %rsi
movl $0xa, %edx
callq 0x21e0
movq %rax, 0x68(%rsp)
movq 0x28(%rbx), %rax
movq (%rax), %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x2040
movq (%r15), %rcx
cmpb $0x0, (%rcx)
je 0x3caf
movb $0x1, 0x83(%rsp)
movq 0x58(%rsp), %r15
movl $0x32, %eax
movq %rax, 0x78(%rsp)
testq %r15, %r15
je 0x360e
movq 0x28(%r15), %rax
movq 0x30(%r15), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x35a6
movb $0x1, 0x87(%rsp)
jmp 0x360e
cmpq %rax, %rcx
je 0x360e
xorl %ecx, %ecx
leaq 0x8(%rsp), %rbp
movq %rcx, (%rbp)
leaq 0x30(%rsp), %rbx
movq %rcx, (%rbx)
movq (%rax), %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x21e0
movq %r15, %rcx
movq %rax, %r15
movq 0x28(%rcx), %rax
movq (%rax), %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x2040
movq (%rbp), %rcx
cmpb $0x0, (%rcx)
je 0x3ccb
movb $0x1, 0x87(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r15
cmovbq %r15, %rax
movq %rax, 0x78(%rsp)
movq 0x50(%rsp), %r15
testq %r15, %r15
je 0x36a1
movq 0x28(%r15), %rax
movq 0x30(%r15), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x363a
movb $0x1, 0x88(%rsp)
jmp 0x36a1
cmpq %rax, %rcx
je 0x36a1
xorl %ecx, %ecx
leaq 0x8(%rsp), %rbx
movq %rcx, (%rbx)
leaq 0x30(%rsp), %rbp
movq %rcx, (%rbp)
movq (%rax), %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x2070
movq %r15, %rcx
movq %rax, %r15
movq 0x28(%rcx), %rax
movq (%rax), %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x2200
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x3ce7
movb $0x1, 0x88(%rsp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, %r15
cmovbq %r15, %rax
movq %rax, 0x78(%rsp)
movq $-0x1, 0x70(%rsp)
testq %r13, %r13
je 0x36d2
movq 0x28(%r13), %rax
movq 0x30(%r13), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
movq 0x28(%rsp), %r15
jb 0x36d9
movb $0x1, 0x8c(%rsp)
jmp 0x3716
movq 0x28(%rsp), %r15
jmp 0x3716
cmpq %rax, %rcx
je 0x3716
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq (%rax), %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x2200
movq %rax, 0x70(%rsp)
movq (%rbx), %rax
cmpb $0x0, (%rax)
jne 0x36c8
movq 0x70(%rsp), %rax
addq $-0x3, %rax
cmpq $-0x3, %rax
jbe 0x36c8
testq %r15, %r15
je 0x3776
movq 0x28(%r15), %rax
movq 0x30(%r15), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x3739
movb $0x1, 0x8d(%rsp)
jmp 0x3776
cmpq %rax, %rcx
je 0x3776
leaq 0x8(%rsp), %rbx
movq $0x0, (%rbx)
movq (%rax), %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x2200
movq %rax, 0x70(%rsp)
movq (%rbx), %rax
cmpb $0x0, (%rax)
jne 0x372f
movq 0x70(%rsp), %rax
addq $-0x3, %rax
cmpq $-0x3, %rax
jbe 0x372f
testq %r14, %r14
je 0x3808
movq 0x28(%r14), %rax
movq 0x30(%r14), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x379d
movb $0x1, 0x91(%rsp)
jmp 0x3808
cmpq %rax, %rcx
je 0x3808
xorl %ecx, %ecx
leaq 0x8(%rsp), %rbx
movq %rcx, (%rbx)
leaq 0x30(%rsp), %rbp
movq %rcx, (%rbp)
movq (%rax), %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x21e0
movq %rax, %r15
movq 0x28(%r14), %rax
movq (%rax), %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x2040
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x3d03
movb $0x1, 0x91(%rsp)
movq 0x78(%rsp), %rax
addq $0x31, %rax
cmpq %rax, %r15
jb 0x380b
movb $0x1, 0x91(%rsp)
jmp 0x380b
xorl %r15d, %r15d
testq %r12, %r12
je 0x389e
movq 0x28(%r12), %rax
movq 0x30(%r12), %rcx
movq %rcx, %rdx
subq %rax, %rdx
cmpq $0x21, %rdx
jb 0x3834
movb $0x1, 0x91(%rsp)
jmp 0x389e
cmpq %rax, %rcx
je 0x389e
xorl %ecx, %ecx
leaq 0x8(%rsp), %rbx
movq %rcx, (%rbx)
leaq 0x30(%rsp), %rbp
movq %rcx, (%rbp)
movq (%rax), %rdi
movq %rbx, %rsi
movl $0xa, %edx
callq 0x21e0
movq %rax, %r15
movq 0x28(%r12), %rax
movq (%rax), %rdi
movq %rbp, %rsi
movl $0xa, %edx
callq 0x2040
movq (%rbx), %rcx
cmpb $0x0, (%rcx)
je 0x3d1f
movb $0x1, 0x91(%rsp)
movq 0x78(%rsp), %rax
addq $0x31, %rax
cmpq %rax, %r15
jb 0x389e
movb $0x1, 0x92(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x46e8(%rip), %rsi      # 0x7f9a
leaq 0x46eb(%rip), %rdx      # 0x7fa4
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5bdc
testq %rax, %rax
je 0x392b
leaq 0x40(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x46b5(%rip), %rsi      # 0x7f9a
leaq 0x46b8(%rip), %rdx      # 0x7fa4
leaq 0x30(%rsp), %rdi
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5d12
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
setne %bl
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x392d
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x392d
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3949
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testb %bl, %bl
je 0x3955
movb $0x1, 0x97(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4627(%rip), %rsi      # 0x7f90
leaq 0x4629(%rip), %rdx      # 0x7f99
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x5bdc
testq %rax, %rax
je 0x39e2
leaq 0x40(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x45f4(%rip), %rsi      # 0x7f90
leaq 0x45f6(%rip), %rdx      # 0x7f99
leaq 0x30(%rsp), %rdi
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x5d12
movq 0x8(%rax), %rcx
cmpq (%rax), %rcx
setne %bl
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x39e4
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x39e4
xorl %ebx, %ebx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3a00
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testb %bl, %bl
je 0x3a0c
movb $0x1, 0x96(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x2542
movq 0xe8(%rsp), %rbx
leaq 0x80(%rsp), %rdi
callq 0x5112
testb %al, %al
jne 0x3c46
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x4550(%rip), %rsi      # 0x7f9a
leaq 0x4553(%rip), %rdx      # 0x7fa4
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x62a6
movq %rax, %rbp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3a87
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testq %rbp, %rbp
je 0x3a96
movsd 0x357c(%rip), %xmm0     # 0x7010
jmp 0x3af4
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
movq %rax, (%rdi)
leaq 0x44e6(%rip), %rsi      # 0x7f90
leaq 0x44e8(%rip), %rdx      # 0x7f99
callq 0x5480
leaq 0xf0(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x62a6
movq %rax, %rbp
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3ae7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
testq %rbp, %rbp
je 0x3afc
movsd 0x3524(%rip), %xmm0     # 0x7018
movq %rbx, %rdi
callq 0x67aa
movq 0xc8(%rsp), %rcx
testq %rcx, %rcx
je 0x3b2b
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
cmpq $0x20, %rax
jne 0x3d3b
movq 0xe0(%rsp), %rax
movq 0x68(%rsp), %rcx
movq %rcx, (%rax)
movq 0xc0(%rsp), %rcx
testq %rcx, %rcx
je 0x3b5a
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
cmpq $0x20, %rax
jne 0x3d5a
movq 0xe0(%rsp), %rax
movq 0x68(%rsp), %rcx
movq %rcx, (%rax)
movq 0x58(%rsp), %rcx
testq %rcx, %rcx
je 0x3b85
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
cmpq $0x20, %rax
jne 0x3d79
movq 0xd0(%rsp), %rax
movq 0x78(%rsp), %rcx
movl %ecx, (%rax)
movq 0x50(%rsp), %rcx
testq %rcx, %rcx
je 0x3bb0
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
cmpq $0x20, %rax
jne 0x3d98
movq 0xd0(%rsp), %rax
movq 0x78(%rsp), %rcx
movl %ecx, (%rax)
testq %r13, %r13
je 0x3bd4
movq 0x30(%r13), %rax
subq 0x28(%r13), %rax
cmpq $0x20, %rax
jne 0x3db7
movq %rbx, %rdi
movq 0x70(%rsp), %rsi
callq 0x67b0
cmpq $0x0, 0x28(%rsp)
je 0x3c00
movq 0x28(%rsp), %rcx
movq 0x30(%rcx), %rax
subq 0x28(%rcx), %rax
cmpq $0x20, %rax
jne 0x3dd6
movq %rbx, %rdi
movq 0x70(%rsp), %rsi
callq 0x67b0
testq %r14, %r14
je 0x3c22
movq 0x30(%r14), %rax
subq 0x28(%r14), %rax
cmpq $0x20, %rax
jne 0x3df5
movq 0xd8(%rsp), %rax
movq %r15, (%rax)
testq %r12, %r12
je 0x3c46
movq 0x30(%r12), %rax
subq 0x28(%r12), %rax
cmpq $0x20, %rax
jne 0x3e14
movq 0xd8(%rsp), %rax
movq %r15, (%rax)
leaq 0x80(%rsp), %rdi
callq 0x5112
movl %eax, %ebx
xorb $0x1, %bl
leaq 0xa0(%rsp), %rdi
callq 0x524e
leaq 0xf0(%rsp), %rdi
callq 0x52ac
leaq 0x250(%rsp), %rdi
callq 0x5372
movl %ebx, %eax
addq $0x288, %rsp            # imm = 0x288
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x30(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x34d8
testq %rax, %rax
jg 0x34e0
jmp 0x34d8
movq 0x30(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x3568
testq %rax, %rax
jg 0x3570
jmp 0x3568
movq 0x30(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x35f5
testq %rax, %rax
jns 0x35fd
jmp 0x35f5
movq 0x30(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x3688
testq %rax, %rax
jns 0x3690
jmp 0x3688
movq 0x30(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x37e8
testq %rax, %rax
jns 0x37f0
jmp 0x37e8
movq 0x30(%rsp), %rcx
cmpb $0x0, (%rcx)
jne 0x3880
testq %rax, %rax
jns 0x3888
jmp 0x3880
leaq 0x4290(%rip), %rdi      # 0x7fd2
leaq 0x42b2(%rip), %rsi      # 0x7ffb
leaq 0x42b5(%rip), %rcx      # 0x8005
movl $0x229, %edx            # imm = 0x229
callq 0x20d0
leaq 0x432e(%rip), %rdi      # 0x808f
leaq 0x4293(%rip), %rsi      # 0x7ffb
leaq 0x4296(%rip), %rcx      # 0x8005
movl $0x22d, %edx            # imm = 0x22D
callq 0x20d0
leaq 0x4342(%rip), %rdi      # 0x80c2
leaq 0x4274(%rip), %rsi      # 0x7ffb
leaq 0x4277(%rip), %rcx      # 0x8005
movl $0x232, %edx            # imm = 0x232
callq 0x20d0
leaq 0x4341(%rip), %rdi      # 0x80e0
leaq 0x4255(%rip), %rsi      # 0x7ffb
leaq 0x4258(%rip), %rcx      # 0x8005
movl $0x237, %edx            # imm = 0x237
callq 0x20d0
leaq 0x434a(%rip), %rdi      # 0x8108
leaq 0x4236(%rip), %rsi      # 0x7ffb
leaq 0x4239(%rip), %rcx      # 0x8005
movl $0x23d, %edx            # imm = 0x23D
callq 0x20d0
leaq 0x4350(%rip), %rdi      # 0x812d
leaq 0x4217(%rip), %rsi      # 0x7ffb
leaq 0x421a(%rip), %rcx      # 0x8005
movl $0x241, %edx            # imm = 0x241
callq 0x20d0
leaq 0x4360(%rip), %rdi      # 0x815c
leaq 0x41f8(%rip), %rsi      # 0x7ffb
leaq 0x41fb(%rip), %rcx      # 0x8005
movl $0x246, %edx            # imm = 0x246
callq 0x20d0
leaq 0x4367(%rip), %rdi      # 0x8182
leaq 0x41d9(%rip), %rsi      # 0x7ffb
leaq 0x41dc(%rip), %rcx      # 0x8005
movl $0x24a, %edx            # imm = 0x24A
callq 0x20d0
jmp 0x3f75
jmp 0x3fb9
jmp 0x3fb9
jmp 0x3f75
jmp 0x3fb9
jmp 0x3e53
jmp 0x3f75
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3f78
jmp 0x3faa
jmp 0x3f75
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %r15, %rdi
je 0x3f78
jmp 0x3faa
jmp 0x3f75
jmp 0x3f75
jmp 0x3fb9
jmp 0x3f75
jmp 0x3fb9
jmp 0x3f75
jmp 0x3fb9
jmp 0x3f75
jmp 0x3fb9
jmp 0x3f75
jmp 0x3fb9
jmp 0x3f75
jmp 0x3fb9
jmp 0x3f75
jmp 0x3fb9
jmp 0x3f75
jmp 0x3fb9
jmp 0x3f75
jmp 0x3fb9
jmp 0x3f75
jmp 0x3fb9
jmp 0x3f75
jmp 0x3fb9
jmp 0x3f75
jmp 0x3fb9
movq %rax, %rbx
leaq 0xf0(%rsp), %rsi
movq %r14, %rdi
callq 0x2290
jmp 0x3fe3
jmp 0x3f28
jmp 0x3f28
jmp 0x3f28
jmp 0x3f28
jmp 0x3f28
jmp 0x3f28
jmp 0x3f28
jmp 0x3f28
jmp 0x3f28
movq %rax, %rbx
addq $-0x10, %r12
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0x3f45
movq (%r12), %rsi
incq %rsi
callq 0x21a0
leaq -0x20(%r12), %rax
addq $-0x10, %r12
cmpq %r14, %r12
movq %rax, %r12
jne 0x3f2f
jmp 0x3fe3
movq %rax, %rbx
jmp 0x3fe3
jmp 0x3fb9
jmp 0x3f75
jmp 0x3fb9
jmp 0x3f75
jmp 0x3fb9
jmp 0x3f75
jmp 0x3fb9
jmp 0x3fb9
jmp 0x3f75
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x3fbc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x3fbc
jmp 0x3fb9
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x3f78
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x21a0
jmp 0x3f78
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x524e
leaq 0xf0(%rsp), %rdi
callq 0x52ac
leaq 0x250(%rsp), %rdi
callq 0x5372
movq %rbx, %rdi
callq 0x2260