name string | code string | asm string | file string |
|---|---|---|---|
mpiabi_reduce_scatter_block_ | void mpiabi_reduce_scatter_block_(
const void * sendbuf,
void * recvbuf,
const MPIABI_Fint * recvcount,
const MPIABI_Fint * datatype,
const MPIABI_Fint * op,
const MPIABI_Fint * comm,
MPIABI_Fint * ierror
) {
return mpi_reduce_scatter_block_(
sendbuf,
recvbuf,
recvcount,
datatype,
op... | jmp 0x223a0
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_reduce_scatter_ | void mpiabi_reduce_scatter_(
const void * sendbuf,
void * recvbuf,
const int * recvcounts,
const MPIABI_Fint * datatype,
const MPIABI_Fint * op,
const MPIABI_Fint * comm,
MPIABI_Fint * ierror
) {
return mpi_reduce_scatter_(
sendbuf,
recvbuf,
recvcounts,
datatype,
op,
comm,
ie... | jmp 0x21200
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_igatherv_ | void mpiabi_igatherv_(
const void * sendbuf,
const MPIABI_Fint * sendcount,
const MPIABI_Fint * sendtype,
void * recvbuf,
const int * recvcounts,
const int * displs,
const MPIABI_Fint * recvtype,
const MPIABI_Fint * root,
const MPIABI_Fint * comm,
MPIABI_Fint * request,
MPIABI_Fint * ierror
) {
... | jmp 0x22e00
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_iscatterv_ | void mpiabi_iscatterv_(
const void * sendbuf,
const int * sendcounts,
const int * displs,
const MPIABI_Fint * sendtype,
void * recvbuf,
const MPIABI_Fint * recvcount,
const MPIABI_Fint * recvtype,
const MPIABI_Fint * root,
const MPIABI_Fint * comm,
MPIABI_Fint * request,
MPIABI_Fint * ierror
) {
... | jmp 0x21b50
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_iallgather_ | void mpiabi_iallgather_(
const void * sendbuf,
const MPIABI_Fint * sendcount,
const MPIABI_Fint * sendtype,
void * recvbuf,
const MPIABI_Fint * recvcount,
const MPIABI_Fint * recvtype,
const MPIABI_Fint * comm,
MPIABI_Fint * request,
MPIABI_Fint * ierror
) {
return mpi_iallgather_(
sendbuf,
... | jmp 0x22e90
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_iallgatherv_ | void mpiabi_iallgatherv_(
const void * sendbuf,
const MPIABI_Fint * sendcount,
const MPIABI_Fint * sendtype,
void * recvbuf,
const int * recvcounts,
const int * displs,
const MPIABI_Fint * recvtype,
const MPIABI_Fint * comm,
MPIABI_Fint * request,
MPIABI_Fint * ierror
) {
return mpi_iallgatherv_(
... | jmp 0x23dc0
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_ialltoall_ | void mpiabi_ialltoall_(
const void * sendbuf,
const MPIABI_Fint * sendcount,
const MPIABI_Fint * sendtype,
void * recvbuf,
const MPIABI_Fint * recvcount,
const MPIABI_Fint * recvtype,
const MPIABI_Fint * comm,
MPIABI_Fint * request,
MPIABI_Fint * ierror
) {
return mpi_ialltoall_(
sendbuf,
se... | jmp 0x220d0
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_ialltoallv_ | void mpiabi_ialltoallv_(
const void * sendbuf,
const int * sendcounts,
const int * sdispls,
const MPIABI_Fint * sendtype,
void * recvbuf,
const int * recvcounts,
const int * rdispls,
const MPIABI_Fint * recvtype,
const MPIABI_Fint * comm,
MPIABI_Fint * request,
MPIABI_Fint * ierror
) {
return mp... | jmp 0x23160
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_ialltoallw_ | void mpiabi_ialltoallw_(
const void * sendbuf,
const int * sendcounts,
const int * sdispls,
const MPIABI_Fint * sendtypes,
void * recvbuf,
const int * recvcounts,
const int * rdispls,
const MPIABI_Fint * recvtypes,
const MPIABI_Fint * comm,
MPIABI_Fint * request,
MPIABI_Fint * ierror
) {
return ... | jmp 0x213c0
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_ireduce_scatter_block_ | void mpiabi_ireduce_scatter_block_(
const void * sendbuf,
void * recvbuf,
const MPIABI_Fint * recvcount,
const MPIABI_Fint * datatype,
const MPIABI_Fint * op,
const MPIABI_Fint * comm,
MPIABI_Fint * request,
MPIABI_Fint * ierror
) {
return mpi_ireduce_scatter_block_(
sendbuf,
recvbuf,
recv... | jmp 0x23d20
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_iexscan_ | void mpiabi_iexscan_(
const void * sendbuf,
void * recvbuf,
const MPIABI_Fint * count,
const MPIABI_Fint * datatype,
const MPIABI_Fint * op,
const MPIABI_Fint * comm,
MPIABI_Fint * request,
MPIABI_Fint * ierror
) {
return mpi_iexscan_(
sendbuf,
recvbuf,
count,
datatype,
op,
com... | jmp 0x21920
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_comm_create_group_ | void mpiabi_comm_create_group_(
const MPIABI_Fint * comm,
const MPIABI_Fint * group,
const MPIABI_Fint * tag,
MPIABI_Fint * newcomm,
MPIABI_Fint * ierror
) {
return mpi_comm_create_group_(
comm,
group,
tag,
newcomm,
ierror
);
} | jmp 0x224a0
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_comm_split_type_ | void mpiabi_comm_split_type_(
const MPIABI_Fint * comm,
const MPIABI_Fint * split_type,
const MPIABI_Fint * key,
const MPIABI_Fint * info,
MPIABI_Fint * newcomm,
MPIABI_Fint * ierror
) {
return mpi_comm_split_type_(
comm,
split_type,
key,
info,
newcomm,
ierror
);
} | jmp 0x23220
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_intercomm_create_ | void mpiabi_intercomm_create_(
const MPIABI_Fint * local_comm,
const MPIABI_Fint * local_leader,
const MPIABI_Fint * peer_comm,
const MPIABI_Fint * remote_leader,
const MPIABI_Fint * tag,
MPIABI_Fint * newintercomm,
MPIABI_Fint * ierror
) {
return mpi_intercomm_create_(
local_comm,
local_leader,... | jmp 0x23de0
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_comm_create_keyval_ | void mpiabi_comm_create_keyval_(
MPIABI_Fint * comm_copy_attr_fn,
MPIABI_Fint * comm_delete_attr_fn,
int * comm_keyval,
void * extra_state,
MPIABI_Fint * ierror
) {
return mpi_comm_create_keyval_(
comm_copy_attr_fn,
comm_delete_attr_fn,
comm_keyval,
extra_state,
ierror
);
} | jmp 0x23980
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_comm_get_attr_ | void mpiabi_comm_get_attr_(
const MPIABI_Fint * comm,
const MPIABI_Fint * comm_keyval,
void * attribute_val,
int * flag,
MPIABI_Fint * ierror
) {
return mpi_comm_get_attr_(
comm,
comm_keyval,
attribute_val,
flag,
ierror
);
} | jmp 0x213a0
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_win_get_attr_ | void mpiabi_win_get_attr_(
const MPIABI_Fint * win,
const MPIABI_Fint * win_keyval,
void * attribute_val,
int * flag,
MPIABI_Fint * ierror
) {
return mpi_win_get_attr_(
win,
win_keyval,
attribute_val,
flag,
ierror
);
} | jmp 0x22d10
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_cart_shift_ | void mpiabi_cart_shift_(
const MPIABI_Fint * comm,
const MPIABI_Fint * direction,
const MPIABI_Fint * disp,
int * rank_source,
int * rank_dest,
MPIABI_Fint * ierror
) {
return mpi_cart_shift_(
comm,
direction,
disp,
rank_source,
rank_dest,
ierror
);
} | jmp 0x22010
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_ineighbor_alltoallw_ | void mpiabi_ineighbor_alltoallw_(
const void * sendbuf,
const int * sendcounts,
const MPIABI_Fint * sdispls,
const MPIABI_Fint * sendtypes,
void * recvbuf,
const int * recvcounts,
const MPIABI_Fint * rdispls,
const MPIABI_Fint * recvtypes,
const MPIABI_Fint * comm,
MPIABI_Fint * request,
MPIABI_Fi... | jmp 0x21e10
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_info_set_ | void mpiabi_info_set_(
const MPIABI_Fint * info,
const char * key,
const char * value,
MPIABI_Fint * ierror,
size_t key_len,
size_t value_len
) {
return mpi_info_set_(
info,
key,
value,
ierror,
key_len,
value_len
);
} | jmp 0x22440
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_info_get_ | void mpiabi_info_get_(
const MPIABI_Fint * info,
const char * key,
const MPIABI_Fint * valuelen,
char * value,
int * flag,
MPIABI_Fint * ierror,
size_t key_len,
size_t value_len
) {
return mpi_info_get_(
info,
key,
valuelen,
value,
flag,
ierror,
key_len,
value_len
);
... | jmp 0x22210
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_info_get_valuelen_ | void mpiabi_info_get_valuelen_(
const MPIABI_Fint * info,
const char * key,
int * valuelen,
int * flag,
MPIABI_Fint * ierror,
size_t key_len
) {
return mpi_info_get_valuelen_(
info,
key,
valuelen,
flag,
ierror,
key_len
);
} | jmp 0x230a0
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_fetch_and_op_ | void mpiabi_fetch_and_op_(
const void * origin_addr,
void * result_addr,
const MPIABI_Fint * datatype,
const MPIABI_Fint * target_rank,
const MPIABI_Fint * target_disp,
const MPIABI_Fint * op,
const MPIABI_Fint * win,
MPIABI_Fint * ierror
) {
return mpi_fetch_and_op_(
origin_addr,
result_addr,... | jmp 0x239a0
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_rget_ | void mpiabi_rget_(
void * origin_addr,
const MPIABI_Fint * origin_count,
const MPIABI_Fint * origin_datatype,
const MPIABI_Fint * target_rank,
const MPIABI_Fint * target_disp,
const MPIABI_Fint * target_count,
const MPIABI_Fint * target_datatype,
const MPIABI_Fint * win,
MPIABI_Fint * request,
MPIAB... | jmp 0x22780
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_file_iread_at_all_ | void mpiabi_file_iread_at_all_(
const MPIABI_Fint * fh,
const MPIABI_Fint * offset,
void * buf,
const MPIABI_Fint * count,
const MPIABI_Fint * datatype,
MPIABI_Fint * request,
MPIABI_Fint * ierror
) {
return mpi_file_iread_at_all_(
fh,
offset,
buf,
count,
datatype,
request,
i... | jmp 0x23aa0
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_file_iwrite_at_all_ | void mpiabi_file_iwrite_at_all_(
const MPIABI_Fint * fh,
const MPIABI_Fint * offset,
const void * buf,
const MPIABI_Fint * count,
const MPIABI_Fint * datatype,
MPIABI_Fint * request,
MPIABI_Fint * ierror
) {
return mpi_file_iwrite_at_all_(
fh,
offset,
buf,
count,
datatype,
reques... | jmp 0x235a0
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
mpiabi_file_read_all_begin_ | void mpiabi_file_read_all_begin_(
const MPIABI_Fint * fh,
void * buf,
const MPIABI_Fint * count,
const MPIABI_Fint * datatype,
MPIABI_Fint * ierror
) {
return mpi_file_read_all_begin_(
fh,
buf,
count,
datatype,
ierror
);
} | jmp 0x21340
| /eschnett[P]MPIwrapper/build_O1/src/mpiabi_defn_functions_fortran.h |
GLOBAL__sub_I_Filter.cpp | Filter::Filter(int input_size, int output_size, double* learning_rate, string type) {
clock = Clock::getInstance();
int pos = type.find_first_of(',');
string filterType = type.substr(0, pos);
string cutoffFreq = type.substr(pos+1);
double normalizedFreq = stoi(cutoffFreq) / (1.0 / clock->getDt());
... | pushq %rbx
leaq 0x18c4f(%rip), %rbx # 0x23280
movq %rbx, %rdi
callq 0xa390
movq 0x189b8(%rip), %rdi # 0x22ff8
leaq 0x18c01(%rip), %rdx # 0x23248
movq %rbx, %rsi
popq %rbx
jmp 0xa240
| /haukri[P]MasterProject/Network/ANN/Filter.cpp |
Network::add(Synapse*) | void Network::add(Synapse* n_synapse) {
synapses.push_back(n_synapse);
if(!networkContainsPopulation(n_synapse->from_population))
populations.push_back(n_synapse->from_population);
if(!networkContainsPopulation(n_synapse->to_population))
populations.push_back(n_synapse->to_population);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rdx
movq %rdi, %rbx
movq %rsi, (%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0xbef4
movq %rdx, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0xbf05
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0xc1da
movq (%r14), %rdx
movq 0x8(%rdx), %rax
leaq 0x20(%rbx), %r14
movq 0x20(%r... | /haukri[P]MasterProject/Network/Network.cpp |
Network::update() | void Network::update() {
for(Population* p : populations) {
p->update();
}
for(Synapse* s : synapses) {
s->update();
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %r15
cmpq %r15, %r14
je 0xc145
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x8, %r14
jmp 0xc132
movq (%rbx), %r14
movq 0x8(%rbx), %rbx
cmpq %rbx, %r14
je 0xc15f
movq (%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x8... | /haukri[P]MasterProject/Network/Network.cpp |
Eigen::internal::inplace_transpose_selector<Eigen::Matrix<double, -1, -1, 0, -1, -1>, false, false>::run(Eigen::Matrix<double, -1, -1, 0, -1, -1>&) | static void run(MatrixType& m) {
if (m.rows()==m.cols())
m.matrix().template triangularView<StrictlyUpper>().swap(m.matrix().transpose());
else
m = m.transpose().eval();
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
jne 0xce46
leaq 0x10(%rsp), %rdi
movq %rbx, (%rdi)
leaq 0x28(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0xf(%rsp), %rdx
callq 0xcea4
jmp 0xce87
leaq 0x28(%rsp), %rsi
movq %rbx, (%rsi)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%... | /haukri[P]MasterProject/Eigen/src/Core/Transpose.h |
Eigen::internal::queryCacheSizes_intel_codes(int&, int&, int&) | inline void queryCacheSizes_intel_codes(int& l1, int& l2, int& l3)
{
int abcd[4];
abcd[0] = abcd[1] = abcd[2] = abcd[3] = 0;
l1 = l2 = l3 = 0;
EIGEN_CPUID(abcd,0x00000002,0);
unsigned char * bytes = reinterpret_cast<unsigned char *>(abcd)+2;
bool check_for_p2_core2 = false;
for(int i=0; i<14; ++i)
{
... | movq %rdx, %r8
xorl %r9d, %r9d
movl %r9d, (%rdx)
movl %r9d, (%rsi)
movl %r9d, (%rdi)
movl $0x2, %eax
xorl %ecx, %ecx
xchgq %rbx, %r10
cpuid
xchgq %rbx, %r10
movl %eax, -0x18(%rsp)
movl %r10d, -0x14(%rsp)
movl %ecx, -0x10(%rsp)
movl %edx, -0xc(%rsp)
leaq 0x9e44(%rip), %rax # 0x18dc8
xorl %ecx, %ecx
addq $-0xe, %r9
... | /haukri[P]MasterProject/Eigen/src/Core/util/Memory.h |
void Eigen::internal::call_dense_assignment_loop<Eigen::Matrix<double, -1, -1, 0, -1, -1>, Eigen::CwiseUnaryOp<double (*)(double), Eigen::Matrix<double, -1, -1, 0, -1, -1> const>, Eigen::internal::assign_op<double, double>>(Eigen::Matrix<double, -1, -1, 0, -1, -1>&, Eigen::CwiseUnaryOp<double (*)(double), Eigen::Matrix... | EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void call_dense_assignment_loop(DstXprType& dst, const SrcXprType& src, const Functor &func)
{
typedef evaluator<DstXprType> DstEvaluatorType;
typedef evaluator<SrcXprType> SrcEvaluatorType;
SrcEvaluatorType srcEvaluator(src);
// NOTE To properly handle A = (A*A.transpose... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq 0x8(%rsi), %r12
movq (%rax), %r13
movq 0x8(%rax), %r15
movq 0x10(%rax), %rbx
cmpq %r15, 0x8(%rdi)
jne 0x10df6
movq %rbx, %rax
movq %r15, %rcx
cmpq %rbx, 0x10(%r14)
je 0x10e47
movq %rbx, %rax
orq %r15, %rax
js 0x10ea1
testq %r1... | /haukri[P]MasterProject/Eigen/src/Core/AssignEvaluator.h |
Eigen::internal::gemm_pack_lhs<double, long, Eigen::internal::const_blas_data_mapper<double, long, 1>, 4, 2, 1, false, false>::operator()(double*, Eigen::internal::const_blas_data_mapper<double, long, 1> const&, long, long, long, long) | EIGEN_DONT_INLINE void gemm_pack_lhs<Scalar, Index, DataMapper, Pack1, Pack2, RowMajor, Conjugate, PanelMode>
::operator()(Scalar* blockA, const DataMapper& lhs, Index depth, Index rows, Index stride, Index offset)
{
typedef typename packet_traits<Scalar>::type Packet;
enum { PacketSize = packet_traits<Scalar>::s... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %r8, 0x10(%rsp)
orq 0xd0(%rsp), %r9
jne 0x12318
movq %rdx, %rdi
movq %rcx, %r15
shrq $0x3f, %r15
addq %rcx, %r15
andq $-0x2, %r15
leaq 0x18(%rsi), %rax
movq %rax, 0x70(%rsp)
movl $0x4, %edx
xorl %r9d, %r9d
xorl %r10d, %r10d
movq %rc... | /haukri[P]MasterProject/Eigen/src/Core/products/GeneralBlockPanelKernel.h |
Eigen::internal::gemm_pack_rhs<double, long, Eigen::internal::const_blas_data_mapper<double, long, 1>, 4, 1, false, false>::operator()(double*, Eigen::internal::const_blas_data_mapper<double, long, 1> const&, long, long, long, long) | EIGEN_DONT_INLINE void gemm_pack_rhs<Scalar, Index, DataMapper, nr, RowMajor, Conjugate, PanelMode>
::operator()(Scalar* blockB, const DataMapper& rhs, Index depth, Index cols, Index stride, Index offset)
{
EIGEN_ASM_COMMENT("EIGEN PRODUCT PACK RHS ROWMAJOR");
EIGEN_UNUSED_VARIABLE(stride);
EIGEN_UNUSED_VARIABL... | pushq %r15
pushq %r14
pushq %rbx
orq 0x20(%rsp), %r9
jne 0x12419
leaq 0x3(%r8), %rax
testq %r8, %r8
cmovnsq %r8, %rax
movq %rax, %rdi
andq $-0x4, %rdi
cmpq $0x4, %r8
jl 0x123cc
movq (%rdx), %r10
movq 0x8(%rdx), %r11
addq $0x18, %r10
shlq $0x3, %r11
xorl %ebx, %ebx
xorl %r9d, %r9d
movq %r10, %r14
movq %rcx, %r15
testq %... | /haukri[P]MasterProject/Eigen/src/Core/products/GeneralBlockPanelKernel.h |
Izhikevich::update(double) | Event* Izhikevich::update(double n_dt) {
dt = n_dt;
dv = 0.04*v*v + 5*v + 140 - u + input_current;
du = param->a*(param->b*v - u);
v += dv * dt + input_spike;
u += du * dt;
v = ( v < -std::numeric_limits< double >::max() ? -std::numeric_limits< double >::max() : v );
logger->logValue... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd %xmm0, 0x50(%rdi)
movsd 0x28(%rdi), %xmm2
movsd 0xa647(%rip), %xmm1 # 0x1d6a8
mulsd %xmm2, %xmm1
movsd 0xa643(%rip), %xmm3 # 0x1d6b0
mulsd %xmm2, %xmm3
mulsd %xmm2, %xmm1
addsd %xmm3, %xmm1
addsd 0xa637(%rip), %xmm1 # 0x1d6b8
movsd 0x20(%rdi), %xmm3
sub... | /haukri[P]MasterProject/Network/Neuron/Izhikevich.cpp |
CurrentGenerator::CurrentGenerator() | CurrentGenerator::CurrentGenerator() : param(new CurrentGenerator_param) {
clock = Clock::getInstance();
initialize();
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
generator = std::default_random_engine(seed);
distribution = std::normal_distribution<double>(param->no... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xf8ce(%rip), %rax # 0x22ae8
movq %rax, (%rdi)
movl $0x28, %edi
callq 0xa2a0
movsd 0xa4a9(%rip), %xmm0 # 0x1d6d8
movups %xmm0, (%rax)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%r... | /haukri[P]MasterProject/Network/Neuron/CurrentGenerator.cpp |
SignalGenerator::SignalGenerator() | SignalGenerator::SignalGenerator() : param(new SignalGenerator_param) {
clock = Clock::getInstance();
initialize();
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
generator = std::default_random_engine(0);
distribution = std::normal_distribution<double>(param->noiseMean... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xf671(%rip), %rax # 0x22b78
movq %rax, (%rdi)
movl $0x58, %edi
callq 0xa2a0
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movq %rcx, 0... | /haukri[P]MasterProject/Network/Neuron/SignalGenerator.cpp |
iaf_psc_alpha::propagator_31(double, double, double, double) | double iaf_psc_alpha::propagator_31( double tau_syn, double tau, double C, double h )
{
const double P31_linear = 1 / ( 3. * C * tau * tau ) * h * h * h * ( tau_syn - tau ) * std::exp( -h / tau );
const double P31 =
1 / C * ( std::exp( -h / tau_syn ) * std::expm1( -h / tau + h / tau_syn ) / ( tau / tau_syn - 1 ... | subq $0x88, %rsp
movapd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x68(%rsp)
movaps %xmm0, 0x30(%rsp)
movapd 0x9a9e(%rip), %xmm0 # 0x1d5e0
xorpd %xmm3, %xmm0
movapd %xmm0, (%rsp)
divsd %xmm1, %xmm0
movapd %xmm0, 0x70(%rsp)
callq 0xa430
movsd %xmm0, 0x58(%rsp)
movapd (%rsp), %xmm0
divsd 0x30(%rsp), %xmm... | /haukri[P]MasterProject/Network/Neuron/iaf_psc_alpha.cpp |
iaf_psc_alpha::calibrate() | void iaf_psc_alpha::calibrate() {
double h = dt*1000.0;
// these P are independent
P11_ex_ = P22_ex_ = std::exp( -h / param->tau_ex_ );
P11_in_ = P22_in_ = std::exp( -h / param->tau_in_ );
P33_ = std::exp( -h / param->Tau_ );
expm1_tau_m_ = std::expm1( -h / param->Tau_ );
// these ... | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movsd 0x28(%rdi), %xmm0
mulsd 0x42f9(%rip), %xmm0 # 0x18170
movapd %xmm0, (%rsp)
xorpd 0x975c(%rip), %xmm0 # 0x1d5e0
movapd %xmm0, 0x10(%rsp)
movq 0x30(%rdi), %rax
divsd 0x40(%rax), %xmm0
callq 0xa430
movsd %xmm0, 0xa0(%rbx)
movsd %xmm0, 0x90(%rbx)
movq 0x30(%rbx), %r... | /haukri[P]MasterProject/Network/Neuron/iaf_psc_alpha.cpp |
iaf_psc_alpha::update(double) | Event* iaf_psc_alpha::update(double n_dt) {
dt = n_dt;
if(shouldCalibrate) {
calibrate();
shouldCalibrate = false;
}
if ( r_ == 0 )
{
// neuron not refractory
y3_ = P30_ * ( y0_ + param->I_e_ ) + P31_ex_ * dI_ex_ + P32_ex_ * I_ex_ + P31_in_ * dI_in_
+ P32_in_ * I_... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd %xmm0, 0x28(%rdi)
cmpb $0x1, 0x20(%rdi)
jne 0x1404e
movq %rbx, %rdi
callq 0x13e62
movb $0x0, 0x20(%rbx)
movl 0x70(%rbx), %eax
testl %eax, %eax
je 0x14072
decl %eax
movl %eax, 0x70(%rbx)
movupd 0x48(%rbx), %xmm1
movupd 0x58(%rbx), %xmm2
movsd 0x68(%rbx), %xmm0
movq ... | /haukri[P]MasterProject/Network/Neuron/iaf_psc_alpha.cpp |
ReceptiveFieldEncodingSynapse::initialize(Population*, Population*) | void ReceptiveFieldEncodingSynapse::initialize(Population* n_from, Population* n_to) {
inputSize = n_from->getNumberOfNeurons();
outputSize = n_to->getNumberOfNeurons();
if(inputSize != 1) {
cout << "There can only be one input neuron" << endl;
throw "There can only be one input neuron";
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x8(%rax)
movl %eax, 0x30(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
movl %eax, 0x34(%rbx)
cmpl $0x1, 0x30(%rbx)
jne 0x14ac6
movq %r15, 0x8(... | /haukri[P]MasterProject/Network/Synapse/ReceptiveFieldEncodingSynapse.cpp |
ReceptiveFieldEncodingSynapse::ReceptiveFieldEncodingSynapse(Population*, Population*, ReceptiveFieldEncodingSynapse_param*) | ReceptiveFieldEncodingSynapse::ReceptiveFieldEncodingSynapse(Population* n_from, Population* n_to, ReceptiveFieldEncodingSynapse_param* param) :
param(param)
{
initialize(n_from, n_to);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xe186(%rip), %rax # 0x22d10
movq %rax, (%rdi)
movq %rcx, 0x18(%rdi)
leaq 0x20(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
leaq 0x58(%rdi), %r12
movups %xmm0, 0x58(%rdi)
movq $0x0, 0x68(%rdi)
callq 0x14880
addq $0x8, %rsp
popq ... | /haukri[P]MasterProject/Network/Synapse/ReceptiveFieldEncodingSynapse.cpp |
ReceptiveFieldDecodingSynapse::update() | void ReceptiveFieldDecodingSynapse::update() {
if(currentWindow + param->window_length_s <= clock->getCurrentTime()) {
spikeTimes.setConstant(-1);
currentWindow += param->window_length_s;
earliestSpike = false;
}
for(int j = 0; j < spikeTimes.size(); j++) {
if(spikeTimes(j) <... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movsd 0x40(%rdi), %xmm0
movq 0x18(%rdi), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x50(%rdi), %rdi
callq 0x157da
ucomisd (%rsp), %xmm0
jb 0x1568b
movq 0x28(%rbx), %rcx
testq %rcx, %rcx
js 0x1571e
movq 0x20(%rbx), %rdx
movabsq $0x7ffffffffffffffe, %rax # imm = 0x... | /haukri[P]MasterProject/Network/Synapse/ReceptiveFieldDecodingSynapse.cpp |
currentDateTime[abi:cxx11]() | string currentDateTime() {
time_t now = time(0);
struct tm tstruct;
char buf[80];
tstruct = *localtime(&now);
strftime(buf, sizeof(buf), "%Y-%m-%d.%X", &tstruct);
return buf;
} | pushq %r14
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbx
xorl %edi, %edi
callq 0xa250
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0xa1d0
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
leaq 0x60(%rsp), %rcx
movaps %xmm0, (%rcx)
movaps %xmm1, 0x10(%rcx)
movaps %xmm2, 0x20(%rcx)
movq 0x30(%rax), %ra... | /haukri[P]MasterProject/Network/utils/Logging.cpp |
FIR::getBuffer(int) | double FIR::getBuffer (int i){
if (i>= this->getTaps() or i<0) {
printf("\nThat value does not exist\n");
return 0.0;
}else{
return buff[i];
}
} | testl %esi, %esi
js 0x16b40
cmpl %esi, (%rdi)
jle 0x16b40
movl %esi, %eax
movq 0x40(%rdi), %rcx
cvtss2sd (%rcx,%rax,4), %xmm0
retq
pushq %rax
leaq 0x7201(%rip), %rdi # 0x1dd49
callq 0xa3a0
xorps %xmm0, %xmm0
addq $0x8, %rsp
retq
nop
| /haukri[P]MasterProject/Network/utils/FIR.cpp |
main | int
main()
{
using fn = tmf::callable<int(int)>;
// default initialize an empty callable 'a'
fn a{};
// assign 'a' with a class with `int operator()(int)` defined
// provide an rvalue to have your object possibly moved into the callable
a = functor{};
// you can provide an lvalue to have your... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
leaq 0x60(%rsp), %rbx
movb $0x1, 0x20(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
movaps %xmm0, 0x10(%rbx)
xorl %r13d, %r13d
leaq 0x10(%rsp), %r14
movb %r13b, 0x20(%r14)
leaq 0x6f8(%rip), %rax # 0x190e
movq %rax, 0x38(%r14)
movq ... | /tacticalmelonfarmer[P]handlebars/ext/callable/tests/assign.cpp |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>& nlohmann::json_ab... | reference at(KeyType && key)
{
// at only works for objects
if (JSON_HEDLEY_UNLIKELY(!is_object()))
{
JSON_THROW(type_error::create(304, detail::concat("cannot use at() with ", type_name()), this));
}
auto it = m_data.m_value.object->find(std::forward<KeyType>(ke... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
cmpb $0x1, (%rdi)
jne 0x53b24
movq %rsi, %r15
movq 0x8(%r14), %rdi
callq 0x5f5d4
movq 0x8(%r14), %rcx
addq $0x8, %rcx
cmpq %rcx, %rax
je 0x53b82
addq $0x40, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %r... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator<unsigned char>>, void>::basic_json(std::i... | basic_json(initializer_list_t init,
bool type_deduction = true,
value_t manual_type = value_t::array)
{
// check if each element is an array with two elements whose first
// element is a string
bool is_an_object = std::all_of(init.begin(), init.end(),
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r8d, %ebp
movl %ecx, %r12d
movq %rsi, %r14
movq %rdi, %rbx
imulq $0x18, %rdx, %r13
leaq (%rsi,%r13), %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rsi, %rdi
movq %r15, %rsi
callq 0x6054c
testb %r12b, %r12b
jne 0x53ea6
cmpb $0x... | /ggerganov[P]llama/common/json.hpp |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> nlohmann::json_abi_v3_11_3::detail::concat<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char const (&) [17], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char, std:... | inline OutStringType concat(Args && ... args)
{
OutStringType str;
str.reserve(concat_length(args...));
concat_into(str, std::forward<Args>(args)...);
return str;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %rbp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsi, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
movq %r8, %rcx
mov... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocato... | void parse(const bool strict, BasicJsonType& result)
{
if (callback)
{
json_sax_dom_callback_parser<BasicJsonType> sdp(result, callback, allow_exceptions);
sax_parse_internal(&sdp);
// in strict mode, input must be completely read
if (strict && (get_t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c0, %rsp # imm = 0x1C0
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r15
cmpq $0x0, 0x10(%rdi)
je 0x549be
leaq 0xc8(%rsp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x54cc4
movzbl 0xc0(%r15), %ecx
leaq 0x108(%rsp), %rdi
movq %rbx, %rsi
movq %r14,... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::input_stream_adapter::~input_stream_adapter() | ~input_stream_adapter()
{
// clear stream flags; we use underlying streambuf I/O, do not
// maintain ifstream flags, except eof
if (is != nullptr)
{
is->clear(is->rdstate() & std::ios::eofbit);
}
} | pushq %rax
movq (%rdi), %rax
testq %rax, %rax
je 0x54c56
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
leaq (%rax,%rcx), %rdi
movl 0x20(%rax,%rcx), %esi
andl $0x2, %esi
callq 0x2d270
popq %rax
retq
movq %rax, %rdi
callq 0x2fa75
| /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator... | explicit lexer(InputAdapterType&& adapter, bool ignore_comments_ = false) noexcept
: ia(std::move(adapter))
, ignore_comments(ignore_comments_)
, decimal_point_char(static_cast<char_int_type>(get_decimal_point()))
{} | pushq %rbx
movq %rdi, %rbx
movups (%rsi), %xmm0
movups %xmm0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movb %dl, 0x10(%rdi)
orl $-0x1, 0x14(%rdi)
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x60(%rdi), %rcx
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movq %rcx, 0x50(%rdi)
andq $0x0, 0... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator... | token_type scan()
{
// initially, skip the BOM
if (position.chars_read_total == 0 && !skip_bom())
{
error_message = "invalid BOM; must be 0xEF 0xBB 0xBF if given";
return token_type::parse_error;
}
// read next character and ignore whitespace
... | pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpq $0x0, 0x20(%rdi)
jne 0x54dfc
movq %rbx, %rdi
callq 0x54f1c
testb %al, %al
je 0x54e51
movq %rbx, %rdi
callq 0x54f5e
pushq $0xe
popq %rbp
movl 0x14(%rbx), %eax
cmpb $0x1, 0x10(%rbx)
jne 0x54e2b
cmpl $0x2f, %eax
jne 0x54e2b
movq %rbx, %rdi
callq 0x54f8e
testb %al... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator... | bool scan_comment()
{
switch (get())
{
// single-line comments skip input until a newline or EOF is read
case '/':
{
while (true)
{
switch (get())
{
case '\n':
... | pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x55808
cmpl $0x2f, %eax
je 0x54fd0
cmpl $0x2a, %eax
jne 0x54fed
movq %rbx, %rdi
callq 0x55808
cmpl $0x2a, %eax
je 0x54fb9
incl %eax
cmpl $0x2, %eax
jae 0x54fa3
jmp 0x54ff6
movq %rbx, %rdi
callq 0x55808
cmpl $0x2f, %eax
je 0x54fe9
movq %rbx, %rdi
callq 0x55870
jmp ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator... | token_type scan_string()
{
// reset token_buffer (ignore opening quote)
reset();
// we entered the function by reading an open quote
JSON_ASSERT(current == '\"');
while (true)
{
// get next character
switch (get())
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x55912
cmpl $0x22, 0x14(%rbx)
jne 0x554a0
leaq 0x50(%rbx), %r14
leaq 0x763e7(%rip), %r12 # 0xcb490
pushq $0xe
popq %rbp
movq %rbx, %rdi
callq 0x55808
incl %eax
cmpl $0xf5, %eax
ja 0x55472
movslq (%r12,%rax,4), ... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator... | token_type scan_number() // lgtm [cpp/use-of-goto]
{
// reset token_buffer to store the number's bytes
reset();
// the type of the parsed number; initially set to unsigned; will be
// changed if minus sign, decimal point or exponent is read
token_type number_type = token_ty... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x55912
movl 0x14(%rbx), %eax
leal -0x31(%rax), %ecx
cmpl $0x9, %ecx
jae 0x5559c
leaq 0x50(%rbx), %r14
pushq $0x5
popq %rbp
movsbl %al, %esi
movq %r14, %rdi
callq 0x2d360
leaq 0x50(%rbx), %r14
jmp 0x55520
movsbl 0x14(%rbx), %esi
movq %r14, %rd... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::lexer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allocator... | char_int_type get()
{
++position.chars_read_total;
++position.chars_read_current_line;
if (next_unget)
{
// just reset the next_unget variable and work with current
next_unget = false;
}
else
{
current = ia.get_character();... | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movdqu 0x20(%rdi), %xmm0
pcmpeqd %xmm1, %xmm1
psubq %xmm1, %xmm0
movdqu %xmm0, 0x20(%rdi)
cmpb $0x1, 0x18(%rdi)
jne 0x55831
movb $0x0, 0x18(%rbx)
movl 0x14(%rbx), %eax
jmp 0x5583c
movq %rbx, %rdi
callq 0x558d4
movl %eax, 0x14(%rbx)
cmpl $-0x1, %eax
je 0x5586b
leaq 0x38(%rbx),... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, ... | bool start_object(std::size_t len)
{
ref_stack.push_back(handle_value(BasicJsonType::value_t::object));
if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408, concat("excessive object size: ", s... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x8(%rsp), %rsi
movb $0x1, (%rsi)
callq 0x5bea6
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x5bf86
cmpq $-0x1, %r15
je 0x5bb47
movq 0x10(%r14), %rax
movq -0x8(%rax), %rdi
callq 0x585... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, ... | bool end_object()
{
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(ref_stack.back()->is_object());
ref_stack.back()->set_parents();
ref_stack.pop_back();
return true;
} | pushq %rax
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x5bc10
movq -0x8(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x5bc2c
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
movb $0x1, %al
popq %rcx
retq
leaq 0x770f3(%rip), %rdi # 0xd2d0a
leaq 0x77140(%rip), %rdx # 0xd2d5e
leaq 0x78100(%rip), %rcx # 0xd3d25
movl $0x1aeb, %es... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, ... | bool start_array(std::size_t len)
{
ref_stack.push_back(handle_value(BasicJsonType::value_t::array));
if (JSON_HEDLEY_UNLIKELY(len != static_cast<std::size_t>(-1) && len > ref_stack.back()->max_size()))
{
JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std:... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x8(%rsp), %rsi
movb $0x2, (%rsi)
callq 0x5bea6
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x5bf86
cmpq $-0x1, %r15
je 0x5bcfd
movq 0x10(%r14), %rax
movq -0x8(%rax), %rdi
callq 0x585... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::json_sax_dom_parser<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, ... | bool end_array()
{
JSON_ASSERT(!ref_stack.empty());
JSON_ASSERT(ref_stack.back()->is_array());
ref_stack.back()->set_parents();
ref_stack.pop_back();
return true;
} | pushq %rax
movq 0x10(%rdi), %rax
cmpq %rax, 0x8(%rdi)
je 0x5bdc6
movq -0x8(%rax), %rcx
cmpb $0x2, (%rcx)
jne 0x5bde2
addq $-0x8, %rax
movq %rax, 0x10(%rdi)
movb $0x1, %al
popq %rcx
retq
leaq 0x76f3d(%rip), %rdi # 0xd2d0a
leaq 0x76f8a(%rip), %rdx # 0xd2d5e
leaq 0x77f4a(%rip), %rcx # 0xd3d25
movl $0x1b01, %es... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std::allo... | void dump(const BasicJsonType& val,
const bool pretty_print,
const bool ensure_ascii,
const unsigned int indent_step,
const unsigned int current_indent = 0)
{
switch (val.m_data.m_type)
{
case value_t::object:
{
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movzbl (%rsi), %eax
cmpq $0x9, %rax
ja 0x5d58d
movl %r9d, %r13d
movl %r8d, %r14d
movl %ecx, %ebp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x6eb28(%rip), %rcx # 0xcb940
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rbx), %r... | /ggerganov[P]llama/common/json.hpp |
void nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std:... | void dump_integer(NumberType x)
{
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
{
{
{{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
{{'1', '0'}... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testl %esi, %esi
je 0x5dd69
movzbl %sil, %r14d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5e394
cmpl $0x3f, %eax
jae 0x5dda1
leaq 0x10(%rbx), %rsi
movl %eax, %ecx
leaq (%rsi,%rcx), %rdi
pushq $0x64
popq %r9
leaq 0x781db(%rip), %r8 # 0xd5f0b
cmpq $0x64, %r14
jb 0x5dd52
... | /ggerganov[P]llama/common/json.hpp |
void nlohmann::json_abi_v3_11_3::detail::serializer<nlohmann::json_abi_v3_11_3::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::json_abi_v3_11_3::adl_serializer, std::vector<unsigned char, std:... | void dump_integer(NumberType x)
{
static constexpr std::array<std::array<char, 2>, 100> digits_to_99
{
{
{{'0', '0'}}, {{'0', '1'}}, {{'0', '2'}}, {{'0', '3'}}, {{'0', '4'}}, {{'0', '5'}}, {{'0', '6'}}, {{'0', '7'}}, {{'0', '8'}}, {{'0', '9'}},
{{'1', '0'}... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x5de30
movq %rsi, %r14
movq %rbx, %rdi
callq 0x5e394
cmpl $0x3f, %eax
jae 0x5de68
leaq 0x10(%rbx), %rsi
movl %eax, %ecx
leaq (%rsi,%rcx), %rdi
pushq $0x64
popq %r9
leaq 0x781dc(%rip), %r8 # 0xd5fd3
cmpq $0x64, %r14
jb 0x5de19
movq %r14, %rax
xor... | /ggerganov[P]llama/common/json.hpp |
nlohmann::json_abi_v3_11_3::detail::type_error nlohmann::json_abi_v3_11_3::detail::type_error::create<std::nullptr_t, 0>(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::nullptr_t) | static type_error create(int id_, const std::string& what_arg, BasicJsonContext context)
{
const std::string w = concat(exception::name("type_error", id_), exception::diagnostics(context), what_arg);
return {id_, w.c_str()};
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x75e28(%rip), %rsi # 0xd3e6a
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2ef76
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movl %ebp, %edx
callq 0x5440e
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x54484
... | /ggerganov[P]llama/common/json.hpp |
minja::Value::operator<(minja::Value const&) const | bool operator<(const Value & other) const {
if (is_null())
throw std::runtime_error("Undefined value or reference");
if (is_number() && other.is_number()) return get<double>() < other.get<double>();
if (is_string() && other.is_string()) return get<std::string>() < other.get<std::string>();
throw s... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x8ad96
testb %al, %al
jne 0x905af
movb 0x40(%r15), %al
leal -0x5(%rax), %ecx
cmpb $0x2, %cl
ja 0x9054b
movb 0x40(%r14), %al
addb $-0x5, %al
cmpb $0x2, %al
ja 0x905df
movq %r15, %rdi
callq 0x8b134
movsd %xmm0, (%rsp)
movq... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::parseMathMulDiv() | std::shared_ptr<Expression> parseMathMulDiv() {
auto left = parseMathUnaryPlusMinus();
if (!left) throw std::runtime_error("Expected left side of 'math mul/div' expression");
static std::regex mul_div_tok(R"(\*\*?|//?|%(?!\}))");
std::string op_str;
while (!(op_str = consumeToke... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, 0x28(%rsp)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0xa5e54
cmpq $0x0, (%rbx)
je 0xa5d1a
leaq 0x87b11(%rip), %rax # 0x12d560
movb (%rax), %al
testb %al, %al
je 0xa5d4a
leaq 0x98(%rsp), %rax
movq %rax, -0... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::Parser::peekSymbols(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&) const | bool peekSymbols(const std::vector<std::string> & symbols) const {
for (const auto & symbol : symbols) {
if (std::distance(it, end) >= (int64_t) symbol.size() && std::string(it, it + symbol.size()) == symbol) {
return true;
}
}
return false;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq (%rsi), %rbx
movq 0x8(%rsi), %r12
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r15
cmpq %r12, %rbx
je 0xa6df5
movq 0x18(%r14), %rax
movq 0x20(%r14), %rsi
subq %rsi, %rax
movq 0x8(%rbx), %rdx
cmpq %rdx, %rax
jl 0xa6def
addq... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::SetTemplateToken::SetTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::ba... | SetTemplateToken(const Location & loc, SpaceHandling pre, SpaceHandling post, const std::string & ns, const std::vector<std::string> & vns, std::shared_ptr<Expression> && v)
: TemplateToken(Type::Set, loc, pre, post), ns(ns), var_names(vns), value(std::move(v)) {} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %r14
movq %r8, %r12
movl %ecx, %r8d
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %rbx
pushq $0xa
popq %rsi
callq 0xa3eb8
leaq 0x7b812(%rip), %rax # 0x12b238
addq $0x10, %rax
movq %rax, (%rbx)
leaq 0x30(%rbx), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0... | /ggerganov[P]llama/common/minja/minja.hpp |
minja::MacroTemplateToken::MacroTemplateToken(minja::Location const&, minja::SpaceHandling, minja::SpaceHandling, std::shared_ptr<minja::VariableExpr>&&, std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::shared_ptr<minja::Expression>>, std::allocator<std::pair<st... | MacroTemplateToken(const Location & loc, SpaceHandling pre, SpaceHandling post, std::shared_ptr<VariableExpr> && n, Expression::Parameters && p)
: TemplateToken(Type::Macro, loc, pre, post), name(std::move(n)), params(std::move(p)) {} | pushq %r15
pushq %r14
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movl %ecx, %r8d
movl %edx, %ecx
movq %rsi, %rdx
movq %rdi, %r15
pushq $0xd
popq %rsi
callq 0xa3eb8
leaq 0x7b3f3(%rip), %rax # 0x12b320
addq $0x10, %rax
movq %rax, (%r15)
andq $0x0, 0x38(%r15)
movups (%r14), %xmm0
andq $0x0, 0x8(%r14)
movups %xmm0, 0x30(... | /ggerganov[P]llama/common/minja/minja.hpp |
search_wstring() | void search_wstring()
{
variable data(L"bravo");
// wstring - null
{
variable subsequence;
auto where = std::search(data.begin(), data.end(),
subsequence.begin(), subsequence.end());
// Empty subsequence returns the first entry
TRIAL_PROTOCOL_... | pushq %rbp
movq %rsp, %rbp
subq $0xd10, %rsp # imm = 0xD10
leaq 0x282f2(%rip), %rsi # 0x334b4
leaq -0x30(%rbp), %rdi
callq 0x184c0
leaq -0x60(%rbp), %rdi
callq 0x17f30
jmp 0xb1d6
leaq -0xa0(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x180e0
jmp 0xb1e8
leaq -0xb8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1... | /breese[P]trial/test/dynamic/std/search_suite.cpp |
bsplib::UIntSerialize<unsigned int>::write(unsigned int, unsigned char (&) [5]) | static int write( UInt x, Buffer & bytes ) {
assert( x >= 0 );
int i = 0;
do {
unsigned char m = (1 << (CHAR_BIT-1));
unsigned char c = x & (m-1); // cut out least significant bits
x >>= (CHAR_BIT-1); // and save these in c
c |= (x > 0) * ... | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x0, -0x4(%rbp)
jb 0x2fcb7
jmp 0x2fcd6
leaq 0x873e(%rip), %rdi # 0x383fc
leaq 0x873e(%rip), %rsi # 0x38403
movl $0x14, %edx
leaq 0x90d5(%rip), %rcx # 0x38da6
callq 0x18200
movl $0x0, -0x14(%rbp)
movb $-0x80, -0... | /wijnand-suijlen[P]bsponmpi/src/uintserialize.h |
main | int main(int argc, char *argv[])
{
uint32_t hostaddr;
libssh2_socket_t sock;
struct sockaddr_in sin;
const char *fingerprint;
int rc;
LIBSSH2_SESSION *session = NULL;
LIBSSH2_CHANNEL *channel;
int exitcode = 0;
char *exitsignal = NULL;
size_t len;
LIBSSH2_KNOWNHOSTS *nh;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x7d68, %rsp # imm = 0x7D68
movq $0x0, 0x28(%rsp)
cmpl $0x2, %edi
jl 0x25c6
movq 0x8(%rsi), %rax
movq %rax, 0x2b9a(%rip) # 0x5160
cmpl $0x3, %edi
jl 0x25d6
movq 0x10(%rsi), %rax
movq %rax, 0x2b92(%rip) # 0x5168
cmpl $0x4, %edi
j... | /libssh2[P]libssh2/example/ssh2_echo.c |
ParticleFilter::write(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const | void ParticleFilter::write(std::string filename) const {
// You don't need to modify this file.
std::ofstream dataFile;
dataFile.open(filename, std::ios::app);
for (unsigned int i = 0; i < num_particles; ++i) {
dataFile << particles[i].x << " " << particles[i].y << " " << particles[i].theta << "\n";
}
dataFile.... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3250
pushq $0x1
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x30c0
xorl %r13d, %r13d
leaq 0x8(%rsp), %r14
leaq 0xef3(%rip), %r15 ... | /friedricherbs[P]CarND-Kidnapped-Vehicle/src/particle_filter.cpp |
opengv::relative_pose::twopt_rotationOnly(opengv::relative_pose::RelativeAdapterBase const&, unsigned long, unsigned long) | opengv::rotation_t
opengv::relative_pose::twopt_rotationOnly(
const RelativeAdapterBase & adapter,
size_t index0,
size_t index1)
{
Eigen::Vector3d pointsCenter1 =
adapter.getBearingVector1(index0) + adapter.getBearingVector1(index1);
Eigen::Vector3d pointsCenter2 =
adapter.getBearingVector2(... | subq $0x328, %rsp # imm = 0x328
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x320(%rsp)
movq %rsi, 0x318(%rsp)
movq %rdx, 0x310(%rsp)
movq %rcx, 0x308(%rsp)
movq 0x318(%rsp), %rsi
movq 0x310(%rsp), %rdx
movq (%rsi), %rax
movq 0x10(%rax), %rax
leaq 0x2c0(%rsp), %rdi
movq %rdi, 0x40(... | /simogasp[P]opengv/src/relative_pose/methods.cpp |
opengv::relative_pose::fivept_nister(opengv::relative_pose::RelativeAdapterBase const&, opengv::Indices const&) | essentials_t fivept_nister(
const RelativeAdapterBase & adapter,
const Indices & indices )
{
size_t numberCorrespondences = indices.size();
assert(numberCorrespondences > 4);
Eigen::MatrixXd Q(numberCorrespondences,9);
for( size_t i = 0; i < numberCorrespondences; i++ )
{
//bearingVector_t f = ad... | pushq %rbp
movq %rsp, %rbp
andq $-0x20, %rsp
subq $0x660, %rsp # imm = 0x660
movq %rdi, 0x150(%rsp)
movq %rdi, %rax
movq %rax, 0x158(%rsp)
movq %rdi, 0x648(%rsp)
movq %rsi, 0x640(%rsp)
movq %rdx, 0x638(%rsp)
movq 0x638(%rsp), %rdi
callq 0xa9adb0
movq %rax, 0x630(%rsp)
movl $0x9, 0x614(%rsp)
leaq 0x618(%rsp),... | /simogasp[P]opengv/src/relative_pose/methods.cpp |
opengv::relative_pose::fivept_kneip(opengv::relative_pose::RelativeAdapterBase const&, std::vector<int, std::allocator<int>> const&) | opengv::rotations_t
opengv::relative_pose::fivept_kneip(
const RelativeAdapterBase & adapter,
const std::vector<int> & indices )
{
size_t numberCorrespondences = indices.size();
assert(numberCorrespondences == 5);
Eigen::Matrix<double,3,5> f1;
Eigen::Matrix<double,3,5> f2;
for(size_t i = 0; i < numb... | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x1e0(%rsp)
movq %rsi, 0x1d8(%rsp)
movq %rdx, 0x1d0(%rsp)
movq 0x1d0(%rsp), %rdi
callq 0xa9b4f0
movq %rax, 0x1c8(%rsp)
leaq 0x150(%rsp), %rdi
callq 0xa9b510
leaq 0xd8(%rsp), %rdi
callq 0xa9b510
movq $0x0, 0... | /simogasp[P]opengv/src/relative_pose/methods.cpp |
opengv::relative_pose::sevenpt(opengv::relative_pose::RelativeAdapterBase const&, opengv::Indices const&) | essentials_t sevenpt(
const RelativeAdapterBase & adapter,
const Indices & indices )
{
size_t numberCorrespondences = indices.size();
assert(numberCorrespondences > 6);
Eigen::MatrixXd A(numberCorrespondences,9);
for( size_t i = 0; i < numberCorrespondences; i++ )
{
//bearingVector_t f1 = adapte... | subq $0xee8, %rsp # imm = 0xEE8
movq %rdi, 0x108(%rsp)
movq %rdi, %rax
movq %rax, 0x110(%rsp)
movq %rdi, 0xee0(%rsp)
movq %rsi, 0xed8(%rsp)
movq %rdx, 0xed0(%rsp)
movq 0xed0(%rsp), %rdi
callq 0xa9adb0
movq %rax, 0xec8(%rsp)
movl $0x9, 0xeac(%rsp)
leaq 0xeb0(%rsp), %rdi
leaq 0xec8(%rsp), %rsi
leaq 0xeac(%rsp)... | /simogasp[P]opengv/src/relative_pose/methods.cpp |
opengv::relative_pose::optimize_nonlinear(opengv::relative_pose::RelativeAdapterBase&, opengv::Indices const&) | transformation_t optimize_nonlinear(
RelativeAdapterBase & adapter,
const Indices & indices )
{
const int n=6;
VectorXd x(n);
x.block<3,1>(0,0) = adapter.gett12();
x.block<3,1>(3,0) = math::rot2cayley(adapter.getR12());
OptimizeNonlinearFunctor1 functor( adapter, indices );
NumericalDiff<OptimizeN... | subq $0x408, %rsp # imm = 0x408
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x400(%rsp)
movq %rsi, 0x3f8(%rsp)
movq %rdx, 0x3f0(%rsp)
movl $0x6, 0x3ec(%rsp)
leaq 0x3d8(%rsp), %rdi
leaq 0x3ec(%rsp), %rsi
callq 0xa9d540
movq 0x3f8(%rsp), %rsi
leaq 0x3c0(%rsp), %rdi
callq 0xa9d5a0
jmp... | /simogasp[P]opengv/src/relative_pose/methods.cpp |
opengv::relative_pose::modules::fivept_kneip::initEpncpRowR(std::vector<Eigen::Matrix<double, 3, 3, 0, 3, 3>, Eigen::aligned_allocator<Eigen::Matrix<double, 3, 3, 0, 3, 3>>>&, std::vector<Eigen::Matrix<double, 3, 3, 0, 3, 3>, Eigen::aligned_allocator<Eigen::Matrix<double, 3, 3, 0, 3, 3>>>&) | Eigen::Matrix<double,1,197>
opengv::relative_pose::modules::fivept_kneip::initEpncpRowR(
std::vector<Eigen::Matrix3d,Eigen::aligned_allocator<Eigen::Matrix3d> > & c123_1,
std::vector<Eigen::Matrix3d,Eigen::aligned_allocator<Eigen::Matrix3d> > & c123_2 )
{
Eigen::Matrix<double,1,197> row = Eigen::Matrix<double... | subq $0x3ab8, %rsp # imm = 0x3AB8
movq %rdi, 0x3a78(%rsp)
movq %rdi, %rax
movq %rax, 0x3a88(%rsp)
movq %rdi, 0x3ab0(%rsp)
movq %rsi, 0x3aa8(%rsp)
movq %rdx, 0x3aa0(%rsp)
leaq 0x3a90(%rsp), %rdi
callq 0xedd310
movq 0x3a78(%rsp), %rdi
leaq 0x3a90(%rsp), %rsi
callq 0xedd340
movq 0x3aa8(%rsp), %rdi
movl $0x1, %es... | /simogasp[P]opengv/src/relative_pose/modules/fivept_kneip/init.cpp |
opengv::relative_pose::modules::fivept_kneip::groebnerRow30_000000000_f(Eigen::Matrix<double, 66, 197, 0, 66, 197>&, int) | void
opengv::relative_pose::modules::fivept_kneip::groebnerRow30_000000000_f( Eigen::Matrix<double,66,197> & groebnerMatrix, int targetRow )
{
double factor = groebnerMatrix(targetRow,152) / groebnerMatrix(30,152);
groebnerMatrix(targetRow,152) = 0.0;
groebnerMatrix(targetRow,153) -= factor * groebnerMatrix(30,15... | subq $0x248, %rsp # imm = 0x248
movq %rdi, 0x240(%rsp)
movl %esi, 0x23c(%rsp)
movq 0x240(%rsp), %rdi
movslq 0x23c(%rsp), %rsi
movl $0x98, %edx
callq 0xebd010
vmovsd (%rax), %xmm0
vmovsd %xmm0, 0x8(%rsp)
movq 0x240(%rsp), %rdi
movl $0x1e, %esi
movl $0x98, %edx
callq 0xebd010
vmovsd 0x8(%rsp), %xmm0
vdivsd (%r... | /simogasp[P]opengv/src/relative_pose/modules/fivept_kneip/reductors.cpp |
opengv::relative_pose::modules::fivept_kneip::groebnerRow34_000000000_f(Eigen::Matrix<double, 66, 197, 0, 66, 197>&, int) | void
opengv::relative_pose::modules::fivept_kneip::groebnerRow34_000000000_f( Eigen::Matrix<double,66,197> & groebnerMatrix, int targetRow )
{
double factor = groebnerMatrix(targetRow,157) / groebnerMatrix(34,157);
groebnerMatrix(targetRow,157) = 0.0;
groebnerMatrix(targetRow,158) -= factor * groebnerMatrix(34,15... | subq $0x208, %rsp # imm = 0x208
movq %rdi, 0x200(%rsp)
movl %esi, 0x1fc(%rsp)
movq 0x200(%rsp), %rdi
movslq 0x1fc(%rsp), %rsi
movl $0x9d, %edx
callq 0xebd010
vmovsd (%rax), %xmm0
vmovsd %xmm0, 0x8(%rsp)
movq 0x200(%rsp), %rdi
movl $0x22, %esi
movl $0x9d, %edx
callq 0xebd010
vmovsd 0x8(%rsp), %xmm0
vdivsd (%r... | /simogasp[P]opengv/src/relative_pose/modules/fivept_kneip/reductors.cpp |
opengv::relative_pose::modules::fivept_kneip::sPolynomial43(Eigen::Matrix<double, 66, 197, 0, 66, 197>&) | void
opengv::relative_pose::modules::fivept_kneip::sPolynomial43( Eigen::Matrix<double,66,197> & groebnerMatrix )
{
groebnerMatrix(43,79) = -groebnerMatrix(36,160)/(groebnerMatrix(36,159));
groebnerMatrix(43,80) = -groebnerMatrix(36,161)/(groebnerMatrix(36,159));
groebnerMatrix(43,81) = -groebnerMatrix(36,162)/(g... | subq $0x1e8, %rsp # imm = 0x1E8
movq %rdi, 0x1e0(%rsp)
movq 0x1e0(%rsp), %rdi
movl $0x24, %esi
movl $0xa0, %edx
callq 0xebd010
vmovsd (%rax), %xmm0
vmovq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
vmovq %rax, %xmm0
vmovsd %xmm0, (%rsp)
movq 0x1e0(%rsp), %rdi
mov... | /simogasp[P]opengv/src/relative_pose/modules/fivept_kneip/spolynomials.cpp |
opengv::relative_pose::modules::sixpt::setupAction(std::vector<Eigen::Matrix<double, 6, 1, 0, 6, 1>, Eigen::aligned_allocator<Eigen::Matrix<double, 6, 1, 0, 6, 1>>> const&, std::vector<Eigen::Matrix<double, 6, 1, 0, 6, 1>, Eigen::aligned_allocator<Eigen::Matrix<double, 6, 1, 0, 6, 1>>> const&, Eigen::Matrix<double, 64,... | void
opengv::relative_pose::modules::sixpt::setupAction(
const std::vector<Eigen::Matrix<double,6,1>,Eigen::aligned_allocator< Eigen::Matrix<double,6,1> > > & L1,
const std::vector<Eigen::Matrix<double,6,1>,Eigen::aligned_allocator< Eigen::Matrix<double,6,1> > > & L2,
Eigen::Matrix<double,64,64> & Action )
... | pushq %rbp
movq %rsp, %rbp
andq $-0x40, %rsp
subq $0x70e40, %rsp # imm = 0x70E40
movq %rdi, 0x70e28(%rsp)
movq %rsi, 0x70e20(%rsp)
movq %rdx, 0x70e18(%rsp)
leaq 0x705a0(%rsp), %rax
movq %rax, %rcx
addq $0x870, %rcx # imm = 0x870
movq %rcx, 0x26440(%rsp)
movq %rax, 0x26448(%rsp)
movq 0x26448(%rsp), %... | /simogasp[P]opengv/src/relative_pose/modules/sixpt/modules2.cpp |
opengv::relative_pose::modules::eigensolver::composeMwithJacobians(Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::Matrix<double, 3, 3, ... | Eigen::Matrix3d
opengv::relative_pose::modules::eigensolver::composeMwithJacobians(
const Eigen::Matrix3d & xxF,
const Eigen::Matrix3d & yyF,
const Eigen::Matrix3d & zzF,
const Eigen::Matrix3d & xyF,
const Eigen::Matrix3d & yzF,
const Eigen::Matrix3d & zxF,
const cayley_t & cayley,
Eigen... | subq $0xb9d8, %rsp # imm = 0xB9D8
movq %rdi, 0x480(%rsp)
movq %rdi, %rax
movq %rax, 0x4d8(%rsp)
movq 0xba00(%rsp), %rax
movq 0xb9f8(%rsp), %rax
movq 0xb9f0(%rsp), %rax
movq 0xb9e8(%rsp), %rax
movq 0xb9e0(%rsp), %rax
movq %rdi, 0xb9d0(%rsp)
movq %rsi, 0xb9c8(%rsp)
movq %rdx, 0xb9c0(%rsp)
movq %rcx, 0xb9b8(%rsp... | /simogasp[P]opengv/src/relative_pose/modules/eigensolver/modules.cpp |
opengv::relative_pose::modules::ge::getEV(Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::Matrix<double, 3, 3, 0, 3, 3> const&, Eigen::M... | void
opengv::relative_pose::modules::ge::getEV(
const Eigen::Matrix3d & xxF,
const Eigen::Matrix3d & yyF,
const Eigen::Matrix3d & zzF,
const Eigen::Matrix3d & xyF,
const Eigen::Matrix3d & yzF,
const Eigen::Matrix3d & zxF,
const Eigen::Matrix<double,3,9> & x1P,
const Eigen::Matrix<double,... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
andq $-0x40, %rsp
subq $0x600, %rsp # imm = 0x600
movq 0x60(%rbp), %rax
movq 0x58(%rbp), %rax
movq 0x50(%rbp), %rax
movq 0x48(%rbp), %rax
movq 0x40(%rbp), %rax
movq 0x38(%rbp), %rax
movq 0x30(%rbp), %rax
movq 0x28(%rbp), %rax
m... | /simogasp[P]opengv/src/relative_pose/modules/ge/modules.cpp |
opengv::math::Bracket::Bracket(double, double, unsigned long, bool) | opengv::math::Bracket::Bracket(
double lowerBound, double upperBound, size_t changes, bool setUpperBoundChanges ) :
_lowerBound(lowerBound),
_upperBound(upperBound),
_lowerBoundChangesComputed(false),
_upperBoundChangesComputed(false),
_lowerBoundChanges(0),
_upperBoundChanges(0)
{
if( set... | movb %dl, %al
movq %rdi, -0x8(%rsp)
vmovsd %xmm0, -0x10(%rsp)
vmovsd %xmm1, -0x18(%rsp)
movq %rsi, -0x20(%rsp)
andb $0x1, %al
movb %al, -0x21(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x30(%rsp)
leaq 0x1c5319(%rip), %rcx # 0x1344bd8
addq $0x10, %rcx
movq %rcx, (%rax)
vmovsd -0x10(%rsp), %xmm0
vmovsd %xmm0, 0x8(%rax)
v... | /simogasp[P]opengv/src/math/Sturm.cpp |
opengv::math::Sturm::computeNegatedRemainder(Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Matrix<double, -1, -1, 0, -1, -1> const&, Eigen::Matrix<double, -1, -1, 0, -1, -1>&) | void
opengv::math::Sturm::computeNegatedRemainder(
const Eigen::MatrixXd & p1,
const Eigen::MatrixXd & p2,
Eigen::MatrixXd & r )
{
//we have to create 3 subtraction polynomials
Eigen::MatrixXd poly_1(1,p1.cols());
poly_1.block(0,0,1,p2.cols()) = (p1(0,0)/p2(0,0)) * p2;
poly_1(0,p1.cols()-1) = 0.0;
... | subq $0x338, %rsp # imm = 0x338
movq %rdi, 0x330(%rsp)
movq %rsi, 0x328(%rsp)
movq %rdx, 0x320(%rsp)
movq %rcx, 0x318(%rsp)
movl $0x1, 0x2fc(%rsp)
movq 0x328(%rsp), %rdi
callq 0xaa41a0
movq %rax, 0x2f0(%rsp)
leaq 0x300(%rsp), %rdi
leaq 0x2fc(%rsp), %rsi
leaq 0x2f0(%rsp), %rdx
callq 0x11831e0
movq 0x328(%rsp)... | /simogasp[P]opengv/src/math/Sturm.cpp |
opengv::math::Sturm::bracketRoots(std::vector<double, std::allocator<double>>&, double) | void
opengv::math::Sturm::bracketRoots( std::vector<double> & roots, double eps )
{
double absoluteBound = computeLagrangianBound();
std::list<Bracket::Ptr> stack;
stack.push_back(Bracket::Ptr(new Bracket(-absoluteBound,absoluteBound)));
stack.back()->setLowerBoundChanges( evaluateChain2(stack.back()->lowerBoun... | subq $0x148, %rsp # imm = 0x148
movq %rdi, 0x140(%rsp)
movq %rsi, 0x138(%rsp)
vmovsd %xmm0, 0x130(%rsp)
movq 0x140(%rsp), %rdi
movq %rdi, 0xa0(%rsp)
callq 0x11815a0
vmovsd %xmm0, 0x128(%rsp)
leaq 0x110(%rsp), %rdi
callq 0x1182b30
movl $0x30, %edi
callq 0xa85090
movq %rax, 0xa8(%rsp)
jmp 0x118209f
movq 0xa8(%... | /simogasp[P]opengv/src/math/Sturm.cpp |
opengv::generateRandomPoint(double, double) | Eigen::Vector3d
opengv::generateRandomPoint( double maximumDepth, double minimumDepth )
{
Eigen::Vector3d cleanPoint;
cleanPoint[0] = (((double) rand())/ ((double) RAND_MAX)-0.5)*2.0;
cleanPoint[1] = (((double) rand())/ ((double) RAND_MAX)-0.5)*2.0;
cleanPoint[2] = (((double) rand())/ ((double) RAND_MAX)-0.5)*2... | subq $0x138, %rsp # imm = 0x138
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x130(%rsp)
vmovsd %xmm0, 0x128(%rsp)
vmovsd %xmm1, 0x120(%rsp)
callq 0xa869f0
callq 0xa85320
movq 0x18(%rsp), %rdi
vcvtsi2sd %eax, %xmm0, %xmm0
vmovsd 0x12f3f(%rip), %xmm1 # 0x11a44f8
vdivsd %xmm1, %xmm... | /simogasp[P]opengv/test/random_generators.cpp |
curlx_sltosi | int curlx_sltosi(long slnum)
{
#ifdef __INTEL_COMPILER
# pragma warning(push)
# pragma warning(disable:810) /* conversion may lose significant bits */
#endif
DEBUGASSERT(slnum >= 0);
#if (SIZEOF_INT < SIZEOF_LONG)
DEBUGASSERT((unsigned long) slnum <= (unsigned long) CURL_MASK_SINT);
#endif
return (int)(slnum &... | movq %rdi, %rax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
retq
| /nomaster[P]curl/lib/warnless.c |
stop_session_fixture | void stop_session_fixture(void)
{
if(connected_session) {
libssh2_session_disconnect(connected_session, "test ended");
libssh2_session_free(connected_session);
connected_session = NULL;
}
else {
fprintf(stderr, "Cannot stop session - none started\n");
}
close_socket_... | pushq %rax
movq 0x47d0(%rip), %rdi # 0x71c0
testq %rdi, %rdi
je 0x2a44
leaq 0x17c7(%rip), %rdx # 0x41c3
leaq 0x179f(%rip), %rcx # 0x41a2
movl $0xb, %esi
callq 0x22f0
movq 0x47ac(%rip), %rdi # 0x71c0
callq 0x21a0
movq $0x0, 0x479c(%rip) # 0x71c0
movl 0x4776(%rip), %edi # 0x71a0
callq 0x3366
movl... | /sysprogs[P]libssh2/tests/session_fixture.c |
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender, int, 0>(fmt::v9::appender, int) | FMT_CONSTEXPR auto write(OutputIt out, T value) -> OutputIt {
auto abs_value = static_cast<uint32_or_64_or_128_t<T>>(value);
bool negative = is_negative(value);
// Don't do -abs_value since it trips unsigned-integer-overflow sanitizer.
if (negative) abs_value = ~abs_value + 1;
int num_digits = count_digits(ab... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, %r14d
negl %r14d
cmovsl %esi, %r14d
movl %r14d, %eax
orl $0x1, %eax
bsrl %eax, %eax
leaq 0x76d3b(%rip), %rcx # 0x9d910
movq (%rcx,%rax,8), %rcx
addq %r14, %rcx
movq %rcx, %r15
shrq $0x20, %r15
movl %es... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
fmt::v9::basic_memory_buffer<int, 500ul, std::allocator<int>>::grow(unsigned long) | FMT_CONSTEXPR20 void basic_memory_buffer<T, SIZE, Allocator>::grow(
size_t size) {
detail::abort_fuzzing_if(size > 5000);
const size_t max_size = std::allocator_traits<Allocator>::max_size(alloc_);
size_t old_capacity = this->capacity();
size_t new_capacity = old_capacity + old_capacity / 2;
if (size > ne... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r14
addq $0x7f0, %rdi # imm = 0x7F0
movq 0x18(%r14), %rbx
movq %rbx, %r15
shrq %r15
addq %rbx, %r15
cmpq %rsi, %r15
jae 0x280bc
movq %rsi, %r15
jmp 0x280d6
movq %r15, %rax
shrq $0x3d, %rax
je 0x280d6
movabsq $0x1fffffffffffffff, %r15 # imm = ... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write_padded<(fmt::v9::align::type)1, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::write_char<char, fmt::v9::appender>(fmt::v9::appender, char, fmt::v9::basic_format_specs<char> const&)::'lambda'(fmt::v9::appender)&>(fmt::v9::appender, fmt::v9::basic_format_specs<char> ... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x750e7(%rip), %rcx # 0x9d795
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r13
movq %rdi, %r12
addq $0xb, %rbx
... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::write<char, fmt::v9::appender, float, 0>(fmt::v9::appender, float) | FMT_CONSTEXPR20 auto write(OutputIt out, T value) -> OutputIt {
if (is_constant_evaluated())
return write(out, value, basic_format_specs<Char>());
if (const_check(!is_supported_floating_point(value))) return out;
auto fspecs = float_specs();
if (detail::signbit(value)) {
fspecs.sign = sign::minus;
... | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq $0x0, 0x8(%rsp)
movd %xmm0, %eax
testl %eax, %eax
jns 0x28c5f
movb $0x1, 0xd(%rsp)
pxor 0x72471(%rip), %xmm0 # 0x9b0d0
movups 0x7252a(%rip), %xmm1 # 0x9b190
movaps %xmm1, 0x10(%rsp)
movd %xmm0, %eax
andl $0x7fffffff, %eax # imm = 0x7FFFFFFF
cmpl $0x7f800000, ... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
fmt::v9::appender fmt::v9::detail::fill_n<fmt::v9::appender, int, char>(fmt::v9::appender, int, char const&) | FMT_CONSTEXPR auto fill_n(OutputIt out, Size count, const T& value)
-> OutputIt {
for (Size i = 0; i < count; ++i) *out++ = value;
return out;
} | pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
testl %esi, %esi
jle 0x29510
movq %rdx, %rbx
movl %esi, %ebp
movq 0x10(%r14), %rsi
incq %rsi
cmpq %rsi, 0x18(%r14)
jae 0x294f7
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movb (%rbx), %al
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x10... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::dragonbox::decimal_fp<float> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detai... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x740ee(%rip), %rcx # 0x9d790
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %rsi
addq $0xb, %rbx
... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
fmt::v9::detail::dragonbox::decimal_fp<float> fmt::v9::detail::write_padded<(fmt::v9::align::type)2, fmt::v9::appender, char, fmt::v9::appender fmt::v9::detail::do_write_float<fmt::v9::appender, fmt::v9::detail::dragonbox::decimal_fp<float>, char, fmt::v9::detail::digit_grouping<char>>(fmt::v9::appender, fmt::v9::detai... | FMT_CONSTEXPR auto write_padded(OutputIt out,
const basic_format_specs<Char>& specs,
size_t size, size_t width, F&& f) -> OutputIt {
static_assert(align == align::left || align == align::right, "");
unsigned spec_width = to_unsigned(specs.width);
siz... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl (%rsi), %eax
xorl %r14d, %r14d
subq %rcx, %rax
cmovaeq %rax, %r14
movzwl 0x9(%rsi), %eax
andl $0xf, %eax
leaq 0x73ab3(%rip), %rcx # 0x9d790
movb (%rax,%rcx), %cl
movq %r14, %r15
shrq %cl, %r15
movq %r8, %r12
movq %rdi, %rsi
addq $0xb, %rbx
... | /njoy[P]ENDFtk/build_O1/_deps/spdlog-src/include/spdlog/fmt/bundled/format.h |
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.