LLM4Binary/decompile-bench-makefile huggingface dataset:
// 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>> nda::move_reinterpret_shape<nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, int, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, std::allocator<int>>(nda::array<int, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, std::allocator<int>>&&, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>> const&, long)
array<T, NewShape, Alloc> move_reinterpret_shape(
    array<T, OldShape, Alloc>&& from, const NewShape& new_shape, index_t offset = 0) {
  // TODO: Use enable_if to implement this check. It is difficult to do due to
  // the friend declaration.
  static_assert(
      std::is_trivial<T>::value, "move_reinterpret_shape is broken for non-trivial types.");
  using std::swap;

  assert(new_shape.is_subset_of(from.shape(), offset));
  array<T, NewShape, Alloc> result;
  // Consider this to be a move assignment.
  if (std::allocator_traits<Alloc>::propagate_on_container_move_assignment::value) {
    swap(result.alloc_, from.alloc_);
  } else {
    assert(result.alloc_ == from.get_allocator());
  }

  swap(result.buffer_, from.buffer_);
  swap(result.buffer_size_, from.buffer_size_);
  swap(result.base_, from.base_);
  result.shape_ = new_shape;
  from.shape_ = OldShape();
  result.base_ += offset;

  return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
leaq 0x20(%rsi), %r12
movq %rdx, %rdi
movq %r12, %rsi
movq %rcx, %rdx
callq 0x208d0
testb %al, %al
je 0x208b0
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r14)
movups %xmm0, 0x8(%r14)
movq $0x0, 0x28(%r14)
movabsq $-0x8000000000000000, %rbp # imm = 0x8000000000000000
movq %rbp, 0x30(%r14)
movups %xmm0, 0x38(%r14)
movq %rbp, 0x48(%r14)
movq %r14, %rdi
callq 0xdf80
movq %r14, %rdi
callq 0xe05e
movq 0x8(%r14), %rax
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x8(%r15)
movq 0x10(%r14), %rax
movq 0x10(%r15), %rcx
movq %rcx, 0x10(%r14)
movq %rax, 0x10(%r15)
movq 0x18(%r14), %rax
movq 0x18(%r15), %rcx
movq %rcx, 0x18(%r14)
movq %rax, 0x18(%r15)
movq 0x28(%r13), %rax
movq %rax, 0x48(%r14)
movups 0x18(%r13), %xmm0
movups %xmm0, 0x38(%r14)
movups (%r13), %xmm0
movups %xmm0, 0x20(%r14)
movq 0x10(%r13), %rax
movq %rax, 0x30(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r15)
movq %rbp, 0x60(%r15)
movups %xmm0, 0x38(%r15)
movq %rbp, 0x48(%r15)
movups %xmm0, (%r12)
movq %rbp, 0x30(%r15)
leaq (%rcx,%rbx,4), %rax
movq %rax, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x854ab(%rip), %rdi     # 0xa5d62
leaq 0x8082f(%rip), %rsi     # 0xa10ed
leaq 0x854ca(%rip), %rcx     # 0xa5d8f
movl $0xbee, %edx            # imm = 0xBEE
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: nda::auto_allocator<nda::lifetime_counter, 256ul, 1ul, std::allocator<nda::lifetime_counter>>::allocate(unsigned long)
value_type* allocate(size_t n) {
    if (!allocated && n <= N) {
      allocated = true;
      return reinterpret_cast<value_type*>(&buffer[0]);
    } else {
      return std::allocator_traits<BaseAlloc>::allocate(alloc, n);
    }
  }

// Assembly:
cmpq $0x100, %rsi            # imm = 0x100
ja 0x3f82f
cmpb $0x0, 0x100(%rdi)
jne 0x3f82f
movb $0x1, 0x100(%rdi)
movq %rdi, %rax
retq
testq %rsi, %rsi
js 0x3f83c
movq %rsi, %rdi
jmp 0x21e0
pushq %rax
callq 0x2060
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: nda::auto_allocator<int, 32ul, 4ul, std::allocator<int>>::deallocate(int*, unsigned long)
void deallocate(value_type* ptr, size_t n) noexcept {
    if (ptr == reinterpret_cast<value_type*>(&buffer[0])) {
      assert(allocated);
      allocated = false;
    } else {
      std::allocator_traits<BaseAlloc>::deallocate(alloc, ptr, n);
    }
  }

