LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/interimadd[P]M5Stack-PixelArt/test/lib/googletest/googletest/include/gtest/internal/gtest-port.h
// Function: testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder, testing::internal::ThreadLocalValueHolderBase>(testing::internal::ThreadLocalValueHolderBase*)
Derived* CheckedDowncastToActualType(Base* base) {
#if GTEST_HAS_RTTI
  GTEST_CHECK_(typeid(*base) == typeid(Derived));
#endif

#if GTEST_HAS_DOWNCAST_
  return ::down_cast<Derived*>(base);
#elif GTEST_HAS_RTTI
  return dynamic_cast<Derived*>(base);  // NOLINT
#else
  return static_cast<Derived*>(base);  // Poor man's downcast.
#endif
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x439ba
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x9cdd(%rip), %rax      # 0x4d623
cmpq %rax, %rdi
je 0x4399d
cmpb $0x2a, (%rdi)
je 0x43960
leaq 0x9ccc(%rip), %rsi      # 0x4d623
callq 0x1d700
testl %eax, %eax
je 0x4399d
leaq 0x9140(%rip), %rdx      # 0x4caa7
leaq 0xc(%rsp), %rdi
movl $0x3, %esi
movl $0x572, %ecx            # imm = 0x572
callq 0x3d4cc
movq 0x1c66e(%rip), %rdi     # 0x5fff0
leaq 0x93b7(%rip), %rsi      # 0x4cd40
movl $0x33, %edx
callq 0x1d540
leaq 0xc(%rsp), %rdi
callq 0x3d60e
leaq 0x1c1cc(%rip), %rsi     # 0x5fb70
leaq 0x1c1d5(%rip), %rdx     # 0x5fb80
movq %rbx, %rdi
xorl %ecx, %ecx
addq $0x10, %rsp
popq %rbx
jmp 0x1d530
callq 0x1d4e0
movq %rax, %rbx
leaq 0xc(%rsp), %rdi
callq 0x3d60e
movq %rbx, %rdi
callq 0x1d900
// File: /workspace/github_cpp_makefile_star2_O3/chen3feng[P]error-handling/result.cpp
// Function: ParseInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
Result<int, ErrnoError> ParseInt(const std::string& s) {
    errno = 0;
    char* end = const_cast<char*>(s.c_str());
    long n = strtol(s.c_str(), &end, 0);
    if (errno == 0) {
        if (*end != '\0') {
            errno = EINVAL;
        } else if (n > INT_MAX || n < INT_MIN) {
            errno = ERANGE;
        } else {
            return static_cast<int>(n);
        }
    }
    return ErrnoError(ErrnoType(errno));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2040
movq %rax, %r14
movl $0x0, (%rax)
movq (%r15), %rdi
leaq -0x20(%rbp), %rsi
movq %rdi, (%rsi)
xorl %edx, %edx
callq 0x2120
movl (%r14), %r15d
testl %r15d, %r15d
jne 0x2566
movq -0x20(%rbp), %rcx
movl $0x16, %r15d
cmpb $0x0, (%rcx)
jne 0x2563
movslq %eax, %rcx
movl $0x22, %r15d
cmpq %rax, %rcx
je 0x25ce
movl %r15d, (%r14)
movl $0x38, %edi
callq 0x20d0
movabsq $0x100000001, %rcx      # imm = 0x100000001
movq %rcx, 0x8(%rax)
leaq 0x378b(%rip), %rcx      # 0x5d10
movq %rcx, (%rax)
leaq 0x10(%rax), %rcx
leaq 0x37f5(%rip), %rdx      # 0x5d88
movq %rdx, 0x10(%rax)
movl %r15d, 0x18(%rax)
leaq 0x1a77(%rip), %rdx      # 0x4019
movq %rdx, 0x20(%rax)
movl $0x11a, 0x28(%rax)      # imm = 0x11A
leaq 0x1a79(%rip), %rdx      # 0x402d
movq %rdx, 0x30(%rax)
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
jmp 0x25c0
// File: /workspace/github_cpp_makefile_star2_O3/aempirei[P]Chat-Art/pgmtobraile.c
// Function: dither
void dither(uint8_t *data, size_t width, size_t height) {

	int *front;
	int *error;

	size_t sz = width * height;

	front = malloc(sizeof(int) * sz);
	error = malloc(sizeof(int) * sz);

	memset(error, 0, sizeof(int) * sz);

	for(size_t z = 0; z < sz; z++)
		front[z] = ((data[z] > 40) ? 128 : 32) - data[z];

	for(size_t y = 1; y < height - 1; y++) {
		for(size_t x = 1; x < width - 1; x++) {

			int d = BIT(front,x,y,width) / 6;

			BIT(error,x,y-1,width) += d;
			BIT(error,x-1,y,width) += d;
			BIT(error,x+1,y,width) += d;
			BIT(error,x,y+1,width) += d;

			BIT(error,x,y,width) -= d * 6;
		}
	}

	for(size_t z = 0; z < sz; z++) {
		int x = (int)data[z] + error[z];
		data[z] = (uint8_t)((x < 0) ? 0 : (x > 255) ? 255 : x);
	}

	free(front);
	free(error);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %rdx, %rbp
imulq %rsi, %rbp
leaq (,%rbp,4), %r15
movq %r15, %rdi
callq 0x10b0
movq %rax, %r14
movl $0x1, %edi
movq %r15, %rsi
callq 0x1080
testq %rbp, %rbp
je 0x1333
xorl %edi, %edi
movl $0x80, %ecx
movzbl (%rbx,%rdi), %edx
cmpl $0x29, %edx
movl $0x20, %esi
cmovael %ecx, %esi
subl %edx, %esi
movl %esi, (%r14,%rdi,4)
incq %rdi
cmpq %rdi, %rbp
jne 0x1316
movq %r14, (%rsp)
decq %r12
cmpq $0x2, %r12
jb 0x142e
leaq -0x1(%r13), %r15
leaq (,%r13,4), %rdx
addq $-0x2, %r13
leaq 0x8(%rax), %rcx
movq %rcx, 0x18(%rsp)
movq (%rsp), %rcx
addq $0x4, %rcx
movq %rcx, 0x10(%rsp)
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, 0x8(%rsp)
movl $0x1, %r8d
movq %r15, 0x20(%rsp)
cmpq $0x1, %r15
jbe 0x1422
movq %r12, %r15
leaq -0x1(%r8), %r9
movq %rdx, %r10
imulq %r8, %r10
incq %r8
movq %rax, %rdi
movl 0x4(%rax,%r10), %esi
movq 0x18(%rsp), %rax
leaq (%rax,%r10), %r11
addq 0x10(%rsp), %r10
movq %rdx, %rcx
imulq %r8, %rcx
movq 0x8(%rsp), %rax
addq %rax, %rcx
imulq %rdx, %r9
addq %rax, %r9
xorl %r14d, %r14d
movslq (%r10,%r14,4), %r12
imulq $0x2aaaaaab, %r12, %r12 # imm = 0x2AAAAAAB
movq %r12, %rax
shrq $0x3f, %rax
shrq $0x20, %r12
addl %eax, %r12d
addl %r12d, (%r9,%r14,4)
addl %r12d, -0x8(%r11,%r14,4)
movl (%r11,%r14,4), %eax
addl %r12d, %eax
movl %eax, (%r11,%r14,4)
addl %r12d, (%rcx,%r14,4)
addl %r12d, %r12d
leal (%r12,%r12,2), %r12d
subl %r12d, %esi
movl %esi, -0x4(%r11,%r14,4)
incq %r14
movl %eax, %esi
cmpq %r14, %r13
jne 0x13cb
movq %r15, %r12
movq 0x20(%rsp), %r15
movq %rdi, %rax
jmp 0x1425
incq %r8
cmpq %r12, %r8
jne 0x1381
testq %rbp, %rbp
movq (%rsp), %rdi
je 0x145b
xorl %esi, %esi
movl $0xff, %ecx
movzbl (%rbx,%rsi), %edx
addl (%rax,%rsi,4), %edx
cmpl %ecx, %edx
cmovgel %ecx, %edx
testl %edx, %edx
jg 0x1450
xorl %edx, %edx
movb %dl, (%rbx,%rsi)
incq %rsi
cmpq %rsi, %rbp
jne 0x143e
movq %rax, %rbx
callq 0x1030
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O3/aempirei[P]Chat-Art/pgmtobraile.c
// Function: braileencode
void braileencode(FILE *fpout, uint8_t *data, size_t width, size_t height) {
	for(size_t y = 0; y < height; y += 4) {
		for(size_t x = 0; x < width; x += 2) {
			wint_t wch = 0x2800;
			if(BIT0(data,x,y,width) > 0x80) wch |= 0x01;
			if(BIT1(data,x,y,width) > 0x80) wch |= 0x02;
			if(BIT2(data,x,y,width) > 0x80) wch |= 0x04;
			if(BIT3(data,x,y,width) > 0x80) wch |= 0x08;
			if(BIT4(data,x,y,width) > 0x80) wch |= 0x10;
			if(BIT5(data,x,y,width) > 0x80) wch |= 0x20;
			if(BIT6(data,x,y,width) > 0x80) wch |= 0x40;
			if(BIT7(data,x,y,width) > 0x80) wch |= 0x80;
			fputwc(wch, fpout);
		}
		fputwc(L'\n', fpout);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x18(%rsp)
testq %rcx, %rcx
je 0x15a4
movq %rsi, %r15
movq %rdi, %r12
leaq (%rdx,%rdx,2), %rax
leaq (%rsi,%rax), %r13
incq %r13
leaq (,%rdx,4), %rax
movq %rax, 0x10(%rsp)
leaq (%rsi,%rdx,2), %rbx
incq %rbx
leaq (%rsi,%rdx), %rbp
incq %rbp
incq %r15
xorl %ecx, %ecx
movq %rdx, 0x8(%rsp)
movq %rcx, 0x20(%rsp)
testq %rdx, %rdx
je 0x156d
xorl %r14d, %r14d
xorl %eax, %eax
cmpb $-0x7f, -0x1(%r15,%r14)
setae %al
xorl %ecx, %ecx
cmpb $-0x7f, -0x1(%rbp,%r14)
setae %cl
leal (%rax,%rcx,2), %eax
xorl %ecx, %ecx
cmpb $-0x7f, -0x1(%rbx,%r14)
setae %cl
leal (%rax,%rcx,4), %ecx
xorl %edx, %edx
cmpb $-0x7f, (%r15,%r14)
setae %dl
xorl %eax, %eax
cmpb $-0x7f, (%rbp,%r14)
leal (%rcx,%rdx,8), %ecx
setae %al
shll $0x4, %eax
orl %ecx, %eax
xorl %ecx, %ecx
cmpb $-0x7f, (%rbx,%r14)
setae %cl
shll $0x5, %ecx
xorl %edx, %edx
cmpb $-0x7f, -0x1(%r13,%r14)
setae %dl
shll $0x6, %edx
orl %ecx, %edx
xorl %edi, %edi
cmpb $-0x7f, (%r13,%r14)
setae %dil
shll $0x7, %edi
orl %edx, %edi
orl %eax, %edi
orl $0x2800, %edi           # imm = 0x2800
movq %r12, %rsi
callq 0x1060
addq $0x2, %r14
cmpq 0x8(%rsp), %r14
jb 0x14dc
movl $0xa, %edi
movq %r12, %rsi
callq 0x1060
movq 0x20(%rsp), %rcx
addq $0x4, %rcx
movq 0x10(%rsp), %rax
addq %rax, %r13
addq %rax, %rbx
addq %rax, %rbp
addq %rax, %r15
cmpq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rdx
jb 0x14cb
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/aempirei[P]Chat-Art/pgmtobraile.c
// Function: pgmtobraile
void pgmtobraile(FILE * fpin, FILE * fpout) {

	const size_t max_rad = 16;
	const int expected_maxval = 255;
	const char *locale = "";
	uint8_t *data;
	int width;
	int height;
	int maxval;
	int ch;
	
	if (setlocale(LC_CTYPE, locale) == NULL) {
		fprintf(stderr, "failed to set locale LC_CTYPE=\"%s\"\n", locale);
		exit(EXIT_FAILURE);
	}

	if(fscanf(fpin, "P5 %d %d %d", &width, &height, &maxval) != 3) {
		fprintf(stderr, "failed to parse pgm header\n");
		exit(EXIT_FAILURE);
	}

	ch = fgetc(fpin);
	if(ch == EOF) {
		perror("fgetc()");
		exit(EXIT_FAILURE);
	}

	if(!isspace(ch)) {
		fprintf(stderr, "unexpected character found after maxval, was expecting whitespace\n");
		exit(EXIT_FAILURE);
	}

	if(maxval != expected_maxval) {
		fprintf(stderr, "unexpected maxval of %d, was expecting %d\n", maxval, expected_maxval);
	}

	data = malloc(width * height);

	if(fread(data, width, height, fpin) != (size_t)height) {
		perror("fread()");
		exit(EXIT_FAILURE);
	}

	if(fgetc(fpin) != EOF || !feof(fpin)) {
		fprintf(stderr, "unexpected trailing data after pgm\n");
	}

	for(size_t rad = 0; rad < max_rad; rad++)
		dither(data, width, height);

	braileencode(fpout, data, width, height);

	free(data);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xa59(%rip), %rsi       # 0x2027
xorl %edi, %edi
callq 0x10c0
testq %rax, %rax
je 0x1703
leaq 0xa43(%rip), %rsi       # 0x2028
leaq 0x10(%rsp), %rdx
leaq 0xc(%rsp), %rcx
leaq 0x14(%rsp), %r8
movq %r14, %rdi
xorl %eax, %eax
callq 0x1040
cmpl $0x3, %eax
jne 0x1708
movq %r14, %rdi
callq 0x1070
cmpl $-0x1, %eax
je 0x170d
movl %eax, %ebp
callq 0x1100
movq (%rax), %rax
movslq %ebp, %rcx
testb $0x20, 0x1(%rax,%rcx,2)
je 0x1712
movl 0x14(%rsp), %edx
cmpl $0xff, %edx
jne 0x16e1
movslq 0x10(%rsp), %r12
movslq 0xc(%rsp), %r13
movq %r13, %rdi
imulq %r12, %rdi
callq 0x10b0
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %r14, %rcx
callq 0x1050
movslq 0xc(%rsp), %rcx
cmpq %rcx, %rax
jne 0x1717
movq %r14, %rdi
callq 0x1070
cmpl $-0x1, %eax
jne 0x16da
movq %r14, %rdi
callq 0x10a0
testl %eax, %eax
je 0x16da
movl $0x10, %r14d
movslq 0x10(%rsp), %rsi
movslq 0xc(%rsp), %rdx
movq %r15, %rdi
callq 0x12cc
decq %r14
jne 0x1697
movslq 0x10(%rsp), %rdx
movslq 0xc(%rsp), %rcx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1479
movq %r15, %rdi
callq 0x1030
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x115a
jmp 0x1691
movq 0x2910(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x9a9(%rip), %rsi       # 0x209b
movl $0xff, %ecx
xorl %eax, %eax
callq 0x1090
jmp 0x1640
callq 0x11b6
callq 0x1120
callq 0x11a1
callq 0x117c
callq 0x1145
// File: /workspace/github_cpp_makefile_star2_O3/ps-george[P]ansi_c_compiler/src/lexer/lexer_main.cpp
// Function: escape_chars(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string escape_chars(const std::string &before){
    std::string after;
    after.reserve(before.length() + 4);
    for (std::string::size_type i = 0; i < before.length(); ++i) {
        switch (before[i]) {
            // Replace tab character with \t
            case '\t':
              after += '\\';
              after += 't';
              break;
            // Replace newline character with \n - not sure if I need this for ANSI C
            case '\n':
              after += '\\';
              after += 'n';
              break;
            case '\r':
              after += '\\';
              after += 'r';
              break;
            case '\v':
              after += '\\';
              after += 'v';
              break;
            case '\f':
              after += '\\';
              after += 'f';
              break;
            case '\\': // If the next character is an n or t
              if (i+1 < before.length() && (before[i+1]=='n' || before[i+1]=='t' || before[i+1]=='r' || before[i+1]=='v' || before[i+1]=='f')){
                after += before[i];
                break;
              }
            case '\"':
                after += '\\';
                // Fall through.
            default:
                after += before[i];
        }
    }
    return after;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rsi), %rsi
addq $0x4, %rsi
callq 0x21c0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x27bc
xorl %r12d, %r12d
leaq 0x4927(%rip), %r13      # 0x7004
movq (%r14), %rcx
movb (%rcx,%r12), %bpl
movzbl %bpl, %edx
leal -0x9(%rdx), %esi
cmpl $0x4, %esi
ja 0x270f
movslq (%r13,%rsi,4), %rax
addq %r13, %rax
jmpq *%rax
movb $0x74, %bpl
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x20c0
jmp 0x27a0
cmpl $0x22, %edx
je 0x2744
cmpl $0x5c, %edx
jne 0x27a0
leaq 0x1(%r12), %rdx
cmpq %rax, %rdx
jae 0x2744
movb 0x1(%rcx,%r12), %al
addb $-0x66, %al
rorb %al
cmpb $0x9, %al
jae 0x2744
movb $0x5c, %bpl
movzbl %al, %eax
movl $0x1d1, %ecx            # imm = 0x1D1
btl %eax, %ecx
jb 0x27a0
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x20c0
movq (%r14), %rax
movb (%rax,%r12), %bpl
jmp 0x27a0
movb $0x72, %bpl
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x20c0
jmp 0x27a0
movb $0x76, %bpl
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x20c0
jmp 0x27a0
movb $0x66, %bpl
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x20c0
jmp 0x27a0
movb $0x6e, %bpl
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x20c0
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x20c0
incq %r12
movq 0x8(%r14), %rax
cmpq %rax, %r12
jb 0x26dd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x27d0
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x27e6
movq (%r15), %rsi
incq %rsi
callq 0x20f0
movq %r14, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/dataprov_hook/hook_direct.c
// Function: hookdemo_dataset_cmd
scdcint_t hookdemo_dataset_cmd(void *dataprov, void *dataset, const char *cmd, const char *params, scdc_dataset_input_t *input, scdc_dataset_output_t *output, scdc_result_t *result)
{
  printf(PREFIX "dataset_cmd:\n");
  printf(PREFIX "  dataprov: '%p'\n", dataprov);
  printf(PREFIX "  dataset: '%p'\n", dataset);
  printf(PREFIX "  cmd: '%s'\n", cmd);
  printf(PREFIX "  params: '%s'\n", params);

  printf(PREFIX "  "); scdc_dataset_input_print(input); printf("\n");

  printf(PREFIX "  "); scdc_dataset_output_print(output); printf("\n");

  printf(PREFIX "\n");

  return SCDC_SUCCESS;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
leaq 0x4ec49(%rip), %rdi     # 0x5b0b9
callq 0xb840
leaq 0x4eb88(%rip), %rdi     # 0x5b004
movq %rbp, %rsi
xorl %eax, %eax
callq 0xb080
leaq 0x4eb96(%rip), %rdi     # 0x5b023
movq %r13, %rsi
xorl %eax, %eax
callq 0xb080
leaq 0x4eba3(%rip), %rdi     # 0x5b041
movq %r12, %rsi
xorl %eax, %eax
callq 0xb080
leaq 0x4ebac(%rip), %rdi     # 0x5b05b
movq %r15, %rsi
xorl %eax, %eax
callq 0xb080
leaq 0x4ebb8(%rip), %r15     # 0x5b078
movq %r15, %rdi
xorl %eax, %eax
callq 0xb080
movq %r14, %rdi
callq 0x1e7ba
movl $0xa, %edi
callq 0xb740
movq %r15, %rdi
xorl %eax, %eax
callq 0xb080
movq %rbx, %rdi
callq 0x1e8e0
movl $0xa, %edi
callq 0xb740
leaq 0x4ec1b(%rip), %rdi     # 0x5b11a
callq 0xb840
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/dataprov_hook/hook_direct.c
// Function: main
int main(int argc, char *argv[])
{
  scdc_dataprov_t dp_hook = SCDC_DATAPROV_NULL;


  printf(PREFIX "start hook demo direct\n");
  printf(PREFIX "\n");

  scdc_init(SCDC_INIT_DEFAULT);

  dp_hook = scdc_dataprov_open("hookdemo", "hook", &hookdemo);

  scdc_dataset_input_t input;
  scdc_dataset_output_t output;

  scdc_dataset_input_unset(&input);
  scdc_dataset_output_unset(&output);

/*
  char format[SCDC_FORMAT_MAX_SIZE];
  scdcint_t buf_size;
  void *buf;
  scdcint_t total_size, current_size;
  char total_size_given;
  scdc_dataset_inout_next_f *next;
  void *data;
*/

  scdc_dataset_cmd(SCDC_DATASET_NULL, "scdc:/hookdemo CMD PARAM1 PARAM2 PARAM3", &input, &output);

  scdc_dataprov_close(dp_hook);

  scdc_release();

  printf(PREFIX "quit hook demo direct\n");
  printf(PREFIX "\n");

  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
leaq 0x4eba6(%rip), %rdi     # 0x5b0d3
callq 0xb840
leaq 0x4ebe1(%rip), %rbx     # 0x5b11a
movq %rbx, %rdi
callq 0xb840
leaq 0x504ba(%rip), %rdi     # 0x5ca02
xorl %eax, %eax
callq 0xcce9
leaq 0x4eb32(%rip), %rdi     # 0x5b088
leaq 0x51781(%rip), %rsi     # 0x5dcde
leaq 0x69694(%rip), %rdx     # 0x75bf8
xorl %eax, %eax
callq 0xd0a3
movq %rax, %r14
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x1ea5a
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x1ea7a
leaq 0x4eb02(%rip), %rsi     # 0x5b091
xorl %edi, %edi
movq %r15, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0xe70f
movq %r14, %rdi
callq 0xd19e
callq 0xcdea
leaq 0x4eb45(%rip), %rdi     # 0x5b0f7
callq 0xb840
movq %rbx, %rdi
callq 0xb840
xorl %eax, %eax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/dataprov_hook/hook.c
// Function: hook_config
scdcint_t hook_config(void *dataprov, const char *cmd, const char *param, const char *input, scdcint_t input_size, scdc_result_t *result)
{
  if (strncmp(cmd, "ls", 2) == 0)
  {
    printf("hook_config: listing parameters\n");

    SCDC_RESULT_SET_STR(result, "param0,param1,param2");

  } else if (strncmp(cmd, "put", 3) == 0)
  {
    printf("hook_config: setting '%s' to '%.*s'\n", param, (int) input_size, input);

  } else if (strncmp(cmd, "get", 3) == 0)
  {
    printf("hook_config: getting '%s'\n", param);

    snprintf(SCDC_RESULT_STR(result), SCDC_RESULT_SIZE(result), "%s_VAL", param);

  } else
  {
    return SCDC_FAILURE;
  }

  printf("%s: return %" scdcint_fmt ", result: '%s'\n", __func__, SCDC_SUCCESS, SCDC_RESULT_STR(result));

  return SCDC_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %rdx, %r14
movzbl (%rsi), %eax
cmpl $0x67, %eax
je 0xc69a
cmpl $0x70, %eax
je 0xc678
cmpl $0x6c, %eax
jne 0xc6f8
cmpb $0x73, 0x1(%rsi)
jne 0xc6f8
leaq 0x4ef8f(%rip), %rdi     # 0x5b5ea
callq 0xb840
leaq 0x8(%rbx), %rdi
movq (%rbx), %rdx
decq %rdx
leaq 0x4eaf6(%rip), %rsi     # 0x5b167
callq 0xb2a0
jmp 0xc6cf
cmpb $0x75, 0x1(%rsi)
jne 0xc6f8
cmpb $0x74, 0x2(%rsi)
jne 0xc6f8
leaq 0x4eaf1(%rip), %rdi     # 0x5b17c
movq %r14, %rsi
movl %r8d, %edx
xorl %eax, %eax
callq 0xb080
jmp 0xc6cf
cmpb $0x65, 0x1(%rsi)
jne 0xc6f8
cmpb $0x74, 0x2(%rsi)
jne 0xc6f8
leaq 0x4eaf4(%rip), %rdi     # 0x5b1a1
movq %r14, %rsi
xorl %eax, %eax
callq 0xb080
leaq 0x8(%rbx), %rdi
movq (%rbx), %rsi
leaq 0x4eaf7(%rip), %rdx     # 0x5b1bc
movq %r14, %rcx
xorl %eax, %eax
callq 0xb8c0
addq $0x8, %rbx
leaq 0x4eae9(%rip), %rdi     # 0x5b1c3
leaq 0x4f0de(%rip), %rsi     # 0x5b7bf
movl $0x1, %r14d
movl $0x1, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xb080
jmp 0xc6fb
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/dataprov_hook/hook.c
// Function: hook_dataset_open
void *hook_dataset_open(void *dataprov, const char *path, scdc_result_t *result)
{
  hook_dataset_t *dataset_hook;
  
  union { void *dataprov; hook_dataset_t dataset_hook; } z;


  printf("hook_dataset_open: dataprov: '%p', path: '%s'\n", dataprov, path);

  dataset_hook = (hook_dataset_t *) malloc(sizeof(hook_dataset_t));

  z.dataprov = dataprov;

  *dataset_hook = ((char *) z.dataset_hook) + 1;

  SCDC_RESULT_SET_STR(result, "result of hook_dataset_open");

  printf("hook_dataset_open: return '%p' (%p), result: '%s'\n", dataset_hook, *dataset_hook, SCDC_RESULT_STR(result));

  return dataset_hook;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0x4eac7(%rip), %rdi     # 0x5b1e2
movq %r14, %rsi
xorl %eax, %eax
callq 0xb080
movl $0x8, %edi
callq 0xb6d0
movq %rax, %r15
incq %r14
movq %r14, (%rax)
movq (%rbx), %rdx
addq $0x8, %rbx
decq %rdx
leaq 0x4eac8(%rip), %rsi     # 0x5b211
movq %rbx, %rdi
callq 0xb2a0
leaq 0x4ead5(%rip), %rdi     # 0x5b22d
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0xb080
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/dataprov_hook/hook.c
// Function: hook_dataset_close
scdcint_t hook_dataset_close(void *dataprov, void *dataset, scdc_result_t *result)
{
  hook_dataset_t *dataset_hook = (hook_dataset_t *) dataset;


  printf("hook_dataset_close: dataprov: '%p', dataset: '%p' (%p)\n", dataprov, dataset_hook, *dataset_hook);

  free(dataset_hook);

  SCDC_RESULT_SET_STR(result, "result of hook_dataset_close");

  printf("hook_dataset_close: return '%" scdcint_fmt "', result: '%s'\n", SCDC_SUCCESS, SCDC_RESULT_STR(result));
  
  return SCDC_SUCCESS;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
movq (%r14), %rcx
leaq 0x4ead8(%rip), %rdi     # 0x5b260
movq %r14, %rdx
xorl %eax, %eax
callq 0xb080
movq %r14, %rdi
callq 0xb640
movq (%rbx), %rdx
addq $0x8, %rbx
decq %rdx
leaq 0x4eaed(%rip), %rsi     # 0x5b298
movq %rbx, %rdi
callq 0xb2a0
leaq 0x4eafb(%rip), %rdi     # 0x5b2b5
movl $0x1, %esi
movq %rbx, %rdx
xorl %eax, %eax
callq 0xb080
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/dataprov_hook/hook.c
// Function: hook_dataset_open_read_state
void *hook_dataset_open_read_state(void *dataprov, const void *state, scdcint_t state_size, scdc_result_t *result)
{
  hook_dataset_t *dataset_hook;


  printf("hook_dataset_open_read_state: dataprov: '%p', state: '%.*s'\n", dataprov, (int) state_size, (const char *) state);

  dataset_hook = (hook_dataset_t *) malloc(sizeof(hook_dataset_t));

  z_snscanf(state, state_size, "%p", dataset_hook);

  SCDC_RESULT_SET_STR(result, "result of hook_dataset_open_read_state");

  printf("hook_dataset_open_read_state: return: '%p' (%p), result: '%s'\n", dataset_hook, *dataset_hook, SCDC_RESULT_STR(result));

  return dataset_hook;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rsi
leaq 0x4eaf5(%rip), %rdi     # 0x5b2e6
movq %r12, %rcx
xorl %eax, %eax
callq 0xb080
movl $0x8, %edi
callq 0xb6d0
movq %rax, %r14
leaq 0x4ff36(%rip), %rdx     # 0x5c745
movq %r12, %rdi
movq %r15, %rsi
movq %rax, %rcx
xorl %eax, %eax
callq 0x287a0
movq (%rbx), %rdx
addq $0x8, %rbx
decq %rdx
leaq 0x4eaf3(%rip), %rsi     # 0x5b323
movq %rbx, %rdi
callq 0xb2a0
movq (%r14), %rdx
leaq 0x4eb08(%rip), %rdi     # 0x5b34a
movq %r14, %rsi
movq %rbx, %rcx
xorl %eax, %eax
callq 0xb080
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/dataprov_hook/hook.c
// Function: hook_dataset_close_write_state
scdcint_t hook_dataset_close_write_state(void *dataprov, void *dataset, void *state, scdcint_t state_size, scdc_result_t *result)
{
  scdcint_t n;
  hook_dataset_t *dataset_hook = (hook_dataset_t *) dataset;


  printf("hook_dataset_close_write_state: dataset: '%p' (%p)\n", dataset_hook, *dataset_hook);

  n = snprintf(state, state_size, "%p", *dataset_hook);

  free(dataset_hook);

  SCDC_RESULT_SET_STR(result, "result of hook_dataset_close_write_state");

  printf("hook_dataset_close_write_state: return: '%" scdcint_fmt "', result: '%s', state: '%.*s'\n", n, SCDC_RESULT_STR(result), (int) state_size, (const char *) state);

  return n;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r15
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r12
movq (%rsi), %rdx
leaq 0x4eb0c(%rip), %rdi     # 0x5b389
xorl %eax, %eax
callq 0xb080
movq (%r12), %rcx
leaq 0x4feb6(%rip), %rdx     # 0x5c745
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0xb8c0
movslq %eax, %r13
movq %r12, %rdi
callq 0xb640
movq (%r15), %rdx
addq $0x8, %r15
decq %rdx
leaq 0x4eb05(%rip), %rsi     # 0x5b3bd
movq %r15, %rdi
callq 0xb2a0
leaq 0x4eb1f(%rip), %rdi     # 0x5b3e6
movq %r13, %rsi
movq %r15, %rdx
movl %r14d, %ecx
movq %rbx, %r8
xorl %eax, %eax
callq 0xb080
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/dataprov_hook/hook.c
// Function: hook_dataset_get_next
scdcint_t hook_dataset_get_next(scdc_dataset_output_t *output, scdc_result_t *result)
{
  ptrdiff_t x;


  printf("hook_dataset_get_next: output: '%p'\n", output);
  print_dataset_output("hook_dataset_get_next: ", output);

  x = (ptrdiff_t) output->data;

  SCDC_DATASET_INOUT_BUF_CURRENT(output) = z_min(SCDC_DATASET_INOUT_BUF_SIZE(output), DEFAULT_GET_SIZE);

#if 0
  memset(SCDC_DATASET_INOUT_BUF_PTR(output), 'x', SCDC_DATASET_INOUT_BUF_CURRENT(output) - 1);
  ((char *) SCDC_DATASET_INOUT_BUF_PTR(output))[SCDC_DATASET_INOUT_BUF_CURRENT(output) - 1] = '\0';
#else
  memset(SCDC_DATASET_INOUT_BUF_PTR(output), 'x', SCDC_DATASET_INOUT_BUF_CURRENT(output));
#endif

  --x;

  output->next = (x > 0)?hook_dataset_get_next:NULL;
  output->data = (void *) x;

  return SCDC_SUCCESS;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4eaf2(%rip), %rdi     # 0x5b448
xorl %r14d, %r14d
movq %rbx, %rsi
xorl %eax, %eax
callq 0xb080
leaq 0x4eb03(%rip), %rdi     # 0x5b46d
movq %rbx, %rsi
callq 0xc917
movq 0x40(%rbx), %r15
movq 0x10(%rbx), %rdi
movq 0x18(%rbx), %rax
cmpq $0xd, %rax
movl $0xd, %edx
cmovlq %rax, %rdx
movq %rdx, 0x20(%rbx)
movl $0x78, %esi
callq 0xb2d0
cmpq $0x2, %r15
leaq -0x5d(%rip), %rax       # 0xc947
cmovgeq %rax, %r14
leaq -0x1(%r15), %rax
movq %r14, 0x38(%rbx)
movq %rax, 0x40(%rbx)
movl $0x1, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/mh0fm4[P]SCDC/test/units/dataprov_hook/hook.c
// Function: consume_input
static void consume_input(const char *prefix, scdc_dataset_input_t *input)
{
  while (input)
  {
    printf("%sinput content: '%.*s'\n", prefix, (int) SCDC_DATASET_INOUT_BUF_CURRENT(input), (char *) SCDC_DATASET_INOUT_BUF_PTR(input));
    if (!input->next) break;
    printf("%snext input\n", prefix);
    input->next(input, 0);
    print_dataset_input(prefix, input);
  }
}

// Assembly:
testq %rdi, %rdi
je 0xcccd
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl 0x20(%rdi), %edx
movq 0x10(%rdi), %rcx
leaq 0x4e975(%rip), %rdi     # 0x5b5c3
leaq 0x4e899(%rip), %rsi     # 0x5b4ee
xorl %eax, %eax
callq 0xb080
cmpq $0x0, 0x38(%rbx)
je 0xccc4
leaq 0x4e972(%rip), %r14     # 0x5b5dc
leaq 0x4e87d(%rip), %r15     # 0x5b4ee
leaq 0x4e7bb(%rip), %r12     # 0x5b433
leaq 0x4e944(%rip), %r13     # 0x5b5c3
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xb080
movq %rbx, %rdi
xorl %esi, %esi
callq *0x38(%rbx)
movq %r12, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xb080
movq %rbx, %rdi
callq 0x1e7ba
movl 0x20(%rbx), %edx
movq 0x10(%rbx), %rcx
movq %r13, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xb080
cmpq $0x0, 0x38(%rbx)
jne 0xcc7f
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/base64dec.cpp
// Function: base64_dec(cstring)
array<uint8_t> base64_dec(cstring text)
{
	array<uint8_t> ret;
	ret.resize(base64_dec_len(text.length()));
	size_t actual = base64_dec_raw(ret, text);
	if (!actual) return NULL;
	ret.resize(actual);
	return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rdx, %rax
shrq $0x38, %rax
xorps %xmm0, %xmm0
movq %rsp, %r12
movaps %xmm0, (%r12)
xorl $0xf, %eax
testq %rdx, %rdx
cmovsq %rdx, %rax
movl %eax, %eax
addq $0x3, %rax
shrq $0x2, %rax
leaq (%rax,%rax,2), %rsi
movq %r12, %rdi
callq 0xdea4
movaps (%r12), %xmm0
leaq 0x18(%rsp), %rdi
movups %xmm0, (%rdi)
movq %r15, %rsi
movq %r14, %rdx
callq 0x3740
testq %rax, %rax
je 0x39b3
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0xdea4
movaps (%r14), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%r14)
movups %xmm0, (%rbx)
xorl %edi, %edi
jmp 0x39bd
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq (%rsp), %rdi
callq 0x3430
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/memmem.cpp
// Function: memmem_arlib(void const*, unsigned long, void const*, unsigned long)
void* memmem_arlib(const void * haystack, size_t haystacklen, const void * needle, size_t needlelen)
{
	if (UNLIKELY(needlelen == 0)) return (void*)haystack;
	
	const void * hay_orig = haystack;
	haystack = memchr(haystack, *(uint8_t*)needle, haystacklen);
	if (!haystack) return NULL;
	if (needlelen == 1) return (void*)haystack;
	
	haystacklen -= (uint8_t*)haystack - (uint8_t*)hay_orig;
	if (UNLIKELY(needlelen > haystacklen)) return NULL;
	
#ifdef runtime__SSE4_2__
	// don't use this for needle length 16, both do one byte per iteration and _mm_cmpestri is slow
	if (needlelen <= 15 && runtime__SSE4_2__) return (void*)memmem_sse42((uint8_t*)haystack, haystacklen, (uint8_t*)needle, needlelen);
#endif
	
#if !defined(_WIN32) && !defined(ARLIB_TEST) // for long needles, use libc; we're roughly equally fast, and code reuse means smaller
	return memmem(haystack, haystacklen, needle, needlelen);
#endif
	
	return (void*)memmem_rollhash((uint8_t*)haystack, haystacklen, (uint8_t*)needle, needlelen);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rcx, %rcx
je 0x3eb0
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movzbl (%rdx), %esi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x33b0
testq %rax, %rax
je 0x3eae
cmpq $0x1, %r14
jne 0x3e74
movq %rax, %rbx
jmp 0x3eb0
subq %rax, %rbx
addq %r12, %rbx
cmpq %r14, %rbx
jb 0x3eae
cmpq $0xf, %r14
ja 0x3e92
leaq 0x42448(%rip), %rcx     # 0x462d4
testb $0x10, 0x2(%rcx)
jne 0x3ebf
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x3620
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1588c
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/stringconv.cpp
// Function: bool fromstring_int_inner<unsigned long>(char const*, char const*, unsigned long&)
bool fromstring_int_inner(const char * in, const char * end, Tu& out)
{
	out = 0;
	if (UNLIKELY(in == end)) return false;
	Tu t_max = (Tu)-1;
	while (in != end)
	{
		if (LIKELY(*in >= '0' && *in <= '9'))
		{
			if (UNLIKELY(out >= t_max/10))
			{
				if (out > t_max/10) return false;
				if (*in > (char)(t_max%10+'0')) return false;
			}
			out = out*10 + *in-'0';
		}
		else return false;
		in++;
	}
	return true;
}

// Assembly:
andq $0x0, (%rdx)
cmpq %rsi, %rdi
je 0x49b9
movabsq $0x1999999999999998, %rcx # imm = 0x1999999999999998
xorl %r8d, %r8d
leaq 0x1(%rcx), %r9
movzbl (%rdi), %r10d
leal -0x30(%r10), %eax
cmpb $0x9, %al
ja 0x49b9
cmpq %rcx, %r8
ja 0x49a7
imulq $0xa, %r8, %rax
leaq (%r10,%rax), %r8
addq $-0x30, %r8
movq %r8, (%rdx)
incq %rdi
cmpq %rsi, %rdi
jne 0x497d
jmp 0x49b6
xorl %eax, %eax
cmpb $0x35, %r10b
ja 0x49b8
cmpq %r9, %r8
je 0x498e
jmp 0x49b8
movb $0x1, %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/stringconv.cpp
// Function: bool fromstring_int_real<unsigned long, long>(cstring, long&)
bool fromstring_int_real(cstring s, Ts& out)
{
	out = 0;
	const char * start = (char*)s.bytes().ptr();
	const char * end = start + s.length();
	
	if (UNLIKELY(start == end)) return false;
	bool neg = (*start == '-');
	start += neg;
	Tu tmp;
	
	if (UNLIKELY(!fromstring_int_inner<Tu>(start, end, tmp))) return false;
	
	if (neg)
	{
		out = (Ts)-tmp;
		return (out <= 0);
	}
	else
	{
		out = (Ts)tmp;
		return (out >= 0);
	}
}

// Assembly:
pushq %rbx
movq %rdi, -0x10(%rsp)
movq %rsi, -0x8(%rsp)
andq $0x0, (%rdx)
movq %rsi, %rax
shrq $0x38, %rax
xorl $0xf, %eax
testq %rsi, %rsi
cmovsl %esi, %eax
testl %eax, %eax
je 0x4a69
testq %rsi, %rsi
leaq -0x10(%rsp), %rcx
cmovnsq %rcx, %rdi
movl %eax, %ecx
movb (%rdi), %sil
xorl %r8d, %r8d
cmpb $0x2d, %sil
sete %r8b
cmpq %rcx, %r8
je 0x4a69
movabsq $0x1999999999999998, %r10 # imm = 0x1999999999999998
xorl %r9d, %r9d
leaq 0x1(%r10), %r11
movzbl (%rdi,%r8), %ebx
leal -0x30(%rbx), %eax
cmpb $0x9, %al
ja 0x4a69
cmpq %r10, %r9
ja 0x4a3c
imulq $0xa, %r9, %rax
leaq (%rax,%rbx), %r9
addq $-0x30, %r9
incq %r8
cmpq %r8, %rcx
jne 0x4a15
jmp 0x4a4a
xorl %eax, %eax
cmpq %r11, %r9
jne 0x4a67
cmpb $0x35, %bl
jbe 0x4a26
jmp 0x4a67
cmpb $0x2d, %sil
jne 0x4a5e
negq %r9
movq %r9, (%rdx)
testq %r9, %r9
setle %al
jmp 0x4a67
movq %r9, (%rdx)
testq %r9, %r9
setns %al
popq %rbx
retq
xorl %eax, %eax
jmp 0x4a67
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/stringconv.cpp
// Function: bool fromstring_hex_real<unsigned long>(char const*, unsigned long, unsigned long&)
bool fromstring_hex_real(const char * s, size_t len, Tu& out)
{
	const char * start = s;
	const char * end = s + len;
	
	out = 0;
	if (UNLIKELY(start == end)) return false;
	while (start < end && *start == '0') start++;
	if (UNLIKELY(end-start > (ptrdiff_t)sizeof(Tu)*2)) return false;
	
	while (start != end)
	{
		out <<= 4;
		char upper = *start & ~0x20;
		if (*start >= '0' && *start <= '9') out += *start-'0';
		else if (upper >= 'A' && upper <= 'F') out += upper-'A'+10;
		else return false;
		start++;
	}
	return true;
}

// Assembly:
leaq (%rdi,%rsi), %rcx
andq $0x0, (%rdx)
testq %rsi, %rsi
je 0x4ae7
jle 0x4a89
cmpb $0x30, (%rdi)
jne 0x4a89
incq %rdi
cmpq %rcx, %rdi
jb 0x4a7c
movq %rcx, %rax
subq %rdi, %rax
cmpq $0x10, %rax
jg 0x4ae7
movb $0x1, %al
cmpq %rcx, %rdi
je 0x4ae6
xorl %esi, %esi
shlq $0x4, %rsi
movq %rsi, (%rdx)
movb (%rdi), %r8b
leal -0x30(%r8), %r9d
cmpb $0x9, %r9b
ja 0x4abb
movzbl %r9b, %r8d
orq %r8, %rsi
jmp 0x4adb
movl %r8d, %r9d
andb $-0x21, %r9b
addb $-0x41, %r9b
cmpb $0x5, %r9b
ja 0x4ae7
addb $0x9, %r8b
andb $0x1f, %r8b
movzbl %r8b, %r8d
addq %r8, %rsi
movq %rsi, (%rdx)
incq %rdi
cmpq %rcx, %rdi
jne 0x4a9e
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/argparse.cpp
// Function: argparse::single_arg(cstring, char const*, argparse::arglevel_t, bool*)
void argparse::single_arg(cstring name, const char * value, arglevel_t arglevel, bool* used_value)
{
	for (arg_base& arg : m_args)
	{
		if (arg.name == name)
		{
			single_arg(arg, value, arglevel, used_value);
			return;
		}
	}
	if (name != "") error("unknown argument: --"+name);
	else error("positional arguments not supported");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r9, 0x20(%rsp)
movl %r8d, 0x4(%rsp)
movq %rcx, 0x18(%rsp)
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rdi), %r14
testq %r14, %r14
je 0x54c7
movq 0x10(%rbx), %rbp
shlq $0x3, %r14
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
movq (%rbp,%r15), %r13
leaq 0x8(%r13), %rdi
movq %r12, %rsi
callq 0x1a52b
testb %al, %al
jne 0x543d
addq $0x8, %r15
cmpq %r15, %r14
jne 0x53e3
movb 0x17(%rsp), %dl
cmpb $0xf, %dl
jne 0x5465
leaq 0x28(%rsp), %r14
movb $0xf, 0xf(%r14)
movb $0x0, (%r14)
leaq 0x29c8c(%rip), %rsi     # 0x2f0ab
movl $0x22, %edx
movq %r14, %rdi
movl $0x1, %ecx
callq 0x5990
movq (%r14), %rsi
movq 0x8(%r14), %rdx
jmp 0x54bf
movq %rbx, %rdi
movq %r13, %rsi
movq 0x18(%rsp), %rdx
movl 0x4(%rsp), %ecx
movq 0x20(%rsp), %r8
callq 0x5110
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %r14
movq 0x10(%rsp), %r12
leaq 0x29c20(%rip), %rsi     # 0x2f096
leaq 0x38(%rsp), %r15
movl $0x14, %edx
movq %r15, %rdi
callq 0x19536
leaq 0x48(%rsp), %rax
movq %r14, (%rax)
movq %r12, 0x8(%rax)
movq %r12, %rcx
shrq $0x38, %rcx
xorq $0xf, %rcx
testq %r12, %r12
movl %r12d, %edx
cmovnsq %rcx, %rdx
cmovnsq %rax, %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x1967e
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x50b6
shrq $0x38, %rdx
jmp 0x5405
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/argparse.cpp
// Function: argparse::single_arg(char, char const*, argparse::arglevel_t, bool*)
void argparse::single_arg(char sname, const char * value, arglevel_t arglevel, bool* used_value)
{
	for (arg_base& arg : m_args)
	{
		if (arg.sname == sname)
		{
			single_arg(arg, value, arglevel, used_value);
			return;
		}
	}
	string e = "unknown argument: -";
	e += sname; // no operator+(string, char), too high risk it's hit by an accidental operator+(string, int)
	error(e);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x5506
movq 0x10(%rbx), %rdi
shlq $0x3, %rax
xorl %r9d, %r9d
movq (%rdi,%r9), %rsi
cmpb %bpl, 0x18(%rsi)
je 0x5560
addq $0x8, %r9
cmpq %r9, %rax
jne 0x54f3
leaq 0x29bc1(%rip), %rsi     # 0x2f0ce
leaq 0x8(%rsp), %r14
movl $0x13, %edx
movq %r14, %rdi
callq 0x19536
movzbl 0xf(%r14), %eax
movl %eax, %r15d
xorl $0xf, %r15d
testb %al, %al
cmovsl 0x8(%r14), %r15d
leal 0x1(%r15), %esi
movq %r14, %rdi
callq 0x193c4
cmpb $0x0, 0xf(%r14)
jns 0x554a
movq 0x8(%rsp), %r14
movb %bpl, (%r14,%r15)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b6
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5110
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/argparse.cpp
// Function: argparse::parse_pre(char const* const*)
void argparse::parse_pre(const char * const * argv)
{
#ifndef ARLIB_OPT
	if (m_appname)
	{
		error("internal error: argparse::parse called twice");
	}
#endif
	m_appname = argv[0];
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movzbl 0xf(%rdi), %eax
testb %al, %al
jns 0x5589
movl 0x8(%rbx), %eax
jmp 0x558c
xorl $0xf, %eax
testl %eax, %eax
jne 0x55be
movq (%rsi), %rax
testq %rax, %rax
leaq 0x2cecf(%rip), %r14     # 0x3246c
cmovneq %rax, %r14
movq %r14, %rdi
callq 0x30f0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
jmp 0x195fc
leaq 0x8(%rsp), %r14
movb $0xf, 0xf(%r14)
movb $0x0, (%r14)
leaq 0x29b0f(%rip), %rsi     # 0x2f0e2
movl $0x2c, %edx
movq %r14, %rdi
movl $0x1, %ecx
callq 0x5990
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x50b6
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/string.h
// Function: cstring::init_from_nocopy(unsigned char const*, unsigned long, bool)
void init_from_nocopy(const uint8_t * str, size_t len, bool has_nul = false)
	{
		if (len <= MAX_INLINE)
		{
			for (uint32_t i=0;i<len;i++) m_inline[i] = str[i]; // memcpy's constant overhead is huge if len is unknown
			m_inline[len] = '\0';
			m_inline_len_w() = MAX_INLINE-len;
		}
		else
		{
			if (len > 0xFFFFFFFF) abort();
			m_inline_len_w() = -1;
			
			m_data = (uint8_t*)str;
			m_len = len;
			m_nul = has_nul;
		}
	}

// Assembly:
cmpq $0xf, %rdx
ja 0x59b7
testq %rdx, %rdx
je 0x59ab
xorl %eax, %eax
movb (%rsi,%rax), %cl
movb %cl, (%rdi,%rax)
incq %rax
cmpq %rax, %rdx
jne 0x599d
movb $0x0, (%rdi,%rdx)
movb $0xf, %al
subb %dl, %al
movb %al, 0xf(%rdi)
retq
movq %rdx, %rax
shrq $0x20, %rax
jne 0x59ce
movb $-0x1, 0xf(%rdi)
movq %rsi, (%rdi)
movl %edx, 0x8(%rdi)
movb %cl, 0xc(%rdi)
retq
pushq %rax
callq 0x3180
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/array.cpp
// Function: bitarray::set_slice(unsigned long, unsigned long, bitarray const&, unsigned long)
void bitarray::set_slice(size_t start, size_t num, const bitarray& other, size_t other_start)
{
	if (&other == this)
	{
		//TODO: optimize
		bitarray copy = other;
		set_slice(start, num, copy, other_start);
		return;
	}
	//TODO: optimize
	for (size_t i=0;i<num;i++)
	{
		set(start+i, other.get(other_start+i));
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %r8, %rbx
movq %rcx, %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq %rdi, %rcx
je 0x5a6b
testq %r14, %r14
je 0x5a9d
cmpq $0x41, 0x8(%rax)
movq %rax, %rcx
jb 0x5a0b
movq (%rax), %rcx
cmpq $0x41, 0x8(%r12)
movq %r12, %rdx
jb 0x5a1a
movq (%r12), %rdx
movq %rbx, %rsi
shrq $0x3, %rsi
movzbl (%rcx,%rsi), %esi
movq %r15, %rdi
shrq $0x3, %rdi
movl %r15d, %ecx
andb $0x7, %cl
movl $0x1, %r8d
shll %cl, %r8d
notb %r8b
andb (%rdx,%rdi), %r8b
movl %ebx, %r9d
andl $0x7, %r9d
xorl %r10d, %r10d
btl %r9d, %esi
setb %r10b
shll %cl, %r10d
orb %r8b, %r10b
movb %r10b, (%rdx,%rdi)
incq %rbx
incq %r15
decq %r14
jne 0x59fe
jmp 0x5a9d
movq %rsp, %r13
movq %r13, %rdi
movq %rax, %rsi
callq 0x5d16
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq %rbx, %r8
callq 0x59d4
cmpq $0x41, 0x8(%r13)
jb 0x5a9d
movq (%rsp), %rdi
callq 0x3430
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/array.cpp
// Function: bitarray::clear_unused(unsigned long, unsigned long)
void bitarray::clear_unused(size_t start, size_t nbytes)
{
	size_t low = start;
	size_t high = nbytes*8;
	
	if (low == high) return; // don't wipe bits()[8] if they're both 64
	
	uint8_t* ptr = bits();
	uint8_t& byte = ptr[low/8];
	byte &=~ (0xFF<<(low&7));
	low = (low+7)&~7;
	
	memset(ptr+low/8, 0, (high-low)/8);
}

// Assembly:
shlq $0x3, %rdx
cmpq %rsi, %rdx
jne 0x5ab6
retq
cmpq $0x41, 0x8(%rdi)
jb 0x5ac0
movq (%rdi), %rdi
movq %rsi, %rax
shrq $0x3, %rax
movl %esi, %ecx
andb $0x7, %cl
movb $-0x1, %r8b
shlb %cl, %r8b
notb %r8b
andb %r8b, (%rdi,%rax)
addq $0x7, %rsi
movq %rsi, %rax
andq $-0x8, %rax
shrq $0x3, %rsi
addq %rdi, %rsi
subq %rax, %rdx
shrq $0x3, %rdx
movq %rsi, %rdi
xorl %esi, %esi
jmp 0x3170
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/array.cpp
// Function: bitarray::slice(unsigned long, unsigned long) const
bitarray bitarray::slice(size_t first, size_t count) const
{
	if ((first&7) == 0)
	{
		bitarray ret;
		ret.resize(count);
		memcpy(ret.bits(), this->bits() + first/8, (count+7)/8);
		return ret;
	}
	else
	{
		//TODO: optimize
		bitarray ret;
		ret.resize(count);
		for (size_t i=0;i<count;i++) ret.set(i, this->get(first+i));
		return ret;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rcx, %rsi
callq 0x5afc
testb $0x7, %r15b
je 0x5cd1
testq %r14, %r14
je 0x5d06
xorl %eax, %eax
cmpq $0x41, 0x8(%r12)
movq %r12, %rcx
jb 0x5c78
movq (%r12), %rcx
cmpq $0x41, 0x8(%rbx)
movq %rbx, %rdx
jb 0x5c85
movq (%rbx), %rdx
leaq (%r15,%rax), %rsi
movq %rsi, %rdi
shrq $0x3, %rdi
movzbl (%rcx,%rdi), %edi
movq %rax, %r8
movl %eax, %ecx
andb $0x7, %cl
movl $0x1, %r9d
shll %cl, %r9d
shrq $0x3, %r8
notb %r9b
andb (%rdx,%r8), %r9b
andl $0x7, %esi
xorl %r10d, %r10d
btl %esi, %edi
setb %r10b
shll %cl, %r10d
orb %r9b, %r10b
movb %r10b, (%rdx,%r8)
incq %rax
cmpq %rax, %r14
jne 0x5c69
jmp 0x5d06
cmpq $0x41, 0x8(%rbx)
jb 0x5cdd
movq (%rbx), %rdi
jmp 0x5ce0
movq %rbx, %rdi
cmpq $0x41, 0x8(%r12)
jb 0x5cec
movq (%r12), %r12
shrq $0x3, %r15
addq %r12, %r15
addq $0x7, %r14
shrq $0x3, %r14
movq %r15, %rsi
movq %r14, %rdx
callq 0x3280
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/array.h
// Function: bitarray::construct(bitarray const&)
void construct(const bitarray& other)
	{
		nbits = other.nbits;
		if (nbits > n_inline)
		{
			size_t nbytes = alloc_size(nbits);
			bits_outline = xmalloc(nbytes);
			memcpy(bits_outline, other.bits_outline, nbytes);
		}
		else
		{
			memcpy(bits_inline, other.bits_inline, sizeof(bits_inline));
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
cmpq $0x41, %rax
jb 0x5d75
addq $0x7, %rax
movq %rax, %rcx
shrq $0x3, %rcx
decq %rcx
bsrq %rcx, %rcx
movl $0x2, %edx
shlq %cl, %rdx
cmpq $0x10, %rax
movl $0x1, %r15d
cmovaeq %rdx, %r15
movq %r15, %rdi
callq 0x1597c
movq %rax, (%r14)
movq (%rbx), %rsi
movq %rax, %rdi
movq %r15, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3280
movq (%rbx), %rax
movq %rax, (%r14)
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/base64enc.cpp
// Function: base64_enc_raw(arrayvieww<unsigned char>, arrayview<unsigned char>)
void base64_enc_raw(arrayvieww<uint8_t> out, arrayview<uint8_t> bytes)
{
	if (!bytes.size()) return;
	
	uint8_t* outp = out.ptr();
	const uint8_t* inp = bytes.ptr();
	const uint8_t* inpe = inp + bytes.size();
	
	while (inp+4 <= inpe)
	{
		uint32_t three = readu_be32(inp) >> 8;
		outp[0] = encode[(three>>18)   ];
		outp[1] = encode[(three>>12)&63];
		outp[2] = encode[(three>>6 )&63];
		outp[3] = encode[(three>>0 )&63];
		inp += 3;
		outp += 4;
	}
	
	uint32_t three = inp[0]<<16;
	if (inp+1 < inpe) three |= inp[1]<<8;
	if (inp+2 < inpe) three |= inp[2]<<0;
	
	outp[0] = encode[(three>>18)   ];
	outp[1] = encode[(three>>12)&63];
	outp[2] = encode[(three>>6 )&63];
	outp[3] = encode[(three>>0 )&63];
	
	if (inp+1 >= inpe) outp[2] = '='; // don't move the outp[2,3] above into elses, it optimizes better this way
	if (inp+2 >= inpe) outp[3] = '=';
}

// Assembly:
testq %rdx, %rdx
je 0x5e80
movq (%rdi), %rax
leaq (%rsi,%rdx), %rcx
cmpq $0x4, %rdx
jl 0x5dfb
leaq 0x2945f(%rip), %rdx     # 0x2f200
movq %rsi, %rdi
movl (%rsi), %esi
bswapl %esi
movl %esi, %r8d
shrl $0x8, %r8d
movl %esi, %r9d
shrl $0x1a, %r9d
movb (%r9,%rdx), %r9b
movb %r9b, (%rax)
movl %esi, %r9d
shrl $0x14, %r9d
andl $0x3f, %r9d
movb (%r9,%rdx), %r9b
movb %r9b, 0x1(%rax)
shrl $0xe, %esi
andl $0x3f, %esi
movb (%rsi,%rdx), %sil
movb %sil, 0x2(%rax)
andl $0x3f, %r8d
movb (%r8,%rdx), %sil
movb %sil, 0x3(%rax)
leaq 0x3(%rdi), %rsi
addq $0x4, %rax
addq $0x7, %rdi
cmpq %rcx, %rdi
jbe 0x5da1
movzbl (%rsi), %edi
shll $0x10, %edi
leaq 0x1(%rsi), %rdx
cmpq %rcx, %rdx
jae 0x5e18
movzbl (%rdx), %r8d
shll $0x8, %r8d
orl %edi, %r8d
movl %r8d, %edi
addq $0x2, %rsi
cmpq %rcx, %rsi
jae 0x5e28
movzbl (%rsi), %r8d
orl %r8d, %edi
movl %edi, %r8d
shrl $0x12, %r8d
movl %edi, %r9d
shrl $0xc, %r9d
andl $0x3f, %r9d
leaq 0x293bf(%rip), %r10     # 0x2f200
movb (%r8,%r10), %r8b
movb %r8b, (%rax)
movl %edi, %r8d
shrl $0x6, %r8d
andl $0x3f, %r8d
andl $0x3f, %edi
movb (%r9,%r10), %r9b
movb %r9b, 0x1(%rax)
movb (%r8,%r10), %r8b
movb %r8b, 0x2(%rax)
movb (%rdi,%r10), %dil
movb %dil, 0x3(%rax)
cmpq %rcx, %rdx
jb 0x5e77
movb $0x3d, 0x2(%rax)
cmpq %rcx, %rsi
jb 0x5e80
movb $0x3d, 0x3(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O3/Alcaro[P]bridges/arlib/bmlparse.cpp
// Function: bml_size_white(cstring const&)
static size_t bml_size_white(const cstring& data)
{
	size_t i = 0;
	while (i < data.length() && (data[i]==' ' || data[i]=='\t')) i++;
	if (i < data.length() && data[i]=='#') return data.length();
	if (i+1 < data.length() && data[i]=='/' && data[i+1]=='/') return data.length();
	else return i;
}

// Assembly:
movzbl 0xf(%rdi), %ecx
movl %ecx, %eax
xorl $0xf, %eax
testb %cl, %cl
cmovsl 0x8(%rdi), %eax
testl %eax, %eax
je 0x68c2
movq %rdi, %rsi
testb %cl, %cl
jns 0x688b
movq (%rdi), %rsi
xorl %r8d, %r8d
movabsq $0x100000000, %r9       # imm = 0x100000000
xorl %edx, %edx
movq %r8, %r10
sarq $0x20, %r10
movzbl (%rsi,%r10), %r10d
cmpl $0x20, %r10d
je 0x68b2
cmpl $0x9, %r10d
jne 0x68c4
incq %rdx
addq %r9, %r8
cmpq %rdx, %rax
jne 0x689a
movq %rax, %rdx
jmp 0x68dd
xorl %edx, %edx
cmpq %rax, %rdx
jae 0x68dd
movq %rdi, %rsi
testb %cl, %cl
jns 0x68d3
movq (%rdi), %rsi
movslq %edx, %r8
cmpb $0x23, (%rsi,%r8)
je 0x6901
leaq 0x1(%rdx), %rsi
cmpq %rax, %rsi
jae 0x6902
testb %cl, %cl
jns 0x68ed
movq (%rdi), %rdi
movslq %edx, %rcx
cmpb $0x2f, (%rdi,%rcx)
jne 0x6902
movslq %esi, %rcx
cmpb $0x2f, (%rdi,%rcx)
cmovneq %rdx, %rax
retq
movq %rdx, %rax
retq