LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/ryuichiueda[P]glueutils/src/juz.c
// Function: main
int main(int argc, char * argv[])
{
	if(argc < 3){
		usage();
		exit(1);
	}

	long rep = strtol(argv[1], NULL, 10);
	if(errno != 0){
		printf("Error: %s\n", strerror(errno));
		exit(1);
	}

	for(int i=0;i<rep;i++){
		int pips[2];
		if(pipe(pips) < 0){
			fputs("Error: pipe open error", stderr);
			exit(1);
		}

		int pid = fork();
		if(pid == 0){//child proc
			if(i < rep-1){
				try_close(pips[0]);
				dup_and_close(pips[1], 1);
			}else{
				try_close(pips[1]);
			}
			return -execvp(argv[2], &argv[2]);
		}

		//parent proc
		try_close(pips[1]);
		dup_and_close(pips[0], 0);
	}

	int wstatus;
	int wpid;
	int lasterror = 0;
	while((wpid = waitpid(-1, &wstatus, 0)) > 0){
		if(WIFEXITED(wstatus) && WEXITSTATUS(wstatus)){
			lasterror = WEXITSTATUS(wstatus);
		}
	}
	exit(lasterror);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x2, %edi
jle 0x1411
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
xorl %esi, %esi
movl $0xa, %edx
callq 0x1090
movq %rax, %r14
callq 0x1030
movl (%rax), %edi
testl %edi, %edi
jne 0x1416
testq %r14, %r14
jle 0x137b
xorl %r12d, %r12d
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x1080
testl %eax, %eax
js 0x140c
callq 0x10e0
testl %eax, %eax
je 0x13c4
movl 0x14(%rsp), %edi
callq 0x127c
movl 0x10(%rsp), %edi
xorl %esi, %esi
callq 0x12b0
incq %r12
cmpq %r12, %r14
jne 0x1346
leaq 0xc(%rsp), %rsi
xorl %ebx, %ebx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
xorl %edx, %edx
callq 0x10a0
testl %eax, %eax
jle 0x13bd
xorl %ebx, %ebx
leaq 0xc(%rsp), %r14
movl 0xc(%rsp), %eax
movzbl %ah, %ecx
testl %ecx, %ecx
cmovel %ebx, %ecx
testb $0x7f, %al
cmovel %ecx, %ebx
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movq %r14, %rsi
xorl %edx, %edx
callq 0x10a0
testl %eax, %eax
jg 0x1399
movl %ebx, %edi
callq 0x10c0
decq %r14
cmpq %r12, %r14
jbe 0x13e5
movl 0x10(%rsp), %edi
callq 0x127c
movl 0x14(%rsp), %edi
movl $0x1, %esi
callq 0x12b0
jmp 0x13ee
movl 0x14(%rsp), %edi
callq 0x127c
movq 0x10(%rbx), %rdi
addq $0x10, %rbx
movq %rbx, %rsi
callq 0x10b0
negl %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x1154
callq 0x1173
callq 0x10d0
leaq 0xca8(%rip), %rdi       # 0x20ca
movq %rax, %rsi
xorl %eax, %eax
callq 0x1050
movl $0x1, %edi
callq 0x10c0
// File: /workspace/github_c_makefile_star2_O3/creationix[P]color-control/src/mpc/mpc.c
// Function: mpcf_freefold
mpc_val_t *mpcf_freefold(int n, mpc_val_t **xs) {
  int i;
  for (i = 0; i < n; i++) {
    free(xs[i]);
  }
  return NULL;
}

// Assembly:
testl %edi, %edi
jle 0x7179
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
xorl %r15d, %r15d
movq (%rbx,%r15,8), %rdi
callq 0x2280
incq %r15
cmpq %r15, %r14
jne 0x7163
popq %rbx
popq %r14
popq %r15
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/creationix[P]color-control/src/mpc/mpc.c
// Function: mpc_nodecount_unretained
static int mpc_nodecount_unretained(mpc_parser_t* p, int force) {

  int i, total;

  if (p->retained && !force) { return 0; }

  if (p->type == MPC_TYPE_EXPECT) { return 1 + mpc_nodecount_unretained(p->data.expect.x, 0); }

  if (p->type == MPC_TYPE_APPLY)    { return 1 + mpc_nodecount_unretained(p->data.apply.x, 0); }
  if (p->type == MPC_TYPE_APPLY_TO) { return 1 + mpc_nodecount_unretained(p->data.apply_to.x, 0); }
  if (p->type == MPC_TYPE_PREDICT)  { return 1 + mpc_nodecount_unretained(p->data.predict.x, 0); }

  if (p->type == MPC_TYPE_CHECK)    { return 1 + mpc_nodecount_unretained(p->data.check.x, 0); }
  if (p->type == MPC_TYPE_CHECK_WITH) { return 1 + mpc_nodecount_unretained(p->data.check_with.x, 0); }

  if (p->type == MPC_TYPE_NOT)   { return 1 + mpc_nodecount_unretained(p->data.not.x, 0); }
  if (p->type == MPC_TYPE_MAYBE) { return 1 + mpc_nodecount_unretained(p->data.not.x, 0); }

  if (p->type == MPC_TYPE_MANY)  { return 1 + mpc_nodecount_unretained(p->data.repeat.x, 0); }
  if (p->type == MPC_TYPE_MANY1) { return 1 + mpc_nodecount_unretained(p->data.repeat.x, 0); }
  if (p->type == MPC_TYPE_COUNT) { return 1 + mpc_nodecount_unretained(p->data.repeat.x, 0); }

  if (p->type == MPC_TYPE_OR) {
    total = 1;
    for(i = 0; i < p->data.or.n; i++) {
      total += mpc_nodecount_unretained(p->data.or.xs[i], 0);
    }
    return total;
  }

  if (p->type == MPC_TYPE_AND) {
    total = 1;
    for(i = 0; i < p->data.and.n; i++) {
      total += mpc_nodecount_unretained(p->data.and.xs[i], 0);
    }
    return total;
  }

  return 1;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebp, %ebp
leaq 0x3598(%rip), %rax      # 0xd25c
xorl %r14d, %r14d
testl %esi, %esi
jne 0x9cd5
cmpb $0x0, 0x31(%rdi)
jne 0x9d92
xorl %ebx, %ebx
movzbl 0x30(%rdi), %ecx
cmpl $0x5, %ecx
jne 0x9cf1
movq 0x8(%rdi), %rdi
incl %ebx
cmpb $0x0, 0x31(%rdi)
je 0x9cd7
jmp 0x9d8e
addl $-0xf, %ecx
cmpl $0xb, %ecx
ja 0x9d87
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x8(%rdi), %rdi
addl %ebx, %r14d
incl %r14d
xorl %esi, %esi
jmp 0x9cc7
movq 0x8(%rdi), %rdi
jmp 0x9d1e
movq 0x18(%rdi), %rdi
xorl %esi, %esi
callq 0x9cb0
addl %eax, %r14d
addl %r14d, %ebx
incl %ebx
jmp 0x9d99
movslq 0x8(%rdi), %r15
testq %r15, %r15
jle 0x9d87
movq 0x18(%rdi), %r12
movl $0x1, %ebp
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
xorl %esi, %esi
callq 0x9cb0
addl %eax, %ebp
incq %r13
cmpq %r13, %r15
jne 0x9d44
jmp 0x9d94
movslq 0x8(%rdi), %r15
testq %r15, %r15
jle 0x9d87
movq 0x10(%rdi), %r12
movl $0x1, %ebp
xorl %r13d, %r13d
movq (%r12,%r13,8), %rdi
xorl %esi, %esi
callq 0x9cb0
addl %eax, %ebp
incq %r13
cmpq %r13, %r15
jne 0x9d70
jmp 0x9d94
movl $0x1, %ebp
jmp 0x9d94
xorl %ebp, %ebp
jmp 0x9d94
xorl %ebx, %ebx
addl %r14d, %ebx
addl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/creationix[P]color-control/src/libs/stdin.c
// Function: stdin_read
uint8_t* stdin_read(size_t* size) {
  size_t max = chunk_size;
  size_t offset = 0;
  uint8_t* buffer = malloc(max);

  // Read stdin into a auto-growing buffer
  while (true) {
    ssize_t bytes_read = read(0, buffer + offset, max - offset);
    if (bytes_read < 0) return NULL;
    if (bytes_read == 0) break;
    offset += bytes_read;
    if (offset == max) {
      max = offset + chunk_size;
      buffer = realloc(buffer, max);
    }
  }

  // Optionally record size
  if (size) *size = offset;

  // Clean up freespace and add null terminator
  buffer = realloc(buffer, offset + 1);
  buffer[offset] = 0;

  return buffer;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movl $0x100, %r12d           # imm = 0x100
movl $0x100, %edi            # imm = 0x100
callq 0x21a0
movq %rax, %r15
xorl %r14d, %r14d
movl $0x100, %edx            # imm = 0x100
xorl %edi, %edi
movq %rax, %rsi
callq 0x2130
testq %rax, %rax
js 0xa437
xorl %r14d, %r14d
xorl %r13d, %r13d
testq %rax, %rax
je 0xa41b
addq %rax, %r13
cmpq %r12, %r13
jne 0xa403
addq $0x100, %r12            # imm = 0x100
movq %r15, %rdi
movq %r12, %rsi
callq 0x21d0
movq %rax, %r15
leaq (%r15,%r13), %rsi
movq %r12, %rdx
subq %r13, %rdx
xorl %edi, %edi
callq 0x2130
testq %rax, %rax
jns 0xa3e1
jmp 0xa437
testq %rbx, %rbx
je 0xa423
movq %r13, (%rbx)
leaq 0x1(%r13), %rsi
movq %r15, %rdi
callq 0x21d0
movq %rax, %r14
movb $0x0, (%rax,%r13)
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/creationix[P]color-control/src/compile.c
// Function: parse_number
uint32_t parse_number(mpc_ast_t* ast) {
  if (is(ast, "number|decimal|regex")) {
    return atoi(ast->contents);
  }
  if (is(ast, "number|boolean|string")) {
    return !strcmp(ast->contents, "true");
  }
  if (is(ast, "number|hex|regex")) {
    return strtol(ast->contents + 2, NULL, 16);
  }
  assert(false); // Unknown tag for number
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
leaq 0x31ee(%rip), %rsi      # 0xd64d
movq %r14, %rdi
callq 0xa4f7
testb %al, %al
je 0xa47b
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2210
leaq 0x31e0(%rip), %rsi      # 0xd662
movq %r14, %rdi
callq 0xa4f7
testb %al, %al
je 0xa4a9
movq 0x8(%rbx), %rdi
leaq 0x31df(%rip), %rsi      # 0xd678
callq 0x2150
movl %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
sete %al
jmp 0xa4d0
leaq 0x31cd(%rip), %rsi      # 0xd67d
movq %r14, %rdi
callq 0xa4f7
testb %al, %al
je 0xa4d8
movq 0x8(%rbx), %rdi
addq $0x2, %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2180
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x31af(%rip), %rdi      # 0xd68e
leaq 0x31ae(%rip), %rsi      # 0xd694
leaq 0x31b5(%rip), %rcx      # 0xd6a2
movl $0x52, %edx
callq 0x20e0
// File: /workspace/github_c_makefile_star2_O3/creationix[P]color-control/src/compile.c
// Function: is
static bool ends_with(const char *str, const char *suffix) {
  if (!str || !suffix) return false;
  size_t lenstr = strlen(str);
  size_t lensuffix = strlen(suffix);
  if (lensuffix > lenstr) return false;
  return strncmp(str + lenstr - lensuffix, suffix, lensuffix) == 0;
}

// Assembly:
testq %rdi, %rdi
sete %al
testq %rsi, %rsi
sete %cl
orb %al, %cl
jne 0xa52b
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x20b0
movq %rax, %r15
movq %rbx, %rdi
callq 0x20b0
cmpq %r15, %rax
jbe 0xa52e
xorl %eax, %eax
jmp 0xa547
xorl %eax, %eax
retq
addq %r15, %r14
subq %rax, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2050
testl %eax, %eax
sete %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/creationix[P]color-control/src/compile.c
// Function: generate_block
static void generate_block(mpc_ast_t* ast) {
  if (ast->children_num > 3) pushchar(DO);
  for (int i = 1; i < ast->children_num - 1; i++) {
    generate_statement(ast->children[i]);
  }
  if (ast->children_num > 3) pushchar(END);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x30(%rdi), %eax
cmpl $0x4, %eax
jl 0xa98d
movzwl 0x886b(%rip), %eax      # 0x131e0
leal 0x1(%rax), %ecx
movw %cx, 0x8861(%rip)       # 0x131e0
leaq 0x887a(%rip), %rcx      # 0x13200
movb $-0x54, (%rax,%rcx)
movl 0x30(%rbx), %eax
cmpl $0x3, %eax
jl 0xa9d6
movl $0x1, %r14d
movq 0x38(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xbdb8
incq %r14
movslq 0x30(%rbx), %rax
leaq -0x1(%rax), %rcx
cmpq %rcx, %r14
jl 0xa998
cmpl $0x3, %eax
jle 0xa9d6
movzwl 0x881f(%rip), %eax      # 0x131e0
leal 0x1(%rax), %ecx
movw %cx, 0x8815(%rip)       # 0x131e0
leaq 0x882e(%rip), %rcx      # 0x13200
movb $-0x53, (%rax,%rcx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/creationix[P]color-control/src/compile.c
// Function: generate_number
static void generate_number(uint32_t num) {
  // fprintf(stderr, "Generate Num %u - %08x\n", num, num);
  if (num < 0x80) {
    pushchar((char)num);
  }
  else if (num < 0x100) {
    pushchar(UINT8);
    pushchar(num);
  }
  else if (num < 0x10000) {
    pushchar(UINT16);
    pushchar(num >> 8);
    pushchar(num);
  }
  else if (num < 0x1000000) {
    pushchar(UINT24);
    pushchar(num >> 16);
    pushchar(num >> 8);
    pushchar(num);
  }
  else {
    pushchar(UINT32);
    pushchar(num >> 24);
    pushchar(num >> 16);
    pushchar(num >> 8);
    pushchar(num);
  }
}

// Assembly:
movl %edi, %eax
cmpl $0x7f, %edi
ja 0xc3ea
movzwl 0x6e0b(%rip), %ecx      # 0x131e0
leal 0x1(%rcx), %edx
movw %dx, 0x6e01(%rip)       # 0x131e0
leaq 0x6e1a(%rip), %rdx      # 0x13200
movb %al, (%rcx,%rdx)
retq
cmpl $0xff, %eax
ja 0xc417
movzwl 0x6de8(%rip), %ecx      # 0x131e0
leal 0x1(%rcx), %edx
leaq 0x6dfe(%rip), %rsi      # 0x13200
movb $-0x80, (%rcx,%rsi)
addl $0x2, %ecx
movw %cx, 0x6dd0(%rip)       # 0x131e0
movzwl %dx, %ecx
movb %al, (%rcx,%rsi)
retq
cmpl $0xffff, %eax           # imm = 0xFFFF
ja 0xc453
movzwl 0x6dbb(%rip), %edx      # 0x131e0
leal 0x1(%rdx), %esi
leaq 0x6dd1(%rip), %rcx      # 0x13200
movb $-0x7f, (%rdx,%rcx)
leal 0x2(%rdx), %edi
movl $0xffff, %r8d           # imm = 0xFFFF
andl %r8d, %esi
movb %ah, (%rsi,%rcx)
addl $0x3, %edx
movw %dx, 0x6d94(%rip)       # 0x131e0
andl %r8d, %edi
movb %al, (%rdi,%rcx)
retq
pushq %rbx
movzwl 0x6d85(%rip), %ecx      # 0x131e0
leal 0x1(%rcx), %edi
leal 0x2(%rcx), %esi
movl $0xffff, %r8d           # imm = 0xFFFF
andl %r8d, %edi
leal 0x3(%rcx), %edx
andl %r8d, %esi
andl %r8d, %edx
leaq 0x6d86(%rip), %rbx      # 0x13200
cmpl $0xffffff, %eax         # imm = 0xFFFFFF
ja 0xc4a2
movb $-0x7e, (%rcx,%rbx)
movl %eax, %r8d
shrl $0x10, %r8d
movb %r8b, (%rdi,%rbx)
movb %ah, (%rsi,%rbx)
addl $0x4, %ecx
movw %cx, 0x6d43(%rip)       # 0x131e0
movb %al, (%rdx,%rbx)
jmp 0xc4d0
movb $-0x7d, (%rcx,%rbx)
movl %eax, %r8d
shrl $0x18, %r8d
movb %r8b, (%rdi,%rbx)
movl %eax, %edi
shrl $0x10, %edi
movb %dil, (%rsi,%rbx)
leal 0x4(%rcx), %esi
movb %ah, (%rdx,%rbx)
addl $0x5, %ecx
movw %cx, 0x6d16(%rip)       # 0x131e0
movzwl %si, %ecx
movb %al, (%rcx,%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/creationix[P]color-control/src/compile.c
// Function: intern_ident
static uint8_t intern_ident(const char* ident) {
  for (int i = 0; i < 8; i++) {
    if (!names[i]) {
      names[i] = ident;
      // fprintf(stderr, "Found %s at %d\n", ident, i);
      return i;
    }
    if (!strcmp(names[i], ident)) {
      // fprintf(stderr, "Added %s at %d\n", ident, i);
      return i;
    }
  }
  return -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
leaq 0x16d2f(%rip), %r15     # 0x23210
xorl %ebx, %ebx
movq (%r15), %rdi
testq %rdi, %rdi
je 0xc508
movq %r14, %rsi
callq 0x2150
testl %eax, %eax
je 0xc50b
incq %rbx
addq $0x8, %r15
cmpq $0x8, %rbx
jne 0xc4e3
movb $-0x1, %bl
jmp 0xc50b
movq %r14, (%r15)
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/./edge264_bitstream.c
// Function: cabac_start
static int cabac_start(Edge264Context *ctx) {
	// reclaim bits from cache while realigning with CPB on a byte boundary
	int extra_bits = SIZE_BIT - 1 - ctz(ctx->t._gb.lsb_cache);
	int shift = extra_bits & 7;
	int ret = shift > 0 && (ssize_t)ctx->t._gb.msb_cache >> (SIZE_BIT - shift) != -1; // return 1 if not all alignment bits are ones
	ctx->t._gb.codIOffset = shld(ctx->t._gb.lsb_cache, ctx->t._gb.msb_cache, shift); // codIOffset and msb_cache are the same memory slot
	ctx->t._gb.lsb_cache >>= (SIZE_BIT - extra_bits) & (SIZE_BIT - 1);
	while (extra_bits >= 8) {
		int32_t i = 0;
		if ((intptr_t)(ctx->t._gb.end - ctx->t._gb.CPB) >= 0)
			memcpy(&i, ctx->t._gb.CPB - 4, 4);
		ctx->t._gb.CPB -= 1 + ((big_endian32(i) & 0xffffff) == 3);
		ctx->t._gb.lsb_cache >>= 8;
		extra_bits -= 8;
	}
	ctx->t._gb.codIRange = (size_t)510 << (SIZE_BIT - 9);
	ctx->t._gb.codIOffset = (ctx->t._gb.codIOffset < ctx->t._gb.codIRange) ? ctx->t._gb.codIOffset : ctx->t._gb.codIRange - 1; // protection against invalid bitstream
	return ret;
}

// Assembly:
pushq %rbp
pushq %rbx
movq 0x10(%rdi), %r8
movq 0x18(%rdi), %rax
tzcntq %r8, %rsi
xorl $0x3f, %esi
movl %esi, %ecx
andl $0x7, %ecx
movq %rax, -0x8(%rsp)
movq %rax, %rdx
shldq %cl, %r8, %rdx
movq %rdx, 0x18(%rdi)
movl %esi, %r8d
negb %r8b
shrxq %r8, 0x10(%rdi), %r8
movq %r8, 0x10(%rdi)
cmpl $0x8, %esi
jb 0x7ebf
movq (%rdi), %r9
movq 0x8(%rdi), %r10
addl $0x8, %esi
movl $0xffffff00, %r11d      # imm = 0xFFFFFF00
cmpq %r9, %r10
js 0x7ea2
movl -0x4(%r9), %ebp
andl %r11d, %ebp
xorl %ebx, %ebx
cmpl $0x3000000, %ebp        # imm = 0x3000000
sete %bl
notq %rbx
jmp 0x7ea9
movq $-0x1, %rbx
addq %rbx, %r9
movq %r9, (%rdi)
shrq $0x8, %r8
movq %r8, 0x10(%rdi)
addl $-0x8, %esi
cmpl $0xf, %esi
jg 0x7e86
testl %ecx, %ecx
setne %sil
negb %cl
sarxq %rcx, %rax, %rax
cmpq $-0x1, %rax
setne %al
andb %sil, %al
movzbl %al, %eax
movabsq $-0x100000000000000, %rcx # imm = 0xFF00000000000000
movq %rcx, 0x10(%rdi)
movabsq $-0x100000000000001, %rcx # imm = 0xFEFFFFFFFFFFFFFF
cmpq %rcx, %rdx
cmovbq %rdx, %rcx
movq %rcx, 0x18(%rdi)
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/./edge264_bitstream.c
// Function: get_uv
static noinline unsigned get_uv(Edge264GetBits *gb, unsigned v) {
	unsigned ret = gb->msb_cache >> (SIZE_BIT - v);
	if (SIZE_BIT == 32 && __builtin_expect(v == 32, 0)) {
		gb->msb_cache = gb->lsb_cache;
		gb->lsb_cache = 0;
	} else {
		gb->msb_cache = shld(gb->lsb_cache, gb->msb_cache, v);
		gb->lsb_cache <<= v;
	}
	if (gb->lsb_cache)
		return ret;
	return refill(gb, ret);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %r14
movq %r14, (%rsp)
movq %r14, %rdx
movl %esi, %ecx
shldq %cl, %rax, %rdx
movq %rdx, 0x18(%rdi)
shlxq %rbx, 0x10(%rdi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
jne 0xd01b
callq 0xef03
negb %bl
shrxq %rbx, %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/./edge264_bitstream.c
// Function: get_u1
static noinline int get_u1(Edge264GetBits *gb) {
	int ret = gb->msb_cache >> (SIZE_BIT - 1);
	gb->msb_cache = shld(gb->lsb_cache, gb->msb_cache, 1);
	if (gb->lsb_cache <<= 1)
		return ret;
	return refill(gb, ret);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rbx
movq %rbx, 0x8(%rsp)
movq %rbx, %rdx
movl $0x1, %ecx
shldq %cl, %rax, %rdx
movq %rdx, 0x18(%rdi)
movq 0x10(%rdi), %rax
addq %rax, %rax
movq %rax, 0x10(%rdi)
jne 0xd530
callq 0xef03
shrq $0x3f, %rbx
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/edge264_headers.c
// Function: parse_access_unit_delimiter_log
int ADD_VARIANT(parse_access_unit_delimiter)(Edge264Decoder *dec, int non_blocking, void(*free_cb)(void*,int), void *free_arg) {
	const char *primary_pic_type_names[8] =
		{"I", "I,P", "I,P,B", "SI", "SI,SP", "I,SI", "I,SI,P,SP", "I,SI,P,SP,B"};
	int primary_pic_type = get_uv(&dec->_gb, 3);
	log_dec(dec, "  primary_pic_type: %u # %s\n",
		primary_pic_type, primary_pic_type_names[primary_pic_type]);
	if (print_dec(dec))
		return ENOTSUP;
	if (!rbsp_end(&dec->_gb))
		return EBADMSG;
	return 0;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x3, %esi
callq 0x18ad7
movzwl 0x7cb0(%rbx), %ecx
cmpq $0x2542, %rcx           # imm = 0x2542
jae 0x25f36
leaq (%rbx,%rcx), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %edx           # imm = 0x2542
subl %ecx, %edx
movzwl %dx, %esi
movslq %eax, %rcx
leaq 0x11dce(%rip), %rdx     # 0x37c78
movslq (%rdx,%rcx,4), %r8
addq %rdx, %r8
leaq 0x13dcc(%rip), %rdx     # 0x39c84
movl %eax, %ecx
xorl %eax, %eax
callq 0x1070
addw 0x7cb0(%rbx), %ax
movw $0x0, 0x7cb0(%rbx)
movzwl %ax, %ecx
movl $0x5f, %eax
cmpl $0x2541, %ecx           # imm = 0x2541
ja 0x25f44
leaq 0x7cb2(%rbx), %rdi
movq 0x7ca8(%rbx), %rsi
callq *0x7ca0(%rbx)
movq 0x10(%rbx), %rcx
movq 0x18(%rbx), %rdx
movq %rdx, %rax
shrq $0x3f, %rax
shlxq %rax, %rdx, %rdx
blsrq %rcx, %rsi
orq %rdx, %rsi
jne 0x25f2f
tzcntq %rcx, %rcx
addl %eax, %ecx
movl (%rbx), %eax
subl 0x8(%rbx), %eax
leal (%rcx,%rax,8), %ecx
addl $0xffffff78, %ecx       # imm = 0xFFFFFF78
xorl %eax, %eax
cmpl $-0x11, %ecx
ja 0x25f44
movl $0x4a, %eax
jmp 0x25f44
movw $0x0, 0x7cb0(%rbx)
movl $0x5f, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/edge264_headers.c
// Function: parse_nal_unit_header_extension_log
int ADD_VARIANT(parse_nal_unit_header_extension)(Edge264Decoder *dec, int non_blocking, void(*free_cb)(void*,int), void *free_arg) {
	unsigned u = get_uv(&dec->_gb, 24);
	if (u & 1 << 23)
		return ENOTSUP;
	dec->IdrPicFlag = u >> 22 & 1 ^ 1;
	log_dec(dec, "  idr_flag: %u\n"
		"  priority_id: %d\n"
		"  view_id: %d\n"
		"  temporal_id: %d\n"
		"  anchor_pic_flag: %u\n"
		"  inter_view_flag: %u\n",
		dec->IdrPicFlag,
		u >> 16 & 0x3f,
		u >> 6 & 0x3ff,
		u >> 3 & 7,
		u >> 2 & 1,
		u >> 1 & 1);
	if (dec->nal_unit_type == 20)
		return ADD_VARIANT(parse_slice_layer_without_partitioning)(dec, non_blocking, free_cb, free_arg);
	// spec doesn't mention rbsp_trailing_bits at the end of prefix_nal_unit_rbsp
	if (!rbsp_end(&dec->_gb))
		return EBADMSG;
	if (print_dec(dec))
		return ENOTSUP;
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movl $0x18, %esi
callq 0x18ad7
movl %eax, %r10d
movl $0x5f, %eax
btl $0x17, %r10d
jb 0x260ac
xorl %ecx, %ecx
btl $0x16, %r10d
setae %al
setae 0x23(%rbx)
movzwl 0x7cb0(%rbx), %esi
movb $0x1, %dl
cmpq $0x2541, %rsi           # imm = 0x2541
ja 0x26023
leaq (%rbx,%rsi), %rdi
addq $0x7cb2, %rdi           # imm = 0x7CB2
movl $0x2542, %r12d          # imm = 0x2542
movl $0x2542, %edx           # imm = 0x2542
subl %esi, %edx
movzwl %dx, %esi
movb %al, %cl
movl %r10d, %r8d
shrl $0x10, %r8d
andl $0x3f, %r8d
movl %r10d, %r9d
shrl $0x6, %r9d
andl $0x3ff, %r9d            # imm = 0x3FF
movl %r10d, %r11d
shrl $0x3, %r11d
andl $0x7, %r11d
movl %r10d, %r13d
shrl $0x2, %r13d
andl $0x1, %r13d
shrl %r10d
andl $0x1, %r10d
subq $0x8, %rsp
leaq 0x13ca6(%rip), %rdx     # 0x39ca1
xorl %eax, %eax
pushq %r10
pushq %r13
pushq %r11
callq 0x1070
addq $0x20, %rsp
addw 0x7cb0(%rbx), %ax
movw %ax, 0x7cb0(%rbx)
movzwl %ax, %eax
cmpl %r12d, %eax
setae %dl
cmpb $0x14, 0x22(%rbx)
jne 0x26047
movq %rbx, %rdi
movl %ebp, %esi
movq %r15, %rdx
movq %r14, %rcx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1178
movq 0x10(%rbx), %rsi
movq 0x18(%rbx), %rax
movq %rax, %rcx
shrq $0x3f, %rcx
shlxq %rcx, %rax, %rdi
blsrq %rsi, %r8
movl $0x4a, %eax
orq %rdi, %r8
jne 0x260ac
tzcntq %rsi, %rsi
movl (%rbx), %edi
subl 0x8(%rbx), %edi
addl %ecx, %esi
leal (%rsi,%rdi,8), %ecx
addl $0xffffff78, %ecx       # imm = 0xFFFFFF78
cmpl $-0x10, %ecx
jb 0x260ac
movw $0x0, 0x7cb0(%rbx)
movl $0x5f, %eax
testb %dl, %dl
jne 0x260ac
leaq 0x7cb2(%rbx), %rdi
movq 0x7ca8(%rbx), %rsi
callq *0x7ca0(%rbx)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/edge264.c
// Function: edge264_find_start_code
const uint8_t *edge264_find_start_code(const uint8_t *buf, const uint8_t *end, int four_byte) {
	const i8x16 *p = (i8x16 *)((uintptr_t)buf & -16);
	four_byte = four_byte != 0;
	i8x16 zero = {};
	i8x16 c1 = set8(1);
	i8x16 lo0 = {};
	i8x16 v = *p;
	i8x16 hi0 = (v == zero) & shlv128(set8(-1), (uintptr_t)buf & 15);
	while (1) {
		#if defined(__SSE2__)
			unsigned m = movemask(shrd128(lo0, hi0, 14) & shrd128(lo0, hi0, 15) & (v == c1));
			if (m) {
				const uint8_t *res = (uint8_t *)p - 2 - four_byte + __builtin_ctz(m);
				if (*res == 0)
					return minp(res, end);
			}
		#elif defined(__ARM_NEON)
			uint64_t m = (uint64_t)vshrn_n_u16(shrd128(lo0, hi0, 14) & shrd128(lo0, hi0, 15) & (v == c1), 4);
			if (m) {
				const uint8_t *res = (uint8_t *)p - 2 - four_byte + (__builtin_ctzll(m) >> 2);
				if (*res == 0)
					return minp(res, end);
			}
		#endif
		if ((intptr_t)(end - (uint8_t *)++p) <= 0)
			return end;
		lo0 = hi0;
		hi0 = ((v = *p) == zero);
	}
}

// Assembly:
movq %rsi, %rax
movq %rdi, %rcx
andq $-0x10, %rcx
xorl %esi, %esi
testl %edx, %edx
setne %sil
vmovdqa (%rcx), %xmm2
vptestnmb %xmm2, %xmm2, %k1
vpxor %xmm0, %xmm0, %xmm0
andl $0xf, %edi
leaq 0x25a90(%rip), %rdx     # 0x34260
subq %rdi, %rdx
vpcmpeqd %xmm1, %xmm1, %xmm1
vpshufb 0x10(%rdx), %xmm1, %xmm1 {%k1} {z}
movq %rax, %rdi
subq %rcx, %rdi
addq $-0x2, %rcx
leaq (%rdi,%rsi), %rdx
addq $0x2, %rdx
addq $-0x10, %rdi
negq %rsi
vpbroadcastb 0x252f5(%rip), %xmm3 # 0x33af5
vpxor %xmm4, %xmm4, %xmm4
vpalignr $0xe, %xmm4, %xmm1, %xmm5 # xmm5 = xmm4[14,15],xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13]
vpalignr $0xf, %xmm4, %xmm1, %xmm4 # xmm4 = xmm4[15],xmm1[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14]
vpand %xmm4, %xmm5, %xmm4
vpcmpeqb %xmm3, %xmm2, %k0
vpmovb2m %xmm4, %k1
ktestw %k1, %k0
je 0xe83e
kandw %k1, %k0, %k0
kmovd %k0, %r8d
tzcntl %r8d, %r8d
leaq (%rsi,%r8), %r9
cmpb $0x0, (%rcx,%r9)
je 0xe85e
testq %rdi, %rdi
jle 0xe86f
vmovdqa 0x12(%rcx), %xmm2
vmovdqa %xmm1, %xmm4
vpcmpeqb %xmm0, %xmm2, %xmm1
addq $-0x10, %rdi
addq $0x10, %rcx
addq $-0x10, %rdx
jmp 0xe804
movzwl %r8w, %edi
addq %rsi, %rcx
addq %rdi, %rcx
cmpq %rdx, %rdi
cmovsq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/edge264.c
// Function: ignore_NAL
static int ignore_NAL(Edge264Decoder *dec, int non_blocking, void(*free_cb)(void*,int), void *free_arg) {
	if (dec->log_arg) {
		dec->log_pos = 0;
		dec->log_cb(dec->log_buf, dec->log_arg);
	}
	return 0;
}

// Assembly:
movq 0x7ca8(%rdi), %rsi
testq %rsi, %rsi
je 0xeb5d
pushq %rax
movq %rdi, %rax
movw $0x0, 0x7cb0(%rdi)
addq $0x7cb2, %rdi           # imm = 0x7CB2
callq *0x7ca0(%rax)
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/edge264.c
// Function: edge264_flush
void edge264_flush(Edge264Decoder *dec) {
	if (dec == NULL)
		return;
	if (dec->n_threads)
		pthread_mutex_lock(&dec->lock);
	// FIXME interrupt all threads
	dec->currPic = dec->prevPic = -1;
	dec->PrevRefFrameNum[0] = dec->PrevRefFrameNum[1] = -1;
	dec->prevPicOrderCnt[0] = dec->prevPicOrderCnt[1] = 0;
	dec->reference_flags = dec->long_term_flags = dec->output_flags = dec->non_base_views = 0;
	for (unsigned b = dec->busy_tasks; b; b &= b - 1) {
		Edge264Task *t = dec->tasks + __builtin_ctz(b);
		if (t->free_cb)
			t->free_cb(t->free_arg, 0);
	}
	dec->busy_tasks = dec->pending_tasks = dec->ready_tasks = 0;
	dec->task_dependencies_v[0] = dec->task_dependencies_v[1] = dec->task_dependencies_v[2] = dec->task_dependencies_v[3] = (i32x4){};
	dec->taskPics_v = set8(-1);
	if (dec->n_threads)
		pthread_mutex_unlock(&dec->lock);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0xec2e
movq %rdi, %rbx
cmpb $0x0, 0x20(%rdi)
je 0xeb82
leaq 0x1590(%rbx), %rdi
callq 0x1160
movw $0xffff, 0x24(%rbx)     # imm = 0xFFFF
movq $-0x1, 0x3c(%rbx)
xorl %eax, %eax
movq %rax, 0x48(%rbx)
movl %eax, 0x78(%rbx)
movl %eax, 0x64(%rbx)
movq %rax, 0x5c(%rbx)
movzwl 0x1648(%rbx), %ebp
testl %ebp, %ebp
je 0xebdf
leaq 0x17a0(%rbx), %r14
tzcntl %ebp, %eax
imulq $0x650, %rax, %rcx      # imm = 0x650
movq 0x160(%r14,%rcx), %rax
testq %rax, %rax
je 0xebd8
addq %r14, %rcx
movq 0x168(%rcx), %rdi
xorl %esi, %esi
callq *%rax
blsrl %ebp, %ebp
jne 0xebb2
movw $0x0, 0x164c(%rbx)
movl $0x0, 0x1648(%rbx)
vpxor %xmm0, %xmm0, %xmm0
vmovdqu %ymm0, 0x1750(%rbx)
vmovdqu %ymm0, 0x1770(%rbx)
vpcmpeqd %xmm0, %xmm0, %xmm0
vmovdqa %xmm0, 0x1790(%rbx)
cmpb $0x0, 0x20(%rbx)
je 0xec2e
addq $0x1590, %rbx           # imm = 0x1590
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
vzeroupper
jmp 0x10e0
popq %rbx
popq %r14
popq %rbp
vzeroupper
retq
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/edge264.c
// Function: edge264_free
void edge264_free(Edge264Decoder **pdec) {
	Edge264Decoder *dec;
	if (pdec != NULL && (dec = *pdec) != NULL) {
		*pdec = NULL;
		if (dec->n_threads) {
			for (int i = 0; i < dec->n_threads; i++)
				pthread_cancel(dec->threads[i]);
			pthread_mutex_destroy(&dec->lock);
			pthread_cond_destroy(&dec->task_ready);
			pthread_cond_destroy(&dec->task_progress);
			pthread_cond_destroy(&dec->task_complete);
		}
		for (int i = 0; i < 32; i++) {
			if (dec->frame_buffers[i] != NULL)
				free(dec->frame_buffers[i]);
		}
		free(dec);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xecd7
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xecd7
movq $0x0, (%rdi)
cmpb $0x0, 0x20(%rbx)
je 0xecab
jle 0xec7b
xorl %r14d, %r14d
movq 0x1510(%rbx,%r14,8), %rdi
callq 0x1130
incq %r14
movsbq 0x20(%rbx), %rax
cmpq %rax, %r14
jl 0xec61
leaq 0x1590(%rbx), %rdi
callq 0x1060
leaq 0x15b8(%rbx), %rdi
callq 0x1110
leaq 0x15e8(%rbx), %rdi
callq 0x1110
leaq 0x1618(%rbx), %rdi
callq 0x1110
movl $0x31, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0xecbf
callq 0x1030
incq %r14
cmpq $0x51, %r14
jne 0xecb1
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/./edge264_mvpred.c
// Function: decode_P_skip
static noinline void decode_P_skip(Edge264Context *ctx) {
	mb->f.inter_eqs_s = little_endian32(0x1b5fbbff);
	mb->refPic_s[0] = ((i32x4)set8(ctx->t.RefPicList_v[0][0]))[0];
	mb->refPic_s[1] = -1;
	int refIdxA = mbA->refIdx[1];
	int refIdxB = mbB->refIdx[2];
	int mvA = mbA->mvs_s[5];
	int mvB = mbB->mvs_s[10];
	i16x8 mv = {};
	if ((refIdxA | mvA) && (refIdxB | mvB) && !(ctx->unavail4x4[0] & 3)) {
		int refIdxC;
		if (__builtin_expect(ctx->unavail4x4[5] & 4, 0)) {
			refIdxC = mbD->refIdx[3];
			mv = (i32x4){mbD->mvs_s[15]};
		} else {
			refIdxC = mbC->refIdx[2];
			mv = (i32x4){mbC->mvs_s[10]};
		}
		// B/C unavailability (->A) was ruled out, thus not tested here
		int eq = !refIdxA + !refIdxB * 2 + !refIdxC * 4;
		if (__builtin_expect(0xe9 >> eq & 1, 1)) {
			mv = median16((i32x4){mvA}, (i32x4){mvB}, mv);
		} else if (eq != 4) {
			mv = (i32x4){(eq == 1) ? mvA : mvB};
		}
	}
	i16x8 mvs = broadcast32(mv, 0);
	mb->mvs_v[0] = mb->mvs_v[1] = mb->mvs_v[2] = mb->mvs_v[3] = mvs;
	mb->mvs_v[4] = mb->mvs_v[5] = mb->mvs_v[6] = mb->mvs_v[7] = (i16x8){};
	decode_inter(ctx, 0, 16, 16);
}

// Assembly:
movq 0x680(%rdi), %rax
movl $0x1b5fbbff, 0x2c(%rax) # imm = 0x1B5FBBFF
vpbroadcastb 0x1a0(%rdi), %xmm0
movq 0x680(%rdi), %rax
vmovd %xmm0, 0x18(%rax)
movq 0x680(%rdi), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movq 0x688(%rdi), %rax
movsbl 0x11(%rax), %edx
movl 0xc4(%rax), %eax
movl %eax, %ecx
orl %edx, %ecx
vpxor %xmm0, %xmm0, %xmm0
vpxor %xmm1, %xmm1, %xmm1
je 0xf9f3
movq 0x690(%rdi), %rcx
movsbl 0x12(%rcx), %esi
movl 0xd8(%rcx), %ecx
movl %ecx, %r8d
orl %esi, %r8d
je 0xf9f3
testb $0x3, 0x6d0(%rdi)
jne 0xf9f3
testb $0x4, 0x6d5(%rdi)
jne 0xfa7e
movq 0x698(%rdi), %r9
leaq 0x12(%r9), %r8
addq $0xd8, %r9
vmovd (%r9), %xmm1
xorl %r9d, %r9d
testb %dl, %dl
sete %r9b
xorl %edx, %edx
testb %sil, %sil
sete %dl
leal (%r9,%rdx,2), %edx
xorl %esi, %esi
cmpb $0x0, (%r8)
sete %sil
leal (%rdx,%rsi,4), %edx
movl $0xe9, %esi
btl %edx, %esi
jae 0xfa95
vmovd %eax, %xmm2
vmovd %ecx, %xmm3
vpmaxsw %xmm3, %xmm2, %xmm4
vpminsw %xmm1, %xmm4, %xmm1
vpminsw %xmm3, %xmm2, %xmm2
vpmaxsw %xmm2, %xmm1, %xmm1
vpbroadcastd %xmm1, %xmm1
movq 0x680(%rdi), %rax
vmovdqa %xmm1, 0xe0(%rax)
movq 0x680(%rdi), %rax
vmovdqa %xmm1, 0xd0(%rax)
movq 0x680(%rdi), %rax
vmovdqa %xmm1, 0xc0(%rax)
movq 0x680(%rdi), %rax
vmovdqa %xmm1, 0xb0(%rax)
movq 0x680(%rdi), %rax
vmovdqa %xmm0, 0x120(%rax)
movq 0x680(%rdi), %rax
vmovdqa %xmm0, 0x110(%rax)
movq 0x680(%rdi), %rax
vmovdqa %xmm0, 0x100(%rax)
movq 0x680(%rdi), %rax
vmovdqa %xmm0, 0xf0(%rax)
xorl %esi, %esi
movl $0x10, %edx
movl $0x10, %ecx
jmp 0xfaee
movq 0x6a0(%rdi), %r9
leaq 0x13(%r9), %r8
addq $0xec, %r9
jmp 0xf9a6
cmpl $0x4, %edx
je 0xf9f3
cmpl $0x1, %edx
cmovel %eax, %ecx
vmovd %ecx, %xmm1
jmp 0xf9f3
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/./edge264_slice.c
// Function: parse_inter_residual_cabac
static void CAFUNC(parse_inter_residual)
{
	static const uint8_t me_inter[48] = {0, 1, 32, 8, 4, 128, 2, 40, 36, 136, 132, 172, 174, 44, 168, 164, 140, 12, 160, 173, 42, 38, 138, 134, 34, 10, 6, 130, 46, 170, 166, 142, 33, 9, 5, 129, 41, 37, 137, 133, 45, 169, 165, 141, 13, 161, 14, 162};
	CACALL(parse_coded_block_pattern, me_inter);
	
	if ((mb->bits[0] & 0xac) && ctx->transform_8x8_mode_flag) {
		mb->f.transform_size_8x8_flag = CACOND(get_u1(&ctx->t._gb), get_ae(ctx, 399 + ctx->inc.transform_size_8x8_flag));
		log_mb(ctx, "    transform_size_8x8_flag: %u\n", mb->f.transform_size_8x8_flag);
	}
	
	#if CABAC
		ctx->nC_inc_v[0] = ctx->nC_inc_v[1] = ctx->nC_inc_v[2] = (i8x16){};
	#endif
	CAJUMP(parse_NxN_residual);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x318b7
movq 0x680(%rbx), %rax
testb $-0x54, 0x8(%rax)
je 0x31897
cmpb $0x0, 0xdc0(%rbx)
je 0x31897
movsbl 0x6c4(%rbx), %esi
addl $0x18f, %esi            # imm = 0x18F
movq %rbx, %rdi
callq 0x3102b
movq 0x680(%rbx), %rcx
movb %al, 0x24(%rcx)
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x31897
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
movq 0x680(%rbx), %rax
movsbl 0x24(%rax), %ecx
leaq 0x8f0c(%rip), %rdx      # 0x3a795
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovups %ymm0, 0x710(%rbx)
vmovaps %ymm0, 0x700(%rbx)
movq %rbx, %rdi
popq %rbx
vzeroupper
jmp 0x31a1e
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/./edge264_slice.c
// Function: parse_coded_block_pattern_cabac
static void CAFUNC(parse_coded_block_pattern, const uint8_t *map_me)
{
	// Luma prefix
	#if !CABAC
		int cbp = map_me[get_ue16(&ctx->t._gb, 47)];
		mb->bits[0] |= cbp & 0xac;
	#else
		int bits = mb->bits[0];
		bits |= get_ae(ctx, 76 - (bits      & 3)) << 5;
		bits |= get_ae(ctx, 76 - (bits >> 5 & 3)) << 3;
		bits |= get_ae(ctx, 76 - (bits >> 4 & 3)) << 2;
		bits |= get_ae(ctx, 76 - (bits >> 2 & 3)) << 7;
		mb->bits[0] = bits;
	#endif
	
	// Chroma suffix
	if ((ctx->t.ChromaArrayType == 1 || ctx->t.ChromaArrayType == 2) &&
		CACOND(cbp & 3, get_ae(ctx, 77 + ctx->inc.CodedBlockPatternChromaDC)))
	{
		mb->f.CodedBlockPatternChromaDC = 1;
		mb->f.CodedBlockPatternChromaAC = CACOND(cbp >> 1 & 1, get_ae(ctx, 81 + ctx->inc.CodedBlockPatternChromaAC));
	}
	
	log_mb(ctx, "    coded_block_pattern: %u\n",
		(mb->bits[0] >> 5 & 1) | (mb->bits[0] >> 2 & 2) | (mb->bits[0] & 4) | (mb->bits[0] >> 4 & 8) |
		(mb->f.CodedBlockPatternChromaDC + mb->f.CodedBlockPatternChromaAC) << 4);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x680(%rdi), %rax
movl 0x8(%rax), %r15d
movl %r15d, %eax
andl $0x3, %eax
movl $0x4c, %ebp
movl $0x4c, %esi
subl %eax, %esi
callq 0x3102b
movl %eax, %r14d
shll $0x5, %r14d
orl %r15d, %r14d
movl %r14d, %eax
shrl $0x5, %eax
andl $0x3, %eax
movl $0x4c, %esi
subl %eax, %esi
movq %rbx, %rdi
callq 0x3102b
movl %eax, %r15d
shll $0x3, %r15d
movl %r14d, %eax
shrl $0x4, %eax
andl $0x3, %eax
movl $0x4c, %esi
subl %eax, %esi
movq %rbx, %rdi
callq 0x3102b
leal (%r15,%rax,4), %r15d
orl %r14d, %r15d
movl %r15d, %eax
shrl $0x2, %eax
andl $0x3, %eax
subl %eax, %ebp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3102b
shll $0x7, %eax
orl %r15d, %eax
movq 0x680(%rbx), %rcx
movl %eax, 0x8(%rcx)
movb 0x2a(%rbx), %al
decb %al
cmpb $0x1, %al
ja 0x31996
movsbl 0x6c6(%rbx), %esi
addl $0x4d, %esi
movq %rbx, %rdi
callq 0x3102b
testl %eax, %eax
je 0x31996
movq 0x680(%rbx), %rax
movb $0x1, 0x26(%rax)
movsbl 0x6c7(%rbx), %esi
addl $0x51, %esi
movq %rbx, %rdi
callq 0x3102b
movq 0x680(%rbx), %rcx
movb %al, 0x27(%rcx)
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x31a13
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
movq 0x680(%rbx), %rax
movl 0x8(%rax), %edx
movl %edx, %ecx
shrl $0x5, %ecx
andl $0x1, %ecx
movl %edx, %r8d
shrl $0x2, %r8d
andl $0x2, %r8d
movl %edx, %r9d
andl $0x4, %r9d
orl %r8d, %r9d
orl %ecx, %r9d
shrl $0x4, %edx
andl $0x8, %edx
orl %r9d, %edx
movsbl 0x26(%rax), %r8d
movsbl 0x27(%rax), %ecx
addl %r8d, %ecx
shll $0x4, %ecx
orl %edx, %ecx
leaq 0x8db1(%rip), %rdx      # 0x3a7b6
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/./edge264_slice.c
// Function: parse_mb_qp_delta_cabac
static void CAFUNC(parse_mb_qp_delta)
{
	#if !CABAC
		int mb_qp_delta = get_se16(&ctx->t._gb, -26, 25); // FIXME QpBdOffset
		if (mb_qp_delta) {
			int sum = ctx->t.QP[0] + mb_qp_delta;
			int QP_Y = (sum < 0) ? sum + 52 : (sum >= 52) ? sum - 52 : sum;
			mb->QP_s = ctx->t.QP_s = (i8x4){QP_Y, ctx->QP_C[0][QP_Y], ctx->QP_C[1][QP_Y]};
		}
	#else
		int mb_qp_delta_nz = get_ae(ctx, 60 + ctx->mb_qp_delta_nz);
		ctx->mb_qp_delta_nz = mb_qp_delta_nz;
		int mb_qp_delta = 0;
		if (mb_qp_delta_nz) {
			unsigned count = 1, ctxIdx = 62;
			while (get_ae(ctx, ctxIdx) && count < 52) // FIXME QpBdOffset
				count++, ctxIdx = 63;
			mb_qp_delta = count & 1 ? count / 2 + 1 : -(count / 2);
			int sum = ctx->t.QP[0] + mb_qp_delta;
			int QP_Y = (sum < 0) ? sum + 52 : (sum >= 52) ? sum - 52 : sum;
			mb->QP_s = ctx->t.QP_s = (i8x4){QP_Y, ctx->QP_C[0][QP_Y], ctx->QP_C[1][QP_Y]};
		}
	#endif
	log_mb(ctx, "    mb_qp_delta: %d\n", mb_qp_delta);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movsbl 0x651(%rdi), %esi
addl $0x3c, %esi
callq 0x16bee
movb %al, 0x651(%rbx)
testl %eax, %eax
je 0x177d7
movq %rbx, %rdi
movl $0x3e, %esi
callq 0x16bee
testl %eax, %eax
je 0x17774
movl $0x1, %r14d
leal 0x1(%r14), %ebp
movq %rbx, %rdi
movl $0x3f, %esi
callq 0x16bee
testl %eax, %eax
je 0x17779
cmpl $0x33, %r14d
movl %ebp, %r14d
jb 0x17754
jmp 0x17779
movl $0x1, %ebp
movl %ebp, %eax
shrl %eax
leal 0x1(%rax), %ecx
negl %eax
testb $0x1, %bpl
cmovnel %ecx, %eax
movsbl 0x50(%rbx), %ecx
leal (%rax,%rcx), %edx
addl $-0x34, %edx
leal (%rax,%rcx), %esi
addl $0x34, %esi
addl %ecx, %eax
cmpl $0x34, %eax
cmovll %eax, %edx
testl %eax, %eax
cmovnsl %edx, %esi
movslq %esi, %rax
movzbl %al, %ecx
vmovd %ecx, %xmm0
vpinsrb $0x1, 0x1ae0(%rbx,%rax), %xmm0, %xmm0
vpinsrb $0x2, 0x1b20(%rbx,%rax), %xmm0, %xmm0
vmovd %xmm0, 0x50(%rbx)
movq 0x680(%rbx), %rax
vmovd %xmm0, 0x4(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/./edge264_slice.c
// Function: parse_residual_block_2x2_cavlc
static noinline void parse_residual_block_2x2_cavlc(Edge264Context *ctx) {
		static const int16_t tokens[8 * 4] = {
			133, 133, 133, 133,
			256, 256, 256, 256,
			394, 394, 394, 394,
			776, 783, 777, 772,
			784, 784, 780, 780,
			910, 910, 909, 909,
			1042, 1042, 1041, 1041,
			915, 915, 915, 915,
		};
		int leadingZeroBits = clz(ctx->t._gb.msb_cache | (size_t)1 << (SIZE_BIT - 8));
		unsigned suffix = ctx->t._gb.msb_cache >> (SIZE_BIT - 3 - leadingZeroBits) & 3;
		int token = tokens[leadingZeroBits * 4 + suffix];
		int coeff_token = token & 127;
		int v = token >> 7;
		ctx->t._gb.msb_cache = shld(ctx->t._gb.lsb_cache, ctx->t._gb.msb_cache, v);
		if (!(ctx->t._gb.lsb_cache <<= v))
			refill(&ctx->t._gb, 0);
		if (coeff_token) {
			log_mb(ctx, "    - {nC: -1, c: [");
			parse_residual_coeffs_cavlc(ctx, 0, 3, coeff_token);
		} else {
			log_mb(ctx, "    - {nC: -1}\n");
		}
	}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rdx
movq 0x18(%rdi), %rax
movq %rax, %rcx
btsq $0x38, %rcx
lzcntq %rcx, %rcx
movb $0x3d, %sil
subb %cl, %sil
shrxq %rsi, %rax, %rsi
andl $0x3, %esi
addl %esi, %esi
leal (%rsi,%rcx,8), %ecx
leaq 0xaba5(%rip), %rsi      # 0x390b0
movswl (%rcx,%rsi), %ecx
movl %ecx, %ebp
andl $0x7f, %ebp
sarl $0x7, %ecx
movq %rax, (%rsp)
shldq %cl, %rdx, %rax
movq %rax, 0x18(%rdi)
shlxq %rcx, 0x10(%rdi), %rax
movq %rax, 0x10(%rdi)
testq %rax, %rax
jne 0x2e53a
movq %rbx, %rdi
callq 0x18999
movzwl 0x1cd0(%rbx), %eax
testl %ebp, %ebp
je 0x2e587
cmpl $0xfff, %eax            # imm = 0xFFF
ja 0x2e574
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %esi           # imm = 0x1000
subq %rax, %rsi
leaq 0xc2be(%rip), %rdx      # 0x3a824
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
movq %rbx, %rdi
xorl %esi, %esi
movl $0x3, %edx
movl %ebp, %ecx
callq 0x2e134
jmp 0x2e5b8
cmpl $0xfff, %eax            # imm = 0xFFF
ja 0x2e5b8
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
leaq 0xc28e(%rip), %rdx      # 0x3a838
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/./edge264_bitstream.c
// Function: cabac_terminate
static int cabac_terminate(Edge264Context *ctx) {
	int extra = SIZE_BIT - 9 - clz(ctx->t._gb.codIRange); // [0..SIZE_BIT-9]
	ctx->t._gb.codIRange -= (size_t)2 << extra;
	if (ctx->t._gb.codIOffset >= ctx->t._gb.codIRange) {
		// reclaim the extra bits minus alignment bits, then refill the cache
		ctx->t._gb.msb_cache = (ctx->t._gb.codIOffset * 2 + 1) << (SIZE_BIT - 1 - (extra & -8));
		return refill(&ctx->t._gb, 1);
	}
	if (__builtin_expect(ctx->t._gb.codIRange < 256, 0)) {
		ctx->t._gb.codIOffset = shld(get_bytes(&ctx->t._gb, SIZE_BIT / 8 - 1), ctx->t._gb.codIOffset, SIZE_BIT - 8);
		ctx->t._gb.codIRange <<= SIZE_BIT - 8;
	}
	return 0;
}

// Assembly:
pushq %rbx
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rcx
lzcntq %rsi, %rax
movb $0x37, %dl
subb %al, %dl
movq $-0x2, %r8
shlxq %rdx, %r8, %rdx
addq %rsi, %rdx
movq %rdx, 0x10(%rdi)
cmpq %rdx, %rcx
jae 0x16bcb
xorl %ebx, %ebx
cmpq $0xff, %rdx
ja 0x16bea
leaq 0x10(%rdi), %rdx
leaq 0x18(%rdi), %rsi
callq 0x123e
jmp 0x16bea
leaq 0x1(,%rcx,2), %rcx
andb $0x38, %al
addb $0xf, %al
shlxq %rax, %rcx, %rax
movq %rax, 0x18(%rdi)
callq 0xef03
movl $0x1, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/tvlabs[P]edge264/./edge264_slice.c
// Function: parse_intra_chroma_pred_mode_cabac
static void CAFUNC(parse_intra_chroma_pred_mode)
{
	static const int8_t IntraChromaModes[4][4] = {
		{IC8x8_DC_8, IC8x8_DCA_8, IC8x8_DCB_8, IC8x8_DCAB_8},
		{IC8x8_H_8 , IC8x8_DCA_8, IC8x8_H_8  , IC8x8_DCAB_8},
		{IC8x8_V_8 , IC8x8_V_8  , IC8x8_DCB_8, IC8x8_DCAB_8},
		{IC8x8_P_8 , IC8x8_DCA_8, IC8x8_DCB_8, IC8x8_DCAB_8},
	};
	
	// Do not optimise too hard to keep the code understandable here.
	int type = ctx->t.ChromaArrayType;
	if (type == 1 || type == 2) {
		#if !CABAC
			int mode = get_ue16(&ctx->t._gb, 3);
		#else
			int ctxIdx = 64 + ctx->inc.intra_chroma_pred_mode_non_zero;
			int mode = 0;
			while (mode <3 && get_ae(ctx, ctxIdx))
				mode++, ctxIdx = 67;
			mb->f.intra_chroma_pred_mode_non_zero = (mode > 0);
		#endif
		log_mb(ctx, "    intra_chroma_pred_mode: %u\n", mode);
		decode_intraChroma(IntraChromaModes[mode][ctx->unavail4x4[0] & 3], ctx->samples_mb[1], ctx->t.stride[1] >> 1, ctx->t.samples_clip_v[1]);
	}
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movb 0x2a(%rdi), %al
decb %al
cmpb $0x1, %al
ja 0x327d6
movq %rdi, %rbx
movsbl 0x6c5(%rdi), %esi
addl $0x40, %esi
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x3102b
testl %eax, %eax
je 0x3275b
incl %ebp
movl $0x43, %esi
cmpl $0x3, %ebp
jne 0x3273e
movl $0x3, %ebp
testl %ebp, %ebp
movq 0x680(%rbx), %rax
setne 0x25(%rax)
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x327a3
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x81d4(%rip), %rdx      # 0x3a967
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
movl %ebp, %eax
movzbl 0x6d0(%rbx), %ecx
andl $0x3, %ecx
leaq 0x131a(%rip), %rdx      # 0x33ad0
leaq (%rdx,%rax,4), %rax
movsbl (%rcx,%rax), %edi
movq 0x670(%rbx), %rsi
movzwl 0x36(%rbx), %edx
shrl %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2f825
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/perdisci[P]LSH/minhash.cpp
// Function: rp::MinHash::random_uint32_universal_hash(unsigned long)
vector<uint32_t> MinHash::random_uint32_universal_hash(const uint64_t x) {
    
    assert(x > 0 && x < UINT64_MAX);
    
    static const unsigned w = sizeof(uint64_t)*8;
    static const unsigned M = sizeof(uint32_t)*8;
    
    vector<uint32_t> hv;
    hv.push_back(static_cast<uint32_t>(x));
    
    for(int i=0; i<sig_len; i++) {
        if(a.size()<sig_len) {
            a.push_back(urandom_64(rand_eng));
            b.push_back(urandom_32(rand_eng));
        }
        
        uint32_t h = static_cast<uint32_t>((a[i]*x+b[i]) >> (w-M));
        hv.push_back(h);
    }
    
    return hv;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq -0x1(%rdx), %rax
cmpq $-0x2, %rax
jae 0xb80f
movq %rdx, %rcx
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq %rsp, %rdx
movq %rcx, 0x10(%rsp)
movl %ecx, (%rdx)
xorl %esi, %esi
callq 0xbd48
movl 0x50(%r15), %eax
testl %eax, %eax
je 0xb7fd
leaq 0x38(%r15), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x30(%r15), %r13
leaq 0x48(%r15), %rbp
leaq 0x18(%r15), %r14
xorl %r12d, %r12d
movq (%r15), %rcx
movq 0x8(%r15), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
movl %eax, %eax
cmpq %rax, %rdx
jae 0xb7b4
movq 0x8(%rsp), %rdi
movq %r13, %rsi
movq %rdi, %rdx
callq 0xbe60
movq %rax, (%rsp)
movq 0x8(%r15), %rsi
cmpq 0x10(%r15), %rsi
je 0xb770
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r15)
jmp 0xb77b
movq %r15, %rdi
movq %rsp, %rdx
callq 0xbfec
movq %rbp, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0xc122
movl %eax, %eax
movq %rax, (%rsp)
movq 0x20(%r15), %rsi
cmpq 0x28(%r15), %rsi
je 0xb7a6
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x20(%r15)
jmp 0xb7b1
movq %r14, %rdi
movq %rsp, %rdx
callq 0xbfec
movq (%r15), %rcx
movq (%rcx,%r12,8), %rax
imulq 0x10(%rsp), %rax
movq (%r14), %rcx
addq (%rcx,%r12,8), %rax
shrq $0x20, %rax
movl %eax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xb7e2
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xb7ed
movq %rbx, %rdi
movq %rsp, %rdx
callq 0xc2a8
incq %r12
movl 0x50(%r15), %eax
cmpq %rax, %r12
jb 0xb730
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6e3a(%rip), %rdi      # 0x12650
leaq 0x6e4b(%rip), %rsi      # 0x12668
leaq 0x6e50(%rip), %rcx      # 0x12674
movl $0x22, %edx
callq 0x5200
jmp 0xb834
jmp 0xb834
jmp 0xb834
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb844
callq 0x5300
movq %r14, %rdi
callq 0x55b0
// File: /workspace/github_c_makefile_star2_O3/perdisci[P]LSH/minhash.cpp
// Function: rp::MinHash::minhash_universal(std::set<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
vector<uint32_t> MinHash::minhash_universal(const set<string>& s_set) {

    vector<uint32_t> mh_sig(sig_len,UINT32_MAX);
    for(string s : s_set) {
        uint64_t xxh = static_cast<uint64_t>(XXH64(s.data(),s.size(),seed));
        vector<uint32_t> rh = random_uint32_universal_hash(xxh);
        for(int i=0; i<sig_len; i++) {
            if(rh[i] < mh_sig[i])
                mh_sig[i] = rh[i];
        }
    }
    
    return std::move(mh_sig);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x8(%rsp)
movl 0x50(%rsi), %esi
leaq 0x10(%rsp), %rdx
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rcx
callq 0xbbcc
movq 0x18(%r14), %r12
addq $0x8, %r14
cmpq %r14, %r12
je 0xb939
leaq 0x20(%rsp), %rbx
leaq 0x10(%rsp), %r13
leaq 0x50(%rsp), %rbp
movq %rbx, 0x10(%rsp)
movq 0x20(%r12), %rsi
movq 0x28(%r12), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0x734c
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x54(%r15), %edx
callq 0xc784
movq %rbp, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb6c8
movl 0x50(%r15), %eax
movq 0x50(%rsp), %rdi
testl %eax, %eax
je 0xb90c
movq 0x30(%rsp), %rcx
xorl %edx, %edx
movl (%rdi,%rdx,4), %esi
cmpl (%rcx,%rdx,4), %esi
jae 0xb900
movl %esi, (%rcx,%rdx,4)
movl 0x50(%r15), %eax
incq %rdx
movl %eax, %esi
cmpq %rsi, %rdx
jb 0xb8f1
jmp 0xb911
testq %rdi, %rdi
je 0xb916
callq 0x5300
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0xb925
callq 0x5300
movq %r12, %rdi
callq 0x5390
movq %rax, %r12
cmpq %r14, %rax
jne 0xb8a2
movaps 0x30(%rsp), %xmm0
movq 0x8(%rsp), %rax
movups %xmm0, (%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rax)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xb977
jmp 0xb965
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbx, %rdi
je 0xb977
callq 0x5300
movq 0x30(%rsp), %rdi
testq %rdi, %rdi
je 0xb986
callq 0x5300
movq %r14, %rdi
callq 0x55b0