LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ddrown[P]pretend-ntp/ntp_msg.c
// Function: ntp_request
void ntp_request(struct ntp_msg *bufs) {
  struct timespec t;

  memset(bufs, 0, sizeof(*bufs));
  bufs->version = NTP_VERS_4;
  bufs->mode = NTP_MODE_CLIENT;
  clock_gettime(CLOCK_REALTIME, &t);
  bufs->trans_time = unixtime_to_ntp_s(t.tv_sec);
  bufs->trans_time_fb = ns_to_ntp_frac(t.tv_nsec);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x1090
movq -0x8(%rbp), %rax
movb (%rax), %cl
andb $-0x39, %cl
orb $0x20, %cl
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movb (%rax), %cl
andb $-0x8, %cl
orb $0x3, %cl
movb %cl, (%rax)
xorl %edi, %edi
leaq -0x18(%rbp), %rsi
callq 0x1050
movq -0x18(%rbp), %rax
movl %eax, %edi
callq 0x1970
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rax
movl %eax, %edi
callq 0x19a0
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ddrown[P]pretend-ntp/ntp_msg.c
// Function: ntp_xchange
int ntp_xchange(int sock, struct ntp_msg *bufs, const struct sockaddr *addr, struct ntptimes *t, struct msghdr *msgs, int timeout_ms) {
  int status[6];
  struct iovec iovecs;
  struct pollfd readfd;

  iovecs.iov_base     = bufs;
  iovecs.iov_len      = sizeof(*bufs);
  msgs->msg_iov        = &iovecs;
  msgs->msg_iovlen     = 1;

  readfd.fd = sock;
  readfd.events = POLLIN;

  status[0] = clock_gettime(CLOCK_REALTIME, &t->before_sendto);
  status[1] = sendto(sock, bufs, sizeof(*bufs), 0, addr, sizeof(*addr));
  status[2] = clock_gettime(CLOCK_REALTIME, &t->after_sendto);
  status[3] = poll(&readfd, 1, timeout_ms);
  status[4] = clock_gettime(CLOCK_REALTIME, &t->after_recvmsg);
  status[5] = recvmsg(sock, msgs, MSG_DONTWAIT);
  if(status[5] < 0) {
    if(errno == EAGAIN) {
      return 0;
    }
    perror_exit("recvmsg");
  }
  if(status[4] != 0) {
    perror_exit("clock_gettime #3");
  }
  if(status[3] < 0) {
    perror_exit("poll");
  }
  if(status[2] != 0) {
    perror_exit("clock_gettime #2");
  }
  if(status[1] < 0) {
    perror_exit("sendto");
  }
  if(status[0] != 0) {
    perror_exit("clock_gettime #1");
  }

  return status[5];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0x30, -0x58(%rbp)
movq -0x28(%rbp), %rax
leaq -0x60(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq $0x1, 0x18(%rax)
movl -0x8(%rbp), %eax
movl %eax, -0x68(%rbp)
movw $0x1, -0x64(%rbp)
movq -0x20(%rbp), %rsi
xorl %edi, %edi
callq 0x1050
movl %eax, -0x50(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %r8
movl $0x30, %edx
xorl %ecx, %ecx
movl $0x10, %r9d
callq 0x10a0
movl %eax, -0x4c(%rbp)
movq -0x20(%rbp), %rsi
addq $0x10, %rsi
xorl %edi, %edi
callq 0x1050
movl %eax, -0x48(%rbp)
movl -0x2c(%rbp), %edx
leaq -0x68(%rbp), %rdi
movl $0x1, %esi
callq 0x1110
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
xorl %edi, %edi
callq 0x1050
movl %eax, -0x40(%rbp)
movl -0x8(%rbp), %edi
movq -0x28(%rbp), %rsi
movl $0x40, %edx
callq 0x10f0
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jge 0x2002
callq 0x1030
cmpl $0xb, (%rax)
jne 0x1ff6
movl $0x0, -0x4(%rbp)
jmp 0x2062
leaq 0x12af(%rip), %rdi      # 0x32ac
callq 0x21f0
cmpl $0x0, -0x40(%rbp)
je 0x2014
leaq 0x12a5(%rip), %rdi      # 0x32b4
callq 0x21f0
cmpl $0x0, -0x44(%rbp)
jge 0x2026
leaq 0x12a4(%rip), %rdi      # 0x32c5
callq 0x21f0
cmpl $0x0, -0x48(%rbp)
je 0x2038
leaq 0x1297(%rip), %rdi      # 0x32ca
callq 0x21f0
cmpl $0x0, -0x4c(%rbp)
jge 0x204a
leaq 0x1296(%rip), %rdi      # 0x32db
callq 0x21f0
cmpl $0x0, -0x50(%rbp)
je 0x205c
leaq 0x128b(%rip), %rdi      # 0x32e2
callq 0x21f0
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ddrown[P]pretend-ntp/timestamp.c
// Function: diff_ts
void diff_ts(const struct timespec *t1, const struct timespec *t2, struct timespec *diff) {
  diff->tv_sec = t1->tv_sec - t2->tv_sec;
  diff->tv_nsec = t1->tv_nsec - t2->tv_nsec;
  if(diff->tv_nsec < -1000000000 || (diff->tv_nsec < 0 && diff->tv_sec > 0)) {
    diff->tv_sec--;
    diff->tv_nsec += 1000000000;
  }
  if(diff->tv_nsec > 0 && diff->tv_sec < 0) {
    diff->tv_sec++;
    diff->tv_nsec -= 1000000000;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x10(%rbp), %rax
subq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
subq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $-0x3b9aca00, 0x8(%rax) # imm = 0xC4653600
jl 0x2100
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jge 0x2121
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jle 0x2121
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x3b9aca00, %rcx       # imm = 0x3B9ACA00
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jle 0x2157
movq -0x18(%rbp), %rax
cmpq $0x0, (%rax)
jge 0x2157
movq -0x18(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
subq $0x3b9aca00, %rcx       # imm = 0x3B9ACA00
movq %rcx, 0x8(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ddrown[P]pretend-ntp/timestamp.c
// Function: print_diff_ts
void print_diff_ts(const struct timespec *t1, const struct timespec *t2) {
  struct timespec diff;

  diff_ts(t1, t2, &diff);

  if(diff.tv_nsec < 0 && diff.tv_sec == 0) {
    printf("-0.%09ld", diff.tv_nsec*-1);
  } else if(diff.tv_nsec < 0) {
    printf("%ld.%09ld", diff.tv_sec, diff.tv_nsec*-1);
  } else {
    printf("%ld.%09ld", diff.tv_sec, diff.tv_nsec);
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x20a0
cmpq $0x0, -0x18(%rbp)
jge 0x21a4
cmpq $0x0, -0x20(%rbp)
jne 0x21a4
imulq $-0x1, -0x18(%rbp), %rsi
leaq 0x1162(%rip), %rdi      # 0x32fd
movb $0x0, %al
callq 0x1070
jmp 0x21dc
cmpq $0x0, -0x18(%rbp)
jge 0x21c4
movq -0x20(%rbp), %rsi
imulq $-0x1, -0x18(%rbp), %rdx
leaq 0x1138(%rip), %rdi      # 0x32f3
movb $0x0, %al
callq 0x1070
jmp 0x21da
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x1120(%rip), %rdi      # 0x32f3
movb $0x0, %al
callq 0x1070
jmp 0x21dc
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/generic32lc/encrypt.c
// Function: crypto_aead_encrypt
int crypto_aead_encrypt(
    unsigned char *c,unsigned long long *clen,
    const unsigned char *m,unsigned long long mlen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *nsec,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    RiverKeyak_Instance instance;

    RiverKeyak_Initialize( &instance, k, 16, npub, 58, 0, 0, 0, 0 );
    RiverKeyak_Wrap( &instance, m, c, (size_t)mlen, ad, (size_t)adlen, c+mlen, 0, 0 );
    *clen = mlen + 16;
    return 0;
}

// Assembly:
subq $0xc8, %rsp
movq 0xe0(%rsp), %rax
movq 0xd8(%rsp), %rax
movq 0xd0(%rsp), %rax
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movq %r8, 0xa0(%rsp)
movq %r9, 0x98(%rsp)
movq 0xe0(%rsp), %rsi
movq 0xd8(%rsp), %rcx
leaq 0x24(%rsp), %rdi
movl $0x10, %edx
movl $0x3a, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x5500
movq 0xb0(%rsp), %rsi
movq 0xc0(%rsp), %rdx
movq 0xa8(%rsp), %rcx
movq 0xa0(%rsp), %r8
movq 0x98(%rsp), %r9
movq 0xc0(%rsp), %rax
addq 0xa8(%rsp), %rax
leaq 0x24(%rsp), %rdi
xorl %r10d, %r10d
movq %rax, (%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x5630
movq 0xa8(%rsp), %rcx
addq $0x10, %rcx
movq 0xb8(%rsp), %rax
movq %rcx, (%rax)
xorl %eax, %eax
addq $0xc8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/riverkeyakv2/generic32lc/encrypt.c
// Function: crypto_aead_decrypt
int crypto_aead_decrypt(
    unsigned char *m,unsigned long long *mlen,
    unsigned char *nsec,
    const unsigned char *c,unsigned long long clen,
    const unsigned char *ad,unsigned long long adlen,
    const unsigned char *npub,
    const unsigned char *k
    )
{
    RiverKeyak_Instance instance;
    unsigned long long mlen_;

    if (clen < 16)
        return -1;
    RiverKeyak_Initialize( &instance, k, 16, npub, 58, 0, 0, 1, 0 );
    mlen_ = clen - 16;
    *mlen = mlen_;
    if ( RiverKeyak_Wrap( &instance, c, m, (size_t)mlen_, ad, (size_t)adlen, (unsigned char *)c+mlen_, 1, 0 ) == 1 )
        return 0;
    return -1;
}

// Assembly:
subq $0xd8, %rsp
movq 0xf0(%rsp), %rax
movq 0xe8(%rsp), %rax
movq 0xe0(%rsp), %rax
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq %rdx, 0xb8(%rsp)
movq %rcx, 0xb0(%rsp)
movq %r8, 0xa8(%rsp)
movq %r9, 0xa0(%rsp)
cmpq $0x10, 0xa8(%rsp)
jae 0x1b8ba
movl $0xffffffff, 0xd4(%rsp) # imm = 0xFFFFFFFF
jmp 0x1b98d
movq 0xf0(%rsp), %rsi
movq 0xe8(%rsp), %rcx
leaq 0x2c(%rsp), %rdi
movl $0x10, %edx
movl $0x3a, %r8d
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x5500
movq 0xa8(%rsp), %rax
subq $0x10, %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq 0xc0(%rsp), %rax
movq %rcx, (%rax)
movq 0xb0(%rsp), %rsi
movq 0xc8(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0xa0(%rsp), %r8
movq 0xe0(%rsp), %r9
movq 0xb0(%rsp), %rax
addq 0x20(%rsp), %rax
leaq 0x2c(%rsp), %rdi
xorl %r10d, %r10d
movq %rax, (%rsp)
movl $0x1, 0x8(%rsp)
movl $0x0, 0x10(%rsp)
callq 0x5630
cmpl $0x1, %eax
jne 0x1b982
movl $0x0, 0xd4(%rsp)
jmp 0x1b98d
movl $0xffffffff, 0xd4(%rsp) # imm = 0xFFFFFFFF
movl 0xd4(%rsp), %eax
addq $0xd8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orestesleal[P]base64/b16enc.c
// Function: main
int main(int argc, char *argv[])
{
	struct finfo *fd;
	char *enc_buf;
	int ofd;
	size_t wr;

	if (argv[1]) {
		/* load the input file */
		if ((fd = get_file(argv[1])) == NULL) {
			fprintf(stderr, "get_file() failed loading %s in main memory\n", argv[1]);
			exit(EXIT_FAILURE);
		}
		if (argv[2]) {
			/* encode and write the encoded file into argv[2] */
			enc_buf = alloc(fd->size*2); /* buffer for the base32 encoding string */
			b16_enc(fd->addr, enc_buf, fd->size);

            if ((ofd = open(argv[2], O_CREAT | O_RDWR, S_IRUSR | O_TRUNC | S_IWUSR)) == -1) {
            	fprintf(stderr, "open(2) error, can't create or truncate %s\n", argv[2]);
	        	exit(EXIT_FAILURE);
			}
			if ((wr = write(ofd, enc_buf, strlen(enc_buf))) == -1) {
				fprintf(stderr, "write(2) error, can't write to %s\n", argv[2]);
				exit(EXIT_FAILURE);
			}
			close(ofd);
			free(enc_buf);
        }
		free(fd);
	}
	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x1334
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2b00
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x1236
movq 0x3de5(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x1ddf(%rip), %rsi      # 0x3004
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x10c0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x132b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movl %eax, %edi
callq 0x2ca0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, %edx
callq 0x2740
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x42, %esi
movl $0x380, %edx            # imm = 0x380
movb $0x0, %al
callq 0x10b0
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
jne 0x12c0
movq 0x3d5b(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x1d82(%rip), %rsi      # 0x3031
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x10c0
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rdi
callq 0x1050
movl -0x3c(%rbp), %edi
movq -0x38(%rbp), %rsi
movq %rax, %rdx
callq 0x1040
movq %rax, -0x30(%rbp)
cmpq $-0x1, %rax
jne 0x131a
movq 0x3d01(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
leaq 0x1d54(%rip), %rsi      # 0x305d
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x10c0
movl -0x24(%rbp), %edi
callq 0x1060
movq -0x20(%rbp), %rdi
callq 0x1030
movq -0x18(%rbp), %rdi
callq 0x1030
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/orestesleal[P]base64/base64.c
// Function: base16_encoder
void base16_encoder(char *s, char b[])
{
	char b16_alp[] = "0123456789ABCDEF";
	int i;
	for (i = 0; *s; i++, s++) { 
		unsigned char x = (unsigned char)*s >> 4;
		unsigned char z = ((unsigned char)(*s << 4)) >> 4;
		b[i] = b16_alp[x];
		b[++i] = b16_alp[z];
	}
	b[i] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x14bd(%rip), %rax      # 0x3080
movq %rax, -0x30(%rbp)
movq 0x14ba(%rip), %rax      # 0x3088
movq %rax, -0x28(%rbp)
movb 0x14b8(%rip), %al       # 0x3090
movb %al, -0x20(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1c50
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
sarl $0x4, %eax
movb %al, -0x35(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
shll $0x4, %eax
movzbl %al, %eax
sarl $0x4, %eax
movb %al, -0x36(%rbp)
movzbl -0x35(%rbp), %eax
movb -0x30(%rbp,%rax), %dl
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb %dl, (%rax,%rcx)
movzbl -0x36(%rbp), %eax
movb -0x30(%rbp,%rax), %dl
movq -0x10(%rbp), %rax
movl -0x34(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x34(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x1be2
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/orestesleal[P]base64/base64.c
// Function: base16_decoder
void base16_decoder(char *b16, char b[])
{
	int i;
	unsigned char n1, n2;
	for (i = 0; *b16; i++, b16+=2) {
		if (*b16  < 'A') {
			n1 = (*b16 - '0') << 4;
		}
		else {
			n1 = (*b16 - 0x37) << 4;
		}
		if (*(b16 + 1) < 'A') {
			n2 = *(b16 + 1) - '0';
		}
		else {
			n2 = *(b16 + 1) - 0x37;
		}
		b[i] =  n1 | n2;
	}
	b[i] = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1d0a
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x41, %eax
jge 0x1c9e
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
subl $0x30, %eax
shll $0x4, %eax
movb %al, -0x15(%rbp)
jmp 0x1cae
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
subl $0x37, %eax
shll $0x4, %eax
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cmpl $0x41, %eax
jge 0x1ccb
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
subl $0x30, %eax
movb %al, -0x16(%rbp)
jmp 0x1cd9
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
subl $0x37, %eax
movb %al, -0x16(%rbp)
movzbl -0x15(%rbp), %eax
movzbl -0x16(%rbp), %ecx
orl %ecx, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x8(%rbp)
jmp 0x1c73
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orestesleal[P]base64/base64.c
// Function: get_data_size
unsigned int get_data_size(char *s, unsigned int len)
{
	unsigned int rtsize, i;
	unsigned char pad = 0;
	for (i = len-1; s[i] == PAD; --i) {
		++pad;
		--len;
	}
	rtsize = (len >> 2) * 3;
	if (pad) {
		rtsize += pad == 2 ? 1 : 2;
	}
	return rtsize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0x15(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl -0x14(%rbp), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x3d, %eax
jne 0x2224
movb -0x15(%rbp), %al
addb $0x1, %al
movb %al, -0x15(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x21f8
movl -0xc(%rbp), %eax
shrl $0x2, %eax
imull $0x3, %eax, %eax
movl %eax, -0x10(%rbp)
cmpb $0x0, -0x15(%rbp)
je 0x2250
movzbl -0x15(%rbp), %edx
movl $0x2, %eax
movl $0x1, %ecx
cmpl $0x2, %edx
cmovel %ecx, %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orestesleal[P]base64/base64.c
// Function: b16_enc
void b16_enc(const unsigned char *s, char *b, unsigned int len)
{
	while (len--) {
		*b++ = b16_alp[*s >> 4];
		*b++ = b16_alp[*s++ & 0x0f]; 	
	}
	*b = '\0';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x14(%rbp)
cmpl $0x0, %eax
je 0x27bc
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
sarl $0x4, %eax
movslq %eax, %rcx
leaq 0x29ad(%rip), %rax      # 0x5120
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movzbl (%rax), %eax
andl $0xf, %eax
movslq %eax, %rcx
leaq 0x297a(%rip), %rax      # 0x5120
movb (%rax,%rcx), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
jmp 0x274f
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orestesleal[P]base64/base64.c
// Function: b16_dec
unsigned int b16_dec(const char *s, char *b, unsigned int len)
{
	unsigned char t[2],d;
	unsigned int i;

	d = 0;
	for (i = 0; i < len; i+=2) {
   		for (d = 0; d < 2; d++) {
			if ((s[i+d] >= '0' && s[i+d] <= '9') || 
				(s[i+d] >= 'A' && s[i+d] <= 'F')) {
				for (t[d] = 0; s[i+d] != b16_alp[t[d]]; ++t[d]); /* get position */
			}
			else { /* rfc4648 sec 3.3 paragraph #2 */ 
				fprintf(stderr, "error: non alphabet character found on encoded stream\n");
				exit(EXIT_FAILURE);
			}
		}
		t[0] <<= 4;
		t[0] |= t[1];
		*b++ = t[0];
	}	
	*b = '\0';
	return len >> 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x17(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x2920
movb $0x0, -0x17(%rbp)
movzbl -0x17(%rbp), %eax
cmpl $0x2, %eax
jge 0x28e7
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl -0x17(%rbp), %edx
addl %edx, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x30, %eax
jl 0x283b
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl -0x17(%rbp), %edx
addl %edx, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x39, %eax
jle 0x286b
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl -0x17(%rbp), %edx
addl %edx, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x41, %eax
jl 0x28b6
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl -0x17(%rbp), %edx
addl %edx, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x46, %eax
jg 0x28b6
movzbl -0x17(%rbp), %eax
movb $0x0, -0x16(%rbp,%rax)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movzbl -0x17(%rbp), %edx
addl %edx, %ecx
movl %ecx, %ecx
movsbl (%rax,%rcx), %eax
movzbl -0x17(%rbp), %ecx
movzbl -0x16(%rbp,%rcx), %ecx
movl %ecx, %edx
leaq 0x2887(%rip), %rcx      # 0x5120
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x28b4
jmp 0x28a3
movzbl -0x17(%rbp), %eax
movb -0x16(%rbp,%rax), %cl
addb $0x1, %cl
movb %cl, -0x16(%rbp,%rax)
jmp 0x2874
jmp 0x28d8
movq 0x273b(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x827(%rip), %rsi       # 0x30ee
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x10c0
jmp 0x28da
movb -0x17(%rbp), %al
addb $0x1, %al
movb %al, -0x17(%rbp)
jmp 0x27fe
movzbl -0x16(%rbp), %eax
shll $0x4, %eax
movb %al, -0x16(%rbp)
movzbl -0x15(%rbp), %ecx
movzbl -0x16(%rbp), %eax
orl %ecx, %eax
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %cl
movq -0x10(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x10(%rbp)
movb %cl, (%rax)
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
jmp 0x27ee
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
movl -0x14(%rbp), %eax
shrl %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orestesleal[P]base64/base64.c
// Function: get_file
struct finfo *get_file(const char *f)
{
	int fd;
	struct stat fp;
	char *addr; 
	struct finfo *st_addr;
	size_t rd;

	if ((fd = open(f, O_RDONLY)) == -1) {
		fprintf(stderr, "open(2) failed for file %s\n", f);
		return NULL;
	}
	stat(f, &fp); /* get file info with stat(2) */
	if ((addr = (char *)malloc(fp.st_size)) == NULL) {
		fprintf(stderr, "malloc(3) failed allocating %d bytes\n", (int)fp.st_size);
		close(fd);
		return NULL;
	}
	if ((rd = read(fd, addr, fp.st_size)) == -1) {
		fprintf(stderr, "read(2) failed reading %s with %d bytes into memory\n", f, (int)fp.st_size);
		close(fd);
		free(addr);
		return NULL;
	}
	if ((st_addr = (struct finfo *)malloc(sizeof(struct finfo))) == NULL) {
		fprintf(stderr, "malloc(3) failed allocating the returned structure\n");
		close(fd);
		free(addr);
		return NULL;
	}
	close(fd);
	st_addr->addr = addr;
	st_addr->size = fp.st_size;
	return st_addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
movb $0x0, %al
callq 0x10b0
movl %eax, -0x14(%rbp)
cmpl $-0x1, %eax
jne 0x2b4d
movq 0x24cd(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x66f(%rip), %rsi       # 0x31a8
movb $0x0, %al
callq 0x1080
movq $0x0, -0x8(%rbp)
jmp 0x2c89
movq -0x10(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x1090
movq -0x78(%rbp), %rdi
callq 0x10a0
movq %rax, -0xb0(%rbp)
cmpq $0x0, %rax
jne 0x2ba6
movq 0x247e(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x78(%rbp), %rax
movl %eax, %edx
leaq 0x63a(%rip), %rsi       # 0x31c4
movb $0x0, %al
callq 0x1080
movl -0x14(%rbp), %edi
callq 0x1060
movq $0x0, -0x8(%rbp)
jmp 0x2c89
movl -0x14(%rbp), %edi
movq -0xb0(%rbp), %rsi
movq -0x78(%rbp), %rdx
callq 0x1070
movq %rax, -0xc0(%rbp)
cmpq $-0x1, %rax
jne 0x2c09
movq 0x242b(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x78(%rbp), %rax
movl %eax, %ecx
leaq 0x609(%rip), %rsi       # 0x31ea
movb $0x0, %al
callq 0x1080
movl -0x14(%rbp), %edi
callq 0x1060
movq -0xb0(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x2c89
movl $0x10, %edi
callq 0x10a0
movq %rax, -0xb8(%rbp)
cmpq $0x0, %rax
jne 0x2c56
movq 0x23d1(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x5ee(%rip), %rsi       # 0x321f
movb $0x0, %al
callq 0x1080
movl -0x14(%rbp), %edi
callq 0x1060
movq -0xb0(%rbp), %rdi
callq 0x1030
movq $0x0, -0x8(%rbp)
jmp 0x2c89
movl -0x14(%rbp), %edi
callq 0x1060
movq -0xb0(%rbp), %rcx
movq -0xb8(%rbp), %rax
movq %rcx, (%rax)
movq -0x78(%rbp), %rcx
movq -0xb8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0xb8(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/orestesleal[P]base64/base64.c
// Function: alloc
char *alloc(unsigned int size)
{
    char *ptr = (char *)malloc(size);
    if (ptr == NULL) {
		fprintf(stderr, "malloc: error, can't allocate %d bytes\n", size);
		exit(EXIT_FAILURE);
	}
	return ptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %edi
callq 0x10a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x2ce5
movq 0x2331(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movl -0x4(%rbp), %edx
leaq 0x4ac(%rip), %rsi       # 0x3180
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x10c0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ulisses[P]ftp-client-server/apl.c
// Function: trataPedido
void trataPedido(char *cmd, char *ip){
	int pid, status;
	if((pid = fork())==0){
		int res;
		res = execl("./clientc2", "-te", "0", "-tp", "0", ip, cmd, NULL);
		if(res < 0){
			perror("execl");
		}
		exit(0);
	}
	wait(&status);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1090
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x1226
movq -0x10(%rbp), %r9
movq -0x8(%rbp), %rax
leaq 0xe28(%rip), %rdi       # 0x2004
leaq 0xe2c(%rip), %rsi       # 0x200f
leaq 0xe29(%rip), %r8        # 0x2013
leaq 0xe24(%rip), %rcx       # 0x2015
xorl %edx, %edx
movq %r8, %rdx
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
movb $0x0, %al
callq 0x1070
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jge 0x121f
leaq 0xdff(%rip), %rdi       # 0x2019
callq 0x1050
xorl %edi, %edi
callq 0x1060
leaq -0x18(%rbp), %rdi
callq 0x1080
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ulisses[P]ftp-client-server/apl.c
// Function: main
int main(int argc, char *argv[]){
	if(argc ==1){
		printf("erro: ./apl endereco_ip_servidor\n");
		return 0;
	}
	else {
		int sair = 0;
		char *ip = argv[1];
		char cmd[50];
		while(!sair){
			printf(">>");
			fgets(cmd, 50, stdin);
			if(strstr(cmd, "sair")) sair = 1;
			else trataPedido(cmd, ip);
		}
	return 1;
		
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x1273
leaq 0xdbc(%rip), %rdi       # 0x201f
movb $0x0, %al
callq 0x1030
movl $0x0, -0x4(%rbp)
jmp 0x12f0
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x1295
jmp 0x12e9
leaq 0xda5(%rip), %rdi       # 0x2041
movb $0x0, %al
callq 0x1030
leaq -0x60(%rbp), %rdi
movq 0x2d32(%rip), %rax      # 0x3fe0
movq (%rax), %rdx
movl $0x32, %esi
callq 0x1040
leaq -0x60(%rbp), %rdi
leaq 0xd7e(%rip), %rsi       # 0x2044
callq 0x10a0
cmpq $0x0, %rax
je 0x12da
movl $0x1, -0x14(%rbp)
jmp 0x12e7
leaq -0x60(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x11b0
jmp 0x1286
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/paeq160/ref/encrypt.cpp
// Function: gmul_o(unsigned char, unsigned char)
unsigned char gmul_o(unsigned char a, unsigned char b) {
	unsigned char p = 0;
	unsigned char counter;
	unsigned char hi_bit_set;
	for(counter = 0; counter < 8; counter++) {
		if((b & 1) == 1) 
			p ^= a;
		hi_bit_set = (a & 0x80);
		a <<= 1;
		if(hi_bit_set == 0x80) 
			a ^= 0x1b;		
		b >>= 1;
	}
	return p;
}

// Assembly:
movb %sil, %al
movb %dil, %cl
movb %cl, -0x1(%rsp)
movb %al, -0x2(%rsp)
movb $0x0, -0x3(%rsp)
movb $0x0, -0x4(%rsp)
movzbl -0x4(%rsp), %eax
cmpl $0x8, %eax
jge 0x1977
movzbl -0x2(%rsp), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x192f
movzbl -0x1(%rsp), %ecx
movzbl -0x3(%rsp), %eax
xorl %ecx, %eax
movb %al, -0x3(%rsp)
movzbl -0x1(%rsp), %eax
andl $0x80, %eax
movb %al, -0x5(%rsp)
movzbl -0x1(%rsp), %eax
shll %eax
movb %al, -0x1(%rsp)
movzbl -0x5(%rsp), %eax
cmpl $0x80, %eax
jne 0x1960
movzbl -0x1(%rsp), %eax
xorl $0x1b, %eax
movb %al, -0x1(%rsp)
movzbl -0x2(%rsp), %eax
sarl %eax
movb %al, -0x2(%rsp)
movb -0x4(%rsp), %al
addb $0x1, %al
movb %al, -0x4(%rsp)
jmp 0x1908
movb -0x3(%rsp), %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/builtins.c
// Function: isbuiltin
extern builtin_t *isbuiltin(char *s) {
    int i;
    for (i = 0; i < arraysize(builtins); i++)
	if (streq(builtins[i].name, s))
	    return builtins[i].p;
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x11, -0x14(%rbp)
jge 0x3519
movslq -0x14(%rbp), %rcx
leaq 0x1bd2c(%rip), %rax     # 0x1f1e0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x350c
movslq -0x14(%rbp), %rcx
leaq 0x1bd08(%rip), %rax     # 0x1f1e0
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x31e0
cmpl $0x0, %eax
jne 0x350c
movslq -0x14(%rbp), %rcx
leaq 0x1bce4(%rip), %rax     # 0x1f1e0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3521
jmp 0x350e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x34a3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/builtins.c
// Function: funcall
extern void funcall(char **av) {
	Jbwrap j;
	Estack e1, e2;
	Edata jreturn, star;
	if (sigsetjmp(j.j, 1))
		return;
	starassign(*av, av+1, TRUE);
	jreturn.jb = &j;
	star.name = "*";
	except(eReturn, jreturn, &e1);
	except(eVarstack, star, &e2);
	walk(treecpy(fnlookup(*av), nalloc), TRUE);
	varrm("*", TRUE);
	unexcept(eVarstack);
	unexcept(eReturn);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
movq %rdi, -0x8(%rbp)
leaq -0xd0(%rbp), %rdi
movl $0x1, %esi
callq 0x3360
cmpl $0x0, %eax
je 0x355a
jmp 0x360c
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movl $0x1, %edx
callq 0x12420
leaq -0xd0(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq 0x11b28(%rip), %rax     # 0x150b0
movq %rax, -0x110(%rbp)
movq -0x108(%rbp), %rsi
movl $0x2, %edi
leaq -0xe8(%rbp), %rdx
callq 0x4da0
movq -0x110(%rbp), %rsi
movl $0x3, %edi
leaq -0x100(%rbp), %rdx
callq 0x4da0
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x5d30
movq %rax, %rdi
leaq 0x9eeb(%rip), %rsi      # 0xd4c0
callq 0x11780
movq %rax, %rdi
movl $0x1, %esi
callq 0x12d80
leaq 0x11ac2(%rip), %rdi     # 0x150b0
movl $0x1, %esi
callq 0x12380
movl $0x3, %edi
callq 0x4e20
movl $0x2, %edi
callq 0x4e20
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/builtins.c
// Function: b_dot
extern void b_dot(char **av) {
	int fd;
	bool old_i = interactive, i = FALSE;
	Estack e;
	Edata star;
	av++;
	if (*av == NULL)
		return;
	if (streq(*av, "-i")) {
		av++;
		i = TRUE;
	}
	if (dasheye) { /* rc -i file has to do the right thing. reset the dasheye state to FALSE, though. */
		dasheye = FALSE;
		i = TRUE;
	}
	if (*av == NULL)
		return;
	fd = rc_open(*av, rFrom);
	if (fd < 0) {
		uerror(*av);
		set(FALSE);
		return;
	}
	starassign(*av, av+1, TRUE);
	interactive = i;
	pushfd(fd);
	star.name = "*";
	except(eVarstack, star, &e);
	doit(TRUE);
	varrm("*", TRUE);
	unexcept(eVarstack);
	interactive = old_i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1c611(%rip), %rax     # 0x1fc64
movl (%rax), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x367a
jmp 0x3790
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
movsbl 0x11a27(%rip), %ecx     # 0x150b2
cmpl %ecx, %eax
jne 0x36ba
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x11a15(%rip), %rsi     # 0x150b2
callq 0x31e0
cmpl $0x0, %eax
jne 0x36ba
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
movl $0x1, -0x14(%rbp)
leaq 0x1c5a7(%rip), %rax     # 0x1fc68
cmpl $0x0, (%rax)
je 0x36da
leaq 0x1c59b(%rip), %rax     # 0x1fc68
movl $0x0, (%rax)
movl $0x1, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x36e9
jmp 0x3790
movq -0x8(%rbp), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0xd900
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jge 0x3715
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x11c10
xorl %edi, %edi
callq 0x107a0
jmp 0x3790
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movq -0x8(%rbp), %rsi
addq $0x8, %rsi
movl $0x1, %edx
callq 0x12420
movl -0x14(%rbp), %ecx
leaq 0x1c52c(%rip), %rax     # 0x1fc64
movl %ecx, (%rax)
movl -0xc(%rbp), %edi
callq 0xaf50
leaq 0x11967(%rip), %rax     # 0x150b0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rsi
movl $0x3, %edi
leaq -0x30(%rbp), %rdx
callq 0x4da0
movl $0x1, %edi
callq 0xb210
leaq 0x11940(%rip), %rdi     # 0x150b0
movl $0x1, %esi
callq 0x12380
movl $0x3, %edi
callq 0x4e20
movl -0x10(%rbp), %ecx
leaq 0x1c4d6(%rip), %rax     # 0x1fc64
movl %ecx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/builtins.c
// Function: b_break
static void b_break(char **av) {
	if (av[1] != NULL) {
		arg_count("break");
		return;
	}
	rc_raise(eBreak);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3815
leaq 0x118a7(%rip), %rdi     # 0x150b5
callq 0x4840
jmp 0x381f
movl $0x1, %edi
callq 0x4ef0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/builtins.c
// Function: b_continue
static void b_continue(char **av) {
	if (av[1] != NULL) {
		arg_count("continue");
		return;
	}
	rc_raise(eContinue);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x3b55
leaq 0x11578(%rip), %rdi     # 0x150c6
callq 0x4840
jmp 0x3b5f
movl $0x7, %edi
callq 0x4ef0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/builtins.c
// Function: b_echo
static void b_echo(char **av) {
    char *format = "%A\n";
    if (*++av != NULL) {
	if (streq(*av, "-n"))
	    format = "%A", av++;
	else if (streq(*av, "--"))
	    av++;
    }
    fprint(1, format, av);
    set(TRUE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x115c4(%rip), %rax     # 0x15147
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x8(%rbp)
cmpq $0x0, 0x8(%rax)
je 0x3c24
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
movsbl 0x11599(%rip), %ecx     # 0x1514b
cmpl %ecx, %eax
jne 0x3be7
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x11587(%rip), %rsi     # 0x1514b
callq 0x31e0
cmpl $0x0, %eax
jne 0x3be7
leaq 0x11579(%rip), %rax     # 0x1514e
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x3c22
movq -0x8(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
movsbl 0x11559(%rip), %ecx     # 0x15151
cmpl %ecx, %eax
jne 0x3c20
movq -0x8(%rbp), %rax
movq (%rax), %rdi
leaq 0x11547(%rip), %rsi     # 0x15151
callq 0x31e0
cmpl $0x0, %eax
jne 0x3c20
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x3c22
jmp 0x3c24
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
movl $0x1, %edi
movb $0x0, %al
callq 0xf3a0
movl $0x1, %edi
callq 0x107a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/builtins.c
// Function: b_eval
static void b_eval(char **av) {
	bool i = interactive;
	if (av[1] == NULL)
		return;
	interactive = FALSE;
	pushstring(av + 1, i); /* don't reset line numbers on noninteractive eval */
	doit(TRUE);
	interactive = i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x1c001(%rip), %rax     # 0x1fc64
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x3c75
jmp 0x3ca8
leaq 0x1bfe8(%rip), %rax     # 0x1fc64
movl $0x0, (%rax)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
movl -0xc(%rbp), %esi
callq 0xb020
movl $0x1, %edi
callq 0xb210
movl -0xc(%rbp), %ecx
leaq 0x1bfbe(%rip), %rax     # 0x1fc64
movl %ecx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/builtins.c
// Function: b_newpgrp
static void b_newpgrp(char **av) {
	if (av[1] != NULL) {
		arg_count("newpgrp");
		return;
	}
	setpgid(rc_pid, rc_pid); /* XXX check return value */
	tcsetpgrp(2, rc_pid); /* XXX check return value */
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4195
leaq 0x10f50(%rip), %rdi     # 0x150de
callq 0x4840
jmp 0x41bf
leaq 0x1bab4(%rip), %rax     # 0x1fc50
movl (%rax), %edi
leaq 0x1baab(%rip), %rax     # 0x1fc50
movl (%rax), %esi
callq 0x3310
leaq 0x1ba9d(%rip), %rax     # 0x1fc50
movl (%rax), %esi
movl $0x2, %edi
callq 0x32d0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/builtins.c
// Function: b_shift
static void b_shift(char **av) {
	int shift = (av[1] == NULL ? 1 : a2u(av[1]));
	List *s, *dollarzero;
	if (av[1] != NULL && av[2] != NULL) {
		arg_count("shift");
		return;
	}
	if (shift < 0) {
		badnum(av[1]);
		return;
	}
	s = varlookup("*")->n;
	dollarzero = varlookup("0");
	while (s != NULL && shift != 0) {
		s = s->n;
		--shift;
	}
	if (s == NULL && shift != 0) {
		fprint(2, "rc: cannot shift\n");
		set(FALSE);
	} else {
		varassign("*", append(dollarzero, s), FALSE);
		set(TRUE);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x4231
movl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x4246
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0xa, %esi
callq 0x11cf0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4273
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x4273
leaq 0x10e84(%rip), %rdi     # 0x150ed
callq 0x4840
jmp 0x4336
cmpl $0x0, -0xc(%rbp)
jge 0x428b
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4bc0
jmp 0x4336
leaq 0x10e1e(%rip), %rdi     # 0x150b0
callq 0x12110
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
leaq 0x11e40(%rip), %rdi     # 0x160e6
callq 0x12110
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x25(%rbp)
je 0x42c5
cmpl $0x0, -0xc(%rbp)
setne %al
movb %al, -0x25(%rbp)
movb -0x25(%rbp), %al
testb $0x1, %al
jne 0x42ce
jmp 0x42e5
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x42af
cmpq $0x0, -0x18(%rbp)
jne 0x430e
cmpl $0x0, -0xc(%rbp)
je 0x430e
movl $0x2, %edi
leaq 0x10f71(%rip), %rsi     # 0x1526f
movb $0x0, %al
callq 0xf3a0
xorl %edi, %edi
callq 0x107a0
jmp 0x4336
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x83b0
movq %rax, %rsi
leaq 0x10d8b(%rip), %rdi     # 0x150b0
xorl %edx, %edx
callq 0x11e60
movl $0x1, %edi
callq 0x107a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/builtins.c
// Function: b_umask
static void b_umask(char **av) {
    int i;
    if (*++av == NULL) {
	set(TRUE);
	i = umask(0);
	umask(i);
	fprint(1, "0%o\n", i);
    } else if (av[1] == NULL) {
	i = o2u(*av);
	if ((unsigned int) i > 0777) {
	    fprint(2, "bad umask\n");
	    set(FALSE);
	} else {
	    umask(i);
	    set(TRUE);
	}
    } else {
	arg_count("umask");
	return;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x8(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x4396
movl $0x1, %edi
callq 0x107a0
xorl %edi, %edi
callq 0x31f0
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
callq 0x31f0
movl -0xc(%rbp), %edx
movl $0x1, %edi
leaq 0x10f0e(%rip), %rsi     # 0x1529b
movb $0x0, %al
callq 0xf3a0
jmp 0x43fe
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x43ee
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0x8, %esi
callq 0x11cf0
movl %eax, -0xc(%rbp)
cmpl $0x1ff, -0xc(%rbp)      # imm = 0x1FF
jbe 0x43da
movl $0x2, %edi
leaq 0x10ed6(%rip), %rsi     # 0x152a0
movb $0x0, %al
callq 0xf3a0
xorl %edi, %edi
callq 0x107a0
jmp 0x43ec
movl -0xc(%rbp), %edi
callq 0x31f0
movl $0x1, %edi
callq 0x107a0
jmp 0x43fc
leaq 0x10cfe(%rip), %rdi     # 0x150f3
callq 0x4840
jmp 0x43fe
jmp 0x43fe
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/builtins.c
// Function: b_wait
static void b_wait(char **av) {
	if (*++av == NULL)
		waitforall();
	else
		waitfor(av);
        sigchk();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x8(%rbp)
cmpq $0x0, 0x8(%rax)
jne 0x4439
callq 0x12b70
jmp 0x4442
movq -0x8(%rbp), %rdi
callq 0x12be0
callq 0x104a0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/builtins.c
// Function: printlimit
static void printlimit(const struct Limit *limit, bool hard) {
	struct rlimit rlim;
	rlim_t lim;
	getrlimit(limit->flag, &rlim);
	if (hard)
		lim = rlim.rlim_max;
	else
		lim = rlim.rlim_cur;
	if (lim == RLIM_INFINITY)
		fprint(1, "%s \tunlimited\n", limit->name);
	else {
		const struct Suffix *suf;
		for (suf = limit->suffix; suf != NULL; suf = suf->next)
			if (lim % suf->amount == 0 && (lim != 0 || suf->amount > 1)) {
				lim /= suf->amount;
				break;
			}
		fprint(1, RLIM_FMT, limit->name, (RLIM_CONV)lim, (suf == NULL || lim == 0) ? "" : suf->name);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edi
leaq -0x20(%rbp), %rsi
callq 0x3330
cmpl $0x0, -0xc(%rbp)
je 0x489f
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x48a7
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $-0x1, -0x28(%rbp)
jne 0x48cd
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movl $0x1, %edi
leaq 0x1098a(%rip), %rsi     # 0x1524b
movb $0x0, %al
callq 0xf3a0
jmp 0x4985
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x492c
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
xorl %edx, %edx
divq 0x8(%rcx)
cmpq $0x0, %rdx
jne 0x491d
cmpq $0x0, -0x28(%rbp)
jne 0x4906
movq -0x30(%rbp), %rax
cmpq $0x1, 0x8(%rax)
jle 0x491d
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rbp), %rax
xorl %edx, %edx
divq %rcx
movq %rax, -0x28(%rbp)
jmp 0x492c
jmp 0x491f
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x48d9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x494d
cmpq $0x0, -0x28(%rbp)
jne 0x495a
leaq 0x11723(%rip), %rax     # 0x16077
movq %rax, -0x48(%rbp)
jmp 0x4966
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rdx
movq -0x48(%rbp), %r8
movl $0x1, %edi
leaq 0x108dc(%rip), %rsi     # 0x1525a
movb $0x0, %al
callq 0xf3a0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/builtins.c
// Function: issig
static bool issig(char *s) {
	int i;
	for (i = 0; i < NUMOFSIGNALS; i++)
		if (streq(s, signals[i].name))
			return TRUE;
	return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x41, -0x14(%rbp)
jge 0x4c65
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movslq -0x14(%rbp), %rdx
leaq 0x1a795(%rip), %rcx     # 0x1f3b0
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
movsbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0x4c58
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x1a775(%rip), %rax     # 0x1f3b0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x31e0
cmpl $0x0, %eax
jne 0x4c58
movl $0x1, -0x4(%rbp)
jmp 0x4c6c
jmp 0x4c5a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x4c03
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/except.c
// Function: except
extern void except(ecodes e, Edata data, Estack *ex) {
	ex->prev = estack;
	estack = ex;
	estack->e = e;
	estack->data = data;
	if (e == eError || e == eBreak || e == eReturn || e == eContinue)
		estack->interactive = interactive;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rsi, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x1aa52(%rip), %rcx     # 0x1f808
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, 0x1aa3f(%rip)     # 0x1f808
movl -0xc(%rbp), %ecx
movq 0x1aa35(%rip), %rax     # 0x1f808
movl %ecx, (%rax)
movq 0x1aa2c(%rip), %rax     # 0x1f808
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
cmpl $0x0, -0xc(%rbp)
je 0x4dfc
cmpl $0x1, -0xc(%rbp)
je 0x4dfc
cmpl $0x2, -0xc(%rbp)
je 0x4dfc
cmpl $0x7, -0xc(%rbp)
jne 0x4e0f
leaq 0x1ae61(%rip), %rax     # 0x1fc64
movl (%rax), %ecx
movq 0x1a9fc(%rip), %rax     # 0x1f808
movl %ecx, 0x4(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/except.c
// Function: unexcept
extern void unexcept(ecodes e) {
	assert(e == estack->e);
	switch (estack->e) {
	default:
		break;
	case eError:
		interactive = estack->interactive;
		break;
	case eArena:
		restoreblock(estack->data.b);
		break;
	case eFifo:
		unlink(estack->data.name);
		break;
	case eFd:
		close(estack->data.fd);
		break;
	}
	estack = estack->prev;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movq 0x1a9d3(%rip), %rcx     # 0x1f808
cmpl (%rcx), %eax
jne 0x4e3b
jmp 0x4e5a
leaq 0x10582(%rip), %rdi     # 0x153c4
leaq 0x1058a(%rip), %rsi     # 0x153d3
movl $0x20, %edx
leaq 0x10587(%rip), %rcx     # 0x153dc
callq 0x3140
movq 0x1a9a7(%rip), %rax     # 0x1f808
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x6, %rax
ja 0x4e81
movq -0x10(%rbp), %rax
leaq 0x10520(%rip), %rcx     # 0x15398
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x4ecb
movq 0x1a97e(%rip), %rax     # 0x1f808
movl 0x4(%rax), %ecx
leaq 0x1add0(%rip), %rax     # 0x1fc64
movl %ecx, (%rax)
jmp 0x4ecb
movq 0x1a969(%rip), %rax     # 0x1f808
movq 0x8(%rax), %rdi
callq 0xd7f0
jmp 0x4ecb
movq 0x1a957(%rip), %rax     # 0x1f808
movq 0x8(%rax), %rdi
callq 0x3050
jmp 0x4ecb
movq 0x1a945(%rip), %rax     # 0x1f808
movl 0x8(%rax), %edi
callq 0x3170
movq 0x1a936(%rip), %rax     # 0x1f808
movq 0x10(%rax), %rax
movq %rax, 0x1a92b(%rip)     # 0x1f808
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/except.c
// Function: rc_error
extern void rc_error(char *s) {
	pr_error(s, -1);
	set(FALSE);
	redirq = NULL;
	cond = FALSE; /* no longer inside conditional */
	rc_raise(eError);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x11ba0
xorl %edi, %edi
callq 0x107a0
leaq 0x1aa60(%rip), %rax     # 0x1fb58
movq $0x0, (%rax)
leaq 0x1bf62(%rip), %rax     # 0x21068
movl $0x0, (%rax)
xorl %edi, %edi
callq 0x4ef0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/except.c
// Function: clearflow
extern void clearflow() {
	Estack **e = &estack;
	while (*e != NULL)
		switch ((*e)->e) {
		case eBreak: case eContinue: case eReturn:
			*e = (*e)->prev;
			break;
		default:
			e = &(*e)->prev;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x1a6dd(%rip), %rax     # 0x1f808
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
je 0x517d
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
decl %eax
subl $0x2, %eax
jb 0x5158
jmp 0x514e
movl -0xc(%rbp), %eax
subl $0x7, %eax
jne 0x516c
jmp 0x5158
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x517b
movq -0x8(%rbp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, -0x8(%rbp)
jmp 0x512f
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/rakitzis[P]rc/except.c
// Function: pop_cmdarg
extern void pop_cmdarg(bool remove) {
	for (; estack != NULL; estack = estack->prev)
		switch (estack->e) {
		case eFifo:
			if (remove)
				unlink(estack->data.name);
			break;
		case eFd:
			if (remove)
				close(estack->data.fd);
			break;
		default:
			return;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpq $0x0, 0x1a645(%rip)     # 0x1f808
je 0x5229
movq 0x1a63c(%rip), %rax     # 0x1f808
movl (%rax), %eax
movl %eax, -0x8(%rbp)
subl $0x5, %eax
je 0x51e2
jmp 0x51d8
movl -0x8(%rbp), %eax
subl $0x6, %eax
je 0x51fa
jmp 0x5211
cmpl $0x0, -0x4(%rbp)
je 0x51f8
movq 0x1a619(%rip), %rax     # 0x1f808
movq 0x8(%rax), %rdi
callq 0x3050
jmp 0x5213
cmpl $0x0, -0x4(%rbp)
je 0x520f
movq 0x1a601(%rip), %rax     # 0x1f808
movl 0x8(%rax), %edi
callq 0x3170
jmp 0x5213
jmp 0x5229
jmp 0x5215
movq 0x1a5ec(%rip), %rax     # 0x1f808
movq 0x10(%rax), %rax
movq %rax, 0x1a5e1(%rip)     # 0x1f808
jmp 0x51bb
addq $0x10, %rsp
popq %rbp
retq
nop