LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x23047(%rip), %rdx     # 0x2e150
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 0x228ac(%rip), %xmm3 # 0x2d9e5
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 0xb177
kandw %k1, %k0, %k0
kmovd %k0, %r8d
tzcntl %r8d, %r8d
leaq (%rsi,%r8), %r9
cmpb $0x0, (%rcx,%r9)
je 0xb197
testq %rdi, %rdi
jle 0xb1a8
vmovdqa 0x12(%rcx), %xmm2
vmovdqa %xmm1, %xmm4
vpcmpeqb %xmm0, %xmm2, %xmm1
addq $-0x10, %rdi
addq $0x10, %rcx
addq $-0x10, %rdx
jmp 0xb13d
movzwl %r8w, %edi
addq %rsi, %rcx
addq %rdi, %rcx
cmpq %rdx, %rdi
cmovsq %rcx, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb46d
pushq %rax
movq %rdi, %rax
andw $0x0, 0x7cb0(%rdi)
addq $0x7cb2, %rdi           # imm = 0x7CB2
callq *0x7ca0(%rax)
addq $0x8, %rsp
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xb538
movq %rdi, %rbx
cmpb $0x0, 0x20(%rdi)
je 0xb492
leaq 0x1590(%rbx), %rdi
callq 0x1160
orw $-0x1, 0x24(%rbx)
orq $-0x1, 0x3c(%rbx)
andq $0x0, 0x48(%rbx)
andl $0x0, 0x78(%rbx)
andl $0x0, 0x64(%rbx)
andq $0x0, 0x5c(%rbx)
movzwl 0x1648(%rbx), %ebp
leaq 0x17a0(%rbx), %r14
testl %ebp, %ebp
je 0xb4ed
tzcntl %ebp, %eax
imulq $0x650, %rax, %rcx      # imm = 0x650
movq 0x160(%r14,%rcx), %rax
testq %rax, %rax
je 0xb4e6
addq %r14, %rcx
movq 0x168(%rcx), %rdi
xorl %esi, %esi
callq *%rax
blsrl %ebp, %ebp
jmp 0xb4bc
andw $0x0, 0x164c(%rbx)
andl $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 0xb538
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_O2/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 0xb57d
movq (%rdi), %rbx
testq %rbx, %rbx
je 0xb57d
andq $0x0, (%rdi)
movb 0x20(%rbx), %al
testb %al, %al
je 0xb5b5
xorl %r14d, %r14d
movsbq %al, %rax
cmpq %rax, %r14
jge 0xb585
movq 0x1510(%rbx,%r14,8), %rdi
callq 0x1130
incq %r14
movb 0x20(%rbx), %al
jmp 0xb55f
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1590(%rbx), %rdi
callq 0x1060
leaq 0x15b8(%rbx), %rdi
callq 0x1110
leaq 0x15e8(%rbx), %rdi
callq 0x1110
leaq 0x1618(%rbx), %rdi
callq 0x1110
pushq $0x31
popq %r14
cmpq $0x51, %r14
je 0xb5cd
movq (%rbx,%r14,8), %rdi
callq 0x1030
incq %r14
jmp 0xb5b9
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/tvlabs[P]edge264/./edge264_bitstream.c
// Function: refill
static noinline int refill(Edge264GetBits *gb, int ret) {
	size_t bytes = get_bytes(gb, SIZE_BIT >> 3);
	int trailing_bit = ctz(gb->msb_cache); // [0..SIZE_BIT-1]
	gb->msb_cache = (gb->msb_cache ^ (size_t)1 << trailing_bit) | bytes >> (SIZE_BIT - 1 - trailing_bit);
	gb->lsb_cache = (bytes * 2 + 1) << trailing_bit;
	return ret;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
pushq $0x8
popq %rsi
callq 0x13e93
movq 0x18(%rbx), %rcx
tzcntq %rcx, %rdx
btcq %rdx, %rcx
leaq 0x1(,%rax,2), %rsi
shlxq %rdx, %rsi, %rsi
notb %dl
shrxq %rdx, %rax, %rax
orq %rcx, %rax
movq %rax, 0x18(%rbx)
movq %rsi, 0x10(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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
orl $-0x1, 0x1c(%rax)
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 0xc13a
movq 0x690(%rdi), %rcx
movsbl 0x12(%rcx), %esi
movl 0xd8(%rcx), %ecx
movl %ecx, %r8d
orl %esi, %r8d
je 0xc13a
testb $0x3, 0x6d0(%rdi)
jne 0xc13a
testb $0x4, 0x6d5(%rdi)
jne 0xc1c3
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 0xc1da
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)
pushq $0x10
popq %rcx
xorl %esi, %esi
movl %ecx, %edx
jmp 0xcabd
movq 0x6a0(%rdi), %r9
leaq 0x13(%r9), %r8
addq $0xec, %r9
jmp 0xc0ed
cmpl $0x4, %edx
je 0xc13a
cmpl $0x1, %edx
cmovel %eax, %ecx
vmovd %ecx, %xmm1
jmp 0xc13a
// File: /workspace/github_c_makefile_star2_O2/tvlabs[P]edge264/./edge264_mvpred.c
// Function: decode_inter_8x16_left
static inline void decode_inter_8x16_left(Edge264Context *ctx, i16x8 mvd, int lx)
{
	// compare neighbouring indices and compute mvp
	i16x8 mvp, mvC;
	int refIdx = mb->refIdx[lx * 4];
	int refIdxA = mbA->refIdx[lx * 4 + 1];
	if (refIdx == refIdxA || ctx->unavail4x4[0] == 14) {
		mvp = (i32x4){mbA->mvs_s[lx * 16 + 5]};
	} else {
		int refIdxB = mbB->refIdx[lx * 4 + 2];
		int refIdxC;
		if (__builtin_expect(ctx->unavail4x4[0] & 2, 0)) {
			refIdxC = mbD->refIdx[lx * 4 + 3];
			mvC = (i32x4){mbD->mvs_s[lx * 16 + 15]};
		} else {
			refIdxC = mbB->refIdx[lx * 4 + 3];
			mvC = (i32x4){mbB->mvs_s[lx * 16 + 14]};
		}
		if (refIdx == refIdxB) {
			mvp = (i32x4){mbB->mvs_s[lx * 16 + 10]};
			if (refIdx == refIdxC) {
				i16x8 mvA = (i32x4){mbA->mvs_s[lx * 16 + 5]};
				mvp = median16(mvA, mvp, mvC);
			}
		} else { // refIdx != refIdxA/B
			mvp = mvC;
			if (refIdx != refIdxC) {
				i16x8 mvA = (i32x4){mbA->mvs_s[lx * 16 + 5]};
				i16x8 mvB = (i32x4){mbB->mvs_s[lx * 16 + 10]};
				mvp = median16(mvA, mvB, mvp);
			}
		}
	}
	
	// sum mvp and mvd, broadcast everything to memory and call decoding
	i16x8 mv = mvp + mvd;
	i16x8 mvs = broadcast32(mv, 0);
	mb->absMvd_l[lx * 4] = mb->absMvd_l[lx * 4 + 2] = ((i64x2)pack_absMvd(mvd))[0];
	mb->mvs_v[lx * 4] = mb->mvs_v[lx * 4 + 2] = mvs;
	decode_inter(ctx, lx * 16, 8, 16);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x680(%rdi), %rcx
movq 0x688(%rdi), %r8
movl %esi, %eax
movb 0x10(%rcx,%rax,4), %r9b
shlq $0x2, %rax
movl %eax, %r11d
cmpb 0x11(%r8,%r11), %r9b
je 0xc558
movb 0x6d0(%rdi), %bpl
cmpb $0xe, %bpl
jne 0xc5d3
shll $0x4, %esi
vmovd 0xc4(%r8,%rsi,4), %xmm1
movl %eax, %edx
orl $0x2, %edx
vpaddw %xmm0, %xmm1, %xmm1
vpbroadcastd %xmm1, %xmm1
vpbroadcastd %xmm0, %xmm0
vpacksswb %xmm0, %xmm0, %xmm0
vpabsb %xmm0, %xmm0
vmovq %xmm0, 0x70(%rcx,%rdx,8)
movq 0x680(%rdi), %rcx
vmovq %xmm0, 0x70(%rcx,%rax,8)
movq 0x680(%rdi), %rcx
shlq $0x4, %rdx
vmovdqa %xmm1, 0xb0(%rcx,%rdx)
movq 0x680(%rdi), %rcx
shlq $0x4, %rax
vmovdqa %xmm1, 0xb0(%rcx,%rax)
movl $0x8, %edx
movl $0x10, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xcabd
movq 0x690(%rdi), %r10
movl %eax, %edx
orl $0x2, %edx
movb 0x10(%r10,%rdx), %bl
testb $0x2, %bpl
jne 0xc683
movl $0xe, %r12d
movq %r10, %r15
movl %esi, %r14d
shll $0x4, %r14d
orl %r14d, %r12d
vmovd 0xb0(%r15,%r12,4), %xmm1
movb 0x13(%r15,%r11), %r11b
cmpb %bl, %r9b
jne 0xc649
shll $0x4, %esi
vmovd 0xd8(%r10,%rsi,4), %xmm2
cmpb %r11b, %r9b
jne 0xc67a
movl %esi, %r9d
vmovd 0xc4(%r8,%r9,4), %xmm3
vpmaxsw %xmm2, %xmm3, %xmm4
vpminsw %xmm1, %xmm4, %xmm1
vpminsw %xmm2, %xmm3, %xmm2
vpmaxsw %xmm2, %xmm1, %xmm1
jmp 0xc56a
cmpb %r11b, %r9b
je 0xc672
vmovd 0xc4(%r8,%r14,4), %xmm2
vmovd 0xd8(%r10,%r14,4), %xmm3
vpmaxsw %xmm3, %xmm2, %xmm4
vpminsw %xmm1, %xmm4, %xmm1
vpminsw %xmm3, %xmm2, %xmm2
vpmaxsw %xmm2, %xmm1, %xmm1
movl %r14d, %esi
jmp 0xc56a
vmovdqa %xmm2, %xmm1
jmp 0xc56a
movq 0x6a0(%rdi), %r15
movl $0xf, %r12d
jmp 0xc5f7
// File: /workspace/github_c_makefile_star2_O2/tvlabs[P]edge264/./edge264_mvpred.c
// Function: decode_inter_8x16_right
static inline void decode_inter_8x16_right(Edge264Context *ctx, i16x8 mvd, int lx)
{
	// compare neighbouring indices and compute mvp
	i16x8 mvp, mvC;
	int refIdx = mb->refIdx[lx * 4 + 1];
	int refIdxC;
	if (__builtin_expect(ctx->unavail4x4[5] & 4, 0)) {
		refIdxC = mbB->refIdx[lx * 4 + 2];
		mvC = (i32x4){mbB->mvs_s[lx * 16 + 11]};
	} else {
		refIdxC = mbC->refIdx[lx * 4 + 2];
		mvC = (i32x4){mbC->mvs_s[lx * 16 + 10]};
	}
	if (refIdx == refIdxC) {
		mvp = mvC;
	} else {
		int refIdxA = mb->refIdx[lx * 4];
		int refIdxB = mbB->refIdx[lx * 4 + 3];
		if (refIdx == refIdxB) {
			mvp = (i32x4){mbB->mvs_s[lx * 16 + 14]};
			if (refIdx == refIdxA) {
				i16x8 mvA = (i32x4){mb->mvs_s[lx * 16]};
				mvp = median16(mvA, mvp, mvC);
			}
		} else { // refIdx != B/C
			mvp = (i32x4){mb->mvs_s[lx * 16]};
			if (refIdx != refIdxA && ctx->unavail4x4[5] != 14) {
				i16x8 mvB = (i32x4){mbB->mvs_s[lx * 16 + 14]};
				mvp = median16(mvp, mvB, mvC);
			}
		}
	}
	
	// sum mvp and mvd, broadcast everything to memory and call decoding
	i16x8 mv = mvp + mvd;
	i16x8 mvs = broadcast32(mv, 0);
	mb->absMvd_l[lx * 4 + 1] = mb->absMvd_l[lx * 4 + 3] = ((i64x2)pack_absMvd(mvd))[0];
	mb->mvs_v[lx * 4 + 1] = mb->mvs_v[lx * 4 + 3] = mvs;
	decode_inter(ctx, lx * 16 + 4, 8, 16);
}

// Assembly:
pushq %rbx
movq 0x680(%rdi), %rdx
movl %esi, %ecx
shlq $0x2, %rcx
movl %ecx, %r10d
leaq 0x1(%r10), %rax
movb 0x11(%rdx,%r10), %r8b
movb 0x6d5(%rdi), %r9b
xorl %r11d, %r11d
testb $0x4, %r9b
sete %r11b
shll $0x4, %esi
movq 0x690(%rdi,%r11,8), %rbx
xorl $0xb, %r11d
orl %esi, %r11d
vmovd 0xb0(%rbx,%r11,4), %xmm1
cmpb 0x12(%rbx,%r10), %r8b
jne 0xc6e9
orl $0x3, %ecx
jmp 0xc764
movb 0x10(%rdx,%rcx), %bl
movq 0x690(%rdi), %r11
movq %r10, %rcx
orq $0x3, %rcx
cmpb 0x13(%r11,%r10), %r8b
jne 0xc72c
movl %esi, %r9d
vmovd 0xe8(%r11,%r9,4), %xmm2
cmpb %bl, %r8b
jne 0xc760
vmovd 0xb0(%rdx,%r9,4), %xmm3
vpmaxsw %xmm2, %xmm3, %xmm4
vpminsw %xmm1, %xmm4, %xmm1
vpminsw %xmm2, %xmm3, %xmm2
jmp 0xc75a
movl %esi, %r10d
vmovd 0xb0(%rdx,%r10,4), %xmm2
cmpb $0xe, %r9b
je 0xc760
cmpb %bl, %r8b
je 0xc760
vmovd 0xe8(%r11,%r10,4), %xmm3
vpmaxsw %xmm3, %xmm2, %xmm4
vpminsw %xmm1, %xmm4, %xmm1
vpminsw %xmm3, %xmm2, %xmm2
vpmaxsw %xmm2, %xmm1, %xmm1
jmp 0xc764
vmovdqa %xmm2, %xmm1
vpaddw %xmm0, %xmm1, %xmm1
vpbroadcastd %xmm0, %xmm0
vpacksswb %xmm0, %xmm0, %xmm0
vpabsb %xmm0, %xmm0
vmovq %xmm0, 0x70(%rdx,%rcx,8)
movq 0x680(%rdi), %rdx
vmovq %xmm0, 0x70(%rdx,%rax,8)
vpbroadcastd %xmm1, %xmm0
movq 0x680(%rdi), %rdx
shlq $0x4, %rcx
vmovdqa %xmm0, 0xb0(%rdx,%rcx)
movq 0x680(%rdi), %rcx
shlq $0x4, %rax
vmovdqa %xmm0, 0xb0(%rcx,%rax)
orl $0x4, %esi
movl $0x8, %edx
movl $0x10, %ecx
popq %rbx
jmp 0xcabd
// File: /workspace/github_c_makefile_star2_O2/tvlabs[P]edge264/./edge264_mvpred.c
// Function: decode_inter_16x8_top
static inline void decode_inter_16x8_top(Edge264Context *ctx, i16x8 mvd, int lx)
{
	// compare neighbouring indices and compute mvp
	i16x8 mvp, mvC;
	int refIdx = mb->refIdx[lx * 4];
	int refIdxB = mbB->refIdx[lx * 4 + 2];
	if (refIdx == refIdxB) {
		mvp = (i32x4){mbB->mvs_s[lx * 16 + 10]};
	} else {
		int refIdxA = mbA->refIdx[lx * 4 + 1];
		int eqA = refIdx == refIdxA;
		int refIdxC;
		if (__builtin_expect(ctx->unavail4x4[5] & 4, 0)) {
			refIdxC = mbD->refIdx[lx * 4 + 3];
			mvC = (i32x4){mbD->mvs_s[lx * 16 + 15]};
			eqA |= ctx->unavail4x4[0] == 14;
		} else {
			refIdxC = mbC->refIdx[lx * 4 + 2];
			mvC = (i32x4){mbC->mvs_s[lx * 16 + 10]};
		}
		if (refIdx == refIdxC) {
			mvp = mvC;
			if (eqA) {
				i16x8 mvA = (i32x4){mbA->mvs_s[lx * 16 + 5]};
				i16x8 mvB = (i32x4){mbB->mvs_s[lx * 16 + 10]};
				mvp = median16(mvA, mvB, mvp);
			}
		} else { // refIdx != refIdxB/C
			mvp = (i32x4){mbA->mvs_s[lx * 16 + 5]};
			if (!eqA) {
				i16x8 mvB = (i32x4){mbB->mvs_s[lx * 16 + 10]};
				mvp = median16(mvp, mvB, mvC);
			}
		}
	}
	
	// sum mvp and mvd, broadcast everything to memory and tail-jump to decoding
	i16x8 mv = mvp + mvd;
	i16x8 mvs = broadcast32(mv, 0);
	mb->absMvd_v[lx * 2] = pack_absMvd(mvd);
	mb->mvs_v[lx * 4 + 0] = mb->mvs_v[lx * 4 + 1] = mvs;
	decode_inter(ctx, lx * 16, 16, 8);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
movq 0x680(%rdi), %rdx
movq 0x690(%rdi), %r9
movl %esi, %ecx
movb 0x10(%rdx,%rcx,4), %al
shlq $0x2, %rcx
leal 0x2(%rcx), %ebx
cmpb 0x10(%r9,%rbx), %al
jne 0xc80c
movl %esi, %eax
shll $0x4, %eax
vmovd 0xd8(%r9,%rax,4), %xmm2
movl %ecx, %r8d
orl $0x1, %r8d
jmp 0xc8ad
movq 0x688(%rdi), %r10
movl %ecx, %r8d
orl $0x1, %r8d
movb 0x10(%r10,%r8), %bpl
cmpb %bpl, %al
sete %r11b
testb $0x4, 0x6d5(%rdi)
jne 0xc910
movq 0x698(%rdi), %r14
addq %r14, %rbx
addq $0x10, %rbx
movl %esi, %r15d
shll $0x4, %r15d
vmovd 0xd8(%r14,%r15,4), %xmm1
cmpb (%rbx), %al
jne 0xc876
movl %esi, %eax
shll $0x4, %eax
testb %r11b, %r11b
je 0xc8a9
vmovd 0xc4(%r10,%rax,4), %xmm2
vmovd 0xd8(%r9,%rax,4), %xmm3
jmp 0xc897
movl %esi, %eax
shll $0x4, %eax
vmovd 0xc4(%r10,%rax,4), %xmm2
testb %r11b, %r11b
jne 0xc8ad
movl %eax, %r10d
vmovd 0xd8(%r9,%r10,4), %xmm3
vpmaxsw %xmm3, %xmm2, %xmm4
vpminsw %xmm1, %xmm4, %xmm1
vpminsw %xmm3, %xmm2, %xmm2
vpmaxsw %xmm2, %xmm1, %xmm2
jmp 0xc8ad
vmovdqa %xmm1, %xmm2
vpaddw %xmm0, %xmm2, %xmm1
vpbroadcastd %xmm1, %xmm1
vpbroadcastd %xmm0, %xmm0
vpacksswb %xmm0, %xmm0, %xmm0
vpabsb %xmm0, %xmm0
addl %esi, %esi
shlq $0x4, %rsi
vmovdqa %xmm0, 0x70(%rdx,%rsi)
movq 0x680(%rdi), %rdx
shlq $0x4, %r8
vmovdqa %xmm1, 0xb0(%rdx,%r8)
movq 0x680(%rdi), %rdx
shlq $0x4, %rcx
vmovdqa %xmm1, 0xb0(%rdx,%rcx)
movl $0x10, %edx
movl $0x8, %ecx
movl %eax, %esi
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xcabd
cmpb %bpl, %al
sete %bpl
movq 0x6a0(%rdi), %r11
movl %ecx, %ebx
addq %r11, %rbx
addq $0x13, %rbx
movl %esi, %r14d
shll $0x4, %r14d
vmovd 0xec(%r11,%r14,4), %xmm1
cmpb $0xe, 0x6d0(%rdi)
sete %r11b
orb %bpl, %r11b
jmp 0xc852
// File: /workspace/github_c_makefile_star2_O2/tvlabs[P]edge264/./edge264_mvpred.c
// Function: decode_inter_16x8_bottom
static inline void decode_inter_16x8_bottom(Edge264Context *ctx, i16x8 mvd, int lx)
{
	// compare neighbouring indices and compute mvp
	i16x8 mvp;
	int refIdx = mb->refIdx[lx * 4 + 2];
	int refIdxA = mbA->refIdx[lx * 4 + 3];
	if (refIdx == refIdxA) {
		mvp = (i32x4){mbA->mvs_s[lx * 16 + 13]};
	} else {
		int refIdxB = mb->refIdx[lx * 4];
		int refIdxC = mbA->refIdx[lx * 4 + 1];
		if (refIdx == refIdxB) {
			mvp = (i32x4){mb->mvs_s[lx * 16]};
			if (refIdx == refIdxC) {
				i16x8 mvA = (i32x4){mbA->mvs_s[lx * 16 + 13]};
				i16x8 mvC = (i32x4){mbA->mvs_s[lx * 16 + 7]};
				mvp = median16(mvA, mvp, mvC);
			}
		} else {
			mvp = (i32x4){mbA->mvs_s[lx * 16 + 7]};
			if (refIdx != refIdxC) {
				i16x8 mvA = (i32x4){mbA->mvs_s[lx * 16 + 13]};
				i16x8 mvB = (i32x4){mb->mvs_s[lx * 16]};
				mvp = median16(mvA, mvB, mvp);
			}
		}
	}
	
	// sum mvp and mvd, broadcast everything to memory and tail-jump to decoding
	i16x8 mv = mvp + mvd;
	i16x8 mvs = broadcast32(mv, 0);
	mb->absMvd_v[lx * 2 + 1] = pack_absMvd(mvd);
	mb->mvs_v[lx * 4 + 2] = mb->mvs_v[lx * 4 + 3] = mvs;
	decode_inter(ctx, lx * 16 + 8, 16, 8);
}

// Assembly:
pushq %rbx
movq 0x680(%rdi), %rcx
movq 0x688(%rdi), %r9
movl %esi, %r11d
shlq $0x2, %r11
movl %r11d, %eax
leaq 0x2(%rax), %rdx
movb 0x12(%rcx,%rax), %r10b
leaq 0x3(%rax), %r8
cmpb 0x13(%r9,%rax), %r10b
jne 0xc9ed
movl %esi, %eax
shll $0x4, %eax
vmovd 0xe4(%r9,%rax,4), %xmm1
vpaddw %xmm0, %xmm1, %xmm1
vpbroadcastd %xmm0, %xmm0
vpacksswb %xmm0, %xmm0, %xmm0
vpabsb %xmm0, %xmm0
leal 0x1(,%rsi,2), %esi
shlq $0x4, %rsi
vmovdqa %xmm0, 0x70(%rcx,%rsi)
vpbroadcastd %xmm1, %xmm0
movq 0x680(%rdi), %rcx
shlq $0x4, %r8
vmovdqa %xmm0, 0xb0(%rcx,%r8)
movq 0x680(%rdi), %rcx
shlq $0x4, %rdx
vmovdqa %xmm0, 0xb0(%rcx,%rdx)
orl $0x8, %eax
movl $0x10, %edx
movl $0x8, %ecx
movl %eax, %esi
popq %rbx
jmp 0xcabd
movb 0x11(%r9,%rax), %bl
movl %esi, %eax
shll $0x4, %eax
cmpb 0x10(%rcx,%r11), %r10b
jne 0xca3d
movl %eax, %r11d
vmovd 0xb0(%rcx,%r11,4), %xmm1
cmpb %bl, %r10b
jne 0xc987
vmovd 0xe4(%r9,%r11,4), %xmm2
vmovd 0xcc(%r9,%r11,4), %xmm3
vpmaxsw %xmm1, %xmm2, %xmm4
vpminsw %xmm3, %xmm4, %xmm3
vpminsw %xmm1, %xmm2, %xmm1
vpmaxsw %xmm1, %xmm3, %xmm1
jmp 0xc987
movl %eax, %r11d
vmovd 0xcc(%r9,%r11,4), %xmm1
cmpb %bl, %r10b
je 0xc987
vmovd 0xe4(%r9,%r11,4), %xmm2
vmovd 0xb0(%rcx,%r11,4), %xmm3
vpmaxsw %xmm3, %xmm2, %xmm4
vpminsw %xmm1, %xmm4, %xmm1
vpminsw %xmm3, %xmm2, %xmm2
vpmaxsw %xmm2, %xmm1, %xmm1
jmp 0xc987
// File: /workspace/github_c_makefile_star2_O2/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 0x2b345
movq 0x680(%rbx), %rax
testb $-0x54, 0x8(%rax)
je 0x2b2c5
cmpb $0x0, 0xdc0(%rbx)
je 0x2b2c5
movsbl 0x6c4(%rbx), %esi
addl $0x18f, %esi            # imm = 0x18F
movq %rbx, %rdi
callq 0x2aced
movq 0x680(%rbx), %rcx
movb %al, 0x24(%rcx)
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x2b2c5
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 0x938e(%rip), %rdx      # 0x34645
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 0x2b4a1
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x4c
popq %rbp
movl %ebp, %esi
subl %eax, %esi
callq 0x2aced
movl %eax, %r14d
shll $0x5, %r14d
orl %r15d, %r14d
movl %r14d, %eax
shrl $0x5, %eax
andl $0x3, %eax
movl %ebp, %esi
subl %eax, %esi
movq %rbx, %rdi
callq 0x2aced
movl %eax, %r15d
shll $0x3, %r15d
movl %r14d, %eax
shrl $0x4, %eax
andl $0x3, %eax
movl %ebp, %esi
subl %eax, %esi
movq %rbx, %rdi
callq 0x2aced
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 0x2aced
shll $0x7, %eax
orl %r15d, %eax
movq 0x680(%rbx), %rcx
movl %eax, 0x8(%rcx)
movb 0x2a(%rbx), %al
decb %al
cmpb $0x1, %al
ja 0x2b419
movsbl 0x6c6(%rbx), %esi
addl $0x4d, %esi
movq %rbx, %rdi
callq 0x2aced
testl %eax, %eax
je 0x2b419
movq 0x680(%rbx), %rax
movb $0x1, 0x26(%rax)
movsbl 0x6c7(%rbx), %esi
addl $0x51, %esi
movq %rbx, %rdi
callq 0x2aced
movq 0x680(%rbx), %rcx
movb %al, 0x27(%rcx)
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x2b496
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 0x91de(%rip), %rdx      # 0x34666
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_O2/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 0x13a0c
movb %al, 0x651(%rbx)
testl %eax, %eax
je 0x14545
pushq $0x3e
popq %rsi
xorl %ebp, %ebp
pushq $0x3f
popq %r14
incl %ebp
movq %rbx, %rdi
callq 0x13a0c
testl %eax, %eax
je 0x144e7
movl %r14d, %esi
cmpl $0x34, %ebp
jb 0x144d1
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_O2/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 0xac64(%rip), %rsi      # 0x32f70
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 0x2833b
movq %rbx, %rdi
callq 0x15327
movzwl 0x1cd0(%rbx), %eax
testl %ebp, %ebp
je 0x28385
cmpw $0xfff, %ax             # imm = 0xFFF
ja 0x28374
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %esi           # imm = 0x1000
subq %rax, %rsi
leaq 0xc36e(%rip), %rdx      # 0x346d4
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
pushq $0x3
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
movl %ebp, %ecx
callq 0x27f93
jmp 0x283b5
cmpw $0xfff, %ax             # imm = 0xFFF
ja 0x283b5
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
leaq 0xc341(%rip), %rdx      # 0x346e8
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tvlabs[P]edge264/./edge264_slice.c
// Function: parse_intraNxN_pred_mode_cabac
static inline int CAFUNC(parse_intraNxN_pred_mode, int luma4x4BlkIdx)
{
	// dcPredModePredictedFlag is enforced by putting -2
	int intraMxMPredModeA = *((int8_t *)mb->Intra4x4PredMode + ctx->A4x4_int8[luma4x4BlkIdx]);
	int intraMxMPredModeB = *((int8_t *)mb->Intra4x4PredMode + ctx->B4x4_int8[luma4x4BlkIdx]);
	int mode = abs(min(intraMxMPredModeA, intraMxMPredModeB));
	int rem_intra_pred_mode = -1;
	if (CACOND(!get_u1(&ctx->t._gb), !get_ae(ctx, 68))) {
		#if !CABAC
			rem_intra_pred_mode = get_uv(&ctx->t._gb, 3);
		#else
			rem_intra_pred_mode = get_ae(ctx, 69);
			rem_intra_pred_mode += get_ae(ctx, 69) * 2;
			rem_intra_pred_mode += get_ae(ctx, 69) * 4;
		#endif
		mode = rem_intra_pred_mode + (rem_intra_pred_mode >= mode);
	}
	log_mb(ctx, luma4x4BlkIdx ? ",%d" : "%d", rem_intra_pred_mode);
	return mode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x680(%rdi), %rax
movslq %esi, %rcx
movswq 0xb40(%rdi,%rcx,2), %rdx
movzbl 0x30(%rax,%rdx), %edx
movslq 0xb80(%rdi,%rcx,4), %rcx
movzbl 0x30(%rax,%rcx), %eax
cmpb %al, %dl
cmovll %edx, %eax
movl %eax, %ecx
sarb $0x7, %cl
xorb %cl, %al
subb %cl, %al
movzbl %al, %r14d
pushq $0x44
popq %rsi
callq 0x2aced
testl %eax, %eax
je 0x2bdcd
pushq $-0x1
popq %rcx
jmp 0x2be07
pushq $0x45
popq %r15
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2aced
movl %eax, %r12d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2aced
leal (%r12,%rax,2), %r12d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2aced
leal (%r12,%rax,4), %ecx
cmpl %r14d, %ecx
movl %ecx, %r14d
sbbl $-0x1, %r14d
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x2be4d
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %edx           # imm = 0x1000
subl %eax, %edx
movzwl %dx, %esi
testl %ebp, %ebp
leaq 0x7adf(%rip), %rax      # 0x33913
leaq 0x89d8(%rip), %rdx      # 0x34813
cmoveq %rax, %rdx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rcx
lzcntq %rsi, %rax
movb $0x37, %dl
subb %al, %dl
pushq $-0x2
popq %rdi
shlxq %rdx, %rdi, %rdx
addq %rsi, %rdx
movq %rdx, 0x10(%rbx)
cmpq %rdx, %rcx
jae 0x139e3
xorl %ebp, %ebp
cmpq $0xff, %rdx
ja 0x13a03
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x13e93
movq 0x18(%rbx), %rdx
movq %rdx, (%rsp)
pushq $0x38
popq %rcx
shldq %cl, %rax, %rdx
movq %rdx, 0x18(%rbx)
shlq $0x38, 0x10(%rbx)
jmp 0x13a03
leaq 0x1(,%rcx,2), %rcx
andb $0x38, %al
addb $0xf, %al
shlxq %rax, %rcx, %rax
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
callq 0xb845
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/tvlabs[P]edge264/./edge264_bitstream.c
// Function: get_bypass
static inline int get_bypass(Edge264Context *ctx) {
	if (ctx->t._gb.codIRange < 512) {
		ctx->t._gb.codIOffset = shld(get_bytes(&ctx->t._gb, SIZE_BIT / 8 - 2), ctx->t._gb.codIOffset, SIZE_BIT - 16);
		ctx->t._gb.codIRange <<= SIZE_BIT - 16;
	}
	ctx->t._gb.codIRange >>= 1;
	size_t binVal = ctx->t._gb.codIOffset >= ctx->t._gb.codIRange;
	ctx->t._gb.codIOffset = binVal ? ctx->t._gb.codIOffset - ctx->t._gb.codIRange : ctx->t._gb.codIOffset;
	return binVal;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
cmpq $0x200, %rcx            # imm = 0x200
jae 0x13fe8
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x13e93
movq 0x18(%rbx), %rdx
movq %rdx, 0x8(%rsp)
pushq $0x30
popq %rcx
shldq %cl, %rax, %rdx
movq 0x10(%rbx), %rcx
shlq $0x30, %rcx
jmp 0x13fec
movq 0x18(%rbx), %rdx
shrq %rcx
movq %rcx, 0x10(%rbx)
xorl %esi, %esi
xorl %eax, %eax
cmpq %rcx, %rdx
setae %al
cmovaeq %rcx, %rsi
subq %rsi, %rdx
movq %rdx, 0x18(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movb 0x2a(%rdi), %al
decb %al
cmpb $0x1, %al
ja 0x2be9f
movq %rdi, %rbx
movsbl 0x6c5(%rdi), %esi
addl $0x40, %esi
leaq 0x1b43(%rip), %r14      # 0x2d9c0
xorl %ebp, %ebp
pushq $0x43
popq %r15
cmpl $-0x3, %ebp
je 0x2beaa
movq %rbx, %rdi
callq 0x2aced
testl %eax, %eax
je 0x2beaa
addq $0x4, %r14
decl %ebp
movl %r15d, %esi
jmp 0x2be83
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
testl %ebp, %ebp
movq 0x680(%rbx), %rax
setne 0x25(%rax)
movzwl 0x1cd0(%rbx), %eax
cmpq $0xfff, %rax            # imm = 0xFFF
ja 0x2bef4
negl %ebp
leaq (%rbx,%rax), %rdi
addq $0x1cd2, %rdi           # imm = 0x1CD2
movl $0x1000, %ecx           # imm = 0x1000
subl %eax, %ecx
movzwl %cx, %esi
leaq 0x8933(%rip), %rdx      # 0x34817
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1070
addw %ax, 0x1cd0(%rbx)
movzbl 0x6d0(%rbx), %eax
andl $0x3, %eax
movsbl (%r14,%rax), %edi
movq 0x670(%rbx), %rsi
movzwl 0x36(%rbx), %edx
shrl %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x296a8
// File: /workspace/github_c_makefile_star2_O2/tvlabs[P]edge264/./edge264_headers.c
// Function: ppow
static unsigned ppow(unsigned p65536, unsigned k) {
	unsigned r = 65536;
	while (k) {
		if (k & 1)
			r = (r * p65536) >> 16;
		p65536 = (p65536 * p65536) >> 16;
		k >>= 1;
	}
	return r;
}

// Assembly:
movl $0x10000, %eax          # imm = 0x10000
movl $0xfeaa, %ecx           # imm = 0xFEAA
testl %edi, %edi
je 0x14a84
movl %eax, %edx
imull %ecx, %edx
shrl $0x10, %edx
testb $0x1, %dil
cmovnel %edx, %eax
imull %ecx, %ecx
shrl $0x10, %ecx
shrl %edi
jmp 0x14a67
retq
// File: /workspace/github_c_makefile_star2_O2/tvlabs[P]edge264/./edge264_internal.h
// Function: print_dec
static inline int print_dec(Edge264Decoder *dec) {
		int pos = dec->log_pos;
		dec->log_pos = 0;
		if (pos >= sizeof(dec->log_buf))
			return ENOTSUP;
		dec->log_cb(dec->log_buf, dec->log_arg);
		return 0;
	}

// Assembly:
movzwl 0x7cb0(%rdi), %ecx
andw $0x0, 0x7cb0(%rdi)
cmpw $0x2541, %cx            # imm = 0x2541
jbe 0x1537b
pushq $0x5f
popq %rax
retq
pushq %rax
movq %rdi, %rax
addq $0x7cb2, %rdi           # imm = 0x7CB2
movq 0x7ca8(%rax), %rsi
callq *0x7ca0(%rax)
xorl %eax, %eax
addq $0x8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/tvlabs[P]edge264/./edge264_internal.h
// Function: print_mb
static inline int print_mb(Edge264Context *ctx) {
		int pos = ctx->log_pos;
		ctx->log_pos = 0;
		if (pos >= sizeof(ctx->log_buf))
			return ENOTSUP;
		ctx->log_cb(ctx->log_buf, ctx->log_arg);
		return 0;
	}

// Assembly:
movzwl 0x1cd0(%rdi), %eax
andw $0x0, 0x1cd0(%rdi)
cmpw $0xfff, %ax             # imm = 0xFFF
jbe 0x22963
retq
leaq 0x1cd2(%rdi), %rax
movq 0x1cc0(%rdi), %rcx
movq 0x1cc8(%rdi), %rsi
movq %rax, %rdi
jmpq *%rcx
// File: /workspace/github_c_makefile_star2_O2/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 $0x28, %rsp
leaq -0x1(%rdx), %rax
cmpq $-0x2, %rax
jae 0xb2aa
movq %rdx, %r14
movq %rsi, %r15
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x8(%rsp), %rsi
movl %r14d, (%rsi)
movq %rdi, 0x10(%rsp)
callq 0xb72e
leaq 0x38(%r15), %rax
movq %rax, 0x20(%rsp)
leaq 0x30(%r15), %r13
leaq 0x48(%r15), %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%r15), %r12
xorl %ebx, %ebx
leaq 0x8(%rsp), %rbp
movl 0x50(%r15), %ecx
cmpq %rcx, %rbx
jae 0xb296
movq (%r15), %rax
movq 0x8(%r15), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rcx, %rdx
jae 0xb269
movq 0x20(%rsp), %rdi
movq %r13, %rsi
callq 0xb61e
movq %rax, 0x8(%rsp)
movq %r15, %rdi
movq %rbp, %rsi
callq 0xb960
movq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0xb626
movl %eax, %eax
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %rbp, %rsi
callq 0xb960
movq (%r15), %rax
movq (%rax,%rbx,8), %rax
imulq %r14, %rax
movq (%r12), %rcx
addq (%rcx,%rbx,8), %rax
shrq $0x20, %rax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq %rbp, %rsi
callq 0xb62e
incq %rbx
jmp 0xb20e
movq 0x10(%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6344(%rip), %rdi      # 0x115f5
leaq 0x6355(%rip), %rsi      # 0x1160d
leaq 0x635a(%rip), %rcx      # 0x11619
pushq $0x22
popq %rdx
callq 0x6210
jmp 0xb2cd
jmp 0xb2cd
jmp 0xb2cd
movq %rax, %r14
movq 0x10(%rsp), %rdi
callq 0x781e
movq %r14, %rdi
callq 0x65a0
// File: /workspace/github_c_makefile_star2_O2/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 $0x58, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl 0x50(%rsi), %esi
leaq 0x20(%rsp), %r12
orl $-0x1, (%r12)
movq %rsp, %rdi
leaq 0x40(%rsp), %r13
movq %r12, %rdx
movq %r13, %rcx
callq 0xb652
movq 0x18(%r14), %rbp
addq $0x8, %r14
cmpq %r14, %rbp
je 0xb394
leaq 0x20(%rbp), %rsi
movq %r12, %rdi
callq 0x6430
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
movl 0x54(%r15), %edx
callq 0xc0bc
movq %r13, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0xb1ae
movq 0x40(%rsp), %rax
movq (%rsp), %rcx
xorl %edx, %edx
movl 0x50(%r15), %esi
cmpq %rsi, %rdx
jae 0xb377
movl (%rax,%rdx,4), %esi
cmpl (%rcx,%rdx,4), %esi
jae 0xb372
movl %esi, (%rcx,%rdx,4)
incq %rdx
jmp 0xb35e
movq %r13, %rdi
callq 0x781e
movq %r12, %rdi
callq 0x6658
movq %rbp, %rdi
callq 0x6370
movq %rax, %rbp
jmp 0xb321
movq %rsp, %rdi
movaps (%rdi), %xmm0
movups %xmm0, (%rbx)
movq 0x10(%rdi), %rax
movq %rax, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
callq 0x781e
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0xb3db
jmp 0xb3ce
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x6658
movq %rsp, %rdi
callq 0x781e
movq %rbx, %rdi
callq 0x65a0
nop
// File: /workspace/github_c_makefile_star2_O2/perdisci[P]LSH/./xxHash/xxhash.c
// Function: XXH32_reset
XXH_PUBLIC_API XXH_errorcode XXH32_reset(XXH32_state_t* statePtr, unsigned int seed)
{
    XXH32_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
    memset(&state, 0, sizeof(state)-4);   /* do not write into reserved, for future removal */
    state.v1 = seed + PRIME32_1 + PRIME32_2;
    state.v2 = seed + PRIME32_2;
    state.v3 = seed + 0;
    state.v4 = seed - PRIME32_1;
    memcpy(statePtr, &state, sizeof(state));
    return XXH_OK;
}

// Assembly:
leal 0x24234428(%rsi), %eax
andq $0x0, (%rdi)
leal -0x7a143589(%rsi), %ecx
movl %eax, 0x8(%rdi)
movl %ecx, 0xc(%rdi)
movl %esi, 0x10(%rdi)
addl $0x61c8864f, %esi       # imm = 0x61C8864F
movl %esi, 0x14(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
andl $0x0, 0x28(%rdi)
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/perdisci[P]LSH/./xxHash/xxhash.c
// Function: XXH32_digest
FORCE_INLINE U32 XXH32_digest_endian (const XXH32_state_t* state, XXH_endianess endian)
{
    const BYTE * p = (const BYTE*)state->mem32;
    const BYTE* const bEnd = (const BYTE*)(state->mem32) + state->memsize;
    U32 h32;

    if (state->large_len) {
        h32 = XXH_rotl32(state->v1, 1) + XXH_rotl32(state->v2, 7) + XXH_rotl32(state->v3, 12) + XXH_rotl32(state->v4, 18);
    } else {
        h32 = state->v3 /* == seed */ + PRIME32_5;
    }

    h32 += state->total_len_32;

    while (p+4<=bEnd) {
        h32 += XXH_readLE32(p, endian) * PRIME32_3;
        h32  = XXH_rotl32(h32, 17) * PRIME32_4;
        p+=4;
    }

    while (p<bEnd) {
        h32 += (*p) * PRIME32_5;
        h32  = XXH_rotl32(h32, 11) * PRIME32_1;
        p++;
    }

    h32 ^= h32 >> 15;
    h32 *= PRIME32_2;
    h32 ^= h32 >> 13;
    h32 *= PRIME32_3;
    h32 ^= h32 >> 16;

    return h32;
}

// Assembly:
movl 0x28(%rdi), %ecx
cmpl $0x0, 0x4(%rdi)
je 0xc040
movdqu 0x8(%rdi), %xmm0
movdqa 0x569a(%rip), %xmm1     # 0x11690
pshufd $0xf5, %xmm0, %xmm2     # xmm2 = xmm0[1,1,3,3]
pmuludq %xmm1, %xmm0
pshufd $0xed, %xmm0, %xmm3     # xmm3 = xmm0[1,3,2,3]
pshufd $0xf5, %xmm1, %xmm1     # xmm1 = xmm1[1,1,3,3]
pmuludq %xmm2, %xmm1
pshufd $0xed, %xmm1, %xmm2     # xmm2 = xmm1[1,3,2,3]
punpckldq %xmm2, %xmm3    # xmm3 = xmm3[0],xmm2[0],xmm3[1],xmm2[1]
pshufd $0xe8, %xmm0, %xmm0     # xmm0 = xmm0[0,2,2,3]
pshufd $0xe8, %xmm1, %xmm1     # xmm1 = xmm1[0,2,2,3]
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
por %xmm3, %xmm0
pshufd $0xee, %xmm0, %xmm1     # xmm1 = xmm0[2,3,2,3]
paddd %xmm0, %xmm1
pshufd $0x55, %xmm1, %xmm0     # xmm0 = xmm1[1,1,1,1]
paddd %xmm1, %xmm0
movd %xmm0, %eax
jmp 0xc048
movl $0x165667b1, %eax       # imm = 0x165667B1
addl 0x10(%rdi), %eax
leaq 0x18(%rdi), %rdx
addq %rdi, %rcx
addq $0x18, %rcx
addl (%rdi), %eax
leaq 0x4(%rdx), %rsi
cmpq %rcx, %rsi
ja 0xc08b
imull $0xc2b2ae3d, (%rdx), %edx # imm = 0xC2B2AE3D
addl %eax, %edx
roll $0x11, %edx
imull $0x27d4eb2f, %edx, %eax # imm = 0x27D4EB2F
movq %rsi, %rdx
jmp 0xc055
movzbl (%rdx), %esi
imull $0x165667b1, %esi, %esi # imm = 0x165667B1
addl %eax, %esi
roll $0xb, %esi
imull $0x9e3779b1, %esi, %eax # imm = 0x9E3779B1
incq %rdx
cmpq %rcx, %rdx
jb 0xc074
movl %eax, %ecx
shrl $0xf, %ecx
xorl %eax, %ecx
imull $0x85ebca77, %ecx, %eax # imm = 0x85EBCA77
movl %eax, %ecx
shrl $0xd, %ecx
xorl %eax, %ecx
imull $0xc2b2ae3d, %ecx, %ecx # imm = 0xC2B2AE3D
movl %ecx, %eax
shrl $0x10, %eax
xorl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/perdisci[P]LSH/./xxHash/xxhash.c
// Function: XXH64_reset
XXH_PUBLIC_API XXH_errorcode XXH64_reset(XXH64_state_t* statePtr, unsigned long long seed)
{
    XXH64_state_t state;   /* using a local state to memcpy() in order to avoid strict-aliasing warnings */
    memset(&state, 0, sizeof(state)-8);   /* do not write into reserved, for future removal */
    state.v1 = seed + PRIME64_1 + PRIME64_2;
    state.v2 = seed + PRIME64_2;
    state.v3 = seed + 0;
    state.v4 = seed - PRIME64_1;
    memcpy(statePtr, &state, sizeof(state));
    return XXH_OK;
}

// Assembly:
movabsq $0x60ea27eeadc0b5d6, %rax # imm = 0x60EA27EEADC0B5D6
addq %rsi, %rax
movabsq $-0x3d4d51c2d82b14b1, %rcx # imm = 0xC2B2AE3D27D4EB4F
addq %rsi, %rcx
movabsq $0x61c8864e7a143579, %rdx # imm = 0x61C8864E7A143579
andq $0x0, (%rdi)
addq %rsi, %rdx
movq %rax, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movq %rdx, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
andq $0x0, 0x48(%rdi)
xorl %eax, %eax
retq