name string | code string | asm string | file string |
|---|---|---|---|
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int c... | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, 0x58(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x57ce8(%rip), %rdx # 0x45c344
fldt 0xf0(%rsp)
fldt 0xe0(%rsp)
fldt 0xd0(%rsp)
fstpt 0x80(%rsp)
fstpt 0x70(%rsp)
fstpt 0x60(%rsp)
pushq $0x14
popq %rsi
leaq 0... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::compute_order::local_compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx... | int local_compute_violated_constraints(const Solver& slv, const Xtype& x)
{
int remaining = 0;
for (int k = 0; k != slv.m; ++k)
if (!is_valid_constraint(slv, k, x))
++remaining;
return remaining;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpl 0x180(%r14), %r15d
je 0x4048d9
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x403d4d
xorb $0x1, %al
incl %r15d
movzbl %al, %eax
addl %eax, %ebp
jmp 0x4048b6
movl %ebp, %eax
addq $0x8, ... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::branch_and_bound_solver<baryonyx::itm::maximize_tag, long double>::solve<std::unique_ptr<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, true>::rc_data [], std::default_delete<baryonyx::itm::solver_inequalities_Zcoeff<... | int solve(R& reduced_cost, int r_size, int bk_min, int bk_max)
{
bx_assert(r_size >= 4);
bx_assert(bk_min <= bk_max);
b_min = bk_min;
b_max = bk_max;
items.resize(r_size);
if (!subvector.init(r_size))
throw solver_failure(solver_error_tag::no_solver_avai... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x3, %edx
jle 0x404c80
cmpl %r8d, %ecx
jg 0x404ca1
leaq 0x20(%rdi), %r13
movl %ecx, 0x74(%rdi)
movl %edx, %ebx
movq %rsi, %r14
movl %edx, %r12d
movq %rdi, %r15
movl %r8d, 0x78(%rdi)
movq %r12, %rsi
movq %r13, %rdi
callq 0x405a4e
movq %r1... | /quesnel[P]baryonyx/lib/src/branch-and-bound-solver.hpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::default_cost_type<long double>, false>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>(baryony... | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, 0x58(%rsp)
leaq 0x10(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
fldt 0xe0(%rsp)
fstpt 0x7c(%rsp)
fldt 0xd0(%rsp)
fstpt 0x70(%rsp)
fldt 0xc0(%rsp)
fstpt 0x64(%rsp)
movq %rax, 0x50(%rsp)
leaq 0x60(%rdi), %rax
mo... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, true>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>... | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, 0x68(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x3fb3d(%rip), %rdx # 0x45c33f
fldt 0x120(%rsp)
fstpt 0x74(%rsp)
fldt 0x110(%rsp)
fldt 0x100(%rsp)
fldt 0xf0(%rsp)
fstpt 0xa0(%rsp)
fstpt 0x90(%rsp)
fstpt 0x8... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, true>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_ite... | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rcx, 0x68(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x3f849(%rip), %rdx # 0x45c33f
fldt 0x120(%rsp)
fstpt 0x74(%rsp)
fldt 0x110(%rsp)
fldt 0x100(%rsp)
fldt 0xf0(%rsp)
fstpt 0xa0(%rsp)
fstpt 0x90(%rsp)
fstpt 0x8... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, true>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, baryonyx::file_observer>::operator()(std::vector<baryonyx::... | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x548, %rsp # imm = 0x548
vmovsd %xmm0, 0x88(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x60(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, true>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, baryonyx::none_observer>::operator()(std::vector<baryonyx::... | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x308, %rsp # imm = 0x308
vmovsd %xmm0, 0x80(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x58(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, true>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, baryonyx::pnm_observer>::store_if_better(baryonyx::bit_arra... | inline bool
is_better_solution(Float lhs, Float rhs) noexcept
{
if constexpr (std::is_same_v<Mode, minimize_tag>)
return lhs < rhs;
else
return lhs > rhs;
} | vucomisd 0x30(%rdi), %xmm0
jbe 0x41f70c
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x20, %rdi
movq %rdx, %rbx
vmovsd %xmm0, (%rsp)
callq 0x36a44
movq %r14, %rdi
callq 0x41f786
vmovsd (%rsp), %xmm1
vmovsd %xmm0, 0x38(%r14)
movq %rbx, 0x48(%r14)
andl $0x0, 0x50(%r14)
vmovsd %xmm1, 0x30(%r14)
addq $0x8, %rsp
p... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, true>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, baryonyx::pnm_observer>::is_timelimit_reached() | bool is_timelimit_reached()
{
m_end = std::chrono::steady_clock::now();
return is_time_limit(m_ctx.parameters.time_limit, m_begin, m_end);
} | pushq %rbx
movq %rdi, %rbx
callq 0xb5a0
movq %rax, 0x8(%rbx)
vxorpd %xmm2, %xmm2, %xmm2
movq 0x10(%rbx), %rcx
subq (%rbx), %rax
vmovsd (%rcx), %xmm0
vcvtsi2sd %rax, %xmm1, %xmm1
vdivsd 0x3a311(%rip), %xmm1, %xmm1 # 0x459a80
vcmpnlepd %xmm2, %xmm0, %k1
vcmpltpd %xmm1, %xmm0, %k0 {%k1}
kmovd %k0, %eax
andb $0x1, %al
popq... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, true>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, baryonyx::none_observer>::is_timelimit_reached() | bool is_timelimit_reached()
{
m_end = std::chrono::steady_clock::now();
return is_time_limit(m_ctx.parameters.time_limit, m_begin, m_end);
} | pushq %rbx
movq %rdi, %rbx
callq 0xb5a0
movq %rax, 0x8(%rbx)
vxorpd %xmm2, %xmm2, %xmm2
movq 0x10(%rbx), %rcx
subq (%rbx), %rax
vmovsd (%rcx), %xmm0
vcvtsi2sd %rax, %xmm1, %xmm1
vdivsd 0x3a14d(%rip), %xmm1, %xmm1 # 0x459a80
vcmpnlepd %xmm2, %xmm0, %k1
vcmpltpd %xmm1, %xmm0, %k0 {%k1}
kmovd %k0, %eax
andb $0x1, %al
popq... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::solver_inequalities_Zcoeff(std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, int, int, baryonyx::itm::quadratic_cost_type<long double> const&, std::vect... | solver_inequalities_Zcoeff(random_engine& rng_,
int m_,
int n_,
const cost_type& c_,
const std::vector<merged_constraint>& csts)
: logger("solver_inequalities_Zcoeff")
, rng(rng_)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
andq $0x0, (%rdi)
leaq 0x10(%rdi), %rbx
movq %rsi, 0x8(%rdi)
movq %rdi, %r15
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %r12d
movq %r9, 0x28(%rsp)
movq %r9, %rsi
movq %rbx, %rdi
callq 0x3a4ca
movl 0x38(%r15), %esi
leaq 0x50(%r15), %r13
mo... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::compute_order::run<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>, baryonyx::bit_array, long double>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadrati... | int run(Solver& solver,
Xtype& x,
random_engine& rng,
Float kappa,
Float delta,
Float theta)
{
bool pi_changed = false;
int remaining = 0;
switch (order) {
case solver_parameters::constraint_order::reversing:
so... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
fldt 0xb0(%rsp)
fldt 0xa0(%rsp)
fldt 0x90(%rsp)
movl 0x30(%rdi), %eax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
decl %eax
cmpl $0x6, %eax
ja 0x420899
leaq 0x45ee8(%rip), %rdx # 0x46669c
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%r14), %rax... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::compute_order::push_and_run<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>, baryonyx::bit_array, long double>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm:... | int push_and_run(Solver& solver,
Xtype& x,
random_engine& rng,
Float kappa,
Float delta,
Float theta,
Float objective_amplifier)
{
bool pi_changed = 0;
int remaining = 0;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
fldt 0xd0(%rsp)
fldt 0xc0(%rsp)
fldt 0xb0(%rsp)
fldt 0xa0(%rsp)
movl 0x30(%rdi), %eax
cmpb $0x1, 0x34(%rdi)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
jne 0x4209f3
xorl %esi, %esi
leal 0x1(%rax), %edx
cmpl $0x7, %eax
cmovll %edx, %esi
movl %esi, %eax
movl %esi, 0x3... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::compute_order::infeasibility_local_compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false> const, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm:... | int infeasibility_local_compute_violated_constraints(Solver& solver,
const Xtype& x)
{
m_order.clear();
for (int k = 0, e = solver.m; k != e; ++k) {
sparse_matrix<int>::const_row_iterator it, et;
std::tie(it, et) = sol... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x18(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
cmpq %rax, 0x20(%rdi)
je 0x420df2
movq %rax, 0x20(%rdi)
leaq 0x18(%rdi), %rax
leaq 0x10(%r15), %rcx
xorl %r12d, %r12d
movq %rdi, 0x20(%rsp)
movq %rax, 0x10(%rsp)
movl 0x180(%r15), %ea... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_c... | int
compute_violated_constraints(const Solver& slv,
const Xtype& x,
std::vector<int>& out)
{
out.clear();
for (int k = 0; k != slv.m; ++k)
if (!is_valid_constraint(slv, k, x))
out.emplace_back(k);
return length(out);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq %rax, 0x8(%rdx)
je 0x420ef0
movq %rax, 0x8(%rbx)
leaq 0x4(%rsp), %r12
xorl %esi, %esi
movl %esi, 0x4(%rsp)
cmpl 0x180(%r15), %esi
je 0x420f26
movq %r15, %rdi
movq %r14, %rdx
callq 0x420f3d
testb... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
bool baryonyx::itm::is_valid_constraint<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type... | bool
is_valid_constraint(const Solver& slv, int k, const Xtype& x)
{
typename sparse_matrix<int>::const_row_iterator it, et;
std::tie(it, et) = slv.ap.row(k);
int v = 0;
for (; it != et; ++it)
v += slv.factor(it->value) * x[it->column];
return slv.bound_min(k) <= v && v <= slv.bound_max(k... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %edx
leaq 0x10(%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
movq %r15, %rdi
callq 0x3c868
movq (%r15), %r12
movq 0x8(%r15), %r13
xorl %r15d, %r15d
cmpq %r12, %r13
je 0x420f9a
movslq (%r... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::compute_update_row<baryonyx::bit_array, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>>(baryonyx::bit_array&, std::rev... | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, 0x58(%rsp)
leaq 0x10(%rdi), %rax
leaq 0x60(%rdi), %rcx
movq %rsi, %r15
leaq 0x100(%rdi), %rsi
movq %rdi, %r12
xorl %ebp, %ebp
fldt 0xe0(%rsp)
fstpt 0x7c(%rsp)
fldt 0xd0(%rsp)
fstpt 0x70(%rsp)
fldt 0xc0(%rsp)
fstpt 0x64(%rsp)
m... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int*, st... | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, 0x58(%rsp)
leaq 0x10(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
fldt 0xe0(%rsp)
fstpt 0x7c(%rsp)
fldt 0xd0(%rsp)
fstpt 0x70(%rsp)
fldt 0xc0(%rsp)
fstpt 0x64(%rsp)
movq %rax, 0x50(%rsp)
leaq 0x60(%rdi), %rax
mo... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>(baryo... | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, 0x58(%rsp)
leaq 0x10(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
fldt 0xe0(%rsp)
fstpt 0x7c(%rsp)
fldt 0xd0(%rsp)
fstpt 0x70(%rsp)
fldt 0xc0(%rsp)
fstpt 0x64(%rsp)
movq %rax, 0x50(%rsp)
leaq 0x60(%rdi), %rax
mo... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::compute_order::infeasibility_local_compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maxim... | int infeasibility_local_compute_violated_constraints(Solver& solver,
const Xtype& x)
{
m_order.clear();
for (int k = 0, e = solver.m; k != e; ++k) {
sparse_matrix<int>::const_row_iterator it, et;
std::tie(it, et) = sol... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x18(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
cmpq %rax, 0x20(%rdi)
je 0x4216ba
movq %rax, 0x20(%rdi)
leaq 0x18(%rdi), %rax
leaq 0x10(%r15), %rcx
xorl %r12d, %r12d
movq %rdi, 0x20(%rsp)
movq %rax, 0x10(%rsp)
movl 0x180(%r15), %ea... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<in... | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, 0x58(%rsp)
leaq 0x10(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
fldt 0xe0(%rsp)
fstpt 0x7c(%rsp)
fldt 0xd0(%rsp)
fstpt 0x70(%rsp)
fldt 0xc0(%rsp)
fstpt 0x64(%rsp)
movq %rax, 0x50(%rsp)
leaq 0x60(%rdi), %rax
mo... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::compute_order::local_compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryo... | int local_compute_violated_constraints(const Solver& slv, const Xtype& x)
{
int remaining = 0;
for (int k = 0; k != slv.m; ++k)
if (!is_valid_constraint(slv, k, x))
++remaining;
return remaining;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpl 0x180(%r14), %r15d
je 0x421a0f
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x420f3d
xorb $0x1, %al
incl %r15d
movzbl %al, %eax
addl %eax, %ebp
jmp 0x4219ec
movl %ebp, %eax
addq $0x8, ... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::decrease_preference(baryonyx::sparse_matrix<int>::row_value*, baryonyx::sparse_matrix<int>::row_value*, long double) | void decrease_preference(sparse_matrix<int>::row_iterator begin,
sparse_matrix<int>::row_iterator end,
Float theta) noexcept
{
for (; begin != end; ++begin)
P[begin->value] *= theta;
} | fldt 0x8(%rsp)
movq 0x50(%rdi), %rax
cmpq %rdx, %rsi
je 0x421a3e
movslq (%rsi), %rcx
addq $0x8, %rsi
shlq $0x4, %rcx
fldt (%rax,%rcx)
fmul %st(1), %st
fstpt (%rax,%rcx)
jmp 0x421a24
fstp %st(0)
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::compute_reduced_costs<baryonyx::bit_array>(baryonyx::sparse_matrix<int>::row_value*, baryonyx::sparse_matrix<int>::row_value*, baryonyx::bit_array const&) | int compute_reduced_costs(sparse_matrix<int>::row_iterator begin,
sparse_matrix<int>::row_iterator end,
const Xtype& x) noexcept
{
// to_log(
// debug_os, " compute-reduced-cost {}\n", std::distance(begin,
// end));
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x10(%rdi), %rbp
movq %rcx, 0x10(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
xorl %ebx, %ebx
cmpq %r14, %r15
je 0x421b20
movl 0x4(%r15), %edx
leaq 0x18(%rsp), %rdi
movq %rbp, %rsi
callq 0x3dede
movq 0x18(%rsp), %rcx
movq 0... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::branch_and_bound_solver<baryonyx::itm::maximize_tag, long double>::solve<std::unique_ptr<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::rc_data [], std::default_delete<baryonyx::itm::solver_inequalities_Zcoe... | int solve(R& reduced_cost, int r_size, int bk_min, int bk_max)
{
bx_assert(r_size >= 4);
bx_assert(bk_min <= bk_max);
b_min = bk_min;
b_max = bk_max;
items.resize(r_size);
if (!subvector.init(r_size))
throw solver_failure(solver_error_tag::no_solver_avai... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x3, %edx
jle 0x421dbe
cmpl %r8d, %ecx
jg 0x421ddf
leaq 0x20(%rdi), %r13
movl %ecx, 0x74(%rdi)
movl %edx, %ebx
movq %rsi, %r14
movl %edx, %r12d
movq %rdi, %r15
movl %r8d, 0x78(%rdi)
movq %r12, %rsi
movq %r13, %rdi
callq 0x405a4e
movq %r1... | /quesnel[P]baryonyx/lib/src/branch-and-bound-solver.hpp |
int baryonyx::itm::exhaustive_solver<baryonyx::itm::maximize_tag, long double>::solve<std::unique_ptr<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::rc_data [], std::default_delete<baryonyx::itm::solver_inequalities_Zcoeff<lon... | int solve(int k, R& reduced_cost, int r_size)
{
const auto it_constraint = constraints.find(k);
bx_expects(it_constraint != constraints.end());
items.resize(r_size);
for (int i = 0; i != r_size; ++i) {
items[i].r = reduced_cost[i].value;
items[i].variable = r... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0xc(%rsp), %rax
movq %rdi, %r15
addq $0x48, %rdi
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, (%rax)
andq $0x0, 0xc(%rax)
movq %rax, %rsi
callq 0x4075de
leaq 0x50(%r15), %rcx
movq %rax, %r13
cmpq %rcx, %r13
je 0x422014
movslq %ebx, %r12
movq %r1... | /quesnel[P]baryonyx/lib/src/exhaustive-solver.hpp |
baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::select_variables(int, int, int) | int select_variables(const int r_size, int bkmin, int bkmax)
{
int sum = 0;
int best = -2;
for (int i = -1; i < r_size; ++i) {
if (bkmin <= sum && sum <= bkmax)
best = i;
if (best != -2 && i - 1 < r_size &&
stop_iterating<Mode>(R[i + ... | movq 0x60(%rdi), %rdi
movslq %esi, %rsi
pushq $-0x2
popq %rax
xorl %r8d, %r8d
pushq $-0x1
popq %r9
fldz
cmpq %rsi, %r9
jge 0x42207b
cmpl %ecx, %r8d
movl %r9d, %r10d
cmovgl %eax, %r10d
cmpl %edx, %r8d
cmovgel %r10d, %eax
cmpl $-0x2, %eax
je 0x42206e
fldt (%rdi)
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
ja 0x42207b
addl... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::select_variables_101(int, int, int) | int select_variables_101(const int r_size, int bkmin, int bkmax)
{
int sum = 0;
int best = -2;
for (int i = -1; i < r_size; ++i) {
if (bkmin <= sum && sum <= bkmax)
best = i;
if (best != -2 && i - 1 < r_size &&
stop_iterating<Mode>(R[... | movq 0x60(%rdi), %rdi
movslq %esi, %rsi
pushq $-0x2
popq %rax
xorl %r8d, %r8d
pushq $-0x1
popq %r9
fldz
cmpq %rsi, %r9
jge 0x4220c3
cmpl %ecx, %r8d
movl %r9d, %r10d
cmovgl %eax, %r10d
cmpl %edx, %r8d
cmovgel %r10d, %eax
cmpl $-0x2, %eax
je 0x4220b6
fldt (%rdi)
fxch %st(1)
fucomi %st(1), %st
fstp %st(1)
ja 0x4220c3
addl... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::local_affect<baryonyx::bit_array, baryonyx::sparse_matrix<int>::row_value*>(baryonyx::bit_array&, baryonyx::sparse_matrix<int>::row_value*, int, int, int, long double, long d... | bool local_affect(Xtype& x,
Iterator it,
int k,
int selected,
int r_size,
const Float kappa,
const Float delta)
{
constexpr Float one{ 1 };
constexpr Float two{ 2 };
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
fldt 0x90(%rsp)
fldt 0x80(%rsp)
movq 0x78(%rdi), %rax
movl %ecx, 0x1c(%rsp)
movslq %ecx, %rcx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
shlq $0x4, %rcx
fldt (%rax,%rcx)
addq %rcx, %rax
movq %rcx, 0x28(%rsp)
fld1
fsub %st(2), %st
fd... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
void baryonyx::itm::random_shuffle_unique<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::rc_data*>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long dou... | inline void
random_shuffle_unique(iteratorT begin,
iteratorT end,
random_engine& rng) noexcept
{
auto ret = begin++;
for (; begin != end; ++begin) {
if (ret->value != begin->value) {
std::shuffle(ret, begin, rng);
ret = begin;
}... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x20(%rdi), %r15
cmpq %r14, %r15
je 0x422401
fldt (%rdi)
fldt (%r15)
addq $0x20, %r15
fxch %st(1)
fucompi %st(1), %st
fstp %st(0)
jne 0x4223ed
jnp 0x4223d5
addq $-0x20, %r15
movq %r15, %rsi
movq %rbx, %rdx
callq 0x422982
movq %r15, %rdi
jmp 0x4223d1
... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
long double baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::local_compute_reduced_cost<baryonyx::bit_array>(int, baryonyx::bit_array const&) | Float local_compute_reduced_cost(int variable, const Xtype& x) noexcept
{
Float sum_a_pi_p = 0;
for (auto [ht, hte] = ap.column(variable); ht != hte; ++ht) {
auto a = std::abs(static_cast<Float>(A[ht->value]));
sum_a_pi_p += a * (pi[ht->row] + P[ht->value]);
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebp
leaq 0x10(%rdi), %rsi
leaq 0x18(%rsp), %r15
movq %rdx, %rbx
movq %rdi, %r14
movl %ebp, %edx
movq %r15, %rdi
callq 0x3dede
movq (%r15), %rax
movq 0x8(%r15), %rcx
movq 0x50(%r14), %rdx
movq 0x58(%r14), %rsi
movq 0x78(%r14), %rdi
fldz
cmpq %rax, ... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::push_and_compute_update_row<baryonyx::bit_array, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>>(baryonyx::bit_array&,... | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x70(%rsp)
leaq 0x10(%rdi), %rax
leaq 0x60(%rdi), %rcx
movq %rsi, %r15
leaq 0x100(%rdi), %rsi
movq %rdi, %r12
xorl %r14d, %r14d
fldt 0x110(%rsp)
fstpt 0x9c(%rsp)
fldt 0x100(%rsp)
fstpt 0x90(%rsp)
fldt 0xf0(%rsp)
fstpt 0x84(%rs... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator... | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x70(%rsp)
leaq 0x10(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
fldt 0x110(%rsp)
fstpt 0x9c(%rsp)
fldt 0x100(%rsp)
fstpt 0x90(%rsp)
fldt 0xf0(%rsp)
fstpt 0x84(%rsp)
fldt 0xe0(%rsp)
fstpt 0x78... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>... | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x70(%rsp)
leaq 0x10(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
fldt 0x110(%rsp)
fstpt 0x9c(%rsp)
fldt 0x100(%rsp)
fstpt 0x90(%rsp)
fldt 0xf0(%rsp)
fstpt 0x84(%rsp)
fldt 0xe0(%rsp)
fstpt 0x78... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>::push_and_compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_it... | bool push_and_compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta,
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, 0x70(%rsp)
leaq 0x10(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
fldt 0x110(%rsp)
fstpt 0x9c(%rsp)
fldt 0x100(%rsp)
fstpt 0x90(%rsp)
fldt 0xf0(%rsp)
fstpt 0x84(%rsp)
fldt 0xe0(%rsp)
fstpt 0x78... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, baryonyx::pnm_observer>::operator()(std::vector<baryonyx::... | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x548, %rsp # imm = 0x548
vmovsd %xmm0, 0x88(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x60(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, baryonyx::file_observer>::operator()(std::vector<baryonyx:... | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x548, %rsp # imm = 0x548
vmovsd %xmm0, 0x88(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x60(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, baryonyx::pnm_observer>::store_if_better(baryonyx::bit_arr... | inline bool
is_better_solution(Float lhs, Float rhs) noexcept
{
if constexpr (std::is_same_v<Mode, minimize_tag>)
return lhs < rhs;
else
return lhs > rhs;
} | vucomisd 0x30(%rdi), %xmm0
jbe 0x4283dc
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x20, %rdi
movq %rdx, %rbx
vmovsd %xmm0, (%rsp)
callq 0x36a44
movq %r14, %rdi
callq 0x428456
vmovsd (%rsp), %xmm1
vmovsd %xmm0, 0x38(%r14)
movq %rbx, 0x48(%r14)
andl $0x0, 0x50(%r14)
vmovsd %xmm1, 0x30(%r14)
addq $0x8, %rsp
p... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, baryonyx::pnm_observer>::is_timelimit_reached() | bool is_timelimit_reached()
{
m_end = std::chrono::steady_clock::now();
return is_time_limit(m_ctx.parameters.time_limit, m_begin, m_end);
} | pushq %rbx
movq %rdi, %rbx
callq 0xb5a0
movq %rax, 0x8(%rbx)
vxorpd %xmm2, %xmm2, %xmm2
movq 0x10(%rbx), %rcx
subq (%rbx), %rax
vmovsd (%rcx), %xmm0
vcvtsi2sd %rax, %xmm1, %xmm1
vdivsd 0x31641(%rip), %xmm1, %xmm1 # 0x459a80
vcmpnlepd %xmm2, %xmm0, %k1
vcmpltpd %xmm1, %xmm0, %k0 {%k1}
kmovd %k0, %eax
andb $0x1, %al
popq... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, baryonyx::file_observer>::store_if_better(baryonyx::bit_ar... | inline bool
is_better_solution(Float lhs, Float rhs) noexcept
{
if constexpr (std::is_same_v<Mode, minimize_tag>)
return lhs < rhs;
else
return lhs > rhs;
} | vucomisd 0x30(%rdi), %xmm0
jbe 0x4284be
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x20, %rdi
movq %rdx, %rbx
vmovsd %xmm0, (%rsp)
callq 0x36a44
movq %r14, %rdi
callq 0x428538
vmovsd (%rsp), %xmm1
vmovsd %xmm0, 0x38(%r14)
movq %rbx, 0x48(%r14)
andl $0x0, 0x50(%r14)
vmovsd %xmm1, 0x30(%r14)
addq $0x8, %rsp
p... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, baryonyx::file_observer>::is_timelimit_reached() | bool is_timelimit_reached()
{
m_end = std::chrono::steady_clock::now();
return is_time_limit(m_ctx.parameters.time_limit, m_begin, m_end);
} | pushq %rbx
movq %rdi, %rbx
callq 0xb5a0
movq %rax, 0x8(%rbx)
vxorpd %xmm2, %xmm2, %xmm2
movq 0x10(%rbx), %rcx
subq (%rbx), %rax
vmovsd (%rcx), %xmm0
vcvtsi2sd %rax, %xmm1, %xmm1
vdivsd 0x3155f(%rip), %xmm1, %xmm1 # 0x459a80
vcmpnlepd %xmm2, %xmm0, %k1
vcmpltpd %xmm1, %xmm0, %k0 {%k1}
kmovd %k0, %eax
andb $0x1, %al
popq... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, false>, long double, baryonyx::itm::maximize_tag, baryonyx::itm::quadratic_cost_type<long double>, baryonyx::none_observer>::is_timelimit_reached() | bool is_timelimit_reached()
{
m_end = std::chrono::steady_clock::now();
return is_time_limit(m_ctx.parameters.time_limit, m_begin, m_end);
} | pushq %rbx
movq %rdi, %rbx
callq 0xb5a0
movq %rax, 0x8(%rbx)
vxorpd %xmm2, %xmm2, %xmm2
movq 0x10(%rbx), %rcx
subq (%rbx), %rax
vmovsd (%rcx), %xmm0
vcvtsi2sd %rax, %xmm1, %xmm1
vdivsd 0x3147d(%rip), %xmm1, %xmm1 # 0x459a80
vcmpnlepd %xmm2, %xmm0, %k1
vcmpltpd %xmm1, %xmm0, %k0 {%k1}
kmovd %k0, %eax
andb $0x1, %al
popq... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::result baryonyx::itm::solve_problem<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>, long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>>(baryonyx::context const&, baryonyx::problem con... | inline result
solve_problem(const context& ctx, const problem& pb)
{
if (ctx.start)
ctx.start(ctx.parameters);
result ret;
auto variables = length(pb.vars.values);
auto constraints{ make_merged_constraints(ctx, pb) };
if (!constraints.empty() && !pb.vars.values.empty()) {
random_e... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x130, %rsp # imm = 0x130
cmpq $0x0, 0x128(%rsi)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
je 0x428cc8
leaq 0x118(%r14), %rdi
movq %r14, %rsi
callq 0x3527e
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm0, 0x58(%rbx)
vmovups %zmm0, 0x40(%rbx)
vmovups... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::result baryonyx::itm::optimize_problem<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, false>, long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>>(baryonyx::context const&, baryonyx::problem... | inline result
optimize_problem(const context& ctx, const problem& pb)
{
result r;
if (ctx.start)
ctx.start(ctx.parameters);
auto constraints{ make_merged_constraints(ctx, pb) };
if (constraints.empty() || pb.vars.values.empty()) {
r.status = result_status::success;
r.solutions.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x188, %rsp # imm = 0x188
vxorpd %xmm0, %xmm0, %xmm0
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r12
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
movq $0x7fffffff, 0x98(%rdi) # imm = 0x7FFFFFFF
movl $0x2, 0xa... | /quesnel[P]baryonyx/lib/src/itm-optimizer-common.hpp |
baryonyx::result baryonyx::itm::solve_problem<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, false>, long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>>(baryonyx::context const&, baryonyx::problem co... | inline result
solve_problem(const context& ctx, const problem& pb)
{
if (ctx.start)
ctx.start(ctx.parameters);
result ret;
auto variables = length(pb.vars.values);
auto constraints{ make_merged_constraints(ctx, pb) };
if (!constraints.empty() && !pb.vars.values.empty()) {
random_e... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x130, %rsp # imm = 0x130
cmpq $0x0, 0x128(%rsi)
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
je 0x42963d
leaq 0x118(%r14), %rdi
movq %r14, %rsi
callq 0x3527e
vxorps %xmm0, %xmm0, %xmm0
vmovups %zmm0, 0x58(%rbx)
vmovups %zmm0, 0x40(%rbx)
vmovups... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::optimize_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>, long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>>::operator()(std::atomic<bool> const&, baryonyx::itm::best_sol... | void operator()(const std::atomic_bool& stop_task,
best_solution_recorder<Cost, Float, Mode>& best_recorder,
const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_const... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp # imm = 0x2F8
movq %rdi, %rbp
leaq 0x58(%rsp), %rdi
movq %rsi, %r15
movl %r8d, %esi
vmovsd %xmm0, 0x88(%rsp)
movq %r9, %r12
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, 0x68(%rsp)
callq 0x368ae
movq (%rbp), %r13
movq %rbp, 0xb0... | /quesnel[P]baryonyx/lib/src/itm-optimizer-common.hpp |
baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>::solver_inequalities_Zcoeff(std::linear_congruential_engine<unsigned long, 16807ul, 0ul, 2147483647ul>&, int, int, baryonyx::itm::default_cost_type<long double> const&, std::vector<ba... | solver_inequalities_Zcoeff(random_engine& rng_,
int m_,
int n_,
const cost_type& c_,
const std::vector<merged_constraint>& csts)
: logger("solver_inequalities_Zcoeff")
, rng(rng_)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %r13d
leaq 0x3c7b6(%rip), %rdx # 0x466abb
movq %r9, %r12
movq %r8, %rbp
movl %ecx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x1a
popq %rsi
callq 0xb8418
movq %r15, 0x8(%rbx)
leaq 0x10(%rbx), %r15
movq %r15, %rdi
movq %... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
void baryonyx::itm::compute_order::init<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long... | void init(const Solver& s, const Xtype& x)
{
switch (order) {
case solver_parameters::constraint_order::infeasibility_decr:
case solver_parameters::constraint_order::infeasibility_incr:
infeasibility_local_compute_violated_constraints(s, x);
break;
case solver... | movl 0x30(%rdi), %ecx
movq %rdi, %rax
leal -0x3(%rcx), %edi
cmpl $0x2, %edi
jae 0x42a790
movq %rax, %rdi
jmp 0x42b5cc
cmpl $0x7, %ecx
jne 0x42a7ad
movq (%rax), %rcx
movq 0x8(%rax), %rax
xorl %edx, %edx
cmpq %rax, %rcx
je 0x42a7bb
movl %edx, (%rcx)
incl %edx
addq $0x4, %rcx
jmp 0x42a79e
movq %rsi, %rdi
movq %rdx, %rsi
m... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::compute_order::run<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>, baryonyx::bit_array, long double>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cos... | int run(Solver& solver,
Xtype& x,
random_engine& rng,
Float kappa,
Float delta,
Float theta)
{
bool pi_changed = false;
int remaining = 0;
switch (order) {
case solver_parameters::constraint_order::reversing:
so... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
fldt 0xb0(%rsp)
fldt 0xa0(%rsp)
fldt 0x90(%rsp)
movl 0x30(%rdi), %eax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
decl %eax
cmpl $0x6, %eax
ja 0x42a8dd
leaq 0x3bf6c(%rip), %rdx # 0x466764
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
movq 0x8(%r14), %rax... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
int baryonyx::itm::compute_order::push_and_run<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>, baryonyx::bit_array, long double>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::de... | int push_and_run(Solver& solver,
Xtype& x,
random_engine& rng,
Float kappa,
Float delta,
Float theta,
Float objective_amplifier)
{
bool pi_changed = 0;
int remaining = 0;
... | pushq %r15
pushq %r14
pushq %rbx
subq $0x80, %rsp
fldt 0xd0(%rsp)
fldt 0xc0(%rsp)
fldt 0xb0(%rsp)
fldt 0xa0(%rsp)
movl 0x30(%rdi), %eax
cmpb $0x1, 0x34(%rdi)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
jne 0x42aa37
xorl %esi, %esi
leal 0x1(%rax), %edx
cmpl $0x7, %eax
cmovll %edx, %esi
movl %esi, %eax
movl %esi, 0x3... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
void baryonyx::itm::exhaustive_solver<baryonyx::itm::minimize_tag, long double>::build_constraints<std::vector<baryonyx::function_element, std::allocator<baryonyx::function_element>>>(int, std::vector<baryonyx::function_element, std::allocator<baryonyx::function_element>> const&, int, int) | void build_constraints(int k,
const C& constraint_elements,
int bk_min,
int bk_max)
{
const auto constraint_size = length(constraint_elements);
const auto start_it_flat_constraints = length(flat_constraints);
au... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, 0x24(%rsp)
movl %ecx, 0x20(%rsp)
movl %r8d, 0x1c(%rsp)
movl %ecx, 0x10(%rsp)
movl %esi, %eax
movl %r8d, 0x14(%rsp)
movq 0x20(%rdi), %rcx
movq 0x8(%rdx), %rsi
subq 0x18(%rdi), %rcx
subq (%rdx), %rsi
andl $0x0, 0x4(%rsp)
shrq $0... | /quesnel[P]baryonyx/lib/src/exhaustive-solver.hpp |
baryonyx::itm::exhaustive_solver<baryonyx::itm::minimize_tag, long double>::reserve(unsigned long, unsigned long) | void reserve(std::size_t max_variables, std::size_t max_z_constraints)
{
bx_assert(max_variables > 0);
bx_assert(max_z_constraints > 0);
items.reserve(max_variables);
flat_constraints.reserve(max_variables * max_z_constraints);
walkers.reserve(max_variables);
} | pushq %r15
pushq %r14
pushq %rbx
testq %rsi, %rsi
je 0x42aff5
movq %rdx, %r15
testq %rdx, %rdx
je 0x42b016
movq %rsi, %rbx
movq %rdi, %r14
callq 0x42b2aa
imulq %rbx, %r15
leaq 0x18(%r14), %rdi
movq %r15, %rsi
callq 0x36bee8
addq $0x30, %r14
movq %rbx, %rsi
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x324c6
leaq ... | /quesnel[P]baryonyx/lib/src/exhaustive-solver.hpp |
int baryonyx::itm::compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_t... | int
compute_violated_constraints(const Solver& slv,
const Xtype& x,
std::vector<int>& out)
{
out.clear();
for (int k = 0; k != slv.m; ++k)
if (!is_valid_constraint(slv, k, x))
out.emplace_back(k);
return length(out);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rdx), %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpq %rax, 0x8(%rdx)
je 0x42b6ec
movq %rax, 0x8(%rbx)
leaq 0x4(%rsp), %r12
xorl %esi, %esi
movl %esi, 0x4(%rsp)
cmpl 0x180(%r15), %esi
je 0x42b722
movq %r15, %rdi
movq %r14, %rdx
callq 0x42b739
testb... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
bool baryonyx::itm::is_valid_constraint<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long... | bool
is_valid_constraint(const Solver& slv, int k, const Xtype& x)
{
typename sparse_matrix<int>::const_row_iterator it, et;
std::tie(it, et) = slv.ap.row(k);
int v = 0;
for (; it != et; ++it)
v += slv.factor(it->value) * x[it->column];
return slv.bound_min(k) <= v && v <= slv.bound_max(k... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movl %esi, %edx
leaq 0x10(%rdi), %rsi
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
movq %r15, %rdi
callq 0x3c868
movq (%r15), %r12
movq 0x8(%r15), %r13
xorl %r15d, %r15d
cmpq %r12, %r13
je 0x42b796
movslq (%r... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>::compute_update_row<baryonyx::bit_array, std::reverse_iterator<__gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>>(baryonyx::bit_array&, std::revers... | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, 0x58(%rsp)
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x30b5a(%rip), %rdx # 0x45c344
fldt 0xf0(%rsp)
fldt 0xe0(%rsp)
fldt 0xd0(%rsp)
fstpt 0x80(%rsp)
fstpt 0x70(%rsp)
fstpt 0x60(%rsp)
pushq $0x14
popq %rsi
leaq 0... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int*, std::... | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, 0x58(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x308da(%rip), %rdx # 0x45c344
fldt 0xf0(%rsp)
fldt 0xe0(%rsp)
fldt 0xd0(%rsp)
fstpt 0x80(%rsp)
fstpt 0x70(%rsp)
fstpt 0x60(%rsp)
pushq $0x14
popq %rsi
leaq 0... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<std::pair<int, int> const*, std::vector<std::pair<int, int>, std::allocator<std::pair<int, int>>>>>(baryonyx... | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, 0x58(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x3066c(%rip), %rdx # 0x45c344
fldt 0xf0(%rsp)
fldt 0xe0(%rsp)
fldt 0xd0(%rsp)
fstpt 0x80(%rsp)
fstpt 0x70(%rsp)
fstpt 0x60(%rsp)
pushq $0x14
popq %rsi
leaq 0... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::compute_order::infeasibility_local_compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize... | int infeasibility_local_compute_violated_constraints(Solver& solver,
const Xtype& x)
{
m_order.clear();
for (int k = 0, e = solver.m; k != e; ++k) {
sparse_matrix<int>::const_row_iterator it, et;
std::tie(it, et) = sol... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x18(%rdi), %rax
movq %rdx, %r14
movq %rsi, %r15
cmpq %rax, 0x20(%rdi)
je 0x42bf42
movq %rax, 0x20(%rdi)
leaq 0x18(%rdi), %rax
leaq 0x10(%r15), %rcx
xorl %r12d, %r12d
movq %rdi, 0x20(%rsp)
movq %rax, 0x10(%rsp)
movl 0x180(%r15), %ea... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>::compute_update_row<baryonyx::bit_array, __gnu_cxx::__normal_iterator<int const*, std::vector<int, std::allocator<int>>>>(baryonyx::bit_array&, __gnu_cxx::__normal_iterator<int c... | bool compute_update_row(Xtype& x,
Iterator first,
Iterator last,
Float kappa,
Float delta,
Float theta)
{
auto at_least_one_pi_changed{ false };
logger::log("u... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, 0x58(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x302fc(%rip), %rdx # 0x45c344
fldt 0xf0(%rsp)
fldt 0xe0(%rsp)
fldt 0xd0(%rsp)
fstpt 0x80(%rsp)
fstpt 0x70(%rsp)
fstpt 0x60(%rsp)
pushq $0x14
popq %rsi
leaq 0... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::compute_order::local_compute_violated_constraints<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>, baryonyx::bit_array>(baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx... | int local_compute_violated_constraints(const Solver& slv, const Xtype& x)
{
int remaining = 0;
for (int k = 0; k != slv.m; ++k)
if (!is_valid_constraint(slv, k, x))
++remaining;
return remaining;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
xorl %ebp, %ebp
xorl %r15d, %r15d
cmpl 0x180(%r14), %r15d
je 0x42c2c5
movq %r14, %rdi
movl %r15d, %esi
movq %rbx, %rdx
callq 0x42b739
xorb $0x1, %al
incl %r15d
movzbl %al, %eax
addl %eax, %ebp
jmp 0x42c2a2
movl %ebp, %eax
addq $0x8, ... | /quesnel[P]baryonyx/lib/src/itm-common.hpp |
baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>::decrease_preference(baryonyx::sparse_matrix<int>::row_value*, baryonyx::sparse_matrix<int>::row_value*, long double) | void decrease_preference(sparse_matrix<int>::row_iterator begin,
sparse_matrix<int>::row_iterator end,
Float theta) noexcept
{
for (; begin != end; ++begin)
P[begin->value] *= theta;
} | fldt 0x8(%rsp)
movq 0x50(%rdi), %rax
cmpq %rdx, %rsi
je 0x42c2f4
movslq (%rsi), %rcx
addq $0x8, %rsi
shlq $0x4, %rcx
fldt (%rax,%rcx)
fmul %st(1), %st
fstpt (%rax,%rcx)
jmp 0x42c2da
fstp %st(0)
retq
nop
| /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>::compute_reduced_costs<baryonyx::bit_array>(baryonyx::sparse_matrix<int>::row_value*, baryonyx::sparse_matrix<int>::row_value*, baryonyx::bit_array const&) | int compute_reduced_costs(sparse_matrix<int>::row_iterator begin,
sparse_matrix<int>::row_iterator end,
const Xtype& x) noexcept
{
// to_log(
// debug_os, " compute-reduced-cost {}\n", std::distance(begin,
// end));
int ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rdi), %r13
leaq 0x8(%rsp), %rbp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
xorl %r15d, %r15d
cmpq %rbx, %r14
je 0x42c3cd
movl 0x4(%r14), %edx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x3dede
movq 0x8(%rsp), %rcx
movq 0x10(%r... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
int baryonyx::itm::branch_and_bound_solver<baryonyx::itm::minimize_tag, long double>::solve<std::unique_ptr<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>::rc_data [], std::default_delete<baryonyx::itm::solver_inequalities_Zcoeff<... | int solve(R& reduced_cost, int r_size, int bk_min, int bk_max)
{
bx_assert(r_size >= 4);
bx_assert(bk_min <= bk_max);
b_min = bk_min;
b_max = bk_max;
items.resize(r_size);
if (!subvector.init(r_size))
throw solver_failure(solver_error_tag::no_solver_avai... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x3, %edx
jle 0x42c66c
cmpl %r8d, %ecx
jg 0x42c68d
leaq 0x20(%rdi), %r13
movl %ecx, 0x74(%rdi)
movl %edx, %ebx
movq %rsi, %r14
movl %edx, %r12d
movq %rdi, %r15
movl %r8d, 0x78(%rdi)
movq %r12, %rsi
movq %r13, %rdi
callq 0x42d432
movq %r1... | /quesnel[P]baryonyx/lib/src/branch-and-bound-solver.hpp |
int baryonyx::itm::exhaustive_solver<baryonyx::itm::minimize_tag, long double>::solve<std::unique_ptr<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>::rc_data [], std::default_delete<baryonyx::itm::solver_inequalities_Zcoeff<long d... | int solve(int k, R& reduced_cost, int r_size)
{
const auto it_constraint = constraints.find(k);
bx_expects(it_constraint != constraints.end());
items.resize(r_size);
for (int i = 0; i != r_size; ++i) {
items[i].r = reduced_cost[i].value;
items[i].variable = r... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
leaq 0xc(%rsp), %rax
movq %rdi, %r15
addq $0x48, %rdi
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, (%rax)
andq $0x0, 0xc(%rax)
movq %rax, %rsi
callq 0x42efa0
leaq 0x50(%r15), %rcx
movq %rax, %r13
cmpq %rcx, %r13
je 0x42c8c2
movslq %ebx, %r12
movq %r1... | /quesnel[P]baryonyx/lib/src/exhaustive-solver.hpp |
baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>::select_variables(int, int, int) | int select_variables(const int r_size, int bkmin, int bkmax)
{
int sum = 0;
int best = -2;
for (int i = -1; i < r_size; ++i) {
if (bkmin <= sum && sum <= bkmax)
best = i;
if (best != -2 && i - 1 < r_size &&
stop_iterating<Mode>(R[i + ... | movq 0x60(%rdi), %rdi
movslq %esi, %rsi
pushq $-0x2
popq %rax
xorl %r8d, %r8d
pushq $-0x1
popq %r9
fldz
cmpq %rsi, %r9
jge 0x42c925
cmpl %ecx, %r8d
movl %r9d, %r10d
cmovgl %eax, %r10d
cmpl %edx, %r8d
cmovgel %r10d, %eax
cmpl $-0x2, %eax
je 0x42c918
fldt (%rdi)
fucompi %st(1), %st
ja 0x42c925
addl 0x14(%rdi), %r8d
incq ... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>::select_variables_101(int, int, int) | int select_variables_101(const int r_size, int bkmin, int bkmax)
{
int sum = 0;
int best = -2;
for (int i = -1; i < r_size; ++i) {
if (bkmin <= sum && sum <= bkmax)
best = i;
if (best != -2 && i - 1 < r_size &&
stop_iterating<Mode>(R[... | movq 0x60(%rdi), %rdi
movslq %esi, %rsi
pushq $-0x2
popq %rax
xorl %r8d, %r8d
pushq $-0x1
popq %r9
fldz
cmpq %rsi, %r9
jge 0x42c969
cmpl %ecx, %r8d
movl %r9d, %r10d
cmovgl %eax, %r10d
cmpl %edx, %r8d
cmovgel %r10d, %eax
cmpl $-0x2, %eax
je 0x42c95c
fldt (%rdi)
fucompi %st(1), %st
ja 0x42c969
addl 0x14(%rdi), %r8d
incq ... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
bool baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, true>::local_affect<baryonyx::bit_array, baryonyx::sparse_matrix<int>::row_value*>(baryonyx::bit_array&, baryonyx::sparse_matrix<int>::row_value*, int, int, int, long double, long doub... | bool local_affect(Xtype& x,
Iterator it,
int k,
int selected,
int r_size,
const Float kappa,
const Float delta)
{
constexpr Float one{ 1 };
constexpr Float two{ 2 };
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
fldt 0x90(%rsp)
fldt 0x80(%rsp)
movl %r8d, 0x14(%rsp)
movl %r9d, 0x10(%rsp)
movq %rdx, %r15
movslq %ecx, %rdx
movl %ecx, 0x24(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq 0x78(%rdi), %rcx
shlq $0x4, %rdx
fldt (%rcx,%rdx)
addq %rdx, %rcx
mo... | /quesnel[P]baryonyx/lib/src/itm-solver-inequalities-Z.cpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, false>, long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, baryonyx::none_observer>::operator()(std::vector<baryonyx::itm... | result operator()(const std::vector<merged_constraint>& constraints,
int variables,
const Cost& original_costs,
double cost_constant)
{
result r;
bit_array x(variables);
int best_remaining = INT_MAX;
auto& p = m_ctx... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2f8, %rsp # imm = 0x2F8
vmovsd %xmm0, 0x80(%rsp)
vxorpd %xmm0, %xmm0, %xmm0
movq %r8, %r13
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, 0x58(%rsp)
vmovupd %zmm0, 0x58(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, false>, long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, baryonyx::file_observer>::store_if_better(baryonyx::bit_array ... | void store_if_better(const bit_array& x, double current, long int i)
{
if (is_better_solution<Mode>(current, m_best.value)) {
m_best.x = x;
m_best.duration = duration();
m_best.loop = i;
m_best.remaining_constraints = 0;
m_best.value = current;
... | vmovsd 0x30(%rdi), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x43ce34
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x20, %rdi
movq %rdx, %rbx
vmovsd %xmm0, (%rsp)
callq 0x36a44
movq %r14, %rdi
callq 0x43ceae
vmovsd (%rsp), %xmm1
vmovsd %xmm0, 0x38(%r14)
movq %rbx, 0x48(%r14)
andl $0x0, 0x50(%r14)
vmovsd %xmm1, 0x30(%r1... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, false>, long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, baryonyx::file_observer>::is_timelimit_reached() | bool is_timelimit_reached()
{
m_end = std::chrono::steady_clock::now();
return is_time_limit(m_ctx.parameters.time_limit, m_begin, m_end);
} | pushq %rbx
movq %rdi, %rbx
callq 0xb5a0
movq %rax, 0x8(%rbx)
vxorpd %xmm2, %xmm2, %xmm2
movq 0x10(%rbx), %rcx
subq (%rbx), %rax
vmovsd (%rcx), %xmm0
vcvtsi2sd %rax, %xmm1, %xmm1
vdivsd 0x1cbe9(%rip), %xmm1, %xmm1 # 0x459a80
vcmpnlepd %xmm2, %xmm0, %k1
vcmpltpd %xmm1, %xmm0, %k0 {%k1}
kmovd %k0, %eax
andb $0x1, %al
popq... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, false>, long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, baryonyx::none_observer>::store_if_better(baryonyx::bit_array ... | void store_if_better(const bit_array& x, double current, long int i)
{
if (is_better_solution<Mode>(current, m_best.value)) {
m_best.x = x;
m_best.duration = duration();
m_best.loop = i;
m_best.remaining_constraints = 0;
m_best.value = current;
... | vmovsd 0x30(%rdi), %xmm1
vucomisd %xmm0, %xmm1
jbe 0x43cf1a
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
addq $0x20, %rdi
movq %rdx, %rbx
vmovsd %xmm0, (%rsp)
callq 0x36a44
movq %r14, %rdi
callq 0x43cf94
vmovsd (%rsp), %xmm1
vmovsd %xmm0, 0x38(%r14)
movq %rbx, 0x48(%r14)
andl $0x0, 0x50(%r14)
vmovsd %xmm1, 0x30(%r1... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
baryonyx::itm::solver_functor<baryonyx::itm::solver_inequalities_Zcoeff<long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, false>, long double, baryonyx::itm::minimize_tag, baryonyx::itm::default_cost_type<long double>, baryonyx::none_observer>::is_timelimit_reached() | bool is_timelimit_reached()
{
m_end = std::chrono::steady_clock::now();
return is_time_limit(m_ctx.parameters.time_limit, m_begin, m_end);
} | pushq %rbx
movq %rdi, %rbx
callq 0xb5a0
movq %rax, 0x8(%rbx)
vxorpd %xmm2, %xmm2, %xmm2
movq 0x10(%rbx), %rcx
subq (%rbx), %rax
vmovsd (%rcx), %xmm0
vcvtsi2sd %rax, %xmm1, %xmm1
vdivsd 0x1cb03(%rip), %xmm1, %xmm1 # 0x459a80
vcmpnlepd %xmm2, %xmm0, %k1
vcmpltpd %xmm1, %xmm0, %k0 {%k1}
kmovd %k0, %eax
andb $0x1, %al
popq... | /quesnel[P]baryonyx/lib/src/itm-solver-common.hpp |
main | int main(const int argc, char** const argv)
{
int exit_code = EXIT_SUCCESS;
if (argc < 2)
{
fputs(
"This tool decompresses a supplied file that's in the Moduled Kosinski format.\n"
"\n"
"www.github.com/Clownacy/accurate-kosinski\n"
"\n"
"Usage: kosinskim-decompress [in_file] [out_file](optional)\n"... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x11ce
movq 0x2e1e(%rip), %rax # 0x3fd8
movq (%rax), %rsi
leaq 0xe40(%rip), %rdi # 0x2004
callq 0x1040
jmp 0x12ca
movq -0x10(%rbp), %rax
movq 0x8(%ra... | /Clownacy[P]accurate-kosinski/main-moduled-decompress.c |
main | int main()
{
using just::console::color;
std::cout << "Hello ";
show_color(color::red);
show_color(color::green);
show_color(color::blue);
just::console::reset();
std::cout << "World!" << std::endl;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x2ad9(%rip), %rdi # 0x4fd8
leaq 0xafe(%rip), %rsi # 0x3004
callq 0x2050
movl 0x2b4b(%rip), %eax # 0x505c
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %edi
callq 0x24a0
movl 0x2b3e(%rip), %eax # 0x5060
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %edi
callq 0x24... | /sabel83[P]just/libs/console/example/hello_colors/main.cpp |
just::console::text_color(just::console::impl::color<void>) | inline void text_color(color c_)
{
if (c_ == color::black) { std::cout << "\033[30m"; }
else if (c_ == color::red) { std::cout << "\033[31m"; }
else if (c_ == color::green) { std::cout << "\033[32m"; }
else if (c_ == color::yellow) { std::cout ... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movl 0x2ae7(%rip), %eax # 0x5068
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %esi
leaq -0x4(%rbp), %rdi
callq 0x2c20
testb $0x1, %al
jne 0x2596
jmp 0x25ae
movq 0x2a3b(%rip), %rdi # 0x4fd8
leaq 0xa6e(%rip), %rsi # 0x3012
callq 0x2050
jmp 0x28ad... | /sabel83[P]just/include/just/console.hpp |
foobar(int, char**) | int foobar(int argc, char** argv) {
using namespace csv;
if (argc < 2) {
std::cout << "Usage: " << argv[0] << " [file]" << std::endl;
exit(1);
}
std::string file = argv[1];
auto info = get_file_info(file);
std::cout << file << std::endl
<< "Columns: " << internals::for... | pushq %rbx
subq $0x90, %rsp
movq %rsi, %rbx
cmpl $0x1, %edi
jle 0x39a0
movq 0x8(%rbx), %rsi
leaq 0x20(%rsp), %rbx
leaq 0x40(%rsp), %rdx
movq %rbx, %rdi
callq 0x3a10
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x3f4a
movq 0x11716(%rip), %rdi # 0x14fd0
leaq 0x20(%rsp), %rsi
callq 0x32c0
movq %rax, %rdi
callq 0x3110
l... | /vincentlaucsb[P]csv-parser/single_include_test/file1.cpp |
csv::internals::MmapParser::next(unsigned long) | CSV_INLINE void MmapParser::next(size_t bytes = ITERATION_CHUNK_SIZE) {
// Reset parser state
this->field_start = UNINITIALIZED_FIELD;
this->field_length = 0;
this->reset_data_ptr();
// Create memory map
size_t length = std::min(this->source_size ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
orl $-0x1, 0x58(%rdi)
movq %rsi, %r15
andq $0x0, 0x60(%rdi)
callq 0x3be0
movq 0x470(%rbx), %r14
movq 0x5b8(%rbx), %r12
subq %r12, %r14
cmpq %r15, %r14
cmovaeq %r15, %r14
leaq 0x18(%rsp), %r15
andl $0x0, (%r15)
callq 0x3190
movq %rax... | /vincentlaucsb[P]csv-parser/single_include_test/csv.hpp |
csv::internals::IBasicCSVParser::reset_data_ptr() | CSV_INLINE void IBasicCSVParser::reset_data_ptr() {
this->data_ptr = std::make_shared<RawCSVData>();
this->data_ptr->parse_flags = this->_parse_flags;
this->data_ptr->col_names = this->_col_names;
this->fields = &(this->data_ptr->fields);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4261
leaq 0x30(%rbx), %rdi
movq %r14, %rsi
callq 0x4daa
leaq 0x10(%rsp), %rdi
callq 0x4b62
leaq 0x68(%rbx), %rsi
movl $0x108, %edi # imm = 0x108
addq 0x30(%rbx), %rdi
movl $0x400, %edx # imm = 0x400... | /vincentlaucsb[P]csv-parser/single_include_test/csv.hpp |
csv::internals::ThreadSafeDeque<csv::CSVRow>::pop_front() | T pop_front() noexcept {
std::lock_guard<std::mutex> lock{ this->_lock };
T item = std::move(data.front());
data.pop_front();
return item;
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsi), %r14
movq %r14, %rdi
callq 0x5148
movq 0x78(%r15), %rax
addq $0x68, %r15
movups (%rax), %xmm0
andq $0x0, 0x8(%rax)
movups %xmm0, (%rbx)
andq $0x0, (%rax)
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%rbx)
movups 0x10(%rax), %xmm0
movups %xmm0, 0... | /vincentlaucsb[P]csv-parser/single_include_test/csv.hpp |
ZNK3csv6CSVRowcvSt6vectorINSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEESaIS7_EEEv | CSV_INLINE CSVRow::operator std::vector<std::string>() const {
std::vector<std::string> ret;
for (size_t i = 0; i < size(); i++)
ret.push_back(std::string(this->get_field(i)));
return ret;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
xorl %r15d, %r15d
leaq 0x18(%rsp), %r12
leaq 0x8(%rsp), %r13
leaq 0x7(%rsp), %rbp
cmpq 0x20(%r14), %r15
jae 0x8eec
movq %r14, %rdi
movq %r15, %... | /vincentlaucsb[P]csv-parser/single_include_test/csv.hpp |
void mio::basic_mmap<(mio::access_mode)0, char>::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long, std::error_code&) | void basic_mmap<AccessMode, ByteT>::map(const String& path, const size_type offset,
const size_type length, std::error_code& error)
{
error.clear();
if(detail::empty(path))
{
error = std::make_error_code(std::errc::invalid_argument);
return;
}
const auto handle = detail::open... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq %r8, %rdi
callq 0x9bc0
cmpq $0x0, 0x8(%r13)
je 0x9ba6
movq %r13, %rdi
xorl %esi, %esi
movq %rbx, %rdx
callq 0x9bd2
cmpl $0x0, (%rbx)
jne 0x9bb5
movq %r14, %rdi
movl %eax, %esi
movq ... | /vincentlaucsb[P]csv-parser/single_include_test/csv.hpp |
csv::internals::data_type(std::basic_string_view<char, std::char_traits<char>>, long double*, char) | CONSTEXPR_14
DataType data_type(csv::string_view in, long double* const out, const char decimalSymbol) {
// Empty string --> NULL
if (in.size() == 0)
return DataType::CSV_NULL;
bool ws_allowed = true,
dot_allowed = true,
digit_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x70(%rsp)
testq %rdi, %rdi
je 0xbd4e
movq %rsi, %r14
movq %rdx, 0x38(%rsp)
leaq 0x1c(%rsp), %r8
andl $0x0, (%r8)
movq %rdi, 0x50(%rsp)
movq %rdi, %r12
negq %r12
movb $0x1, %al
fldz
xorl %r10d, %r10d
push... | /vincentlaucsb[P]csv-parser/single_include_test/csv.hpp |
main | int main (void) {
int number;
int flag = 1;
int numA;
int numB;
int numC;
int numD;
printf("%s", "Enter a 5 digit number: ");
scanf("%d", &number);
while (flag != -1) {
if (number > 10000) {
if (number < 99999) {
numA = number / 10000;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xe96(%rip), %rbx # 0x2004
leaq 0xe92(%rip), %r14 # 0x2007
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1040
leaq 0xe97(%rip), %r15 # 0x2020
leaq 0x4(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %eax, %eax... | /giannis20012001[P]CGeneralRepo/CStructuredProgrammingDev/PalindromeTester.c |
main | int main(int argc, char *argv[])
{
vector<string> arguments;
char *image = NULL;
int index;
// -O offset
unsigned long long globalOffset = 0;
// -s, specify the size to be read
unsigned int size = -1;
// -i, display information about the disk
bool infoFlag = false;
// -l, lis... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x508, %rsp # imm = 0x508
movq %rsi, %r15
movl %edi, %r12d
xorps %xmm0, %xmm0
movaps %xmm0, 0x1d0(%rsp)
andq $0x0, 0x1e0(%rsp)
leaq 0x220(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %edx, %edx
movb %dl, (%rax)
leaq 0x48... | /Gregwar[P]fatcat/src/fatcat.cpp |
FatEntry::isCorrect() | bool FatEntry::isCorrect()
{
if (attributes && !(attributes&FAT_ATTRIBUTES_DIR) && !(attributes&FAT_ATTRIBUTES_FILE)) {
return false;
}
if (isDirectory() && cluster == 0 && getFilename()!="..") {
return false;
}
for (int i=1; i<11; i++) {
if (printable(data[i])) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movb 0x40(%rdi), %al
testb %al, %al
setne %cl
testb $0x30, %al
sete %dl
testb %dl, %cl
je 0xd867
xorl %ebx, %ebx
jmp 0xd8c9
movq %rdi, %rbx
testb $0x10, %al
je 0xd8a4
cmpl $0x0, 0x44(%rbx)
jne 0xd8a4
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq ... | /Gregwar[P]fatcat/src/core/FatEntry.cpp |
FatSystem::enableCache() | void FatSystem::enableCache()
{
if (!cacheEnabled) {
cout << "Computing FAT cache..." << endl;
for (int cluster=0; cluster<totalClusters; cluster++) {
cache[cluster] = nextCluster(cluster);
}
cacheEnabled = true;
}
} | cmpb $0x0, 0x130(%rdi)
jne 0xe472
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xebb2(%rip), %rdi # 0x1cfc0
leaq 0x862b(%rip), %rsi # 0x16a40
callq 0xb2e0
movq %rax, %rdi
callq 0xb170
leaq 0x138(%rbx), %r14
xorl %esi, %esi
leaq 0x4(%rsp), %r15
movl %esi, 0x4(%rsp)
movslq %esi, %... | /Gregwar[P]fatcat/src/core/FatSystem.cpp |
FatSystem::enableWrite() | void FatSystem::enableWrite()
{
close(fd);
fd = open(filename.c_str(), O_RDWR|O_LARGEFILE);
if (fd < 0) {
ostringstream oss;
oss << "! Unable to open the input file: " << filename << " for writing";
throw oss.str();
}
writeMode = true;
} | pushq %r14
pushq %rbx
subq $0x178, %rsp # imm = 0x178
movq %rdi, %rbx
movl 0x28(%rdi), %edi
callq 0xb560
movq (%rbx), %rdi
pushq $0x2
popq %rsi
xorl %eax, %eax
callq 0xb230
movl %eax, 0x28(%rbx)
testl %eax, %eax
js 0xe5a4
movb $0x1, 0x2c(%rbx)
addq $0x178, %rsp # imm = 0x178
popq %rbx
popq %r14
re... | /Gregwar[P]fatcat/src/core/FatSystem.cpp |
adjust_freqs(std::array<unsigned long, 256ul> const&) | std::array<uint16_t, constants::MAX_SIGMA> adjust_freqs(
const std::array<uint64_t, constants::MAX_SIGMA>& freqs)
{
std::array<uint16_t, constants::MAX_SIGMA> adj_freqs { 0 };
size_t uniq_syms = 0;
size_t initial_sum = 0;
for (size_t i = 0; i < constants::MAX_SIGMA; i++) {
initial_sum += fre... | vxorpd %xmm0, %xmm0, %xmm0
movq %rdi, %rax
xorl %ecx, %ecx
xorl %edx, %edx
vmovupd %zmm0, 0x1c0(%rdi)
vmovupd %zmm0, 0x180(%rdi)
vmovupd %zmm0, 0x140(%rdi)
vmovupd %zmm0, 0x100(%rdi)
vmovupd %zmm0, 0xc0(%rdi)
vmovupd %zmm0, 0x80(%rdi)
vmovupd %zmm0, 0x40(%rdi)
vmovupd %zmm0, (%rdi)
xorl %edi, %edi
cmpq $0x100, %rdi ... | /mpetri[P]ans-large-alphabet/include/ans_byte.hpp |
ans_msb_compress(unsigned char*, unsigned long, unsigned int const*, unsigned long) | size_t ans_msb_compress(
uint8_t* dst, size_t dstCapacity, const uint32_t* src, size_t srcSize)
{
const uint32_t num_states = 4;
#ifdef RECORD_STATS
auto start_compress = std::chrono::high_resolution_clock::now();
#endif
auto in_u32 = reinterpret_cast<const uint32_t*>(src);
auto ans_frame = ans_msb... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq 0x38(%rsp), %rbx
movq %rdi, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rdx, %rsi
movq %rcx, %rdx
movq %rbx, %rdi
callq 0x33988
leaq 0x8(%rsp), %rsi
movq %r12, (%rsi)
movq %rbx, %rdi
callq 0x33ae0
movq 0x70(%rsp), %rax
xorl %ecx, %ec... | /mpetri[P]ans-large-alphabet/include/ans_msb.hpp |
ans_smsb_decode::load(unsigned char const*) | static ans_smsb_decode load(const uint8_t* in_u8)
{
ans_smsb_decode model;
model.nfreqs = ans_load_interp(in_u8);
model.frame_size = std::accumulate(
std::begin(model.nfreqs), std::end(model.nfreqs), 0);
model.frame_mask = model.frame_size - 1;
model.frame_log2 = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
vxorpd %xmm0, %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movq %rdi, %rbx
vmovupd %xmm0, (%rdi)
andq $0x0, 0x48(%rdi)
vmovupd %xmm0, 0x38(%rdi)
leaq 0x30(%rsp), %rdi
movq %rbx, 0x8(%rsp)
callq 0x30ce0
leaq 0x38(%rbx), %rax
leaq 0x30(%rsp), %r15
m... | /mpetri[P]ans-large-alphabet/include/ans_smsb.hpp |
void run<ANSfold<4u>>(std::vector<unsigned int, std::allocator<unsigned int>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void run(std::vector<uint32_t>& input, std::string input_name)
{
// (0) compute entropy
auto [input_entropy, sigma] = compute_entropy(input);
// (1) encode
std::vector<uint8_t> encoded_data(input.size() * 8);
std::vector<uint8_t> tmp_buf(input.size() * 8);
size_t encoded_bytes;
size_t enco... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0x2f2da
movq 0x8(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %rsp, %rdi
subq (%rbx), %rsi
addq %rsi, %rsi
callq 0x32bee
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
addq %rsi, %rsi
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x32bee
movb $0x1, %al
testb... | /mpetri[P]ans-large-alphabet/src/fold_effectiveness.cpp |
void run<ANSrfold<3u>>(std::vector<unsigned int, std::allocator<unsigned int>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | void run(std::vector<uint32_t>& input, std::string input_name)
{
// (0) compute entropy
auto [input_entropy, sigma] = compute_entropy(input);
// (1) encode
std::vector<uint8_t> encoded_data(input.size() * 8);
std::vector<uint8_t> tmp_buf(input.size() * 8);
size_t encoded_bytes;
size_t enco... | pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0x2f2da
movq 0x8(%rbx), %rsi
leaq 0x18(%rsp), %rdx
movq %rsp, %rdi
subq (%rbx), %rsi
addq %rsi, %rsi
callq 0x32bee
movq 0x8(%rbx), %rsi
subq (%rbx), %rsi
addq %rsi, %rsi
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x32bee
movb $0x1, %al
testb... | /mpetri[P]ans-large-alphabet/src/fold_effectiveness.cpp |
SHUFF_OUTPUT_BIT(bit_io_t*, long) | inline void SHUFF_OUTPUT_BIT(bit_io_t* bio, int64_t b)
{
*bio->out_u64 <<= 1;
if (b)
*bio->out_u64 |= 1;
bio->buff_btg--;
if (bio->buff_btg == 0) {
SHUFF_OUTPUT_NEXT(bio);
*bio->out_u64 = 0;
bio->buff_btg = SHUFF_BUFF_BITS;
}
} | movq 0x10(%rdi), %rax
xorl %edx, %edx
testq %rsi, %rsi
setne %dl
movq (%rax), %rcx
leaq (%rdx,%rcx,2), %rcx
movq %rcx, (%rax)
decq 0x20(%rdi)
je 0x3561e
retq
leaq 0x8(%rax), %rcx
movq %rcx, 0x10(%rdi)
andq $0x0, 0x8(%rax)
movq $0x40, 0x20(%rdi)
retq
| /mpetri[P]ans-large-alphabet/include/shuff.hpp |
interpolative_internal::read_center_mid(bit_stream&, unsigned long) | static inline uint64_t read_center_mid(bit_stream& is, uint64_t u)
{
auto b = u == 1ULL ? 0ULL : bits::hi(u - 1ULL) + 1ULL;
auto d = 2ULL * u - (1ULL << b);
uint64_t val = 1ULL;
if (u != 1) {
uint64_t m = (1ULL << b) - u;
val = is.get_int(b - 1) + 1;
... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpq $0x1, %rsi
jne 0x356f3
pushq $0x1
popq %r14
movq %r14, %r12
jmp 0x3573f
leaq -0x1(%rbx), %rax
leaq (%rbx,%rbx), %r14
movq %rdi, %r15
lzcntq %rax, %rsi
movl %esi, %eax
negb %al
pushq $0x1
popq %rcx
shlxq %rax, %rcx, %r13
xorq $0x3f, %rsi
subq %r... | /mpetri[P]ans-large-alphabet/include/interp.hpp |
interpolative_internal::encode_interpolative(bit_stream&, unsigned int const*, unsigned long, unsigned long, unsigned long) | static inline void encode_interpolative(bit_stream& os,
const uint32_t* in_buf, size_t n, size_t low, size_t high)
{
if (n == 0ULL)
return;
uint64_t h = (n + 1ULL) >> 1ULL;
uint64_t n1 = h - 1ULL;
uint64_t n2 = n - h;
uint64_t v = in_buf[h - 1ULL] ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, (%rsp)
incq %r8
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r15
movq (%rsp), %rbx
movq %r8, 0x8(%rsp)
testq %r14, %r14
je 0x358d5
leaq 0x1(%r14), %rax
shrq %rax
leaq -0x1(%rax), %rcx
movq %rcx, 0x10(%rsp)
pushq $0x1
popq %rcx
... | /mpetri[P]ans-large-alphabet/include/interp.hpp |
bits::write_int(unsigned int*&, unsigned int, unsigned char&, unsigned char) | inline void write_int(
uint32_t*& word, uint32_t x, uint8_t& offset, const uint8_t len)
{
x &= lo_set[len & 63];
if (offset + len < 32) {
*word &= ((all_set << (offset + len))
| lo_set[offset]); // mask 1..10..01..1
*word |= (x << offset);
offset += len;
} el... | movl %ecx, %r8d
andl $0x3f, %r8d
leaq 0x1b83f(%rip), %rax # 0x51200
andl (%rax,%r8,4), %esi
movzbl (%rdx), %r8d
movl %r8d, %r9d
addl %ecx, %r9d
cmpl $0x1f, %r9d
ja 0x359fc
pushq $-0x1
popq %r10
shlxl %r9d, %r10d, %r9d
orl (%rax,%r8,4), %r9d
movq (%rdi), %r8
andl (%r8), %r9d
movl %r9d, (%r8)
movb (%rdx), %dil
shlxl ... | /mpetri[P]ans-large-alphabet/include/bits.hpp |
ans_fold_encode<1u>::encode_symbol(unsigned long&, unsigned int, unsigned char*&) | void encode_symbol(uint64_t& state, uint32_t sym, uint8_t*& out_u8)
{
auto mapped_sym
= ans_fold_mapping_and_exceptions<fidelity>(sym, out_u8);
const auto& e = table[mapped_sym];
if (state >= e.sym_upper_bound) {
auto out_ptr_u32 = reinterpret_cast<uint32_t*>(out_u8);... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %r15
movl %edx, %edi
movq %rcx, %rsi
callq 0x4a023
movq 0x18(%r14), %rsi
movl %eax, %edx
movq (%rbx), %rax
shlq $0x4, %rdx
leaq (%rsi,%rdx), %rcx
cmpq 0x8(%rsi,%rdx), %rax
jb 0x49dc9
movq (%r15), %rdx
movl %eax, (%rdx)
addq $0x4, %rdx
shrq $0x2... | /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
unsigned long ans_fold_compress<2u>(unsigned char*, unsigned long, unsigned int const*, unsigned long) | size_t ans_fold_compress(
uint8_t* dst, size_t dstCapacity, const uint32_t* src, size_t srcSize)
{
auto in_u32 = reinterpret_cast<const uint32_t*>(src);
auto ans_frame = ans_fold_encode<fidelity>::create(in_u32, srcSize);
uint8_t* out_u8 = reinterpret_cast<uint8_t*>(dst);
// serialize model
ans... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
leaq 0x38(%rsp), %rbx
movq %rdi, %r12
movq %rcx, %r14
movq %rdx, %r15
movq %rdx, %rsi
movq %rcx, %rdx
movq %rbx, %rdi
callq 0x4a3a0
leaq 0x8(%rsp), %rsi
movq %r12, 0x30(%rsp)
movq %r12, (%rsi)
movq %rbx, %rdi
callq 0x4a4f8
leaq 0x38(%rsp... | /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
ans_fold_encode<2u>::encode_symbol(unsigned long&, unsigned int, unsigned char*&) | void encode_symbol(uint64_t& state, uint32_t sym, uint8_t*& out_u8)
{
auto mapped_sym
= ans_fold_mapping_and_exceptions<fidelity>(sym, out_u8);
const auto& e = table[mapped_sym];
if (state >= e.sym_upper_bound) {
auto out_ptr_u32 = reinterpret_cast<uint32_t*>(out_u8);... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rcx, %r15
movl %edx, %edi
movq %rcx, %rsi
callq 0x4a595
movq 0x18(%r14), %rsi
movl %eax, %edx
movq (%rbx), %rax
shlq $0x4, %rdx
leaq (%rsi,%rdx), %rcx
cmpq 0x8(%rsi,%rdx), %rax
jb 0x4a547
movq (%r15), %rdx
movl %eax, (%rdx)
addq $0x4, %rdx
shrq $0x2... | /mpetri[P]ans-large-alphabet/include/ans_fold.hpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.