// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_suite_main_custom
int
munit_suite_main_custom(const MunitSuite* suite, void* user_data,
                        int argc, const char* argv[MUNIT_ARRAY_PARAM(argc + 1)],
                        const MunitArgument arguments[]) {
  int result = EXIT_FAILURE;
  MunitTestRunner runner = {
    .prefix = NULL,
    .suite = NULL,
    .tests = NULL,
    .seed = 0,
    .iterations = 0,
    .parameters = NULL,
    .single_parameter_mode = false,
    .user_data = NULL,
    .report = {
      .successful = 0,
      .skipped = 0,
      .failed = 0,
      .errored = 0,
#if defined(MUNIT_ENABLE_TIMING)
      .cpu_clock = 0.0,
      .wall_clock = 0.0
#endif
    },
    .colorize = false,
#if !defined(_WIN32)
    .fork = true,
#else
    .fork = false,
#endif
    .show_stderr = false,
    .fatal_failures = false
  };
  size_t parameters_size = 0;
  size_t tests_size = 0;

  runner.suite = suite;
  runner.user_data = user_data;

  runner.seed = munit_rand_generate_seed();
  runner.colorize = isatty(fileno(MUNIT_OUTPUT_FILE));

  for (int arg = 1 ; arg < argc ; arg++) {
    if (strncmp("--", argv[arg], 2) == 0) {
      if (strcmp("seed", argv[arg] + 2) == 0) {
        if (arg + 1 >= argc) {
	  munit_logf_internal(MUNIT_LOG_ERROR, stderr, "%s requires an argument", argv[arg]);
          goto cleanup;
        }

        char* envptr = NULL;
        unsigned long long ts = strtoull(argv[arg + 1], &envptr, 0);
        if (*envptr != '\0' || ts > UINT32_MAX) {
	  munit_logf_internal(MUNIT_LOG_ERROR, stderr, "invalid value ('%s') passed to %s", argv[arg + 1], argv[arg]);
          goto cleanup;
        }
        runner.seed = (uint32_t) ts;

        arg++;
      } else if (strcmp("iterations", argv[arg] + 2) == 0) {
        if (arg + 1 >= argc) {
	  munit_logf_internal(MUNIT_LOG_ERROR, stderr, "%s requires an argument", argv[arg]);
          goto cleanup;
        }

        char* endptr;
        unsigned long long iterations = strtoull(argv[arg + 1], &endptr, 0);
        if (*endptr != '\0' || iterations > UINT_MAX) {
	  munit_logf_internal(MUNIT_LOG_ERROR, stderr, "invalid value ('%s') passed to %s", argv[arg + 1], argv[arg]);
          goto cleanup;
        }

        runner.iterations = (unsigned int) iterations;

        arg++;
      } else if (strcmp("param", argv[arg] + 2) == 0) {
        if (arg + 2 >= argc) {
	  munit_logf_internal(MUNIT_LOG_ERROR, stderr, "%s requires two arguments", argv[arg]);
          goto cleanup;
        }

        runner.parameters = realloc(runner.parameters, sizeof(MunitParameter) * (parameters_size + 2));
        if (runner.parameters == NULL) {
	  munit_log_internal(MUNIT_LOG_ERROR, stderr, "failed to allocate memory");
          goto cleanup;
        }
        runner.parameters[parameters_size].name = (char*) argv[arg + 1];
        runner.parameters[parameters_size].value = (char*) argv[arg + 2];
        parameters_size++;
        runner.parameters[parameters_size].name = NULL;
        runner.parameters[parameters_size].value = NULL;
        arg += 2;
      } else if (strcmp("color", argv[arg] + 2) == 0) {
        if (arg + 1 >= argc) {
	  munit_logf_internal(MUNIT_LOG_ERROR, stderr, "%s requires an argument", argv[arg]);
          goto cleanup;
        }

        if (strcmp(argv[arg + 1], "always") == 0)
          runner.colorize = true;
        else if (strcmp(argv[arg + 1], "never") == 0)
          runner.colorize = false;
        else if (strcmp(argv[arg + 1], "auto") == 0)
          runner.colorize = isatty(fileno(MUNIT_OUTPUT_FILE));
        else {
	  munit_logf_internal(MUNIT_LOG_ERROR, stderr, "invalid value ('%s') passed to %s", argv[arg + 1], argv[arg]);
          goto cleanup;
        }

        arg++;
      } else if (strcmp("help", argv[arg] + 2) == 0) {
        munit_print_help(argc, argv, user_data, arguments);
        result = EXIT_SUCCESS;
        goto cleanup;
      } else if (strcmp("single", argv[arg] + 2) == 0) {
        runner.single_parameter_mode = true;
      } else if (strcmp("show-stderr", argv[arg] + 2) == 0) {
        runner.show_stderr = true;
#if !defined(_WIN32)
      } else if (strcmp("no-fork", argv[arg] + 2) == 0) {
        runner.fork = false;
#endif
      } else if (strcmp("fatal-failures", argv[arg] + 2) == 0) {
        runner.fatal_failures = true;
      } else if (strcmp("log-visible", argv[arg] + 2) == 0 ||
                 strcmp("log-fatal", argv[arg] + 2) == 0) {
        MunitLogLevel level;

        if (arg + 1 >= argc) {
	  munit_logf_internal(MUNIT_LOG_ERROR, stderr, "%s requires an argument", argv[arg]);
          goto cleanup;
        }

        if (strcmp(argv[arg + 1], "debug") == 0)
          level = MUNIT_LOG_DEBUG;
        else if (strcmp(argv[arg + 1], "info") == 0)
          level = MUNIT_LOG_DEBUG;
        else if (strcmp(argv[arg + 1], "warning") == 0)
          level = MUNIT_LOG_DEBUG;
        else if (strcmp(argv[arg + 1], "error") == 0)
          level = MUNIT_LOG_DEBUG;
        else {
	  munit_logf_internal(MUNIT_LOG_ERROR, stderr, "invalid value ('%s') passed to %s", argv[arg + 1], argv[arg]);
          goto cleanup;
        }

        if (strcmp("log-visible", argv[arg] + 2) == 0)
          munit_log_level_visible = level;
        else
          munit_log_level_fatal = level;

        arg++;
      } else if (strcmp("list", argv[arg] + 2) == 0) {
        munit_suite_list_tests(suite, false, NULL);
        result = EXIT_SUCCESS;
        goto cleanup;
      } else if (strcmp("list-params", argv[arg] + 2) == 0) {
        munit_suite_list_tests(suite, true, NULL);
        result = EXIT_SUCCESS;
        goto cleanup;
      } else {
        const MunitArgument* argument = munit_arguments_find(arguments, argv[arg] + 2);
        if (argument == NULL) {
	  munit_logf_internal(MUNIT_LOG_ERROR, stderr, "unknown argument ('%s')", argv[arg]);
          goto cleanup;
        }

        if (!argument->parse_argument(suite, user_data, &arg, argc, argv))
          goto cleanup;
      }
    } else {
      runner.tests = realloc((void*) runner.tests, sizeof(char*) * (tests_size + 2));
      if (runner.tests == NULL) {
	  munit_log_internal(MUNIT_LOG_ERROR, stderr, "failed to allocate memory");
        goto cleanup;
      }
      runner.tests[tests_size++] = argv[arg];
      runner.tests[tests_size] = NULL;
    }
  }

  fflush(stderr);
  fprintf(MUNIT_OUTPUT_FILE, "Running test suite with seed 0x%08" PRIx32 "...\n", runner.seed);

  munit_test_runner_run(&runner);

  const unsigned int tests_run = runner.report.successful + runner.report.failed;
  const unsigned int tests_total = tests_run + runner.report.skipped;
  if (tests_run == 0) {
    fprintf(stderr, "No tests run, %d (100%%) skipped.\n", runner.report.skipped);
  } else {
    fprintf(MUNIT_OUTPUT_FILE, "%d of %d (%0.0f%%) tests successful, %d (%0.0f%%) test skipped.\n",
            runner.report.successful, tests_run,
            (((double) runner.report.successful) / ((double) tests_run)) * 100.0,
            runner.report.skipped,
            (((double) runner.report.skipped) / ((double) tests_total)) * 100.0);
  }

  if (runner.report.failed == 0 && runner.report.errored == 0) {
    result = EXIT_SUCCESS;
  }

 cleanup:
  free(runner.parameters);
  free((void*) runner.tests);

  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl $0x1, -0x2c(%rbp)
leaq -0x90(%rbp), %rdi
xorl %esi, %esi
movl $0x60, %edx
callq 0x3130
movb $0x1, -0x37(%rbp)
movq $0x0, -0x98(%rbp)
movq $0x0, -0xa0(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x11b00
movl %eax, -0x78(%rbp)
movq 0xdfdc(%rip), %rax      # 0x1efd0
movq (%rax), %rdi
callq 0x3210
movl %eax, %edi
callq 0x3080
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x38(%rbp)
movl $0x1, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x119e3
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq 0x91b1(%rip), %rdi      # 0x1a1ee
movl $0x2, %edx
callq 0x3060
cmpl $0x0, %eax
jne 0x1194b
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x2, %rsi
leaq 0x9187(%rip), %rdi      # 0x1a1f1
callq 0x31c0
cmpl $0x0, %eax
jne 0x1116b
movl -0xa4(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jl 0x110b7
movq 0xdf63(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movl $0x3, %edi
leaq 0x914b(%rip), %rdx      # 0x1a1f6
movb $0x0, %al
callq 0x11b30
jmp 0x11ada
movq $0x0, -0xb0(%rbp)
movq -0x20(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq -0xb0(%rbp), %rsi
xorl %edx, %edx
callq 0x3190
movq %rax, -0xb8(%rbp)
movq -0xb0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x11108
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0xb8(%rbp)
jbe 0x1114d
movq 0xdee1(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rdx
movq (%rax,%rdx,8), %r8
movl $0x3, %edi
leaq 0x90cd(%rip), %rdx      # 0x1a20e
movb $0x0, %al
callq 0x11b30
jmp 0x11ada
movq -0xb8(%rbp), %rax
movl %eax, -0x78(%rbp)
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x11946
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x2, %rsi
leaq 0x90ab(%rip), %rdi      # 0x1a230
callq 0x31c0
cmpl $0x0, %eax
jne 0x1127b
movl -0xa4(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jl 0x111d2
movq 0xde48(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movl $0x3, %edi
leaq 0x9030(%rip), %rdx      # 0x1a1f6
movb $0x0, %al
callq 0x11b30
jmp 0x11ada
movq -0x20(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq -0xc0(%rbp), %rsi
xorl %edx, %edx
callq 0x3190
movq %rax, -0xc8(%rbp)
movq -0xc0(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x11218
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq %rax, -0xc8(%rbp)
jbe 0x1125d
movq 0xddd1(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rdx
movq (%rax,%rdx,8), %r8
movl $0x3, %edi
leaq 0x8fbd(%rip), %rdx      # 0x1a20e
movb $0x0, %al
callq 0x11b30
jmp 0x11ada
movq -0xc8(%rbp), %rax
movl %eax, -0x74(%rbp)
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x11944
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x2, %rsi
leaq 0x8fa6(%rip), %rdi      # 0x1a23b
callq 0x31c0
cmpl $0x0, %eax
jne 0x113d1
movl -0xa4(%rbp), %eax
addl $0x2, %eax
cmpl -0x14(%rbp), %eax
jl 0x112e2
movq 0xdd38(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movl $0x3, %edi
leaq 0x8f6b(%rip), %rdx      # 0x1a241
movb $0x0, %al
callq 0x11b30
jmp 0x11ada
movq -0x70(%rbp), %rdi
movq -0x98(%rbp), %rsi
addq $0x2, %rsi
shlq $0x4, %rsi
callq 0x3250
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
jne 0x11325
movq 0xdce4(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movl $0x3, %edi
leaq 0x8f40(%rip), %rdx      # 0x1a25b
callq 0x11bd0
jmp 0x11ada
movq -0x20(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x70(%rbp), %rax
movq -0x98(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x2, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x70(%rbp), %rax
movq -0x98(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movq -0x98(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x98(%rbp)
movq -0x70(%rbp), %rax
movq -0x98(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, (%rax)
movq -0x70(%rbp), %rax
movq -0x98(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movl -0xa4(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xa4(%rbp)
jmp 0x11942
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x2, %rsi
leaq 0x8e8a(%rip), %rdi      # 0x1a275
callq 0x31c0
cmpl $0x0, %eax
jne 0x11539
movl -0xa4(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jl 0x11438
movq 0xdbe2(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movl $0x3, %edi
leaq 0x8dca(%rip), %rdx      # 0x1a1f6
movb $0x0, %al
callq 0x11b30
jmp 0x11ada
movq -0x20(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x8e28(%rip), %rsi      # 0x1a27b
callq 0x31c0
cmpl $0x0, %eax
jne 0x11466
movb $0x1, -0x38(%rbp)
jmp 0x11525
movq -0x20(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x8e01(%rip), %rsi      # 0x1a282
callq 0x31c0
cmpl $0x0, %eax
jne 0x11494
movb $0x0, -0x38(%rbp)
jmp 0x11523
movq -0x20(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x8dd9(%rip), %rsi      # 0x1a288
callq 0x31c0
cmpl $0x0, %eax
jne 0x114dc
movq 0xdb10(%rip), %rax      # 0x1efd0
movq (%rax), %rdi
callq 0x3210
movl %eax, %edi
callq 0x3080
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x38(%rbp)
jmp 0x11521
movq 0xdb0d(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rdx
movq (%rax,%rdx,8), %r8
movl $0x3, %edi
leaq 0x8cf9(%rip), %rdx      # 0x1a20e
movb $0x0, %al
callq 0x11b30
jmp 0x11ada
jmp 0x11523
jmp 0x11525
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x11940
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x2, %rsi
leaq 0x8d3a(%rip), %rdi      # 0x1a28d
callq 0x31c0
cmpl $0x0, %eax
jne 0x1157d
movl -0x14(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x11c10
movl $0x0, -0x2c(%rbp)
jmp 0x11ada
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x2, %rsi
leaq 0x8cfb(%rip), %rdi      # 0x1a292
callq 0x31c0
cmpl $0x0, %eax
jne 0x115aa
movb $0x1, -0x68(%rbp)
jmp 0x1193c
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x2, %rsi
leaq 0x8cd5(%rip), %rdi      # 0x1a299
callq 0x31c0
cmpl $0x0, %eax
jne 0x115d7
movb $0x1, -0x36(%rbp)
jmp 0x1193a
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x2, %rsi
leaq 0x8cb4(%rip), %rdi      # 0x1a2a5
callq 0x31c0
cmpl $0x0, %eax
jne 0x11604
movb $0x0, -0x37(%rbp)
jmp 0x11938
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x2, %rsi
leaq 0x8c8f(%rip), %rdi      # 0x1a2ad
callq 0x31c0
cmpl $0x0, %eax
jne 0x11631
movb $0x1, -0x35(%rbp)
jmp 0x11936
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x2, %rsi
leaq 0x8c71(%rip), %rdi      # 0x1a2bc
callq 0x31c0
cmpl $0x0, %eax
je 0x1167d
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x2, %rsi
leaq 0x8c59(%rip), %rdi      # 0x1a2c8
callq 0x31c0
cmpl $0x0, %eax
jne 0x11823
movl -0xa4(%rbp), %eax
addl $0x1, %eax
cmpl -0x14(%rbp), %eax
jl 0x116bc
movq 0xd95e(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movl $0x3, %edi
leaq 0x8b46(%rip), %rdx      # 0x1a1f6
movb $0x0, %al
callq 0x11b30
jmp 0x11ada
movq -0x20(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x8bfb(%rip), %rsi      # 0x1a2d2
callq 0x31c0
cmpl $0x0, %eax
jne 0x116f0
movl $0x0, -0xcc(%rbp)
jmp 0x117d1
movq -0x20(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x8bcd(%rip), %rsi      # 0x1a2d8
callq 0x31c0
cmpl $0x0, %eax
jne 0x11724
movl $0x0, -0xcc(%rbp)
jmp 0x117cf
movq -0x20(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x8b9e(%rip), %rsi      # 0x1a2dd
callq 0x31c0
cmpl $0x0, %eax
jne 0x11755
movl $0x0, -0xcc(%rbp)
jmp 0x117cd
movq -0x20(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rdi
leaq 0x8b75(%rip), %rsi      # 0x1a2e5
callq 0x31c0
cmpl $0x0, %eax
jne 0x11786
movl $0x0, -0xcc(%rbp)
jmp 0x117cb
movq 0xd863(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movl -0xa4(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rdx
movq (%rax,%rdx,8), %r8
movl $0x3, %edi
leaq 0x8a4f(%rip), %rdx      # 0x1a20e
movb $0x0, %al
callq 0x11b30
jmp 0x11ada
jmp 0x117cd
jmp 0x117cf
jmp 0x117d1
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x2, %rsi
leaq 0x8ad1(%rip), %rdi      # 0x1a2bc
callq 0x31c0
cmpl $0x0, %eax
jne 0x11803
movl -0xcc(%rbp), %eax
movl %eax, 0xef07(%rip)      # 0x20708
jmp 0x1180f
movl -0xcc(%rbp), %eax
movl %eax, 0xeef1(%rip)      # 0x20700
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x11934
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x2, %rsi
leaq 0x8aae(%rip), %rdi      # 0x1a2eb
callq 0x31c0
cmpl $0x0, %eax
jne 0x11862
movq -0x8(%rbp), %rdi
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11ca0
movl $0x0, -0x2c(%rbp)
jmp 0x11ada
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x2, %rsi
leaq 0x8a74(%rip), %rdi      # 0x1a2f0
callq 0x31c0
cmpl $0x0, %eax
jne 0x118a4
movq -0x8(%rbp), %rdi
movl $0x1, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x11ca0
movl $0x0, -0x2c(%rbp)
jmp 0x11ada
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
addq $0x2, %rsi
callq 0x11eb0
movq %rax, -0xd8(%rbp)
cmpq $0x0, -0xd8(%rbp)
jne 0x11902
movq 0xd718(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movl $0x3, %edi
leaq 0x8a06(%rip), %rdx      # 0x1a2fc
movb $0x0, %al
callq 0x11b30
jmp 0x11ada
movq -0xd8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
leaq -0xa4(%rbp), %rdx
callq *%rax
testb $0x1, %al
jne 0x1192e
jmp 0x11ada
jmp 0x11930
jmp 0x11932
jmp 0x11934
jmp 0x11936
jmp 0x11938
jmp 0x1193a
jmp 0x1193c
jmp 0x1193e
jmp 0x11940
jmp 0x11942
jmp 0x11944
jmp 0x11946
jmp 0x119cd
movq -0x80(%rbp), %rdi
movq -0xa0(%rbp), %rsi
addq $0x2, %rsi
shlq $0x3, %rsi
callq 0x3250
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
jne 0x1198e
movq 0xd67b(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movl $0x3, %edi
leaq 0x88d7(%rip), %rdx      # 0x1a25b
callq 0x11bd0
jmp 0x11ada
movq -0x20(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x80(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0xa0(%rbp)
movq %rdx, (%rax,%rcx,8)
movq -0x80(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
jmp 0x119cf
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x11018
movq 0xd606(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
callq 0x3230
movq 0xd5d7(%rip), %rax      # 0x1efd0
movq (%rax), %rdi
movl -0x78(%rbp), %edx
leaq 0x890e(%rip), %rsi      # 0x1a314
movb $0x0, %al
callq 0x31e0
leaq -0x90(%rbp), %rdi
callq 0x11f30
movl -0x58(%rbp), %eax
addl -0x50(%rbp), %eax
movl %eax, -0xdc(%rbp)
movl -0xdc(%rbp), %eax
addl -0x54(%rbp), %eax
movl %eax, -0xe0(%rbp)
cmpl $0x0, -0xdc(%rbp)
jne 0x11a5a
movq 0xd5ac(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
movl -0x54(%rbp), %edx
leaq 0x88eb(%rip), %rsi      # 0x1a33c
movb $0x0, %al
callq 0x31e0
jmp 0x11ac5
movq 0xd56f(%rip), %rax      # 0x1efd0
movq (%rax), %rdi
movl -0x58(%rbp), %ecx
movl -0x54(%rbp), %eax
movl %ecx, %r8d
movl %r8d, %edx
movl -0xdc(%rbp), %ecx
movl %ecx, %esi
movl %esi, %ecx
cvtsi2sd %r8, %xmm0
cvtsi2sd %rsi, %xmm1
divsd %xmm1, %xmm0
movsd 0x8728(%rip), %xmm1     # 0x1a1b8
mulsd %xmm1, %xmm0
movl %eax, %r8d
cvtsi2sd %rax, %xmm1
movl -0xe0(%rbp), %eax
cvtsi2sd %rax, %xmm2
divsd %xmm2, %xmm1
movsd 0x8705(%rip), %xmm2     # 0x1a1b8
mulsd %xmm2, %xmm1
leaq 0x88a1(%rip), %rsi      # 0x1a35f
movb $0x2, %al
callq 0x31e0
cmpl $0x0, -0x50(%rbp)
jne 0x11ad8
cmpl $0x0, -0x4c(%rbp)
jne 0x11ad8
movl $0x0, -0x2c(%rbp)
jmp 0x11ada
movq -0x70(%rbp), %rdi
callq 0x3030
movq -0x80(%rbp), %rdi
callq 0x3030
movl -0x2c(%rbp), %eax
addq $0xe0, %rsp
popq %rbp
retq
nopl (%rax,%rax)