// File: /workspace/github_c_makefile_star2_O3/nemequ[P]safe-math/munit/munit.c
// Function: munit_test_runner_run_test_with_params
static void
munit_test_runner_run_test_with_params(MunitTestRunner* runner, const MunitTest* test, const MunitParameter params[]) {
  MunitResult result = MUNIT_OK;
  MunitReport report = {
    0, 0, 0, 0,
#if defined(MUNIT_ENABLE_TIMING)
    0.0, 0.0
#endif
  };

  if (params != NULL) {
    unsigned int output_l = 2;
    fputs("  ", MUNIT_OUTPUT_FILE);
    bool first = true;
    for (const MunitParameter* param = params ; param != NULL && param->name != NULL ; param++) {
      if (!first) {
        fputs(", ", MUNIT_OUTPUT_FILE);
        output_l += 2;
      } else {
        first = false;
      }

      output_l += fprintf(MUNIT_OUTPUT_FILE, "%s=%s", param->name, param->value);
    }
    while (output_l++ < MUNIT_TEST_NAME_LEN) {
      fputc(' ', MUNIT_OUTPUT_FILE);
    }
  }

  fflush(MUNIT_OUTPUT_FILE);

  FILE* stderr_buf;
#if !defined(_WIN32) || defined(__MINGW32__)
  stderr_buf = tmpfile();
#else
  tmpfile_s(&stderr_buf);
#endif
  if (stderr_buf == NULL) {
    munit_log_errno(MUNIT_LOG_ERROR, stderr, "unable to create buffer for stderr");
    result = MUNIT_ERROR;
    goto print_result;
  }

#if !defined(_WIN32)
  if (runner->fork) {
    int pipefd[2] = { -1, -1 };
    if (pipe(pipefd) != 0) {
      munit_log_errno(MUNIT_LOG_ERROR, stderr, "unable to create pipe");
      result = MUNIT_ERROR;
      goto print_result;
    }

    const pid_t fork_pid = fork();
    if (fork_pid == 0) {
      close(pipefd[0]);

      int orig_stderr = munit_replace_stderr(stderr_buf);
      result = munit_test_runner_exec(runner, test, params, &report);
      munit_restore_stderr(orig_stderr);

      ssize_t bytes_written = 0;
      do {
        bytes_written += write(pipefd[1], ((uint8_t*) (&report)) + bytes_written, sizeof(report) - bytes_written);
        if (bytes_written < 0) {
          if (stderr_buf != NULL) {
	    munit_log_errno(MUNIT_LOG_ERROR, stderr, "unable to write to pipe");
	  }
          exit(EXIT_FAILURE);
        }
      } while ((size_t) bytes_written < sizeof(report));

      if (stderr_buf != NULL)
        fclose(stderr_buf);
      close(pipefd[1]);

      exit(EXIT_SUCCESS);
    } else if (fork_pid == -1) {
      close(pipefd[0]);
      close(pipefd[1]);
      if (stderr_buf != NULL) {
	munit_log_errno(MUNIT_LOG_ERROR, stderr, "unable to fork");
      }
      report.failed++;
      result = MUNIT_ERROR;
    } else {
      close(pipefd[1]);
      ssize_t bytes_read = 0;
      do {
        bytes_read += read(pipefd[0], ((uint8_t*) (&report)) + bytes_read, sizeof(report) - bytes_read);
        if (bytes_read < 1) {
          if (stderr_buf != NULL) {
            int status = 0;
            const pid_t changed_pid = waitpid(fork_pid, &status, WNOHANG);

            if ((changed_pid != fork_pid) || WIFCONTINUED(status)) {
	      munit_log_errno(MUNIT_LOG_ERROR, stderr, "unable to read from pipe");
            } else if (WIFEXITED(status)) {
	      munit_logf_internal(MUNIT_LOG_ERROR, stderr_buf, "child exited unexpectedly with status %d", WEXITSTATUS(status));
            } else if (WIFSIGNALED(status)) {
	      munit_logf_internal(MUNIT_LOG_ERROR, stderr_buf, "child killed by signal %d (%s)", WTERMSIG(status), strsignal(WTERMSIG(status)));
            } else if (WIFSTOPPED(status)) {
	      munit_logf_internal(MUNIT_LOG_ERROR, stderr_buf, "child stopped by signal %d", WSTOPSIG(status));
            }
          }
          break;
        }
      } while (bytes_read < (ssize_t) sizeof(report));

      if (bytes_read != sizeof(report)) {
        report.failed++;
      }

      close(pipefd[0]);
      waitpid(fork_pid, NULL, 0);
    }
  } else
#endif
  {
    const volatile int orig_stderr = munit_replace_stderr(stderr_buf);

#if defined(MUNIT_THREAD_LOCAL)
    if (MUNIT_UNLIKELY(setjmp(munit_error_jmp_buf) != 0)) {
      result = MUNIT_FAIL;
      report.failed++;
    } else {
      munit_error_jmp_buf_valid = true;
      result = munit_test_runner_exec(runner, test, params, &report);
    }
#else
    result = munit_test_runner_exec(runner, test, params, &report);
#endif

    munit_restore_stderr(orig_stderr);

    /* Here just so that the label is used on Windows and we don't get
     * a warning */
    goto print_result;
  }

 print_result:

  fputs("[ ", MUNIT_OUTPUT_FILE);
  if (report.failed > 0) {
    munit_test_runner_print_color(runner, MUNIT_RESULT_STRING_FAIL, '1');
    runner->report.failed++;
    result = MUNIT_FAIL;
  } else if (report.errored > 0) {
    munit_test_runner_print_color(runner, MUNIT_RESULT_STRING_ERROR, '1');
    runner->report.errored++;
    result = MUNIT_ERROR;
  } else if (report.skipped > 0) {
    munit_test_runner_print_color(runner, MUNIT_RESULT_STRING_SKIP, '3');
    runner->report.skipped++;
    result = MUNIT_SKIP;
  } else if (report.successful > 1) {
    munit_test_runner_print_color(runner, MUNIT_RESULT_STRING_OK, '2');
#if defined(MUNIT_ENABLE_TIMING)
    fputs(" ] [ ", MUNIT_OUTPUT_FILE);
    munit_print_time(MUNIT_OUTPUT_FILE, report.wall_clock / ((double) report.successful));
    fputs(" / ", MUNIT_OUTPUT_FILE);
    munit_print_time(MUNIT_OUTPUT_FILE, report.cpu_clock / ((double) report.successful));
    fprintf(MUNIT_OUTPUT_FILE, " CPU ]\n  %-" MUNIT_XSTRINGIFY(MUNIT_TEST_NAME_LEN) "s Total: [ ", "");
    munit_print_time(MUNIT_OUTPUT_FILE, report.wall_clock);
    fputs(" / ", MUNIT_OUTPUT_FILE);
    munit_print_time(MUNIT_OUTPUT_FILE, report.cpu_clock);
    fputs(" CPU", MUNIT_OUTPUT_FILE);
#endif
    runner->report.successful++;
    result = MUNIT_OK;
  } else if (report.successful > 0) {
    munit_test_runner_print_color(runner, MUNIT_RESULT_STRING_OK, '2');
#if defined(MUNIT_ENABLE_TIMING)
    fputs(" ] [ ", MUNIT_OUTPUT_FILE);
    munit_print_time(MUNIT_OUTPUT_FILE, report.wall_clock);
    fputs(" / ", MUNIT_OUTPUT_FILE);
    munit_print_time(MUNIT_OUTPUT_FILE, report.cpu_clock);
    fputs(" CPU", MUNIT_OUTPUT_FILE);
#endif
    runner->report.successful++;
    result = MUNIT_OK;
  }
  fputs(" ]\n", MUNIT_OUTPUT_FILE);

  if (stderr_buf != NULL) {
    if (result == MUNIT_FAIL || result == MUNIT_ERROR || runner->show_stderr) {
      fflush(MUNIT_OUTPUT_FILE);

      rewind(stderr_buf);
      munit_splice(fileno(stderr_buf), STDERR_FILENO);

      fflush(stderr);
    }

    fclose(stderr_buf);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x478, %rsp            # imm = 0x478
movq %rsi, 0x38(%rsp)
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
testq %rdx, %rdx
movq %rdx, 0x40(%rsp)
je 0x4dd3
movq %rdx, %rbx
movq 0x52ad(%rip), %r13      # 0x9fd0
movq (%r13), %rsi
leaq 0x22e8(%rip), %rdi      # 0x7016
callq 0x3120
movq (%rbx), %rcx
testq %rcx, %rcx
je 0x4db1
movq %r14, 0x60(%rsp)
leaq 0x10(%rbx), %r14
movb $0x1, %bpl
movl $0x2, %r12d
leaq 0x21cb(%rip), %rbx      # 0x6f1f
leaq 0x21bb(%rip), %r15      # 0x6f16
testb $0x1, %bpl
je 0x4d66
movq %rcx, %rdx
jmp 0x4d7a
movq (%r13), %rsi
movq %r15, %rdi
callq 0x3120
addl $0x2, %r12d
movq -0x10(%r14), %rdx
movq (%r13), %rdi
movq -0x8(%r14), %rcx
xorl %eax, %eax
movl %eax, %ebp
movq %rbx, %rsi
callq 0x31d0
addl %r12d, %eax
movq (%r14), %rsi
addq $0x10, %r14
movq %rsi, %rcx
movl %eax, %r12d
testq %rsi, %rsi
jne 0x4d5b
movl %eax, %ecx
cmpl $0x24, %eax
movq 0x60(%rsp), %r14
jbe 0x4db6
jmp 0x4dd3
movl $0x2, %ecx
addl $-0x25, %ecx
movl $0x20, %ebx
movl %ecx, %eax
movl %eax, %ebp
movq (%r13), %rsi
movl %ebx, %edi
callq 0x3150
incl %ebp
movl %ebp, %eax
jne 0x4dc0
movq 0x51f6(%rip), %rbx      # 0x9fd0
movq (%rbx), %rdi
callq 0x3220
callq 0x31a0
movq %rax, %r15
movq %rax, %r13
testq %rax, %rax
je 0x4e25
cmpb $0x1, 0x59(%r14)
jne 0x4e42
leaq 0x70(%rsp), %rdi
movq $-0x1, (%rdi)
callq 0x3140
testl %eax, %eax
je 0x4f27
movq 0x51d7(%rip), %rax      # 0x9ff0
movq (%rax), %rdi
leaq 0x2125(%rip), %rsi      # 0x6f48
jmp 0x4e36
movq 0x51c4(%rip), %rax      # 0x9ff0
movq (%rax), %rdi
leaq 0x20ef(%rip), %rsi      # 0x6f25
callq 0x5477
movl $0x3, %ebp
jmp 0x4e96
movq %r13, %rdi
callq 0x54c8
movl %eax, 0x70(%rsp)
movq %fs:0x0, %rax
leaq -0xd0(%rax), %rdi
callq 0x3170
testl %eax, %eax
jne 0x5317
movb $0x1, %fs:-0xe0
leaq 0x10(%rsp), %rcx
movq %r14, %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x5503
movl %eax, %ebp
movl 0x70(%rsp), %edi
callq 0x5678
movq (%rbx), %rsi
leaq 0x2199(%rip), %rdi      # 0x7039
callq 0x3120
cmpl $0x0, 0x18(%rsp)
je 0x4ecf
movl 0x58(%r14), %edi
leaq 0x214a(%rip), %rsi      # 0x7001
movl $0x31, %edx
callq 0x5693
incl 0x40(%r14)
movl $0x1, %ebp
jmp 0x51b3
cmpl $0x0, 0x1c(%rsp)
je 0x4ef9
movl 0x58(%r14), %edi
leaq 0x2126(%rip), %rsi      # 0x7007
movl $0x31, %edx
callq 0x5693
incl 0x44(%r14)
movl $0x3, %ebp
jmp 0x51b3
cmpl $0x0, 0x14(%rsp)
je 0x4fc8
movl 0x58(%r14), %edi
leaq 0x20fe(%rip), %rsi      # 0x700d
movl $0x33, %edx
callq 0x5693
incl 0x3c(%r14)
movl $0x2, %ebp
jmp 0x51b3
callq 0x3290
cmpl $-0x1, %eax
je 0x4f97
movl %eax, %ebp
movq %r14, %r12
movq %r13, (%rsp)
testl %eax, %eax
je 0x5325
movl %ebp, 0xc(%rsp)
movl 0x74(%rsp), %edi
callq 0x3130
xorl %eax, %eax
movl %eax, %ecx
movl $0x20, %r14d
movq %rcx, %r13
movl 0x70(%rsp), %edi
leaq (%rsp,%rcx), %rsi
addq $0x10, %rsi
movq %r14, %rdx
subq %rcx, %rdx
callq 0x3160
addq %r13, %rax
jle 0x50d5
movq %rax, %rcx
cmpq $0x20, %rax
jb 0x4f59
movq (%rsp), %r13
movq %r12, %r14
jne 0x52f6
jmp 0x52fa
movl 0x70(%rsp), %edi
callq 0x3130
movl 0x74(%rsp), %edi
callq 0x3130
movq 0x5040(%rip), %rax      # 0x9ff0
movq (%rax), %rdi
leaq 0x1fbc(%rip), %rsi      # 0x6f76
callq 0x5477
incl 0x18(%rsp)
jmp 0x4e3b
movq %r14, %rax
movl 0x10(%rsp), %r14d
cmpl $0x2, %r14d
jb 0x5132
movq %rax, %rbp
movl 0x58(%rax), %edi
leaq 0x202c(%rip), %rsi      # 0x7013
movl $0x32, %edx
callq 0x5693
movq (%rbx), %rsi
leaq 0x201e(%rip), %rdi      # 0x7019
callq 0x3120
movq (%rbx), %rdi
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x58(%rsp)
movl %r14d, %r14d
movl %r14d, %eax
cvtsi2sd %rax, %xmm1
movsd %xmm1, 0x48(%rsp)
divsd %xmm1, %xmm0
leaq 0x2071(%rip), %r12      # 0x709c
movb $0x1, %al
movq %r12, %rsi
callq 0x31d0
movq (%rbx), %rsi
movq %r13, %r14
leaq 0x1fdd(%rip), %rdi      # 0x701f
callq 0x3120
movq (%rbx), %rdi
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
divsd 0x48(%rsp), %xmm0
movq %r12, %rsi
movb $0x1, %r13b
movl %r13d, %eax
callq 0x31d0
movq (%rbx), %rdi
leaq 0x1faf(%rip), %rsi      # 0x7023
leaq 0x18de(%rip), %rdx      # 0x6959
xorl %eax, %eax
callq 0x31d0
movq (%rbx), %rdi
movq %r12, %rsi
movsd 0x58(%rsp), %xmm0
movl %r13d, %eax
callq 0x31d0
movq (%rbx), %rsi
leaq 0x1f7f(%rip), %rdi      # 0x701f
movq %r14, %r13
movq %rbp, %r14
callq 0x3120
movq (%rbx), %rdi
movq %r12, %rsi
movsd 0x50(%rsp), %xmm0
movb $0x1, %al
callq 0x31d0
movq (%rbx), %rsi
leaq 0x1f74(%rip), %rdi      # 0x703c
callq 0x3120
incl 0x38(%rbp)
jmp 0x51b1
leaq 0x6c(%rsp), %r13
movl $0x0, (%r13)
movl 0xc(%rsp), %edi
movq %r13, %rsi
movl $0x1, %edx
callq 0x3260
cmpl %ebp, %eax
setne %al
movl (%r13), %ecx
cmpl $0xffff, %ecx           # imm = 0xFFFF
sete %dl
orb %al, %dl
cmpb $0x1, %dl
jne 0x5290
movq 0x4ed9(%rip), %rax      # 0x9ff0
movq (%rax), %rdi
leaq 0x1e64(%rip), %rsi      # 0x6f85
callq 0x5477
movq (%rsp), %r13
movq %r12, %r14
jmp 0x52f6
cmpl $0x1, %r14d
movq %rax, %r14
jne 0x51b3
movl 0x58(%r14), %edi
leaq 0x1ecd(%rip), %rsi      # 0x7013
movl $0x32, %edx
callq 0x5693
movq (%rbx), %rsi
leaq 0x1ebf(%rip), %rdi      # 0x7019
callq 0x3120
movq (%rbx), %rdi
movsd 0x28(%rsp), %xmm0
leaq 0x1f2d(%rip), %r12      # 0x709c
movb $0x1, %bpl
movq %r12, %rsi
movl %ebp, %eax
callq 0x31d0
movq (%rbx), %rsi
leaq 0x1e99(%rip), %rdi      # 0x701f
callq 0x3120
movq (%rbx), %rdi
movsd 0x20(%rsp), %xmm0
movq %r12, %rsi
movl %ebp, %eax
callq 0x31d0
movq (%rbx), %rsi
leaq 0x1e94(%rip), %rdi      # 0x703c
callq 0x3120
incl 0x38(%r14)
xorl %ebp, %ebp
movq (%rbx), %rsi
leaq 0x1e84(%rip), %rdi      # 0x7041
callq 0x3120
testq %r15, %r15
je 0x527e
andl $-0x3, %ebp
cmpl $0x1, %ebp
je 0x51de
cmpb $0x1, 0x5a(%r14)
jne 0x5276
movq (%rbx), %rdi
callq 0x3220
movq %r13, %rdi
callq 0x3100
movq %r13, (%rsp)
movq %r13, %rdi
callq 0x3200
movl %eax, %ebp
leaq 0x70(%rsp), %rsi
movl $0x400, %edx            # imm = 0x400
movl %eax, %edi
callq 0x3160
testq %rax, %rax
jle 0x5263
movl $0x2, %r14d
leaq 0x70(%rsp), %r15
movl $0x400, %r12d           # imm = 0x400
movq %rax, %r13
xorl %eax, %eax
movl %eax, %ebx
leaq (%rsp,%rbx), %rsi
addq $0x70, %rsi
movq %r13, %rdx
subq %rbx, %rdx
movl %r14d, %edi
callq 0x30b0
movq %rax, %rcx
addq %rbx, %rcx
movq %rcx, %rbx
cmpq %r13, %rcx
jb 0x522a
movl %ebp, %edi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3160
movq %rax, %r13
testq %rax, %rax
jg 0x5226
movq 0x4d86(%rip), %rax      # 0x9ff0
movq (%rax), %rdi
callq 0x3220
movq (%rsp), %r13
movq %r13, %rdi
callq 0x30c0
addq $0x478, %rsp            # imm = 0x478
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl %ecx, %eax
movl %ecx, %ebp
andl $0x7f, %ebp
movq (%rsp), %r13
movq %r12, %r14
je 0x52d2
movl %ebp, %ecx
shll $0x18, %ecx
addl $0x1000000, %ecx        # imm = 0x1000000
cmpl $0x2000000, %ecx        # imm = 0x2000000
jl 0x52de
movl %ebp, %edi
callq 0x3230
movq %rax, %r8
leaq 0x1d03(%rip), %rdx      # 0x6fc7
xorl %eax, %eax
movl %ebp, %ecx
movq %r13, %rsi
callq 0x4464
jmp 0x52f6
movzbl %ah, %ecx
leaq 0x1cc2(%rip), %rdx      # 0x6f9e
jmp 0x52ec
cmpb $0x7f, %al
jne 0x52f6
movzbl %ah, %ecx
leaq 0x1cfa(%rip), %rdx      # 0x6fe6
xorl %eax, %eax
movq %r13, %rsi
callq 0x4464
incl 0x18(%rsp)
movl 0x70(%rsp), %edi
callq 0x3130
xorl %ebp, %ebp
movl %ebp, %esi
movl 0xc(%rsp), %edi
movl %ebp, %edx
callq 0x3260
jmp 0x4e96
incl 0x18(%rsp)
movl $0x1, %ebp
jmp 0x4e8d
movl 0x70(%rsp), %edi
callq 0x3130
movq (%rsp), %rdi
callq 0x54c8
movl %eax, %ebp
leaq 0x10(%rsp), %rcx
movq %r12, %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x5503
movl %ebp, %edi
callq 0x5678
xorl %eax, %eax
movl %eax, %ecx
movl $0x20, %ebx
movq %rcx, %r14
movl 0x74(%rsp), %edi
leaq (%rsp,%rcx), %rsi
addq $0x10, %rsi
movq %rbx, %rdx
subq %rcx, %rdx
callq 0x30b0
addq %r14, %rax
js 0x53a1
movq %rax, %rcx
cmpq $0x20, %rax
jb 0x5360
movq (%rsp), %rdi
callq 0x30c0
movl 0x74(%rsp), %edi
callq 0x3130
xorl %edi, %edi
callq 0x3280
movq 0x4c48(%rip), %rax      # 0x9ff0
movq (%rax), %rdi
leaq 0x1bac(%rip), %rsi      # 0x6f5e
callq 0x5477
movl $0x1, %edi
callq 0x3280