LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Hypercube/../../algorithms/Search/Hypercube/headers/../../LSH/headers/hashing.h
// Function: lsh::HashFunction::HashFunction(int, double, unsigned int, unsigned int)
HashFunction(int dim, double w, uint32_t m, uint32_t M) : dim(dim), w(w), s(dim, 0), m(m), M(M), const_m_values(dim) {
				// we want to use a uniform real distributor, thus we must initialize it
				// we want to randomize the input each time
				std::random_device mch;
				std::default_random_engine generator(mch());
				std::uniform_real_distribution<double> distribution(0.0, w);
				// initialize the random vector in the space `dim` using the uniform distribution
				for (int i = 0; i < this->dim; i++) {
					s.at(i) = distribution(generator);
				}

				// initialize the const m vector
				for (int i = 0; i < this->dim; i++) {
					const_m_values[i] = our_math::modular_power(m, i, M);
				}
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x13a8, %rsp           # imm = 0x13A8
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
movl %esi, (%rdi)
movsd %xmm0, 0x18(%rsp)
movsd %xmm0, 0x8(%rdi)
addq $0x10, %rdi
movslq %esi, %r15
leaq 0x20(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x8(%rsp), %rcx
movq %rdi, 0x10(%rsp)
movq %r15, %rsi
callq 0x6458
movl %ebp, 0x28(%r14)
movl %ebx, 0x2c(%r14)
leaq 0x30(%r14), %r12
leaq 0x20(%rsp), %rdx
movq %r12, %rdi
movq %r15, %rsi
callq 0x6570
leaq 0x20(%rsp), %rdi
callq 0x6160
leaq 0x20(%rsp), %rdi
callq 0x22c0
movl %eax, %ecx
leaq (%rcx,%rcx,2), %rcx
shrq $0x20, %rcx
movl %eax, %edx
subl %ecx, %edx
shrl %edx
addl %ecx, %edx
shrl $0x1e, %edx
movl %edx, %ecx
shll $0x1f, %ecx
orl %edx, %ecx
leal (%rax,%rcx), %edx
cmpl $0x1, %edx
adcl %eax, %ecx
movq %rcx, 0x8(%rsp)
cmpl $0x0, (%r14)
jle 0x6042
xorl %r13d, %r13d
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x6615
movq 0x10(%r14), %rax
movq 0x18(%r14), %rdx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %r13, %rdx
jbe 0x60b1
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax,%r13,8)
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0x600b
cmpl $0x0, (%r14)
jle 0x6095
movq (%r12), %rdi
xorl %r8d, %r8d
movl $0x1, %ecx
testq %r8, %r8
je 0x6086
movl %ebp, %esi
movl %r8d, %r9d
movl %esi, %eax
cltd
idivl %ebx
movl %edx, %esi
testb $0x1, %r9b
je 0x6075
imull %esi, %ecx
movl %ecx, %eax
cltd
idivl %ebx
movl %edx, %ecx
movl %r9d, %eax
shrl %eax
imull %esi, %esi
cmpl $0x1, %r9d
movl %eax, %r9d
ja 0x605e
movl %ecx, (%rdi,%r8,4)
incq %r8
movslq (%r14), %rax
cmpq %rax, %r8
jl 0x604f
leaq 0x20(%rsp), %rdi
callq 0x2210
addq $0x13a8, %rsp           # imm = 0x13A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x22cd(%rip), %rdi      # 0x8385
movq %r13, %rsi
xorl %eax, %eax
callq 0x2320
jmp 0x6107
jmp 0x60d2
movq %rax, %rbx
jmp 0x60df
movq %rax, %rbx
jmp 0x60ed
jmp 0x60d2
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2210
movq (%r12), %rdi
testq %rdi, %rdi
je 0x60ed
callq 0x2220
movq 0x10(%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x60ff
callq 0x2220
movq %rbx, %rdi
callq 0x2400
movq %rax, %rdi
callq 0x35b7
nop
// File: /workspace/github_cpp_makefile_star2_O1/nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Hypercube/../../algorithms/Search/Hypercube/headers/hypercube.h
// Function: Hypercube<double>::hash_to_hypercube(std::vector<double, std::allocator<double>>)
int hash_to_hypercube(std::vector<T> vec) {
			// store the string produced
			std::string bucket_str;
			// hash k times
			int k = 0;
			for (std::list<lsh::HashFunction>::iterator it = hash_fns.begin(); 
				it != hash_fns.end(); it++) {
					// hash with the i-th hash fn
					int res = it->hash(vec);
					// find its pre-maped result of a coin flip
					bool bit = flipped_coins.at(k)[res];
					// append the 0/1 value to the string
					bucket_str += to_string(bit);
			}
			// convert the string into an integer
			return (int)std::bitset<32>(bucket_str).to_ulong();
		}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, 0x28(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x58(%rdi), %r13
movq 0x58(%rdi), %rbx
cmpq %r13, %rbx
je 0x6320
movq %rdi, %r14
leaq 0x18(%rsp), %rbp
leaq 0x50(%rsp), %r15
movq %r15, %rdi
movq 0x28(%rsp), %rsi
callq 0x3860
leaq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x73be
movl %eax, %r12d
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x62a2
callq 0x2220
movl %r12d, 0x4(%rsp)
movq 0x70(%r14), %rdi
movq 0x78(%r14), %rax
subq %rdi, %rax
je 0x635b
leaq 0x4(%rsp), %rsi
callq 0x7726
movzbl (%rax), %r12d
movq %rbp, 0x8(%rsp)
movl $0x1, %esi
leaq 0x8(%rsp), %rdi
movl $0x2d, %edx
callq 0x2270
movq 0x8(%rsp), %rdi
movl $0x1, %esi
movl %r12d, %edx
callq 0x77c6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
leaq 0x30(%rsp), %rdi
callq 0x20a0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6314
callq 0x2220
movq (%rbx), %rbx
cmpq %r13, %rbx
jne 0x6277
leaq 0x8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
xorl %edx, %edx
callq 0x756e
movq 0x8(%rsp), %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x634a
callq 0x2220
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
sarq $0x3, %rax
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rdx
leaq 0x2011(%rip), %rdi      # 0x8385
xorl %esi, %esi
xorl %eax, %eax
callq 0x2320
jmp 0x63a8
jmp 0x63a8
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
jne 0x63a1
jmp 0x63ab
jmp 0x63a8
jmp 0x63a8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x63ab
callq 0x2220
jmp 0x63ab
movq %rax, %rbx
movq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x63bf
callq 0x2220
movq %rbx, %rdi
callq 0x2400
nop
// File: /workspace/github_cpp_makefile_star2_O1/nikosgalanis[P]Vectors-Similarity-Search-and-Clustering/programs/Hypercube/../../algorithms/Search/Hypercube/headers/../../LSH/headers/hashing.h
// Function: unsigned int lsh::HashFunction::hash<double>(std::vector<double, std::allocator<double>>)
uint32_t hash(std::vector<T> x) {
				uint32_t h = 0;
				// vector a computed by the lsh method
				std::vector<int> a(dim, 0);
				// compute the values of the vector a
				for (int i = 0; i < dim; i++) {
					a[i] = floor((x.at(i) - s.at(i)) / (w * 1.0));
				}
				// compute the hash result of the vector x
				for (int i = 0; i < dim; i++) {
					// each time apply a modulo operation
					h += our_math::modulo(our_math::modulo(a.at(dim - i - 1), M) * const_m_values.at(i), M);
				}
				// return the position in the hash
				return h % M;
			}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movslq (%rdi), %rsi
leaq 0x34(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x75b2
movq %rbx, 0x8(%rsp)
movl (%rbx), %eax
testl %eax, %eax
jle 0x7478
movq (%r14), %r15
movq 0x8(%r14), %r14
subq %r15, %r14
sarq $0x3, %r14
movq 0x8(%rsp), %rax
movq 0x10(%rax), %r13
movq 0x18(%rax), %r12
subq %r13, %r12
sarq $0x3, %r12
movq 0x18(%rsp), %rbp
movsd 0xdd7(%rip), %xmm0      # 0x8200
divsd 0x8(%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
xorl %ebx, %ebx
cmpq %rbx, %r14
je 0x7527
cmpq %rbx, %r12
je 0x7524
movsd (%r15,%rbx,8), %xmm0
subsd (%r13,%rbx,8), %xmm0
mulsd 0x10(%rsp), %xmm0
callq 0x23a0
cvttsd2si %xmm0, %eax
movl %eax, (%rbp,%rbx,4)
incq %rbx
movq 0x8(%rsp), %rax
movslq (%rax), %rax
cmpq %rax, %rbx
jl 0x7436
testl %eax, %eax
jle 0x74f4
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rcx
subq %rdi, %rcx
sarq $0x2, %rcx
movq 0x8(%rsp), %rdx
movq 0x38(%rdx), %r8
movq 0x30(%rdx), %r9
subq %r9, %r8
sarq $0x2, %r8
movl 0x2c(%rdx), %r10d
movl %eax, %esi
decq %rsi
xorl %r11d, %r11d
xorl %r14d, %r14d
cmpq %rsi, %rcx
jbe 0x7541
cmpq %r11, %r8
je 0x753b
movl (%rdi,%rsi,4), %eax
cltd
idivl %r10d
movl %edx, %eax
sarl $0x1f, %eax
andl %r10d, %eax
addl %edx, %eax
imull (%r9,%r11,4), %eax
cltd
idivl %r10d
movl %edx, %ebp
addl %edx, %r14d
sarl $0x1f, %ebp
andl %r10d, %ebp
addl %r14d, %ebp
incq %r11
movl %ebp, %r14d
addq $-0x1, %rsi
jb 0x74b0
jmp 0x74f6
xorl %ebp, %ebp
movq 0x8(%rsp), %rax
movl 0x2c(%rax), %ebx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x750d
callq 0x2220
movl %ebp, %eax
xorl %edx, %edx
divl %ebx
movl %edx, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, %r14
leaq 0xe57(%rip), %rdi       # 0x8385
movq %r14, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2320
movq %r8, %rsi
movq %r8, %rcx
leaq 0xe3d(%rip), %rdi       # 0x8385
movq %rcx, %rdx
xorl %eax, %eax
callq 0x2320
jmp 0x7554
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x7566
callq 0x2220
movq %rbx, %rdi
callq 0x2400
// File: /workspace/github_cpp_makefile_star2_O1/iZhangHui[P]CppPrimer/CH12_DynamicMemory/examples/weak.cc
// Function: main
int main()
{
	auto p = make_shared<int>(42);

	weak_ptr<int> wp(p);  // wp weakly shares with p; use count in p is unchanged

	p.reset(); // assuming p.unique() was true, the int is deleted

	if (shared_ptr<int> np = wp.lock()) { // true if np is not null
		// inside the if, np shares its object with p
		cout << "np is not null." << endl;
	}

	cout << "np is null." << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x18, %edi
callq 0x1070
movq %rax, %rbx
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x8(%rbx)
leaq 0x2ad7(%rip), %rax      # 0x3d10
movq %rax, (%rbx)
movl $0x2a, 0x10(%rbx)
movq 0x2d86(%rip), %r12      # 0x3fd0
cmpb $0x0, (%r12)
je 0x125a
movl $0x2, 0xc(%rbx)
jmp 0x125e
lock
incl 0xc(%rbx)
movq %rbx, %rdi
callq 0x13a0
movl 0x8(%rbx), %eax
xorl %r14d, %r14d
testl %eax, %eax
je 0x127d
leal 0x1(%rax), %ecx
lock
cmpxchgl %ecx, 0x8(%rbx)
jne 0x126c
movq %rbx, %r14
testq %r14, %r14
je 0x12dd
movl 0x8(%r14), %eax
testl %eax, %eax
je 0x12d0
movq 0x2d47(%rip), %r15      # 0x3fd8
leaq 0xd6c(%rip), %rsi       # 0x2004
movl $0xf, %edx
movq %r15, %rdi
callq 0x1090
movq (%r15), %rax
addq -0x18(%rax), %r15
movq %r15, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq 0x2d15(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1040
testq %r14, %r14
je 0x12dd
movq %r14, %rdi
callq 0x13a0
movq 0x2cf4(%rip), %r14      # 0x3fd8
leaq 0xd29(%rip), %rsi       # 0x2014
movl $0xb, %edx
movq %r14, %rdi
callq 0x1090
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x1060
movsbl %al, %esi
movq 0x2cc2(%rip), %rdi      # 0x3fd8
callq 0x1030
movq %rax, %rdi
callq 0x1040
cmpb $0x0, (%r12)
je 0x1335
movl 0xc(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rbx)
jmp 0x133f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rbx)
cmpl $0x1, %eax
jne 0x134d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
testq %r14, %r14
je 0x136d
movq %r14, %rdi
callq 0x13a0
jmp 0x136d
movq %rax, %r15
cmpb $0x0, (%r12)
jne 0x1380
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
lock
xaddl %eax, 0xc(%rbx)
jmp 0x1389
movl 0xc(%rbx), %eax
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rbx)
cmpl $0x1, %eax
jne 0x1397
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
movq %r15, %rdi
callq 0x10c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/algorithm.cpp
// Function: nda::test_algorithm_copy_scalar_body()
TEST(algorithm_copy_scalar) {
  array_of_rank<int, 0> a;
  generate(a, rand);

  array_of_rank<int, 0> b;
  copy(a, b);
  ASSERT(a == b);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
leaq 0x28(%rsp), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xf09a
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
je 0xbb8a
callq 0x2330
movl %eax, (%rbx)
movq %rsp, %rdi
leaq 0x50(%rsp), %rsi
callq 0xf09a
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0xbba9
movq 0x18(%rsp), %rcx
testq %rcx, %rcx
je 0xbba9
movl (%rax), %ebx
movl %ebx, (%rcx)
movl (%rax), %ebp
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x955bc(%rip), %rsi     # 0xa10a3
leaq 0x955bb(%rip), %rdx     # 0xa10a9
leaq 0x50(%rsp), %rdi
callq 0xd0b8
xorl %esi, %esi
cmpl %ebx, %ebp
sete %sil
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0xbf0a
leaq 0x70(%rsp), %rdi
callq 0xbf62
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0xbb30
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x21f0
cmpq $0x0, 0x18(%rsp)
je 0xbb57
xorl %ebx, %ebx
movq %rbx, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
shlq $0x2, %rsi
callq 0x21f0
movq %rbx, 0x8(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0xbb7e
xorl %ebx, %ebx
movq %rbx, 0x40(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
shlq $0x2, %rsi
callq 0x21f0
movq %rbx, 0x30(%rsp)
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x9571a(%rip), %rdi     # 0xa12ab
leaq 0x95555(%rip), %rsi     # 0xa10ed
leaq 0x96e0d(%rip), %rcx     # 0xa29ac
movl $0x6a1, %edx            # imm = 0x6A1
callq 0x2100
leaq 0x956fb(%rip), %rdi     # 0xa12ab
leaq 0x95536(%rip), %rsi     # 0xa10ed
leaq 0x96e81(%rip), %rcx     # 0xa2a3f
movl $0x6b8, %edx            # imm = 0x6B8
callq 0x2100
movq %rax, %rbx
jmp 0xbbec
movq %rax, %rbx
jmp 0xbc14
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0xbbec
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x21f0
cmpq $0x0, 0x18(%rsp)
je 0xbc14
xorl %r14d, %r14d
movq %r14, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
shlq $0x2, %rsi
callq 0x21f0
movq %r14, 0x8(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0xbc3c
xorl %r14d, %r14d
movq %r14, 0x40(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
shlq $0x2, %rsi
callq 0x21f0
movq %r14, 0x30(%rsp)
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/algorithm.cpp
// Function: nda::test_algorithm_move_scalar_body()
TEST(algorithm_move_scalar) {
  array_of_rank<int, 0> a;
  move_only token;
  generate(a, [token = std::move(token)]() {
    unused(token);
    return rand();
  });

  array_of_rank<int, 0> b;
  copy(a, b);
  ASSERT(a == b);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
leaq 0x28(%rsp), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xf09a
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
je 0xbd55
callq 0x2330
movl %eax, (%rbx)
movq %rsp, %rdi
leaq 0x50(%rsp), %rsi
callq 0xf09a
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0xbd74
movq 0x18(%rsp), %rcx
testq %rcx, %rcx
je 0xbd74
movl (%rax), %ebx
movl %ebx, (%rcx)
movl (%rax), %ebp
leaq 0x60(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x953f1(%rip), %rsi     # 0xa10a3
leaq 0x953f0(%rip), %rdx     # 0xa10a9
leaq 0x50(%rsp), %rdi
callq 0xd0b8
xorl %esi, %esi
cmpl %ebx, %ebp
sete %sil
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0xbf0a
leaq 0x70(%rsp), %rdi
callq 0xbf62
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0xbcfb
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x21f0
cmpq $0x0, 0x18(%rsp)
je 0xbd22
xorl %ebx, %ebx
movq %rbx, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
shlq $0x2, %rsi
callq 0x21f0
movq %rbx, 0x8(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0xbd49
xorl %ebx, %ebx
movq %rbx, 0x40(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
shlq $0x2, %rsi
callq 0x21f0
movq %rbx, 0x30(%rsp)
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x9554f(%rip), %rdi     # 0xa12ab
leaq 0x9538a(%rip), %rsi     # 0xa10ed
leaq 0x96c42(%rip), %rcx     # 0xa29ac
movl $0x6a1, %edx            # imm = 0x6A1
callq 0x2100
leaq 0x95530(%rip), %rdi     # 0xa12ab
leaq 0x9536b(%rip), %rsi     # 0xa10ed
leaq 0x96cb6(%rip), %rcx     # 0xa2a3f
movl $0x6b8, %edx            # imm = 0x6B8
callq 0x2100
movq %rax, %rbx
jmp 0xbdb7
movq %rax, %rbx
jmp 0xbddf
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r14, %rdi
je 0xbdb7
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x21f0
cmpq $0x0, 0x18(%rsp)
je 0xbddf
xorl %r14d, %r14d
movq %r14, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
shlq $0x2, %rsi
callq 0x21f0
movq %r14, 0x8(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0xbe07
xorl %r14d, %r14d
movq %r14, 0x40(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
shlq $0x2, %rsi
callq 0x21f0
movq %r14, 0x30(%rsp)
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: auto nda::make_compact<nda::shape<nda::dim<0l, -9l, -9l>, nda::dim<0l, -9l, -9l>>>(nda::shape<nda::dim<0l, -9l, -9l>, nda::dim<0l, -9l, -9l>> const&)
NDARRAY_HOST_DEVICE auto make_compact(const Shape& s) {
  auto static_compact =
      make_shape_from_tuple(internal::make_compact_dims(s.dims(), typename Shape::dim_indices()));
  static_compact.resolve();
  return static_compact;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq 0x8(%rsi), %rax
movq 0x20(%rsi), %rcx
leaq 0x38(%rsp), %r14
movq %rax, 0x8(%r14)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%r14)
movq %rcx, 0x20(%r14)
movq %r14, %rdi
callq 0x7cddc
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movaps %xmm2, 0x20(%rsp)
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
xorl %eax, %eax
cmpq 0x10(%rsp), %rax
jno 0x7cd45
movq %rsp, %r14
movq 0x8(%r14), %rdi
movq %r14, %rsi
callq 0x7ce40
movq %rax, 0x10(%r14)
movq 0x10(%rsp), %rax
movq %rax, 0x10(%rbx)
movaps (%rsp), %xmm0
movups %xmm0, (%rbx)
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x18(%rbx)
movq 0x28(%rsp), %rax
movq %rax, 0x28(%rbx)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: nda::array<int, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, nda::auto_allocator<int, 32ul, 4ul, std::allocator<int>>>::allocate()
void allocate() {
    assert(!buffer_);
    shape_.resolve();
    size_type flat_extent = shape_.flat_extent();
    if (flat_extent > 0) {
      buffer_size_ = flat_extent;
      buffer_ = alloc_traits::allocate(alloc_, buffer_size_);
    }
    base_ = buffer_ - shape_.flat_min();
  }

// Assembly:
pushq %rbx
cmpq $0x0, 0x88(%rdi)
jne 0x4e3ec
movq %rdi, %rbx
addq $0xa0, %rdi
leaq 0xb8(%rbx), %rsi
movq %rdi, %rdx
callq 0xc4eb
movq 0xc0(%rbx), %rax
decq %rax
movq 0xc8(%rbx), %rcx
movq 0xa8(%rbx), %rdx
movq 0xb0(%rbx), %rsi
decq %rdx
movq %rsi, %rdi
negq %rdi
cmovsq %rsi, %rdi
imulq %rdx, %rdi
movq %rcx, %rdx
negq %rdx
cmovsq %rcx, %rdx
imulq %rax, %rdx
addq 0xd8(%rbx), %rdx
leaq (%rdi,%rdx), %rax
decq %rax
testq %rax, %rax
movq $-0x1, %rsi
cmovnsq %rax, %rsi
incq %rsi
je 0x4e392
movq %rsi, 0x90(%rbx)
cmpq $0x20, %rsi
ja 0x4e37d
cmpb $0x0, 0x80(%rbx)
jne 0x4e37d
movb $0x1, 0x80(%rbx)
movq %rbx, %rax
jmp 0x4e38b
leaq 0x81(%rbx), %rdi
xorl %edx, %edx
callq 0xc640
movq %rax, 0x88(%rbx)
movl $0x1, %eax
movl $0x1, %ecx
subq 0xc0(%rbx), %rcx
movq 0xb0(%rbx), %rdx
movq 0xc8(%rbx), %rsi
movq %rsi, %rdi
sarq $0x3f, %rdi
andq %rsi, %rdi
imulq %rcx, %rdi
subq 0xa8(%rbx), %rax
movq %rdx, %rcx
sarq $0x3f, %rcx
andq %rdx, %rcx
imulq %rax, %rcx
shlq $0x2, %rcx
addq 0x88(%rbx), %rcx
leaq (%rcx,%rdi,4), %rax
movq %rax, 0x98(%rbx)
popq %rbx
retq
leaq 0x52cf1(%rip), %rdi     # 0xa10e4
leaq 0x52cf3(%rip), %rsi     # 0xa10ed
leaq 0x5ee85(%rip), %rcx     # 0xad286
movl $0x8eb, %edx            # imm = 0x8EB
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: void nda::internal::resolve_unknown_strides<std::tuple<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>(std::tuple<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>&, nda::dim<-9l, -9l, -9l>&, nda::dim<-9l, -9l, -9l>&)
NDARRAY_HOST_DEVICE void resolve_unknown_strides(AllDims& all_dims, Dim0& dim0, Dims&... dims) {
  if (is_unresolved(dim0.stride())) {
    constexpr size_t rank = std::tuple_size<AllDims>::value;
    dim0.set_stride(find_stride(dim0.extent(), all_dims, make_index_sequence<rank>()));
  }
  resolve_unknown_strides(all_dims, dims...);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movabsq $-0x8000000000000000, %r12 # imm = 0x8000000000000000
xorl %eax, %eax
cmpq 0x10(%rsi), %rax
jno 0xc51e
movq %rsi, %r15
movq 0x8(%rsi), %rdi
movq %r14, %rsi
callq 0xc3d7
movq %rax, 0x10(%r15)
cmpq %r12, 0x10(%rbx)
jne 0xc534
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0xc3d7
movq %rax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: long nda::internal::filter_stride<nda::dim<0l, 4l, -9l>, nda::dim<0l, 5l, -9l>, nda::dim<0l, 6l, -9l>>(long, long, nda::dim<0l, 4l, -9l> const&, nda::dim<0l, 5l, -9l> const&, nda::dim<0l, 6l, -9l> const&)
NDARRAY_HOST_DEVICE index_t filter_stride(index_t stride, index_t extent, const Dims&... dims) {
  if (all(is_stride_ok(stride, extent, dims)...)) {
    return stride;
  } else {
    return std::numeric_limits<index_t>::max();
  }
}

// Assembly:
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq 0x8(%rdx), %r9
movq %r9, %rdx
negq %rdx
jo 0x40170
cmpq $0x1, %rsi
jne 0x40148
movq %rdi, %r10
negq %r10
cmovsq %rdi, %r10
movq %r9, %r11
negq %r11
cmovsq %r9, %r11
movl $0x1, %edx
cmpq %r11, %r10
je 0x40172
movq %r9, %r10
negq %r10
cmovsq %r9, %r10
leaq (,%r10,4), %rdx
cmpq %rdi, %rdx
jle 0x40170
movq %rsi, %r9
imulq %rdi, %r9
xorl %edx, %edx
cmpq %r9, %r10
setl %dl
jmp 0x40172
xorl %edx, %edx
movq 0x8(%rcx), %r9
cmpq %rax, %r9
je 0x401c3
cmpq $0x1, %rsi
jne 0x4019f
movq %rdi, %r10
negq %r10
cmovsq %rdi, %r10
movq %r9, %r11
negq %r11
cmovsq %r9, %r11
movl $0x1, %ecx
cmpq %r11, %r10
je 0x401c5
movq %r9, %r10
negq %r10
cmovsq %r9, %r10
leaq (%r10,%r10,4), %rcx
cmpq %rdi, %rcx
jle 0x401c3
movq %rsi, %r9
imulq %rdi, %r9
xorl %ecx, %ecx
cmpq %r9, %r10
setl %cl
jmp 0x401c5
xorl %ecx, %ecx
movq 0x8(%r8), %r9
cmpq %rax, %r9
je 0x4021a
cmpq $0x1, %rsi
jne 0x401f3
movq %rdi, %r10
negq %r10
cmovsq %rdi, %r10
movq %r9, %r11
negq %r11
cmovsq %r9, %r11
movl $0x1, %r8d
cmpq %r11, %r10
je 0x4021d
movq %r9, %r10
negq %r10
cmovsq %r9, %r10
leaq (%r10,%r10), %r8
leaq (%r8,%r8,2), %r8
cmpq %rdi, %r8
jle 0x4021a
imulq %rdi, %rsi
xorl %r8d, %r8d
cmpq %rsi, %r10
setl %r8b
jmp 0x4021d
xorl %r8d, %r8d
addq %rdx, %rcx
decq %rax
orq %r8, %rcx
cmoveq %rdi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: nda::array<int, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, std::allocator<int>>::deallocate()
void deallocate() {
    if (base_) {
      destroy();
      base_ = nullptr;
      shape_ = Shape();
      alloc_traits::deallocate(alloc_, buffer_, buffer_size_);
      buffer_ = nullptr;
    }
  }

// Assembly:
cmpq $0x0, 0x18(%rdi)
je 0xd1c3
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xd1c4
xorl %r14d, %r14d
movq %r14, 0x18(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%rbx)
movups %xmm0, 0x38(%rbx)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x48(%rbx)
movups %xmm0, 0x20(%rbx)
movq %rax, 0x30(%rbx)
movq 0x8(%rbx), %rdi
movq 0x10(%rbx), %rsi
shlq $0x2, %rsi
callq 0x21f0
movq %r14, 0x8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: nda::array<int, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, std::allocator<int>>::assign(nda::array<int, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, std::allocator<int>> const&)
void assign(const array& other) {
    if (base_ == other.base_) {
      if (base_) {
        assert(shape_ == other.shape_);
      } else {
        shape_ = other.shape_;
        assert(shape_.empty());
      }
      return;
    }
    if (base_ && shape_ == other.shape_) {
      destroy();
    } else {
      deallocate();
      shape_ = other.shape_;
      allocate();
    }
    copy_construct(other);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rax
cmpq 0x18(%rsi), %rax
je 0xd484
testq %rax, %rax
je 0xd430
movq 0x50(%rbx), %rax
cmpq 0x50(%r14), %rax
jne 0xd430
movq 0x58(%r14), %rax
cmpq %rax, 0x58(%rbx)
jne 0xd430
leaq 0x20(%r14), %rsi
leaq 0x20(%rbx), %rdi
callq 0xd5f6
testb %al, %al
je 0xd430
movq %rbx, %rdi
callq 0xd1c4
jmp 0xd472
movq %rbx, %rdi
callq 0xd16c
movb 0x60(%r14), %al
movb %al, 0x60(%rbx)
movups 0x50(%r14), %xmm0
movups %xmm0, 0x50(%rbx)
movups 0x38(%r14), %xmm0
movups %xmm0, 0x38(%rbx)
movq 0x48(%r14), %rax
movq %rax, 0x48(%rbx)
movups 0x20(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
movq %rbx, %rdi
callq 0xc2a2
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd540
testq %rax, %rax
je 0xd4d3
movq 0x50(%rbx), %rax
cmpq 0x50(%r14), %rax
jne 0xd4b4
movq 0x58(%r14), %rax
cmpq %rax, 0x58(%rbx)
jne 0xd4b4
addq $0x20, %r14
addq $0x20, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd5f6
testb %al, %al
jne 0xd518
leaq 0x94466(%rip), %rdi     # 0xa1921
leaq 0x93c2b(%rip), %rsi     # 0xa10ed
leaq 0x9446f(%rip), %rcx     # 0xa1938
movl $0x9b9, %edx            # imm = 0x9B9
callq 0x2100
movb 0x60(%r14), %al
movb %al, 0x60(%rbx)
movups 0x50(%r14), %xmm0
movups %xmm0, 0x50(%rbx)
movq 0x48(%r14), %rax
movq %rax, 0x48(%rbx)
movups 0x38(%r14), %xmm0
movups %xmm0, 0x38(%rbx)
movups 0x20(%r14), %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rbx)
movq 0x40(%rbx), %rax
imulq 0x58(%rbx), %rax
imulq 0x28(%rbx), %rax
testq %rax, %rax
jg 0xd520
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x93ca7(%rip), %rdi     # 0xa11ce
leaq 0x93bbf(%rip), %rsi     # 0xa10ed
leaq 0x94403(%rip), %rcx     # 0xa1938
movl $0x9bc, %edx            # imm = 0x9BC
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: nda::array<int, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, std::allocator<int>>::copy_construct(nda::array<int, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, std::allocator<int>> const&)
void copy_construct(const array& other) {
    assert(base_ || shape_.empty());
    assert(shape_ == other.shape_);
    copy_shape_traits_type::for_each_value(other.shape_, other.base_, shape_, base_,
        [&](const_reference src, reference dst) { alloc_traits::construct(alloc_, &dst, src); });
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x18(%rdi)
jne 0xd568
movq 0x40(%rbx), %rax
imulq 0x58(%rbx), %rax
imulq 0x28(%rbx), %rax
testq %rax, %rax
jg 0xd5d7
movq 0x50(%rbx), %rax
cmpq 0x50(%r14), %rax
jne 0xd5b8
movq 0x58(%r14), %rax
cmpq %rax, 0x58(%rbx)
jne 0xd5b8
leaq 0x20(%rbx), %r15
leaq 0x20(%r14), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xd5f6
testb %al, %al
je 0xd5b8
movq 0x18(%r14), %rsi
movq 0x18(%rbx), %rcx
movq %rsp, %r8
movq %rbx, (%r8)
movq %r12, %rdi
movq %r15, %rdx
callq 0xd608
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x94362(%rip), %rdi     # 0xa1921
leaq 0x93b27(%rip), %rsi     # 0xa10ed
leaq 0x94449(%rip), %rcx     # 0xa1a16
movl $0x900, %edx            # imm = 0x900
callq 0x2100
leaq 0x93be7(%rip), %rdi     # 0xa11c5
leaq 0x93b08(%rip), %rsi     # 0xa10ed
leaq 0x9442a(%rip), %rcx     # 0xa1a16
movl $0x8ff, %edx            # imm = 0x8FF
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: void nda::copy<int const, int, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 1l, 1l>>, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, void>(nda::array_ref<int const, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 1l, 1l>>> const&, nda::array_ref<int, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>> const&)
void copy(const array_ref<TSrc, ShapeSrc>& src, const array_ref<TDst, ShapeDst>& dst) {
  if (dst.shape().empty()) { return; }

  assert(src.shape().is_in_range(dst.shape().min()) && src.shape().is_in_range(dst.shape().max()));

  copy_shape_traits<ShapeSrc, ShapeDst>::for_each_value(
      src.shape(), src.base(), dst.shape(), dst.base(), internal::copy_assign<TSrc, TDst>);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %rdx
movq %rdi, %rsi
movq 0x40(%rdx), %rdi
movq 0x10(%rdx), %rax
movq 0x28(%rdx), %r8
movq %r8, %rcx
imulq %rdi, %rcx
imulq %rax, %rcx
testq %rcx, %rcx
jle 0x71f3a
movq 0x38(%rdx), %r11
movq 0x8(%rdx), %rcx
movq 0x20(%rdx), %rbx
movq 0x10(%rsi), %r9
movq 0x28(%rsi), %r10
cmpq %r11, %r10
setg %bpl
movq 0x30(%rsi), %r14
addq %r10, %r14
cmpq %r11, %r14
setle %r12b
orb %bpl, %r12b
cmpq %rbx, %r9
setg %bpl
movq 0x18(%rsi), %r15
addq %r9, %r15
cmpq %rbx, %r15
setle %r13b
orb %bpl, %r13b
xorl %ebp, %ebp
testq %rcx, %rcx
setne %bpl
movzbl %r12b, %r12d
movzbl %r13b, %r13d
addq %r12, %r13
orq %r13, %rbp
jne 0x71f4c
addq %r11, %rdi
decq %rdi
addq %rbx, %r8
decq %r8
decq %rcx
cmpq %rdi, %r10
setg %r10b
cmpq %rdi, %r14
setle %dil
orb %r10b, %dil
cmpq %r8, %r9
setg %r9b
cmpq %r8, %r15
setle %r8b
orb %r9b, %r8b
xorl %r9d, %r9d
addq %rax, %rcx
setne %r9b
movzbl %dil, %eax
movzbl %r8b, %ecx
addq %rax, %rcx
orq %rcx, %r9
jne 0x71f4c
movq (%rsi), %rbx
addq $0x8, %rsi
movq (%rdx), %r14
addq $0x8, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x71f6b
leaq 0x50(%rsp), %rcx
leaq -0x65240(%rip), %r9     # 0xcce9
movq %rcx, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %r8
callq 0x5b43e
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f41b(%rip), %rdi     # 0xa136e
leaq 0x2f193(%rip), %rsi     # 0xa10ed
leaq 0x449b1(%rip), %rcx     # 0xb6912
movl $0xad0, %edx            # imm = 0xAD0
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: void nda::move<int, int, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, void>(nda::array_ref<int, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>> const&, nda::array_ref<int, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>> const&)
void move(const array_ref<TSrc, ShapeSrc>& src, const array_ref<TDst, ShapeDst>& dst) {
  if (dst.shape().empty()) { return; }

  assert(src.shape().is_in_range(dst.shape().min()) && src.shape().is_in_range(dst.shape().max()));

  copy_shape_traits<ShapeSrc, ShapeDst>::for_each_value(
      src.shape(), src.base(), dst.shape(), dst.base(), internal::move_assign<TSrc, TDst>);
}

// Assembly:
pushq %rbx
movq %rsi, %rdx
movq 0x10(%rsi), %rax
movq 0x28(%rsi), %rcx
movq %rax, %rsi
imulq %rcx, %rsi
testq %rsi, %rsi
jle 0xeec4
movq 0x20(%rdx), %rsi
movq 0x20(%rdi), %r8
cmpq %rsi, %r8
jg 0xeec6
movq 0x28(%rdi), %r9
addq %r8, %r9
cmpq %rsi, %r9
jle 0xeec6
movq 0x8(%rdx), %r10
movq 0x8(%rdi), %r11
cmpq %r10, %r11
jg 0xeec6
movq 0x10(%rdi), %rbx
addq %r11, %rbx
cmpq %r10, %rbx
jle 0xeec6
addq %rsi, %rcx
decq %rcx
cmpq %rcx, %r8
jg 0xeec6
cmpq %rcx, %r9
jle 0xeec6
addq %r10, %rax
decq %rax
cmpq %rax, %r11
jg 0xeec6
cmpq %rax, %rbx
jle 0xeec6
movq (%rdi), %rsi
addq $0x8, %rdi
movq (%rdx), %rcx
addq $0x8, %rdx
leaq 0x1d7(%rip), %r8        # 0xf095
popq %rbx
jmp 0xeee6
popq %rbx
retq
leaq 0x924a1(%rip), %rdi     # 0xa136e
leaq 0x92219(%rip), %rsi     # 0xa10ed
leaq 0x93808(%rip), %rcx     # 0xa26e3
movl $0xb17, %edx            # imm = 0xB17
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/array.cpp
// Function: nda::test_array_for_each_value_scalar_body()
TEST(array_for_each_value_scalar) {
  array_of_rank<int, 0> scalar;
  move_only token;
  scalar.for_each_value([token = std::move(token)](int& v) {
    v = 3;
    assert_used(token);
  });
  ASSERT_EQ(scalar(), 3);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rsp, %rbx
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0xf09a
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x16756
movl $0x3, (%rax)
leaq 0x48(%rsp), %rdi
callq 0x1f92a
movq 0x18(%rsp), %rax
movl (%rax), %ebx
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x8ca79(%rip), %rsi     # 0xa30ac
leaq 0x8ca7f(%rip), %rdx     # 0xa30b9
leaq 0x28(%rsp), %rdi
callq 0xd0b8
xorl %esi, %esi
cmpl $0x3, %ebx
sete %sil
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0xbf0a
leaq 0x8aff1(%rip), %rsi     # 0xa1654
leaq 0x48(%rsp), %rdi
callq 0x18a16
leaq 0x8ca46(%rip), %rsi     # 0xa30ba
movq %rax, %rdi
callq 0x19c24
leaq 0x8eca7(%rip), %rsi     # 0xa532a
movq %rax, %rdi
callq 0x18a16
movq %rax, %rbx
cmpb $0x1, 0x188(%rax)
jne 0x166aa
movq 0x18(%rsp), %rax
movq %rbx, %rdi
addq $0x10, %rdi
movl (%rax), %esi
callq 0x22f0
leaq 0x8afa3(%rip), %rsi     # 0xa1654
movq %rbx, %rdi
callq 0x18a16
leaq 0x95489(%rip), %rsi     # 0xabb49
movq %rax, %rdi
callq 0x18a16
leaq 0x8ec5b(%rip), %rsi     # 0xa532a
movq %rax, %rdi
callq 0x18a16
movq %rax, %rbx
cmpb $0x1, 0x188(%rax)
jne 0x166f4
movq %rbx, %rdi
addq $0x10, %rdi
movl $0x3, %esi
callq 0x22f0
leaq 0xa1c6e(%rip), %rsi     # 0xb8369
movq %rbx, %rdi
callq 0x18a16
leaq 0x48(%rsp), %rdi
callq 0xbf62
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x16724
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21f0
cmpq $0x0, 0x18(%rsp)
je 0x1674b
xorl %ebx, %ebx
movq %rbx, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
shlq $0x2, %rsi
callq 0x21f0
movq %rbx, 0x8(%rsp)
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
retq
leaq 0x8ab4e(%rip), %rdi     # 0xa12ab
leaq 0x8a989(%rip), %rsi     # 0xa10ed
leaq 0x8eeb7(%rip), %rcx     # 0xa5622
movl $0x6a1, %edx            # imm = 0x6A1
callq 0x2100
movq %rax, %rbx
jmp 0x167a5
jmp 0x16781
movq %rax, %rbx
jmp 0x1678e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbf62
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x167a5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21f0
cmpq $0x0, 0x18(%rsp)
je 0x167cd
xorl %r14d, %r14d
movq %r14, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
shlq $0x2, %rsi
callq 0x21f0
movq %r14, 0x8(%rsp)
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc036
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/array.cpp
// Function: nda::test_array_move_reinterpret_shape_body()
TEST(array_move_reinterpret_shape) {
  array_of_rank<int, 3> a({9, {0, 5, 10}, 1});
  fill_pattern(a);

  auto b = move_reinterpret_shape<shape_of_rank<2>>(std::move(a));
  check_pattern(b);

  a = move_reinterpret_shape<shape_of_rank<3>>(std::move(b));
  check_pattern(a);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
leaq 0x138(%rsp), %rbx
xorps %xmm0, %xmm0
movups %xmm0, -0x8(%rbx)
movups %xmm0, -0x18(%rbx)
movq $0x1, 0x8(%rbx)
movq %r15, 0x10(%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
movq $0x5, 0x20(%rbx)
movq $0xa, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq $0x9, 0x38(%rbx)
movq %r15, 0x40(%rbx)
leaq 0x118(%rsp), %r14
movq %r14, %rdi
callq 0x1a362
movq %r14, %rdi
callq 0x1a43a
movq 0x18(%r14), %rcx
leaq 0x70(%rsp), %rax
movq %rcx, -0x8(%rax)
movl $0x9, %ecx
movq %rax, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0xd0(%rsp), %rcx
movl $0x0, (%rcx)
leaq 0x18(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x68(%rsp), %r14
movq %r14, 0x8(%rsi)
movq %rax, %rdi
callq 0x1d4b4
leaq 0x18(%rsp), %rdi
leaq 0x118(%rsp), %rsi
xorl %edx, %edx
callq 0x1a13b
xorps %xmm0, %xmm0
movq %rsp, %rax
movaps %xmm0, (%rax)
movq 0x30(%rsp), %rcx
leaq 0x70(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movups 0x38(%rsp), %xmm0
movups %xmm0, (%rdi)
movups 0x48(%rsp), %xmm0
movups %xmm0, 0x10(%rdi)
movups 0x58(%rsp), %xmm0
movups %xmm0, 0x20(%rdi)
leaq 0xd0(%rsp), %rsi
movq %r14, (%rsi)
movq %rax, 0x8(%rsi)
callq 0x1f63c
leaq 0x38(%rsp), %rax
movq 0x28(%rax), %rcx
leaq 0xd0(%rsp), %r14
movq %rcx, 0x40(%r14)
movups 0x18(%rax), %xmm0
movups %xmm0, 0x30(%r14)
movups (%rax), %xmm0
movups %xmm0, 0x18(%r14)
movq 0x10(%rax), %rax
movq %rax, 0x28(%r14)
movq $0x0, (%r14)
movq $0x1, 0x8(%r14)
movq %r15, 0x10(%r14)
leaq 0x68(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x209c3
leaq 0x118(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x18ee0
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x1d3b4
xorps %xmm0, %xmm0
movaps %xmm0, 0xd0(%rsp)
movq $0x0, 0xe0(%rsp)
movq 0x130(%rsp), %rcx
leaq 0x70(%rsp), %rax
movq %rcx, -0x8(%rax)
movl $0x9, %ecx
movq %rax, %rdi
movq %rbx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rsp, %rsi
movq %r15, (%rsi)
movq %r14, 0x8(%rsi)
movq %rax, %rdi
callq 0x1eda4
leaq 0x18(%rsp), %rdi
callq 0xe542
leaq 0x118(%rsp), %rdi
callq 0x1d3b4
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
jmp 0x183d8
jmp 0x183d8
jmp 0x183ad
jmp 0x183d8
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x1d3b4
jmp 0x183b0
jmp 0x183d8
jmp 0x183ad
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xe542
jmp 0x183c1
jmp 0x183be
movq %rax, %rbx
leaq 0x118(%rsp), %rdi
callq 0x1d3b4
movq %rbx, %rdi
callq 0x2300
jmp 0x183d8
movq %rax, %rdi
callq 0xc036
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: nda::array<int, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, std::allocator<int>>::clear()
void clear() {
    deallocate();
    shape_ = Shape();
    allocate();
    construct();
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0xe542
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rbx)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x48(%rbx)
movups %xmm0, 0x20(%rbx)
movq %rax, 0x30(%rbx)
movq %rbx, %rdi
callq 0xdf80
movq %rbx, %rdi
popq %rbx
jmp 0xe05e
nop
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: nda::array<int, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, nda::auto_allocator<int, 32ul, 4ul, std::allocator<int>>>::operator=(nda::array<int, nda::shape<nda::dim<-9l, -9l, 1l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, nda::auto_allocator<int, 32ul, 4ul, std::allocator<int>>> const&)
array& operator=(const array& other) {
    if (base_ == other.base_) {
      if (base_) {
        assert(shape_ == other.shape_);
      } else {
        shape_ = other.shape_;
        assert(shape_.empty());
      }
      return *this;
    }

    if (alloc_traits::propagate_on_container_copy_assignment::value) {
      if (alloc_ != other.get_allocator()) { deallocate(); }
      alloc_ = other.get_allocator();
    }

    assign(other);
    return *this;
  }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x98(%rdi), %rax
cmpq 0x98(%rsi), %rax
je 0x4dcf1
movq %rbx, %rdi
callq 0x4e72e
jmp 0x4ddbb
testq %rax, %rax
je 0x4dd4d
movq 0xd0(%rbx), %rax
cmpq 0xd0(%rsi), %rax
jne 0x4dd2e
movq 0xd8(%rsi), %rax
cmpq %rax, 0xd8(%rbx)
jne 0x4dd2e
movl $0xa0, %edi
addq %rdi, %rsi
addq %rbx, %rdi
callq 0xd5f6
testb %al, %al
jne 0x4ddbb
leaq 0x53bec(%rip), %rdi     # 0xa1921
leaq 0x533b1(%rip), %rsi     # 0xa10ed
leaq 0x5fac3(%rip), %rcx     # 0xad806
movl $0x987, %edx            # imm = 0x987
callq 0x2100
movb 0xe0(%rsi), %al
movb %al, 0xe0(%rbx)
movups 0xd0(%rsi), %xmm0
movups %xmm0, 0xd0(%rbx)
movq 0xc8(%rsi), %rax
movq %rax, 0xc8(%rbx)
movups 0xb8(%rsi), %xmm0
movups %xmm0, 0xb8(%rbx)
movups 0xa0(%rsi), %xmm0
movups %xmm0, 0xa0(%rbx)
movq 0xb0(%rsi), %rax
movq %rax, 0xb0(%rbx)
movq 0xc0(%rbx), %rax
imulq 0xd8(%rbx), %rax
imulq 0xa8(%rbx), %rax
testq %rax, %rax
jg 0x4ddc0
movq %rbx, %rax
popq %rbx
retq
leaq 0x53407(%rip), %rdi     # 0xa11ce
leaq 0x5331f(%rip), %rsi     # 0xa10ed
leaq 0x5fa31(%rip), %rcx     # 0xad806
movl $0x98a, %edx            # imm = 0x98A
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: nda::array<int, nda::shape<nda::dim<-9l, -9l, -9l>>, std::allocator<int>>::assign(nda::shape<nda::dim<-9l, -9l, -9l>>, int const&)
void assign(Shape shape, const T& value) {
    shape.resolve();
    if (shape_ == shape) {
      destroy();
    } else {
      deallocate();
      shape_ = shape;
      allocate();
    }
    construct(value);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
xorl %eax, %eax
cmpq 0x10(%rsi), %rax
jno 0x4b41d
movq 0x8(%r15), %rdi
movq %r15, %rsi
callq 0x1fa1b
movq %rax, 0x10(%r15)
movq 0x20(%r14), %rax
cmpq (%r15), %rax
jne 0x4b444
movq 0x28(%r14), %rax
cmpq 0x8(%r15), %rax
jne 0x4b444
movq 0x30(%r14), %rax
cmpq 0x10(%r15), %rax
jne 0x4b444
movq %r14, %rdi
callq 0x1fb9c
jmp 0x4b46a
leaq 0x20(%r14), %r12
movq %r14, %rdi
callq 0x1fb50
movq 0x10(%r15), %rax
movq %rax, 0x10(%r12)
movups (%r15), %xmm0
movups %xmm0, (%r12)
movq %r14, %rdi
callq 0x1f92c
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x4b480
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: nda::array<int, nda::shape<nda::dim<-9l, -9l, -9l>>, std::allocator<int>>::reshape(nda::shape<nda::dim<-9l, -9l, -9l>>)
void reshape(Shape new_shape) {
    new_shape.resolve();
    if (shape_ == new_shape) { return; }

    // Allocate an array with the new shape.
    array new_array(new_shape);

    // Move the common elements to the new array.
    Shape intersection =
        internal::clamp(new_shape.dims(), shape_.dims(), typename Shape::dim_indices());
    pointer intersection_base =
        internal::pointer_add(new_array.base_, new_shape[intersection.min()]);
    copy_shape_traits_type::for_each_value(
        shape_, base_, intersection, intersection_base, internal::move_assign<T, T>);

    *this = std::move(new_array);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movabsq $0x7fffffffffffffff, %r12 # imm = 0x7FFFFFFFFFFFFFFF
leaq 0x1(%r12), %rax
cmpq %rax, 0x10(%rsi)
jne 0x19cca
movq 0x8(%r14), %rdi
movq %r14, %rsi
callq 0x1fa1b
movq %rax, 0x10(%r14)
movq 0x20(%rbx), %rax
cmpq (%r14), %rax
jne 0x19ceb
movq 0x28(%rbx), %rax
cmpq 0x8(%r14), %rax
jne 0x19ceb
movq 0x30(%rbx), %rax
cmpq 0x10(%r14), %rax
je 0x19e19
xorps %xmm0, %xmm0
movq %rsp, %r15
movups %xmm0, 0x8(%r15)
movq $0x0, 0x18(%r15)
movups (%r14), %xmm0
movups %xmm0, 0x20(%r15)
movq 0x10(%r14), %rax
movq %rax, 0x30(%r15)
movq %r15, %rdi
callq 0x1f92c
movq %r15, %rdi
callq 0x1f9da
movq 0x20(%rbx), %rdi
movq (%r14), %rcx
movq 0x8(%r14), %rax
cmpq %rdi, %rcx
movq %rdi, %rsi
cmovgq %rcx, %rsi
addq %rcx, %rax
decq %rax
movq 0x28(%rbx), %rdx
addq %rdi, %rdx
decq %rdx
cmpq %rax, %rdx
cmovlq %rdx, %rax
movq 0x18(%rbx), %r9
subq %rsi, %rax
movq 0x10(%r14), %rdx
movq 0x18(%r15), %r8
movq %rsi, %r10
subq %rcx, %r10
imulq %rdx, %r10
testq %r8, %r8
leaq (%r8,%r10,4), %rcx
cmoveq %r8, %rcx
testq %r9, %r9
je 0x19dc0
testq %rcx, %rcx
je 0x19dc0
movq 0x30(%rbx), %r8
subq %rdi, %rsi
imulq %r8, %rsi
leaq (%r9,%rsi,4), %rdi
movq %r8, %r10
xorq $0x1, %r10
movq %rdx, %r11
xorq $0x1, %r11
orq %r10, %r11
jne 0x19de7
cmpq %r12, %rax
jae 0x19e06
leaq (%rdi,%rax,4), %rax
leaq (%r9,%rsi,4), %rdx
addq $-0x4, %rdx
movl 0x4(%rdx), %esi
addq $0x4, %rdx
movl %esi, (%rcx)
addq $0x4, %rcx
cmpq %rax, %rdx
jb 0x19dac
jmp 0x19e06
decq %r12
cmpq %r12, %rax
ja 0x19e06
leaq 0x874dc(%rip), %rdi     # 0xa12ab
leaq 0x87317(%rip), %rsi     # 0xa10ed
leaq 0x8bce4(%rip), %rcx     # 0xa5ac1
movl $0x6b8, %edx            # imm = 0x6B8
callq 0x2100
cmpq %r12, %rax
jae 0x19e06
shlq $0x2, %rdx
shlq $0x2, %r8
incq %rax
movl (%rdi), %esi
movl %esi, (%rcx)
addq %rdx, %rcx
addq %r8, %rdi
decq %rax
jne 0x19df7
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1fbfa
movq %rsp, %rdi
callq 0x1fb50
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x19e3a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1fb50
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc036
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: nda::array_ref<int const, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>>::operator!=(nda::array_ref<int const, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>> const&) const
NDARRAY_HOST_DEVICE bool operator!=(const array_ref& other) const {
    if (shape_ != other.shape_) { return true; }

    // TODO: This currently calls operator!= on all elements of the array_ref,
    // even after we find a non-equal element
    // (https://github.com/dsharlet/array/issues/4).
    bool result = false;
    copy_shape_traits<Shape, Shape>::for_each_value(
        shape_, base_, other.shape_, other.base_, [&](const_reference a, const_reference b) {
          if (a != b) { result = true; }
        });
    return result;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rdi), %r14
leaq 0x8(%rsi), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d87a
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
je 0x1d5f8
leaq 0x7(%rsp), %r13
movb $0x0, (%r13)
movq (%r12), %rsi
movq (%r15), %rcx
leaq 0x8(%rsp), %r8
movq %r13, (%r8)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x1d606
movb (%r13), %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/test.h
// Function: std::ostream& nda::operator<<<long>(std::ostream&, std::tuple<long> const&)
std::ostream& operator<<(std::ostream& s, const std::tuple<Ts...>& t) {
  s << "{";
  ostream_tuple(s, t, std::make_index_sequence<sizeof...(Ts)>());
  s << "}";
  return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8542b(%rip), %rsi     # 0xa5336
movl $0x1, %edx
callq 0x2210
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x21b0
leaq 0x85411(%rip), %rsi     # 0xa5338
movl $0x1, %edx
movq %r14, %rdi
callq 0x2210
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/test.h
// Function: std::ostream& nda::operator<<<-9l, -9l, 1l>(std::ostream&, nda::dim<-9l, -9l, 1l> const&)
std::ostream& operator<<(std::ostream& s, const dim<Min, Extent, Stride>& d) {
  s << "dim<";
  if (internal::is_static(Stride)) {
    ostream_comma_separated_list(s, Min, Extent, Stride);
  } else if (internal::is_static(Extent)) {
    ostream_comma_separated_list(s, Min, Extent);
  } else if (internal::is_static(Min)) {
    s << Min;
  }
  s << ">(";
  ostream_comma_separated_list(s, d.min(), d.extent(), d.stride());
  s << ")";
  return s;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x860f0(%rip), %rsi     # 0xa542d
movl $0x4, %edx
callq 0x2210
movl $0x1, %ecx
movq %rbx, %rdi
movq $-0x9, %rsi
movq $-0x9, %rdx
callq 0x1e8da
leaq 0x860c9(%rip), %rsi     # 0xa5432
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2210
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movl $0x1, %ecx
movq %rbx, %rdi
callq 0x1e8da
leaq 0x83b4a(%rip), %rsi     # 0xa2edb
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop