LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/twine80n6t4clocv2/ref/twine.c
// Function: pstate3
void pstate3(const unsigned char* st, int len)
{
	int i;
	for(i = 0; i < len; i++){
		printf("%01x", st[i]&0xf);
		if(((i%16) == (16-1)) && (i+1 !=len)) printf("\n");
	}
	printf("\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x1db9
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %esi
andl $0xf, %esi
leaq 0x22ec(%rip), %rdi      # 0x4063
movb $0x0, %al
callq 0x1030
movl 0x8(%rsp), %eax
movl $0x10, %ecx
cltd
idivl %ecx
cmpl $0xf, %edx
jne 0x1daa
movl 0x8(%rsp), %eax
addl $0x1, %eax
cmpl 0xc(%rsp), %eax
je 0x1daa
leaq 0x2364(%rip), %rdi      # 0x4107
movb $0x0, %al
callq 0x1030
jmp 0x1dac
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1d55
leaq 0x2347(%rip), %rdi      # 0x4107
movb $0x0, %al
callq 0x1030
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/twine80n6t4clocv2/ref/twine.c
// Function: Keyschedule
int Keyschedule(const uint32 key_len, const uint8 sk[128/8])
{
	if(key_len == 80)
		Keyschedule80(sk);
	else if(key_len == 128)
		Keyschedule128(sk);
	else
		return -1;

	return 0;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpl $0x50, 0x10(%rsp)
jne 0x32c0
movq 0x8(%rsp), %rdi
callq 0x1070
jmp 0x32e2
cmpl $0x80, 0x10(%rsp)
jne 0x32d6
movq 0x8(%rsp), %rdi
callq 0x10d0
jmp 0x32e0
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x32ea
jmp 0x32e2
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sbp[P]tweetnacl-tools/tweetnacl-sign.c
// Function: main
int main(int argc, char *argv[]) {
    if (argc != 4) error(2,
        "Usage: tweetnacl-sign sign.sec message.txt message.signed");

    // This will also erroneously fail if the file "-" exists
    if (file_exists(argv[3])) errorf(1, "File <%s> exists", argv[3]);

    unsigned char secret_key[crypto_sign_SECRETKEYBYTES];
    read_key(argv[1], secret_key, crypto_sign_SECRETKEYBYTES);

    Content c = read_file(argv[2]);
    unsigned char *sm = malloc(c.size + crypto_sign_BYTES);
    unsigned long long ssize;
    crypto_sign(sm, &ssize, c.bytes, c.size, secret_key);
    free(c.bytes);

    if (strcmp(argv[3], "-") != 0) {
        FILE *out = create_file(argv[3]);
        fwrite(sm, ssize, 1, out);
        fclose(out);
    } else {
        fwrite(bytes_to_hex(sm, ssize - c.size), 
            (ssize - c.size) * 2, 1, stdout);
        fputs("\n", stdout);
    }

    free(sm);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x4, -0x8(%rbp)
je 0x50a0
movl $0x2, %edi
leaq 0x1875(%rip), %rsi      # 0x6910
callq 0x1310
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x14d0
cmpl $0x0, %eax
je 0x50cb
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
movl $0x1, %edi
leaq 0x1884(%rip), %rsi      # 0x694a
callq 0x1370
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x50(%rbp), %rsi
movl $0x40, %edx
callq 0x1510
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1580
movq %rax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movq -0x60(%rbp), %rdi
addq $0x40, %rdi
callq 0x10b0
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rdx
movq -0x60(%rbp), %rcx
leaq -0x50(%rbp), %r8
leaq -0x70(%rbp), %rsi
callq 0x3f10
movq -0x58(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x1823(%rip), %rsi      # 0x695b
callq 0x1080
cmpl $0x0, %eax
je 0x5174
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x1470
movq %rax, -0x78(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rcx
movl $0x1, %edx
callq 0x1130
movq -0x78(%rbp), %rdi
callq 0x1050
jmp 0x51bf
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rax
subq -0x60(%rbp), %rax
movl %eax, %esi
callq 0x13e0
movq %rax, %rdi
movq -0x70(%rbp), %rsi
subq -0x60(%rbp), %rsi
shlq %rsi
movq 0x3e3c(%rip), %rax      # 0x8fd8
movq (%rax), %rcx
movl $0x1, %edx
callq 0x1130
movq 0x3e28(%rip), %rax      # 0x8fd8
movq (%rax), %rsi
leaq 0xe5f(%rip), %rdi       # 0x6019
callq 0x1060
movq -0x68(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x80, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/simple-hash.c
// Function: main
int main( int argc, char** argv ) {
	
	if ( argc < 2 )
	{
		printf( "Not enough arguments given!\nUsage: %s text\n", argv[0] );
		return 1;
	}
	uint16_t hash1;
	uint32_t hash2;
	uint32_t hash3;
	if(strlen(argv[1]) > 512) BREAK("donut: the abuse\n");
	printf("Hashing the following string:\n%s\n", argv[1]);
	hash1 = StrCode16(argv[1]);
	hash2 = StrCode24(argv[1]);
	hash3 = StrCode32(argv[1]);
	printf("Hash16(MGS1):     %04x\n", hash1);
	printf("Hash24(MGS2+):  %06x\n", hash2);
	printf("Hash32(ZoE2): %08x\n", hash3);
	printf("Done.\n");
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x12dd
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xd3a(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
movl $0x1, -0x4(%rbp)
jmp 0x139c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
cmpq $0x200, %rax            # imm = 0x200
jbe 0x130c
leaq 0xd37(%rip), %rdi       # 0x2030
movb $0x0, %al
callq 0x1040
movl $0x1, -0x4(%rbp)
jmp 0x139c
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xd27(%rip), %rdi       # 0x2042
movb $0x0, %al
callq 0x1040
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1150
movw %ax, -0x12(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11b0
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1230
movl %eax, -0x1c(%rbp)
movzwl -0x12(%rbp), %esi
leaq 0xd06(%rip), %rdi       # 0x2064
movb $0x0, %al
callq 0x1040
movl -0x18(%rbp), %esi
leaq 0xd0d(%rip), %rdi       # 0x207c
movb $0x0, %al
callq 0x1040
movl -0x1c(%rbp), %esi
leaq 0xd12(%rip), %rdi       # 0x2092
movb $0x0, %al
callq 0x1040
leaq 0xd18(%rip), %rdi       # 0x20a6
movb $0x0, %al
callq 0x1040
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/analyzer.c
// Function: showBuffers
static void showBuffers(void)
{
  size_t  buffer;
  Packet *p;

  for (buffer = 0; buffer < REASSEMBLY_BUFFER_SIZE; buffer++)
  {
    p = &reassemblyBuffer[buffer];

    if (p->used)
    {
      logError("ReassemblyBuffer[%zu] PGN %u: size %zu frames=%x mask=%x\n", buffer, p->pgn, p->size, p->frames, p->allFrames);
    }
    else
    {
      logDebug("ReassemblyBuffer[%zu]: inUse=false\n", buffer);
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq $0x0, -0x8(%rbp)
cmpq $0x40, -0x8(%rbp)
jae 0xcf1e
movq -0x8(%rbp), %rcx
leaq 0x874da(%rip), %rax     # 0x94380
shlq $0x8, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
testb $0x1, 0xf8(%rax)
je 0xcef9
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0xf0(%rax), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
movl 0xe8(%rax), %r8d
movq -0x10(%rbp), %rax
movl 0xec(%rax), %r9d
leaq 0x1d5d5(%rip), %rdi     # 0x2a4c5
movb $0x0, %al
callq 0x22620
jmp 0xcf0b
movq -0x8(%rbp), %rsi
leaq 0x1d5fb(%rip), %rdi     # 0x2a4ff
movb $0x0, %al
callq 0x22570
jmp 0xcf0d
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0xce90
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/analyzer.c
// Function: getMessageByteCount
static unsigned int getMessageByteCount(const char *const msg)
{
  const char  *p;
  int          r;
  unsigned int len;

  p = strchr(msg, ',');
  if (p)
  {
    r = sscanf(p, ",%*u,%*u,%*u,%*u,%u,%*x,%*x,%*x,%*x,%*x,%*x,%*x,%*x,%*x", &len);
    if (r >= 1)
    {
      return len;
    }
  }
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0x2c, %esi
callq 0xb0e0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xd1de
movq -0x18(%rbp), %rdi
leaq 0x1cfac(%rip), %rsi     # 0x2a16c
leaq -0x20(%rbp), %rdx
movb $0x0, %al
callq 0xb250
movl %eax, -0x1c(%rbp)
cmpl $0x1, -0x1c(%rbp)
jl 0xd1dc
movl -0x20(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xd1e5
jmp 0xd1de
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/analyzer.c
// Function: printCanRaw
static void printCanRaw(const RawMessage *msg)
{
  size_t i;
  FILE  *f = stdout;

  if (onlySrc >= 0 && onlySrc != msg->src)
  {
    return;
  }
  if (onlyDst >= 0 && onlyDst != msg->dst)
  {
    return;
  }
  if (onlyPgn > 0 && onlyPgn != msg->pgn)
  {
    return;
  }

  if (showJson)
  {
    f = stderr;
  }

  if (showRaw && (!onlyPgn || onlyPgn == msg->pgn))
  {
    fprintf(f, "%s,%u,%u,%u,%u,%u", msg->timestamp, msg->prio, msg->pgn, msg->src, msg->dst, msg->len);
    for (i = 0; i < msg->len; i++)
    {
      fprintf(f, ",%02x", msg->data[i]);
    }
    putc('\n', f);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x339a5(%rip), %rax     # 0x40fc8
movq (%rax), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x80b97(%rip)     # 0x8e1c8
jl 0xd64a
movl 0x80b8f(%rip), %eax     # 0x8e1c8
movq -0x8(%rbp), %rcx
movzbl 0x45(%rcx), %ecx
cmpl %ecx, %eax
je 0xd64a
jmp 0xd763
cmpl $0x0, 0x80b7b(%rip)     # 0x8e1cc
jl 0xd66a
movl 0x80b73(%rip), %eax     # 0x8e1cc
movq -0x8(%rbp), %rcx
movzbl 0x44(%rcx), %ecx
cmpl %ecx, %eax
je 0xd66a
jmp 0xd763
cmpl $0x0, 0x86ce3(%rip)     # 0x94354
jle 0xd687
movl 0x86cdb(%rip), %eax     # 0x94354
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
je 0xd687
jmp 0xd763
testb $0x1, 0x86cba(%rip)     # 0x94348
je 0xd69e
movq 0x33959(%rip), %rax     # 0x40ff0
movq (%rax), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x86c9f(%rip)     # 0x94344
je 0xd763
cmpl $0x0, 0x86ca2(%rip)     # 0x94354
je 0xd6c7
movl 0x86c9a(%rip), %eax     # 0x94354
movq -0x8(%rbp), %rcx
cmpl 0x40(%rcx), %eax
jne 0xd763
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movzbl 0x3c(%rax), %ecx
movq -0x8(%rbp), %rax
movl 0x40(%rax), %r8d
movq -0x8(%rbp), %rax
movzbl 0x45(%rax), %r9d
movq -0x8(%rbp), %rax
movzbl 0x44(%rax), %r10d
movq -0x8(%rbp), %rax
movzbl 0x46(%rax), %eax
leaq 0x1cdad(%rip), %rsi     # 0x2a4ad
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0xb1d0
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movzbl 0x46(%rcx), %ecx
cmpq %rcx, %rax
jae 0xd755
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movzbl 0x47(%rax,%rcx), %edx
leaq 0x1cd7f(%rip), %rsi     # 0x2a4bf
movb $0x0, %al
callq 0xb1d0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xd717
movq -0x18(%rbp), %rsi
movl $0xa, %edi
callq 0xb1a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/analyzer.c
// Function: fieldPrintVariable
extern bool fieldPrintVariable(const Field   *field,
                               const char    *fieldName,
                               const uint8_t *data,
                               size_t         dataLen,
                               size_t         startBit,
                               size_t        *bits)
{
  const Field *refField;
  bool         r;

  refField = getField(g_refPgn, data[startBit / 8 - 1] - 1);
  if (refField)
  {
    logDebug("Field %s: found variable field %u '%s'\n", fieldName, g_refPgn, refField->name);
    r     = printField(refField, fieldName, data, dataLen, startBit, bits, false);
    *bits = (*bits + 7) & ~0x07; // round to bytes
    return r;
  }

  logError("Field %s: cannot derive variable length for PGN %d field # %d\n", fieldName, g_refPgn, data[-1]);
  *bits = 8; /* Gotta assume something */
  return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movl 0x85a12(%rip), %edi     # 0x94378
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
shrq $0x3, %rcx
subq $0x1, %rcx
movzbl (%rax,%rcx), %esi
subl $0x1, %esi
callq 0xbc30
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xe9f7
movq -0x18(%rbp), %rsi
movl 0x859e1(%rip), %edx     # 0x94378
movq -0x40(%rbp), %rax
movq (%rax), %rcx
leaq 0x1b0d8(%rip), %rdi     # 0x29a7d
movb $0x0, %al
callq 0x22570
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
movq -0x38(%rbp), %r9
xorl %eax, %eax
movl $0x0, (%rsp)
callq 0xe300
andb $0x1, %al
movb %al, -0x41(%rbp)
movq -0x38(%rbp), %rax
movq (%rax), %rcx
addq $0x7, %rcx
andq $-0x8, %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movb -0x41(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xea26
movq -0x18(%rbp), %rsi
movl 0x85977(%rip), %edx     # 0x94378
movq -0x20(%rbp), %rax
movzbl -0x1(%rax), %ecx
leaq 0x1b095(%rip), %rdi     # 0x29aa5
movb $0x0, %al
callq 0x22620
movq -0x38(%rbp), %rax
movq $0x8, (%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/canboat[P]canboat/analyzer/analyzer.c
// Function: fillGlobalsBasedOnFieldName
static void fillGlobalsBasedOnFieldName(const char *fieldName, const uint8_t *data, size_t dataLen, size_t startBit, size_t bits)
{
  int64_t value;
  int64_t maxValue;

  if (strcmp(fieldName, "PGN") == 0)
  {
    extractNumber(NULL, data, dataLen, startBit, bits, &value, &maxValue);
    logDebug("Reference PGN = %" PRId64 "\n", value);
    g_refPgn = value;
    return;
  }

  if (strcmp(fieldName, "Length") == 0)
  {
    extractNumber(NULL, data, dataLen, startBit, bits, &value, &maxValue);
    logDebug("for next field: length = %" PRId64 "\n", value);
    g_length = value;
    return;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2a53e(%rip), %rsi     # 0x38fa5
callq 0xb1b0
cmpl $0x0, %eax
jne 0xeab4
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
xorl %eax, %eax
movl %eax, %edi
leaq -0x30(%rbp), %r9
leaq -0x38(%rbp), %rax
movq %rax, (%rsp)
callq 0x1e050
movq -0x30(%rbp), %rsi
leaq 0x1bcdd(%rip), %rdi     # 0x2a77e
movb $0x0, %al
callq 0x22570
movq -0x30(%rbp), %rax
movl %eax, 0x858c6(%rip)     # 0x94378
jmp 0xeb0e
movq -0x8(%rbp), %rdi
leaq 0x266c2(%rip), %rsi     # 0x35181
callq 0xb1b0
cmpl $0x0, %eax
jne 0xeb0e
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
xorl %eax, %eax
movl %eax, %edi
leaq -0x30(%rbp), %r9
leaq -0x38(%rbp), %rax
movq %rax, (%rsp)
callq 0x1e050
movq -0x30(%rbp), %rsi
leaq 0x1bc9a(%rip), %rdi     # 0x2a793
movb $0x0, %al
callq 0x22570
movq -0x30(%rbp), %rcx
leaq 0x92a1d(%rip), %rax     # 0xa1528
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/regex_src/regexMain.c
// Function: verbose_test
void verbose_test(regex_char_t *pattern, regex_char_t *string)
{
	int error;
	regex_char_t *ptr;
	struct regex_machine* machine;
	struct regex_match* match;
	int begin, end, id;

	ptr = pattern;
	while (*ptr)
		ptr++;

	printf("Start test '%s' matches to '%s'\n", pattern, string);
	machine = regex_compile(pattern, ptr - pattern, REGEX_MATCH_VERBOSE | REGEX_NEWLINE, &error);

	if (error) {
		printf("WARNING: Error %d\n", error);
		return;
	}
	if (!machine) {
		printf("ERROR: machine must be exists. Report this bug, please\n");
		return;
	}

	match = regex_begin_match(machine);
	if (!match) {
		printf("WARNING: Not enough memory for matching\n");
		regex_free_machine(machine);
		return;
	}

	ptr = string;
	while (*ptr)
		ptr++;

	regex_continue_match_debug(match, string, ptr - string);

	begin = regex_get_result(match, &end, &id);
	printf("Math returns: %3d->%3d [%3d]\n", begin, end, id);

	regex_free_match(match);
	regex_free_machine(machine);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x223f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x2228
movq -0x8(%rbp), %rsi
movq -0x10(%rbp), %rdx
leaq 0x1cdb6(%rip), %rdi     # 0x1f004
movb $0x0, %al
callq 0x2060
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
subq %rcx, %rax
movl %eax, %esi
movl $0x14, %edx
leaq -0x14(%rbp), %rcx
callq 0x2a90
movq %rax, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x2294
movl -0x14(%rbp), %esi
leaq 0x1cd9d(%rip), %rdi     # 0x1f025
movb $0x0, %al
callq 0x2060
jmp 0x2351
cmpq $0x0, -0x28(%rbp)
jne 0x22ae
leaq 0x1cd96(%rip), %rdi     # 0x1f038
movb $0x0, %al
callq 0x2060
jmp 0x2351
movq -0x28(%rbp), %rdi
callq 0x7e40
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x22db
leaq 0x1cda7(%rip), %rdi     # 0x1f070
movb $0x0, %al
callq 0x2060
movq -0x28(%rbp), %rdi
callq 0x7e00
jmp 0x2351
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpb $0x0, (%rax)
je 0x22fa
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x22e3
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movl %eax, %edx
callq 0x8570
movq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
leaq -0x3c(%rbp), %rdx
callq 0x82a0
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %esi
movl -0x38(%rbp), %edx
movl -0x3c(%rbp), %ecx
leaq 0x1cd61(%rip), %rdi     # 0x1f099
movb $0x0, %al
callq 0x2060
movq -0x30(%rbp), %rdi
callq 0x8250
movq -0x28(%rbp), %rdi
callq 0x7e00
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/regex_src/regexMain.c
// Function: main
int main(int argc, char* argv[])
{
	int has_arg = (argc >= 2 && argv[1][0] == '-' && argv[1][2] == '\0');

/*	verbose_test("a((b)((c|d))|)c|"); */
/*	verbose_test("Xa{009,0010}Xb{,7}Xc{5,}Xd{,}Xe{1,}Xf{,1}X"); */
/*	verbose_test("{3!}({3})({0!}){,"); */
/*	verbose_test("(s(ab){2,4}t){2,}*S(a*(b)(c()|)d+){3,4}{0,0}*M"); */
/*	verbose_test("^a({2!})*b+(a|{1!}b)+d$"); */
/*	verbose_test("((a|b|c)*(xy)+)+", "asbcxyxy"); */

	run_tests(tests, has_arg && argv[1][1] == 'v', has_arg && argv[1][1] == 's');
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorl %eax, %eax
cmpl $0x2, -0x8(%rbp)
movb %al, -0x15(%rbp)
jl 0x2a1b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2d, %ecx
movb %al, -0x15(%rbp)
jne 0x2a1b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl 0x2(%rax), %eax
cmpl $0x0, %eax
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x16(%rbp)
je 0x2a46
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x76, %eax
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x17(%rbp)
je 0x2a71
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl 0x1(%rax), %eax
cmpl $0x73, %eax
sete %al
movb %al, -0x17(%rbp)
movl -0x1c(%rbp), %esi
movb -0x17(%rbp), %al
andb $0x1, %al
movzbl %al, %edx
leaq 0x2061d(%rip), %rdi     # 0x230a0
callq 0x2360
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/regex_src/regexJIT.c
// Function: stack_destroy
static void stack_destroy(struct stack *stack)
{
	struct stack_fragment *curr = stack->first;
	struct stack_fragment *prev;

#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
	stack_check(stack);
#endif

	while (curr) {
		prev = curr;
		curr = curr->data.next;
		free(prev);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9270
cmpq $0x0, -0x10(%rbp)
je 0x4ee5
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2030
jmp 0x4ec0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/regex_src/regexJIT.c
// Function: stack_init
static void stack_init(struct stack *stack)
{
	stack->first = NULL;
	stack->last = NULL;
	stack->index = STACK_FRAGMENT_SIZE - 1;
	stack->count = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x3d, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/regex_src/regexJIT.c
// Function: stack_pop
static struct stack_item* stack_pop(struct stack *stack)
{
	struct stack_item *ret = stack_top(stack);

	if (stack->index > 0)
		stack->index--;
	else {
		stack->last = stack->last->data.prev;
		stack->index = STACK_FRAGMENT_SIZE - 1;
	}

	stack->count--;
#if (defined SLJIT_DEBUG && SLJIT_DEBUG)
	stack_check(stack);
#endif
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x9d20
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x10(%rax)
jle 0x5b72
movq -0x8(%rbp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
jmp 0x5b91
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x3d, 0x10(%rax)
movq -0x8(%rbp), %rax
movl 0x14(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x14(%rax)
movq -0x8(%rbp), %rdi
callq 0x9270
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/regex_src/regexJIT.c
// Function: compile_newline_check
static int compile_newline_check(struct compiler_common *compiler_common, long ind)
{
	struct sljit_compiler *compiler = compiler_common->compiler;
	struct sljit_jump *jump1;
	struct sljit_jump *jump2;
	struct sljit_label *label;
	long no_states;
	long offset;

	/* Check whether a new-line character is found. */
	EMIT_CMP(jump1, SLJIT_EQUAL, R_CURR_CHAR, 0, SLJIT_IMM, '\n');
	EMIT_CMP(jump2, SLJIT_EQUAL, R_CURR_CHAR, 0, SLJIT_IMM, '\r');

	no_states = compiler_common->no_states;
	offset = TERM_OFFSET_OF(compiler_common->search_states[ind].type, 1);
	EMIT_OP1(SLJIT_MOV, R_TEMP, 0, SLJIT_MEM1(R_CURR_STATE), offset);
	EMIT_OP1(SLJIT_MOV, SLJIT_MEM1(R_CURR_STATE), offset, SLJIT_IMM, -1);
	CHECK(sljit_emit_ijump(compiler, SLJIT_JUMP, SLJIT_MEM2(R_CURR_STATE, R_TEMP), 0));

	EMIT_LABEL(label);
	sljit_set_label(jump1, label);
	sljit_set_label(jump2, label);
	return REGEX_NO_ERROR;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x40, %r8d
movl $0xa, %r9d
callq 0x1c790
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x6fb3
movl $0x1, -0x4(%rbp)
jmp 0x70de
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x40, %r8d
movl $0xd, %r9d
callq 0x1c790
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x6fea
movl $0x1, -0x4(%rbp)
jmp 0x70de
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rax
movq -0x18(%rbp), %rcx
movslq (%rax,%rcx,8), %rax
imulq -0x40(%rbp), %rax
addq $0x1, %rax
shlq $0x3, %rax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %r9
movl $0x20, %esi
movl $0x3, %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x8c, %r8d
callq 0xeee0
cmpl $0x0, %eax
je 0x7049
movl $0x1, -0x4(%rbp)
jmp 0x70de
movq -0x20(%rbp), %rdi
movq -0x48(%rbp), %rcx
movl $0x20, %esi
movl $0x8c, %edx
movl $0x40, %r8d
movq $-0x1, %r9
callq 0xeee0
cmpl $0x0, %eax
je 0x707b
movl $0x1, -0x4(%rbp)
jmp 0x70de
movq -0x20(%rbp), %rdi
movl $0x16, %esi
movl $0x38c, %edx            # imm = 0x38C
xorl %eax, %eax
movl %eax, %ecx
callq 0x1a3c0
cmpl $0x0, %eax
je 0x70a0
movl $0x1, -0x4(%rbp)
jmp 0x70de
movq -0x20(%rbp), %rdi
callq 0x19d30
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x70bd
movl $0x1, -0x4(%rbp)
jmp 0x70de
movq -0x28(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xa940
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xa940
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/regex_src/regexJIT.c
// Function: regex_reset_match
void regex_reset_match(struct regex_match *match)
{
	struct regex_machine *machine = match->machine;
	long current, ind;
	long *current_ptr;

	match->best_end = 0;
	match->fast_quit = 0;
	match->fast_forward = 0;

	if (match->head != 0) {
		/* Clear the current state. */
		current = match->head;
		current_ptr = match->current;
		do {
			ind = (current / sizeof(long)) + 1;
			current = current_ptr[ind];
			current_ptr[ind] = -1;
		} while (current != 0);
	}
	match->head = machine->u.call_init(match->current, match);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x8227
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
shrq $0x3, %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movq $-0x1, (%rax,%rcx,8)
cmpq $0x0, -0x18(%rbp)
jne 0x81ee
jmp 0x8227
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rdi
movq -0x8(%rbp), %rsi
callq *%rax
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/regex_src/regexJIT.c
// Function: decode_number
static const regex_char_t* decode_number(const regex_char_t *regex_string, int length, int *result)
{
	int value = 0;

	SLJIT_ASSERT(length > 0);
	if (*regex_string < '0' || *regex_string > '9') {
		*result = -1;
		return regex_string;
	}

	while (length > 0 && *regex_string >= '0' && *regex_string <= '9') {
		value = value * 10 + (*regex_string - '0');
		length--;
		regex_string++;
	}

	*result = value;
	return regex_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x0, -0x14(%rbp)
jg 0x94a8
leaq 0x16379(%rip), %rdi     # 0x1f810
movl $0x199, %esi            # imm = 0x199
movb $0x0, %al
callq 0x2060
callq 0x2040
jmp 0x94aa
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x30, %eax
jl 0x94c2
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
jle 0x94d6
movq -0x20(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x9548
jmp 0x94d8
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x25(%rbp)
jle 0x9504
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x30, %ecx
movb %al, -0x25(%rbp)
jl 0x9504
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x39, %eax
setle %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x950d
jmp 0x9537
imull $0xa, -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
subl $0x30, %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x94d8
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mmcco[P]sljit/regex_src/regexJIT.c
// Function: handle_iteratives
static struct stack_item* handle_iteratives(struct stack_item *transitions_ptr, struct stack_item *transitions, struct stack *depth)
{
	struct stack_item *item;

	while (1) {
		item = stack_top(depth);

		switch (item->type) {
		case type_asterisk:
			SLJIT_ASSERT(transitions[item->value].type == type_branch);
			transitions[item->value].value = transitions_ptr - transitions;
			PUT_TRANSITION(type_branch, item->value + 1);
			break;

		case type_plus_sign:
			SLJIT_ASSERT(transitions[item->value].type == type_branch);
			transitions[item->value].value = transitions_ptr - transitions;
			break;

		case type_qestion_mark:
			PUT_TRANSITION(type_branch, item->value);
			break;

		default:
			return transitions_ptr;
		}
		stack_pop(depth);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x9d20
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
subl $0xf, %eax
je 0x9c10
jmp 0x9bf1
movl -0x24(%rbp), %eax
subl $0x10, %eax
je 0x9c8b
jmp 0x9bff
movl -0x24(%rbp), %eax
subl $0x11, %eax
je 0x9cdc
jmp 0x9d04
jmp 0x9c12
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq 0x4(%rcx), %rcx
cmpl $0xa, (%rax,%rcx,8)
je 0x9c3c
leaq 0x15be5(%rip), %rdi     # 0x1f810
movl $0x3bb, %esi            # imm = 0x3BB
movb $0x0, %al
callq 0x2060
callq 0x2040
jmp 0x9c3e
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movl %edx, 0x4(%rax,%rcx,8)
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xa, (%rax)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x9d0e
jmp 0x9c8d
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq 0x4(%rcx), %rcx
cmpl $0xa, (%rax,%rcx,8)
je 0x9cb7
leaq 0x15b6a(%rip), %rdi     # 0x1f810
movl $0x3c1, %esi            # imm = 0x3C1
movb $0x0, %al
callq 0x2060
callq 0x2040
jmp 0x9cb9
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
sarq $0x3, %rax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
movslq 0x4(%rcx), %rcx
movl %edx, 0x4(%rax,%rcx,8)
jmp 0x9d0e
jmp 0x9cde
movq -0x8(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0xa, (%rax)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x9d0e
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x5b40
jmp 0x9bd4
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/PARKINHYO[P]BlackjackGame/mqueue/./common.h
// Function: get_suit_id
int get_suit_id(char suit)
{
	unsigned i;
	for (i = 0; i < sizeof(suit_codes); ++i)
		if (suit == suit_codes[i])
			return i;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpq $0x4, %rax
jae 0x12e7
movsbl -0x5(%rbp), %eax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
leaq 0xf6e(%rip), %rcx       # 0x2238
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x12da
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12ee
jmp 0x12dc
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x12b1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PARKINHYO[P]BlackjackGame/mqueue/./common.h
// Function: get_value_id
int get_value_id(char value)
{
	unsigned i;
	for (i = 0; i < sizeof(value_codes); ++i)
		if (value == value_codes[i])
			return i;
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpq $0xe, %rax
jae 0x1347
movsbl -0x5(%rbp), %eax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
leaq 0xf12(%rip), %rcx       # 0x223c
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
jne 0x133a
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x134e
jmp 0x133c
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1311
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PARKINHYO[P]BlackjackGame/mqueue/mqueue_client.c
// Function: set_shutdown
void *set_shutdown()
{
	printf("[SIGNAL] : Got shutdown signal\n");
	msgctl(msgid_Send_Main, IPC_RMID, 0);
	printf("[SIGNAL] : Message passing queue marked for deletion\n");
	msgctl(msgid_Recv_Main, IPC_RMID, 0);
	printf("[SIGNAL] : Message passing queue marked for deletion\n");
	exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0xb8e(%rip), %rdi       # 0x2069
movb $0x0, %al
callq 0x1090
movl 0x2c84(%rip), %edi      # 0x416c
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0xb8f(%rip), %rdi       # 0x2089
movb $0x0, %al
callq 0x1090
movl 0x2c69(%rip), %edi      # 0x4170
xorl %esi, %esi
xorl %eax, %eax
movl %eax, %edx
callq 0x1100
leaq 0xb70(%rip), %rdi       # 0x2089
movb $0x0, %al
callq 0x1090
movl $0x1, %edi
callq 0x1130
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PARKINHYO[P]BlackjackGame/mqueue/mqueue_client.c
// Function: send_msg
void* send_msg() {
	msg buf;
	buf.type = pid;

	char buffer[BUFFER_SIZE];
	int choice;

	while (1) {
		if(finalcheck) {break;}
		if(check2 == 1){
			printf("\n");
			printf("1. Hit\n");
			printf("2. Stand\n");
			printf("Please choose 1 or 2: ");
			fflush(stdout);
			scanf("%d", &choice);

			if (choice == 1)
			{
				strcpy(buffer, HIT);
				printf("Sending: %s\n", buffer);

				strncpy(buf.data, buffer, BUFFER_SIZE);
				msgsnd(msgid_Send_Main, (void*)&buf, sizeof(msg), 0);
				buffer[0]='\0';
				check2 =2;

			}
			else if (choice == 2)
			{
				strcpy(buffer, STAND);
				printf("Sending: %s\n", buffer);
				strncpy(buf.data, buffer, BUFFER_SIZE);
				msgsnd(msgid_Send_Main, (void*)&buf, sizeof(msg), 0);
				buffer[0]='\0';	
				check2 = 0;
				check = 0;
				finalcheck = 1;
				break;
			}
			else
				printf("Unrecognized choice. Choose again.\n");
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movslq 0x2c35(%rip), %rax      # 0x4174
movq %rax, -0x30(%rbp)
cmpl $0x0, 0x2c1e(%rip)      # 0x4168
je 0x1551
jmp 0x16ad
cmpl $0x1, 0x2c0c(%rip)      # 0x4164
jne 0x16a8
leaq 0xbc6(%rip), %rdi       # 0x212b
movb $0x0, %al
callq 0x1090
leaq 0xb4c(%rip), %rdi       # 0x20bf
movb $0x0, %al
callq 0x1090
leaq 0xb46(%rip), %rdi       # 0x20c7
movb $0x0, %al
callq 0x1090
leaq 0xb42(%rip), %rdi       # 0x20d1
movb $0x0, %al
callq 0x1090
movq 0x2a33(%rip), %rax      # 0x3fd0
movq (%rax), %rdi
callq 0x10f0
leaq 0xab1(%rip), %rdi       # 0x205d
leaq -0x54(%rbp), %rsi
movb $0x0, %al
callq 0x1120
cmpl $0x1, -0x54(%rbp)
jne 0x161e
leaq -0x50(%rbp), %rdi
leaq 0xb20(%rip), %rsi       # 0x20e8
callq 0x1060
leaq -0x50(%rbp), %rsi
leaq 0xb14(%rip), %rdi       # 0x20ec
movb $0x0, %al
callq 0x1090
leaq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq -0x50(%rbp), %rsi
movl $0x20, %edx
callq 0x1040
movl 0x2b71(%rip), %edi      # 0x416c
leaq -0x30(%rbp), %rsi
movl $0x28, %edx
xorl %ecx, %ecx
callq 0x10c0
movb $0x0, -0x50(%rbp)
movl $0x2, 0x2b4b(%rip)      # 0x4164
jmp 0x16a6
cmpl $0x2, -0x54(%rbp)
jne 0x1696
leaq -0x50(%rbp), %rdi
leaq 0xaca(%rip), %rsi       # 0x20f9
callq 0x1060
leaq -0x50(%rbp), %rsi
leaq 0xaad(%rip), %rdi       # 0x20ec
movb $0x0, %al
callq 0x1090
leaq -0x30(%rbp), %rdi
addq $0x8, %rdi
leaq -0x50(%rbp), %rsi
movl $0x20, %edx
callq 0x1040
movl 0x2b0a(%rip), %edi      # 0x416c
leaq -0x30(%rbp), %rsi
movl $0x28, %edx
xorl %ecx, %ecx
callq 0x10c0
movb $0x0, -0x50(%rbp)
movl $0x0, 0x2ae4(%rip)      # 0x4164
movl $0x0, 0x2ad6(%rip)      # 0x4160
movl $0x1, 0x2ad4(%rip)      # 0x4168
jmp 0x16ad
leaq 0xa62(%rip), %rdi       # 0x20ff
movb $0x0, %al
callq 0x1090
jmp 0x16a6
jmp 0x16a8
jmp 0x1543
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/PARKINHYO[P]BlackjackGame/mqueue/mqueue_client.c
// Function: play_game
void* play_game() {

	// recv_msg, send_msg 스레드 생성...
	pthread_create(&threads[1], NULL, recv_msg, NULL);
	pthread_create(&threads[2], NULL, send_msg, NULL);
	int tid;
	// 스레드들 끝날때까지 대기후 삭제...
	for (tid = 1; tid < 2; ++tid)
		pthread_join(threads[tid], NULL);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x2581(%rip), %rdi      # 0x4180
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x54e(%rip), %rdx      # 0x16c0
movq %rcx, %rsi
callq 0x1110
leaq 0x2563(%rip), %rdi      # 0x4180
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x6fc(%rip), %rdx      # 0x1530
movq %rcx, %rsi
callq 0x1110
movl $0x1, -0xc(%rbp)
cmpl $0x2, -0xc(%rbp)
jge 0x1c64
movslq -0xc(%rbp), %rcx
leaq 0x2534(%rip), %rax      # 0x4180
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1140
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1c3b
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/PARKINHYO[P]BlackjackGame/mqueue/mqueue_client.c
// Function: main
int main() {

	char buffer[BUFFER_SIZE];
	int count = 0;
	pid = getpid();
	msg buf;

	msgid_Send_Main = msgget(KEY_VALUE_MAIN, IPC_CREAT | PERM);
	msgid_Recv_Main = msgget(KEY_VALUE_MAIN2, IPC_CREAT | PERM);

	// Signal 등록 ...
	(void)signal(SIGINT, (void(*)()) set_shutdown);

	printf("input data ==> ");
	fgets(buffer, BUFFER_SIZE, stdin);

	buf.type = 200;
	memset(buf.data, 0, sizeof(buf.data));
	strncpy(buf.data, buffer, BUFFER_SIZE);
	msgsnd(msgid_Send_Main, (void*)&buf, sizeof(msg), 0);

	// 쓴 데이터가 ‘quit’이면 while 문 벗어남...
	if (!strncmp(buf.data, "quit", 4)) {
		return 0;
	}

	// play_game 스레드 진입...
	pthread_create(&threads[0], NULL, play_game, NULL);
	// 스레드 종료 대기후 삭제...
	pthread_join(threads[0], NULL);
	printf("game end!\n");
	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x34(%rbp)
callq 0x1070
movl %eax, 0x24e3(%rip)      # 0x4174
movl $0xeb8c, %edi           # imm = 0xEB8C
movl $0x3b6, %esi            # imm = 0x3B6
callq 0x1030
movl %eax, 0x24c6(%rip)      # 0x416c
movl $0xeb8d, %edi           # imm = 0xEB8D
movl $0x3b6, %esi            # imm = 0x3B6
callq 0x1030
movl %eax, 0x24b5(%rip)      # 0x4170
movl $0x2, %edi
leaq -0x7f7(%rip), %rsi      # 0x14d0
callq 0x10d0
leaq 0x545(%rip), %rdi       # 0x2218
movb $0x0, %al
callq 0x1090
leaq -0x30(%rbp), %rdi
movq 0x22f3(%rip), %rax      # 0x3fd8
movq (%rax), %rdx
movl $0x20, %esi
callq 0x10b0
movq $0xc8, -0x60(%rbp)
leaq -0x60(%rbp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x10a0
leaq -0x60(%rbp), %rdi
addq $0x8, %rdi
leaq -0x30(%rbp), %rsi
movl $0x20, %edx
callq 0x1040
movl 0x2442(%rip), %edi      # 0x416c
leaq -0x60(%rbp), %rsi
movl $0x28, %edx
xorl %ecx, %ecx
callq 0x10c0
leaq -0x60(%rbp), %rdi
addq $0x8, %rdi
leaq 0x4df(%rip), %rsi       # 0x2228
movl $0x4, %edx
callq 0x1050
cmpl $0x0, %eax
jne 0x1d61
movl $0x0, -0x4(%rbp)
jmp 0x1da0
leaq 0x2418(%rip), %rdi      # 0x4180
xorl %eax, %eax
movl %eax, %ecx
leaq -0x183(%rip), %rdx      # 0x1bf0
movq %rcx, %rsi
callq 0x1110
movq 0x23fe(%rip), %rdi      # 0x4180
xorl %eax, %eax
movl %eax, %esi
callq 0x1140
leaq 0x49b(%rip), %rdi       # 0x222d
movb $0x0, %al
callq 0x1090
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/bitfield.c
// Function: moongl_bitfieldCheck
GLbitfield bitfieldCheck(lua_State *L, int arg, int mandatory, bitfield_t *b)
/* Assuming all args from arg to end are bitfield strings */
/* returns the OR of the corresponding codes */
        {
        int first = arg;
        GLbitfield val = 0;
        while(!lua_isnoneornil(L, arg))
            val |= b->codes[checkoption(L, arg++, NULL, b->strings)];
        if(mandatory && (arg==first))
            return luaL_argerror(L, first, "string expected");
        return val;
        }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movl %edx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl 0x24(%rsp), %eax
movl %eax, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x11860
cmpl $0x0, %eax
setle %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x11ca2
jmp 0x11cea
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movl %esi, %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x11a60
movl %eax, %ecx
movq 0x8(%rsp), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
orl 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x11c86
cmpl $0x0, 0x20(%rsp)
je 0x11d16
movl 0x24(%rsp), %eax
cmpl 0x14(%rsp), %eax
jne 0x11d16
movq 0x28(%rsp), %rdi
movl 0x14(%rsp), %esi
leaq 0x402f5(%rip), %rdx     # 0x52000
callq 0x11940
movl %eax, 0x34(%rsp)
jmp 0x11d1e
movl 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/bitfield.c
// Function: moongl_bitfieldPush
int bitfieldPush(lua_State *L, GLbitfield code, bitfield_t *b)
/* Pushes all the strings corresponding to bits contained in code */
    {
    size_t i;
    int nret = 0;
    for(i = 0; i < b->n; i++)
        {
        if((b->codes[i] & code) == b->codes[i])
            { lua_pushstring(L, b->strings[i]); nret++; }
        }
    return nret;
    }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x0, 0x4(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
cmpq 0x10(%rcx), %rax
jae 0x11dc3
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %eax
andl 0x1c(%rsp), %eax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x11db1
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x110c0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x11db3
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x11d53
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/buffer.c
// Function: BindBufferBase
static int BindBufferBase(lua_State *L)
    {
    GLenum target = checkbufferrangetarget(L, 1);
    GLuint index = luaL_checkinteger(L, 2);
    GLuint buffer = luaL_checkinteger(L, 3); 
    glBindBufferBase(target, index, buffer);
    CheckError(L);
    return 0;
    }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl $0x37, %esi
movl $0x1, %edx
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11af0
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x11af0
movl %eax, 0x4(%rsp)
movq 0x55182(%rip), %rax     # 0x67470
movq (%rax), %rax
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x4(%rsp), %edx
callq *%rax
movq 0x10(%rsp), %rdi
callq 0x11880
xorl %eax, %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/stetre[P]moongl/src/buffer.c
// Function: BufferStorage
static int BufferStorage(lua_State *L)
/* size = buffer_storage(target|buffer, data, flag1, flag2, ... ) */
    {
    size_t len;
    const char *data;
    GLsizeiptr size;
    GLbitfield flags;
    GLenum target;
    GLuint buffer = checktargetorname(L, 1, &target, DOMAIN_BUFFER_TARGET);
    if(lua_isnoneornil(L, 2))
        {
        data = NULL;
        size = 0;
        }
    else if(lua_isstring(L, 2))
        {
        data = lua_tolstring(L, 2, &len);
        size = len;
        }
    else if(lua_istable(L, 2))
        {
        data = checkdataptr(L, 2, &len);
        size = len;
        }
    else
        return luaL_argerror(L, 2, "invalid type");
    flags = CheckStorageFlags(L, 3, 0);

    if(buffer==0)
        glBufferStorage(target, size, data, flags);
    else
        glNamedBufferStorage(buffer, size, data, flags);
    CheckError(L);
    lua_pushinteger(L, size);
    return 1;
    }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movl $0x1, %esi
leaq 0x8(%rsp), %rdx
movl $0x36, %ecx
callq 0x11430
movl %eax, 0x4(%rsp)
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x11860
cmpl $0x0, %eax
jg 0x12391
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
jmp 0x12426
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x110b0
cmpl $0x0, %eax
je 0x123ca
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x20(%rsp), %rdx
callq 0x11950
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x12424
movq 0x28(%rsp), %rdi
movl $0x2, %esi
callq 0x11860
cmpl $0x5, %eax
jne 0x12403
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x20(%rsp), %rdx
callq 0x11b20
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x12422
movq 0x28(%rsp), %rdi
movl $0x2, %esi
leaq 0x3fde4(%rip), %rdx     # 0x521f8
callq 0x11940
movl %eax, 0x34(%rsp)
jmp 0x124a8
jmp 0x12424
jmp 0x12426
movq 0x28(%rsp), %rdi
movl $0x3, %esi
xorl %edx, %edx
leaq 0x561a7(%rip), %rcx     # 0x685e0
callq 0x11b50
movl %eax, 0xc(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x12469
movq 0x54e08(%rip), %rax     # 0x67258
movq (%rax), %rax
movl 0x8(%rsp), %edi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq *%rax
jmp 0x12487
movq 0x55770(%rip), %rax     # 0x67be0
movq (%rax), %rax
movl 0x4(%rsp), %edi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl 0xc(%rsp), %ecx
callq *%rax
movq 0x28(%rsp), %rdi
callq 0x11880
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x113c0
movl $0x1, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)