LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/soso7885[P]OPCUA_example/demo_src/server.c
// Function: getMonitoredItems
static UA_StatusCode
getMonitoredItems(void *methodHandle, const UA_NodeId objectId,
                  size_t inputSize, const UA_Variant *input,
                  size_t outputSize, UA_Variant *output) {
    UA_String tmp = UA_STRING("Hello World");
    UA_Variant_setScalarCopy(output, &tmp, &UA_TYPES[UA_TYPES_STRING]);
    printf("getMonitoredItems was called\n");
    return UA_STATUSCODE_GOOD;
}

// 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)
leaq 0x937(%rip), %rdi       # 0x520a
callq 0x4850
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
movq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movq 0x26e1(%rip), %rdx      # 0x6fd0
addq $0x1b8, %rdx            # imm = 0x1B8
callq 0x2150
leaq 0x914(%rip), %rdi       # 0x5216
movb $0x0, %al
callq 0x20f0
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/aes128n12t8clocv2/aesni/encrypt.c
// Function: load_partial_block
void load_partial_block(block* dst, const unsigned char* m, int len, unsigned choice)
{
    unsigned char temp[16];
    if(choice == ZERO_APPEND){
        memcpy(temp, m, len);
        memset(temp+len, 0, 16-len);
        *dst = LOAD(temp);
    }
    else if(choice == ONE_ZERO_PADDING){
        memcpy(temp, m, len);
        memset(temp+len, 0, STATE_LEN-len);
        if(len < STATE_LEN)
            temp[len] = 0x80;
        *dst = LOAD(temp);
    }
    else if(choice == ZERO_PREPEND){
        memcpy(temp+16-len, m, len);
        memset(temp, 0, 16-len);
        *dst = LOAD(temp);
    }
    else if(choice == PARAM_OZP){
        temp[0] = PARAM;
        memcpy(temp+1, m, len);
        memset(temp+len+1, 0, STATE_LEN-len-1);
        if(len < (STATE_LEN-1))
            temp[len+1] = 0x80;
        *dst = LOAD(temp);
    }
    else{
        // do nothing
    }
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
cmpl $0x0, 0x10(%rsp)
jne 0x20cc
movq %rsp, %rdi
movq 0x18(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x10a0
movq %rsp, %rdi
movslq 0x14(%rsp), %rax
addq %rax, %rdi
movl $0x10, %eax
subl 0x14(%rsp), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x1030
movq %rsp, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
vmovdqa (%rax), %xmm0
movq 0x20(%rsp), %rax
vmovdqa %xmm0, (%rax)
jmp 0x220c
cmpl $0x2, 0x10(%rsp)
jne 0x2132
movq %rsp, %rdi
movq 0x18(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x10a0
movq %rsp, %rdi
movslq 0x14(%rsp), %rax
addq %rax, %rdi
movl $0x10, %eax
subl 0x14(%rsp), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x1030
cmpl $0x10, 0x14(%rsp)
jge 0x2113
movslq 0x14(%rsp), %rax
movb $-0x80, (%rsp,%rax)
movq %rsp, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
vmovdqa (%rax), %xmm0
movq 0x20(%rsp), %rax
vmovdqa %xmm0, (%rax)
jmp 0x220a
cmpl $0x1, 0x10(%rsp)
jne 0x218e
movq %rsp, %rdi
addq $0x10, %rdi
movslq 0x14(%rsp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdi
movq 0x18(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x10a0
movq %rsp, %rdi
movl $0x10, %eax
subl 0x14(%rsp), %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x1030
movq %rsp, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
vmovdqa (%rax), %xmm0
movq 0x20(%rsp), %rax
vmovdqa %xmm0, (%rax)
jmp 0x2208
cmpl $0x3, 0x10(%rsp)
jne 0x2204
movb $-0x40, (%rsp)
movq %rsp, %rdi
addq $0x1, %rdi
movq 0x18(%rsp), %rsi
movslq 0x14(%rsp), %rdx
callq 0x10a0
movq %rsp, %rdi
movslq 0x14(%rsp), %rax
addq %rax, %rdi
addq $0x1, %rdi
movl $0x10, %eax
subl 0x14(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rdx
xorl %esi, %esi
callq 0x1030
cmpl $0xf, 0x14(%rsp)
jge 0x21e8
movl 0x14(%rsp), %eax
addl $0x1, %eax
cltq
movb $-0x80, (%rsp,%rax)
movq %rsp, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
vmovdqa (%rax), %xmm0
movq 0x20(%rsp), %rax
vmovdqa %xmm0, (%rax)
jmp 0x2206
jmp 0x2206
jmp 0x2208
jmp 0x220a
jmp 0x220c
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]init/daemon.c
// Function: pidfile_open
static void pidfile_open(const char *path) {
  pidfile.fd = open(path, O_RDWR | O_CLOEXEC | O_CREAT, 0666);
  if (pidfile.fd < 0)
    err(EXIT_FAILURE, "%s", path);
  if (flock(pidfile.fd, LOCK_EX | LOCK_NB) < 0)
    errx(EXIT_FAILURE, "%s already locked", path);
  if (!(pidfile.path = realpath(path, NULL)))
    err(EXIT_FAILURE, "%s", path);
  if (ftruncate(pidfile.fd, 0) < 0)
    err(EXIT_FAILURE, "%s", path);
  atexit(pidfile_close);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0x80042, %esi          # imm = 0x80042
movl $0x1b6, %edx            # imm = 0x1B6
movb $0x0, %al
callq 0x22e0
movl %eax, 0x3421(%rip)      # 0x6218
cmpl $0x0, 0x341a(%rip)      # 0x6218
jge 0x2e17
movq -0x8(%rbp), %rdx
movl $0x1, %edi
leaq 0x13e5(%rip), %rsi      # 0x41f5
movb $0x0, %al
callq 0x2230
movl 0x33fb(%rip), %edi      # 0x6218
movl $0x6, %esi
callq 0x2320
cmpl $0x0, %eax
jge 0x2e43
movq -0x8(%rbp), %rdx
movl $0x1, %edi
leaq 0x12fe(%rip), %rsi      # 0x413a
movb $0x0, %al
callq 0x20e0
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2200
movq %rax, 0x33b9(%rip)      # 0x6210
cmpq $0x0, %rax
jne 0x2e74
movq -0x8(%rbp), %rdx
movl $0x1, %edi
leaq 0x1388(%rip), %rsi      # 0x41f5
movb $0x0, %al
callq 0x2230
movl 0x339e(%rip), %edi      # 0x6218
xorl %eax, %eax
movl %eax, %esi
callq 0x2140
cmpl $0x0, %eax
jge 0x2e9f
movq -0x8(%rbp), %rdx
movl $0x1, %edi
leaq 0x135d(%rip), %rsi      # 0x41f5
movb $0x0, %al
callq 0x2230
leaq 0xe6a(%rip), %rdi       # 0x3d10
callq 0x3e70
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]init/daemon.c
// Function: listen_unix
static void listen_unix(const char *path) {
  struct sockaddr_un address;
  size_t length = strlen(path);
  int fd;

  /* On Linux, address.sun_path is NUL-padded not NUL-terminated. */
  if (length > sizeof(address.sun_path))
    errx(EXIT_FAILURE, "Socket path is too long to bind");
  length += offsetof(struct sockaddr_un, sun_path);

  address.sun_family = AF_UNIX;
  strncpy(address.sun_path, path, sizeof(address.sun_path));
  unlink(path);

  if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
    err(EXIT_FAILURE, "socket");
  fcntl(fd, F_SETFD, FD_CLOEXEC);
  fcntl(fd, F_SETFL, O_NONBLOCK);

  if (bind(fd, (struct sockaddr *) &address, length) < 0)
    err(EXIT_FAILURE, "bind");
  if (listen(fd, SOMAXCONN) < 0)
    err(EXIT_FAILURE, "listen");
  listen_add(fd);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x20c0
movq %rax, -0x80(%rbp)
cmpq $0x6c, -0x80(%rbp)
jbe 0x2ef6
movl $0x1, %edi
leaq 0x1288(%rip), %rsi      # 0x4177
movb $0x0, %al
callq 0x20e0
movq -0x80(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x80(%rbp)
movw $0x1, -0x76(%rbp)
leaq -0x76(%rbp), %rdi
addq $0x2, %rdi
movq -0x8(%rbp), %rsi
movl $0x6c, %edx
callq 0x2060
movq -0x8(%rbp), %rdi
callq 0x2050
movl $0x1, %esi
xorl %edx, %edx
movl %esi, %edi
callq 0x23d0
movl %eax, -0x84(%rbp)
cmpl $0x0, %eax
jge 0x2f53
movl $0x1, %edi
leaq 0x124b(%rip), %rsi      # 0x4197
movb $0x0, %al
callq 0x2230
movl -0x84(%rbp), %edi
movl $0x2, %esi
movl $0x1, %edx
movb $0x0, %al
callq 0x2090
movl -0x84(%rbp), %edi
movl $0x4, %esi
movl $0x800, %edx            # imm = 0x800
movb $0x0, %al
callq 0x2090
movl -0x84(%rbp), %edi
leaq -0x76(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x80(%rbp), %rax
movl %eax, %edx
movq -0x90(%rbp), %rsi
callq 0x22b0
cmpl $0x0, %eax
jge 0x2fbc
movl $0x1, %edi
leaq 0x11dd(%rip), %rsi      # 0x4192
movb $0x0, %al
callq 0x2230
movl -0x84(%rbp), %edi
movl $0x1000, %esi           # imm = 0x1000
callq 0x2270
cmpl $0x0, %eax
jge 0x2fe4
movl $0x1, %edi
leaq 0x11c1(%rip), %rsi      # 0x419e
movb $0x0, %al
callq 0x2230
movl -0x84(%rbp), %edi
callq 0x3d40
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]init/daemon.c
// Function: execute
static void execute(char **argv) {
  if (gid > 0 && setgid(gid) < 0)
    err(EXIT_FAILURE, "setgid");
  if (uid > 0 && setuid(uid) < 0)
    err(EXIT_FAILURE, "setuid");
  execvp(argv[0], argv);
  err(EXIT_FAILURE, "exec");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpl $0x0, 0x2959(%rip)      # 0x620c
jbe 0x38d8
movl 0x2951(%rip), %edi      # 0x620c
callq 0x22c0
cmpl $0x0, %eax
jge 0x38d8
movl $0x1, %edi
leaq 0xe2f(%rip), %rsi       # 0x4700
movb $0x0, %al
callq 0x2230
cmpl $0x0, 0x2929(%rip)      # 0x6208
jbe 0x3904
movl 0x2921(%rip), %edi      # 0x6208
callq 0x2360
cmpl $0x0, %eax
jge 0x3904
movl $0x1, %edi
leaq 0xe0a(%rip), %rsi       # 0x4707
movb $0x0, %al
callq 0x2230
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
callq 0x2310
movl $0x1, %edi
leaq 0x84a(%rip), %rsi       # 0x416a
movb $0x0, %al
callq 0x2230
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]init/daemon.c
// Function: supervise
static int supervise(char **argv, int restart) {
  int signal;
  pid_t child, command;
  time_t wait;

  do {
    switch (command = fork()) {
      case -1:
        err(EXIT_FAILURE, "fork");
      case 0:
        setsid(); /* Ignore errors but should always work after fork. */
        execute(argv);
    }

    wait = time(NULL) + 5;
    while (command)
      switch (signal = signal_get()) {
        case SIGCHLD:
          /* Reap every child, watching out for the command pid. */
          while ((child = reap(NULL)))
            if (child == command)
              command = 0;
          break;
        case SIGTERM:
          restart = 0;
          /* Fall through to the default behaviour. */
        case SIGHUP:
        case SIGINT:
        case SIGUSR1:
        case SIGUSR2:
          /* Pass signals on to our child process. */
          kill(command, signal);
          wait = 0;
      }

    /* Try to avoid restarting a crashing command in a tight loop. */
    if (restart && time(NULL) < wait)
      errx(EXIT_FAILURE, "Child died within 5 seconds: not restarting");
  } while (restart);

  return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
callq 0x23c0
movl %eax, -0x18(%rbp)
movl %eax, %ecx
movl %ecx, -0x24(%rbp)
subl $-0x1, %eax
je 0x3c0c
jmp 0x3c03
movl -0x24(%rbp), %eax
testl %eax, %eax
je 0x3c1f
jmp 0x3c2d
movl $0x1, %edi
leaq 0x4a2(%rip), %rsi       # 0x40ba
movb $0x0, %al
callq 0x2230
callq 0x2190
movq -0x8(%rbp), %rdi
callq 0x38a0
xorl %eax, %eax
movl %eax, %edi
callq 0x2220
addq $0x5, %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x18(%rbp)
je 0x3ccd
callq 0x3dd0
movl %eax, %ecx
movl %ecx, -0x10(%rbp)
movl %ecx, %eax
decl %eax
movl %ecx, -0x28(%rbp)
subl $0x2, %eax
jb 0x3cb5
jmp 0x3c60
movl -0x28(%rbp), %eax
subl $0xa, %eax
je 0x3cb5
jmp 0x3c6a
movl -0x28(%rbp), %eax
subl $0xc, %eax
je 0x3cb5
jmp 0x3c74
movl -0x28(%rbp), %eax
subl $0xf, %eax
je 0x3cae
jmp 0x3c7e
movl -0x28(%rbp), %eax
subl $0x11, %eax
jne 0x3cc8
jmp 0x3c88
jmp 0x3c8a
xorl %eax, %eax
movl %eax, %edi
callq 0x3e10
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
je 0x3cac
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jne 0x3caa
movl $0x0, -0x18(%rbp)
jmp 0x3c8a
jmp 0x3cc8
movl $0x0, -0xc(%rbp)
movl -0x18(%rbp), %edi
movl -0x10(%rbp), %esi
callq 0x2210
movq $0x0, -0x20(%rbp)
jmp 0x3c3e
cmpl $0x0, -0xc(%rbp)
je 0x3cf5
xorl %eax, %eax
movl %eax, %edi
callq 0x2220
cmpq -0x20(%rbp), %rax
jge 0x3cf5
movl $0x1, %edi
leaq 0xa20(%rip), %rsi       # 0x470e
movb $0x0, %al
callq 0x20e0
jmp 0x3cf7
cmpl $0x0, -0xc(%rbp)
jne 0x3bef
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]init/daemon.c
// Function: listen_add
static void listen_add(int fd) {
  if ((listeners & 15) == 0) {
    pollfd = realloc(pollfd, (listeners + 16) * sizeof(struct pollfd));
    if (pollfd == NULL)
      err(EXIT_FAILURE, "realloc");
  }
  pollfd[listeners++].fd = fd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movq 0x24ce(%rip), %rax      # 0x6220
andq $0xf, %rax
cmpq $0x0, %rax
jne 0x3d9d
movq 0x24e5(%rip), %rdi      # 0x6248
movq 0x24b6(%rip), %rsi      # 0x6220
addq $0x10, %rsi
shlq $0x3, %rsi
callq 0x2290
movq %rax, 0x24ca(%rip)      # 0x6248
cmpq $0x0, 0x24c2(%rip)      # 0x6248
jne 0x3d9b
movl $0x1, %edi
leaq 0x411(%rip), %rsi       # 0x41a5
movb $0x0, %al
callq 0x2230
jmp 0x3d9d
movl -0x4(%rbp), %edx
movq 0x24a1(%rip), %rax      # 0x6248
movq 0x2472(%rip), %rcx      # 0x6220
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x2464(%rip)      # 0x6220
movl %edx, (%rax,%rcx,8)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]init/daemon.c
// Function: signal_get
static int signal_get(void) {
  unsigned char signal = 0;
  while (read(signals[0], &signal, 1) < 0)
    if (errno != EINTR)
      break;
  return signal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb $0x0, -0x1(%rbp)
movl 0x2446(%rip), %edi      # 0x6228
leaq -0x1(%rbp), %rsi
movl $0x1, %edx
callq 0x21a0
cmpq $0x0, %rax
jge 0x3e04
callq 0x2040
cmpl $0x4, (%rax)
je 0x3e02
jmp 0x3e04
jmp 0x3ddc
movzbl -0x1(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/arachsys[P]init/daemon.c
// Function: reap
static pid_t reap(int *status) {
  pid_t child;

  while ((child = waitpid(-1, status, WNOHANG)) < 0)
    if (errno != EINTR)
      break;
  return child > 0 ? child : 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x22d0
movl %eax, -0xc(%rbp)
cmpl $0x0, %eax
jge 0x3e45
callq 0x2040
cmpl $0x4, (%rax)
je 0x3e43
jmp 0x3e45
jmp 0x3e1c
cmpl $0x0, -0xc(%rbp)
jle 0x3e53
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x3e5a
xorl %eax, %eax
movl %eax, -0x10(%rbp)
jmp 0x3e5a
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/antonblanchard[P]will-it-scale/tests/read3.c
// Function: testcase
void testcase(unsigned long long *iterations, unsigned long nr)
{
	char *buf;
	char tmpfile[] = "/tmp/willitscale.XXXXXX";
	int fd = mkostemp(tmpfile, O_DIRECT);
	char *p;

	buf = aligned_alloc(getpagesize(), FILESIZE);
	memset(buf, 0, FILESIZE);
	assert(fd >= 0);
	assert(write(fd, buf, FILESIZE) == FILESIZE);
	unlink(tmpfile);

	p = malloc(BUFLEN + getpagesize());
	p = (char *)(((unsigned long)p + getpagesize()-1) & ~(getpagesize()-1));

	while (1) {
		int ret = read(fd, p, BUFLEN);
		assert(ret >= 0);
		if (ret == 0)
			lseek(fd, 0, SEEK_SET);

		(*iterations)++;
	}
	free(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x1289(%rip), %rax      # 0x42f0
movq %rax, -0x30(%rbp)
movq 0x1286(%rip), %rax      # 0x42f8
movq %rax, -0x28(%rbp)
movq 0x1283(%rip), %rax      # 0x4300
movq %rax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
movl $0x4000, %esi           # imm = 0x4000
callq 0x2120
movl %eax, -0x34(%rbp)
callq 0x2270
movslq %eax, %rdi
movl $0x100000, %esi         # imm = 0x100000
callq 0x2290
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
xorl %esi, %esi
movl $0x100000, %edx         # imm = 0x100000
callq 0x2150
cmpl $0x0, -0x34(%rbp)
jl 0x30c0
jmp 0x30df
leaq 0x11ad(%rip), %rdi      # 0x4274
leaq 0x11ae(%rip), %rsi      # 0x427c
movl $0x16, %edx
leaq 0x11b0(%rip), %rcx      # 0x428a
callq 0x2140
movl -0x34(%rbp), %edi
movq -0x18(%rbp), %rsi
movl $0x100000, %edx         # imm = 0x100000
callq 0x20c0
cmpq $0x100000, %rax         # imm = 0x100000
jne 0x30fa
jmp 0x3119
leaq 0x11bc(%rip), %rdi      # 0x42bd
leaq 0x1174(%rip), %rsi      # 0x427c
movl $0x17, %edx
leaq 0x1176(%rip), %rcx      # 0x428a
callq 0x2140
leaq -0x30(%rbp), %rdi
callq 0x2080
callq 0x2270
movl %eax, -0x5c(%rbp)
callq 0x2270
movl %eax, %ecx
movl -0x5c(%rbp), %eax
addl %ecx, %eax
movslq %eax, %rdi
callq 0x21e0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x58(%rbp)
callq 0x2270
movl %eax, %ecx
movq -0x58(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
subq $0x1, %rax
movq %rax, -0x50(%rbp)
callq 0x2270
movl %eax, %ecx
movq -0x50(%rbp), %rax
subl $0x1, %ecx
xorl $-0x1, %ecx
movslq %ecx, %rcx
andq %rcx, %rax
movq %rax, -0x40(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x6c(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x68(%rbp)
callq 0x2270
movl -0x6c(%rbp), %edi
movq -0x68(%rbp), %rsi
movslq %eax, %rdx
callq 0x2180
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x44(%rbp)
jl 0x31ab
jmp 0x31ca
leaq 0x1130(%rip), %rdi      # 0x42e2
leaq 0x10c3(%rip), %rsi      # 0x427c
movl $0x1f, %edx
leaq 0x10c5(%rip), %rcx      # 0x428a
callq 0x2140
cmpl $0x0, -0x44(%rbp)
jne 0x31de
movl -0x34(%rbp), %edi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2130
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x317e
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/heap.c
// Function: CreateHeap
Heap *
CreateHeap( uint chunk_size, uint chnk_hunk_ratio )
{	Heap    *heap;
	uint     unit;

	heap = (Heap *) e_malloc(sizeof(Heap));

	unit  = max(chunk_size, MIN_SZE);
	if (unit % ALGN_SZE != 0)
		unit += ALGN_SZE - (unit % ALGN_SZE);
	heap->chnk_sze = unit;

	if (chnk_hunk_ratio)
		heap->ch_ratio = chnk_hunk_ratio; 
	else
		heap->ch_ratio = DEFLT_RATIO;

	heap->num_alloc = 0; 
	heap->num_free  = 0; 
	heap->num_hunks = 0; 

	heap->next_chunk = 0;
	heap->hunk_array_sze = MIN_HUNK_ARRY;
	heap->free_list = (void *) NULL;

	heap->hunks = (void **) e_malloc(MIN_HUNK_ARRY * PNTR_SZE);

	return(heap);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x30, %edi
callq 0x4a70
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
cmpq $0x8, %rax
jb 0x43ce
movl -0x4(%rbp), %eax
movq %rax, -0x20(%rbp)
jmp 0x43d9
movl $0x8, %eax
movq %rax, -0x20(%rbp)
jmp 0x43d9
movq -0x20(%rbp), %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x4405
movl -0x14(%rbp), %eax
andq $0x7, %rax
movl $0x8, %ecx
subq %rax, %rcx
movl -0x14(%rbp), %eax
addq %rcx, %rax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x8(%rbp)
je 0x4420
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x442b
movq -0x10(%rbp), %rax
movl $0x100, 0x4(%rax)       # imm = 0x100
movq -0x10(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x8, 0x14(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movl $0x40, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/heap.c
// Function: check_chunks
int
check_chunks(void *y)
{	FC *x;

	for (x = free_chunks; x; x = x->fc.nxt)
	{	if (x < (FC *) 1000)
		{	printf("memory corrupted \n");
			abort();
		}
		if (x == y)
		{	printf("double release %p\n", x);
		//	abort();
			return 0;
		}
	}
	return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq 0x416a5(%rip), %rax     # 0x45b48
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4500
movl $0x3e8, %eax            # imm = 0x3E8
cmpq %rax, -0x18(%rbp)
jae 0x44cc
leaq 0x2eb44(%rip), %rdi     # 0x33004
movb $0x0, %al
callq 0x4120
callq 0x4050
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jne 0x44f1
movq -0x18(%rbp), %rsi
leaq 0x2eb36(%rip), %rdi     # 0x33017
movb $0x0, %al
callq 0x4120
movl $0x0, -0x4(%rbp)
jmp 0x4507
jmp 0x44f3
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x44a7
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/heap.c
// Function: rel_chunk
void
rel_chunk(void *x)
{	FC *y;
#if 1
	if (!check_chunks(x)) exit(1);
#endif
	memset(x, 0, MX_NODE_SZE);
	y = (FC *) x;
	y->fc.nxt = free_chunks;
	free_chunks = y;
	gh_sz++;
if (0) printf("++ %p	-- %d\n", x, gh_sz);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4490
cmpl $0x0, %eax
jne 0x4534
movl $0x1, %edi
callq 0x4270
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x50, %edx
callq 0x4160
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x415f5(%rip), %rcx     # 0x45b48
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x415e3(%rip)     # 0x45b48
movl 0x415e5(%rip), %eax     # 0x45b50
addl $0x1, %eax
movl %eax, 0x415dc(%rip)     # 0x45b50
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/heap.c
// Function: DestroyHeap
void
DestroyHeap( Heap *heap )
{	int j, k;
	char *v;

	if (heap)
	{	for (j = 0; j < (int) heap->num_hunks; j++)
		for (k = 0; k < (int) heap->ch_ratio; k++)
		{	v = (char *) heap->hunks[j] + (k * (MX_NODE_SZE));
			rel_chunk((void *) v);
		}
		memset(heap, 0, sizeof(Heap));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4609
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x45f9
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x45ec
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
imulq $0x50, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4510
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x45ad
jmp 0x45ee
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x459a
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x4160
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/nmetab.c
// Function: calc_hash
unsigned int
calc_hash(char *str)	/* pjw's hash */
{	unsigned int hsh = 0, i;

	while (*str)
	{	hsh = (hsh << ONE_EIGHTH) + *str++;
		if ((i = hsh & HIGH_BITS) != 0)
			hsh = (hsh ^ ( i >> THREE_QUARTERS)) & ~HIGH_BITS;
	}
	return hsh;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x48fa
movl -0xc(%rbp), %eax
shll $0x4, %eax
movq -0x8(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x8(%rbp)
movsbl (%rcx), %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
andl $0xf0000000, %eax       # imm = 0xF0000000
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
je 0x48f8
movl -0xc(%rbp), %eax
movl -0x10(%rbp), %ecx
shrl $0x18, %ecx
xorl %ecx, %eax
andl $0xfffffff, %eax        # imm = 0xFFFFFFF
movl %eax, -0xc(%rbp)
jmp 0x48af
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/nmetab.c
// Function: nmelook
str_t *
nmelook(char *sym, int len)
{	HashItem *hptr;
	unsigned int hsh;
	int bckt;

	hsh  = calc_hash(sym);
	bckt = hsh % MAX_HASH_BCKTS;

	for (hptr=NmeTab[bckt]; hptr; hptr=hptr->next)
	{	if ((hptr->sym.hash == hsh)
		&&  (strcmp(sym, hptr->sym.str) == 0))
			return(&(hptr->sym));
	} 

	hptr = (HashItem *) e_malloc(HASH_ITEM_SZE);

	if (!len) len = strlen(sym);

	hptr->sym.str = e_malloc(len+1);
	hptr->sym.hash = hsh;
	strncpy(hptr->sym.str, sym, len);

	hptr->next = NmeTab[bckt];
	NmeTab[bckt] = hptr;

	return(&(hptr->sym));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x48a0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x3ff, %ecx            # imm = 0x3FF
xorl %edx, %edx
divl %ecx
movl %edx, -0x28(%rbp)
movslq -0x28(%rbp), %rcx
leaq 0x411eb(%rip), %rax     # 0x45b60
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x49c2
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x49b2
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x49b2
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a48
jmp 0x49b4
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x497d
movl $0x18, %edi
callq 0x4a70
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x49e2
movq -0x10(%rbp), %rdi
callq 0x40f0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %edi
addl $0x1, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
movslq -0x14(%rbp), %rdx
callq 0x4080
movslq -0x28(%rbp), %rcx
leaq 0x4113f(%rip), %rax     # 0x45b60
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rdx
movslq -0x28(%rbp), %rcx
leaq 0x41124(%rip), %rax     # 0x45b60
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: e_malloc
void *
e_malloc(uint m)
{	char *tmp;
	long n = m + ALGN;	/* for possible alignment */

	assert(m != 0);

	tmp = not_malloc(n);

	if (((ulong) tmp)&(ALGN-1))
	{	tmp += (long) (ALGN  - (((ulong) tmp)&(ALGN-1)));
		memwaste += ALGN;
	} else
	{	left += ALGN;	/* return the extra bytes */
		have -= ALGN;
	}

	memcnt += m;

	return (void *) tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x4a8e
jmp 0x4aad
leaq 0x2e5a7(%rip), %rdi     # 0x3303c
leaq 0x2e5a7(%rip), %rsi     # 0x33043
movl $0x54, %edx
leaq 0x2e5a4(%rip), %rcx     # 0x3304c
callq 0x4140
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0x4b40
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
je 0x4af6
movq -0x10(%rbp), %rcx
andq $0x7, %rcx
movl $0x8, %eax
subq %rcx, %rax
addq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x4306f(%rip), %rax     # 0x47b58
addq $0x8, %rax
movq %rax, 0x43064(%rip)     # 0x47b58
jmp 0x4b1a
movq 0x43063(%rip), %rax     # 0x47b60
addq $0x8, %rax
movq %rax, 0x43058(%rip)     # 0x47b60
movq 0x43059(%rip), %rax     # 0x47b68
addq $-0x8, %rax
movq %rax, 0x4304e(%rip)     # 0x47b68
movl -0x4(%rbp), %eax
addq 0x4304c(%rip), %rax     # 0x47b70
movq %rax, 0x43045(%rip)     # 0x47b70
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: not_malloc
static char *
not_malloc(uint n)
{	char *tmp;

	if (left < n)
	{	int grow = (n < CHUNK) ? CHUNK : n;
		have = (char *) malloc(grow);
		if (!have)
		{	fprintf(stderr, "%s: out of memory\n", progname);
			exit(1);
		}
		memset(have, 0, grow);
		left = grow;
	}
	tmp = have;
	have += n;
	left -= n;

	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq 0x4300e(%rip), %rax     # 0x47b60
movl -0x4(%rbp), %ecx
cmpq %rcx, %rax
jge 0x4be0
cmpl $0x100000, -0x4(%rbp)   # imm = 0x100000
jae 0x4b71
movl $0x100000, %eax         # imm = 0x100000
movl %eax, -0x18(%rbp)
jmp 0x4b77
movl -0x4(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
callq 0x41e0
movq %rax, 0x42fdb(%rip)     # 0x47b68
cmpq $0x0, 0x42fd3(%rip)     # 0x47b68
jne 0x4bc3
movq 0x4045a(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
leaq 0x405c8(%rip), %rax     # 0x45170
movq (%rax), %rdx
leaq 0x2e5fd(%rip), %rsi     # 0x331af
movb $0x0, %al
callq 0x4190
movl $0x1, %edi
callq 0x4270
movq 0x42f9e(%rip), %rdi     # 0x47b68
movslq -0x14(%rbp), %rdx
xorl %esi, %esi
callq 0x4160
movslq -0x14(%rbp), %rax
movq %rax, 0x42f80(%rip)     # 0x47b60
movq 0x42f81(%rip), %rax     # 0x47b68
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq 0x42f73(%rip), %rax     # 0x47b68
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, 0x42f67(%rip)     # 0x47b68
movl -0x4(%rbp), %eax
movl %eax, %ecx
movq 0x42f53(%rip), %rax     # 0x47b60
subq %rcx, %rax
movq %rax, 0x42f49(%rip)     # 0x47b60
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: new_symentry
symentry_t *
new_symentry(void)
{	symentry_t *that;

	if (fses)
	{	that = fses;
		fses = fses->next;
		memset(that, 0, sizeof(symentry_t));
	} else
		that = (symentry_t *) e_malloc(sizeof(symentry_t));

	that->ln = current_linenumber();	/* gjh */
	that->fn = current_filename();		/* gjh */
	return that;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x42f38(%rip)     # 0x47b78
je 0x4c71
movq 0x42f2f(%rip), %rax     # 0x47b78
movq %rax, -0x8(%rbp)
movq 0x42f24(%rip), %rax     # 0x47b78
movq 0x38(%rax), %rax
movq %rax, 0x42f19(%rip)     # 0x47b78
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x40, %edx
callq 0x4160
jmp 0x4c7f
movl $0x40, %edi
callq 0x4a70
movq %rax, -0x8(%rbp)
callq 0x2d0d0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
callq 0x2d100
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: mk_g
static symentry_t*
mk_g(str_t *sym, treenode *tn, int knd)	/* mk_generic */
{	symentry_t *that;

	that = new_symentry();

	that->kind = knd;
	that->nme  = sym;
	that->node = tn;
	that->nes = (scopetab_t *) 0;
	that->decl_level = 0;
	that->container = NULL;

	return that;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
callq 0x4c30
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movw $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: new_hashtab
hashtab_t *
new_hashtab(void)
{	hashtab_t *that;

	if (freehtab)
	{	that = freehtab;
		freehtab = that->nxt;
		if (that->tsize != INIT_HASHTAB_SIZE)
		{	fprintf(stderr, "cannot happen nht\n");
			exit(1);
		}
		memset(that->tab, 0, sizeof(symentry_t*) * that->tsize);
	} else
	{	that = (hashtab_t *) e_malloc(sizeof(hashtab_t));
		that->tsize = INIT_HASHTAB_SIZE;
		that->tab = (symentry_t **) e_malloc( sizeof(symentry_t*) * that->tsize );
	}
	that->nent = 0;

	return that;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpq $0x0, 0x42cc0(%rip)     # 0x47b80
je 0x4f23
movq 0x42cb7(%rip), %rax     # 0x47b80
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x42ca4(%rip)     # 0x47b80
movq -0x8(%rbp), %rax
cmpl $0x11, (%rax)
je 0x4f07
movq 0x4010c(%rip), %rax     # 0x44ff8
movq (%rax), %rdi
leaq 0x2e16b(%rip), %rsi     # 0x33061
movb $0x0, %al
callq 0x4190
movl $0x1, %edi
callq 0x4270
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq (%rax), %rdx
shlq $0x3, %rdx
xorl %esi, %esi
callq 0x4160
jmp 0x4f58
movl $0x18, %edi
callq 0x4a70
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x11, (%rax)
movq -0x8(%rbp), %rax
movslq (%rax), %rax
shlq $0x3, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: hashtab_lookup
symentry_t *
hashtab_lookup(hashtab_t *that, str_t *nme)
{	symentry_t *curr;
	int j;
  
	if (!nme || !that) return NULL;

	j = nme->hash % that->tsize;
	for (curr = that->tab[j]; curr; curr = curr->next)
		if (curr->nme
		&&  strcmp(curr->nme->str, nme->str) == 0) 
			return curr;

	return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x4f8e
cmpq $0x0, -0x10(%rbp)
jne 0x4f98
movq $0x0, -0x8(%rbp)
jmp 0x500f
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl (%rcx)
movl %edx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5007
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4ff7
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x4ff7
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x500f
jmp 0x4ff9
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x4fbd
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: hashtab_insert
symentry_t*
hashtab_insert(hashtab_t *that, symentry_t *entry)
{	int j;
	symentry_t *ret;

	if ((ret = hashtab_lookup(that, entry->nme)))
	{
		return ret;
	}

	if (0) printf("insert in hashtab %p -- %s\n",
		that, entry->nme->str);

	j = entry->nme->hash % that->tsize;
	entry->next = that->tab[j];
	that->tab[j] = entry;

	return entry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x4f70
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x5055
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x509e
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
xorl %edx, %edx
divl (%rcx)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rdx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: show_hashtab
void
show_hashtab(hashtab_t *that, int tabs, FILE *fp)
{	symentry_t *t;
	int j;

	for (j = 0; j < that->tsize; j++)
	for (t = that->tab[j]; t; t = t->next)
		show_symentry(t, tabs, fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x511b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x510e
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rdx
callq 0x5130
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x50e9
jmp 0x5110
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x50ca
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: show_symentry
static void
show_symentry(symentry_t *that, int tabs, FILE *fp)
{
	dotabs(tabs+1, fp);
	fprintf(fp, "%s", that->nme->str);
	print_frag(that->node, fp);
	if (that->node
	&&  that->node->hdr.type != TN_FUNC_DEF
	&& !that->used)
		fprintf(fp, " unused");
	fprintf(fp, "\n");
#if 0
	if (that->container)
	{	fputs("Container:\n", fp);
		print_frag(that->container, fp);
	}
#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl -0xc(%rbp), %edi
addl $0x1, %edi
movq -0x18(%rbp), %rsi
callq 0x6c40
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x30658(%rip), %rsi     # 0x357c1
movb $0x0, %al
callq 0x4190
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x6c90
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x51b6
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
cmpl $0x1, 0x1c(%rax)
je 0x51b6
movq -0x8(%rbp), %rax
cmpb $0x0, 0x22(%rax)
jne 0x51b6
movq -0x18(%rbp), %rdi
leaq 0x2e013(%rip), %rsi     # 0x331c2
movb $0x0, %al
callq 0x4190
movq -0x18(%rbp), %rdi
leaq 0x30896(%rip), %rsi     # 0x35a57
movb $0x0, %al
callq 0x4190
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: getscoop
scopetab_t **
getscoop(int n)
{	Scoop *s, *prevs = (Scoop *) 0;
	scopetab_t **g = (scopetab_t **) 0;

	for (s = scoop; s; prevs = s, s = s->nxt)
		if (s->n == n)
		{	g = s->g;
			if (!prevs)
				scoop = s->nxt;
			else
				prevs->nxt = s->nxt;
				
			s->n = 0;
			s->g = (scopetab_t **) 0;
			s->nxt = freescoop;
			freescoop = s;
			break;
		}
	if (!g)
		g = (scopetab_t **) e_malloc( sizeof(scopetab_t*) * n );

	return g;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq $0x0, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq 0x42996(%rip), %rax     # 0x47b88
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x528d
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
jne 0x5272
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5230
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x4295a(%rip)     # 0x47b88
jmp 0x5240
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq 0x42933(%rip), %rcx     # 0x47b90
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, 0x42920(%rip)     # 0x47b90
jmp 0x528d
jmp 0x5274
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x51f6
cmpq $0x0, -0x20(%rbp)
jne 0x52a7
movslq -0x4(%rbp), %rax
shlq $0x3, %rax
movl %eax, %edi
callq 0x4a70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: new_scopetab
scopetab_t*
new_scopetab(scopetab_t *mom)
{	scopetab_t *that;

	if (freestab)
	{	that = freestab;
		freestab = that->parent;
		memset(that, 0, sizeof(scopetab_t));
	} else
		that = (scopetab_t *) e_malloc(sizeof(scopetab_t));

	if (0)
	printf("new scope tab %p, level %d\n", that, mom?mom->level+1:EXTERN_SCOPE);

	that->size = INIT_CHILD_SIZE;

	that->children = getscoop(that->size);

	that->parent = mom;
	if (mom)
		that->level = mom->level + 1;
	else
		that->level = EXTERN_SCOPE;

	return that;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, 0x428c4(%rip)     # 0x47b98
je 0x5302
movq 0x428bb(%rip), %rax     # 0x47b98
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x428a8(%rip)     # 0x47b98
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movl $0x38, %edx
callq 0x4160
jmp 0x5310
movl $0x38, %edi
callq 0x4a70
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x4, 0x2c(%rax)
movq -0x10(%rbp), %rax
movl 0x2c(%rax), %edi
callq 0x51d0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, -0x8(%rbp)
je 0x5358
movq -0x8(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
jmp 0x5363
movq -0x10(%rbp), %rax
movl $0x1, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: scopetab_insert
symentry_t *
scopetab_insert(scopetab_t *that, symentry_t *entry)
{
#if DBG
	int i;
	printf("	Inserting '%s' at level %d -- owner %s (%d) -- nchild %d\n",
		entry->nme->str, that->level, that->owner, that->owner_t, that->nchild);
	printf("	scopetab: %u; ", that);
	for (i = 0; i < that->nchild; i++)
		printf("%u, ", that->children[i]);
	printf("\n");
	
#endif
	if (!that->htab)
	{	that->htab = new_hashtab();
		if (!that->htab)
			return 0;
	}

	return hashtab_insert(that->htab,entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5522
callq 0x4eb0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x5520
movq $0x0, -0x8(%rbp)
jmp 0x5537
jmp 0x5522
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x5020
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: find_glob_symentry
symentry_t *
find_glob_symentry(scopetab_t *that, char *s)
{	int j;
	symentry_t *fnd = (symentry_t *) 0;

	if (that->htab
	&&  that->level <= 2)
 		fnd = find_hashtab(that->htab, s);

	if (!fnd)
	for (j = 0; j < that->nchild; j++)
	{	if ((fnd = find_glob_symentry(that->children[j], s)) != NULL)
		{	break;
	}	}

	return fnd;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5592
movq -0x8(%rbp), %rax
cmpl $0x2, 0x4(%rax)
jg 0x5592
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x55f0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x55e0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x55de
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x5550
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x55d1
jmp 0x55de
jmp 0x55d3
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x55a0
jmp 0x55e0
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: find_hashtab
static symentry_t *
find_hashtab(hashtab_t *that, char *s)
{	symentry_t *list;
	int j;

	for (j = 0; j < that->tsize; j++)
	for (list = that->tab[j]; list; list = list->next)
		if (list->nme
		&&  strcmp(s, list->nme->str) == 0)
			return list;

	return (symentry_t *) 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x5679
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x566c
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x565c
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x4180
cmpl $0x0, %eax
jne 0x565c
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x5681
jmp 0x565e
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5626
jmp 0x566e
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5607
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: remove_struct
void
remove_struct(char *s)
{	char *p, *q, *x;
	int cnt, m = 0, n = strlen(s);

	p = strstr(s, "struct");

	if (p)	/* check if struct is unnamed */
	{	x = p + strlen("struct");
		while (*x == ' ' || *x == '\t')
		{	x++;
		}
		if (*x == '{')	/* unnamed */
		{	return;
	}	}

	cnt = 0;
	for (q = p; q-p < n; q++)
	{	switch (*q) {
		case '{': cnt++; m++; break;
		case '}': cnt--; break;
		default: break;
		}
		if (m > 0)
		{	*q = ' ';
			if (cnt == 0)
			{	break;
	}	}	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x40f0
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2d635(%rip), %rsi     # 0x330ff
callq 0x4280
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5b31
movq -0x10(%rbp), %rax
addq $0x6, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %ecx
movb $0x1, %al
cmpl $0x20, %ecx
movb %al, -0x2d(%rbp)
je 0x5b07
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x9, %eax
sete %al
movb %al, -0x2d(%rbp)
movb -0x2d(%rbp), %al
testb $0x1, %al
jne 0x5b10
jmp 0x5b1e
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x5ae6
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x7b, %eax
jne 0x5b2f
jmp 0x5bb7
jmp 0x5b31
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
subq %rcx, %rax
movslq -0x2c(%rbp), %rcx
cmpq %rcx, %rax
jge 0x5bb7
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x34(%rbp)
subl $0x7b, %eax
je 0x5b6f
jmp 0x5b65
movl -0x34(%rbp), %eax
subl $0x7d, %eax
je 0x5b83
jmp 0x5b8e
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x5b90
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x5b90
jmp 0x5b90
cmpl $0x0, -0x28(%rbp)
jle 0x5ba7
movq -0x18(%rbp), %rax
movb $0x20, (%rax)
cmpl $0x0, -0x24(%rbp)
jne 0x5ba5
jmp 0x5bb7
jmp 0x5ba7
jmp 0x5ba9
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x5b40
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: find_typedefs
void
find_typedefs(scopetab_t *that, FILE *fp)
{	scopetab_t *z;
	symentry_t *t;
	char *s;
	int j;

	if (that->htab)
	{	for (z = that; z; z = z->parent)
		for (j = 0; j < that->htab->tsize; j++)
		for (t = that->htab->tab[j]; t; t = t->next)
		{	if (t->kind == TYPEDEF_ENTRY
			&&  t->generated == 0)
			{	s = nx_stmnt(t->node);
				if (strstr(s, "struct"))
				{	t->generated = 1;
					remove_newlines(s);
					remove_struct(s);	/* if named, it will be declared separately below */
					fprintf(fp, "c_decl { %s } /* find_typedefs %p, %p */\n", s, z, t);
	}	}	}	}

	for (j = 0; j < that->nchild; j++)
		find_typedefs(that->children[j], fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x5cde
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x5cdc
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
jge 0x5cc9
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x5cb9
movq -0x20(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x5ca6
movq -0x20(%rbp), %rax
movsbl 0x23(%rax), %eax
cmpl $0x0, %eax
jne 0x5ca6
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0xc890
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x2d49e(%rip), %rsi     # 0x330ff
callq 0x4280
cmpq $0x0, %rax
je 0x5ca4
movq -0x20(%rbp), %rax
movb $0x1, 0x23(%rax)
movq -0x28(%rbp), %rdi
callq 0x5d20
movq -0x28(%rbp), %rdi
callq 0x5aa0
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %r8
leaq 0x2d469(%rip), %rsi     # 0x33106
movb $0x0, %al
callq 0x4190
jmp 0x5ca6
jmp 0x5ca8
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x5c24
jmp 0x5cbb
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5bf9
jmp 0x5ccb
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x5be7
jmp 0x5cde
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x5d15
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rsi
callq 0x5bc0
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5ce5
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nimble-code[P]Modex/Src/symtab.c
// Function: remove_newlines
static void
remove_newlines(char *s)
{	char *u;
	for (;;)
	{	u = strstr(s, "\\n");
		if (u) { *u++ = ' '; *u = ' '; }
		else { break; }
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x2d49d(%rip), %rsi     # 0x331d4
callq 0x4280
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x5d62
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb $0x20, (%rax)
movq -0x10(%rbp), %rax
movb $0x20, (%rax)
jmp 0x5d64
jmp 0x5d66
jmp 0x5d2c
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)