LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_Update
void LCU_Update(LCU_type * lcu, LCLitem_t newitem) {
	int h;
	LCUITEM *il;

	lcu->n++;
	h=hash31(lcu->a,lcu->b,newitem) % lcu->tblsz;
	il=lcu->hashtable[h];
	while (il) {
		if (il->item == newitem) 
			break;
		il=il->nexti;
	}
	if (il==NULL) // item is not monitored (not in hashtable) 
	{
		il=LCU_GetNewCounter(lcu);
		/// and put it into the hashtable for the new item 
		il->delta=lcu->root->count;
		// initialize delta with count of first group
		LCU_InsertIntoHashtable(lcu,il,h,newitem);
		// put the new counter into the first group
		// counter is already in first group by defn of how we got it
		LCU_IncrementCounter(lcu, il);
	}
	else 
		LCU_IncrementCounter(lcu, il);
	// if we have an item, we need to increment its counter 
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
incl (%rdi)
movl %esi, %ebp
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rsi
movl %ebp, %edx
callq 0x24a5
movslq 0xc(%rbx), %rcx
cqto
idivq %rcx
movq %rdx, %r14
movq 0x40(%rbx), %rax
movq (%rax,%rdx,8), %rsi
testq %rsi, %rsi
je 0x1ffd
cmpl %ebp, (%rsi)
je 0x203c
movq 0x20(%rsi), %rsi
jmp 0x1fee
movq %rbx, %rdi
callq 0x1e6e
movq %rax, %rsi
movq 0x20(%rbx), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsi)
movq 0x40(%rbx), %rax
movq (%rax,%r14,8), %rcx
movq %rcx, 0x20(%rsi)
movl %ebp, (%rsi)
movl %r14d, 0x4(%rsi)
movq $0x0, 0x18(%rsi)
movq (%rax,%r14,8), %rcx
testq %rcx, %rcx
je 0x2038
movq %rsi, 0x18(%rcx)
movq %rsi, (%rax,%r14,8)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1f94
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_PointEstUpp
int LCU_PointEstUpp(LCU_type * lcu, LCLitem_t newitem) {
	int h;
	LCUITEM *il;

	lcu->n++;
	h=hash31(lcu->a,lcu->b,newitem) % lcu->tblsz;
	il=lcu->hashtable[h];
	while (il) {
		if (il->item == newitem) 
			return il->parentg->count;
		il=il->nexti;
	}
	return (lcu->root != NULL ? lcu->root->count : 0);
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl (%rdi)
movl %esi, %ebp
movq 0x10(%rdi), %rdi
movq 0x18(%rbx), %rsi
movl %ebp, %edx
callq 0x24a5
movslq 0xc(%rbx), %rcx
cqto
idivq %rcx
movq 0x40(%rbx), %rax
movq (%rax,%rdx,8), %rax
testq %rax, %rax
je 0x20c5
cmpl %ebp, (%rax)
je 0x20d2
movq 0x20(%rax), %rax
jmp 0x20b6
movq 0x20(%rbx), %rax
testq %rax, %rax
jne 0x20d6
xorl %eax, %eax
jmp 0x20d8
movq 0x10(%rax), %rax
movl (%rax), %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/ulossycount.c
// Function: LCU_PointEstLow
int LCU_PointEstLow(LCU_type * lcu, LCLitem_t newitem) {
	int h;
	LCUITEM *il;

	lcu->n++;
	h=hash31(lcu->a,lcu->b,newitem) % lcu->tblsz;
	il=lcu->hashtable[h];
	while (il) {
		if (il->item == newitem) 
			return thismax(il->parentg->count - il->delta, 0);
		il=il->nexti;
	}
	return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
incl (%rdi)
movl %esi, %ebx
movq 0x10(%rdi), %rdi
movq 0x18(%r14), %rsi
movl %ebx, %edx
callq 0x24a5
movslq 0xc(%r14), %rcx
cqto
idivq %rcx
movq 0x40(%r14), %rax
movq (%rax,%rdx,8), %rax
testq %rax, %rax
je 0x2121
cmpl %ebx, (%rax)
je 0x2125
movq 0x20(%rax), %rax
jmp 0x2112
xorl %eax, %eax
jmp 0x2135
movq 0x10(%rax), %rcx
movl (%rcx), %ecx
subl 0x8(%rax), %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/hashtable.c
// Function: HT_Clear
void HT_Clear(LL ** hashtable, int size) { //destroy
	int i;
	LL * ptr, * tmp;
	for (i = 0; i < size; i++) {
		ptr = hashtable[i];
		hashtable[i] = NULL;
		while (ptr) {
			tmp = ptr->next;
			free(ptr);
			ptr = tmp;
		}
	}
	free(hashtable);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
jle 0x218c
movl %esi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
movq $0x0, (%rbx,%r15,8)
testq %rdi, %rdi
je 0x2184
movq 0x10(%rdi), %r12
callq 0x1050
movq %r12, %rdi
testq %r12, %r12
jne 0x2173
incq %r15
cmpq %r14, %r15
jne 0x2162
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1050
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/hashtable.c
// Function: HT_Insert
LL * HT_Insert(LL ** hashtable, int64__t item, int val, int size) { //if item already exists just return the pointer, otherwise insert and set val
	int hash = (int) hash31(HASHA_VAL, HASHB_VAL, item) % size;

	//ptr is the start of the list
	LL * ptr = hashtable[hash];

	//search thru the list
	while (ptr) {
		if (ptr->item == item) return ptr; //if we have found it, we are done
		ptr = ptr->next; //keep looking
	}
	
	//if we get here then ptr = NULL and we aren't in the list yet so we may prepend it to the list
	ptr = (LL*) calloc(1, sizeof(LL));
	ptr->item = item;
	ptr->val = val;
	ptr->next = hashtable[hash];
	ptr->prev = NULL;
	if (hashtable[hash] != NULL) hashtable[hash]->prev = ptr;
	hashtable[hash] = ptr;
	return ptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movl $0x9041077, %edi        # imm = 0x9041077
movl $0x66939d, %esi         # imm = 0x66939D
movq %r14, %rdx
callq 0x24a5
cltd
idivl %r15d
movslq %edx, %r15
movq (%rbx,%r15,8), %r12
testq %r12, %r12
je 0x21e5
movq %r12, %rax
cmpq %r14, (%rax)
je 0x220c
movq 0x10(%rax), %rax
testq %rax, %rax
jne 0x21d7
movl $0x1, %edi
movl $0x20, %esi
callq 0x1110
movq %r14, (%rax)
movl %ebp, 0x8(%rax)
movq %r12, 0x10(%rax)
testq %r12, %r12
je 0x2208
movq %rax, 0x18(%r12)
movq %rax, (%rbx,%r15,8)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/hashtable.c
// Function: HT_Find
LL * HT_Find(LL ** hashtable, int64__t item, int size) { //find the LL corresponding to the item. All updates happen via this, as do removes
	int hash = (int) hash31(HASHA_VAL, HASHB_VAL, item) % size;

	//ptr is the start of the list
	LL * ptr = hashtable[hash];

	//search thru the list
	while (ptr) {
		if (ptr->item == item) return ptr; //if we have found it, we are done
		ptr = ptr->next; //keep looking
	}
	//can't find
	return NULL;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movl $0x9041077, %edi        # imm = 0x9041077
movl $0x66939d, %esi         # imm = 0x66939D
movq %rbx, %rdx
callq 0x24a5
cltd
idivl %ebp
movslq %edx, %rax
movq (%r14,%rax,8), %rax
testq %rax, %rax
je 0x224d
cmpq %rbx, (%rax)
je 0x224f
movq 0x10(%rax), %rax
jmp 0x223d
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/prng.c
// Function: LLMedSelect
int64__t LLMedSelect(int k, int n, int64__t arr[]) {
  int64__t a, temp;

  int i, ir, j, mid, l;

  l=1;
  ir=n;
  for (;;) {
    if (ir <= l+1) {
      if (ir == l+1 && arr[ir] < arr[l]) {
	SWAP(arr[l],arr[ir])
	  }
      return arr[k];
    }
    else
      {
	mid=(l+ir) >> 1;
	SWAP(arr[mid],arr[l+1])
	  if (arr[l] > arr[ir]) {
	    SWAP(arr[l],arr[ir])
	      }
	if (arr[l+1] > arr[ir]) {
	  SWAP(arr[l+1],arr[ir])
	    }
	if (arr[l] > arr[l+1]) {
	  SWAP(arr[l],arr[l+1])
	    }
	i=l+1;
	j=ir;
	a=arr[l+1];
	for (;;) {
	  do i++; while (arr[i] < a);
	  do j--; while (arr[j] > a);
	  if (j < i) break;
	  SWAP(arr[i],arr[j])
	    }
	arr[l+1]=arr[j];
	arr[j]=a;
	if (j >= k) ir=j-1;
	if (j <= k) l=i;
      }
  }

    }

// Assembly:
cmpl $0x3, %esi
jl 0x236b
pushq %r14
pushq %rbx
movl $0x1, %ecx
movl $0x2, %eax
leal (%rcx,%rsi), %r8d
sarl %r8d
movslq %r8d, %r9
movq (%rdx,%r9,8), %r10
movslq %eax, %r8
movq (%rdx,%r8,8), %r11
movq %r11, (%rdx,%r9,8)
movq %r10, (%rdx,%r8,8)
movslq %ecx, %r11
movq (%rdx,%r11,8), %rbx
movslq %esi, %r9
movq (%rdx,%r9,8), %r14
cmpq %r14, %rbx
jle 0x22d8
movq %r14, (%rdx,%r11,8)
movq %rbx, (%rdx,%r9,8)
movq (%rdx,%r8,8), %r10
jmp 0x22db
movq %r14, %rbx
cmpq %rbx, %r10
jle 0x22ec
movq %rbx, (%rdx,%r8,8)
movq %r10, (%rdx,%r9,8)
movq (%rdx,%r8,8), %r10
movq (%rdx,%r11,8), %r9
cmpq %r10, %r9
jle 0x22ff
movq %r10, (%rdx,%r11,8)
movq %r9, (%rdx,%r8,8)
jmp 0x2302
movq %r10, %r9
movl %esi, %r10d
cltq
movq 0x8(%rdx,%rax,8), %r11
incq %rax
cmpq %r9, %r11
jl 0x2307
movslq %r10d, %rbx
incq %rbx
movq -0x10(%rdx,%rbx,8), %r14
decl %r10d
decq %rbx
cmpq %r9, %r14
jg 0x231a
cmpq %rax, %rbx
jle 0x233a
movq %r14, (%rdx,%rax,8)
movq %r11, -0x8(%rdx,%rbx,8)
jmp 0x2305
leal 0x1(%r10), %r11d
movq %r14, (%rdx,%r8,8)
movq %r9, -0x8(%rdx,%rbx,8)
leal -0x1(%r10), %r8d
cmpl %edi, %r11d
cmovgl %r8d, %esi
cmpl %edi, %r10d
cmovlel %eax, %ecx
leal 0x1(%rcx), %eax
cmpl %eax, %esi
jg 0x229a
movslq %ecx, %rcx
popq %rbx
popq %r14
jmp 0x2375
movl $0x2, %eax
movl $0x1, %ecx
cmpl %eax, %esi
jne 0x2391
movslq %esi, %rax
movq (%rdx,%rax,8), %rsi
movq (%rdx,%rcx,8), %r8
cmpq %r8, %rsi
jge 0x2391
movq %rsi, (%rdx,%rcx,8)
movq %r8, (%rdx,%rax,8)
movslq %edi, %rax
movq (%rdx,%rax,8), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/prng.c
// Function: MedSelect
int MedSelect(int k, int n, int arr[]) {
  int a, temp;

  int i, ir, j, mid, l;

  l=1;
  ir=n;
  for (;;) {
    if (ir <= l+1) {
      if (ir == l+1 && arr[ir] < arr[l]) {
	SWAP(arr[l],arr[ir])
	  }
      return arr[k];
    }
    else
      {
	mid=(l+ir) >> 1;
	SWAP(arr[mid],arr[l+1])
	  if (arr[l] > arr[ir]) {
	    SWAP(arr[l],arr[ir])
	      }
	if (arr[l+1] > arr[ir]) {
	  SWAP(arr[l+1],arr[ir])
	    }
	if (arr[l] > arr[l+1]) {
	  SWAP(arr[l],arr[l+1])
	    }
	i=l+1;
	j=ir;
	a=arr[l+1];
	for (;;) {
	  do i++; while (arr[i] < a);
	  do j--; while (arr[j] > a);
	  if (j < i) break;
	  SWAP(arr[i],arr[j])
	    }
	arr[l+1]=arr[j];
	arr[j]=a;
	if (j >= k) ir=j-1;
	if (j <= k) l=i;
      }
  }
}

// Assembly:
cmpl $0x3, %esi
jl 0x247a
pushq %rbp
pushq %rbx
movl $0x1, %ecx
movl $0x2, %eax
leal (%rcx,%rsi), %r8d
sarl %r8d
movslq %r8d, %r9
movl (%rdx,%r9,4), %r10d
movslq %eax, %r8
movl (%rdx,%r8,4), %r11d
movl %r11d, (%rdx,%r9,4)
movl %r10d, (%rdx,%r8,4)
movslq %ecx, %r11
movl (%rdx,%r11,4), %ebx
movslq %esi, %r9
movl (%rdx,%r9,4), %ebp
cmpl %ebp, %ebx
jle 0x23eb
movl %ebp, (%rdx,%r11,4)
movl %ebx, (%rdx,%r9,4)
movl (%rdx,%r8,4), %r10d
jmp 0x23ed
movl %ebp, %ebx
cmpl %ebx, %r10d
jle 0x23fe
movl %ebx, (%rdx,%r8,4)
movl %r10d, (%rdx,%r9,4)
movl (%rdx,%r8,4), %r10d
movl (%rdx,%r11,4), %r9d
cmpl %r10d, %r9d
jle 0x2411
movl %r10d, (%rdx,%r11,4)
movl %r9d, (%rdx,%r8,4)
jmp 0x2414
movl %r10d, %r9d
movl %esi, %r10d
cltq
movl 0x4(%rdx,%rax,4), %r11d
incq %rax
cmpl %r9d, %r11d
jl 0x2419
movslq %r10d, %rbx
incq %rbx
movl -0x8(%rdx,%rbx,4), %ebp
decl %r10d
decq %rbx
cmpl %r9d, %ebp
jg 0x242c
cmpq %rax, %rbx
jle 0x244a
movl %ebp, (%rdx,%rax,4)
movl %r11d, -0x4(%rdx,%rbx,4)
jmp 0x2417
leal 0x1(%r10), %r11d
movl %ebp, (%rdx,%r8,4)
movl %r9d, -0x4(%rdx,%rbx,4)
leal -0x1(%r10), %r8d
cmpl %edi, %r11d
cmovgl %r8d, %esi
cmpl %edi, %r10d
cmovlel %eax, %ecx
leal 0x1(%rcx), %eax
cmpl %eax, %esi
jg 0x23ae
movslq %ecx, %rcx
popq %rbx
popq %rbp
jmp 0x2484
movl $0x2, %eax
movl $0x1, %ecx
cmpl %eax, %esi
jne 0x249e
movslq %esi, %rax
movl (%rdx,%rax,4), %esi
movl (%rdx,%rcx,4), %r8d
cmpl %r8d, %esi
jge 0x249e
movl %esi, (%rdx,%rcx,4)
movl %r8d, (%rdx,%rax,4)
movslq %edi, %rax
movl (%rdx,%rax,4), %eax
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/prng.c
// Function: ran1
float ran1(prng_type * prng) {

  // A Random Number Generator that picks a uniform [0,1] random number
  // From Numerical Recipes, page 280
  // Should be called with a NEGATIVE value of idum to initialize
  // subsequent calls should not alter idum

  int j;
  long k;
  float temp;

  if (prng->floatidum <= 0 || !prng->iy) {
    if (-(prng->floatidum) < 1) prng->floatidum=1;
    else prng->floatidum = -(prng->floatidum);
    for (j=NTAB+7;j>=0;j--) {
      k=(prng->floatidum)/IQ;
      prng->floatidum=IA*(prng->floatidum-k*IQ)-IR*k;
      if (prng->floatidum < 0) prng->floatidum+=IM;
      if (j<NTAB) prng->iv[j]=prng->floatidum;
    }
    prng->iy=prng->iv[0];
  }
  k = (prng->floatidum)/IQ;
  prng->floatidum=IA*(prng->floatidum-k*IQ)-IR*k;
  if (prng->floatidum<0) prng->floatidum += IM;
  j = prng->iy/NDIV;
  prng->iy=prng->iv[j];
  prng->iv[j]=prng->floatidum;
  if ((temp=AM*prng->iy) > RNMX) return RNMX;
  else return temp;
}

// Assembly:
movq 0x8(%rdi), %rcx
movabsq $0x41a705af1fe3fb79, %rsi # imm = 0x41A705AF1FE3FB79
testq %rcx, %rcx
jle 0x2515
movq 0x18(%rdi), %r8
testq %r8, %r8
jne 0x2584
movq %rcx, %rax
negq %rax
testq %rcx, %rcx
movl $0x1, %ecx
cmovsq %rax, %rcx
movl $0x27, %r8d
movq %rcx, %rax
imulq %rsi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0x1f31d, %rdx, %rax   # imm = 0xFFFE0CE3
addq %rcx, %rax
imulq $0x41a7, %rax, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rdx     # imm = 0xF4EC
leaq (%rax,%rdx), %rcx
addq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
addq %rdx, %rax
cmovnsq %rax, %rcx
cmpq $0x1f, %r8
ja 0x2576
movq %rcx, 0x20(%rdi,%r8,8)
addq $-0x1, %r8
jb 0x252d
movq 0x20(%rdi), %r8
movq %r8, 0x18(%rdi)
movq %rcx, %rax
imulq %rsi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0x1f31d, %rdx, %rax   # imm = 0xFFFE0CE3
addq %rcx, %rax
imulq $0x41a7, %rax, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rcx     # imm = 0xF4EC
leaq (%rax,%rcx), %rdx
addq $0x7fffffff, %rdx       # imm = 0x7FFFFFFF
addq %rcx, %rax
cmovnsq %rax, %rdx
leaq 0x3ffffff(%r8), %rax
testq %r8, %r8
cmovnsq %r8, %rax
movq %rdx, 0x8(%rdi)
shrq $0x1a, %rax
cltq
movq 0x20(%rdi,%rax,8), %rcx
movq %rcx, 0x18(%rdi)
movq %rdx, 0x20(%rdi,%rax,8)
cvtsi2sdq 0x18(%rdi), %xmm0
mulsd 0xbba(%rip), %xmm0      # 0x31b0
cvtsd2ss %xmm0, %xmm0
cvtss2sd %xmm0, %xmm1
ucomisd 0xbb2(%rip), %xmm1      # 0x31b8
jbe 0x2610
movss 0xbe0(%rip), %xmm0      # 0x31f0
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/prng.c
// Function: ran2
long ran2(prng_type * prng) {

  // A Random Number Generator that picks a uniform random number
  // from the range of long integers.
  // From Numerical Recipes, page 280
  // Should be called with a NEGATIVE value of idum to initialize
  // subsequent calls should not alter idum
  // This is a hacked version of the above procedure, so proceed with
  // caution.

  int j;
  long k;

  if (prng->intidum <= 0 || !prng->iy) {
    if (-(prng->intidum) < 1) prng->intidum=1;
    else prng->intidum = -(prng->intidum);
    for (j=NTAB+7;j>=0;j--) {
      k=(prng->intidum)/IQ;
      prng->intidum=IA*(prng->intidum-k*IQ)-IR*k;
      if (prng->intidum < 0) prng->intidum+=IM;
      if (j<NTAB) prng->iv[j]=prng->intidum;
    }
    prng->iy=prng->iv[0];
  }
  k = (prng->intidum)/IQ;
  prng->intidum=IA*(prng->intidum-k*IQ)-IR*k;
  if (prng->intidum<0) prng->intidum += IM;
  j = prng->iy/NDIV;
  prng->iy=prng->iv[j];
  prng->iv[j]=prng->intidum;
  return prng->iy;
}

// Assembly:
movq 0x10(%rdi), %rcx
movabsq $0x41a705af1fe3fb79, %rsi # imm = 0x41A705AF1FE3FB79
testq %rcx, %rcx
jle 0x262d
movq 0x18(%rdi), %r8
testq %r8, %r8
jne 0x269c
movq %rcx, %rax
negq %rax
testq %rcx, %rcx
movl $0x1, %ecx
cmovsq %rax, %rcx
movl $0x27, %r8d
movq %rcx, %rax
imulq %rsi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0x1f31d, %rdx, %rax   # imm = 0xFFFE0CE3
addq %rcx, %rax
imulq $0x41a7, %rax, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rdx     # imm = 0xF4EC
leaq (%rax,%rdx), %rcx
addq $0x7fffffff, %rcx       # imm = 0x7FFFFFFF
addq %rdx, %rax
cmovnsq %rax, %rcx
cmpq $0x1f, %r8
ja 0x268e
movq %rcx, 0x20(%rdi,%r8,8)
addq $-0x1, %r8
jb 0x2645
movq 0x20(%rdi), %r8
movq %r8, 0x18(%rdi)
movq %rcx, %rax
imulq %rsi
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0xf, %rdx
addq %rax, %rdx
imulq $-0x1f31d, %rdx, %rax   # imm = 0xFFFE0CE3
addq %rcx, %rax
imulq $0x41a7, %rax, %rax     # imm = 0x41A7
imulq $-0xb14, %rdx, %rcx     # imm = 0xF4EC
leaq (%rax,%rcx), %rdx
addq $0x7fffffff, %rdx       # imm = 0x7FFFFFFF
addq %rcx, %rax
cmovnsq %rax, %rdx
leaq 0x3ffffff(%r8), %rax
testq %r8, %r8
cmovnsq %r8, %rax
movq %rdx, 0x10(%rdi)
shrq $0x1a, %rax
cltq
movq 0x20(%rdi,%rax,8), %rcx
movq %rcx, 0x18(%rdi)
movq %rdx, 0x20(%rdi,%rax,8)
movq 0x18(%rdi), %rax
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/prng.c
// Function: ran3
unsigned long ran3(prng_type * prng) {

  unsigned long x;

  /* generate next random number */

  x = prng->randbuffer[prng->r_p1] = rotl(prng->randbuffer[prng->r_p2], R1)
    +  rotl(prng->randbuffer[prng->r_p1], R2);
  /* rotate list pointers */
  if (--prng->r_p1 < 0) prng->r_p1 = KK - 1;
  if (--prng->r_p2 < 0) prng->r_p2 = KK - 1;
  /* conversion to float */
  return x;
}

// Assembly:
movq 0x1a8(%rdi), %rax
movq %rax, %xmm0
movq %rax, %rcx
sarq $0x20, %rcx
movq 0x120(%rdi,%rcx,8), %rcx
rolq $0x5, %rcx
movslq %eax, %rdx
movq 0x120(%rdi,%rdx,8), %rax
rolq $0x3, %rax
addq %rcx, %rax
pcmpeqd %xmm1, %xmm1
paddd %xmm0, %xmm1
pxor %xmm2, %xmm2
pcmpgtd %xmm2, %xmm0
pand %xmm0, %xmm1
pandn 0xaa4(%rip), %xmm0      # 0x3200
movq %rax, 0x120(%rdi,%rdx,8)
por %xmm1, %xmm0
movq %xmm0, 0x1a8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/prng.c
// Function: RanrotAInit
void RanrotAInit (prng_type * prng, unsigned long seed) {

  int i;

  /* put semi-random numbers into the buffer */
  for (i=0; i<KK; i++) {
    prng->randbuffer[i] = seed;
    seed = rotl(seed,5) + 97;}

  /* initialize pointers to circular buffer */
  prng->r_p1 = 0;  prng->r_p2 = JJ;

  /* randomize */
  for (i = 0;  i < 300;  i++) ran3(prng);
  prng->scale = ldexp(1.0f, -8.0f * sizeof(unsigned long));
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movq %rsi, 0x120(%rbx,%rax,8)
rolq $0x5, %rsi
addq $0x61, %rsi
incq %rax
cmpq $0x11, %rax
jne 0x2806
xorl %edx, %edx
movl $0xa, %esi
movl $0x12c, %eax            # imm = 0x12C
movl $0x10, %ecx
movslq %esi, %rdi
movq 0x120(%rbx,%rdi,8), %rsi
rolq $0x5, %rsi
movslq %edx, %r8
movq 0x120(%rbx,%r8,8), %rdx
rolq $0x3, %rdx
addq %rsi, %rdx
movq %rdx, 0x120(%rbx,%r8,8)
leal -0x1(%r8), %edx
testl %r8d, %r8d
cmovlel %ecx, %edx
leal -0x1(%rdi), %esi
testl %edi, %edi
cmovlel %ecx, %esi
decl %eax
jne 0x2830
movl %esi, 0x1ac(%rbx)
movl %edx, 0x1a8(%rbx)
movsd 0x785(%rip), %xmm0      # 0x3008
movl $0xffffffc0, %edi       # imm = 0xFFFFFFC0
callq 0x1060
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x4(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/prng.c
// Function: prng_int
long prng_int(prng_type * prng) {

  // returns a pseudo-random long integer.  Initialise the generator
  // before use!

  long response=0;

  switch (prng->usenric)
    {
    case 1 : response=(ran2(prng)); break;
    case 2 : response=(ran3(prng)); break;
    case 3 : response=(lrand48()); break;
    }
  return response;
}

// Assembly:
movl (%rdi), %eax
cmpl $0x3, %eax
je 0x1150
cmpl $0x2, %eax
je 0x28b4
cmpl $0x1, %eax
je 0x2611
xorl %eax, %eax
retq
movq 0x1a8(%rdi), %rcx
movq %rcx, %rax
sarq $0x20, %rax
movq 0x120(%rdi,%rax,8), %rdx
rolq $0x5, %rdx
movslq %ecx, %rsi
movq 0x120(%rdi,%rsi,8), %rax
rolq $0x3, %rax
movq %rcx, %xmm0
addq %rdx, %rax
movq %rax, 0x120(%rdi,%rsi,8)
pcmpeqd %xmm1, %xmm1
paddd %xmm0, %xmm1
pxor %xmm2, %xmm2
pcmpgtd %xmm2, %xmm0
pand %xmm0, %xmm1
pandn 0x8f7(%rip), %xmm0      # 0x3200
por %xmm1, %xmm0
movq %xmm0, 0x1a8(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/prng.c
// Function: prng_float
float prng_float(prng_type * prng) {

  // returns a pseudo-random float in the range [0.0,1.0].
  // Initialise the generator before use!
  float result=0;

  switch (prng->usenric)
    {
    case 1 : result=(ran1(prng)); break;
    case 2 : result=(ran4(prng)); break;
    case 3 : result=(drand48()); break;
    }
  return result;
}

// Assembly:
movl (%rdi), %eax
cmpl $0x3, %eax
je 0x29a4
cmpl $0x2, %eax
je 0x2937
xorps %xmm0, %xmm0
cmpl $0x1, %eax
jne 0x29b2
jmp 0x24f9
movq 0x1a8(%rdi), %rcx
movq %rcx, %rax
sarq $0x20, %rax
movq 0x120(%rdi,%rax,8), %rdx
rolq $0x5, %rdx
movslq %ecx, %rsi
movq 0x120(%rdi,%rsi,8), %rax
rolq $0x3, %rax
movq %rcx, %xmm0
addq %rdx, %rax
movq %rax, 0x120(%rdi,%rsi,8)
pcmpeqd %xmm1, %xmm1
paddd %xmm0, %xmm1
pxor %xmm2, %xmm2
pcmpgtd %xmm2, %xmm0
pand %xmm0, %xmm1
pandn 0x874(%rip), %xmm0      # 0x3200
por %xmm1, %xmm0
movq %xmm0, 0x1a8(%rdi)
js 0x29b3
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
jmp 0x29cb
pushq %rax
callq 0x11f0
cvtsd2ss %xmm0, %xmm0
addq $0x8, %rsp
retq
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
mulss 0x4(%rdi), %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/prng.c
// Function: prng_Init
prng_type * prng_Init(long seed, int nric) {

  // Initialise the random number generators.  nric determines
  // which algorithm to use, 1 for Numerical Recipes in C,
  // 0 for the other one.
  prng_type * result;

  result=(prng_type *) calloc(1,sizeof(prng_type));

  result->iy=0;
  result->usenric=nric;
  result->floatidum=-1;
  result->intidum=-1;
  result->iset=0;
  // set a global variable to record which algorithm to use
  switch (nric)
    {
    case 2 :
      RanrotAInit(result,seed);
      break;
    case 1 :
      if (seed>0) {
	// to initialise the NRiC PRNGs, call it with a negative value
	// so make sure it gets a negative value!
	result->floatidum = -(seed);  result->intidum = -(seed);
      } else {
	result->floatidum=seed; result->intidum=seed;
      }
      break;
    case 3 :
      srand48(seed);
      break;
    }

  prng_float(result);
  prng_int(result);
  // call the routines to actually initialise them
  return(result);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
movl $0x1, %edi
movl $0x1c0, %esi            # imm = 0x1C0
callq 0x1110
movq %rax, %rbx
movl %ebp, (%rax)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x8(%rax)
cmpl $0x1, %ebp
je 0x2a1d
cmpl $0x3, %ebp
je 0x2a13
cmpl $0x2, %ebp
jne 0x2a2d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2800
jmp 0x2a2d
movq %r14, %rdi
callq 0x1170
jmp 0x2a2d
testq %r14, %r14
jle 0x2a25
negq %r14
movq %r14, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rdi
callq 0x2916
movq %rbx, %rdi
callq 0x2898
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/prng.c
// Function: prng_normal
double prng_normal(prng_type * prng) {

  // Pick random values distributed N(0,1) using the Box-Muller transform
  // Taken from numerical recipes in C p289
  // picks two at a time, returns one per call (buffers the other)

  double fac,rsq,v1,v2;
  if (prng->iset == 0) {
    do {
      v1 = 2.0*prng_float(prng)-1.0;
      v2 = 2.0*prng_float(prng)-1.0;
      rsq=v1*v1+v2*v2;
    } while (rsq >= 1.0 || rsq == 0.0);

    fac = sqrt((double) -2.0*log((double)rsq)/rsq);
    prng->gset=v1*fac;
    prng->iset=1;
    return v2*fac;
  }
  else {
    prng->iset = 0;
    return prng->gset;
  }
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
cmpl $0x0, 0x1b0(%rdi)
je 0x2aa1
movl $0x0, 0x1b0(%rbx)
movsd 0x1b8(%rbx), %xmm1
jmp 0x2b67
movq %rbx, %rdi
callq 0x2916
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
addsd %xmm1, %xmm1
movsd 0x5a4(%rip), %xmm0      # 0x3060
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movq %rbx, %rdi
callq 0x2916
xorps %xmm1, %xmm1
cvtss2sd %xmm0, %xmm1
addsd %xmm1, %xmm1
addsd 0x57f(%rip), %xmm1      # 0x3060
movapd %xmm1, %xmm2
mulsd %xmm1, %xmm2
movsd 0x8(%rsp), %xmm0
mulsd %xmm0, %xmm0
addsd %xmm2, %xmm0
ucomisd 0x509(%rip), %xmm0      # 0x3008
jae 0x2aa1
ucomisd 0x517(%rip), %xmm0      # 0x3020
jne 0x2b0d
jnp 0x2aa1
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x10(%rsp)
callq 0x10d0
mulsd 0x69a(%rip), %xmm0      # 0x31c0
divsd 0x10(%rsp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2b3c
sqrtsd %xmm0, %xmm0
jmp 0x2b41
callq 0x11c0
movsd 0x8(%rsp), %xmm1
mulsd %xmm0, %xmm1
movsd %xmm1, 0x1b8(%rbx)
movl $0x1, 0x1b0(%rbx)
movsd 0x18(%rsp), %xmm1
mulsd %xmm0, %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/prng.c
// Function: prng_stabledbn
double prng_stabledbn(prng_type * prng, double alpha) {

  // From 'stable distributions', John Nolan, manuscript, p24
  // we set beta = 0 by analogy with the normal and cauchy case
  // identical to the above routine, but returns a double instead
  // of a long double (you'll see this a lot...)

  double theta, W, holder, left, right;

  theta=PI*(prng_float(prng) - 0.5);
  W = -log(prng_float(prng)); // takes natural log

  //  printf("theta %Lf, W = %Lf \n", theta, W);

  // some notes on Nolan's notes:
  // if beta == 0 then c(alpha,beta)=1; theta_0 = 0
  // expression reduces to sin alpha.theta / (cos theta) ^1/alpha
  //  * (cos (theta - alpha theta)/W) ^(1-alpha)/alpha
  left = (sin(alpha*theta)/pow(cos(theta), 1.0/alpha));
  right= pow(cos(theta*(1.0 - alpha))/W, ((1.0-alpha)/alpha));
  holder=left*right;
  return(holder);
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0x2916
cvtss2sd %xmm0, %xmm0
addsd 0x639(%rip), %xmm0      # 0x31c8
mulsd 0x639(%rip), %xmm0      # 0x31d0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x2916
cvtss2sd %xmm0, %xmm0
callq 0x10d0
xorps 0x65b(%rip), %xmm0      # 0x3210
movaps %xmm0, 0x20(%rsp)
movsd 0x10(%rsp), %xmm0
mulsd (%rsp), %xmm0
callq 0x1190
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x10e0
movsd 0x425(%rip), %xmm1      # 0x3008
divsd (%rsp), %xmm1
callq 0x1090
movsd 0x8(%rsp), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x403(%rip), %xmm1      # 0x3008
subsd (%rsp), %xmm1
movsd %xmm1, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
callq 0x10e0
divsd 0x20(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
divsd (%rsp), %xmm1
callq 0x1090
mulsd 0x8(%rsp), %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/prng.c
// Function: prng_altstab
double prng_altstab(prng_type * prng, double p)
{
  double u,v,result;

  u=prng_float(prng);
  v=prng_float(prng);
  result=pow(u,p);
  // result=exp(p*log(u));
  if (v<0.5) result=-result;
  return(result);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x18(%rsp)
movq %rdi, %rbx
callq 0x2916
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x2916
movss %xmm0, 0xc(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
callq 0x1090
movss 0x546(%rip), %xmm1      # 0x31f4
ucomiss 0xc(%rsp), %xmm1
jbe 0x2cbc
xorps 0x554(%rip), %xmm0      # 0x3210
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/prng.c
// Function: prng_stable
double prng_stable(prng_type * prng, double alpha) {

  // wrapper for the stable distributions above:
  // call the appropriate routine based on the value of alpha given
  // initialising it with the seed in idum

  // randinit must be called before entering this procedure for
  // the first time since it uses the random generators


  if (alpha==2.0)
    return(prng_normal(prng));
  else if (alpha==1.0)
    return(prng_cauchy(prng));
  else if (alpha<0.01)
    return(prng_altstab(prng,-50.0));
  else return (prng_stabledbn(prng,alpha));
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
ucomisd 0x506(%rip), %xmm0      # 0x31d8
jne 0x2ce3
jp 0x2ce3
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x2a79
ucomisd 0x31d(%rip), %xmm0      # 0x3008
jne 0x2d15
jp 0x2d15
movq %rbx, %rdi
callq 0x2916
cvtss2sd %xmm0, %xmm0
addsd 0x4c5(%rip), %xmm0      # 0x31c8
mulsd 0x4c5(%rip), %xmm0      # 0x31d0
addq $0x10, %rsp
popq %rbx
jmp 0x1140
movsd 0x4c3(%rip), %xmm1      # 0x31e0
ucomisd %xmm0, %xmm1
jbe 0x2d72
movq %rbx, %rdi
callq 0x2916
cvtss2sd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq %rbx, %rdi
callq 0x2916
movss %xmm0, 0x4(%rsp)
movsd 0x49d(%rip), %xmm1      # 0x31e8
movsd 0x8(%rsp), %xmm0
callq 0x1090
movss 0x496(%rip), %xmm1      # 0x31f4
ucomiss 0x4(%rsp), %xmm1
jbe 0x2d6c
xorps 0x4a4(%rip), %xmm0      # 0x3210
addq $0x10, %rsp
popq %rbx
retq
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
jmp 0x2b71
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/prng.c
// Function: zeta
double zeta(long n, double theta)
{

  // the zeta function, used by the below zipf function
  // (this is not often called from outside this library)
  // ... but have made it public now to speed things up

  int i;
  double ans=0.0;

  for (i=1; i <= n; i++)
    ans += pow(1./(double)i, theta);
  return(ans);
}

// Assembly:
testq %rdi, %rdi
jle 0x2de8
pushq %r14
pushq %rbx
subq $0x18, %rsp
movaps %xmm0, %xmm1
movq %rdi, %rbx
xorps %xmm0, %xmm0
xorl %r14d, %r14d
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
incq %r14
xorps %xmm2, %xmm2
cvtsi2sd %r14d, %xmm2
movsd 0x252(%rip), %xmm0      # 0x3008
divsd %xmm2, %xmm0
callq 0x1090
movsd 0x10(%rsp), %xmm1
movsd 0x8(%rsp), %xmm2
addsd %xmm0, %xmm2
movsd %xmm2, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
cmpq %r14, %rbx
jne 0x2d9d
addq $0x18, %rsp
popq %rbx
popq %r14
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O3/ranbenbasat[P]RHHH/prng.c
// Function: fastzipf
double fastzipf(double theta, long n, double zetan, prng_type * prng) {

  // this draws values from the zipf distribution
  // this is mainly useful for test generation purposes
  // n is range, theta is skewness parameter
  // theta = 0 gives uniform dbn,
  // theta > 1 gives highly skewed dbn.
  // original code due to Flip Korn, used with permission

	double alpha;
	double eta;
	double u;
	double uz;
	long double val;

  // randinit must be called before entering this procedure for
  // the first time since it uses the random generators

	alpha = 1. / (1. - theta);
	eta = (1. - pow(2./((double) n), 1. - theta)) 
	  / (1. - zeta(2.,theta)/zetan);

	u = prng_float(prng);
	uz = u * zetan;
	if (uz < 1.) val = 1;
	else if (uz < (1. + pow(0.5, theta))) val = 2;
	else val = 1 + (int64__t)(n * pow(eta*u - eta + 1., alpha));

	return(val);
}

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movsd %xmm1, 0x10(%rsp)
movapd %xmm0, (%rsp)
movsd 0x201(%rip), %xmm1      # 0x3008
cvtsi2sd %rdi, %xmm2
subsd %xmm0, %xmm1
movsd 0x3c0(%rip), %xmm0      # 0x31d8
movsd %xmm2, 0x38(%rsp)
divsd %xmm2, %xmm0
movsd %xmm1, 0x30(%rsp)
callq 0x1090
movsd %xmm0, 0x28(%rsp)
movaps (%rsp), %xmm0
xorps 0x3d2(%rip), %xmm0      # 0x3210
movaps %xmm0, (%rsp)
callq 0x1040
movsd %xmm0, 0x20(%rsp)
movq %rbx, %rdi
callq 0x2916
movsd 0x1ab(%rip), %xmm1      # 0x3008
cvtss2sd %xmm0, %xmm0
movaps %xmm0, %xmm2
mulsd 0x10(%rsp), %xmm2
ucomisd %xmm2, %xmm1
jbe 0x2e79
movapd %xmm1, %xmm0
jmp 0x2f0a
movsd %xmm0, 0x18(%rsp)
movapd (%rsp), %xmm0
movsd %xmm2, (%rsp)
callq 0x1040
addsd 0x172(%rip), %xmm0      # 0x3008
ucomisd (%rsp), %xmm0
movsd 0x335(%rip), %xmm0      # 0x31d8
ja 0x2f0a
movsd 0x15b(%rip), %xmm2      # 0x3008
movsd 0x20(%rsp), %xmm0
addsd %xmm2, %xmm0
movapd %xmm2, %xmm1
divsd 0x30(%rsp), %xmm1
movapd %xmm2, %xmm3
subsd 0x28(%rsp), %xmm3
divsd 0x10(%rsp), %xmm0
subsd %xmm0, %xmm2
divsd %xmm2, %xmm3
movsd 0x18(%rsp), %xmm0
mulsd %xmm3, %xmm0
subsd %xmm3, %xmm0
addsd 0x119(%rip), %xmm0      # 0x3008
callq 0x1090
mulsd 0x38(%rsp), %xmm0
cvttsd2si %xmm0, %rax
incq %rax
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
addq $0x40, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/vi[P]simple_cbor_stream_parse/scsp.c
// Function: scsp_closeelements
SCSP_INT static scsp_closeelements(
                struct scsp_state* state, 
                struct scsp_callbacks* callbacks,
                SCSP_USERDATA userdata) {
    while (state->cur_depth > 0) {
        struct scsp_stack_entry* se1 = &state->stack[state->cur_depth- 1];
        if (se1->remaining >= 0) {
            if (se1->remaining == 0) {
                SCSP_DEBUG("internal error: remaining=0?\n");
                return -1;
            }
            se1->remaining -= 1;
            if (se1->remaining == 0) {
                switch(se1->type) {
                    case ']': 
                    case '[':
                         CALLBACK0(array_closed);
                         break;
                    case '{': 
                    case '}':
                        CALLBACK0(map_closed);
                        break;
                    case 'B':
                        CALLBACK0(bytestring_closed);
                        break;
                    case 'S':
                        CALLBACK0(string_closed);
                        break;
                    case 'b':
                    case 's':
                        SCSP_DEBUG("interal error 5\n");
                        return -1;
                    default: {
                        SCSP_DEBUG("internal error: se->type=%c ?\n", se1->type);
                        return -1;
                    }
                }
                state->cur_depth -= 1;
                continue;
            }
        } else {
            if (se1->type == '}') {
                if (se1->remaining == -1) {
                    se1->remaining = -2;
                } else {
                    se1->remaining = -1;
                }
            }
        }
        break;
    }
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rax
testq %rax, %rax
jle 0x1fca
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x8(%rdi), %r13
movq $-0x1, %r15
shlq $0x4, %rax
addq %r13, %rax
addq $-0x10, %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
js 0x1fb5
je 0x1fcd
decq %rcx
movq %rcx, 0x8(%rax)
jne 0x1fca
movzbl (%rax), %eax
cmpl $0x5c, %eax
jg 0x1f69
cmpl $0x42, %eax
je 0x1f84
cmpl $0x53, %eax
je 0x1f8a
cmpl $0x5b, %eax
je 0x1f78
jmp 0x1fcd
cmpl $0x7d, %eax
je 0x1f7e
cmpl $0x7b, %eax
je 0x1f7e
cmpl $0x5d, %eax
jne 0x1fcd
movq 0x48(%r14), %rax
jmp 0x1f8e
movq 0x68(%r14), %rax
jmp 0x1f8e
movq 0x18(%r14), %rax
jmp 0x1f8e
movq 0x30(%r14), %rax
testq %rax, %rax
je 0x1f9d
movq %rbx, %rdi
callq *%rax
testq %rax, %rax
js 0x1fcd
movq (%r12), %rcx
leaq -0x1(%rcx), %rax
movq %rax, (%r12)
cmpq $0x1, %rcx
jg 0x1f2d
jmp 0x1fca
cmpb $0x7d, (%rax)
jne 0x1fca
xorl %edx, %edx
cmpq $-0x1, %rcx
sete %dl
notq %rdx
movq %rdx, 0x8(%rax)
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/vi[P]simple_cbor_stream_parse/scsp.c
// Function: decode_half
static double decode_half(const unsigned char *halfp) {
     int half = (halfp[0] << 8) + halfp[1];
     int exp = (half >> 10) & 0x1f;
     int mant = half & 0x3ff;
     double val;
     if (exp == 0) val = ldexp(mant, -24);
     else if (exp != 31) val = ldexp(mant + 1024, exp - 25);
     else val = mant == 0 ? INFINITY : NAN;
     return half & 0x8000 ? -val : val;
   }

// Assembly:
pushq %rbx
movl %edi, %ebx
movzbl %sil, %ecx
shrl $0x2, %edi
andl $0x1f, %edi
movl %ebx, %eax
andl $0x3, %eax
shll $0x8, %eax
orl %ecx, %eax
cmpl $0x1f, %edi
je 0x2005
testl %edi, %edi
jne 0x201a
cvtsi2sd %eax, %xmm0
movl $0xffffffe8, %edi       # imm = 0xFFFFFFE8
jmp 0x2026
xorl %ecx, %ecx
testl %eax, %eax
sete %cl
leaq 0x117d(%rip), %rax      # 0x3190
movsd (%rax,%rcx,8), %xmm0
jmp 0x202b
orl $0x400, %eax            # imm = 0x400
cvtsi2sd %eax, %xmm0
addl $-0x19, %edi
callq 0x1040
testb %bl, %bl
jns 0x2037
xorpd 0x1169(%rip), %xmm0     # 0x31a0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/vi[P]simple_cbor_stream_parse/scsp.c
// Function: scsp_parse_from_fd
SCSP_INT SCSP_EXPORT scsp_parse_from_fd(
            int fd, 
            struct scsp_callbacks* callbacks,
            SCSP_USERDATA userdata)
{
    struct scsp_state     ss;
    ss.cur_depth = 0;
    uint8_t buf[8092];
    
    size_t read_cursor = 0;
    for(;;) {
        size_t len = read(fd, buf+read_cursor, (sizeof buf) - read_cursor);
        if (len == -1) {
            if (errno == EINTR) continue;
            if (errno == EAGAIN) { usleep(100000); continue; }
            return -1;
        }
        if (len == 0) break;
        
        len += read_cursor;
        read_cursor=0;
        
        size_t write_cursor = 0;
        while(write_cursor < len) {
            int ret2 = scsp_parse_lowlevel(&ss, callbacks, userdata, buf+write_cursor, len-write_cursor);
            if (ret2 == -1) {
                return -1;
            }
            if (ret2 == 0) {
                memmove(buf, buf+write_cursor, len-write_cursor);
                read_cursor = len-write_cursor;
                break;
            }
            write_cursor += ret2;
        }
        //fflush(stdout);
    }
    return read_cursor;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20b8, %rsp           # imm = 0x20B8
movq %rdx, (%rsp)
movq %rsi, %r14
movl %edi, %ebp
leaq 0x8(%rsp), %rax
movq $0x0, (%rax)
xorl %r12d, %r12d
leaq (%rsp,%r12), %r15
addq $0x110, %r15            # imm = 0x110
movl $0x1f9c, %ebx           # imm = 0x1F9C
subq %r12, %rbx
movl %ebp, %edi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x1070
cmpq $-0x1, %rax
jne 0x20a5
callq 0x1030
movl (%rax), %eax
cmpl $0x4, %eax
je 0x2075
cmpl $0xb, %eax
jne 0x2113
movl $0x186a0, %edi          # imm = 0x186A0
callq 0x10d0
jmp 0x2075
movq %rax, %r13
testq %rax, %rax
je 0x211a
addq %r12, %r13
movl $0x0, %r12d
je 0x2062
xorl %r15d, %r15d
leaq (%rsp,%r15), %rbx
addq $0x110, %rbx            # imm = 0x110
movq %r13, %r12
subq %r15, %r12
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq (%rsp), %rdx
movq %rbx, %rcx
movq %r12, %r8
callq 0x1558
cmpl $-0x1, %eax
je 0x2113
testl %eax, %eax
je 0x20fb
cltq
addq %rax, %r15
cmpq %r13, %r15
jb 0x20bb
jmp 0x205f
leaq 0x110(%rsp), %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1090
jmp 0x2062
movq $-0x1, %r12
movq %r12, %rax
addq $0x20b8, %rsp           # imm = 0x20B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/vi[P]simple_cbor_stream_parse/scsp.c
// Function: scsp_parse_from_memory
SCSP_INT SCSP_EXPORT scsp_parse_from_memory(
            const void *buffer,
            size_t count,
            struct scsp_callbacks* callbacks,
            SCSP_USERDATA userdata)
{
    struct scsp_state     ss;
    ss.cur_depth = 0;
    
    const uint8_t *buf = (const uint8_t*)buffer;
    
    size_t write_cursor = 0;
    while(write_cursor < count) {
        int ret2 = scsp_parse_lowlevel(&ss, callbacks, userdata, buf+write_cursor, count-write_cursor);
        if (ret2 == -1) {
            return -1;
        }
        if (ret2 == 0) {
            break;
        }
        write_cursor += ret2;
    }
    
    return count - write_cursor;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, %rbx
movq $0x0, (%rsp)
testq %rsi, %rsi
je 0x218b
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
xorl %ebp, %ebp
movq %rsp, %r13
leaq (%r12,%rbp), %rcx
movq %rbx, %r8
subq %rbp, %r8
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1558
cmpl $-0x1, %eax
je 0x2192
testl %eax, %eax
je 0x218d
cltq
addq %rax, %rbp
cmpq %rbx, %rbp
jb 0x215e
jmp 0x218d
xorl %ebp, %ebp
subq %rbp, %rbx
jmp 0x2199
movq $-0x1, %rbx
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/CkTD[P]btree/btree.c
// Function: bt_node_leaf_fetch_values
int bt_node_leaf_fetch_values(BTreeNode *leaf, BTreeValues *values, uint64_t limit, uint64_t key_min, uint64_t key_max)
{
    uint64_t count;
    uint64_t index;
    uint64_t keys_in_node;
    uint64_t k, v;

    count = 0;
    keys_in_node = bt_node_blk_get_key_count(leaf->blk);

    // empty tree!
    if(keys_in_node == 0)
    {
        assert(bt_node_get_type(leaf) & BT_NODE_TYPE_ROOT);
        return 0;
    }

    index = bt_node_blk_leaf_search(leaf->blk, key_min);

    for(; index < keys_in_node; index ++)
    {
        k = bt_node_blk_get_key(leaf->blk, index);
        if(k > key_max)
            break;
        v = bt_node_blk_get_value(leaf->blk, index);
        bt_values_put_value(values, v);

        count ++;
        if(count == limit)
            break;
    }

    if((index == keys_in_node) && (count < limit))
        return 1;
    else
        return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdi, 0x38(%rsp)
movq 0x8(%rdi), %rsi
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x137f
movq %rdx, (%rsp)
movq %rax, %rbp
negq %rbp
movl $0x30, %r12d
xorl %ebx, %ebx
xorl %r14d, %r14d
cmpq %rcx, (%rsi,%r12)
jae 0x13a9
addq $0x10, %r12
decq %r14
cmpq %r14, %rbp
jne 0x1365
movq %rax, %r15
jmp 0x1479
xorl %eax, %eax
testb $0x1, (%rsi)
jne 0x148e
leaq 0x1cdc(%rip), %rdi      # 0x306d
leaq 0x1c8d(%rip), %rsi      # 0x3025
leaq 0x1cf9(%rip), %rcx      # 0x3098
movl $0x384, %edx            # imm = 0x384
callq 0x10b0
movq %r14, %r15
negq %r15
cmpq %rax, %r15
jae 0x1477
movq %rax, 0x8(%rsp)
addq %r14, %rax
movq %rax, 0x10(%rsp)
movq (%rsp), %rax
decq %rax
movq %rax, 0x18(%rsp)
movq %r14, %rax
negq %rax
movq %rax, 0x20(%rsp)
xorl %ebx, %ebx
movq 0x28(%rsp), %r13
movq 0x20(%rsp), %rax
leaq (%rax,%rbx), %rsi
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rdi
cmpq %rsi, 0x8(%rdi)
jbe 0x14b7
movq 0x30(%rsp), %rax
cmpq %rax, (%rdi,%r12)
ja 0x149d
callq 0x14d6
movq %rax, 0x40(%rsp)
movq (%r13), %rax
movq 0x8(%r13), %rdi
leaq 0x1(%rax), %rcx
movq %rcx, (%r13)
leaq 0x8(,%rax,8), %rsi
callq 0x1110
movq %rax, 0x8(%r13)
movq (%r13), %rcx
movq 0x40(%rsp), %rdx
movq %rdx, -0x8(%rax,%rcx,8)
cmpq %rbx, 0x18(%rsp)
je 0x14a9
incq %r15
leaq (%rbx,%rbp), %rax
incq %rax
incq %rbx
addq $0x10, %r12
cmpq %r14, %rax
jne 0x13e3
movq 0x8(%rsp), %rax
movq %rax, %r15
movq 0x10(%rsp), %rbx
jmp 0x1479
xorl %ebx, %ebx
movq (%rsp), %rcx
cmpq %rax, %r15
sete %al
cmpq %rcx, %rbx
setb %cl
andb %al, %cl
movzbl %cl, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %r15
subq %r14, %r15
movq (%rsp), %rcx
jmp 0x14b0
movq (%rsp), %rcx
movq %rcx, %rbx
movq 0x8(%rsp), %rax
jmp 0x147d
leaq 0x1e61(%rip), %rdi      # 0x331f
leaq 0x1b60(%rip), %rsi      # 0x3025
leaq 0x1e81(%rip), %rcx      # 0x334d
movl $0x148, %edx            # imm = 0x148
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/CkTD[P]btree/btree.c
// Function: bt_node_blk_get_value
static uint64_t bt_node_blk_get_value(BTreeNodeBlk *blk, uint64_t index)
{
    assert(blk->type & BT_NODE_TYPE_LEAF);
    assert(index < blk->key_counts);
    return *(uint64_t *)
            ((char *)blk + sizeof(BTreeNodeBlk) + sizeof(uint64_t) * (index * 2));

}

// Assembly:
pushq %rax
testb $0x4, (%rdi)
je 0x14ed
cmpq %rsi, 0x8(%rdi)
jbe 0x150c
shlq $0x4, %rsi
movq 0x28(%rdi,%rsi), %rax
popq %rcx
retq
leaq 0x1e90(%rip), %rdi      # 0x3384
leaq 0x1b2a(%rip), %rsi      # 0x3025
leaq 0x1ea0(%rip), %rcx      # 0x33a2
movl $0x156, %edx            # imm = 0x156
callq 0x10b0
leaq 0x1e22(%rip), %rdi      # 0x3335
leaq 0x1b0b(%rip), %rsi      # 0x3025
leaq 0x1e81(%rip), %rcx      # 0x33a2
movl $0x157, %edx            # imm = 0x157
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/CkTD[P]btree/btree.c
// Function: bt_flush
void bt_flush(BTree *bt)
{
    BTreeNode *node;

    if(bt->meta->dirty)
        bt_store_blk(bt, 0);

    list_for_each_entry(node, &bt->new_node_chain, chain)
        bt_store_blk(bt, bt_node_get_blkid(node));

    list_for_each_entry(node, &bt->dirty_node_chain, chain)
        bt_store_blk(bt, bt_node_get_blkid(node));

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpl $0x0, 0x8(%rax)
je 0x158f
movq %rbx, %rdi
xorl %esi, %esi
callq 0x15d1
leaq 0x20(%rbx), %r14
movq 0x20(%rbx), %r15
cmpq %r14, %r15
je 0x15ad
movq -0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x15d1
movq (%r15), %r15
jmp 0x1597
leaq 0x40(%rbx), %r14
movq 0x40(%rbx), %r15
cmpq %r14, %r15
je 0x15cb
movq -0x8(%r15), %rsi
movq %rbx, %rdi
callq 0x15d1
movq (%r15), %r15
jmp 0x15b5
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/CkTD[P]btree/btree.c
// Function: bt_store_blk
static void bt_store_blk(BTree *bt, uint64_t blkid)
{
    ssize_t   rtv;
    uint64_t  blksize;
    void     *blk;

    if(blkid == 0)
        blk = (void *)bt->meta->blk;
    else
        blk = (void *)bt->blkid_to_node[blkid]->blk;
    

    blksize = bt_get_blksize(bt);
    bt_open_file(bt);
    rtv = lseek(bt->file_fd, blkid * blksize, SEEK_SET);
    assert(rtv == blkid * blksize);
    rtv = write(bt->file_fd, blk, blksize);
    assert(rtv == blksize);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
testq %rsi, %rsi
je 0x15f6
movq 0x18(%rbx), %rax
movq 0x60(%rbx), %rcx
movq (%rcx,%r14,8), %rcx
addq $0x8, %rcx
jmp 0x15fd
movq 0x18(%rbx), %rax
movq %rax, %rcx
movq (%rcx), %r12
movq (%rax), %rax
movq 0x10(%rax), %r15
movq %rbx, %rdi
callq 0x1fbf
movl 0x8(%rbx), %edi
imulq %r15, %r14
movq %r14, %rsi
xorl %edx, %edx
callq 0x10a0
cmpq %r14, %rax
jne 0x1644
movl 0x8(%rbx), %edi
movq %r12, %rsi
movq %r15, %rdx
callq 0x1070
cmpq %r15, %rax
jne 0x1663
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x1d90(%rip), %rdi      # 0x33db
leaq 0x19d3(%rip), %rsi      # 0x3025
leaq 0x1d99(%rip), %rcx      # 0x33f2
movl $0x445, %edx            # imm = 0x445
callq 0x10b0
leaq 0x1dad(%rip), %rdi      # 0x3417
leaq 0x19b4(%rip), %rsi      # 0x3025
leaq 0x1d7a(%rip), %rcx      # 0x33f2
movl $0x447, %edx            # imm = 0x447
callq 0x10b0
// File: /workspace/github_c_makefile_star2_O3/CkTD[P]btree/btree.c
// Function: bt_insert
void bt_insert(BTree *bt, uint64_t key, uint64_t value)
{
    BTreeNode  *leaf;

    leaf = bt_node_search(bt->root, key);
    bt_node_leaf_insert(leaf, key, value);   
    
    assert(bt_node_get_key_count(leaf) <= bt->max_keys);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x182c
movq %rax, %r14
movq %rax, %rdi
callq 0x12c9
movq 0x8(%r14), %rbp
testb $0x4, (%rbp)
je 0x17b0
movq 0x8(%rbp), %rdx
testq %rdx, %rdx
je 0x16dd
leaq 0x30(%rbp), %rcx
xorl %eax, %eax
cmpq %r15, (%rcx)
jae 0x16df
incq %rax
addq $0x10, %rcx
cmpq %rax, %rdx
jne 0x16c7
movq %rdx, %rax
jmp 0x16df
xorl %eax, %eax
subq %rax, %rdx
shlq $0x4, %rax
leaq (%rax,%rbp), %rsi
addq $0x28, %rsi
leaq (%rax,%rbp), %r13
addq $0x38, %r13
shlq $0x4, %rdx
movq %r13, %rdi
callq 0x1120
movq %r12, -0x10(%r13)
movq %r15, -0x8(%r13)
incq 0x8(%rbp)
movq (%r14), %rcx
movq 0x8(%r14), %rdx
movq 0x8(%rdx), %rax
movq 0x58(%rcx), %rcx
cmpq %rcx, %rax
jbe 0x179b
movl (%rdx), %ebp
testb $0x4, %bpl
je 0x17ee
incq %rcx
cmpq %rax, %rcx
jne 0x180d
movq %rsp, %rsi
movq %r14, %rdi
callq 0x2006
movq %rax, %r15
movq (%r14), %r12
testb $0x1, %bpl
jne 0x176b
movq 0x8(%r14), %rax
movq 0x10(%rax), %rsi
testq %rsi, %rsi
je 0x177f
movq %r12, %rdi
callq 0x25ed
movq %rax, %rsi
jmp 0x1781
movq (%rsp), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x218c
jmp 0x1793
xorl %esi, %esi
movq (%rsp), %r8
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x21fb
movq 0x8(%r14), %rax
movq 0x8(%rax), %rax
cmpq 0x58(%rbx), %rax
ja 0x17cf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1bcd(%rip), %rdi      # 0x3384
leaq 0x1867(%rip), %rsi      # 0x3025
leaq 0x1c8e(%rip), %rcx      # 0x3453
movl $0x1ad, %edx            # imm = 0x1AD
callq 0x10b0
leaq 0x1967(%rip), %rdi      # 0x313d
leaq 0x1848(%rip), %rsi      # 0x3025
leaq 0x1985(%rip), %rcx      # 0x3169
movl $0x4ab, %edx            # imm = 0x4AB
callq 0x10b0
leaq 0x1c9f(%rip), %rdi      # 0x3494
leaq 0x1829(%rip), %rsi      # 0x3025
leaq 0x1cbc(%rip), %rcx      # 0x34bf
movl $0x345, %edx            # imm = 0x345
callq 0x10b0
leaq 0x1cd0(%rip), %rdi      # 0x34e4
leaq 0x180a(%rip), %rsi      # 0x3025
leaq 0x1c9d(%rip), %rcx      # 0x34bf
movl $0x346, %edx            # imm = 0x346
callq 0x10b0