// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x3130
cmpq $0x0, -0x18(%rbp)
je 0x12911
movl $0x2, -0x44(%rbp)
movq 0xc799(%rip), %rax      # 0x1efd0
movq (%rax), %rsi
leaq 0x82a8(%rip), %rdi      # 0x1aae9
callq 0x3120
movb $0x1, -0x45(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x50(%rbp)
movb %al, -0x85(%rbp)
je 0x12872
movq -0x50(%rbp), %rax
cmpq $0x0, (%rax)
setne %al
movb %al, -0x85(%rbp)
movb -0x85(%rbp), %al
testb $0x1, %al
jne 0x1287e
jmp 0x128e7
testb $0x1, -0x45(%rbp)
jne 0x128a5
movq 0xc745(%rip), %rax      # 0x1efd0
movq (%rax), %rsi
leaq 0x8154(%rip), %rdi      # 0x1a9e9
callq 0x3120
movl -0x44(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x44(%rbp)
jmp 0x128a9
movb $0x0, -0x45(%rbp)
movq 0xc720(%rip), %rax      # 0x1efd0
movq (%rax), %rdi
movq -0x50(%rbp), %rax
movq (%rax), %rdx
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rcx
leaq 0x8129(%rip), %rsi      # 0x1a9f2
movb $0x0, %al
callq 0x31e0
addl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x50(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x50(%rbp)
jmp 0x12852
jmp 0x128e9
movl -0x44(%rbp), %eax
movl %eax, %ecx
addl $0x1, %ecx
movl %ecx, -0x44(%rbp)
cmpl $0x25, %eax
jae 0x1290f
movq 0xc6d0(%rip), %rax      # 0x1efd0
movq (%rax), %rsi
movl $0x20, %edi
callq 0x3160
jmp 0x128e9
jmp 0x12911
movq 0xc6b8(%rip), %rax      # 0x1efd0
movq (%rax), %rdi
callq 0x3230
callq 0x31b0
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x12957
movq 0xc6b9(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movl $0x3, %edi
leaq 0x80b2(%rip), %rdx      # 0x1a9f8
callq 0x13230
movl $0x3, -0x1c(%rbp)
jmp 0x12cd3
movq -0x8(%rbp), %rax
testb $0x1, 0x59(%rax)
je 0x12c50
movq 0x785c(%rip), %rax      # 0x1a1c8
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3150
cmpl $0x0, %eax
je 0x129a5
movq 0xc66b(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movl $0x3, %edi
leaq 0x8087(%rip), %rdx      # 0x1aa1b
callq 0x13230
movl $0x3, -0x1c(%rbp)
jmp 0x12cd3
callq 0x32a0
movl %eax, -0x64(%rbp)
cmpl $0x0, -0x64(%rbp)
jne 0x12a6f
movl -0x60(%rbp), %edi
callq 0x3140
movq -0x58(%rbp), %rdi
callq 0x132c0
movl %eax, -0x68(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x13330
movl %eax, -0x1c(%rbp)
movl -0x68(%rbp), %edi
callq 0x13500
movq $0x0, -0x70(%rbp)
movl -0x5c(%rbp), %edi
leaq -0x40(%rbp), %rsi
addq -0x70(%rbp), %rsi
movl $0x20, %edx
subq -0x70(%rbp), %rdx
callq 0x30b0
addq -0x70(%rbp), %rax
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
jge 0x12a47
cmpq $0x0, -0x58(%rbp)
je 0x12a3d
movq 0xc5c7(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movl $0x3, %edi
leaq 0x7ff9(%rip), %rdx      # 0x1aa31
callq 0x13230
movl $0x1, %edi
callq 0x3290
jmp 0x12a49
cmpq $0x20, -0x70(%rbp)
jb 0x129f3
cmpq $0x0, -0x58(%rbp)
je 0x12a60
movq -0x58(%rbp), %rdi
callq 0x30c0
movl -0x5c(%rbp), %edi
callq 0x3140
xorl %edi, %edi
callq 0x3290
cmpl $-0x1, -0x64(%rbp)
jne 0x12abc
movl -0x60(%rbp), %edi
callq 0x3140
movl -0x5c(%rbp), %edi
callq 0x3140
cmpq $0x0, -0x58(%rbp)
je 0x12aa7
movq 0xc55d(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movl $0x3, %edi
leaq 0x7fa7(%rip), %rdx      # 0x1aa49
callq 0x13230
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl $0x3, -0x1c(%rbp)
jmp 0x12c49
movl -0x5c(%rbp), %edi
callq 0x3140
movq $0x0, -0x78(%rbp)
movl -0x60(%rbp), %edi
leaq -0x40(%rbp), %rsi
addq -0x78(%rbp), %rsi
movl $0x20, %edx
subq -0x78(%rbp), %rdx
callq 0x3170
addq -0x78(%rbp), %rax
movq %rax, -0x78(%rbp)
cmpq $0x1, -0x78(%rbp)
jge 0x12c16
cmpq $0x0, -0x58(%rbp)
je 0x12c14
movl $0x0, -0x7c(%rbp)
movl -0x64(%rbp), %edi
leaq -0x7c(%rbp), %rsi
movl $0x1, %edx
callq 0x3270
movl %eax, -0x80(%rbp)
movl -0x80(%rbp), %eax
cmpl -0x64(%rbp), %eax
jne 0x12b2f
cmpl $0xffff, -0x7c(%rbp)    # imm = 0xFFFF
jne 0x12b4f
movq 0xc4ba(%rip), %rax      # 0x1eff0
movq (%rax), %rsi
movl $0x3, %edi
leaq 0x7f13(%rip), %rdx      # 0x1aa58
callq 0x13230
jmp 0x12c12
movl -0x7c(%rbp), %eax
andl $0x7f, %eax
cmpl $0x0, %eax
jne 0x12b82
movq -0x58(%rbp), %rsi
movl -0x7c(%rbp), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
sarl $0x8, %ecx
movl $0x3, %edi
leaq 0x7efb(%rip), %rdx      # 0x1aa71
movb $0x0, %al
callq 0x11b30
jmp 0x12c10
movl -0x7c(%rbp), %eax
andl $0x7f, %eax
addl $0x1, %eax
movsbl %al, %eax
sarl %eax
cmpl $0x0, %eax
jle 0x12bdc
movq -0x58(%rbp), %rax
movq %rax, -0x98(%rbp)
movl -0x7c(%rbp), %eax
andl $0x7f, %eax
movl %eax, -0x8c(%rbp)
movl -0x7c(%rbp), %edi
andl $0x7f, %edi
callq 0x3240
movq -0x98(%rbp), %rsi
movl -0x8c(%rbp), %ecx
movq %rax, %r8
movl $0x3, %edi
leaq 0x7ec7(%rip), %rdx      # 0x1aa9a
movb $0x0, %al
callq 0x11b30
jmp 0x12c0e
movl -0x7c(%rbp), %eax
andl $0xff, %eax
cmpl $0x7f, %eax
jne 0x12c0c
movq -0x58(%rbp), %rsi
movl -0x7c(%rbp), %ecx
andl $0xff00, %ecx           # imm = 0xFF00
sarl $0x8, %ecx
movl $0x3, %edi
leaq 0x7eb4(%rip), %rdx      # 0x1aab9
movb $0x0, %al
callq 0x11b30
jmp 0x12c0e
jmp 0x12c10
jmp 0x12c12
jmp 0x12c14
jmp 0x12c23
jmp 0x12c18
cmpq $0x20, -0x78(%rbp)
jl 0x12acc
cmpq $0x20, -0x78(%rbp)
je 0x12c33
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
movl -0x60(%rbp), %edi
callq 0x3140
movl -0x64(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x3270
jmp 0x12c4b
jmp 0x12cd1
movq -0x58(%rbp), %rdi
callq 0x132c0
movl %eax, -0x84(%rbp)
movq %fs:0x0, %rax
leaq -0xd0(%rax), %rdi
callq 0x3180
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0x12c99
movl $0x1, -0x1c(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x12cc4
movq %fs:0x0, %rax
leaq -0xe0(%rax), %rax
movb $0x1, (%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x40(%rbp), %rcx
callq 0x13330
movl %eax, -0x1c(%rbp)
movl -0x84(%rbp), %edi
callq 0x13500
jmp 0x12cd3
jmp 0x12cd3
movq 0xc2f6(%rip), %rax      # 0x1efd0
movq (%rax), %rsi
leaq 0x7e28(%rip), %rdi      # 0x1ab0c
callq 0x3120
cmpl $0x0, -0x38(%rbp)
jbe 0x12d1d
movq -0x8(%rbp), %rdi
leaq 0x7dda(%rip), %rsi      # 0x1aad4
movl $0x31, %edx
callq 0x13530
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x40(%rax)
movl $0x1, -0x1c(%rbp)
jmp 0x12f48
cmpl $0x0, -0x34(%rbp)
jbe 0x12d51
movq -0x8(%rbp), %rdi
leaq 0x7dac(%rip), %rsi      # 0x1aada
movl $0x31, %edx
callq 0x13530
movq -0x8(%rbp), %rax
movl 0x44(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x44(%rax)
movl $0x3, -0x1c(%rbp)
jmp 0x12f46
cmpl $0x0, -0x3c(%rbp)
jbe 0x12d85
movq -0x8(%rbp), %rdi
leaq 0x7d7e(%rip), %rsi      # 0x1aae0
movl $0x33, %edx
callq 0x13530
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x3c(%rax)
movl $0x2, -0x1c(%rbp)
jmp 0x12f44
cmpl $0x1, -0x40(%rbp)
jbe 0x12ea3
movq -0x8(%rbp), %rdi
leaq 0x7d4c(%rip), %rsi      # 0x1aae6
movl $0x32, %edx
callq 0x13530
movq 0xc225(%rip), %rax      # 0x1efd0
movq %rax, -0xa0(%rbp)
movq (%rax), %rsi
leaq 0x7d30(%rip), %rdi      # 0x1aaec
callq 0x3120
movq -0xa0(%rbp), %rax
movq (%rax), %rdi
movsd -0x28(%rbp), %xmm0
movl -0x40(%rbp), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
callq 0x13590
movq -0xa0(%rbp), %rax
movq (%rax), %rsi
leaq 0x7d00(%rip), %rdi      # 0x1aaf2
callq 0x3120
movq -0xa0(%rbp), %rax
movq (%rax), %rdi
movsd -0x30(%rbp), %xmm0
movl -0x40(%rbp), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
callq 0x13590
movq 0xc1b2(%rip), %rax      # 0x1efd0
movq (%rax), %rdi
leaq 0x7cce(%rip), %rsi      # 0x1aaf6
leaq 0x75fd(%rip), %rdx      # 0x1a42c
movb $0x0, %al
callq 0x31e0
movq 0xc193(%rip), %rax      # 0x1efd0
movq (%rax), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x13590
movq 0xc17f(%rip), %rax      # 0x1efd0
movq (%rax), %rsi
leaq 0x7c97(%rip), %rdi      # 0x1aaf2
callq 0x3120
movq 0xc169(%rip), %rax      # 0x1efd0
movq (%rax), %rdi
movsd -0x30(%rbp), %xmm0
callq 0x13590
movq 0xc155(%rip), %rax      # 0x1efd0
movq (%rax), %rsi
leaq 0x7c8a(%rip), %rdi      # 0x1ab0f
callq 0x3120
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
movl $0x0, -0x1c(%rbp)
jmp 0x12f42
cmpl $0x0, -0x40(%rbp)
jbe 0x12f40
movq -0x8(%rbp), %rdi
leaq 0x7c2e(%rip), %rsi      # 0x1aae6
movl $0x32, %edx
callq 0x13530
movq 0xc107(%rip), %rax      # 0x1efd0
movq (%rax), %rsi
leaq 0x7c19(%rip), %rdi      # 0x1aaec
callq 0x3120
movq 0xc0f1(%rip), %rax      # 0x1efd0
movq (%rax), %rdi
movsd -0x28(%rbp), %xmm0
callq 0x13590
movq 0xc0dd(%rip), %rax      # 0x1efd0
movq (%rax), %rsi
leaq 0x7bf5(%rip), %rdi      # 0x1aaf2
callq 0x3120
movq 0xc0c7(%rip), %rax      # 0x1efd0
movq (%rax), %rdi
movsd -0x30(%rbp), %xmm0
callq 0x13590
movq 0xc0b3(%rip), %rax      # 0x1efd0
movq (%rax), %rsi
leaq 0x7be8(%rip), %rdi      # 0x1ab0f
callq 0x3120
movq -0x8(%rbp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
movl $0x0, -0x1c(%rbp)
jmp 0x12f42
jmp 0x12f44
jmp 0x12f46
jmp 0x12f48
movq 0xc081(%rip), %rax      # 0x1efd0
movq (%rax), %rsi
leaq 0x7bbb(%rip), %rdi      # 0x1ab14
callq 0x3120
cmpq $0x0, -0x58(%rbp)
je 0x12fc0
cmpl $0x1, -0x1c(%rbp)
je 0x12f7b
cmpl $0x3, -0x1c(%rbp)
je 0x12f7b
movq -0x8(%rbp), %rax
testb $0x1, 0x5a(%rax)
je 0x12fb7
movq 0xc04e(%rip), %rax      # 0x1efd0
movq (%rax), %rdi
callq 0x3230
movq -0x58(%rbp), %rdi
callq 0x3100
movq -0x58(%rbp), %rdi
callq 0x3210
movl %eax, %edi
movl $0x2, %esi
callq 0x135c0
movq 0xc041(%rip), %rax      # 0x1eff0
movq (%rax), %rdi
callq 0x3230
movq -0x58(%rbp), %rdi
callq 0x30c0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)