idx
int64 0
2.11M
| name
stringlengths 1
118k
| code
stringlengths 6
516k
| asm
stringlengths 21
4.64M
| file
stringlengths 39
143
| opt
stringclasses 1
value | path
stringlengths 20
133
|
|---|---|---|---|---|---|---|
1,500 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::neq_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)>(long, long, Omega_h::Read<signed char> Omega_h::neq_each<long>(Omega_h::Read<long>, Omega_h::Read<long>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x268ad8
jmp 0x268b67
movq 0x48f1a9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1ba6a0
movq 0x48f192(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x268b5e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x70(%rbp), %rdi
callq 0x1c49d0
jmp 0x268b30
jmp 0x268b32
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x268af9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1d6d30
jmp 0x268b70
leaq -0x70(%rbp), %rdi
callq 0x1d6d30
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,501 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<long> Omega_h::get_component<long>(Omega_h::Read<long>, int, int)::'lambda'(int)>(long, long, Omega_h::Read<long> Omega_h::get_component<long>(Omega_h::Read<long>, int, int)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x268db8
jmp 0x268e47
movq 0x48eec9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1ded20
movq 0x48eeb2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x268e3e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1dd250
jmp 0x268e10
jmp 0x268e12
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x268dd9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1bcdc0
jmp 0x268e50
leaq -0x68(%rbp), %rdi
callq 0x1bcdc0
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,502 | void Omega_h::set_component<long>(Omega_h::Write<long>, Omega_h::Read<long>, int, int)::'lambda'(int)::('lambda'(int) const&) | void set_component(Write<T> out, Read<T> a, Int ncomps, Int comp) {
auto f = OMEGA_H_LAMBDA(LO i) { out[i * ncomps + comp] = a[i]; };
parallel_for(a.size(), f, "set_component");
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c78d0
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x1c3090
jmp 0x268fb4
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1e1240
movq -0x18(%rbp), %rdi
callq 0x1dfa40
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,503 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::set_component<long>(Omega_h::Write<long>, Omega_h::Read<long>, int, int)::'lambda'(int)>(long, long, void Omega_h::set_component<long>(Omega_h::Write<long>, Omega_h::Read<long>, int, int)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x269018
jmp 0x2690a7
movq 0x48ec69(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1e4b20
movq 0x48ec52(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26909e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1d1b30
jmp 0x269070
jmp 0x269072
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x269039
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1be190
jmp 0x2690b0
leaq -0x68(%rbp), %rdi
callq 0x1be190
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,504 | void Omega_h::set_component<long>(Omega_h::Write<long>, Omega_h::Read<long>, int, int)::'lambda'(int)::('lambda'(int)&&) | void set_component(Write<T> out, Read<T> a, Int ncomps, Int comp) {
auto f = OMEGA_H_LAMBDA(LO i) { out[i * ncomps + comp] = a[i]; };
parallel_for(a.size(), f, "set_component");
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1bd640
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x1d7940
jmp 0x269104
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1e1240
movq -0x18(%rbp), %rdi
callq 0x1dfa40
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,505 | void Omega_h::set_component<long>(Omega_h::Write<long>, Omega_h::Read<long>, int, int)::'lambda'(int)::operator()(int) const | void set_component(Write<T> out, Read<T> a, Int ncomps, Int comp) {
auto f = OMEGA_H_LAMBDA(LO i) { out[i * ncomps + comp] = a[i]; };
parallel_for(a.size(), f, "set_component");
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x58(%rbp)
movl %esi, -0x5c(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x18, %rdx
movl -0x5c(%rbp), %eax
movq %rdx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rdx
movl -0x4c(%rbp), %eax
movq %rdx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x3c(%rbp), %rdx
movq (%rax,%rdx,8), %rdx
movl -0x5c(%rbp), %eax
imull 0x10(%rcx), %eax
addl 0x14(%rcx), %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,506 | std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>::begin() const | const_iterator
begin() const _GLIBCXX_NOEXCEPT
{ return const_iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1da8b0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,507 | std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>::end() const | const_iterator
end() const _GLIBCXX_NOEXCEPT
{ return const_iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x1da8b0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,508 | _gnu_cxx::__normal_iterator<Omega_h::Read<long> const*, std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>>::__normal_iterator(Omega_h::Read<long> const* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
1,509 | _gnu_cxx::__normal_iterator<Omega_h::Read<long>*, std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>>::__normal_iterator(Omega_h::Read<long>* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
1,510 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<long> Omega_h::interleave<long>(std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>)::'lambda'(int)>(long, long, Omega_h::Read<long> Omega_h::interleave<long>(std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x2694d8
jmp 0x269567
movq 0x48e7a9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1dea00
movq 0x48e792(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26955e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1d1640
jmp 0x269530
jmp 0x269532
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2694f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c6300
jmp 0x269570
leaq -0x68(%rbp), %rdi
callq 0x1c6300
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,511 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<long> Omega_h::coalesce<long>(std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>)::'lambda'(int)>(long, long, Omega_h::Read<long> Omega_h::coalesce<long>(std::vector<Omega_h::Read<long>, std::allocator<Omega_h::Read<long>>>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x269728
jmp 0x2697b7
movq 0x48e559(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1e1ab0
movq 0x48e542(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x2697ae
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1d8bf0
jmp 0x269780
jmp 0x269782
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x269749
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1ca130
jmp 0x2697c0
leaq -0x68(%rbp), %rdi
callq 0x1ca130
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,512 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Write<double> Omega_h::multiply_each<double>(Omega_h::Read<double>, Omega_h::Read<double>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(int)>(double, double, Omega_h::Write<double> Omega_h::multiply_each<double>(Omega_h::Read<double>, Omega_h::Read<double>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x269bc8
jmp 0x269c5a
movq 0x48e0b9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x1bd490
movq 0x48e0a2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x269c51
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0x1bb6b0
jmp 0x269c20
jmp 0x269c22
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x269be9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1c34a0
jmp 0x269c63
leaq -0x78(%rbp), %rdi
callq 0x1c34a0
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,513 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::multiply_each_by<double>(Omega_h::Read<double>, double)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::multiply_each_by<double>(Omega_h::Read<double>, double)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x269f08
jmp 0x269f97
movq 0x48dd79(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1d17a0
movq 0x48dd62(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x269f8e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1cd060
jmp 0x269f60
jmp 0x269f62
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x269f29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c4280
jmp 0x269fa0
leaq -0x68(%rbp), %rdi
callq 0x1c4280
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,514 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::divide_each_by<double>(Omega_h::Read<double>, double)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::divide_each_by<double>(Omega_h::Read<double>, double)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26a178
jmp 0x26a207
movq 0x48db09(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1bd0d0
movq 0x48daf2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26a1fe
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1e1b50
jmp 0x26a1d0
jmp 0x26a1d2
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26a199
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c5ce0
jmp 0x26a210
leaq -0x68(%rbp), %rdi
callq 0x1c5ce0
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,515 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Write<double> Omega_h::divide_each<double>(Omega_h::Read<double>, Omega_h::Read<double>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(int)>(double, double, Omega_h::Write<double> Omega_h::divide_each<double>(Omega_h::Read<double>, Omega_h::Read<double>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26a418
jmp 0x26a4aa
movq 0x48d869(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x1c7b40
movq 0x48d852(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26a4a1
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0x1c6b50
jmp 0x26a470
jmp 0x26a472
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26a439
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x80(%rbp)
movl %eax, -0x84(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x1be000
jmp 0x26a4b3
leaq -0x78(%rbp), %rdi
callq 0x1be000
addq $0x90, %rsp
popq %rbp
retq
movq -0x80(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,516 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::add_each<double>(Omega_h::Read<double>, Omega_h::Read<double>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::add_each<double>(Omega_h::Read<double>, Omega_h::Read<double>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26a778
jmp 0x26a807
movq 0x48d509(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1d83a0
movq 0x48d4f2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26a7fe
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x70(%rbp), %rdi
callq 0x1d9dd0
jmp 0x26a7d0
jmp 0x26a7d2
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26a799
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1e0f50
jmp 0x26a810
leaq -0x70(%rbp), %rdi
callq 0x1e0f50
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,517 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::subtract_each<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::subtract_each<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26aa78
jmp 0x26ab07
movq 0x48d209(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1cd900
movq 0x48d1f2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26aafe
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x70(%rbp), %rdi
callq 0x1cd180
jmp 0x26aad0
jmp 0x26aad2
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26aa99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1c03b0
jmp 0x26ab10
leaq -0x70(%rbp), %rdi
callq 0x1c03b0
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,518 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::min_each<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::min_each<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26ad78
jmp 0x26ae07
movq 0x48cf09(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1ca830
movq 0x48cef2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26adfe
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x70(%rbp), %rdi
callq 0x1bc970
jmp 0x26add0
jmp 0x26add2
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26ad99
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1b8df0
jmp 0x26ae10
leaq -0x70(%rbp), %rdi
callq 0x1b8df0
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,519 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::max_each<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::max_each<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26b0c8
jmp 0x26b157
movq 0x48cbb9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1bbb70
movq 0x48cba2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26b14e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x70(%rbp), %rdi
callq 0x1cb140
jmp 0x26b120
jmp 0x26b122
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26b0e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1bddd0
jmp 0x26b160
leaq -0x70(%rbp), %rdi
callq 0x1bddd0
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,520 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::ternary_each<double>(Omega_h::Read<signed char>, Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::ternary_each<double>(Omega_h::Read<signed char>, Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26b458
jmp 0x26b4f9
movq 0x48c829(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x88(%rbp), %rdi
callq 0x1c3380
movq 0x48c80f(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26b4ed
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x88(%rbp), %rdi
callq 0x1e10c0
jmp 0x26b4b6
jmp 0x26b4b8
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26b47c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1bc450
jmp 0x26b502
leaq -0x88(%rbp), %rdi
callq 0x1bc450
addq $0xa0, %rsp
popq %rbp
retq
movq -0x90(%rbp), %rdi
callq 0x1dfa40
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,521 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::each_max_with<double>(Omega_h::Read<double>, double)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::each_max_with<double>(Omega_h::Read<double>, double)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26b828
jmp 0x26b8b7
movq 0x48c459(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1cdb20
movq 0x48c442(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26b8ae
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1bfb40
jmp 0x26b880
jmp 0x26b882
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26b849
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1d5fe0
jmp 0x26b8c0
leaq -0x68(%rbp), %rdi
callq 0x1d5fe0
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,522 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::add_to_each<double>(Omega_h::Read<double>, double)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::add_to_each<double>(Omega_h::Read<double>, double)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26bac8
jmp 0x26bb57
movq 0x48c1b9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1d5490
movq 0x48c1a2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26bb4e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1c2770
jmp 0x26bb20
jmp 0x26bb22
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26bae9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c15c0
jmp 0x26bb60
leaq -0x68(%rbp), %rdi
callq 0x1c15c0
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,523 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::subtract_from_each<double>(Omega_h::Read<double>, double)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::subtract_from_each<double>(Omega_h::Read<double>, double)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26bd38
jmp 0x26bdc7
movq 0x48bf49(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1c2c00
movq 0x48bf32(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26bdbe
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1baba0
jmp 0x26bd90
jmp 0x26bd92
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26bd59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1e3020
jmp 0x26bdd0
leaq -0x68(%rbp), %rdi
callq 0x1e3020
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,524 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::each_geq_to<double>(Omega_h::Read<double>, double)::'lambda'(int)>(double, double, Omega_h::Read<signed char> Omega_h::each_geq_to<double>(Omega_h::Read<double>, double)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26bfa8
jmp 0x26c037
movq 0x48bcd9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1c43c0
movq 0x48bcc2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26c02e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1c4920
jmp 0x26c000
jmp 0x26c002
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26bfc9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1d6c60
jmp 0x26c040
leaq -0x68(%rbp), %rdi
callq 0x1d6c60
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,525 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::each_leq_to<double>(Omega_h::Read<double>, double)::'lambda'(int)>(double, double, Omega_h::Read<signed char> Omega_h::each_leq_to<double>(Omega_h::Read<double>, double)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26c218
jmp 0x26c2a7
movq 0x48ba69(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1c3300
movq 0x48ba52(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26c29e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1b8930
jmp 0x26c270
jmp 0x26c272
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26c239
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c06d0
jmp 0x26c2b0
leaq -0x68(%rbp), %rdi
callq 0x1c06d0
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,526 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::each_gt<double>(Omega_h::Read<double>, double)::'lambda'(int)>(double, double, Omega_h::Read<signed char> Omega_h::each_gt<double>(Omega_h::Read<double>, double)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26c488
jmp 0x26c517
movq 0x48b7f9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1cdf40
movq 0x48b7e2(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26c50e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1de4e0
jmp 0x26c4e0
jmp 0x26c4e2
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26c4a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1de9e0
jmp 0x26c520
leaq -0x68(%rbp), %rdi
callq 0x1de9e0
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,527 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::each_lt<double>(Omega_h::Read<double>, double)::'lambda'(int)>(double, double, Omega_h::Read<signed char> Omega_h::each_lt<double>(Omega_h::Read<double>, double)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26c6f8
jmp 0x26c787
movq 0x48b589(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1c20a0
movq 0x48b572(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26c77e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1bd000
jmp 0x26c750
jmp 0x26c752
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26c719
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1db910
jmp 0x26c790
leaq -0x68(%rbp), %rdi
callq 0x1db910
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,528 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::each_neq_to<double>(Omega_h::Read<double>, double)::'lambda'(int)>(double, double, Omega_h::Read<signed char> Omega_h::each_neq_to<double>(Omega_h::Read<double>, double)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26c968
jmp 0x26c9f7
movq 0x48b319(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1dca00
movq 0x48b302(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26c9ee
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1bdd30
jmp 0x26c9c0
jmp 0x26c9c2
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26c989
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1bd2b0
jmp 0x26ca00
leaq -0x68(%rbp), %rdi
callq 0x1bd2b0
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,529 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::each_eq<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)>(double, double, Omega_h::Read<signed char> Omega_h::each_eq<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26cbf8
jmp 0x26cc87
movq 0x48b089(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1c2cb0
movq 0x48b072(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26cc7e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x70(%rbp), %rdi
callq 0x1d7c70
jmp 0x26cc50
jmp 0x26cc52
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26cc19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1d7880
jmp 0x26cc90
leaq -0x70(%rbp), %rdi
callq 0x1d7880
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,530 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::each_eq_to<double>(Omega_h::Read<double>, double)::'lambda'(int)>(double, double, Omega_h::Read<signed char> Omega_h::each_eq_to<double>(Omega_h::Read<double>, double)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26ced8
jmp 0x26cf67
movq 0x48ada9(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1c88b0
movq 0x48ad92(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26cf5e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1db690
jmp 0x26cf30
jmp 0x26cf32
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26cef9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1e3490
jmp 0x26cf70
leaq -0x68(%rbp), %rdi
callq 0x1e3490
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,531 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::gt_each<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)>(double, double, Omega_h::Read<signed char> Omega_h::gt_each<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26d168
jmp 0x26d1f7
movq 0x48ab19(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1dd3a0
movq 0x48ab02(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26d1ee
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x70(%rbp), %rdi
callq 0x1be550
jmp 0x26d1c0
jmp 0x26d1c2
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26d189
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1d8cf0
jmp 0x26d200
leaq -0x70(%rbp), %rdi
callq 0x1d8cf0
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,532 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::lt_each<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)>(double, double, Omega_h::Read<signed char> Omega_h::lt_each<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26d468
jmp 0x26d4f7
movq 0x48a819(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1e0460
movq 0x48a802(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26d4ee
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x70(%rbp), %rdi
callq 0x1d0210
jmp 0x26d4c0
jmp 0x26d4c2
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26d489
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1c3e10
jmp 0x26d500
leaq -0x70(%rbp), %rdi
callq 0x1c3e10
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,533 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::eq_each<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)>(double, double, Omega_h::Read<signed char> Omega_h::eq_each<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26d768
jmp 0x26d7f7
movq 0x48a519(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1c2650
movq 0x48a502(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26d7ee
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x70(%rbp), %rdi
callq 0x1d2340
jmp 0x26d7c0
jmp 0x26d7c2
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26d789
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1e1ef0
jmp 0x26d800
leaq -0x70(%rbp), %rdi
callq 0x1e1ef0
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,534 | void Omega_h::parallel_for<Omega_h::Read<signed char> Omega_h::neq_each<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)>(int, double const&, char const*) | void parallel_for(LO n, T const& f, char const* name = "") {
#if defined(OMEGA_H_USE_KOKKOS)
if (n > 0) Kokkos::parallel_for(name, policy(n), f);
#else
(void)name;
auto const first = IntIterator(0);
auto const last = IntIterator(n);
auto f2 = f;
::Omega_h::for_each(first, last, std::move(f2));
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
leaq -0x38(%rbp), %rcx
movq %rcx, -0x8(%rbp)
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
leaq -0x68(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x1cc6f0
movq -0x88(%rbp), %rdx
movl -0x34(%rbp), %eax
movl %eax, -0x6c(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x70(%rbp)
movl -0x6c(%rbp), %edi
movl -0x70(%rbp), %esi
callq 0x1d2a60
jmp 0x26da09
leaq -0x68(%rbp), %rdi
callq 0x1bd840
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1bd840
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,535 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<signed char> Omega_h::neq_each<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)>(double, double, Omega_h::Read<signed char> Omega_h::neq_each<double>(Omega_h::Read<double>, Omega_h::Read<double>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26db18
jmp 0x26dba7
movq 0x48a169(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x70(%rbp), %rdi
callq 0x1b8fa0
movq 0x48a152(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26db9e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x70(%rbp), %rdi
callq 0x1bcc60
jmp 0x26db70
jmp 0x26db72
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26db39
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x1bd840
jmp 0x26dbb0
leaq -0x70(%rbp), %rdi
callq 0x1bd840
addq $0x80, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,536 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::get_component<double>(Omega_h::Read<double>, int, int)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::get_component<double>(Omega_h::Read<double>, int, int)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26ddf8
jmp 0x26de87
movq 0x489e89(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1ca7c0
movq 0x489e72(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26de7e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1e4080
jmp 0x26de50
jmp 0x26de52
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26de19
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1ca7a0
jmp 0x26de90
leaq -0x68(%rbp), %rdi
callq 0x1ca7a0
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,537 | void Omega_h::set_component<double>(Omega_h::Write<double>, Omega_h::Read<double>, int, int)::'lambda'(int)::('lambda'(int) const&) | void set_component(Write<T> out, Read<T> a, Int ncomps, Int comp) {
auto f = OMEGA_H_LAMBDA(LO i) { out[i * ncomps + comp] = a[i]; };
parallel_for(a.size(), f, "set_component");
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1c7e70
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x1cae10
jmp 0x26dff4
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1dc900
movq -0x18(%rbp), %rdi
callq 0x1dfa40
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,538 | void Omega_h::for_each<Omega_h::IntIterator, void Omega_h::set_component<double>(Omega_h::Write<double>, Omega_h::Read<double>, int, int)::'lambda'(int)>(double, double, void Omega_h::set_component<double>(Omega_h::Write<double>, Omega_h::Read<double>, int, int)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26e058
jmp 0x26e0e7
movq 0x489c29(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1c3fd0
movq 0x489c12(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26e0de
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1d8a20
jmp 0x26e0b0
jmp 0x26e0b2
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26e079
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1e3970
jmp 0x26e0f0
leaq -0x68(%rbp), %rdi
callq 0x1e3970
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,539 | void Omega_h::set_component<double>(Omega_h::Write<double>, Omega_h::Read<double>, int, int)::'lambda'(int)::('lambda'(int)&&) | void set_component(Write<T> out, Read<T> a, Int ncomps, Int comp) {
auto f = OMEGA_H_LAMBDA(LO i) { out[i * ncomps + comp] = a[i]; };
parallel_for(a.size(), f, "set_component");
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1d8720
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x1e4220
jmp 0x26e144
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x1dc900
movq -0x18(%rbp), %rdi
callq 0x1dfa40
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,540 | void Omega_h::set_component<double>(Omega_h::Write<double>, Omega_h::Read<double>, int, int)::'lambda'(int)::operator()(int) const | void set_component(Write<T> out, Read<T> a, Int ncomps, Int comp) {
auto f = OMEGA_H_LAMBDA(LO i) { out[i * ncomps + comp] = a[i]; };
parallel_for(a.size(), f, "set_component");
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x58(%rbp)
movl %esi, -0x5c(%rbp)
movq -0x58(%rbp), %rcx
movq %rcx, %rdx
addq $0x18, %rdx
movl -0x5c(%rbp), %eax
movq %rdx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rdx
movl -0x4c(%rbp), %eax
movq %rdx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x3c(%rbp), %rdx
movsd (%rax,%rdx,8), %xmm0
movl -0x5c(%rbp), %eax
imull 0x10(%rcx), %eax
addl 0x14(%rcx), %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x2c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_array_ops.cpp |
1,541 | std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::begin() const | const_iterator
begin() const _GLIBCXX_NOEXCEPT
{ return const_iterator(this->_M_impl._M_start); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1c04a0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,542 | std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>::end() const | const_iterator
end() const _GLIBCXX_NOEXCEPT
{ return const_iterator(this->_M_impl._M_finish); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
addq $0x8, %rsi
leaq -0x8(%rbp), %rdi
callq 0x1c04a0
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,543 | _gnu_cxx::__normal_iterator<Omega_h::Read<double> const*, std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>>::__normal_iterator(Omega_h::Read<double> const* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
1,544 | _gnu_cxx::__normal_iterator<Omega_h::Read<double>*, std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>>::__normal_iterator(Omega_h::Read<double>* const&) | explicit _GLIBCXX20_CONSTEXPR
__normal_iterator(const _Iterator& __i) _GLIBCXX_NOEXCEPT
: _M_current(__i) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_iterator.h |
1,545 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::interleave<double>(std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::interleave<double>(std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26e518
jmp 0x26e5a7
movq 0x489769(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1c1350
movq 0x489752(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26e59e
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1c7ad0
jmp 0x26e570
jmp 0x26e572
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26e539
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1d3930
jmp 0x26e5b0
leaq -0x68(%rbp), %rdi
callq 0x1d3930
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,546 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::coalesce<double>(std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>)::'lambda'(int)>(double, double, Omega_h::Read<double> Omega_h::coalesce<double>(std::vector<Omega_h::Read<double>, std::allocator<Omega_h::Read<double>>>)::'lambda'(int)&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26e768
jmp 0x26e7f7
movq 0x489519(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x1da620
movq 0x489502(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26e7ee
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x68(%rbp), %rdi
callq 0x1bc070
jmp 0x26e7c0
jmp 0x26e7c2
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26e789
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x70(%rbp)
movl %eax, -0x74(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x1c6ca0
jmp 0x26e800
leaq -0x68(%rbp), %rdi
callq 0x1c6ca0
addq $0x80, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x1dfa40
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,547 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<double> Omega_h::array_cast<double, int>(Omega_h::Read<int>)::'lambda'(int)>(double, double, int&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26e995
jmp 0x26ea24
movq 0x4892ec(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1e4e30
movq 0x4892d5(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26ea1b
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x60(%rbp), %rdi
callq 0x1bb010
jmp 0x26e9ed
jmp 0x26e9ef
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26e9b6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1cacf0
jmp 0x26ea2a
leaq -0x60(%rbp), %rdi
callq 0x1cacf0
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,548 | void Omega_h::for_each<Omega_h::IntIterator, Omega_h::Read<int> Omega_h::array_cast<int, signed char>(Omega_h::Read<signed char>)::'lambda'(int)>(int, int, signed char&&) | void for_each(InputIterator first, InputIterator last, UnaryFunction&& f) {
if (first >= last) return;
Omega_h::entering_parallel = true;
auto const f2 = std::move(f);
Omega_h::entering_parallel = false;
#if defined(OMEGA_H_USE_OPENMP)
LO const n = last - first;
#pragma omp parallel for
for (LO i = 0; i < n; ++i) {
f2(first[i]);
}
#else
for (; first != last; ++first) {
f2(*first);
}
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x34(%rbp)
movl %esi, -0x38(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x34(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x26ebb5
jmp 0x26ec44
movq 0x4890cc(%rip), %rax # 0x6f7c88
movb $0x1, (%rax)
movq -0x40(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x1c2740
movq 0x4890b5(%rip), %rax # 0x6f7c88
movb $0x0, (%rax)
leaq -0x34(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movq -0x30(%rbp), %rcx
cmpl (%rcx), %eax
je 0x26ec3b
leaq -0x34(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %esi
leaq -0x60(%rbp), %rdi
callq 0x1c9000
jmp 0x26ec0d
jmp 0x26ec0f
leaq -0x34(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x26ebd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x1d35b0
jmp 0x26ec4a
leaq -0x60(%rbp), %rdi
callq 0x1d35b0
addq $0x70, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_for.hpp |
1,549 | Omega_h::get_assoc_dim(unsigned long, int) | Int get_assoc_dim(size_t set_type, Int mesh_dim) {
switch (set_type) {
case ELEM_SET:
return mesh_dim;
case SIDE_SET:
return mesh_dim - 1;
case NODE_SET:
return VERT;
}
return -1;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
testq %rax, %rax
je 0x26ed72
jmp 0x26ed5a
movq -0x20(%rbp), %rax
subq $0x1, %rax
je 0x26ed7a
jmp 0x26ed66
movq -0x20(%rbp), %rax
subq $0x2, %rax
je 0x26ed85
jmp 0x26ed8e
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x26ed95
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x26ed95
movl $0x0, -0x4(%rbp)
jmp 0x26ed95
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_assoc.cpp |
1,550 | Omega_h::invert(Omega_h::Mesh*, std::array<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>, 3ul> const&) | MeshSets invert(Mesh* mesh, Assoc const& geom_sets) {
MeshSets mesh_sets;
for (size_t set_type = 0; set_type < NSET_TYPES; ++set_type) {
auto ent_dim = get_assoc_dim(set_type, mesh->dim());
for (auto& name_pairs : geom_sets[set_type]) {
auto& name = name_pairs.first;
auto& pairs = name_pairs.second;
auto marks = mark_class_closures(mesh, ent_dim, pairs);
auto set_ents = collect_marked(marks);
mesh_sets[set_type][name] = set_ents;
}
}
return mesh_sets;
} | pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xb0(%rbp)
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x0, -0x19(%rbp)
callq 0x1e1420
movq $0x0, -0x28(%rbp)
cmpq $0x3, -0x28(%rbp)
jae 0x26ef8c
movq -0x28(%rbp), %rax
movq %rax, -0xc0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1ddc00
movl %eax, -0xb4(%rbp)
jmp 0x26ee00
movl -0xb4(%rbp), %esi
movq -0xc0(%rbp), %rdi
callq 0x1df330
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1c1ea0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1d0240
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0x1cf0c0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1d4340
testb $0x1, %al
jne 0x26ee56
jmp 0x26ef79
leaq -0x50(%rbp), %rdi
callq 0x1d13e0
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x60(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rsi
movl -0x2c(%rbp), %edx
movq -0x70(%rbp), %rcx
leaq -0x80(%rbp), %rdi
callq 0x1e3200
jmp 0x26ee8d
leaq -0xa0(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x1bec60
jmp 0x26ee9f
leaq -0x90(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1dfde0
jmp 0x26eeb4
leaq -0xa0(%rbp), %rdi
callq 0x1e0060
movq -0xb0(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1df8c0
movq %rax, %rdi
movq -0x68(%rbp), %rsi
callq 0x1df180
movq %rax, -0xc8(%rbp)
jmp 0x26eee5
movq -0xc8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x1d4a20
jmp 0x26eefa
leaq -0x90(%rbp), %rdi
callq 0x1c7d90
leaq -0x80(%rbp), %rdi
callq 0x1e0060
leaq -0x50(%rbp), %rdi
callq 0x1c6610
jmp 0x26ee40
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x26efb2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x26ef6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1e0060
jmp 0x26ef6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x1c7d90
leaq -0x80(%rbp), %rdi
callq 0x1e0060
jmp 0x26efb2
jmp 0x26ef7b
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x26edd9
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0x26efa2
movq -0xb0(%rbp), %rdi
callq 0x1dfff0
movq -0xa8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xb0(%rbp), %rdi
callq 0x1dfff0
movq -0x38(%rbp), %rdi
callq 0x1dfa40
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_assoc.cpp |
1,551 | Omega_h::update_from_file(std::array<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>, 3ul>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | void update_from_file(Assoc* p_assoc, std::string const& filepath) {
Assoc& assoc = *p_assoc;
std::ifstream f(filepath.c_str());
if (!f.is_open()) {
Omega_h_fail("Could not open associations file \"%s\"\n", filepath.c_str());
}
std::string sline;
LO lc = 0;
while (std::getline(f, sline)) {
if (sline.empty()) break;
++lc;
std::string rest;
size_t set_type;
for (set_type = 0; set_type < NSET_TYPES; ++set_type) {
std::string set_name = assoc_file_names[set_type];
if (sline.compare(0, set_name.length(), set_name) == 0) {
rest = sline.substr(set_name.length());
break;
}
}
if (set_type >= NSET_TYPES) {
Omega_h_fail("Unknown set type \"%s\" at %s +%d\n", sline.c_str(),
filepath.c_str(), lc);
}
std::stringstream rest_stream(rest);
std::string set_name;
rest_stream >> set_name;
LO set_size;
rest_stream >> set_size;
if (!rest_stream) {
Omega_h_fail(
"Couldn't parse set name and size at %s +%d\n", filepath.c_str(), lc);
}
for (LO i = 0; i < set_size; ++i) {
std::string eline;
std::getline(f, eline);
if (!f || eline.empty()) {
Omega_h_fail(
"Expected more pairs after %s +%d\n", filepath.c_str(), lc);
}
++lc;
std::stringstream pair_stream(eline);
Int class_dim;
LO class_id;
pair_stream >> class_dim >> class_id;
if (!pair_stream) {
Omega_h_fail("Couldn't parse pair \"%s\" at %s +%d\n", eline.c_str(),
filepath.c_str(), lc);
}
assoc[set_type][set_name].push_back({class_dim, class_id});
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x6d0, %rsp # imm = 0x6D0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rsi
leaq -0x220(%rbp), %rdi
movq %rdi, -0x648(%rbp)
movl $0x8, %edx
callq 0x1e12d0
movq -0x648(%rbp), %rdi
callq 0x1dbaf0
movb %al, -0x639(%rbp)
jmp 0x26f023
movb -0x639(%rbp), %al
testb $0x1, %al
jne 0x26f062
jmp 0x26f02f
movq -0x10(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rsi
leaq 0x3bd7d1(%rip), %rdi # 0x62c813
xorl %eax, %eax
callq 0x1ce550
jmp 0x26f04b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x26f689
leaq -0x250(%rbp), %rdi
callq 0x1d67d0
movl $0x0, -0x254(%rbp)
leaq -0x220(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x1ba550
movq %rax, -0x650(%rbp)
jmp 0x26f094
movq -0x650(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x1d38d0
movb %al, -0x651(%rbp)
jmp 0x26f0b2
movb -0x651(%rbp), %al
testb $0x1, %al
jne 0x26f0c1
jmp 0x26f65c
leaq -0x250(%rbp), %rdi
callq 0x1dd4c0
testb $0x1, %al
jne 0x26f0d3
jmp 0x26f0ef
jmp 0x26f65c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x26f67d
movl -0x254(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x254(%rbp)
leaq -0x278(%rbp), %rdi
callq 0x1d67d0
movq $0x0, -0x280(%rbp)
cmpq $0x3, -0x280(%rbp)
jae 0x26f294
movq -0x280(%rbp), %rcx
leaq 0x48659f(%rip), %rax # 0x6f56d0
movq (%rax,%rcx,8), %rax
movq %rax, -0x668(%rbp)
leaq -0x2a1(%rbp), %rdi
movq %rdi, -0x660(%rbp)
callq 0x1dfbb0
movq -0x668(%rbp), %rsi
movq -0x660(%rbp), %rdx
leaq -0x2a0(%rbp), %rdi
callq 0x1d5e00
jmp 0x26f16b
leaq -0x2a1(%rbp), %rdi
callq 0x1cf450
leaq -0x2a0(%rbp), %rdi
movq %rdi, -0x678(%rbp)
callq 0x1d91b0
movq -0x678(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
leaq -0x250(%rbp), %rdi
callq 0x1d4540
movl %eax, -0x66c(%rbp)
jmp 0x26f1ac
movl -0x66c(%rbp), %eax
cmpl $0x0, %eax
jne 0x26f257
leaq -0x2a0(%rbp), %rdi
callq 0x1d91b0
movq %rax, %rdx
leaq -0x2c8(%rbp), %rdi
leaq -0x250(%rbp), %rsi
movq $-0x1, %rcx
callq 0x1ce800
jmp 0x26f1e6
leaq -0x278(%rbp), %rdi
leaq -0x2c8(%rbp), %rsi
callq 0x1d2cf0
leaq -0x2c8(%rbp), %rdi
callq 0x1c4d10
movl $0x4, -0x2cc(%rbp)
jmp 0x26f261
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x2a1(%rbp), %rdi
callq 0x1cf450
jmp 0x26f64e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x2a0(%rbp), %rdi
callq 0x1c4d10
jmp 0x26f64e
movl $0x0, -0x2cc(%rbp)
leaq -0x2a0(%rbp), %rdi
callq 0x1c4d10
movl -0x2cc(%rbp), %eax
testl %eax, %eax
je 0x26f27b
jmp 0x26f279
jmp 0x26f294
jmp 0x26f27d
movq -0x280(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x280(%rbp)
jmp 0x26f115
cmpq $0x3, -0x280(%rbp)
jb 0x26f2f1
leaq -0x250(%rbp), %rdi
callq 0x1bf7a0
movq %rax, -0x680(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bf7a0
movq -0x680(%rbp), %rsi
movq %rax, %rdx
movl -0x254(%rbp), %ecx
leaq 0x3bd569(%rip), %rdi # 0x62c83a
xorl %eax, %eax
callq 0x1ce550
jmp 0x26f2da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x26f64e
movl $0x10, %edi
movl $0x8, %esi
callq 0x1e0980
movl %eax, -0x684(%rbp)
jmp 0x26f308
movl -0x684(%rbp), %edx
leaq -0x458(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x1db700
jmp 0x26f323
leaq -0x478(%rbp), %rdi
movq %rdi, -0x690(%rbp)
callq 0x1d67d0
movq -0x690(%rbp), %rsi
leaq -0x458(%rbp), %rdi
callq 0x1d3e40
jmp 0x26f34b
leaq -0x458(%rbp), %rdi
leaq -0x47c(%rbp), %rsi
callq 0x1c4b40
jmp 0x26f360
movq -0x458(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x458(%rbp,%rax), %rdi
callq 0x1c0540
movb %al, -0x691(%rbp)
jmp 0x26f380
movb -0x691(%rbp), %al
testb $0x1, %al
jne 0x26f38c
jmp 0x26f3c5
movq -0x10(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rsi
movl -0x254(%rbp), %edx
leaq 0x3bd4b6(%rip), %rdi # 0x62c85b
xorl %eax, %eax
callq 0x1ce550
jmp 0x26f3ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x26f636
movl $0x0, -0x480(%rbp)
movl -0x480(%rbp), %eax
cmpl -0x47c(%rbp), %eax
jge 0x26f60d
leaq -0x4a0(%rbp), %rdi
movq %rdi, -0x6a0(%rbp)
callq 0x1d67d0
movq -0x6a0(%rbp), %rsi
leaq -0x220(%rbp), %rdi
callq 0x1ba550
jmp 0x26f409
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x1c0540
movb %al, -0x6a1(%rbp)
jmp 0x26f429
movb -0x6a1(%rbp), %al
testb $0x1, %al
jne 0x26f447
jmp 0x26f435
leaq -0x4a0(%rbp), %rdi
callq 0x1dd4c0
testb $0x1, %al
jne 0x26f447
jmp 0x26f480
movq -0x10(%rbp), %rdi
callq 0x1bf7a0
movq %rax, %rsi
movl -0x254(%rbp), %edx
leaq 0x3bd427(%rip), %rdi # 0x62c887
xorl %eax, %eax
callq 0x1ce550
jmp 0x26f469
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
jmp 0x26f5ff
movl -0x254(%rbp), %eax
incl %eax
movl %eax, -0x254(%rbp)
movl $0x10, %edi
movl $0x8, %esi
callq 0x1e0980
movl %eax, -0x6a8(%rbp)
jmp 0x26f4a5
movl -0x6a8(%rbp), %edx
leaq -0x628(%rbp), %rdi
leaq -0x4a0(%rbp), %rsi
callq 0x1db700
jmp 0x26f4c0
leaq -0x628(%rbp), %rdi
leaq -0x62c(%rbp), %rsi
callq 0x1c4b40
movq %rax, -0x6b0(%rbp)
jmp 0x26f4dc
movq -0x6b0(%rbp), %rdi
leaq -0x630(%rbp), %rsi
callq 0x1c4b40
jmp 0x26f4f1
movq -0x628(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x628(%rbp,%rax), %rdi
callq 0x1c0540
movb %al, -0x6b1(%rbp)
jmp 0x26f511
movb -0x6b1(%rbp), %al
testb $0x1, %al
jne 0x26f51d
jmp 0x26f57c
leaq -0x4a0(%rbp), %rdi
callq 0x1bf7a0
movq %rax, -0x6c0(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1bf7a0
movq -0x6c0(%rbp), %rsi
movq %rax, %rdx
movl -0x254(%rbp), %ecx
leaq 0x3bd359(%rip), %rdi # 0x62c8a9
xorl %eax, %eax
callq 0x1ce550
jmp 0x26f559
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x628(%rbp), %rdi
callq 0x1c76d0
jmp 0x26f5ff
movq -0x18(%rbp), %rdi
movq -0x280(%rbp), %rsi
callq 0x1d5a70
movq %rax, %rdi
leaq -0x478(%rbp), %rsi
callq 0x1cd990
movq %rax, -0x6c8(%rbp)
jmp 0x26f5a4
movl -0x62c(%rbp), %esi
movl -0x630(%rbp), %edx
leaq -0x638(%rbp), %rdi
callq 0x1cdbe0
jmp 0x26f5be
movq -0x6c8(%rbp), %rdi
leaq -0x638(%rbp), %rsi
callq 0x1c97f0
jmp 0x26f5d3
leaq -0x628(%rbp), %rdi
callq 0x1c76d0
leaq -0x4a0(%rbp), %rdi
callq 0x1c4d10
movl -0x480(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x480(%rbp)
jmp 0x26f3cf
leaq -0x4a0(%rbp), %rdi
callq 0x1c4d10
jmp 0x26f636
leaq -0x478(%rbp), %rdi
callq 0x1c4d10
leaq -0x458(%rbp), %rdi
callq 0x1c76d0
leaq -0x278(%rbp), %rdi
callq 0x1c4d10
jmp 0x26f078
leaq -0x478(%rbp), %rdi
callq 0x1c4d10
leaq -0x458(%rbp), %rdi
callq 0x1c76d0
leaq -0x278(%rbp), %rdi
callq 0x1c4d10
jmp 0x26f67d
leaq -0x250(%rbp), %rdi
callq 0x1c4d10
leaq -0x220(%rbp), %rdi
callq 0x1bbe70
addq $0x6d0, %rsp # imm = 0x6D0
popq %rbp
retq
leaq -0x250(%rbp), %rdi
callq 0x1c4d10
leaq -0x220(%rbp), %rdi
callq 0x1bbe70
movq -0x228(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_assoc.cpp |
1,552 | Omega_h::read_assoc_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | Assoc read_assoc_file(std::string const& filepath) {
Assoc assoc;
update_from_file(&assoc, filepath);
return assoc;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x1d5d70
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1de9b0
jmp 0x26f6e3
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x26f70f
jmp 0x26f706
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x1e30e0
jmp 0x26f719
movq -0x30(%rbp), %rdi
callq 0x1e30e0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x1dfa40
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_assoc.cpp |
1,553 | Omega_h::get_box_assoc[abi:cxx11](int) | Assoc get_box_assoc(int dim) {
Assoc assoc;
if (dim == 1) {
assoc[NODE_SET]["x-"] = {{0, 0}};
assoc[SIDE_SET]["x-"] = {{0, 0}};
assoc[NODE_SET]["body"] = {{1, 1}};
assoc[ELEM_SET]["body"] = {{1, 1}};
assoc[NODE_SET]["x+"] = {{0, 2}};
assoc[SIDE_SET]["x+"] = {{0, 2}};
} else if (dim == 2) {
assoc[NODE_SET]["y-"] = {{1, 1}};
assoc[SIDE_SET]["y-"] = {{1, 1}};
assoc[NODE_SET]["x-"] = {{1, 3}};
assoc[SIDE_SET]["x-"] = {{1, 3}};
assoc[NODE_SET]["body"] = {{2, 4}};
assoc[ELEM_SET]["body"] = {{2, 4}};
assoc[NODE_SET]["x+"] = {{1, 5}};
assoc[SIDE_SET]["x+"] = {{1, 5}};
assoc[NODE_SET]["y+"] = {{1, 7}};
assoc[SIDE_SET]["y+"] = {{1, 7}};
} else if (dim == 3) {
assoc[NODE_SET]["z-"] = {{2, 4}};
assoc[SIDE_SET]["z-"] = {{2, 4}};
assoc[NODE_SET]["y-"] = {{2, 10}};
assoc[SIDE_SET]["y-"] = {{2, 10}};
assoc[NODE_SET]["x-"] = {{2, 12}};
assoc[SIDE_SET]["x-"] = {{2, 12}};
assoc[NODE_SET]["body"] = {{3, 13}};
assoc[ELEM_SET]["body"] = {{3, 13}};
assoc[NODE_SET]["x+"] = {{2, 14}};
assoc[SIDE_SET]["x+"] = {{2, 14}};
assoc[NODE_SET]["y+"] = {{2, 16}};
assoc[SIDE_SET]["y+"] = {{2, 16}};
assoc[NODE_SET]["z+"] = {{2, 22}};
assoc[SIDE_SET]["z+"] = {{2, 22}};
}
return assoc;
} | pushq %rbp
movq %rsp, %rbp
subq $0xa80, %rsp # imm = 0xA80
movq %rdi, -0x7b0(%rbp)
movq %rdi, %rax
movq %rax, -0x7a8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movb $0x0, -0xd(%rbp)
callq 0x1d5d70
cmpl $0x1, -0xc(%rbp)
jne 0x26fd24
leaq -0x28(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x1cdbe0
jmp 0x26f775
movq -0x7b0(%rbp), %rdi
leaq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x18(%rbp)
movl $0x2, %esi
callq 0x1d5a70
movq %rax, -0x7c0(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x7b8(%rbp)
callq 0x1dfbb0
movq -0x7b8(%rbp), %rdx
leaq 0x3bd112(%rip), %rsi # 0x62c8cd
leaq -0x58(%rbp), %rdi
callq 0x1d5e00
jmp 0x26f7c6
movq -0x7c0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x7c8(%rbp)
jmp 0x26f7df
movq -0x7c8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1dda30
jmp 0x26f7f5
leaq -0x58(%rbp), %rdi
callq 0x1c4d10
leaq -0x59(%rbp), %rdi
callq 0x1cf450
leaq -0x78(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x1cdbe0
jmp 0x26f816
movq -0x7b0(%rbp), %rdi
leaq -0x78(%rbp), %rax
movq %rax, -0x70(%rbp)
movq $0x1, -0x68(%rbp)
movl $0x1, %esi
callq 0x1d5a70
movq %rax, -0x7d8(%rbp)
leaq -0x99(%rbp), %rdi
movq %rdi, -0x7d0(%rbp)
callq 0x1dfbb0
movq -0x7d0(%rbp), %rdx
leaq 0x3bd06e(%rip), %rsi # 0x62c8cd
leaq -0x98(%rbp), %rdi
callq 0x1d5e00
jmp 0x26f86d
movq -0x7d8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x7e0(%rbp)
jmp 0x26f889
movq -0x7e0(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0x1dda30
jmp 0x26f89f
leaq -0x98(%rbp), %rdi
callq 0x1c4d10
leaq -0x99(%rbp), %rdi
callq 0x1cf450
leaq -0xb8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x1cdbe0
jmp 0x26f8cc
movq -0x7b0(%rbp), %rdi
leaq -0xb8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq $0x1, -0xa8(%rbp)
movl $0x2, %esi
callq 0x1d5a70
movq %rax, -0x7f0(%rbp)
leaq -0xd9(%rbp), %rdi
movq %rdi, -0x7e8(%rbp)
callq 0x1dfbb0
movq -0x7e8(%rbp), %rdx
leaq 0x3bcfb2(%rip), %rsi # 0x62c8d0
leaq -0xd8(%rbp), %rdi
callq 0x1d5e00
jmp 0x26f92c
movq -0x7f0(%rbp), %rdi
leaq -0xd8(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x7f8(%rbp)
jmp 0x26f948
movq -0x7f8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
callq 0x1dda30
jmp 0x26f964
leaq -0xd8(%rbp), %rdi
callq 0x1c4d10
leaq -0xd9(%rbp), %rdi
callq 0x1cf450
leaq -0xf8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x1cdbe0
jmp 0x26f991
movq -0x7b0(%rbp), %rdi
leaq -0xf8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq $0x1, -0xe8(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1d5a70
movq %rax, -0x808(%rbp)
leaq -0x119(%rbp), %rdi
movq %rdi, -0x800(%rbp)
callq 0x1dfbb0
movq -0x800(%rbp), %rdx
leaq 0x3bceee(%rip), %rsi # 0x62c8d0
leaq -0x118(%rbp), %rdi
callq 0x1d5e00
jmp 0x26f9f0
movq -0x808(%rbp), %rdi
leaq -0x118(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x810(%rbp)
jmp 0x26fa0c
movq -0x810(%rbp), %rdi
movq -0xf0(%rbp), %rsi
movq -0xe8(%rbp), %rdx
callq 0x1dda30
jmp 0x26fa28
leaq -0x118(%rbp), %rdi
callq 0x1c4d10
leaq -0x119(%rbp), %rdi
callq 0x1cf450
leaq -0x138(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1cdbe0
jmp 0x26fa55
movq -0x7b0(%rbp), %rdi
leaq -0x138(%rbp), %rax
movq %rax, -0x130(%rbp)
movq $0x1, -0x128(%rbp)
movl $0x2, %esi
callq 0x1d5a70
movq %rax, -0x820(%rbp)
leaq -0x159(%rbp), %rdi
movq %rdi, -0x818(%rbp)
callq 0x1dfbb0
movq -0x818(%rbp), %rdx
leaq 0x3bce2e(%rip), %rsi # 0x62c8d5
leaq -0x158(%rbp), %rdi
callq 0x1d5e00
jmp 0x26fab5
movq -0x820(%rbp), %rdi
leaq -0x158(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x828(%rbp)
jmp 0x26fad1
movq -0x828(%rbp), %rdi
movq -0x130(%rbp), %rsi
movq -0x128(%rbp), %rdx
callq 0x1dda30
jmp 0x26faed
leaq -0x158(%rbp), %rdi
callq 0x1c4d10
leaq -0x159(%rbp), %rdi
callq 0x1cf450
leaq -0x178(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x1cdbe0
jmp 0x26fb1a
movq -0x7b0(%rbp), %rdi
leaq -0x178(%rbp), %rax
movq %rax, -0x170(%rbp)
movq $0x1, -0x168(%rbp)
movl $0x1, %esi
callq 0x1d5a70
movq %rax, -0x838(%rbp)
leaq -0x199(%rbp), %rdi
movq %rdi, -0x830(%rbp)
callq 0x1dfbb0
movq -0x830(%rbp), %rdx
leaq 0x3bcd69(%rip), %rsi # 0x62c8d5
leaq -0x198(%rbp), %rdi
callq 0x1d5e00
jmp 0x26fb7a
movq -0x838(%rbp), %rdi
leaq -0x198(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x840(%rbp)
jmp 0x26fb96
movq -0x840(%rbp), %rdi
movq -0x170(%rbp), %rsi
movq -0x168(%rbp), %rdx
callq 0x1dda30
jmp 0x26fbb2
leaq -0x198(%rbp), %rdi
callq 0x1c4d10
leaq -0x199(%rbp), %rdi
callq 0x1cf450
jmp 0x271520
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x26fc03
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x1c4d10
leaq -0x59(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x26fc37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x1c4d10
leaq -0x99(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x26fc6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x1c4d10
leaq -0xd9(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x26fca5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x118(%rbp), %rdi
callq 0x1c4d10
leaq -0x119(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x26fcdc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x158(%rbp), %rdi
callq 0x1c4d10
leaq -0x159(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x26fd13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x198(%rbp), %rdi
callq 0x1c4d10
leaq -0x199(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
cmpl $0x2, -0xc(%rbp)
jne 0x270722
leaq -0x1b8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x1cdbe0
jmp 0x26fd43
movq -0x7b0(%rbp), %rdi
leaq -0x1b8(%rbp), %rax
movq %rax, -0x1b0(%rbp)
movq $0x1, -0x1a8(%rbp)
movl $0x2, %esi
callq 0x1d5a70
movq %rax, -0x850(%rbp)
leaq -0x1d9(%rbp), %rdi
movq %rdi, -0x848(%rbp)
callq 0x1dfbb0
movq -0x848(%rbp), %rdx
leaq 0x3bcb43(%rip), %rsi # 0x62c8d8
leaq -0x1d8(%rbp), %rdi
callq 0x1d5e00
jmp 0x26fda3
movq -0x850(%rbp), %rdi
leaq -0x1d8(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x858(%rbp)
jmp 0x26fdbf
movq -0x858(%rbp), %rdi
movq -0x1b0(%rbp), %rsi
movq -0x1a8(%rbp), %rdx
callq 0x1dda30
jmp 0x26fddb
leaq -0x1d8(%rbp), %rdi
callq 0x1c4d10
leaq -0x1d9(%rbp), %rdi
callq 0x1cf450
leaq -0x1f8(%rbp), %rdi
movl $0x1, %edx
movl %edx, %esi
callq 0x1cdbe0
jmp 0x26fe08
movq -0x7b0(%rbp), %rdi
leaq -0x1f8(%rbp), %rax
movq %rax, -0x1f0(%rbp)
movq $0x1, -0x1e8(%rbp)
movl $0x1, %esi
callq 0x1d5a70
movq %rax, -0x868(%rbp)
leaq -0x219(%rbp), %rdi
movq %rdi, -0x860(%rbp)
callq 0x1dfbb0
movq -0x860(%rbp), %rdx
leaq 0x3bca7e(%rip), %rsi # 0x62c8d8
leaq -0x218(%rbp), %rdi
callq 0x1d5e00
jmp 0x26fe68
movq -0x868(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x870(%rbp)
jmp 0x26fe84
movq -0x870(%rbp), %rdi
movq -0x1f0(%rbp), %rsi
movq -0x1e8(%rbp), %rdx
callq 0x1dda30
jmp 0x26fea0
leaq -0x218(%rbp), %rdi
callq 0x1c4d10
leaq -0x219(%rbp), %rdi
callq 0x1cf450
leaq -0x238(%rbp), %rdi
movl $0x1, %esi
movl $0x3, %edx
callq 0x1cdbe0
jmp 0x26fed0
movq -0x7b0(%rbp), %rdi
leaq -0x238(%rbp), %rax
movq %rax, -0x230(%rbp)
movq $0x1, -0x228(%rbp)
movl $0x2, %esi
callq 0x1d5a70
movq %rax, -0x880(%rbp)
leaq -0x259(%rbp), %rdi
movq %rdi, -0x878(%rbp)
callq 0x1dfbb0
movq -0x878(%rbp), %rdx
leaq 0x3bc9ab(%rip), %rsi # 0x62c8cd
leaq -0x258(%rbp), %rdi
callq 0x1d5e00
jmp 0x26ff30
movq -0x880(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x888(%rbp)
jmp 0x26ff4c
movq -0x888(%rbp), %rdi
movq -0x230(%rbp), %rsi
movq -0x228(%rbp), %rdx
callq 0x1dda30
jmp 0x26ff68
leaq -0x258(%rbp), %rdi
callq 0x1c4d10
leaq -0x259(%rbp), %rdi
callq 0x1cf450
leaq -0x278(%rbp), %rdi
movl $0x1, %esi
movl $0x3, %edx
callq 0x1cdbe0
jmp 0x26ff98
movq -0x7b0(%rbp), %rdi
leaq -0x278(%rbp), %rax
movq %rax, -0x270(%rbp)
movq $0x1, -0x268(%rbp)
movl $0x1, %esi
callq 0x1d5a70
movq %rax, -0x898(%rbp)
leaq -0x299(%rbp), %rdi
movq %rdi, -0x890(%rbp)
callq 0x1dfbb0
movq -0x890(%rbp), %rdx
leaq 0x3bc8e3(%rip), %rsi # 0x62c8cd
leaq -0x298(%rbp), %rdi
callq 0x1d5e00
jmp 0x26fff8
movq -0x898(%rbp), %rdi
leaq -0x298(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x8a0(%rbp)
jmp 0x270014
movq -0x8a0(%rbp), %rdi
movq -0x270(%rbp), %rsi
movq -0x268(%rbp), %rdx
callq 0x1dda30
jmp 0x270030
leaq -0x298(%rbp), %rdi
callq 0x1c4d10
leaq -0x299(%rbp), %rdi
callq 0x1cf450
leaq -0x2b8(%rbp), %rdi
movl $0x2, %esi
movl $0x4, %edx
callq 0x1cdbe0
jmp 0x270060
movq -0x7b0(%rbp), %rdi
leaq -0x2b8(%rbp), %rax
movq %rax, -0x2b0(%rbp)
movq $0x1, -0x2a8(%rbp)
movl $0x2, %esi
callq 0x1d5a70
movq %rax, -0x8b0(%rbp)
leaq -0x2d9(%rbp), %rdi
movq %rdi, -0x8a8(%rbp)
callq 0x1dfbb0
movq -0x8a8(%rbp), %rdx
leaq 0x3bc81e(%rip), %rsi # 0x62c8d0
leaq -0x2d8(%rbp), %rdi
callq 0x1d5e00
jmp 0x2700c0
movq -0x8b0(%rbp), %rdi
leaq -0x2d8(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x8b8(%rbp)
jmp 0x2700dc
movq -0x8b8(%rbp), %rdi
movq -0x2b0(%rbp), %rsi
movq -0x2a8(%rbp), %rdx
callq 0x1dda30
jmp 0x2700f8
leaq -0x2d8(%rbp), %rdi
callq 0x1c4d10
leaq -0x2d9(%rbp), %rdi
callq 0x1cf450
leaq -0x2f8(%rbp), %rdi
movl $0x2, %esi
movl $0x4, %edx
callq 0x1cdbe0
jmp 0x270128
movq -0x7b0(%rbp), %rdi
leaq -0x2f8(%rbp), %rax
movq %rax, -0x2f0(%rbp)
movq $0x1, -0x2e8(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1d5a70
movq %rax, -0x8c8(%rbp)
leaq -0x319(%rbp), %rdi
movq %rdi, -0x8c0(%rbp)
callq 0x1dfbb0
movq -0x8c0(%rbp), %rdx
leaq 0x3bc757(%rip), %rsi # 0x62c8d0
leaq -0x318(%rbp), %rdi
callq 0x1d5e00
jmp 0x270187
movq -0x8c8(%rbp), %rdi
leaq -0x318(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x8d0(%rbp)
jmp 0x2701a3
movq -0x8d0(%rbp), %rdi
movq -0x2f0(%rbp), %rsi
movq -0x2e8(%rbp), %rdx
callq 0x1dda30
jmp 0x2701bf
leaq -0x318(%rbp), %rdi
callq 0x1c4d10
leaq -0x319(%rbp), %rdi
callq 0x1cf450
leaq -0x338(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1cdbe0
jmp 0x2701ef
movq -0x7b0(%rbp), %rdi
leaq -0x338(%rbp), %rax
movq %rax, -0x330(%rbp)
movq $0x1, -0x328(%rbp)
movl $0x2, %esi
callq 0x1d5a70
movq %rax, -0x8e0(%rbp)
leaq -0x359(%rbp), %rdi
movq %rdi, -0x8d8(%rbp)
callq 0x1dfbb0
movq -0x8d8(%rbp), %rdx
leaq 0x3bc694(%rip), %rsi # 0x62c8d5
leaq -0x358(%rbp), %rdi
callq 0x1d5e00
jmp 0x27024f
movq -0x8e0(%rbp), %rdi
leaq -0x358(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x8e8(%rbp)
jmp 0x27026b
movq -0x8e8(%rbp), %rdi
movq -0x330(%rbp), %rsi
movq -0x328(%rbp), %rdx
callq 0x1dda30
jmp 0x270287
leaq -0x358(%rbp), %rdi
callq 0x1c4d10
leaq -0x359(%rbp), %rdi
callq 0x1cf450
leaq -0x378(%rbp), %rdi
movl $0x1, %esi
movl $0x5, %edx
callq 0x1cdbe0
jmp 0x2702b7
movq -0x7b0(%rbp), %rdi
leaq -0x378(%rbp), %rax
movq %rax, -0x370(%rbp)
movq $0x1, -0x368(%rbp)
movl $0x1, %esi
callq 0x1d5a70
movq %rax, -0x8f8(%rbp)
leaq -0x399(%rbp), %rdi
movq %rdi, -0x8f0(%rbp)
callq 0x1dfbb0
movq -0x8f0(%rbp), %rdx
leaq 0x3bc5cc(%rip), %rsi # 0x62c8d5
leaq -0x398(%rbp), %rdi
callq 0x1d5e00
jmp 0x270317
movq -0x8f8(%rbp), %rdi
leaq -0x398(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x900(%rbp)
jmp 0x270333
movq -0x900(%rbp), %rdi
movq -0x370(%rbp), %rsi
movq -0x368(%rbp), %rdx
callq 0x1dda30
jmp 0x27034f
leaq -0x398(%rbp), %rdi
callq 0x1c4d10
leaq -0x399(%rbp), %rdi
callq 0x1cf450
leaq -0x3b8(%rbp), %rdi
movl $0x1, %esi
movl $0x7, %edx
callq 0x1cdbe0
jmp 0x27037f
movq -0x7b0(%rbp), %rdi
leaq -0x3b8(%rbp), %rax
movq %rax, -0x3b0(%rbp)
movq $0x1, -0x3a8(%rbp)
movl $0x2, %esi
callq 0x1d5a70
movq %rax, -0x910(%rbp)
leaq -0x3d9(%rbp), %rdi
movq %rdi, -0x908(%rbp)
callq 0x1dfbb0
movq -0x908(%rbp), %rdx
leaq 0x3bc50a(%rip), %rsi # 0x62c8db
leaq -0x3d8(%rbp), %rdi
callq 0x1d5e00
jmp 0x2703df
movq -0x910(%rbp), %rdi
leaq -0x3d8(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x918(%rbp)
jmp 0x2703fb
movq -0x918(%rbp), %rdi
movq -0x3b0(%rbp), %rsi
movq -0x3a8(%rbp), %rdx
callq 0x1dda30
jmp 0x270417
leaq -0x3d8(%rbp), %rdi
callq 0x1c4d10
leaq -0x3d9(%rbp), %rdi
callq 0x1cf450
leaq -0x3f8(%rbp), %rdi
movl $0x1, %esi
movl $0x7, %edx
callq 0x1cdbe0
jmp 0x270447
movq -0x7b0(%rbp), %rdi
leaq -0x3f8(%rbp), %rax
movq %rax, -0x3f0(%rbp)
movq $0x1, -0x3e8(%rbp)
movl $0x1, %esi
callq 0x1d5a70
movq %rax, -0x928(%rbp)
leaq -0x419(%rbp), %rdi
movq %rdi, -0x920(%rbp)
callq 0x1dfbb0
movq -0x920(%rbp), %rdx
leaq 0x3bc442(%rip), %rsi # 0x62c8db
leaq -0x418(%rbp), %rdi
callq 0x1d5e00
jmp 0x2704a7
movq -0x928(%rbp), %rdi
leaq -0x418(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x930(%rbp)
jmp 0x2704c3
movq -0x930(%rbp), %rdi
movq -0x3f0(%rbp), %rsi
movq -0x3e8(%rbp), %rdx
callq 0x1dda30
jmp 0x2704df
leaq -0x418(%rbp), %rdi
callq 0x1c4d10
leaq -0x419(%rbp), %rdi
callq 0x1cf450
jmp 0x27151e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x270522
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x1d8(%rbp), %rdi
callq 0x1c4d10
leaq -0x1d9(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x270559
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x1c4d10
leaq -0x219(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x270590
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x1c4d10
leaq -0x259(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2705c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x298(%rbp), %rdi
callq 0x1c4d10
leaq -0x299(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2705fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x2d8(%rbp), %rdi
callq 0x1c4d10
leaq -0x2d9(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x270635
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x318(%rbp), %rdi
callq 0x1c4d10
leaq -0x319(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x27066c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x358(%rbp), %rdi
callq 0x1c4d10
leaq -0x359(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2706a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x398(%rbp), %rdi
callq 0x1c4d10
leaq -0x399(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2706da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x3d8(%rbp), %rdi
callq 0x1c4d10
leaq -0x3d9(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x270711
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x418(%rbp), %rdi
callq 0x1c4d10
leaq -0x419(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
cmpl $0x3, -0xc(%rbp)
jne 0x27151c
leaq -0x438(%rbp), %rdi
movl $0x2, %esi
movl $0x4, %edx
callq 0x1cdbe0
jmp 0x270744
movq -0x7b0(%rbp), %rdi
leaq -0x438(%rbp), %rax
movq %rax, -0x430(%rbp)
movq $0x1, -0x428(%rbp)
movl $0x2, %esi
callq 0x1d5a70
movq %rax, -0x940(%rbp)
leaq -0x459(%rbp), %rdi
movq %rdi, -0x938(%rbp)
callq 0x1dfbb0
movq -0x938(%rbp), %rdx
leaq 0x3bc148(%rip), %rsi # 0x62c8de
leaq -0x458(%rbp), %rdi
callq 0x1d5e00
jmp 0x2707a4
movq -0x940(%rbp), %rdi
leaq -0x458(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x948(%rbp)
jmp 0x2707c0
movq -0x948(%rbp), %rdi
movq -0x430(%rbp), %rsi
movq -0x428(%rbp), %rdx
callq 0x1dda30
jmp 0x2707dc
leaq -0x458(%rbp), %rdi
callq 0x1c4d10
leaq -0x459(%rbp), %rdi
callq 0x1cf450
leaq -0x478(%rbp), %rdi
movl $0x2, %esi
movl $0x4, %edx
callq 0x1cdbe0
jmp 0x27080c
movq -0x7b0(%rbp), %rdi
leaq -0x478(%rbp), %rax
movq %rax, -0x470(%rbp)
movq $0x1, -0x468(%rbp)
movl $0x1, %esi
callq 0x1d5a70
movq %rax, -0x958(%rbp)
leaq -0x499(%rbp), %rdi
movq %rdi, -0x950(%rbp)
callq 0x1dfbb0
movq -0x950(%rbp), %rdx
leaq 0x3bc080(%rip), %rsi # 0x62c8de
leaq -0x498(%rbp), %rdi
callq 0x1d5e00
jmp 0x27086c
movq -0x958(%rbp), %rdi
leaq -0x498(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x960(%rbp)
jmp 0x270888
movq -0x960(%rbp), %rdi
movq -0x470(%rbp), %rsi
movq -0x468(%rbp), %rdx
callq 0x1dda30
jmp 0x2708a4
leaq -0x498(%rbp), %rdi
callq 0x1c4d10
leaq -0x499(%rbp), %rdi
callq 0x1cf450
leaq -0x4b8(%rbp), %rdi
movl $0x2, %esi
movl $0xa, %edx
callq 0x1cdbe0
jmp 0x2708d4
movq -0x7b0(%rbp), %rdi
leaq -0x4b8(%rbp), %rax
movq %rax, -0x4b0(%rbp)
movq $0x1, -0x4a8(%rbp)
movl $0x2, %esi
callq 0x1d5a70
movq %rax, -0x970(%rbp)
leaq -0x4d9(%rbp), %rdi
movq %rdi, -0x968(%rbp)
callq 0x1dfbb0
movq -0x968(%rbp), %rdx
leaq 0x3bbfb2(%rip), %rsi # 0x62c8d8
leaq -0x4d8(%rbp), %rdi
callq 0x1d5e00
jmp 0x270934
movq -0x970(%rbp), %rdi
leaq -0x4d8(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x978(%rbp)
jmp 0x270950
movq -0x978(%rbp), %rdi
movq -0x4b0(%rbp), %rsi
movq -0x4a8(%rbp), %rdx
callq 0x1dda30
jmp 0x27096c
leaq -0x4d8(%rbp), %rdi
callq 0x1c4d10
leaq -0x4d9(%rbp), %rdi
callq 0x1cf450
leaq -0x4f8(%rbp), %rdi
movl $0x2, %esi
movl $0xa, %edx
callq 0x1cdbe0
jmp 0x27099c
movq -0x7b0(%rbp), %rdi
leaq -0x4f8(%rbp), %rax
movq %rax, -0x4f0(%rbp)
movq $0x1, -0x4e8(%rbp)
movl $0x1, %esi
callq 0x1d5a70
movq %rax, -0x988(%rbp)
leaq -0x519(%rbp), %rdi
movq %rdi, -0x980(%rbp)
callq 0x1dfbb0
movq -0x980(%rbp), %rdx
leaq 0x3bbeea(%rip), %rsi # 0x62c8d8
leaq -0x518(%rbp), %rdi
callq 0x1d5e00
jmp 0x2709fc
movq -0x988(%rbp), %rdi
leaq -0x518(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x990(%rbp)
jmp 0x270a18
movq -0x990(%rbp), %rdi
movq -0x4f0(%rbp), %rsi
movq -0x4e8(%rbp), %rdx
callq 0x1dda30
jmp 0x270a34
leaq -0x518(%rbp), %rdi
callq 0x1c4d10
leaq -0x519(%rbp), %rdi
callq 0x1cf450
leaq -0x538(%rbp), %rdi
movl $0x2, %esi
movl $0xc, %edx
callq 0x1cdbe0
jmp 0x270a64
movq -0x7b0(%rbp), %rdi
leaq -0x538(%rbp), %rax
movq %rax, -0x530(%rbp)
movq $0x1, -0x528(%rbp)
movl $0x2, %esi
callq 0x1d5a70
movq %rax, -0x9a0(%rbp)
leaq -0x559(%rbp), %rdi
movq %rdi, -0x998(%rbp)
callq 0x1dfbb0
movq -0x998(%rbp), %rdx
leaq 0x3bbe17(%rip), %rsi # 0x62c8cd
leaq -0x558(%rbp), %rdi
callq 0x1d5e00
jmp 0x270ac4
movq -0x9a0(%rbp), %rdi
leaq -0x558(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x9a8(%rbp)
jmp 0x270ae0
movq -0x9a8(%rbp), %rdi
movq -0x530(%rbp), %rsi
movq -0x528(%rbp), %rdx
callq 0x1dda30
jmp 0x270afc
leaq -0x558(%rbp), %rdi
callq 0x1c4d10
leaq -0x559(%rbp), %rdi
callq 0x1cf450
leaq -0x578(%rbp), %rdi
movl $0x2, %esi
movl $0xc, %edx
callq 0x1cdbe0
jmp 0x270b2c
movq -0x7b0(%rbp), %rdi
leaq -0x578(%rbp), %rax
movq %rax, -0x570(%rbp)
movq $0x1, -0x568(%rbp)
movl $0x1, %esi
callq 0x1d5a70
movq %rax, -0x9b8(%rbp)
leaq -0x599(%rbp), %rdi
movq %rdi, -0x9b0(%rbp)
callq 0x1dfbb0
movq -0x9b0(%rbp), %rdx
leaq 0x3bbd4f(%rip), %rsi # 0x62c8cd
leaq -0x598(%rbp), %rdi
callq 0x1d5e00
jmp 0x270b8c
movq -0x9b8(%rbp), %rdi
leaq -0x598(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x9c0(%rbp)
jmp 0x270ba8
movq -0x9c0(%rbp), %rdi
movq -0x570(%rbp), %rsi
movq -0x568(%rbp), %rdx
callq 0x1dda30
jmp 0x270bc4
leaq -0x598(%rbp), %rdi
callq 0x1c4d10
leaq -0x599(%rbp), %rdi
callq 0x1cf450
leaq -0x5b8(%rbp), %rdi
movl $0x3, %esi
movl $0xd, %edx
callq 0x1cdbe0
jmp 0x270bf4
movq -0x7b0(%rbp), %rdi
leaq -0x5b8(%rbp), %rax
movq %rax, -0x5b0(%rbp)
movq $0x1, -0x5a8(%rbp)
movl $0x2, %esi
callq 0x1d5a70
movq %rax, -0x9d0(%rbp)
leaq -0x5d9(%rbp), %rdi
movq %rdi, -0x9c8(%rbp)
callq 0x1dfbb0
movq -0x9c8(%rbp), %rdx
leaq 0x3bbc8a(%rip), %rsi # 0x62c8d0
leaq -0x5d8(%rbp), %rdi
callq 0x1d5e00
jmp 0x270c54
movq -0x9d0(%rbp), %rdi
leaq -0x5d8(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x9d8(%rbp)
jmp 0x270c70
movq -0x9d8(%rbp), %rdi
movq -0x5b0(%rbp), %rsi
movq -0x5a8(%rbp), %rdx
callq 0x1dda30
jmp 0x270c8c
leaq -0x5d8(%rbp), %rdi
callq 0x1c4d10
leaq -0x5d9(%rbp), %rdi
callq 0x1cf450
leaq -0x5f8(%rbp), %rdi
movl $0x3, %esi
movl $0xd, %edx
callq 0x1cdbe0
jmp 0x270cbc
movq -0x7b0(%rbp), %rdi
leaq -0x5f8(%rbp), %rax
movq %rax, -0x5f0(%rbp)
movq $0x1, -0x5e8(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1d5a70
movq %rax, -0x9e8(%rbp)
leaq -0x619(%rbp), %rdi
movq %rdi, -0x9e0(%rbp)
callq 0x1dfbb0
movq -0x9e0(%rbp), %rdx
leaq 0x3bbbc3(%rip), %rsi # 0x62c8d0
leaq -0x618(%rbp), %rdi
callq 0x1d5e00
jmp 0x270d1b
movq -0x9e8(%rbp), %rdi
leaq -0x618(%rbp), %rsi
callq 0x1e4160
movq %rax, -0x9f0(%rbp)
jmp 0x270d37
movq -0x9f0(%rbp), %rdi
movq -0x5f0(%rbp), %rsi
movq -0x5e8(%rbp), %rdx
callq 0x1dda30
jmp 0x270d53
leaq -0x618(%rbp), %rdi
callq 0x1c4d10
leaq -0x619(%rbp), %rdi
callq 0x1cf450
leaq -0x638(%rbp), %rdi
movl $0x2, %esi
movl $0xe, %edx
callq 0x1cdbe0
jmp 0x270d83
movq -0x7b0(%rbp), %rdi
leaq -0x638(%rbp), %rax
movq %rax, -0x630(%rbp)
movq $0x1, -0x628(%rbp)
movl $0x2, %esi
callq 0x1d5a70
movq %rax, -0xa00(%rbp)
leaq -0x659(%rbp), %rdi
movq %rdi, -0x9f8(%rbp)
callq 0x1dfbb0
movq -0x9f8(%rbp), %rdx
leaq 0x3bbb00(%rip), %rsi # 0x62c8d5
leaq -0x658(%rbp), %rdi
callq 0x1d5e00
jmp 0x270de3
movq -0xa00(%rbp), %rdi
leaq -0x658(%rbp), %rsi
callq 0x1e4160
movq %rax, -0xa08(%rbp)
jmp 0x270dff
movq -0xa08(%rbp), %rdi
movq -0x630(%rbp), %rsi
movq -0x628(%rbp), %rdx
callq 0x1dda30
jmp 0x270e1b
leaq -0x658(%rbp), %rdi
callq 0x1c4d10
leaq -0x659(%rbp), %rdi
callq 0x1cf450
leaq -0x678(%rbp), %rdi
movl $0x2, %esi
movl $0xe, %edx
callq 0x1cdbe0
jmp 0x270e4b
movq -0x7b0(%rbp), %rdi
leaq -0x678(%rbp), %rax
movq %rax, -0x670(%rbp)
movq $0x1, -0x668(%rbp)
movl $0x1, %esi
callq 0x1d5a70
movq %rax, -0xa18(%rbp)
leaq -0x699(%rbp), %rdi
movq %rdi, -0xa10(%rbp)
callq 0x1dfbb0
movq -0xa10(%rbp), %rdx
leaq 0x3bba38(%rip), %rsi # 0x62c8d5
leaq -0x698(%rbp), %rdi
callq 0x1d5e00
jmp 0x270eab
movq -0xa18(%rbp), %rdi
leaq -0x698(%rbp), %rsi
callq 0x1e4160
movq %rax, -0xa20(%rbp)
jmp 0x270ec7
movq -0xa20(%rbp), %rdi
movq -0x670(%rbp), %rsi
movq -0x668(%rbp), %rdx
callq 0x1dda30
jmp 0x270ee3
leaq -0x698(%rbp), %rdi
callq 0x1c4d10
leaq -0x699(%rbp), %rdi
callq 0x1cf450
leaq -0x6b8(%rbp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x1cdbe0
jmp 0x270f13
movq -0x7b0(%rbp), %rdi
leaq -0x6b8(%rbp), %rax
movq %rax, -0x6b0(%rbp)
movq $0x1, -0x6a8(%rbp)
movl $0x2, %esi
callq 0x1d5a70
movq %rax, -0xa30(%rbp)
leaq -0x6d9(%rbp), %rdi
movq %rdi, -0xa28(%rbp)
callq 0x1dfbb0
movq -0xa28(%rbp), %rdx
leaq 0x3bb976(%rip), %rsi # 0x62c8db
leaq -0x6d8(%rbp), %rdi
callq 0x1d5e00
jmp 0x270f73
movq -0xa30(%rbp), %rdi
leaq -0x6d8(%rbp), %rsi
callq 0x1e4160
movq %rax, -0xa38(%rbp)
jmp 0x270f8f
movq -0xa38(%rbp), %rdi
movq -0x6b0(%rbp), %rsi
movq -0x6a8(%rbp), %rdx
callq 0x1dda30
jmp 0x270fab
leaq -0x6d8(%rbp), %rdi
callq 0x1c4d10
leaq -0x6d9(%rbp), %rdi
callq 0x1cf450
leaq -0x6f8(%rbp), %rdi
movl $0x2, %esi
movl $0x10, %edx
callq 0x1cdbe0
jmp 0x270fdb
movq -0x7b0(%rbp), %rdi
leaq -0x6f8(%rbp), %rax
movq %rax, -0x6f0(%rbp)
movq $0x1, -0x6e8(%rbp)
movl $0x1, %esi
callq 0x1d5a70
movq %rax, -0xa48(%rbp)
leaq -0x719(%rbp), %rdi
movq %rdi, -0xa40(%rbp)
callq 0x1dfbb0
movq -0xa40(%rbp), %rdx
leaq 0x3bb8ae(%rip), %rsi # 0x62c8db
leaq -0x718(%rbp), %rdi
callq 0x1d5e00
jmp 0x27103b
movq -0xa48(%rbp), %rdi
leaq -0x718(%rbp), %rsi
callq 0x1e4160
movq %rax, -0xa50(%rbp)
jmp 0x271057
movq -0xa50(%rbp), %rdi
movq -0x6f0(%rbp), %rsi
movq -0x6e8(%rbp), %rdx
callq 0x1dda30
jmp 0x271073
leaq -0x718(%rbp), %rdi
callq 0x1c4d10
leaq -0x719(%rbp), %rdi
callq 0x1cf450
leaq -0x738(%rbp), %rdi
movl $0x2, %esi
movl $0x16, %edx
callq 0x1cdbe0
jmp 0x2710a3
movq -0x7b0(%rbp), %rdi
leaq -0x738(%rbp), %rax
movq %rax, -0x730(%rbp)
movq $0x1, -0x728(%rbp)
movl $0x2, %esi
callq 0x1d5a70
movq %rax, -0xa60(%rbp)
leaq -0x759(%rbp), %rdi
movq %rdi, -0xa58(%rbp)
callq 0x1dfbb0
movq -0xa58(%rbp), %rdx
leaq 0x3bb7ec(%rip), %rsi # 0x62c8e1
leaq -0x758(%rbp), %rdi
callq 0x1d5e00
jmp 0x271103
movq -0xa60(%rbp), %rdi
leaq -0x758(%rbp), %rsi
callq 0x1e4160
movq %rax, -0xa68(%rbp)
jmp 0x27111f
movq -0xa68(%rbp), %rdi
movq -0x730(%rbp), %rsi
movq -0x728(%rbp), %rdx
callq 0x1dda30
jmp 0x27113b
leaq -0x758(%rbp), %rdi
callq 0x1c4d10
leaq -0x759(%rbp), %rdi
callq 0x1cf450
leaq -0x778(%rbp), %rdi
movl $0x2, %esi
movl $0x16, %edx
callq 0x1cdbe0
jmp 0x27116b
movq -0x7b0(%rbp), %rdi
leaq -0x778(%rbp), %rax
movq %rax, -0x770(%rbp)
movq $0x1, -0x768(%rbp)
movl $0x1, %esi
callq 0x1d5a70
movq %rax, -0xa78(%rbp)
leaq -0x799(%rbp), %rdi
movq %rdi, -0xa70(%rbp)
callq 0x1dfbb0
movq -0xa70(%rbp), %rdx
leaq 0x3bb724(%rip), %rsi # 0x62c8e1
leaq -0x798(%rbp), %rdi
callq 0x1d5e00
jmp 0x2711cb
movq -0xa78(%rbp), %rdi
leaq -0x798(%rbp), %rsi
callq 0x1e4160
movq %rax, -0xa80(%rbp)
jmp 0x2711e7
movq -0xa80(%rbp), %rdi
movq -0x770(%rbp), %rsi
movq -0x768(%rbp), %rdx
callq 0x1dda30
jmp 0x271203
leaq -0x798(%rbp), %rdi
callq 0x1c4d10
leaq -0x799(%rbp), %rdi
callq 0x1cf450
jmp 0x27151c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x271246
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x458(%rbp), %rdi
callq 0x1c4d10
leaq -0x459(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x27127d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x498(%rbp), %rdi
callq 0x1c4d10
leaq -0x499(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2712b4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x4d8(%rbp), %rdi
callq 0x1c4d10
leaq -0x4d9(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2712eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x518(%rbp), %rdi
callq 0x1c4d10
leaq -0x519(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x271322
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x558(%rbp), %rdi
callq 0x1c4d10
leaq -0x559(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x271359
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x598(%rbp), %rdi
callq 0x1c4d10
leaq -0x599(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x271390
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x5d8(%rbp), %rdi
callq 0x1c4d10
leaq -0x5d9(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2713c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x618(%rbp), %rdi
callq 0x1c4d10
leaq -0x619(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2713fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x658(%rbp), %rdi
callq 0x1c4d10
leaq -0x659(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x271435
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x698(%rbp), %rdi
callq 0x1c4d10
leaq -0x699(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x27146c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x6d8(%rbp), %rdi
callq 0x1c4d10
leaq -0x6d9(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2714a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x718(%rbp), %rdi
callq 0x1c4d10
leaq -0x719(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x2714da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x758(%rbp), %rdi
callq 0x1c4d10
leaq -0x759(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x27150e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x798(%rbp), %rdi
callq 0x1c4d10
leaq -0x799(%rbp), %rdi
callq 0x1cf450
jmp 0x271546
jmp 0x27151e
jmp 0x271520
movb $0x1, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
jne 0x271536
movq -0x7b0(%rbp), %rdi
callq 0x1e30e0
movq -0x7a8(%rbp), %rax
addq $0xa80, %rsp # imm = 0xA80
popq %rbp
retq
movq -0x7b0(%rbp), %rdi
callq 0x1e30e0
movq -0x30(%rbp), %rdi
callq 0x1dfa40
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_assoc.cpp |
1,554 | std::array<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>, 3ul>::operator[](unsigned long) const | constexpr const_reference
operator[](size_type __n) const noexcept
{
#if __cplusplus >= 201402L
__glibcxx_requires_subscript(__n);
#endif
return _AT_Type::_S_ref(_M_elems, __n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1bdd40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/array |
1,555 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>::begin() const | const_iterator
begin() const _GLIBCXX_NOEXCEPT
{ return _M_t.begin(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1d01d0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
1,556 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>::end() const | const_iterator
end() const _GLIBCXX_NOEXCEPT
{ return _M_t.end(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1c2ba0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
1,557 | std::operator!=(std::_Rb_tree_const_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>> const&, std::_Rb_tree_const_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>> const&) | bool
operator!=(const _Self& __x, const _Self& __y) _GLIBCXX_NOEXCEPT
{ return __x._M_node != __y._M_node; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
setne %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,558 | std::_Rb_tree_const_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>::operator*() const | reference
operator*() const _GLIBCXX_NOEXCEPT
{ return *static_cast<_Link_type>(_M_node)->_M_valptr(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1e0b40
movq %rax, -0x10(%rbp)
jmp 0x27168e
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,559 | std::array<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Omega_h::Read<int>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>, 3ul>::operator[](unsigned long) | _GLIBCXX17_CONSTEXPR reference
operator[](size_type __n) noexcept
{
__glibcxx_requires_subscript(__n);
return _AT_Type::_S_ref(_M_elems, __n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1d2e60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/array |
1,560 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Omega_h::Read<int>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | mapped_type&
operator[](const key_type& __k)
{
// concept requirements
__glibcxx_function_requires(_DefaultConstructibleConcept<mapped_type>)
iterator __i = lower_bound(__k);
// __i->first is greater than or equivalent to __k.
if (__i == end() || key_comp()(__k, (*__i).first))
#if __cplusplus >= 201103L
__i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
std::tuple<const key_type&>(__k),
std::tuple<>());
#else
__i = insert(__i, value_type(__k, mapped_type()));
#endif
return (*__i).second;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1dcfd0
movq -0x50(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x1db040
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1d0980
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x42(%rbp)
jne 0x271748
movq -0x50(%rbp), %rdi
callq 0x1bd540
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1ba920
movq -0x58(%rbp), %rsi
movq %rax, %rdx
leaq -0x21(%rbp), %rdi
callq 0x1cfbf0
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x271751
jmp 0x271793
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1bb760
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1c37f0
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq 0x3bb188(%rip), %rdx # 0x62c902
leaq -0x40(%rbp), %rcx
leaq -0x41(%rbp), %r8
callq 0x1cbd60
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1ba920
addq $0x20, %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
1,561 | std::_Rb_tree_const_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>::operator++() | _Self&
operator++() _GLIBCXX_NOEXCEPT
{
_M_node = _Rb_tree_increment(_M_node);
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x1d1740
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,562 | std::operator|(std::_Ios_Openmode, std::_Ios_Openmode) | inline _GLIBCXX_CONSTEXPR _Ios_Openmode
operator|(_Ios_Openmode __a, _Ios_Openmode __b)
{ return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); } | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
orl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/ios_base.h |
1,563 | std::array<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>, 3ul>::operator[](unsigned long) | _GLIBCXX17_CONSTEXPR reference
operator[](size_type __n) noexcept
{
__glibcxx_requires_subscript(__n);
return _AT_Type::_S_ref(_M_elems, __n);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1bdd40
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/array |
1,564 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | mapped_type&
operator[](const key_type& __k)
{
// concept requirements
__glibcxx_function_requires(_DefaultConstructibleConcept<mapped_type>)
iterator __i = lower_bound(__k);
// __i->first is greater than or equivalent to __k.
if (__i == end() || key_comp()(__k, (*__i).first))
#if __cplusplus >= 201103L
__i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
std::tuple<const key_type&>(__k),
std::tuple<>());
#else
__i = insert(__i, value_type(__k, mapped_type()));
#endif
return (*__i).second;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1bae40
movq -0x50(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x1db6b0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1c6580
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x42(%rbp)
jne 0x2718f8
movq -0x50(%rbp), %rdi
callq 0x1dddb0
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1dd750
movq -0x58(%rbp), %rsi
movq %rax, %rdx
leaq -0x21(%rbp), %rdi
callq 0x1cfbf0
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x271901
jmp 0x271943
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1c9eb0
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1c37f0
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq 0x3bafd8(%rip), %rdx # 0x62c902
leaq -0x40(%rbp), %rcx
leaq -0x41(%rbp), %r8
callq 0x1bee40
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1dd750
addq $0x20, %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
1,565 | std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>::push_back(Omega_h::ClassPair&&) | void
push_back(value_type&& __x)
{ emplace_back(std::move(__x)); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c5120
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,566 | Omega_h::ClassPair::ClassPair(int, int) | inline ClassPair(Int t_dim, LO t_id) : dim(t_dim), id(t_id) {} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4(%rax)
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | gahansen[P]omega_h/src/Omega_h_mesh.hpp |
1,567 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>::operator[](std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&&) | mapped_type&
operator[](key_type&& __k)
{
// concept requirements
__glibcxx_function_requires(_DefaultConstructibleConcept<mapped_type>)
iterator __i = lower_bound(__k);
// __i->first is greater than or equivalent to __k.
if (__i == end() || key_comp()(__k, (*__i).first))
__i = _M_t._M_emplace_hint_unique(__i, std::piecewise_construct,
std::forward_as_tuple(std::move(__k)),
std::tuple<>());
return (*__i).second;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1bae40
movq -0x50(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x1db6b0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1c6580
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x42(%rbp)
jne 0x271ac8
movq -0x50(%rbp), %rdi
callq 0x1dddb0
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1dd750
movq -0x58(%rbp), %rsi
movq %rax, %rdx
leaq -0x21(%rbp), %rdi
callq 0x1cfbf0
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
testb $0x1, %al
jne 0x271ad1
jmp 0x271b13
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1c9eb0
movq -0x10(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x1bced0
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
leaq 0x3bae08(%rip), %rdx # 0x62c902
leaq -0x40(%rbp), %rcx
leaq -0x41(%rbp), %r8
callq 0x1bb2b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1dd750
addq $0x20, %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
1,568 | std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>::operator=(std::initializer_list<Omega_h::ClassPair>) | vector&
operator=(initializer_list<value_type> __l)
{
this->_M_assign_aux(__l.begin(), __l.end(),
random_access_iterator_tag());
return *this;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1c9e20
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x1c4b70
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdi
movq %rax, %rdx
callq 0x1b8fc0
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_vector.h |
1,569 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Omega_h::Read<int>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::map() | map() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cf560
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
1,570 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::_Rb_tree() | _Rb_tree() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d5220
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,571 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::_Rb_tree_impl<std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, true>::_Rb_tree_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Node_allocator>::value
&& is_nothrow_default_constructible<_Base_key_compare>::value )
: _Node_allocator()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1bd260
movq -0x10(%rbp), %rdi
callq 0x1dd7e0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d8bc0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,572 | std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d60f0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
1,573 | _gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
1,574 | std::__array_traits<std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>, 3ul>::_S_ref(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>> const (&) [3], unsigned long) | static constexpr _Tp&
_S_ref(const _Type& __t, std::size_t __n) noexcept
{ return const_cast<_Tp&>(__t[__n]); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
imulq $0x30, -0x10(%rbp), %rcx
addq %rcx, %rax
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/array |
1,575 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Omega_h::Read<int>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::~map() | ~map() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bb950
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
1,576 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::~_Rb_tree() | ~_Rb_tree() _GLIBCXX_NOEXCEPT
{ _M_erase(_M_begin()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1cd500
movq -0x10(%rbp), %rdi
movq %rax, %rsi
callq 0x1bf480
jmp 0x271c97
movq -0x10(%rbp), %rdi
callq 0x1cd110
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,577 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::_M_begin() | _Link_type
_M_begin() _GLIBCXX_NOEXCEPT
{ return _M_mbegin(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d5110
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,578 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::_S_right(std::_Rb_tree_node_base*) | static _Link_type
_S_right(_Base_ptr __x) _GLIBCXX_NOEXCEPT
{ return static_cast<_Link_type>(__x->_M_right); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,579 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::_S_left(std::_Rb_tree_node_base*) | static _Link_type
_S_left(_Base_ptr __x) _GLIBCXX_NOEXCEPT
{ return static_cast<_Link_type>(__x->_M_left); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,580 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::_M_drop_node(std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>*) | void
_M_drop_node(_Link_type __p) _GLIBCXX_NOEXCEPT
{
_M_destroy_node(__p);
_M_put_node(__p);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x1cf9f0
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1db4d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,581 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::_M_destroy_node(std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>*) | void
_M_destroy_node(_Link_type __p) _GLIBCXX_NOEXCEPT
{
#if __cplusplus < 201103L
get_allocator().destroy(__p->_M_valptr());
#else
_Alloc_traits::destroy(_M_get_Node_allocator(), __p->_M_valptr());
__p->~_Rb_tree_node<_Val>();
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d5f00
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1e3390
movq %rax, -0x18(%rbp)
jmp 0x271dfc
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdi
callq 0x1d6d40
addq $0x20, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,582 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::_M_put_node(std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>*) | void
_M_put_node(_Link_type __p) _GLIBCXX_NOEXCEPT
{ _Alloc_traits::deallocate(_M_get_Node_allocator(), __p, 1); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d5f00
movq %rax, %rdi
movq -0x10(%rbp), %rsi
movl $0x1, %edx
callq 0x1cfcf0
jmp 0x271e4c
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x1e9370
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,583 | void std::allocator_traits<std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>>::destroy<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>(std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>*) | static _GLIBCXX20_CONSTEXPR void
destroy(allocator_type& __a __attribute__((__unused__)), _Up* __p)
noexcept(is_nothrow_destructible<_Up>::value)
{
#if __cplusplus <= 201703L
__a.destroy(__p);
#else
std::destroy_at(__p);
#endif
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1cdfa0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
1,584 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::_M_get_Node_allocator() | const _Node_allocator&
_M_get_Node_allocator() const _GLIBCXX_NOEXCEPT
{ return this->_M_impl; } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,585 | std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>::_M_valptr() | const _Val*
_M_valptr() const
{ return _M_storage._M_ptr(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x20, %rdi
callq 0x1cee90
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,586 | void __gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::destroy<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>*) | void
destroy(_Up* __p)
noexcept(std::is_nothrow_destructible<_Up>::value)
{ __p->~_Up(); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1be5f0
addq $0x10, %rsp
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
1,587 | _gnu_cxx::__aligned_membuf<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>::_M_ptr() | _Tp*
_M_ptr() noexcept
{ return static_cast<_Tp*>(_M_addr()); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1cb0d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/aligned_buffer.h |
1,588 | _gnu_cxx::__aligned_membuf<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>::_M_addr() | void*
_M_addr() noexcept
{ return static_cast<void*>(&_M_storage); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/aligned_buffer.h |
1,589 | std::allocator_traits<std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>>::deallocate(std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>&, std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>*, unsigned long) | static _GLIBCXX20_CONSTEXPR void
deallocate(allocator_type& __a, pointer __p, size_type __n)
{ __a.deallocate(__p, __n); } | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1dcf30
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/alloc_traits.h |
1,590 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::_M_mbegin() const | _Link_type
_M_mbegin() const _GLIBCXX_NOEXCEPT
{ return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,591 | std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::~allocator() | [[nodiscard,__gnu__::__always_inline__]]
constexpr _Tp*
allocate(size_t __n)
{
#ifdef __cpp_lib_is_constant_evaluated
if (std::is_constant_evaluated())
return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
#endif
return __allocator_base<_Tp>::allocate(__n, 0);
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1bacb0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
1,592 | _gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, Omega_h::Read<int>>>>::~new_allocator() | ~new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
1,593 | std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>::map() | map() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1d86e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_map.h |
1,594 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>::_Rb_tree() | _Rb_tree() = default; | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1dda60
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,595 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>::_Rb_tree_impl<std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, true>::_Rb_tree_impl() | _GLIBCXX_NOEXCEPT_IF(
is_nothrow_default_constructible<_Node_allocator>::value
&& is_nothrow_default_constructible<_Base_key_compare>::value )
: _Node_allocator()
{ } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x1df750
movq -0x10(%rbp), %rdi
callq 0x1dd7e0
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
callq 0x1d8bc0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,596 | std::allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>::allocator() | _GLIBCXX20_CONSTEXPR
allocator() _GLIBCXX_NOTHROW { } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1b95e0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/allocator.h |
1,597 | _gnu_cxx::new_allocator<std::_Rb_tree_node<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>::new_allocator() | _GLIBCXX20_CONSTEXPR
new_allocator() _GLIBCXX_USE_NOEXCEPT { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/ext/new_allocator.h |
1,598 | std::_Rb_tree<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>, std::_Select1st<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>>::begin() const | const_iterator
begin() const _GLIBCXX_NOEXCEPT
{ return const_iterator(this->_M_impl._M_header._M_left); } | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
leaq -0x8(%rbp), %rdi
callq 0x1c4020
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
1,599 | std::_Rb_tree_const_iterator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::vector<Omega_h::ClassPair, std::allocator<Omega_h::ClassPair>>>>::_Rb_tree_const_iterator(std::_Rb_tree_node_base const*) | explicit
_Rb_tree_const_iterator(_Base_ptr __x) _GLIBCXX_NOEXCEPT
: _M_node(__x) { } | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
popq %rbp
retq
nopl (%rax)
| gahansen[P]omega_h[P]build_O0[P]src[P]libomega_h.so.asm_src.json | O0 | /usr/lib/gcc/x86_64-linux-gnu/11/../../../../include/c++/11/bits/stl_tree.h |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.