LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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), %r11
movb $0x1, %dl
movq %r11, %r9
negq %r9
jo 0x40bac
cmpq $0x1, %rsi
jne 0x40b88
movq %rdi, %r9
negq %r9
cmovsq %rdi, %r9
movq %r11, %r10
negq %r10
cmovsq %r11, %r10
cmpq %r10, %r9
jne 0x40b92
movq 0x8(%rcx), %rcx
xorl %edx, %edx
cmpq %rax, %rcx
jne 0x40bc5
jmp 0x40bff
movq %r11, %r10
negq %r10
cmovsq %r11, %r10
leaq (,%r10,4), %r9
cmpq %rdi, %r9
jle 0x40bac
movq %rsi, %rdx
imulq %rdi, %rdx
cmpq %rdx, %r10
setge %dl
movq 0x8(%rcx), %rcx
cmpq %rax, %rcx
je 0x40bff
cmpq $0x1, %rsi
jne 0x40bdb
movq %rdi, %r9
negq %r9
cmovsq %rdi, %r9
movq %rcx, %r10
negq %r10
cmovsq %rcx, %r10
movl $0x1, %ecx
cmpq %r10, %r9
jne 0x40be5
jmp 0x40c01
movq %rcx, %r10
negq %r10
cmovsq %rcx, %r10
leaq (%r10,%r10,4), %rcx
cmpq %rdi, %rcx
jle 0x40bff
movq %rsi, %r9
imulq %rdi, %r9
xorl %ecx, %ecx
cmpq %r9, %r10
setl %cl
jmp 0x40c01
xorl %ecx, %ecx
movq 0x8(%r8), %r8
cmpq %rax, %r8
je 0x40c58
cmpq $0x1, %rsi
jne 0x40c31
movq %rdi, %r10
negq %r10
cmovsq %rdi, %r10
movq %r8, %r9
negq %r9
cmovsq %r8, %r9
movl $0x1, %r8d
cmpq %r9, %r10
jne 0x40c3b
jmp 0x40c5b
movq %r8, %r9
negq %r9
cmovsq %r8, %r9
leaq (%r9,%r9), %r8
leaq (%r8,%r8,2), %r8
cmpq %rdi, %r8
jle 0x40c58
imulq %rdi, %rsi
xorl %r8d, %r8d
cmpq %rsi, %r9
setl %r8b
jmp 0x40c5b
xorl %r8d, %r8d
xorb $0x1, %dl
movzbl %dl, %edx
addq %rdx, %rcx
decq %rax
orq %r8, %rcx
cmoveq %rdi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd25d
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xd25e
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_O3/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 0xd51e
testq %rax, %rax
je 0xd4ca
movq 0x50(%rbx), %rax
cmpq 0x50(%r14), %rax
jne 0xd4ca
movq 0x58(%r14), %rax
cmpq %rax, 0x58(%rbx)
jne 0xd4ca
leaq 0x20(%r14), %rsi
leaq 0x20(%rbx), %rdi
callq 0xd690
testb %al, %al
je 0xd4ca
movq %rbx, %rdi
callq 0xd25e
jmp 0xd50c
movq %rbx, %rdi
callq 0xd206
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 0xc30a
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd5da
testq %rax, %rax
je 0xd56d
movq 0x50(%rbx), %rax
cmpq 0x50(%r14), %rax
jne 0xd54e
movq 0x58(%r14), %rax
cmpq %rax, 0x58(%rbx)
jne 0xd54e
addq $0x20, %r14
addq $0x20, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd690
testb %al, %al
jne 0xd5b2
leaq 0x963fc(%rip), %rdi     # 0xa3951
leaq 0x95bc1(%rip), %rsi     # 0xa311d
leaq 0x96405(%rip), %rcx     # 0xa3968
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 0xd5ba
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x95c3d(%rip), %rdi     # 0xa31fe
leaq 0x95b55(%rip), %rsi     # 0xa311d
leaq 0x96399(%rip), %rcx     # 0xa3968
movl $0x9bc, %edx            # imm = 0x9BC
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq 0x58(%rdi), %rax
jne 0xd605
movq 0x40(%rbx), %rcx
imulq %rax, %rcx
imulq 0x28(%rbx), %rcx
testq %rcx, %rcx
jg 0xd670
movq 0x50(%rbx), %rcx
cmpq 0x50(%r14), %rcx
jne 0xd651
cmpq 0x58(%r14), %rax
jne 0xd651
leaq 0x20(%rbx), %r15
leaq 0x20(%r14), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xd690
testb %al, %al
je 0xd651
movq 0x18(%r14), %rsi
movq 0x18(%rbx), %rcx
movq %rsp, %r8
movq %rbx, (%r8)
movq %r12, %rdi
movq %r15, %rdx
callq 0xd6a2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x962f9(%rip), %rdi     # 0xa3951
leaq 0x95abe(%rip), %rsi     # 0xa311d
leaq 0x963e0(%rip), %rcx     # 0xa3a46
movl $0x900, %edx            # imm = 0x900
callq 0x2100
leaq 0x95b7e(%rip), %rdi     # 0xa31f5
leaq 0x95a9f(%rip), %rsi     # 0xa311d
leaq 0x963c1(%rip), %rcx     # 0xa3a46
movl $0x8ff, %edx            # imm = 0x8FF
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x735a4
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 0x735b6
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 0x735b6
movq (%rsi), %rbx
addq $0x8, %rsi
movq (%rdx), %r14
addq $0x8, %rdx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x735d5
leaq 0x50(%rsp), %rcx
leaq -0x66816(%rip), %r9     # 0xcd7d
movq %rcx, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %r8
callq 0x5c9e0
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2fde1(%rip), %rdi     # 0xa339e
leaq 0x2fb59(%rip), %rsi     # 0xa311d
leaq 0x45277(%rip), %rcx     # 0xb8842
movl $0xad0, %edx            # imm = 0xAD0
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf217
movq 0x20(%rdx), %rsi
movq 0x20(%rdi), %r8
cmpq %rsi, %r8
jg 0xf219
movq 0x28(%rdi), %r9
addq %r8, %r9
cmpq %rsi, %r9
jle 0xf219
movq 0x8(%rdx), %r10
movq 0x8(%rdi), %r11
cmpq %r10, %r11
jg 0xf219
movq 0x10(%rdi), %rbx
addq %r11, %rbx
cmpq %r10, %rbx
jle 0xf219
addq %rsi, %rcx
decq %rcx
cmpq %rcx, %r8
jg 0xf219
cmpq %rcx, %r9
jle 0xf219
addq %r10, %rax
decq %rax
cmpq %rax, %r11
jg 0xf219
cmpq %rax, %rbx
jle 0xf219
movq (%rdi), %rsi
addq $0x8, %rdi
movq (%rdx), %rcx
addq $0x8, %rdx
leaq 0x1d6(%rip), %r8        # 0xf3e7
popq %rbx
jmp 0xf238
popq %rbx
retq
leaq 0x9417e(%rip), %rdi     # 0xa339e
leaq 0x93ef6(%rip), %rsi     # 0xa311d
leaq 0x954e5(%rip), %rcx     # 0xa4713
movl $0xb17, %edx            # imm = 0xB17
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf3ec
movq 0x18(%rbx), %rax
testq %rax, %rax
je 0x16c29
movl $0x3, (%rax)
leaq 0x48(%rsp), %rdi
callq 0x203cc
movq 0x18(%rsp), %rax
movl (%rax), %ebx
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x8e5eb(%rip), %rsi     # 0xa50f4
leaq 0x8e5f1(%rip), %rdx     # 0xa5101
leaq 0x28(%rsp), %rdi
callq 0xd14c
xorl %esi, %esi
cmpl $0x3, %ebx
sete %sil
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0xbf80
leaq 0x8cb4b(%rip), %rsi     # 0xa3684
leaq 0x48(%rsp), %rdi
callq 0x18fba
leaq 0x8e5b8(%rip), %rsi     # 0xa5102
movq %rax, %rdi
callq 0x1a146
leaq 0x906fd(%rip), %rsi     # 0xa7256
movq %rax, %rdi
callq 0x18fba
movq %rax, %rbx
cmpb $0x1, 0x188(%rax)
jne 0x16b80
movq 0x18(%rsp), %rax
movq %rbx, %rdi
addq $0x10, %rdi
movl (%rax), %esi
callq 0x22f0
leaq 0x8cafd(%rip), %rsi     # 0xa3684
movq %rbx, %rdi
callq 0x18fba
leaq 0x96dc3(%rip), %rsi     # 0xad959
movq %rax, %rdi
callq 0x18fba
leaq 0x906b1(%rip), %rsi     # 0xa7256
movq %rax, %rdi
callq 0x18fba
movq %rax, %rbx
cmpb $0x1, 0x188(%rax)
jne 0x16bca
movq %rbx, %rdi
addq $0x10, %rdi
movl $0x3, %esi
callq 0x22f0
leaq 0xa36c8(%rip), %rsi     # 0xba299
movq %rbx, %rdi
callq 0x18fba
leaq 0x48(%rsp), %rdi
callq 0xbfd8
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x16bfa
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21f0
cmpq $0x0, 0x18(%rsp)
je 0x16c1e
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
shlq $0x2, %rsi
callq 0x21f0
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
retq
leaq 0x8c6ab(%rip), %rdi     # 0xa32db
leaq 0x8c4e6(%rip), %rsi     # 0xa311d
leaq 0x90910(%rip), %rcx     # 0xa754e
movl $0x6a1, %edx            # imm = 0x6A1
callq 0x2100
movq %rax, %rbx
jmp 0x16c78
jmp 0x16c54
movq %rax, %rbx
jmp 0x16c61
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0xbfd8
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x16c78
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21f0
cmpq $0x0, 0x18(%rsp)
je 0x16c9c
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
shlq $0x2, %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc0a9
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a8cc
movq %r14, %rdi
callq 0x1a9a6
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 0x1d948
leaq 0x18(%rsp), %rdi
leaq 0x118(%rsp), %rsi
xorl %edx, %edx
callq 0x1a6b1
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 0x200de
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 0x213d5
leaq 0x118(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x19484
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0x1d848
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 0x1f848
leaq 0x18(%rsp), %rdi
callq 0xe84a
leaq 0x118(%rsp), %rdi
callq 0x1d848
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1897b
jmp 0x1897b
jmp 0x18950
jmp 0x1897b
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x1d848
jmp 0x18953
jmp 0x1897b
jmp 0x18950
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0xe84a
jmp 0x18964
jmp 0x18961
movq %rax, %rbx
leaq 0x118(%rsp), %rdi
callq 0x1d848
movq %rbx, %rdi
callq 0x2300
jmp 0x1897b
movq %rax, %rdi
callq 0xc0a9
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe84a
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 0xe236
movq %rbx, %rdi
popq %rbx
jmp 0xe334
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4ec55
movq %rbx, %rdi
callq 0x4f690
jmp 0x4ed1f
testq %rax, %rax
je 0x4ecb1
movq 0xd0(%rbx), %rax
cmpq 0xd0(%rsi), %rax
jne 0x4ec92
movq 0xd8(%rsi), %rax
cmpq %rax, 0xd8(%rbx)
jne 0x4ec92
movl $0xa0, %edi
addq %rdi, %rsi
addq %rbx, %rdi
callq 0xd690
testb %al, %al
jne 0x4ed1f
leaq 0x54cb8(%rip), %rdi     # 0xa3951
leaq 0x5447d(%rip), %rsi     # 0xa311d
leaq 0x60a16(%rip), %rcx     # 0xaf6bd
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 0x4ed24
movq %rbx, %rax
popq %rbx
retq
leaq 0x544d3(%rip), %rdi     # 0xa31fe
leaq 0x543eb(%rip), %rsi     # 0xa311d
leaq 0x60984(%rip), %rcx     # 0xaf6bd
movl $0x98a, %edx            # imm = 0x98A
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/include/array/array.h
// Function: nda::array<float, nda::shape<nda::dim<0l, -9l, 1l>, nda::dim<0l, -9l, -9l>>, std::allocator<float>>::assign(nda::shape<nda::dim<0l, -9l, 1l>, nda::dim<0l, -9l, -9l>>, float 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
movq 0x10(%rsi), %rax
movq %rax, %rcx
negq %rcx
jno 0x7eb49
movq 0x8(%r15), %rdi
movq %r15, %rsi
callq 0x7e8f1
movq %rax, 0x10(%r15)
movq 0x40(%r14), %rcx
cmpq 0x20(%r15), %rcx
jne 0x7eb6d
movq 0x28(%r14), %rcx
cmpq 0x8(%r15), %rcx
jne 0x7eb6d
cmpq %rax, 0x30(%r14)
jne 0x7eb6d
movq %r14, %rdi
callq 0x7ef60
jmp 0x7eba5
leaq 0x20(%r14), %r12
movq %r14, %rdi
callq 0x7efa8
movb 0x28(%r15), %al
movb %al, 0x48(%r14)
movups 0x18(%r15), %xmm0
movups %xmm0, 0x38(%r14)
movq 0x10(%r15), %rax
movq %rax, 0x10(%r12)
movups (%r15), %xmm0
movups %xmm0, (%r12)
movq %r14, %rdi
callq 0x7ebbc
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x7eff6
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1dd08
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
je 0x1da86
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 0x1da94
movb (%r13), %al
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x86941(%rip), %rsi     # 0xa7262
movl $0x1, %edx
callq 0x2210
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x21b0
leaq 0x86927(%rip), %rsi     # 0xa7264
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_O3/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 0x87578(%rip), %rsi     # 0xa7359
movl $0x4, %edx
callq 0x2210
movl $0x1, %ecx
movq %rbx, %rdi
movq $-0x9, %rsi
movq $-0x9, %rdx
callq 0x1f37e
leaq 0x87551(%rip), %rsi     # 0xa735e
movl $0x2, %edx
movq %rbx, %rdi
callq 0x2210
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movl $0x1, %ecx
movq %rbx, %rdi
callq 0x1f37e
leaq 0x850ee(%rip), %rsi     # 0xa4f23
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2210
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x212e2
testb %al, %al
je 0x212c2
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 0xe236
movq %r14, %rdi
callq 0xe334
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
shlq $0x2, %rbx
addq 0x18(%r15), %rbx
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)
movq %rbx, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x868a9(%rip), %rdi     # 0xa7b72
leaq 0x81e4d(%rip), %rsi     # 0xa311d
leaq 0x868c8(%rip), %rcx     # 0xa7b9f
movl $0xbee, %edx            # imm = 0xBEE
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x40221
cmpb $0x0, 0x100(%rdi)
jne 0x40221
movb $0x1, 0x100(%rdi)
movq %rdi, %rax
retq
testq %rsi, %rsi
js 0x4022e
movq %rsi, %rdi
jmp 0x21e0
pushq %rax
callq 0x2060
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4f65e
shlq $0x2, %rdx
movq %rsi, %rdi
movq %rdx, %rsi
jmp 0x21f0
cmpb $0x0, 0x80(%rdi)
je 0x4f66f
movb $0x0, 0x80(%rdi)
retq
pushq %rax
leaq 0x597d9(%rip), %rdi     # 0xa8e50
leaq 0x53a9f(%rip), %rsi     # 0xa311d
leaq 0x5fd73(%rip), %rcx     # 0xaf3f8
movl $0xc57, %edx            # imm = 0xC57
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rsi, %rbx
movq %rdi, %r14
movl $0x0, (%rdi)
incq 0xa31d0(%rip)           # 0xe7260
leaq 0x20(%rdi), %rax
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x8(%rdi)
movq $0x0, 0x28(%rdi)
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
movq %rdx, 0x30(%rdi)
leaq 0x38(%rdi), %rcx
movups %xmm0, 0x38(%rdi)
movq %rdx, 0x48(%rdi)
cmpl $0x0, (%rsi)
je 0x440fc
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 0x3fd78
movq %r14, %rdi
movq %rbx, %rsi
callq 0x441a0
jmp 0x44188
movq 0x8(%rbx), %rdx
movq %rdx, 0x8(%r14)
xorl %edx, %edx
movq %rdx, 0x8(%rbx)
movq 0x10(%rbx), %rsi
movq %rsi, 0x10(%r14)
movq %rdx, 0x10(%rbx)
movq 0x18(%r14), %rdx
movq 0x18(%rbx), %rsi
movq %rsi, 0x18(%r14)
movq %rdx, 0x18(%rbx)
movq 0x10(%rax), %rdx
movq %rdx, 0x10(%rsp)
movups (%rax), %xmm0
movaps %xmm0, (%rsp)
movq 0x10(%rcx), %rdx
movq %rdx, 0x28(%rsp)
movups (%rcx), %xmm0
movups %xmm0, 0x18(%rsp)
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 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 0xa30d9(%rip)           # 0xe7270
movq %rax, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq 0xd8(%rdi), %rax
jne 0x4fc13
movq 0xc0(%rbx), %rcx
imulq %rax, %rcx
imulq 0xa8(%rbx), %rcx
testq %rcx, %rcx
jg 0x4fc92
movq 0xd0(%rbx), %rcx
cmpq 0xd0(%r14), %rcx
jne 0x4fc73
cmpq 0xd8(%r14), %rax
jne 0x4fc73
movl $0xa0, %r12d
leaq (%rbx,%r12), %r15
addq %r14, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0xd690
testb %al, %al
je 0x4fc73
movq 0x98(%r14), %rsi
movq 0x98(%rbx), %rcx
movq %rsp, %r8
movq %rbx, (%r8)
movq %r12, %rdi
movq %r15, %rdx
callq 0x4fcb2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x53cd7(%rip), %rdi     # 0xa3951
leaq 0x5349c(%rip), %rsi     # 0xa311d
leaq 0x5fb81(%rip), %rcx     # 0xaf809
movl $0x906, %edx            # imm = 0x906
callq 0x2100
leaq 0x5355c(%rip), %rdi     # 0xa31f5
leaq 0x5347d(%rip), %rsi     # 0xa311d
leaq 0x5fb62(%rip), %rcx     # 0xaf809
movl $0x905, %edx            # imm = 0x905
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5002c
testq %rax, %rax
je 0x4ffb4
movq 0xd0(%rbx), %rax
cmpq 0xd0(%r14), %rax
jne 0x4ffb4
movq 0xd8(%r14), %rax
cmpq %rax, 0xd8(%rbx)
jne 0x4ffb4
movl $0xa0, %edi
leaq (%r14,%rdi), %rsi
addq %rbx, %rdi
callq 0xd690
testb %al, %al
je 0x4ffb4
movq %rbx, %rdi
callq 0x4f598
jmp 0x5001a
movq %rbx, %rdi
callq 0x4f522
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 0x4f218
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x4fbdc
testq %rax, %rax
je 0x5008e
movq 0xd0(%rbx), %rax
cmpq 0xd0(%r14), %rax
jne 0x5006f
movq 0xd8(%r14), %rax
cmpq %rax, 0xd8(%rbx)
jne 0x5006f
movl $0xa0, %eax
addq %rax, %r14
addq %rax, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd690
testb %al, %al
jne 0x50100
leaq 0x538db(%rip), %rdi     # 0xa3951
leaq 0x530a0(%rip), %rsi     # 0xa311d
leaq 0x5fb2c(%rip), %rcx     # 0xafbb0
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 0x50108
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x530ef(%rip), %rdi     # 0xa31fe
leaq 0x53007(%rip), %rsi     # 0xa311d
leaq 0x5fa93(%rip), %rcx     # 0xafbb0
movl $0x9cf, %edx            # imm = 0x9CF
callq 0x2100
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x20(%rsp)
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
movq %rax, 0x30(%rsp)
movups %xmm0, 0x38(%rsp)
movq %rax, 0x48(%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
xorl %eax, %eax
movq %rax, 0x8(%rsi)
movq 0x10(%rsi), %rcx
movq %rcx, 0x10(%rsp)
movq %rax, 0x10(%rsi)
movq 0x18(%rsi), %rcx
movq %rcx, 0x18(%rsp)
movq %rax, 0x18(%rsi)
movq 0x30(%rsp), %rax
movq %rax, 0x60(%rsp)
movups 0x20(%rsp), %xmm0
movaps %xmm0, 0x50(%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)
movaps 0x50(%rsp), %xmm0
movups %xmm0, 0x20(%rsi)
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x454dc
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x454dc
movq %rsp, %rdi
callq 0x3f83e
addq $0x80, %rsp
popq %rbx
retq
jmp 0x4689d
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3f83e
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc0a9
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd133
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x64f60(%rip), %rsi     # 0xae2a3
leaq 0x64f69(%rip), %rdx     # 0xae2b3
leaq 0x8(%rsp), %rdi
callq 0xd14c
leaq 0x4d8(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf80
leaq 0x4d8(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4938f
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 0xd133
movq %r14, (%rbx)
leaq 0x64ee7(%rip), %rsi     # 0xae2a3
leaq 0x64ef0(%rip), %rdx     # 0xae2b3
leaq 0x8(%rsp), %rdi
callq 0xd14c
leaq 0x348(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf80
leaq 0x348(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x49408
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x64e9d(%rip), %rsi     # 0xae2b4
leaq 0x64ea9(%rip), %rdx     # 0xae2c7
callq 0xd14c
leaq 0x1b8(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf80
leaq 0x1b8(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x4945e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x64e5b(%rip), %rsi     # 0xae2c8
leaq 0x64e6b(%rip), %rdx     # 0xae2df
callq 0xd14c
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movl $0x1, %esi
callq 0xbf80
leaq 0x28(%rsp), %rdi
callq 0xbfd8
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x494ae
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
addq $0x668, %rsp            # imm = 0x668
popq %rbx
popq %r14
retq
jmp 0x494bf
jmp 0x494bf
jmp 0x494bf
movq %rax, %rbx
jmp 0x494e4
jmp 0x494ca
jmp 0x494ca
jmp 0x494ca
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x494e4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O3/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 0x580ab(%rip), %rsi     # 0xa30d3
leaq 0x580aa(%rip), %rdx     # 0xa30d9
movq %rsp, %r15
movq %r15, %rdi
callq 0xd14c
leaq 0x20(%rsp), %rdi
movl %ebp, %esi
movq %r15, %rdx
callq 0xbf80
leaq 0x58634(%rip), %rsi     # 0xa3684
leaq 0x20(%rsp), %rdi
callq 0x18fba
leaq 0x63ff8(%rip), %rsi     # 0xaf059
movq %rax, %rdi
callq 0x18fba
leaq 0x5c1e6(%rip), %rsi     # 0xa7256
movq %rax, %rdi
callq 0x18fba
movq %rax, %r15
cmpb $0x1, 0x188(%rax)
jne 0x4b093
movq %r15, %rdi
addq $0x10, %rdi
movq %r14, %rsi
callq 0x4c9be
leaq 0x585ea(%rip), %rsi     # 0xa3684
movq %r15, %rdi
callq 0x18fba
leaq 0x59f4f(%rip), %rsi     # 0xa4ff8
movq %rax, %rdi
callq 0x18fba
leaq 0x5c19e(%rip), %rsi     # 0xa7256
movq %rax, %rdi
callq 0x18fba
movq %rax, %r14
cmpb $0x1, 0x188(%rax)
jne 0x4b0db
movq %r14, %rdi
addq $0x10, %rdi
movq %rbx, %rsi
callq 0x4c9be
leaq 0x6f1b7(%rip), %rsi     # 0xba299
movq %r14, %rdi
callq 0x18fba
leaq 0x20(%rsp), %rdi
callq 0xbfd8
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4b10a
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 0x4b12e
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0xbfd8
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x4b144
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x2300
movq %rax, %rdi
callq 0xc0a9
// File: /workspace/github_cpp_makefile_star2_O3/dsharlet[P]array/include/array/array.h
// Function: void nda::internal::assert_dim_compatible<nda::dim<0l, 1l, 0l>, 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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %r15
testq %r15, %r15
jne 0x59ebf
movabsq $0x7fffffffffffffff, %r12 # imm = 0x7FFFFFFFFFFFFFFF
movq 0x8(%r14), %r8
cmpq $0x1, %r8
jne 0x59ee1
movq 0x10(%r14), %r8
testq %r12, %r8
jne 0x59f0a
testq %r15, %r15
jne 0x59f27
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x8d10a(%rip), %rax     # 0xe6fd0
movq (%rax), %rdi
leaq 0x54a8c(%rip), %rsi     # 0xae95c
movq %rbx, %rdx
xorl %ecx, %ecx
movq %r15, %r8
xorl %eax, %eax
callq 0x2240
jmp 0x59e91
movq 0x8d0e8(%rip), %rax     # 0xe6fd0
movq (%rax), %rdi
leaq 0x54b1b(%rip), %rsi     # 0xaea0d
movl $0x1, %ecx
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2240
movq 0x10(%r14), %r8
testq %r12, %r8
je 0x59f27
movq 0x8d0bf(%rip), %rax     # 0xe6fd0
movq (%rax), %rdi
leaq 0x4972c(%rip), %rsi     # 0xa3647
movq %rbx, %rdx
xorl %ecx, %ecx
xorl %eax, %eax
callq 0x2240
leaq 0x493a2(%rip), %rdi     # 0xa32d0
leaq 0x491e8(%rip), %rsi     # 0xa311d
leaq 0x58151(%rip), %rcx     # 0xb208d
movl $0x3f5, %edx            # imm = 0x3F5
callq 0x2100
// File: /workspace/github_cpp_makefile_star2_O3/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)
movq 0x48(%rdi), %rax
movq %rax, 0x10(%rsi)
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x58d3d
movq 0x28(%rbx), %rax
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, 0x8(%rsi)
movq %r15, 0x10(%rsi)
movl $0x1, %edi
callq 0x58d4e
movq 0x18(%rbx), %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %r14, 0x8(%rsi)
movq %r15, 0x10(%rsi)
movl $0x2, %edi
callq 0x58d4e
movups (%rbx), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x1, 0x10(%rsi)
movl $0x3, %edi
callq 0xd133
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4c30e
movups 0x60(%r14), %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
movq $0x1, 0x10(%rsi)
xorl %edi, %edi
callq 0xd133
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_O3/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 0x58026
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 0x4b2ad(%rip), %rdi     # 0xa32db
leaq 0x4b0e8(%rip), %rsi     # 0xa311d
leaq 0x5852b(%rip), %rcx     # 0xb0567
movl $0x6a1, %edx            # imm = 0x6A1
callq 0x2100