// Assembly:
cmpq %rdi, %rsi
je 0x4e6fc
shlq $0x2, %rdx
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x21f0
cmpb $0x0, 0x80(%rdi)
je 0x4e70d
movb $0x0, 0x80(%rdi)
retq
pushq %rax
leaq 0x5892b(%rip), %rdi     # 0xa7040
leaq 0x529d1(%rip), %rsi     # 0xa10ed
leaq 0x5ee1e(%rip), %rcx     # 0xad541
movl $0xc57, %edx            # imm = 0xC57
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: nda::array<nda::lifetime_counter, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, nda::custom_alloc<std::integral_constant<bool, false>>>::array(nda::array<nda::lifetime_counter, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, nda::custom_alloc<std::integral_constant<bool, false>>>&&)
array(array&& other)
      : alloc_(get_allocator_for_move(other)), buffer_(nullptr), buffer_size_(0), base_(nullptr) {
    using std::swap;
    // If we already took other's allocator, it might be in an undefined state.
    // Just assume we can swap in that case.
    if (typename alloc_traits::propagate_on_container_move_assignment() ||
        alloc_ == other.get_allocator()) {
      swap_except_allocator(other);
    } else {
      shape_ = other.shape_;
      allocate();
      move_construct(other);
    }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %r14
movl $0x0, (%rdi)
incq 0xa1c45(%rip)           # 0xe5260
movq %rsi, %rbx
leaq 0x20(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x28(%rdi)
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
movq %rcx, 0x30(%rdi)
movups %xmm0, 0x38(%rdi)
movq %rcx, 0x48(%rdi)
cmpl $0x0, (%rsi)
je 0x4368a
leaq 0x38(%r14), %rcx
movq 0x48(%rbx), %rdx
movq %rdx, 0x10(%rcx)
movups 0x38(%rbx), %xmm0
movups %xmm0, (%rcx)
movq 0x30(%rbx), %rcx
movq %rcx, 0x10(%rax)
movups 0x20(%rbx), %xmm0
movups %xmm0, (%rax)
movq %r14, %rdi
callq 0x3f3aa
movq %r14, %rdi
movq %rbx, %rsi
callq 0x43732
jmp 0x4371a
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%r14)
xorl %ecx, %ecx
movq %rcx, 0x8(%rbx)
movq 0x10(%rbx), %rdx
movq %rdx, 0x10(%r14)
movq %rcx, 0x10(%rbx)
movq 0x18(%r14), %rcx
movq 0x18(%rbx), %rdx
movq %rdx, 0x18(%r14)
movq %rcx, 0x18(%rbx)
movq 0x10(%rax), %rcx
movq %rcx, 0x10(%rsp)
movups (%rax), %xmm0
movaps %xmm0, (%rsp)
movq 0x48(%r14), %rcx
movq %rcx, 0x28(%rsp)
movups 0x38(%r14), %xmm0
movups %xmm0, 0x18(%rsp)
movq 0x48(%rbx), %rcx
movq %rcx, 0x48(%r14)
movups 0x38(%rbx), %xmm0
movups %xmm0, 0x38(%r14)
movq 0x30(%rbx), %rcx
movq %rcx, 0x10(%rax)
movups 0x20(%rbx), %xmm0
movups %xmm0, (%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x48(%rbx)
movups 0x18(%rsp), %xmm0
movups %xmm0, 0x38(%rbx)
movaps (%rsp), %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r14
retq
incq 0xa1b47(%rip)           # 0xe5270
movq %rax, %rdi
callq 0x2300
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>>>::move_construct(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>>>&)
void move_construct(array& other) {
    assert(base_ || shape_.empty());
    assert(shape_ == other.shape_);
    copy_shape_traits_type::for_each_value(
        other.shape_, other.base_, shape_, base_, [&](reference src, reference dst) {
          alloc_traits::construct(alloc_, &dst, std::move(src));
        });
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x98(%rdi)
jne 0x4ecba
movq 0xc0(%rbx), %rax
imulq 0xd8(%rbx), %rax
imulq 0xa8(%rbx), %rax
testq %rax, %rax
jg 0x4ed40
movq 0xd0(%rbx), %rax
cmpq 0xd0(%r14), %rax
jne 0x4ed21
movq 0xd8(%r14), %rax
cmpq %rax, 0xd8(%rbx)
jne 0x4ed21
movl $0xa0, %r12d
leaq (%rbx,%r12), %r15
addq %r14, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xd5f6
testb %al, %al
je 0x4ed21
movq 0x98(%r14), %rsi
movq 0x98(%rbx), %rcx
movq %rsp, %r8
movq %rbx, (%r8)
movq %r12, %rdi
movq %r15, %rdx
callq 0x4ed60
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x52bf9(%rip), %rdi     # 0xa1921
leaq 0x523be(%rip), %rsi     # 0xa10ed
leaq 0x5ec1c(%rip), %rcx     # 0xad952
movl $0x906, %edx            # imm = 0x906
callq 0x2100
leaq 0x5247e(%rip), %rdi     # 0xa11c5
leaq 0x5239f(%rip), %rsi     # 0xa10ed
leaq 0x5ebfd(%rip), %rcx     # 0xad952
movl $0x905, %edx            # imm = 0x905
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>>, nda::auto_allocator<int, 32ul, 4ul, std::allocator<int>>>::assign(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>>>&&)
void assign(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();
    }
    move_construct(other);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x98(%rdi), %rax
cmpq 0x98(%rsi), %rax
je 0x4f0da
testq %rax, %rax
je 0x4f062
movq 0xd0(%rbx), %rax
cmpq 0xd0(%r14), %rax
jne 0x4f062
movq 0xd8(%r14), %rax
cmpq %rax, 0xd8(%rbx)
jne 0x4f062
movl $0xa0, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0xd5f6
testb %al, %al
je 0x4f062
movq %rbx, %rdi
callq 0x4e636
jmp 0x4f0c8
movq %rbx, %rdi
callq 0x4e5c0
movb 0xe0(%r14), %al
movb %al, 0xe0(%rbx)
movups 0xd0(%r14), %xmm0
movups %xmm0, 0xd0(%rbx)
movups 0xb8(%r14), %xmm0
movups %xmm0, 0xb8(%rbx)
movq 0xc8(%r14), %rax
movq %rax, 0xc8(%rbx)
movups 0xa0(%r14), %xmm0
movups %xmm0, 0xa0(%rbx)
movq 0xb0(%r14), %rax
movq %rax, 0xb0(%rbx)
movq %rbx, %rdi
callq 0x4e2d4
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4ec82
testq %rax, %rax
je 0x4f13c
movq 0xd0(%rbx), %rax
cmpq 0xd0(%r14), %rax
jne 0x4f11d
movq 0xd8(%r14), %rax
cmpq %rax, 0xd8(%rbx)
jne 0x4f11d
movl $0xa0, %eax
addq %rax, %r14
addq %rax, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd5f6
testb %al, %al
jne 0x4f1ae
leaq 0x527fd(%rip), %rdi     # 0xa1921
leaq 0x51fc2(%rip), %rsi     # 0xa10ed
leaq 0x5ebc7(%rip), %rcx     # 0xadcf9
movl $0x9cc, %edx            # imm = 0x9CC
callq 0x2100
movb 0xe0(%r14), %al
movb %al, 0xe0(%rbx)
movups 0xd0(%r14), %xmm0
movups %xmm0, 0xd0(%rbx)
movq 0xc8(%r14), %rax
movq %rax, 0xc8(%rbx)
movups 0xb8(%r14), %xmm0
movups %xmm0, 0xb8(%rbx)
movups 0xa0(%r14), %xmm0
movups %xmm0, 0xa0(%rbx)
movq 0xb0(%r14), %rax
movq %rax, 0xb0(%rbx)
movq 0xc0(%rbx), %rax
imulq 0xd8(%rbx), %rax
imulq 0xa8(%rbx), %rax
testq %rax, %rax
jg 0x4f1b6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x52011(%rip), %rdi     # 0xa11ce
leaq 0x51f29(%rip), %rsi     # 0xa10ed
leaq 0x5eb2e(%rip), %rcx     # 0xadcf9
movl $0x9cf, %edx            # imm = 0x9CF
callq 0x2100
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: nda::array<nda::lifetime_counter, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, std::allocator<nda::lifetime_counter>>::swap(nda::array<nda::lifetime_counter, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, std::allocator<nda::lifetime_counter>>&)
void swap(array& other) {
    using std::swap;

    if (alloc_traits::propagate_on_container_swap::value) {
      swap(alloc_, other.alloc_);
      swap_except_allocator(other);
    } else {
      // TODO: If the shapes are equal, we could swap each element without the
      // temporary allocation.
      array temp(std::move(other));
      other = std::move(*this);
      *this = std::move(temp);
    }
  }

// Assembly:
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rsp)
movups %xmm0, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x28(%rsp)
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
movq %rcx, 0x30(%rsp)
movups %xmm0, 0x38(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rsp)
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x10(%rsi)
movq 0x18(%rsp), %rax
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x18(%rsi)
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x78(%rsp)
movups 0x38(%rsp), %xmm0
movups %xmm0, 0x68(%rsp)
movups 0x38(%rsi), %xmm1
movups %xmm1, 0x38(%rsp)
movq 0x48(%rsi), %rcx
movq %rcx, 0x48(%rsp)
movups 0x20(%rsi), %xmm1
movups %xmm1, 0x20(%rsp)
movq 0x30(%rsi), %rcx
movq %rcx, 0x30(%rsp)
movq %rax, 0x48(%rsi)
movups %xmm0, 0x38(%rsi)
movq 0x60(%rsp), %rax
movq %rax, 0x30(%rsi)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsi)
movq 0x58(%rsp), %rax
movq %rax, 0x28(%rsi)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x44a9e
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x44a9e
movq %rsp, %rdi
callq 0x3ee72
addq $0x80, %rsp
popq %rbx
retq
jmp 0x45e81
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3ee72
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc036
nop
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/array_ref.cpp
// Function: nda::test_array_ref_empty_body()
TEST(array_ref_empty) {
  dense_array_ref<int, 1> null_ref(nullptr, {10});
  ASSERT(null_ref.empty());
  null_ref.set_shape({{3, 3}}, 3);
  ASSERT(null_ref.empty());

  int x;
  array_ref_of_rank<int, 0> scalar_ref(&x, {});
  ASSERT(!scalar_ref.empty());
  array_ref_of_rank<int, 0> null_scalar_ref(nullptr, {});
  ASSERT(null_scalar_ref.empty());
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x668, %rsp            # imm = 0x668
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq $0xa, 0x8(%rsi)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%rsi)
xorl %edi, %edi
callq 0xd09f
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x63c1b(%rip), %rsi     # 0xac46b
leaq 0x63c24(%rip), %rdx     # 0xac47b
leaq 0x8(%rsp), %rdi
callq 0xd0b8
leaq 0x4d8(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf0a
leaq 0x4d8(%rsp), %rdi
callq 0xbf62
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4889c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movl $0x3, %eax
leaq 0x8(%rsp), %rbx
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
movq $0x1, 0x10(%rbx)
xorl %edi, %edi
movq %rbx, %rsi
callq 0xd09f
movq %r14, (%rbx)
leaq 0x63ba2(%rip), %rsi     # 0xac46b
leaq 0x63bab(%rip), %rdx     # 0xac47b
leaq 0x8(%rsp), %rdi
callq 0xd0b8
leaq 0x348(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf0a
leaq 0x348(%rsp), %rdi
callq 0xbf62
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x48915
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x63b58(%rip), %rsi     # 0xac47c
leaq 0x63b64(%rip), %rdx     # 0xac48f
callq 0xd0b8
leaq 0x1b8(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf0a
leaq 0x1b8(%rsp), %rdi
callq 0xbf62
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4896b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x63b16(%rip), %rsi     # 0xac490
leaq 0x63b26(%rip), %rdx     # 0xac4a7
callq 0xd0b8
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf0a
leaq 0x28(%rsp), %rdi
callq 0xbf62
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x489bb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
addq $0x668, %rsp            # imm = 0x668
popq %rbx
popq %r14
retq
jmp 0x489cc
jmp 0x489cc
jmp 0x489cc
movq %rax, %rbx
jmp 0x489f1
jmp 0x489d7
jmp 0x489d7
jmp 0x489d7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x489f1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/test.h
// Function: bool nda::assert_dim_eq<0l, -9l, 1l, 0l, -9l, 1l>(nda::dim<0l, -9l, 1l> const&, nda::dim<0l, -9l, 1l> const&)
bool assert_dim_eq(const dim<MinA, ExtentA, StrideA>& a, const dim<MinB, ExtentB, StrideB>& b) {
  static_assert(MinA == MinB, "");
  static_assert(ExtentA == ExtentB, "");
  static_assert(StrideA == StrideB, "");
  ASSERT_EQ(a, b);
  return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
xorl %ebp, %ebp
cmpq 0x8(%rsi), %rax
sete %bpl
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x56b4d(%rip), %rsi     # 0xa10a3
leaq 0x56b4c(%rip), %rdx     # 0xa10a9
movq %rsp, %r15
movq %r15, %rdi
callq 0xd0b8
leaq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0xbf0a
leaq 0x570d6(%rip), %rsi     # 0xa1654
leaq 0x20(%rsp), %rdi
callq 0x18a16
leaq 0x62c13(%rip), %rsi     # 0xad1a2
movq %rax, %rdi
callq 0x18a16
leaq 0x5ad8c(%rip), %rsi     # 0xa532a
movq %rax, %rdi
callq 0x18a16
movq %rax, %r15
cmpb $0x1, 0x188(%rax)
jne 0x4a5c1
movq %r15, %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x4be0c
leaq 0x5708c(%rip), %rsi     # 0xa1654
movq %r15, %rdi
callq 0x18a16
leaq 0x589d9(%rip), %rsi     # 0xa2fb0
movq %rax, %rdi
callq 0x18a16
leaq 0x5ad44(%rip), %rsi     # 0xa532a
movq %rax, %rdi
callq 0x18a16
movq %rax, %r14
cmpb $0x1, 0x188(%rax)
jne 0x4a609
movq %r14, %rdi
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x4be0c
leaq 0x6dd59(%rip), %rsi     # 0xb8369
movq %r14, %rdi
callq 0x18a16
leaq 0x20(%rsp), %rdi
callq 0xbf62
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4a638
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
movb $0x1, %al
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x4a65c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xbf62
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4a672
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
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: void nda::internal::assert_dim_compatible<nda::dim<4l, 3l, 1l>, nda::dim<-9l, -9l, -9l>>(unsigned long, nda::dim<-9l, -9l, -9l> const&)
NDARRAY_HOST_DEVICE void assert_dim_compatible(size_t dim_index, const DimSrc& src) {
  bool compatible = true;
  if (is_static(DimDst::Min) && src.min() != DimDst::Min) {
    NDARRAY_PRINT_ERR("Error converting dim %zu: expected static min " NDARRAY_INDEX_T_FMT
                      ", got " NDARRAY_INDEX_T_FMT "\n",
        dim_index, DimDst::Min, src.min());
    compatible = false;
  }
  if (is_static(DimDst::Extent) && src.extent() != DimDst::Extent) {
    NDARRAY_PRINT_ERR("Error converting dim %zu: expected static extent " NDARRAY_INDEX_T_FMT
                      ", got " NDARRAY_INDEX_T_FMT "\n",
        dim_index, DimDst::Extent, src.extent());
    compatible = false;
  }
  if (is_static(DimDst::Stride) && is_resolved(src.stride()) && src.stride() != DimDst::Stride) {
    NDARRAY_PRINT_ERR("Error converting dim %zu: expected static stride " NDARRAY_INDEX_T_FMT
                      ", got " NDARRAY_INDEX_T_FMT "\n",
        dim_index, DimDst::Stride, src.stride());
    compatible = false;
  }
  assert(compatible);
  (void)compatible;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r8
cmpq $0x4, %r8
sete %bpl
jne 0x4b129
movq 0x8(%r14), %r8
cmpq $0x3, %r8
jne 0x4b14b
movq 0x10(%r14), %r8
movq %r8, %rax
negq %rax
jo 0x4b11f
cmpq $0x1, %r8
jne 0x4b16f
testb %bpl, %bpl
je 0x4b18f
popq %rbx
popq %r14
popq %rbp
retq
movq 0x99ea0(%rip), %rax     # 0xe4fd0
movq (%rax), %rdi
leaq 0x619ea(%rip), %rsi     # 0xacb24
movl $0x4, %ecx
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2240
jmp 0x4b103
movq 0x99e7e(%rip), %rax     # 0xe4fd0
movq (%rax), %rdi
leaq 0x61a79(%rip), %rsi     # 0xacbd5
xorl %ebp, %ebp
movl $0x3, %ecx
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2240
jmp 0x4b10d
movq 0x99e5a(%rip), %rax     # 0xe4fd0
movq (%rax), %rdi
leaq 0x56497(%rip), %rsi     # 0xa1617
movl $0x1, %ecx
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2240
leaq 0x5610a(%rip), %rdi     # 0xa12a0
leaq 0x55f50(%rip), %rsi     # 0xa10ed
leaq 0x61a70(%rip), %rcx     # 0xacc14
movl $0x3f5, %edx            # imm = 0x3F5
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: void nda::internal::assert_dims_compatible<std::tuple<nda::dim<-9l, 3l, -9l>, nda::dim<-9l, 3l, 0l>, nda::dim<-9l, 3l, 0l>, nda::dim<-9l, -9l, 1l>>, std::tuple<nda::dim<-9l, 3l, -9l>, nda::dim<-9l, 3l, 0l>, nda::dim<-9l, 3l, 0l>, nda::dim<-9l, -9l, 1l>>, 0ul, 1ul, 2ul, 3ul>(std::tuple<nda::dim<-9l, 3l, -9l>, nda::dim<-9l, 3l, 0l>, nda::dim<-9l, 3l, 0l>, nda::dim<-9l, -9l, 1l>> const&, std::integer_sequence<unsigned long, 0ul, 1ul, 2ul, 3ul>)
NDARRAY_HOST_DEVICE void assert_dims_compatible(const DimsSrc& src, index_sequence<Is...>) {
  // This is ugly, in C++17, we'd use a fold  expression over the comma operator (f(), ...).
  int unused[] = {(assert_dim_compatible<typename std::tuple_element<Is, DimsDst>::type>(
                       Is, nda::dim<>(std::get<Is>(src))),
      0)...};
  (void)unused;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rax
leaq 0x48(%rsp), %rsi
movq %rax, (%rsi)
movl $0x3, %r14d
movq %r14, 0x8(%rsi)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x10(%rsi)
movq 0x48(%rdi), %rax
movq %rax, 0x10(%rsi)
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x57a9b
movq 0x28(%rbx), %rax
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, 0x8(%rsi)
movq %r15, 0x10(%rsi)
movl $0x1, %edi
callq 0x57aac
movq 0x18(%rbx), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, 0x8(%rsi)
movq %r15, 0x10(%rsi)
movl $0x2, %edi
callq 0x57aac
movups (%rbx), %xmm0
movq %rsp, %rsi
movups %xmm0, (%rsi)
movq $0x1, 0x10(%rsi)
movl $0x3, %edi
callq 0xd09f
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: nda::shape<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>> nda::convert_shape<nda::shape<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>>, nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>>, void>(nda::shape<nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>, nda::dim<-9l, -9l, -9l>> const&)
NDARRAY_HOST_DEVICE ShapeDst convert_shape(const ShapeSrc& src) {
  assert(
      internal::is_trivial_slice<ShapeDst::rank()>(src.dims(), typename ShapeSrc::dim_indices()));
  return internal::convert_dims<typename ShapeDst::dims_type>(
      src.dims(), typename ShapeDst::dim_indices());
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x4b775
movups 0x60(%r14), %xmm0
leaq 0x8(%rsp), %rsi
movups %xmm0, (%rsi)
movq $0x1, 0x10(%rsi)
xorl %edi, %edi
callq 0xd09f
movl $0xf, %ecx
movq %rbx, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/auto_allocator.cpp
// Function: bool nda::is_auto_allocation<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>>>>(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&)
bool is_auto_allocation(const T& a) {
  const uint8_t* a_begin = reinterpret_cast<const uint8_t*>(&a);
  const uint8_t* a_end = a_begin + sizeof(T);
  const uint8_t* a_data_begin = reinterpret_cast<const uint8_t*>(a.data());
  const uint8_t* a_data_end = reinterpret_cast<const uint8_t*>(a.data() + a.shape().flat_extent());
  return a_begin <= a_data_begin && a_data_end <= a_end;
}

// Assembly:
leaq 0xe8(%rdi), %rax
movq 0xc0(%rdi), %rcx
decq %rcx
movq 0xc8(%rdi), %rdx
movq %rdx, %rsi
sarq $0x3f, %rsi
andq %rdx, %rsi
imulq %rcx, %rsi
movq 0x98(%rdi), %r8
movq 0xa8(%rdi), %r9
decq %r9
movq 0xb0(%rdi), %r10
movq %r10, %r11
sarq $0x3f, %r11
andq %r10, %r11
imulq %r9, %r11
testq %r8, %r8
leaq (%r8,%r11,4), %r11
leaq (%r11,%rsi,4), %rsi
cmoveq %r8, %rsi
movq %r10, %r8
negq %r8
cmovsq %r10, %r8
imulq %r9, %r8
movq %rdx, %r9
negq %r9
cmovsq %rdx, %r9
imulq %rcx, %r9
addq 0xd8(%rdi), %r9
leaq (%r8,%r9), %rcx
decq %rcx
testq %rcx, %rcx
movq $-0x1, %rdx
cmovnsq %rcx, %rdx
leaq (%rsi,%rdx,4), %rcx
addq $0x4, %rcx
cmpq %rdi, %rsi
setae %dl
cmpq %rax, %rcx
setbe %al
andb %dl, %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/array.h
// Function: void nda::shape_traits<nda::shape<nda::dim<-9l, 64l, 1l>>>::for_each_value<int*, nda::array<int, nda::shape<nda::dim<-9l, 64l, 1l>>, std::allocator<int>>::construct()::'lambda'(int&)&>(nda::shape<nda::dim<-9l, 64l, 1l>> const&, int*, nda::array<int, nda::shape<nda::dim<-9l, 64l, 1l>>, std::allocator<int>>::construct()::'lambda'(int&)&)
NDARRAY_UNIQUE NDARRAY_HOST_DEVICE void for_each_value_in_order(
    const Shape& shape, Ptr base, Fn&& fn) {
  if (!base) {
    assert(shape.empty());
    return;
  }
  // TODO: This is losing compile-time constant extents and strides info
  // (https://github.com/dsharlet/array/issues/1).
  auto base_and_stride = std::make_pair(base, shape.stride());
  internal::for_each_value_in_order<Shape::rank() - 1>(shape.extent(), fn, base_and_stride);
}

// Assembly:
testq %rsi, %rsi
je 0x56ed6
leaq 0x100(%rsi), %rax
leaq 0x4(%rsi), %rcx
cmpq %rcx, %rax
cmovaq %rax, %rcx
movq %rsi, %rdx
notq %rdx
addq %rcx, %rdx
andq $-0x4, %rdx
addq $0x4, %rdx
movq %rsi, %rdi
xorl %esi, %esi
jmp 0x20e0
pushq %rax
leaq 0x4a3cd(%rip), %rdi     # 0xa12ab
leaq 0x4a208(%rip), %rsi     # 0xa10ed
leaq 0x5774b(%rip), %rcx     # 0xae637
movl $0x6a1, %edx            # imm = 0x6A1
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/image.cpp
// Function: nda::test_image_chunky_copy_body()
TEST(image_chunky_copy) {
  test_copy_all_types<chunky_image_shape<1>, chunky_image_shape<1>>(1);
  test_copy_all_types<chunky_image_shape<2>, chunky_image_shape<2>>(2);
  test_copy_all_types<chunky_image_shape<3>, chunky_image_shape<3>>(3);
  test_copy_all_types<chunky_image_shape<4>, chunky_image_shape<4>>(4);
}

// Assembly:
pushq %rax
movl $0x1, %edi
callq 0x617e0
movl $0x1, %edi
callq 0x61bf3
movl $0x1, %edi
callq 0x62005
movl $0x2, %edi
callq 0x63da6
movl $0x2, %edi
callq 0x641b9
movl $0x2, %edi
callq 0x645cb
movl $0x3, %edi
callq 0x667ee
movl $0x3, %edi
callq 0x66c01
movl $0x3, %edi
callq 0x67013
movl $0x4, %edi
callq 0x68bdc
movl $0x4, %edi
callq 0x68fef
movl $0x4, %edi
popq %rax
jmp 0x69401
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/image.cpp
// Function: nda::test_image_interleave_body()
TEST(image_interleave) {
  test_copy_all_types<planar_image_shape, chunky_image_shape<1>>(1);
  test_copy_all_types<planar_image_shape, chunky_image_shape<2>>(2);
  test_copy_all_types<planar_image_shape, chunky_image_shape<3>>(3);
  test_copy_all_types<planar_image_shape, chunky_image_shape<4>>(4);
}

// Assembly:
pushq %rax
movl $0x1, %edi
callq 0x6cd11
movl $0x1, %edi
callq 0x6d0d8
movl $0x1, %edi
callq 0x6d49e
movl $0x2, %edi
callq 0x6dea8
movl $0x2, %edi
callq 0x6e26f
movl $0x2, %edi
callq 0x6e635
movl $0x3, %edi
callq 0x6f04e
movl $0x3, %edi
callq 0x6f415
movl $0x3, %edi
callq 0x6f7db
movl $0x4, %edi
callq 0x701f7
movl $0x4, %edi
callq 0x705be
movl $0x4, %edi
popq %rax
jmp 0x70984
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/image.cpp
// Function: nda::test_image_deinterleave_body()
TEST(image_deinterleave) {
  test_copy_all_types<chunky_image_shape<1>, planar_image_shape>(1);
  test_copy_all_types<chunky_image_shape<2>, planar_image_shape>(2);
  test_copy_all_types<chunky_image_shape<3>, planar_image_shape>(3);
  test_copy_all_types<chunky_image_shape<4>, planar_image_shape>(4);
}

// Assembly:
pushq %rax
movl $0x1, %edi
callq 0x713a0
movl $0x1, %edi
callq 0x71721
movl $0x1, %edi
callq 0x71aa1
movl $0x2, %edi
callq 0x72552
movl $0x2, %edi
callq 0x728d3
movl $0x2, %edi
callq 0x72c53
movl $0x3, %edi
callq 0x73713
movl $0x3, %edi
callq 0x73a94
movl $0x3, %edi
callq 0x73e14
movl $0x4, %edi
callq 0x748d4
movl $0x4, %edi
callq 0x74c55
movl $0x4, %edi
popq %rax
jmp 0x74fd5
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/image.cpp
// Function: nda::test_image_overload_shape_body()
TEST(image_overload_shape) {
  planar_image<int> planar({10, 20, 3});
  chunky_image<int> chunky({10, 20, 3});

  overload_shape(planar);
  overload_shape(chunky);

  chunky_image<int, 3> chunky3({10, 20, {}});
  general_chunky(chunky3.cref());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x168, %rsp            # imm = 0x168
movabsq $-0x8000000000000000, %r15 # imm = 0x8000000000000000
xorl %r12d, %r12d
leaq 0x40(%rsp), %rbx
movq %r12, (%rbx)
movl $0xa, %eax
movq %rax, 0x8(%rbx)
movq %r15, 0x10(%rbx)
xorl %edi, %edi
movq %rbx, %rsi
callq 0xd09f
xorps %xmm0, %xmm0
leaq 0x100(%rsp), %r14
movups %xmm0, 0x8(%r14)
movups %xmm0, 0x18(%r14)
movl $0x3, %ebp
movq %rbp, 0x28(%r14)
movq %r15, 0x30(%r14)
movq %r12, 0x38(%r14)
movl $0x14, %r13d
movq %r13, 0x40(%r14)
movq %r15, 0x48(%r14)
movq %r12, 0x50(%r14)
movl $0xa, %eax
movq %rax, 0x58(%r14)
movq %r14, %rdi
callq 0xc2a2
movq %r14, %rdi
callq 0xc38a
leaq 0xa8(%rsp), %rsi
movq %r12, (%rsi)
movq %rbp, 0x8(%rsi)
movq %r15, 0x10(%rsi)
movl $0x2, %edi
callq 0x4b05b
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq %r12, 0x18(%rbx)
movq %rbp, 0x28(%rbx)
movq %r12, 0x38(%rbx)
movq %r13, 0x40(%rbx)
movq %r15, 0x48(%rbx)
movq %r12, 0x50(%rbx)
movl $0xa, %eax
movq %rax, 0x58(%rbx)
movq %r15, 0x60(%rbx)
leaq 0x40(%rsp), %rdi
callq 0x765e8
leaq 0x40(%rsp), %rdi
callq 0x766d4
xorl %eax, %eax
leaq 0x8(%rsp), %rdi
movq %rax, 0x8(%rdi)
movq $0x14, 0x10(%rdi)
movq %r15, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq $0xa, 0x28(%rdi)
callq 0x76c80
movq 0x38(%rsp), %rax
leaq 0xa8(%rsp), %rdi
movq %rax, 0x50(%rdi)
movups 0x8(%rsp), %xmm0
movups 0x18(%rsp), %xmm1
movups 0x28(%rsp), %xmm2
movups %xmm2, 0x40(%rdi)
movups %xmm1, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
callq 0x76cc8
leaq 0xa8(%rsp), %rdi
callq 0x76d84
leaq 0x8(%rsp), %rsi
movq $0x0, (%rsi)
movq $0x3, 0x8(%rsi)
movq $0x1, 0x10(%rsi)
movl $0x2, %edi
callq 0x4b05b
leaq 0xa8(%rsp), %rdi
callq 0x76eb6
leaq 0x40(%rsp), %rdi
callq 0x76b3c
leaq 0x100(%rsp), %rdi
callq 0xd16c
addq $0x168, %rsp            # imm = 0x168
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b2f5
jmp 0x5b2f5
jmp 0x5b2f5
movq %rax, %rbx
jmp 0x5b2de
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x76b3c
leaq 0x100(%rsp), %rdi
callq 0xd16c
movq %rbx, %rdi
callq 0x2300
jmp 0x5b2f5
movq %rax, %rdi
callq 0xc036
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/image.cpp
// Function: nda::test_image_overload_chunky_body()
TEST(image_overload_chunky) {
  chunky_image<int, 1> chunky1({10, 20, {}});
  chunky_image<int, 3> chunky3({10, 20, {}});

  overload_chunky(chunky1);
  overload_chunky(chunky3);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
xorl %r15d, %r15d
leaq 0x38(%rsp), %rbx
movq %r15, 0x8(%rbx)
movl $0x14, %r12d
movq %r12, 0x10(%rbx)
movabsq $-0x8000000000000000, %r13 # imm = 0x8000000000000000
movq %r13, 0x18(%rbx)
movq %r15, 0x20(%rbx)
movl $0xa, %ebp
movq %rbp, 0x28(%rbx)
movq %rbx, %rdi
callq 0x76fbe
movq 0x30(%rbx), %rax
leaq 0x90(%rsp), %r14
movq %rax, 0x50(%r14)
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups 0x20(%rbx), %xmm2
movups %xmm2, 0x40(%r14)
movups %xmm1, 0x30(%r14)
movups %xmm0, 0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%r14)
movq %r15, 0x18(%r14)
movq %r14, %rdi
callq 0x77002
movq %r14, %rdi
callq 0x770bc
movq %rsp, %rdi
movq %r15, 0x8(%rdi)
movq %r12, 0x10(%rdi)
movq %r13, 0x18(%rdi)
movq %r15, 0x20(%rdi)
movq %rbp, 0x28(%rdi)
callq 0x76c80
movq 0x30(%rsp), %rax
leaq 0x38(%rsp), %rdi
movq %rax, 0x50(%rdi)
movups (%rsp), %xmm0
movups 0x10(%rsp), %xmm1
movups 0x20(%rsp), %xmm2
movups %xmm2, 0x40(%rdi)
movups %xmm1, 0x30(%rdi)
movups %xmm0, 0x20(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x18(%rdi)
callq 0x76cc8
leaq 0x38(%rsp), %rdi
callq 0x76d84
leaq 0x38(%rsp), %rdi
callq 0x76eb6
leaq 0x90(%rsp), %rdi
callq 0x771e4
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5b436
jmp 0x5b436
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x771e4
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc036
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/image.h
// Function: nda::array_ref<int, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>> nda::crop<int, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>>(nda::array_ref<int, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>> const&, long, long, long, long, nda::crop_origin)
array_ref<T, Shape> crop(const array_ref<T, Shape>& im, index_t x0, index_t y0, index_t x1,
    index_t y1, crop_origin origin = crop_origin::crop) {
  x0 = internal::max(x0, im.x().min());
  y0 = internal::max(y0, im.y().min());
  x1 = internal::min(x1, im.x().max() + 1);
  y1 = internal::min(y1, im.y().max() + 1);
  Shape cropped_shape = crop_image_shape(im.shape(), x0, y0, x1, y1, origin);
  index_t c0 = im.c().min();
  T* base = im.base() != nullptr ? &im(x0, y0, c0) : nullptr;
  if (origin == crop_origin::crop) {
    base = internal::pointer_add(base, -cropped_shape(x0, y0, c0));
  }
  return array_ref<T, Shape>(base, cropped_shape);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rsi), %r14
cmpq %rdx, %r14
cmovgq %r14, %rdx
movq 0x10(%rsi), %r15
cmpq %rcx, %r15
cmovgq %r15, %rcx
movl 0x30(%rsp), %r10d
movq 0x30(%rsi), %rax
addq %r14, %rax
cmpq %r8, %rax
cmovgeq %r8, %rax
movq 0x18(%rsi), %rdi
addq %r15, %rdi
cmpq %r9, %rdi
cmovgeq %r9, %rdi
cmpl $0x1, %r10d
je 0x60159
movq %r14, %r8
movq %r15, %r9
testl %r10d, %r10d
jne 0x6015f
xorl %r8d, %r8d
xorl %r9d, %r9d
jmp 0x6015f
movq %rdx, %r8
movq %rcx, %r9
movq 0x8(%rsi), %r11
movq (%rsi), %r12
testq %r12, %r12
je 0x6018a
movq %rcx, %r13
subq %r15, %r13
movq %rdx, %r15
imulq 0x20(%rsi), %r13
subq %r14, %r15
leaq (%r15,%r15,2), %r14
leaq (%r12,%r14,4), %r14
leaq (%r14,%r13,4), %r15
jmp 0x6018d
xorl %r15d, %r15d
movq 0x20(%rsi), %r14
movq 0x38(%rsi), %rsi
subq %rdx, %rax
subq %rcx, %rdi
cmpl $0x1, %r10d
jne 0x601c0
subq %r8, %rdx
leaq (%rdx,%rdx,2), %rdx
movq %r9, %r10
subq %rcx, %r10
imulq %r14, %r10
subq %rdx, %r10
testq %r15, %r15
leaq (%r15,%r10,4), %rcx
cmovneq %rcx, %r15
movq %r15, (%rbx)
movw %r11w, 0x8(%rbx)
shrl $0x10, %r11d
movb %r11b, 0xa(%rbx)
movq %r9, 0x10(%rbx)
movq %rdi, 0x18(%rbx)
movq %r14, 0x20(%rbx)
movq %r8, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movq %rsi, 0x38(%rbx)
negq %r14
jno 0x601fe
leaq 0x8(%rbx), %rsi
movq 0x18(%rbx), %rdi
callq 0x606ee
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/include/array/image.h
// Function: void nda::for_each_image_index<nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>, void nda::check_pattern<int, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>>(nda::array_ref<int, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>> const&, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>::index_type const&)::'lambda'(std::tuple<long, long, long> const&)&>(int const&, nda::shape<nda::dim<-9l, -9l, 3l>, nda::dim<-9l, -9l, -9l>, nda::dim<0l, 3l, 1l>>&&)
void for_each_image_index(const Shape& s, Fn&& fn) {
  // Images should always be iterated with c as the innermost loop. Even when
  // the image is planar, the number of channels is generally small, and many
  // operations use all of the channels at the same time (all-to-all
  // communication in the c dimension).
  for (index_t y : s.y()) {
    for (index_t x : s.x()) {
      for (index_t c : s.c()) {
        fn(std::tuple<index_t, index_t, index_t>(x, y, c));
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, (%rsp)
movq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x60486
movq %rsi, %rbx
movq (%rsp), %rax
movq 0x8(%rax), %r13
addq %r13, 0x8(%rsp)
leaq 0x10(%rsp), %r15
movq (%rsp), %rax
movq 0x28(%rax), %rbp
testq %rbp, %rbp
je 0x6047c
movq (%rsp), %rax
movq 0x20(%rax), %r12
addq %r12, %rbp
xorl %r14d, %r14d
movq %r14, 0x10(%rsp)
movq %r13, 0x18(%rsp)
movq %r12, 0x20(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x60496
incq %r14
cmpq $0x3, %r14
jne 0x60451
incq %r12
cmpq %rbp, %r12
jne 0x6044e
incq %r13
cmpq 0x8(%rsp), %r13
jne 0x60436
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/main.cpp
// Function: (anonymous namespace)::wildcard_match(char const*, char const*)
bool wildcard_match(const char* p, const char* str) {
  while (*p && *str && (*p == *str || *p == '?') && *p != '*') {
    str++;
    p++;
  }

  if (!*p) {
    return *str == 0;
  } else if (*p == '*') {
    p++;
    do {
      if (wildcard_match(p, str)) { return true; }
    } while (*str++);
  }
  return !*p;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movb (%rdi), %al
testb %al, %al
je 0x776ef
movq %rdi, %r14
incq %r14
movb (%rbx), %cl
testb %cl, %cl
je 0x776de
cmpb %cl, %al
setne %cl
cmpb $0x3f, %al
setne %dl
cmpb $0x2a, %al
je 0x776de
andb %cl, %dl
jne 0x776de
incq %rbx
movb (%r14), %al
incq %r14
testb %al, %al
jne 0x776b7
jmp 0x776ef
cmpb $0x2a, %al
je 0x77706
movzbl %al, %eax
testl %eax, %eax
je 0x776ef
decq %r14
movq %r14, %rbx
cmpb $0x0, (%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpb $0x0, (%rbx)
leaq 0x1(%rbx), %rbx
je 0x776ec
movq %r14, %rdi
movq %rbx, %rsi
callq 0x776a4
testb %al, %al
je 0x776fd
movb $0x1, %al
jmp 0x776f5
nop
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/shape.cpp
// Function: nda::test_shape_1d_body()
TEST(shape_1d) {
  for (int stride : {1, 2, 10}) {
    dim<> x(0, 10, stride);
    shape<dim<>> s(x);
    for (int i : x) {
      ASSERT_EQ(s(i), i * stride);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movabsq $0x200000001, %rax      # imm = 0x200000001
movq %rax, 0x2c(%rsp)
movl $0xa, 0x34(%rsp)
xorl %eax, %eax
leaq 0x38(%rsp), %r12
leaq 0x2415a(%rip), %rbx     # 0xa532a
movq %rax, 0x20(%rsp)
movslq 0x2c(%rsp,%rax), %r15
movl $0xa, %r13d
xorl %r14d, %r14d
leaq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq %rsp, %rbp
movq %rbp, %rdi
leaq 0x3bbe9(%rip), %rsi     # 0xbcde2
leaq 0x3bbf4(%rip), %rdx     # 0xbcdf4
callq 0xd0b8
movslq %r14d, %rax
xorl %esi, %esi
cmpq %rax, %r14
sete %sil
movq %r12, %rdi
movq %rbp, %rdx
callq 0xbf0a
movq %r12, %rdi
leaq 0x2042e(%rip), %rsi     # 0xa1654
callq 0x18a16
movq %rax, %rdi
leaq 0x2b1c5(%rip), %rsi     # 0xac3fa
callq 0x18a4e
movq %rax, %rdi
movq %rbx, %rsi
callq 0x18a16
movq %rax, %rbp
cmpb $0x1, 0x188(%rax)
jne 0x81260
movq %rbp, %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x21b0
movq %rbp, %rdi
leaq 0x203ea(%rip), %rsi     # 0xa1654
callq 0x18a16
movq %rax, %rdi
leaq 0x3bb71(%rip), %rsi     # 0xbcdea
callq 0x18abe
movq %rax, %rdi
movq %rbx, %rsi
callq 0x18a16
movq %rax, %rbp
cmpb $0x1, 0x188(%rax)
jne 0x812a4
movq %rbp, %rdi
addq $0x10, %rdi
movl %r14d, %esi
callq 0x22f0
movq %rbp, %rdi
leaq 0x370bb(%rip), %rsi     # 0xb8369
callq 0x18a16
movq %r12, %rdi
callq 0xbf62
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x812d6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
addq %r15, %r14
decq %r13
jne 0x811e3
movq 0x20(%rsp), %rax
addq $0x4, %rax
cmpq $0xc, %rax
jne 0x811d0
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x81310
movq %rax, %rbx
jmp 0x8131d
jmp 0x81310
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0xbf62
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x81338
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc036
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/shape.cpp
// Function: nda::test_shape_1d_dense_body()
TEST(shape_1d_dense) {
  dense_dim<> x(0, 10);
  shape<dense_dim<>> s(x);
  for (int i : x) {
    ASSERT_EQ(s(i), i);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
leaq 0x28(%rsp), %rbx
movq $0x0, (%rbx)
movq $0xa, 0x8(%rbx)
movq $0x1, 0x10(%rbx)
xorl %r14d, %r14d
xorl %edi, %edi
movq %rbx, %rsi
callq 0xd09f
leaq 0x8(%rsp), %r13
leaq 0x202c6(%rip), %rbp     # 0xa1654
leaq 0x23f95(%rip), %r12     # 0xa532a
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r13, %rdi
leaq 0x3ba5b(%rip), %rsi     # 0xbce04
leaq 0x3ba5d(%rip), %rdx     # 0xbce0d
callq 0xd0b8
movq %rbx, %rdi
movl $0x1, %esi
movq %r13, %rdx
callq 0xbf0a
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x18a16
movq %rax, %rdi
leaq 0x2b020(%rip), %rsi     # 0xac3fa
callq 0x18a4e
movq %rax, %rdi
movq %r12, %rsi
callq 0x18a16
movq %rax, %r15
cmpb $0x1, 0x188(%rax)
jne 0x81405
movq %r15, %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x21b0
movq %r15, %rdi
movq %rbp, %rsi
callq 0x18a16
movq %rax, %rdi
leaq 0x36f94(%rip), %rsi     # 0xb83ae
callq 0x18a16
movq %rax, %rdi
movq %r12, %rsi
callq 0x18a16
movq %rax, %r15
cmpb $0x1, 0x188(%rax)
jne 0x81445
movq %r15, %rdi
addq $0x10, %rdi
movl %r14d, %esi
callq 0x22f0
movq %r15, %rdi
leaq 0x36f1a(%rip), %rsi     # 0xb8369
callq 0x18a16
movq %rbx, %rdi
callq 0xbf62
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x81478
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
incq %r14
cmpq $0xa, %r14
jne 0x81395
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x814ab
jmp 0x8149e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbf62
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x814c7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc036
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/shape.cpp
// Function: nda::test_shape_2d_body()
TEST(shape_2d) {
  dense_dim<> x(0, 10);
  dim<> y(0, 5, x.extent());
  shape<dense_dim<>, dim<>> s(x, y);
  for (int i : y) {
    for (int j : x) {
      ASSERT_EQ(s(j, i), i * x.extent() + j);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
leaq 0x28(%rsp), %rbx
movq $0x0, (%rbx)
movq $0xa, 0x8(%rbx)
movq $0x1, 0x10(%rbx)
xorl %r12d, %r12d
xorl %edi, %edi
movq %rbx, %rsi
callq 0xd09f
leaq 0x18(%rsp), %r15
xorl %eax, %eax
movq %rax, (%rsp)
xorl %r13d, %r13d
movq %r15, 0x8(%rsp)
leaq 0x8(%rsp), %r14
movq %r14, %rdi
leaq 0x3b8db(%rip), %rsi     # 0xbce0e
leaq 0x3b8f1(%rip), %rdx     # 0xbce2b
callq 0xd0b8
movq %rbx, %rdi
movl $0x1, %esi
movq %r14, %rdx
callq 0xbf0a
movq %rbx, %rdi
leaq 0x200fb(%rip), %rsi     # 0xa1654
callq 0x18a16
movq %rax, %rdi
leaq 0x3b8c4(%rip), %rsi     # 0xbce2c
callq 0x18af6
movq %rax, %rdi
leaq 0x23db3(%rip), %rsi     # 0xa532a
callq 0x18a16
movq %rax, %rbp
movq %r15, %r14
leaq (%r12,%r13), %r15
cmpb $0x1, 0x188(%rax)
jne 0x8159e
movq %rbp, %rdi
addq $0x10, %rdi
movq %r15, %rsi
callq 0x21b0
movq %rbp, %rdi
leaq 0x200ac(%rip), %rsi     # 0xa1654
callq 0x18a16
movq %rax, %rdi
leaq 0x3b862(%rip), %rsi     # 0xbce19
callq 0x18c46
movq %rax, %rdi
leaq 0x23d64(%rip), %rsi     # 0xa532a
callq 0x18a16
movq %rax, %rbp
cmpb $0x1, 0x188(%rax)
jne 0x815e6
movq %rbp, %rdi
addq $0x10, %rdi
movq %r15, %rsi
callq 0x21b0
movq %rbp, %rdi
leaq 0x36d79(%rip), %rsi     # 0xb8369
callq 0x18a16
movq %rbx, %rdi
movq %r14, %r15
callq 0xbf62
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x81617
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
incq %r13
cmpq $0xa, %r13
jne 0x8151f
movq (%rsp), %rax
incq %rax
addq $0xa, %r12
cmpq $0x5, %rax
jne 0x81518
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x81657
movq %rax, %rbx
jmp 0x81667
movq %rax, %rbx
jmp 0x8165d
movq %rax, %rbx
movq %r14, %r15
leaq 0x28(%rsp), %rdi
callq 0xbf62
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8167e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc036
// File: /workspace/github_cpp_makefile_star2_O1/dsharlet[P]array/test/shape.cpp
// Function: nda::test_clamp_body()
TEST(clamp) {
  dim<> x(5, 10, 1);
  for (int i = -10; i < 20; i++) {
    int correct = std::max(std::min(i, 14), 5);
    ASSERT_EQ(clamp(i, x), correct);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movl $0xfffffff6, %r13d      # imm = 0xFFFFFFF6
leaq 0x28(%rsp), %r12
leaq 0x210d0(%rip), %rbx     # 0xa532a
cmpl $0xe, %r13d
movl $0xe, %r14d
cmovll %r13d, %r14d
cmpl $0x6, %r14d
movl $0x5, %eax
cmovll %eax, %r14d
cmpl $0x6, %r13d
movl $0x5, %ebp
cmovgel %r13d, %ebp
cmpq $0xe, %rbp
movl $0xe, %eax
cmovgeq %rax, %rbp
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %r15
movq %r15, %rdi
leaq 0x3904b(%rip), %rsi     # 0xbd2f3
leaq 0x3905a(%rip), %rdx     # 0xbd309
callq 0xd0b8
xorl %esi, %esi
cmpq %r14, %rbp
sete %sil
movq %r12, %rdi
movq %r15, %rdx
callq 0xbf0a
movq %r12, %rdi
leaq 0x1d382(%rip), %rsi     # 0xa1654
callq 0x18a16
movq %rax, %rdi
leaq 0x39029(%rip), %rsi     # 0xbd30a
callq 0x56a5c
movq %rax, %rdi
movq %rbx, %rsi
callq 0x18a16
movq %rax, %r15
cmpb $0x1, 0x188(%rax)
jne 0x8430c
movq %r15, %rdi
addq $0x10, %rdi
movq %rbp, %rsi
callq 0x21b0
movq %r15, %rdi
leaq 0x1d33e(%rip), %rsi     # 0xa1654
callq 0x18a16
movq %rax, %rdi
leaq 0x38fdd(%rip), %rsi     # 0xbd302
callq 0x18af6
movq %rax, %rdi
movq %rbx, %rsi
callq 0x18a16
movq %rax, %r15
cmpb $0x1, 0x188(%rax)
jne 0x84350
movq %r15, %rdi
addq $0x10, %rdi
movl %r14d, %esi
callq 0x22f0
movq %r15, %rdi
leaq 0x3400f(%rip), %rsi     # 0xb8369
callq 0x18a16
movq %r12, %rdi
callq 0xbf62
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x84383
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
incl %r13d
cmpl $0x14, %r13d
jne 0x8425a
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x843b6
jmp 0x843a9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0xbf62
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x843d2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc036