LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ethinethin[P]Secret/items.c
// Function: drop_item
extern void drop_item(int room_id, char *word1, char *word2)
{
	char *adj = NULL;
	char *name = NULL;
	int item_num;

	putchar('\n');

	if (word1 == NULL) {
		printf("Drop what?\n");
		return;
	}
	
	/* assign an adjective if possible */
	assign_name(&word1, &word2, &adj, &name);
	
	/* find out if given name is ambiguous */
	item_num = in_inv(adj, name);

	/* if none were found, the item is not in inventory */
	/* if only one was found, it's not ambiguous */
	if (item_num == -1) {
		printf("You do not have a ");
		if (adj != NULL) printf("%s ",adj);
		printf("%s.\n",name);
		return;
	} else if (item_num == -2) {
		printf("Which %s do you want to drop?\n",name);
		return;
	}

	/* drop item */
	items[item_num].location = room_id;
	inventory[item_num] = NO;
	printf("You dropped the ");
	if (items[item_num].item_adj != NULL)
		printf("%s ",items[item_num].item_adj);
	printf("%s.\n",name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0xa, %edi
callq 0x3050
cmpq $0x0, -0x10(%rbp)
jne 0x6ff7
leaq 0x4a66(%rip), %rdi      # 0xba51
movb $0x0, %al
callq 0x30e0
jmp 0x7103
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x6c30
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6e90
movl %eax, -0x2c(%rbp)
cmpl $-0x1, -0x2c(%rbp)
jne 0x7060
leaq 0x4a34(%rip), %rdi      # 0xba5d
movb $0x0, %al
callq 0x30e0
cmpq $0x0, -0x20(%rbp)
je 0x7049
movq -0x20(%rbp), %rsi
leaq 0x1a78(%rip), %rdi      # 0x8aba
movb $0x0, %al
callq 0x30e0
movq -0x28(%rbp), %rsi
leaq 0x1a61(%rip), %rdi      # 0x8ab5
movb $0x0, %al
callq 0x30e0
jmp 0x7103
cmpl $-0x2, -0x2c(%rbp)
jne 0x707d
movq -0x28(%rbp), %rsi
leaq 0x49ff(%rip), %rdi      # 0xba70
movb $0x0, %al
callq 0x30e0
jmp 0x7103
jmp 0x707f
movl -0x4(%rbp), %ecx
movslq -0x2c(%rbp), %rdx
leaq 0x8ba3(%rip), %rax      # 0xfc30
imulq $0x38, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x30(%rax)
movslq -0x2c(%rbp), %rcx
leaq 0x9b9e(%rip), %rax      # 0x10c40
movb $0x0, (%rax,%rcx)
leaq 0x49e2(%rip), %rdi      # 0xba8f
movb $0x0, %al
callq 0x30e0
movslq -0x2c(%rbp), %rcx
leaq 0x8b71(%rip), %rax      # 0xfc30
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
cmpq $0x0, 0x10(%rax)
je 0x70f1
movslq -0x2c(%rbp), %rcx
leaq 0x8b58(%rip), %rax      # 0xfc30
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rsi
leaq 0x19d0(%rip), %rdi      # 0x8aba
movb $0x0, %al
callq 0x30e0
movq -0x28(%rbp), %rsi
leaq 0x19b9(%rip), %rdi      # 0x8ab5
movb $0x0, %al
callq 0x30e0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ethinethin[P]Secret/items.c
// Function: look_item
extern void look_item(int room_id, char *word1, char *word2)
{
	char *adj = NULL;
	char *name = NULL;
	int item_num;

	putchar('\n');

	if (word1 == NULL) {
		printf("Look at what?\n");
		return;
	}
	
	/* assign an adjective if possible */
	assign_name(&word1, &word2, &adj, &name);

	/* in location or inventory? */
	item_num = unique_item(room_id, adj, name);

	/* is it ambiguous? */
	if (item_num == -2) {
		printf("Which %s?\n",name);
		return;
	} else if (item_num == -1) {
		printf("There is no ");
		if (adj != NULL) printf("%s ",adj);
		printf("%s here.\n",name);
		return;
	} 
	/* output description */
	printf("%s\n",items[item_num].item_desc_exam);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movl $0xa, %edi
callq 0x3050
cmpq $0x0, -0x10(%rbp)
jne 0x7157
leaq 0x4955(%rip), %rdi      # 0xbaa0
movb $0x0, %al
callq 0x30e0
jmp 0x7200
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0x6c30
movl -0x4(%rbp), %edi
movq -0x20(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x6df0
movl %eax, -0x2c(%rbp)
cmpl $-0x2, -0x2c(%rbp)
jne 0x7199
movq -0x28(%rbp), %rsi
leaq 0x491f(%rip), %rdi      # 0xbaaf
movb $0x0, %al
callq 0x30e0
jmp 0x7200
cmpl $-0x1, -0x2c(%rbp)
jne 0x71da
leaq 0x4858(%rip), %rdi      # 0xb9fe
movb $0x0, %al
callq 0x30e0
cmpq $0x0, -0x20(%rbp)
je 0x71c6
movq -0x20(%rbp), %rsi
leaq 0x18fb(%rip), %rdi      # 0x8aba
movb $0x0, %al
callq 0x30e0
movq -0x28(%rbp), %rsi
leaq 0x4903(%rip), %rdi      # 0xbad4
movb $0x0, %al
callq 0x30e0
jmp 0x7200
jmp 0x71dc
movslq -0x2c(%rbp), %rcx
leaq 0x8a49(%rip), %rax      # 0xfc30
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rsi
leaq 0x189b(%rip), %rdi      # 0x8a94
movb $0x0, %al
callq 0x30e0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/simpleblockmodel.c
// Function: compute
void compute(size_t HowManyKeys) {
  bool verbose = false;
  printf("Number of keys %zu \n", HowManyKeys);
  printf("Full cache line (512-bits) \n");
  assessBlockSize(HowManyKeys, 512, verbose);
  printf("3/4 cache line (384-bits) \n");
  assessBlockSize(HowManyKeys, 384, verbose);
  printf("Half cache line (256-bits) \n");
  assessBlockSize(HowManyKeys, 256, verbose);
  printf("Half cache line (128-bits) \n");
  assessBlockSize(HowManyKeys, 128, verbose);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movb $0x0, 0xf(%rsp)
movq 0x10(%rsp), %rsi
leaq 0x32c3(%rip), %rdi      # 0x632d
movb $0x0, %al
callq 0x1060
leaq 0x32ca(%rip), %rdi      # 0x6342
movb $0x0, %al
callq 0x1060
movq 0x10(%rsp), %rdi
movb 0xf(%rsp), %al
movl $0x200, %esi            # imm = 0x200
andb $0x1, %al
movzbl %al, %edx
callq 0x18a0
leaq 0x32c1(%rip), %rdi      # 0x635f
movb $0x0, %al
callq 0x1060
movq 0x10(%rsp), %rdi
movb 0xf(%rsp), %al
movl $0x180, %esi            # imm = 0x180
andb $0x1, %al
movzbl %al, %edx
callq 0x18a0
leaq 0x32b7(%rip), %rdi      # 0x637b
movb $0x0, %al
callq 0x1060
movq 0x10(%rsp), %rdi
movb 0xf(%rsp), %al
movl $0x100, %esi            # imm = 0x100
andb $0x1, %al
movzbl %al, %edx
callq 0x18a0
leaq 0x32ae(%rip), %rdi      # 0x6398
movb $0x0, %al
callq 0x1060
movq 0x10(%rsp), %rdi
movb 0xf(%rsp), %al
movl $0x80, %esi
andb $0x1, %al
movzbl %al, %edx
callq 0x18a0
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/FastFilter[P]BlockBloomSimulator/src/simpleblockmodel.c
// Function: main
int main() {
  printf("bits per key indicates storage (bits used per key): smaller is "
         "better\n");
  printf("best bits per bucket indicates the number of bits to check per key: "
         "smaller is better\n");
  printf("collision rate is the false negative rate: smaller is better\n");
  printf("In the 'lane' model you have one bit set per lane.\n");
  printf("\n");
  for(size_t i = 10000; i < 1000000000; i*=10) {
    compute(i);
  }

  return EXIT_SUCCESS;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
leaq 0x3292(%rip), %rdi      # 0x63b5
movb $0x0, %al
callq 0x1060
leaq 0x32cb(%rip), %rdi      # 0x63fc
movb $0x0, %al
callq 0x1060
leaq 0x3314(%rip), %rdi      # 0x6453
movb $0x0, %al
callq 0x1060
leaq 0x3344(%rip), %rdi      # 0x6491
movb $0x0, %al
callq 0x1060
leaq 0x2f92(%rip), %rdi      # 0x60ed
movb $0x0, %al
callq 0x1060
movq $0x2710, 0x8(%rsp)      # imm = 0x2710
cmpq $0x3b9aca00, 0x8(%rsp)  # imm = 0x3B9ACA00
jae 0x318d
movq 0x8(%rsp), %rdi
callq 0x3050
imulq $0xa, 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x316b
xorl %eax, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/cirocosta[P]stress/src/consistent-forking.c
// Function: main
int
main(int argc, char** argv)
{
	stress_args_t args = { 0 };

	stress_parse_args(argc, argv, &args);
	_STRESS_MUST(args.n > 0, "'n' argument must be at least > 0");
	fork_so_much(args.n);

	return 0;
}

// Assembly:
subq $0x2018, %rsp           # imm = 0x2018
movl $0x0, 0x2014(%rsp)
movl %edi, 0x2010(%rsp)
movq %rsi, 0x2008(%rsp)
movq %rsp, %rdi
xorl %esi, %esi
movl $0x2008, %edx           # imm = 0x2008
callq 0x10a0
movl 0x2010(%rsp), %edi
movq 0x2008(%rsp), %rsi
movq %rsp, %rdx
callq 0x1300
cmpl $0x0, (%rsp)
jg 0x1e17
movq 0x22b0(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x42a(%rip), %rsi       # 0x217c
movb $0x0, %al
callq 0x10c0
movq 0x2298(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x418(%rip), %rsi       # 0x2182
movb $0x0, %al
callq 0x10c0
movq 0x2280(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x42e(%rip), %rsi       # 0x21b0
movb $0x0, %al
callq 0x10c0
movq 0x2268(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x2c1(%rip), %rsi       # 0x205b
movb $0x0, %al
callq 0x10c0
movq 0x2250(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x2ac(%rip), %rsi       # 0x205e
leaq 0x384(%rip), %rdx       # 0x213d
movb $0x0, %al
callq 0x10c0
movq 0x2231(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x2a9(%rip), %rsi       # 0x207a
movl $0x47, %edx
movb $0x0, %al
callq 0x10c0
movq 0x2214(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x26e(%rip), %rsi       # 0x205c
movb $0x0, %al
callq 0x10c0
movq 0x21fc(%rip), %rax      # 0x3ff8
movq (%rax), %rdi
leaq 0x281(%rip), %rsi       # 0x2087
movb $0x0, %al
callq 0x10c0
movl $0x1, %edi
callq 0x1130
jmp 0x1e19
movl (%rsp), %edi
callq 0x18c0
xorl %eax, %eax
addq $0x2018, %rsp           # imm = 0x2018
retq
// File: /workspace/github_c_makefile_star2_O0/Openvario[P]sensord/compdata.c
// Function: sigintHandler
static void sigintHandler(int sig_num)
{
	(void)sig_num;

	signal(SIGINT, sigintHandler);

	// if sensordata from file
	if (fp_sensordata != NULL)
		fclose(fp_sensordata);

	fprintf(stderr, "Exiting ...\n");

	exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x2, %edi
leaq -0x17(%rip), %rsi       # 0x3410
callq 0x1140
leaq 0x3005f75(%rip), %rax   # 0x30093a8
cmpq $0x0, (%rax)
je 0x3448
leaq 0x3005f68(%rip), %rax   # 0x30093a8
movq (%rax), %rdi
callq 0x10a0
movq 0x5ba9(%rip), %rax      # 0x8ff8
movq (%rax), %rdi
leaq 0x354d(%rip), %rsi      # 0x69a6
movb $0x0, %al
callq 0x1150
xorl %edi, %edi
callq 0x1210
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190820_1MM1_INTRO/mcd.c
// Function: mcd
static int mcd(int n,int d)
{
  int N,D,R;
  N=abs(n);D=abs(d);
  while((R=D%N)!=0){
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
    D=N;
    N=R;
  }
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
  return N;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, %edx
je 0x11f6
movl -0x10(%rbp), %esi
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, %edx
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0xe23(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
jmp 0x11b8
movl -0x10(%rbp), %esi
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, %edx
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0xdf4(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190820_1MM1_INTRO/main.c
// Function: main
int main(void){
  int result=printf("mcd(32,132)=%d\n",mcd(32,132));
  printf("mcd(8,64)=%d\n",mcd(8,64));
  printf("mcd(65,2048)=%d\n",mcd(65,2048));

  int m=mcd(32,132);
  int arr[]={32,132};
  simplificar(arr);
  printf("32/132=%d/%d\n",arr[0],arr[1]);
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl $0x20, %edi
movl $0x84, %esi
callq 0x12e0
movl %eax, %esi
leaq 0xdcd(%rip), %rdi       # 0x2014
movb $0x0, %al
callq 0x1030
movl %eax, -0x8(%rbp)
movl $0x8, %edi
movl $0x40, %esi
callq 0x12e0
movl %eax, %esi
leaq 0xdbb(%rip), %rdi       # 0x2024
movb $0x0, %al
callq 0x1030
movl $0x41, %edi
movl $0x800, %esi            # imm = 0x800
callq 0x12e0
movl %eax, %esi
leaq 0xdaa(%rip), %rdi       # 0x2032
movb $0x0, %al
callq 0x1030
movl $0x20, %edi
movl $0x84, %esi
callq 0x12e0
movl %eax, -0xc(%rbp)
movq 0xdac(%rip), %rax       # 0x2054
movq %rax, -0x14(%rbp)
leaq -0x14(%rbp), %rdi
callq 0x1140
movl -0x14(%rbp), %esi
movl -0x10(%rbp), %edx
leaq 0xd81(%rip), %rdi       # 0x2043
movb $0x0, %al
callq 0x1030
movl -0x8(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/GRUPO1MM1INTRO-2020-1[P]1MM1INTRO/20190820_1MM1_INTRO/otro.c
// Function: mcd
int mcd(int n,int d)
{
  int N,D,R;
  N=abs(n);
  D=abs(d);
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
  D=N;
  N=R;
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
  D=N;
  N=R;
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
  D=N;
  N=R;
  R=D%N;
  if(!R) goto fin;
#ifdef PRELIMINAR
  printf("%d = %d(%d)+%d\n",D,D/N,N,R);
#endif /*PRELIMINAR*/
fin:
  return N;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x131d
jmp 0x13fe
movl -0x10(%rbp), %esi
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, %edx
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0xccd(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x135f
jmp 0x13fe
movl -0x10(%rbp), %esi
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, %edx
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0xc8b(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x139e
jmp 0x13fe
movl -0x10(%rbp), %esi
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, %edx
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0xc4c(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x13dd
jmp 0x13fe
movl -0x10(%rbp), %esi
movl -0x10(%rbp), %eax
cltd
idivl -0xc(%rbp)
movl %eax, %edx
movl -0xc(%rbp), %ecx
movl -0x14(%rbp), %r8d
leaq 0xc0d(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: StrCaseStr
char *StrCaseStr(char *s1, const char *s2)
{
   char h1[MAX_STR];
   char h2[MAX_STR];
   char *r;
   unsigned int i;

   memset(h1,0,sizeof(h1));
   memset(h2,0,sizeof(h2));

    for (i=0 ; i < strlen(s1) && i < sizeof(h1)-1 ; ++i)
        h1[i] = toupper(s1[i]);
    for (i=0 ; i < strlen(s2) && i < sizeof(h2)-1 ; ++i)
        h2[i] = toupper(s2[i]);

    r = strstr(h1,h2);
    if (r) r = s1 + (r - h1);
    return r;
}

// Assembly:
subq $0x848, %rsp            # imm = 0x848
movq %rdi, 0x840(%rsp)
movq %rsi, 0x838(%rsp)
leaq 0x430(%rsp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x2160
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x2160
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq %rax, 0x18(%rsp)
movq 0x840(%rsp), %rdi
callq 0x20f0
movq 0x18(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x23(%rsp)
jae 0x24de
movl 0x24(%rsp), %eax
cmpq $0x3ff, %rax            # imm = 0x3FF
setb %al
movb %al, 0x23(%rsp)
movb 0x23(%rsp), %al
testb $0x1, %al
jne 0x24e8
jmp 0x2517
movq 0x840(%rsp), %rax
movl 0x24(%rsp), %ecx
movsbl (%rax,%rcx), %edi
callq 0x2080
movb %al, %cl
movl 0x24(%rsp), %eax
movb %cl, 0x430(%rsp,%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x24a4
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq %rax, 0x8(%rsp)
movq 0x838(%rsp), %rdi
callq 0x20f0
movq 0x8(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x17(%rsp)
jae 0x2559
movl 0x24(%rsp), %eax
cmpq $0x3ff, %rax            # imm = 0x3FF
setb %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x2563
jmp 0x258f
movq 0x838(%rsp), %rax
movl 0x24(%rsp), %ecx
movsbl (%rax,%rcx), %edi
callq 0x2080
movb %al, %cl
movl 0x24(%rsp), %eax
movb %cl, 0x30(%rsp,%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x251f
leaq 0x430(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x22d0
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x25ce
movq 0x840(%rsp), %rax
movq 0x28(%rsp), %rcx
leaq 0x430(%rsp), %rdx
subq %rdx, %rcx
addq %rcx, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0x848, %rsp            # imm = 0x848
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: StrNDup
char *StrNDup(void *src, unsigned int n)
{
   char *dst;
   if (n > MAX_STR)
   {
      fprintf(stderr,"*** tried to allocate %d bytes for string\n",n);
      fprintf(stderr,"*** current maximum length is %d\n",MAX_STR);
      exit(1);
   }
   dst = (char *)MallocOrDie(n+1);
   memmove(dst,src,n);
   return dst;
 }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $0x400, 0xc(%rsp)       # imm = 0x400
jbe 0x270a
movq 0x1292a(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
movl 0xc(%rsp), %edx
leaq 0xd9fe(%rip), %rsi      # 0x100da
movb $0x0, %al
callq 0x21e0
movq 0x1290e(%rip), %rax     # 0x14ff8
movq (%rax), %rdi
leaq 0xda11(%rip), %rsi      # 0x10105
movl $0x400, %edx            # imm = 0x400
movb $0x0, %al
callq 0x21e0
movl $0x1, %edi
callq 0x22b0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
callq 0x2620
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl 0xc(%rsp), %eax
movl %eax, %edx
callq 0x2260
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: MneStat
void MneStat(void)
{
   unsigned int i,j;

   for (i=0 ; i < DIMOP_6309 ; ++i)
   for (j=0 ; j < strlen(Mat[i].Mne) ; ++j)
      ++Cstat[Mat[i].Mne[j]-'A'];

   for (i=0 ; i < 26 ; ++i)
      printf("%c:%3d\n",'A'+i,Cstat[i]);
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpq $0xe6, %rax
jae 0x27e9
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %eax
leaq 0x12a28(%rip), %rdi     # 0x151a0
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x20f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x27d7
movl 0x14(%rsp), %eax
movl %eax, %ecx
leaq 0x12a02(%rip), %rax     # 0x151a0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rsp), %ecx
movsbl (%rax,%rcx), %eax
subl $0x41, %eax
movslq %eax, %rcx
leaq 0x255a6(%rip), %rax     # 0x27d60
movb (%rax,%rcx), %dl
addb $0x1, %dl
leaq 0x25599(%rip), %rax     # 0x27d60
movb %dl, (%rax,%rcx)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x2764
jmp 0x27d9
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x274c
movl $0x0, 0x14(%rsp)
cmpl $0x1a, 0x14(%rsp)
jae 0x282b
movl 0x14(%rsp), %esi
addl $0x41, %esi
movl 0x14(%rsp), %eax
movl %eax, %ecx
leaq 0x25554(%rip), %rax     # 0x27d60
movsbl (%rax,%rcx), %edx
leaq 0xd916(%rip), %rdi      # 0x1012d
movb $0x0, %al
callq 0x2110
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x27f1
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: StrMatch
char *StrMatch(char *s, const char *m)
{
   int i,j,k,l;

   k = strlen(s);
   l = strlen(m);

   for (j = 0 ; j <= k-l ; ++j)
   {
      if (s[j] == ';') break;  // don't search comment
      for (i = 0 ; i < l ; ++i)
      {
         if (toupper(s[j+i]) != toupper(m[i])) break;
      }
      if (i == l) return (s + j);
   }
   return NULL;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x20f0
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rdi
callq 0x20f0
movl %eax, 0x10(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movl 0x14(%rsp), %ecx
subl 0x10(%rsp), %ecx
cmpl %ecx, %eax
jg 0x296b
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x3b, %eax
jne 0x28de
jmp 0x296b
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x10(%rsp), %eax
jge 0x293b
movq 0x28(%rsp), %rax
movl 0x18(%rsp), %ecx
addl 0x1c(%rsp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %edi
callq 0x2080
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2080
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
je 0x292c
jmp 0x293b
jmp 0x292e
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x28e6
movl 0x1c(%rsp), %eax
cmpl 0x10(%rsp), %eax
jne 0x2959
movq 0x28(%rsp), %rax
movslq 0x18(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
jmp 0x2974
jmp 0x295b
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x28b2
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: StrKey
char *StrKey(char *s, const char *m)
{
   char *r = StrMatch(s,m);
   if (r) // match was true
   {
      if ((r > s && isalnum(*(r-1))) ||       // check before
         (isalnum(*(r+strlen(m))))) r = NULL; // check after
   }
   return r;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2880
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2a20
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jbe 0x29d6
callq 0x22e0
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movsbl -0x1(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x2a15
callq 0x22e0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x20f0
movq (%rsp), %rcx
movq %rax, %rdx
movq 0x8(%rsp), %rax
movsbl (%rcx,%rdx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x2a1e
movq $0x0, 0x10(%rsp)
jmp 0x2a20
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: GetSymbol
char *GetSymbol(char *p, char *s)
{
   if (*p == '.') // expand local symbol
   {
      if (Scope[0])
      {
         strcpy(s,Scope);
         s += strlen(s);
         *s++ = *p++;
      }
   }
   if (*p == '_' || isalpha(*p)) while (isym(*p)) *s++ = *p++;
   *s = 0;
   return p;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x2b11
cmpb $0x0, 0x252be(%rip)     # 0x27d80
je 0x2b0f
movq 0x8(%rsp), %rdi
leaq 0x252b0(%rip), %rsi     # 0x27d80
callq 0x2070
movq 0x8(%rsp), %rdi
callq 0x20f0
addq 0x8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movb (%rax), %cl
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %cl, (%rax)
jmp 0x2b11
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x5f, %eax
je 0x2b3f
callq 0x22e0
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
je 0x2b7d
jmp 0x2b41
movq 0x10(%rsp), %rax
movsbl (%rax), %edi
callq 0x2a30
cmpl $0x0, %eax
je 0x2b7b
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movb (%rax), %cl
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %cl, (%rax)
jmp 0x2b41
jmp 0x2b7d
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: GetMacroArg
char *GetMacroArg(char *p, char *s)
{
   p = SkipSpace(p);
   while (*p && *p != ',' && *p != ')') *s++ = *p++;
   *s = 0;
   return p;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x2830
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, 0x7(%rsp)
je 0x2be5
movq 0x10(%rsp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2c, %ecx
movb %al, 0x7(%rsp)
je 0x2be5
movq 0x10(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x29, %eax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x2bef
jmp 0x2c17
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movb (%rax), %cl
movq 0x8(%rsp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, 0x8(%rsp)
movb %cl, (%rax)
jmp 0x2bad
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: StrCaseCmp
int StrCaseCmp(const char *a, const char *b)
{
   unsigned int i,l,m;

   l = strlen(a);
   m = strlen(b);

   for (i=0 ; i <= l && i <= m ; ++i)
   {
      if (toupper(a[i]) < toupper(b[i])) return -1;
      if (toupper(a[i]) > toupper(b[i])) return  1;
   }
   return 0;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x20f0
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x20f0
movl %eax, 0x14(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %ecx
xorl %eax, %eax
cmpl 0x18(%rsp), %ecx
movb %al, 0x13(%rsp)
ja 0x2cc1
movl 0x1c(%rsp), %eax
cmpl 0x14(%rsp), %eax
setbe %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %al
testb $0x1, %al
jne 0x2cce
jmp 0x2d58
movq 0x28(%rsp), %rax
movl 0x1c(%rsp), %ecx
movsbl (%rax,%rcx), %edi
callq 0x2080
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rax
movl 0x1c(%rsp), %ecx
movsbl (%rax,%rcx), %edi
callq 0x2080
movl %eax, %ecx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x2d0a
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x2d60
movq 0x28(%rsp), %rax
movl 0x1c(%rsp), %ecx
movsbl (%rax,%rcx), %edi
callq 0x2080
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movl 0x1c(%rsp), %ecx
movsbl (%rax,%rcx), %edi
callq 0x2080
movl %eax, %ecx
movl 0x8(%rsp), %eax
cmpl %ecx, %eax
jle 0x2d46
movl $0x1, 0x34(%rsp)
jmp 0x2d60
jmp 0x2d48
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2ca2
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: strcmpword
int strcmpword(const char *s1, const char *s2)
{
   int l = strlen(s2);
   int r = StrNCaseCmp(s1,s2,l);
   if (r == 0 && isym(s1[l])) r = 1;
   return r;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x20f0
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
callq 0x2d70
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jne 0x2ed7
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2a30
cmpl $0x0, %eax
je 0x2ed7
movl $0x1, (%rsp)
movl (%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: SkipHexCode
char *SkipHexCode(char *p)
{
   int l;

   l = strlen(p);
   if (l > 20 && isdigit(p[4]) && isspace(p[5]) &&
       isxdigit(p[6]) && isxdigit(p[7]) &&
       isxdigit(p[8]) && isxdigit(p[9]) &&
       p[0] != ';')
   {
      if (SkipHex) memmove(Line,Line+20,l-19);
      else return (p+20);
   }
   return p;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x20f0
movl %eax, 0x4(%rsp)
cmpl $0x14, 0x4(%rsp)
jle 0x3025
callq 0x22e0
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movsbl 0x4(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x800, %eax            # imm = 0x800
cmpl $0x0, %eax
je 0x3025
callq 0x22e0
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movsbl 0x5(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x3025
callq 0x22e0
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movsbl 0x6(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x3025
callq 0x22e0
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movsbl 0x7(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x3025
callq 0x22e0
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movsbl 0x8(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x3025
callq 0x22e0
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movsbl 0x9(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x1000, %eax           # imm = 0x1000
cmpl $0x0, %eax
je 0x3025
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x3b, %eax
je 0x3025
cmpl $0x0, 0x24d3e(%rip)     # 0x27d30
je 0x3013
movl 0x4(%rsp), %eax
subl $0x13, %eax
movslq %eax, %rdx
leaq 0x24e7b(%rip), %rdi     # 0x27e80
leaq 0x24e88(%rip), %rsi     # 0x27e94
callq 0x2260
jmp 0x3023
movq 0x8(%rsp), %rax
addq $0x14, %rax
movq %rax, 0x10(%rsp)
jmp 0x302f
jmp 0x3025
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: ErrorLine
void ErrorLine(char *p)
{
   int i,ep;
   printf("%s\n",Line);
   ep = p - Line;
   if (ep >= 0 && ep < 80)
   {
      for (i=0 ; i < ep ; ++i) printf(" ");
      printf("^\n");
      return;
   }
   ep = p - OpText;
   if (ep >= 0 && ep < 80 && *OpText)
   {
      printf("Operand: %s\n",OpText);
      for (i=0 ; i < ep+9 ; ++i) printf(" ");
      printf("^\n");
      return;
   }

}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0xd13c(%rip), %rdi      # 0x1018c
leaq 0x24e29(%rip), %rsi     # 0x27e80
movb $0x0, %al
callq 0x2110
movq 0x10(%rsp), %rax
leaq 0x24e16(%rip), %rcx     # 0x27e80
subq %rcx, %rax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jl 0x30bf
cmpl $0x50, 0x8(%rsp)
jge 0x30bf
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x8(%rsp), %eax
jge 0x30ac
leaq 0xe596(%rip), %rdi      # 0x1162e
movb $0x0, %al
callq 0x2110
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3087
leaq 0xd082(%rip), %rdi      # 0x10135
movb $0x0, %al
callq 0x2110
jmp 0x3141
movq 0x10(%rsp), %rax
leaq 0x24eb5(%rip), %rcx     # 0x27f80
subq %rcx, %rax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jl 0x3141
cmpl $0x50, 0x8(%rsp)
jge 0x3141
movsbl 0x24e99(%rip), %eax     # 0x27f80
cmpl $0x0, %eax
je 0x3141
leaq 0xd045(%rip), %rdi      # 0x10138
leaq 0x24e86(%rip), %rsi     # 0x27f80
movb $0x0, %al
callq 0x2110
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl 0x8(%rsp), %ecx
addl $0x9, %ecx
cmpl %ecx, %eax
jge 0x3133
leaq 0xe50f(%rip), %rdi      # 0x1162e
movb $0x0, %al
callq 0x2110
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3109
leaq 0xcffb(%rip), %rdi      # 0x10135
movb $0x0, %al
callq 0x2110
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: ErrorMsg
void ErrorMsg(const char *format, ...) {
   va_list args;
   char *buf;

   buf = (char *)MallocOrDie(SIZE_ERRMSG);
   snprintf(buf, SIZE_ERRMSG, "\n*** Error in file %s line %d:\n",
         IncludeStack[IncludeLevel].Src, LiNo);
   va_start(args,format);
   vsnprintf(buf+strlen(buf), SIZE_ERRMSG-strlen(buf), format, args);
   va_end(args);
   fputs(Line, stdout);
   fputs(Line, lf);
   fputs(buf, stdout);
   fputs(buf, lf);
   if (df)
   {
      fputs(Line, df);
      fputs(buf, df);
      // ListSymbols(df,Labels,0,0xffff);
   }
   free(buf);
}

// Assembly:
subq $0xf8, %rsp
testb %al, %al
je 0x318f
movaps %xmm0, 0x40(%rsp)
movaps %xmm1, 0x50(%rsp)
movaps %xmm2, 0x60(%rsp)
movaps %xmm3, 0x70(%rsp)
movaps %xmm4, 0x80(%rsp)
movaps %xmm5, 0x90(%rsp)
movaps %xmm6, 0xa0(%rsp)
movaps %xmm7, 0xb0(%rsp)
movq %r9, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdi, 0xf0(%rsp)
movl $0x400, %edi            # imm = 0x400
callq 0x2620
movq %rax, 0xc8(%rsp)
movq 0xc8(%rsp), %rdi
movslq 0x2580f(%rip), %rcx     # 0x289e0
leaq 0x24ea8(%rip), %rax     # 0x28080
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rcx
movl 0x24b4e(%rip), %r8d     # 0x27d38
movl $0x400, %esi            # imm = 0x400
leaq 0xcf4f(%rip), %rdx      # 0x10145
movb $0x0, %al
callq 0x2130
leaq 0xd0(%rsp), %rax
leaq 0x10(%rsp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x100(%rsp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x8, (%rax)
movq 0xc8(%rsp), %rax
movq %rax, (%rsp)
movq 0xc8(%rsp), %rdi
callq 0x20f0
movq %rax, %rcx
movq (%rsp), %rax
addq %rcx, %rax
movq %rax, 0x8(%rsp)
movq 0xc8(%rsp), %rdi
callq 0x20f0
movq 0x8(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
subq %rax, %rsi
movq 0xf0(%rsp), %rdx
leaq 0xd0(%rsp), %rcx
callq 0x20d0
leaq 0xd0(%rsp), %rax
movq 0x11d4b(%rip), %rax     # 0x14fd8
movq (%rax), %rsi
leaq 0x24be9(%rip), %rdi     # 0x27e80
callq 0x2150
movq 0x25745(%rip), %rsi     # 0x289e8
leaq 0x24bd6(%rip), %rdi     # 0x27e80
callq 0x2150
movq 0xc8(%rsp), %rdi
movq 0x11d1a(%rip), %rax     # 0x14fd8
movq (%rax), %rsi
callq 0x2150
movq 0xc8(%rsp), %rdi
movq 0x25713(%rip), %rsi     # 0x289e8
callq 0x2150
cmpq $0x0, 0x2570e(%rip)     # 0x289f0
je 0x330b
movq 0x25705(%rip), %rsi     # 0x289f0
leaq 0x24b8e(%rip), %rdi     # 0x27e80
callq 0x2150
movq 0xc8(%rsp), %rdi
movq 0x256ea(%rip), %rsi     # 0x289f0
callq 0x2150
movq 0xc8(%rsp), %rdi
callq 0x2030
addq $0xf8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: PrintOC
void PrintOC(int v)
{

   if (!ListOn) return;
   // special format for 32 bit load

   if (oc == 0xcd) // LDQ immediate
   {
      fprintf(lf," cd %4.4x %4.4x",(v>>16)&0xffff,v&0xffff);
      return;
   }

   // opcode value is 16 or 8 bit

   if (oc > 255) fprintf(lf," %4.4x",oc);
   else          fprintf(lf,"   %2.2x",oc);

   // postbyte

   if (pb >= 0)  fprintf(lf," %2.2x",pb);
   else          fprintf(lf,"   ");

   // address or value 16 bit, 8 bit or none

        if (ql == 2) fprintf(lf," %4.4x",v&0xffff);
   else if (ql == 1) fprintf(lf,"   %2.2x",v&0xff);
   else              fprintf(lf,"     ");
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
cmpl $0x0, 0x11e0c(%rip)     # 0x15198
jne 0x3393
jmp 0x34ba
cmpl $0xcd, 0x2565f(%rip)    # 0x289fc
jne 0x33d0
movq 0x25642(%rip), %rdi     # 0x289e8
movl 0x4(%rsp), %edx
sarl $0x10, %edx
andl $0xffff, %edx           # imm = 0xFFFF
movl 0x4(%rsp), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
leaq 0xcda6(%rip), %rsi      # 0x1016a
movb $0x0, %al
callq 0x21e0
jmp 0x34ba
cmpl $0xff, 0x25622(%rip)    # 0x289fc
jle 0x33f9
movq 0x25605(%rip), %rdi     # 0x289e8
movl 0x25613(%rip), %edx     # 0x289fc
leaq 0xe0ee(%rip), %rsi      # 0x114de
movb $0x0, %al
callq 0x21e0
jmp 0x3414
movq 0x255e8(%rip), %rdi     # 0x289e8
movl 0x255f6(%rip), %edx     # 0x289fc
leaq 0xcd87(%rip), %rsi      # 0x10194
movb $0x0, %al
callq 0x21e0
cmpl $0x0, 0x255e5(%rip)     # 0x28a00
jl 0x343a
movq 0x255c4(%rip), %rdi     # 0x289e8
movl 0x255d6(%rip), %edx     # 0x28a00
leaq 0xcd65(%rip), %rsi      # 0x10196
movb $0x0, %al
callq 0x21e0
jmp 0x344f
movq 0x255a7(%rip), %rdi     # 0x289e8
leaq 0xe1e4(%rip), %rsi      # 0x1162c
movb $0x0, %al
callq 0x21e0
cmpl $0x2, 0x255ae(%rip)     # 0x28a04
jne 0x3479
movq 0x25589(%rip), %rdi     # 0x289e8
movl 0x4(%rsp), %edx
andl $0xffff, %edx           # imm = 0xFFFF
leaq 0xe06e(%rip), %rsi      # 0x114de
movb $0x0, %al
callq 0x21e0
jmp 0x34ba
cmpl $0x1, 0x25584(%rip)     # 0x28a04
jne 0x34a3
movq 0x2555f(%rip), %rdi     # 0x289e8
movl 0x4(%rsp), %edx
andl $0xff, %edx
leaq 0xccfa(%rip), %rsi      # 0x10194
movb $0x0, %al
callq 0x21e0
jmp 0x34b8
movq 0x2553e(%rip), %rdi     # 0x289e8
leaq 0xe179(%rip), %rsi      # 0x1162a
movb $0x0, %al
callq 0x21e0
jmp 0x34ba
popq %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: PrintByteLine
void PrintByteLine(int b)
{
   if (!ListOn || Pass) return;
   PrintLiNo();
   fprintf(lf,"       %2.2x",b);
   fprintf(lf,"         %s\n",Line);
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
cmpl $0x0, 0x11c4c(%rip)     # 0x15198
je 0x3557
cmpl $0x0, 0x254a3(%rip)     # 0x289f8
je 0x3559
jmp 0x3593
callq 0x3320
movq 0x25483(%rip), %rdi     # 0x289e8
movl 0x4(%rsp), %edx
leaq 0xcc20(%rip), %rsi      # 0x10190
movb $0x0, %al
callq 0x21e0
movq 0x2546a(%rip), %rdi     # 0x289e8
leaq 0xcbfe(%rip), %rsi      # 0x10183
leaq 0x248f4(%rip), %rdx     # 0x27e80
movb $0x0, %al
callq 0x21e0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: PrintWordLine
void PrintWordLine(int w)
{
   if (!ListOn || Pass) return;
   PrintLiNo();
   fprintf(lf,"%4.4x",w);
   fprintf(lf,"              %s\n",Line);
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
cmpl $0x0, 0x11bec(%rip)     # 0x15198
je 0x35b7
cmpl $0x0, 0x25443(%rip)     # 0x289f8
je 0x35b9
jmp 0x35f3
callq 0x3320
movq 0x25423(%rip), %rdi     # 0x289e8
movl 0x4(%rsp), %edx
leaq 0xdf0f(%rip), %rsi      # 0x114df
movb $0x0, %al
callq 0x21e0
movq 0x2540a(%rip), %rdi     # 0x289e8
leaq 0xcb99(%rip), %rsi      # 0x1017e
leaq 0x24894(%rip), %rdx     # 0x27e80
movb $0x0, %al
callq 0x21e0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: IsInstruction
int IsInstruction(char *p)
{
   int i,l;

   for (i = 0 ; i < DimOp ; ++i)
   {
      l = strlen(Mat[i].Mne);
      if (!StrNCaseCmp(p,Mat[i].Mne,l) && !isym(p[l]))
      {
         return i;
      }
   }
   return -1; // No mnemonic
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x13f75(%rip), %eax     # 0x17590
jge 0x368d
movslq 0x4(%rsp), %rax
leaq 0x11b77(%rip), %rdi     # 0x151a0
imulq $0x28, %rax, %rax
addq %rax, %rdi
callq 0x20f0
movl %eax, (%rsp)
movq 0x8(%rsp), %rdi
movslq 0x4(%rsp), %rax
leaq 0x11b57(%rip), %rsi     # 0x151a0
imulq $0x28, %rax, %rax
addq %rax, %rsi
movl (%rsp), %edx
callq 0x2d70
cmpl $0x0, %eax
jne 0x367e
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2a30
cmpl $0x0, %eax
jne 0x367e
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x3695
jmp 0x3680
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3611
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: ParseCaseData
char *ParseCaseData(char *p)
{
   p = SkipSpace(p);
        if (*p == '+') IgnoreCase = 0;
   else if (*p == '-') IgnoreCase = 1;
   else
   {
      ++ErrNum;
      ErrorMsg("Missing '+' or '-' after CASE\n");
      exit(1);
   }
   PrintLine();
   return p+1;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x2830
movq %rax, (%rsp)
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x371a
movl $0x0, 0x252f0(%rip)     # 0x28a08
jmp 0x375b
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x3732
movl $0x1, 0x252d8(%rip)     # 0x28a08
jmp 0x3759
movl 0x252d4(%rip), %eax     # 0x28a0c
addl $0x1, %eax
movl %eax, 0x252cb(%rip)     # 0x28a0c
leaq 0xca55(%rip), %rdi      # 0x1019d
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
jmp 0x375b
callq 0x34c0
movq (%rsp), %rax
addq $0x1, %rax
popq %rcx
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: ParseListOption
char *ParseListOption(char *p)
{
   p = SkipSpace(p);
        if (*p == '+') ListGlobal = 1;
   else if (*p == '-') ListGlobal = 0;
   else
   {
      ++ErrNum;
      ErrorMsg("Missing '+' or '-' after LIST\n");
      exit(1);
   }
   ListOn = ListGlobal;
   PrintLine();
   return p+1;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
callq 0x2830
movq %rax, (%rsp)
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2b, %eax
jne 0x379a
movl $0x1, 0x119fc(%rip)     # 0x15194
jmp 0x37db
movq (%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x37b2
movl $0x0, 0x119e4(%rip)     # 0x15194
jmp 0x37d9
movl 0x25254(%rip), %eax     # 0x28a0c
addl $0x1, %eax
movl %eax, 0x2524b(%rip)     # 0x28a0c
leaq 0xc9f4(%rip), %rdi      # 0x101bc
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
jmp 0x37db
movl 0x119b3(%rip), %eax     # 0x15194
movl %eax, 0x119b1(%rip)     # 0x15198
callq 0x34c0
movq (%rsp), %rax
addq $0x1, %rax
popq %rcx
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: SetBSS
char *SetBSS(char *p)
{
   p = NeedChar(p,'=');
   if (!p)
   {
      ++ErrNum;
      ErrorMsg("Missing '=' in set BSS & instruction\n");
      exit(1);
   }
   p = ExtractValue(p+1,&bss);
   if (ListOn && !Pass)
   {
      PrintLiNo();
      fprintf(lf,"%4.4x              %s\n",bss,Line);
   }
   return p;
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
movl $0x3d, %esi
callq 0x36a0
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x3845
movl 0x251e8(%rip), %eax     # 0x28a0c
addl $0x1, %eax
movl %eax, 0x251df(%rip)     # 0x28a0c
leaq 0xc9a7(%rip), %rdi      # 0x101db
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
movq (%rsp), %rdi
addq $0x1, %rdi
leaq 0x251bc(%rip), %rsi     # 0x28a10
callq 0x38a0
movq %rax, (%rsp)
cmpl $0x0, 0x11934(%rip)     # 0x15198
je 0x3896
cmpl $0x0, 0x2518b(%rip)     # 0x289f8
jne 0x3896
callq 0x3320
movq 0x2516d(%rip), %rdi     # 0x289e8
movl 0x2518f(%rip), %edx     # 0x28a10
leaq 0xc979(%rip), %rsi      # 0x10201
leaq 0x245f1(%rip), %rcx     # 0x27e80
movb $0x0, %al
callq 0x21e0
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: ExtractValue
char *ExtractValue(char *p, int *v)
{
   char *r; // pointer to trailing text after value (should be none)

   p = ExtractOpText(p);        // separate value string from comment
   if (OpText[0] == 0)
   {
      ErrorLine(p);
      ErrorMsg("Empty operand\n");
      exit(1);
   }
   r = EvalOperand(OpText,v,0); // evaluate integer value
   if (*r)                      // check for trailing text
   {
      ErrorLine(r);
      ErrorMsg("Extra text after operand\n");
      exit(1);
   }
   return p;                    // points to comment or EOL
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x3b70
movq %rax, 0x10(%rsp)
movsbl 0x246bc(%rip), %eax     # 0x27f80
cmpl $0x0, %eax
jne 0x38eb
movq 0x10(%rsp), %rdi
callq 0x3040
leaq 0xcc2f(%rip), %rdi      # 0x10509
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
movq 0x8(%rsp), %rsi
leaq 0x24689(%rip), %rdi     # 0x27f80
xorl %edx, %edx
callq 0x4740
movq %rax, (%rsp)
movq (%rsp), %rax
cmpb $0x0, (%rax)
je 0x392c
movq (%rsp), %rdi
callq 0x3040
leaq 0xcbfd(%rip), %rdi      # 0x10518
movb $0x0, %al
callq 0x3150
movl $0x1, %edi
callq 0x22b0
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: LabelIndex
int LabelIndex(char *p)
{
   int i;

   for (i = 0 ; i < Labels ; ++i)
   {
      if (!StrCmp(p,lab[i].Name)) return i;
   }
   return -1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x25009(%rip), %eax     # 0x28a14
jge 0x3a4b
movq 0x8(%rsp), %rdi
movslq 0x4(%rsp), %rcx
leaq 0x25002(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x3940
cmpl $0x0, %eax
jne 0x3a3c
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x3a53
jmp 0x3a3e
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3a01
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: AddressIndex
int AddressIndex(int a)
{
   int i;

   for (i = 0 ; i < Labels ; ++i)
   {
      if (lab[i].Address == a) return i;
   }
   return -1;
}

// Assembly:
movl %edi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
cmpl 0x24f9e(%rip), %eax     # 0x28a14
jge 0x3aad
movslq -0xc(%rsp), %rcx
leaq 0x24f9c(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
cmpl -0x8(%rsp), %eax
jne 0x3a9e
movl -0xc(%rsp), %eax
movl %eax, -0x4(%rsp)
jmp 0x3ab5
jmp 0x3aa0
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x3a6c
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: MacroIndex
int MacroIndex(char *p)
{
   int i,l;

   for (i = 0 ; i < Macros ; ++i)
   {
      l = strlen(Mac[i].Name);
      if (!StrnCmp(p,Mac[i].Name,l) && !isym(p[l])) return i;
   }
   return -1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x82b45(%rip), %eax     # 0x86620
jge 0x3b57
movslq 0x4(%rsp), %rcx
leaq 0x82b47(%rip), %rax     # 0x86630
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x20f0
movl %eax, (%rsp)
movq 0x8(%rsp), %rdi
movslq 0x4(%rsp), %rcx
leaq 0x82b24(%rip), %rax     # 0x86630
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movslq (%rsp), %rdx
callq 0x3990
cmpl $0x0, %eax
jne 0x3b45
movq 0x8(%rsp), %rax
movslq (%rsp), %rcx
movsbl (%rax,%rcx), %edi
callq 0x2a30
cmpl $0x0, %eax
jne 0x3b45
movl 0x4(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0x3b5f
jmp 0x3b47
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x3ad1
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Edilbert[P]BS9/bs9.c
// Function: SymRefs
void SymRefs(int i)
{
   int n;

   if (Pass) return;
   n = ++lab[i].NumRef;
   lab[i].Ref = (int *)ReallocOrDie(lab[i].Ref,(n+1)*sizeof(int));
   lab[i].Ref[n] = LiNo;
   lab[i].Att = (int *)ReallocOrDie(lab[i].Att,(n+1)*sizeof(int));
   lab[i].Att[n] = am;
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
cmpl $0x0, 0x23e2c(%rip)     # 0x289f8
je 0x4bd3
jmp 0x4cc0
movslq 0x4(%rsp), %rax
leaq 0x23e41(%rip), %rcx     # 0x28a20
imulq $0x30, %rax, %rax
addq %rax, %rcx
movl 0x18(%rcx), %eax
addl $0x1, %eax
movl %eax, 0x18(%rcx)
movl %eax, (%rsp)
movslq 0x4(%rsp), %rcx
leaq 0x23e22(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdi
movl (%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x2640
movq %rax, %rcx
movslq 0x4(%rsp), %rdx
leaq 0x23df6(%rip), %rax     # 0x28a20
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x20(%rax)
movl 0x230fd(%rip), %edx     # 0x27d38
movslq 0x4(%rsp), %rcx
leaq 0x23dd9(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
movslq (%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movslq 0x4(%rsp), %rcx
leaq 0x23dbb(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
movl (%rsp), %eax
addl $0x1, %eax
movslq %eax, %rsi
shlq $0x2, %rsi
callq 0x2640
movq %rax, %rcx
movslq 0x4(%rsp), %rdx
leaq 0x23d8f(%rip), %rax     # 0x28a20
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x28(%rax)
movl 0x833a2(%rip), %edx     # 0x88044
movslq 0x4(%rsp), %rcx
leaq 0x23d72(%rip), %rax     # 0x28a20
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rax
movslq (%rsp), %rcx
movl %edx, (%rax,%rcx,4)
popq %rax
retq
nopw %cs:(%rax,%rax)