// File: /workspace/github_c_makefile_star2_O0/nemequ[P]safe-math/munit/munit.c
// Function: munit_test_runner_run_test
static void
munit_test_runner_run_test(MunitTestRunner* runner,
                           const MunitTest* test,
                           const char* prefix) {
  char* test_name = munit_maybe_concat(NULL, (char*) prefix, (char*) test->name);

  munit_rand_seed(runner->seed);

  fprintf(MUNIT_OUTPUT_FILE, "%-" MUNIT_XSTRINGIFY(MUNIT_TEST_NAME_LEN) "s", test_name);

  if (test->parameters == NULL) {
    /* No parameters.  Simple, nice. */
    munit_test_runner_run_test_with_params(runner, test, NULL);
  } else {
    /* The array of parameters to pass to
     * munit_test_runner_run_test_with_params */
    MunitParameter* params = NULL;
    size_t params_l = 0;
    /* Wildcard parameters are parameters which have possible values
     * specified in the test, but no specific value was passed to the
     * CLI.  That means we want to run the test once for every
     * possible combination of parameter values or, if --single was
     * passed to the CLI, a single time with a random set of
     * parameters. */
    MunitParameter* wild_params = NULL;
    size_t wild_params_l = 0;

    fputc('\n', MUNIT_OUTPUT_FILE);

    for (const MunitParameterEnum* pe = test->parameters ; pe != NULL && pe->name != NULL ; pe++) {
      /* Did we received a value for this parameter from the CLI? */
      bool filled = false;
      for (const MunitParameter* cli_p = runner->parameters ; cli_p != NULL && cli_p->name != NULL ; cli_p++) {
        if (strcmp(cli_p->name, pe->name) == 0) {
          if (MUNIT_UNLIKELY(munit_parameters_add(&params_l, &params, pe->name, cli_p->value) != MUNIT_OK))
            goto cleanup;
          filled = true;
          break;
        }
      }
      if (filled)
        continue;

      /* Nothing from CLI, is the enum NULL/empty?  We're not a
       * fuzzer… */
      if (pe->values == NULL || pe->values[0] == NULL)
        continue;

      /* If --single was passed to the CLI, choose a value from the
       * list of possibilities randomly. */
      if (runner->single_parameter_mode) {
        unsigned int possible = 0;
        for (char** vals = pe->values ; *vals != NULL ; vals++)
          possible++;
        /* We want the tests to be reproducible, even if you're only
         * running a single test, but we don't want every test with
         * the same number of parameters to choose the same parameter
         * number, so use the test name as a primitive salt. */
	const int pidx = munit_rand_at_most(munit_str_hash(test_name), possible - 1);
        if (MUNIT_UNLIKELY(munit_parameters_add(&params_l, &params, pe->name, pe->values[pidx]) != MUNIT_OK))
          goto cleanup;
      } else {
        /* We want to try every permutation.  Put in a placeholder
         * entry, we'll iterate through them later. */
        if (MUNIT_UNLIKELY(munit_parameters_add(&wild_params_l, &wild_params, pe->name, NULL) != MUNIT_OK))
          goto cleanup;
      }
    }

    if (wild_params_l != 0) {
      const size_t first_wild = params_l;
      for (const MunitParameter* wp = wild_params ; wp != NULL && wp->name != NULL ; wp++) {
        for (const MunitParameterEnum* pe = test->parameters ; pe != NULL && pe->name != NULL ; pe++) {
          if (strcmp(wp->name, pe->name) == 0) {
            if (MUNIT_UNLIKELY(munit_parameters_add(&params_l, &params, pe->name, pe->values[0]) != MUNIT_OK))
              goto cleanup;
          }
        }
      }

      munit_test_runner_run_test_wild(runner, test, test_name, params, params + first_wild);
    } else {
      munit_test_runner_run_test_with_params(runner, test, params);
    }

  cleanup:
    free(params);
    free(wild_params);
  }

  munit_maybe_free_concat(test_name, prefix, test->name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
xorl %eax, %eax
movl %eax, %edi
callq 0x12060
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x18(%rax), %edi
callq 0x10ab0
movq 0xcbae(%rip), %rax      # 0x1efd0
movq (%rax), %rdi
movq -0x20(%rbp), %rdx
leaq 0x85bc(%rip), %rsi      # 0x1a9ec
movb $0x0, %al
callq 0x31e0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x12458
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x127f0
jmp 0x127c8
movq $0x0, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq $0x0, -0x40(%rbp)
movq 0xcb51(%rip), %rax      # 0x1efd0
movq (%rax), %rsi
movl $0xa, %edi
callq 0x3160
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x48(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x48(%rbp)
movb %al, -0x89(%rbp)
je 0x124b8
movq -0x48(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x124c7
jmp 0x1266f
movb $0x0, -0x49(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x58(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x58(%rbp)
movb %al, -0x8a(%rbp)
je 0x124f7
movq -0x58(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x8a(%rbp)
movb -0x8a(%rbp), %al
testb $0x1, %al
jne 0x12503
jmp 0x12568
movq -0x58(%rbp), %rax
movq (%rax), %rdi
movq -0x48(%rbp), %rax
movq (%rax), %rsi
callq 0x31c0
cmpl $0x0, %eax
jne 0x12555
movq -0x48(%rbp), %rax
movq (%rax), %rdx
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rcx
leaq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12fd0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x1254f
jmp 0x127b6
movb $0x1, -0x49(%rbp)
jmp 0x12568
jmp 0x12557
movq -0x58(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x58(%rbp)
jmp 0x124d7
testb $0x1, -0x49(%rbp)
je 0x12573
jmp 0x1265e
movq -0x48(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1258c
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, (%rax)
jne 0x12591
jmp 0x1265e
movq -0x8(%rbp), %rax
testb $0x1, 0x28(%rax)
je 0x1262a
movl $0x0, -0x5c(%rbp)
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
cmpq $0x0, (%rax)
je 0x125d3
movl -0x5c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x5c(%rbp)
movq -0x68(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
jmp 0x125b2
movq -0x20(%rbp), %rdi
callq 0x130c0
movl %eax, %edi
movl -0x5c(%rbp), %esi
subl $0x1, %esi
callq 0x10d50
movl %eax, -0x6c(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rdx
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x6c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
leaq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12fd0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x12628
jmp 0x127b6
jmp 0x1265c
movq -0x48(%rbp), %rax
movq (%rax), %rdx
leaq -0x40(%rbp), %rdi
leaq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
callq 0x12fd0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x1265a
jmp 0x127b6
jmp 0x1265c
jmp 0x1265e
movq -0x48(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x48(%rbp)
jmp 0x12498
cmpq $0x0, -0x40(%rbp)
je 0x127a3
movq -0x30(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x80(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x80(%rbp)
movb %al, -0x8b(%rbp)
je 0x126aa
movq -0x80(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x8b(%rbp)
movb -0x8b(%rbp), %al
testb $0x1, %al
jne 0x126b9
jmp 0x1277d
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x88(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x88(%rbp)
movb %al, -0x8c(%rbp)
je 0x126ee
movq -0x88(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x8c(%rbp)
movb -0x8c(%rbp), %al
testb $0x1, %al
jne 0x126fa
jmp 0x1276a
movq -0x80(%rbp), %rax
movq (%rax), %rdi
movq -0x88(%rbp), %rax
movq (%rax), %rsi
callq 0x31c0
cmpl $0x0, %eax
jne 0x12751
movq -0x88(%rbp), %rax
movq (%rax), %rdx
movq -0x88(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rcx
leaq -0x30(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12fd0
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x1274f
jmp 0x127b6
jmp 0x12751
jmp 0x12753
movq -0x88(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x88(%rbp)
jmp 0x126c8
jmp 0x1276c
movq -0x80(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x80(%rbp)
jmp 0x1268a
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x28(%rbp), %r8
movq -0x78(%rbp), %rax
shlq $0x4, %rax
addq %rax, %r8
callq 0x13110
jmp 0x127b4
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x127f0
jmp 0x127b6
movq -0x28(%rbp), %rdi
callq 0x3030
movq -0x38(%rbp), %rdi
callq 0x3030
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rdx
callq 0x121a0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)