name string | code string | asm string | file string |
|---|---|---|---|
cube::net::Socket::BindAndListen(cube::net::InetAddr const&, int) | bool Socket::BindAndListen(const InetAddr &addr, int backlog) {
socklen_t sockaddr_len = sizeof(addr.SockAddrIn());
if (::bind(m_sockfd, addr.SockAddr(), sockaddr_len) < 0)
return false;
if (::listen(m_sockfd, backlog) < 0)
return false;
return true;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x10, -0x20(%rbp)
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4e8b0
movl -0x24(%rbp), %edi
movq %rax, %rsi
movl -0x20(%rbp), %e... | /yplusplus[P]cube/net/socket.cpp |
UniValue::pushKV(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, UniValue) | void UniValue::pushKV(std::string key, UniValue val)
{
checkType(VOBJ);
size_t idx;
if (findKey(key, idx))
values[idx] = std::move(val);
else
pushKVEnd(std::move(key), std::move(val));
} | endbr64
subq $0xe8, %rsp
movq %rsi, 0x28(%rsp)
movq %rdx, 0x18(%rsp)
movq %fs:0x28, %rax
movq %rax, 0xe0(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl $0x1, 0x64(%rsp)
leaq 0x64(%rsp), %rsi
callq 0xb000
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rs... | /brunoerg[P]bitcoin/src/univalue/lib/univalue.cpp |
UniValue::operator[](unsigned long) const | const UniValue& UniValue::operator[](size_t index) const
{
if (typ != VOBJ && typ != VARR)
return NullUniValue;
if (index >= values.size())
return NullUniValue;
return values.at(index);
} | endbr64
subq $0x38, %rsp
movq %fs:0x28, %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x1, (%rax)
je 0xbb17
movq 0x10(%rsp), %rax
cmpl $0x2, (%rax)
je 0xbb17
leaq 0x1bee8(%rip), %rax # 0x279f8
movq %rax, 0x28(%rsp)
jmp 0xbb62
movq 0x10(%rsp)... | /brunoerg[P]bitcoin/src/univalue/lib/univalue.cpp |
UniValue::find_value(std::basic_string_view<char, std::char_traits<char>>) const | const UniValue& UniValue::find_value(std::string_view key) const
{
for (unsigned int i = 0; i < keys.size(); ++i) {
if (keys[i] == key) {
return values.at(i);
}
}
return NullUniValue;
} | endbr64
subq $0x68, %rsp
movq %fs:0x28, %rax
movq %rax, 0x60(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0x28, %rdi
callq 0xc840
movq %rax, %rcx
movq 0x8(%... | /brunoerg[P]bitcoin/src/univalue/lib/univalue.cpp |
jsonTokenIsValue(jtokentype) | static inline bool jsonTokenIsValue(enum jtokentype jtt)
{
switch (jtt) {
case JTOK_KW_NULL:
case JTOK_KW_TRUE:
case JTOK_KW_FALSE:
case JTOK_NUMBER:
case JTOK_STRING:
return true;
default:
return false;
}
// not reached
} | subq $0x18, %rsp
movq %fs:0x28, %rax
movq %rax, 0x10(%rsp)
movl %edi, 0x8(%rsp)
movl 0x8(%rsp), %eax
addl $-0x7, %eax
subl $0x4, %eax
ja 0x19e5b
jmp 0x19e54
movb $0x1, 0xf(%rsp)
jmp 0x19e60
movb $0x0, 0xf(%rsp)
movb 0xf(%rsp), %al
movb %al, 0x7(%rsp)
movq %fs:0x28, %rax
movq 0x10(%rsp), %rcx
cmpq %rcx, %rax
jne 0x19e86... | /brunoerg[P]bitcoin/src/univalue/include/univalue.h |
json_escape(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | static std::string json_escape(const std::string& inS)
{
std::string outS;
outS.reserve(inS.size() * 2);
for (unsigned int i = 0; i < inS.size(); i++) {
unsigned char ch = static_cast<unsigned char>(inS[i]);
const char *escStr = escapes[ch];
if (escStr)
outS += escStr;
... | subq $0x68, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %fs:0x28, %rax
movq %rax, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movb $0x0, 0x4f(%rsp)
callq 0x6b90
movq 0x50(%rsp), %rdi
callq 0x8460
movq 0x20(%rsp), %rdi
movq %rax, %rsi
addq %rsi, %rsi
callq 0x12690
jmp 0x1d1bf
movl $0... | /brunoerg[P]bitcoin/src/univalue/lib/univalue_write.cpp |
main | int main() {
// clang-format off
auto injector = di::make_injector(
di::bind<int>().named(int1).to(42)
, di::bind<int>().named(int2).to(87)
);
// clang-format on
{
auto object = injector.create<T>();
assert(42 == object.a);
assert(87 == object.b);
}
{
auto object = T(42, 87);
ass... | xorl %eax, %eax
retq
| /boost-ext[P]di/example/user_guide/annotated_constructor_injection.cpp |
nn(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>>>>) | void nn(const std::vector<std::string> args) {
int32_t k;
if (args.size() == 3) {
k = 10;
} else if (args.size() == 4) {
k = std::stoi(args[3]);
} else {
printNNUsage();
exit(EXIT_FAILURE);
}
FastText fasttext;
fasttext.loadModel(std::string(args[2]));
std::string prompt("Query word? ");... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movq %rdi, %r14
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq $0x3, %rcx
je 0x13281
cmpq $0x4, %rcx
jne 0x13396
movq 0x60(%rax), %r12
callq 0x11050
movq %rax, %r15
movl (%rax), %ebp... | /Whadup[P]weightedFastText/src/main.cc |
fasttext::Args::printDictionaryHelp() | void Args::printDictionaryHelp() {
std::cerr << "\nThe following arguments for the dictionary are optional:\n"
<< " -minCount minimal number of word occurences ["
<< minCount << "]\n"
<< " -minCountLabel minimal number of label occurences ["
<< minCount... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x2027d(%rip), %r14 # 0x35fe8
leaq 0x14ed0(%rip), %rsi # 0x2ac42
movl $0x3a, %edx
movq %r14, %rdi
callq 0x11390
leaq 0x14ef7(%rip), %rsi # 0x2ac7d
movl $0x39, %edx
movq %r14, %rdi
callq 0x11390
movl 0x78(%rbx), %esi
movq %r14, %rdi
callq 0x115d0
movq %ra... | /Whadup[P]weightedFastText/src/args.cc |
fasttext::FastText::selectEmbeddings(int) const | std::vector<int32_t> FastText::selectEmbeddings(int32_t cutoff) const {
Vector norms(input_->size(0));
input_->l2NormRow(norms);
std::vector<int32_t> idx(input_->size(0), 0);
std::iota(idx.begin(), idx.end(), 0);
auto eosid = dict_->getId(Dictionary::EOS);
std::sort(idx.begin(), idx.end(), [&norms, eosid](size_t ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rsi), %rax
movq 0x18(%rax), %rsi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x27ea8
movq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0x23cda
movq 0x20(%r14), %rax
movq 0x18(%rax), %rs... | /Whadup[P]weightedFastText/src/fasttext.cc |
fasttext::FastText::quantize(fasttext::Args const&) | void FastText::quantize(const Args& qargs) {
if (args_->model != model_name::sup) {
throw std::invalid_argument(
"For now we only support quantization of supervised models");
}
args_->input = qargs.input;
args_->qout = qargs.qout;
args_->output = qargs.output;
if (qargs.cutoff > 0 && qargs.cutoff < input_-... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $0x3, 0x8c(%rdi)
jne 0x1dd06
movq %rsi, %r14
callq 0x111b0
movb 0x111(%r14), %al
movq (%rbx), %rdi
movb %al, 0x111(%rdi)
leaq 0x20(%r14), %rsi
addq $0x20, %rdi
callq 0x111b0
movq 0x118(%r14), %rdx
testq %rdx, %rdx
je 0x1... | /Whadup[P]weightedFastText/src/fasttext.cc |
fasttext::FastText::supervised(fasttext::Model&, float, std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&, int) | void FastText::supervised(
Model& model,
real lr,
const std::vector<int32_t>& line,
const std::vector<int32_t>& labels,
int32_t id) {
if (labels.size() == 0 || line.size() == 0) {
return;
}
if (args_->loss == loss_name::ova) {
model.update(line, labels, Model::kAllLabelsAsTarget, lr,id);
} else {
st... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq 0x8(%rcx), %rax
movq (%rcx), %rcx
subq %rcx, %rax
je 0x1e0ee
movq %rdx, %r15
movq 0x8(%rdx), %rcx
cmpq (%rdx), %rcx
je 0x1e0ee
movl %r8d, %ebx
movq %rsi, %r12
movq (%rdi), %rcx
cmpl $0x4, 0x88(%rcx)
jne 0x1e0ab
movq %r12, %rdi
movq %r15, ... | /Whadup[P]weightedFastText/src/fasttext.cc |
fasttext::FastText::retrain(fasttext::Args const&) | void FastText::retrain(const Args& args)
{
args_ = std::make_shared<Args>(args);
if (args_->model == model_name::sup) {
output_ = std::make_shared<Matrix>(dict_->nlabels(), args_->dim);
} else {
output_ = std::make_shared<Matrix>(dict_->nwords(), args_->dim);
}
output_->zero();
startThreads();
model_ = std:... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rcx
movq %rdi, %rbx
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x10(%rsp), %r15
leaq 0xc(%rsp), %r14
movq %r15, %rsi
movq %r14, %rdx
callq 0x23418
vmovaps (%r15), %xmm0
vxorps %xmm1, %xmm1, %xmm1
vmovaps %xmm1, (%r15)
movq 0x8(%rbx), %rdi
vm... | /Whadup[P]weightedFastText/src/fasttext.cc |
fasttext::Matrix::load(std::istream&) | void Matrix::load(std::istream& in) {
in.read((char*)&m_, sizeof(int64_t));
in.read((char*)&n_, sizeof(int64_t));
data_ = std::vector<real>(m_ * n_);
in.read((char*)data_.data(), m_ * n_ * sizeof(real));
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x113f0
leaq 0x20(%r14), %rsi
movl $0x8, %edx
movq %rbx, %rdi
callq 0x113f0
movq 0x20(%r14), %rsi
imulq 0x18(%r14), %rsi
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rd... | /Whadup[P]weightedFastText/src/matrix.cc |
fasttext::Matrix::dump(std::ostream&) const | void Matrix::dump(std::ostream& out) const {
out << m_ << " " << n_ << std::endl;
for (int64_t i = 0; i < m_; i++) {
for (int64_t j = 0; j < n_; j++) {
if (j > 0) {
out << " ";
}
out << at(i, j);
}
out << std::endl;
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rsi
movq %rbx, %rdi
callq 0x11310
movq %rax, %r15
leaq 0x76d1(%rip), %rsi # 0x2b534
movl $0x1, %edx
movq %rax, %rdi
callq 0x11390
movq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x11310
movq %... | /Whadup[P]weightedFastText/src/matrix.cc |
fasttext::Model::binaryLogistic(int, bool, float) | real Model::binaryLogistic(int32_t target, bool label, real lr) {
real score = sigmoid(wo_->dotRow(hidden_, target));
real alpha = lr * (real(label) - score);
grad_.addRow(*wo_, target, alpha);
wo_->addRow(hidden_, target, alpha);
if (label) {
return -log(score);
} else {
return -log(1.0 - score);
}
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
vmovss %xmm0, (%rsp)
movl %edx, %ebp
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
leaq 0x60(%rbx), %r14
movslq %esi, %r15
movq %r14, %rsi
movq %r15, %rdx
callq 0x2384e
vxorps %xmm2, %xmm2, %xmm2
vmovss 0x7949(%rip), %xmm1 # 0x2c3a0
vucomiss %xmm0, %xmm1
ja 0x24aa2
vuc... | /Whadup[P]weightedFastText/src/model.cc |
fasttext::Model::computeOutput(fasttext::Vector&, fasttext::Vector&) const | void Model::computeOutput(Vector& hidden, Vector& output) const {
if (quant_ && args_->qout) {
output.mul(*qwo_, hidden);
} else {
output.mul(*wo_, hidden);
}
} | movq %rdx, %rax
movq %rsi, %rdx
cmpb $0x1, 0x160(%rdi)
jne 0x24dba
movq 0x50(%rdi), %rcx
cmpb $0x1, 0x111(%rcx)
jne 0x24dba
movq 0x40(%rdi), %rsi
movq %rax, %rdi
jmp 0x282d6
movq 0x10(%rdi), %rsi
movq %rax, %rdi
jmp 0x28220
| /Whadup[P]weightedFastText/src/model.cc |
fasttext::ProductQuantizer::MStep(float const*, float*, unsigned char const*, int, int) | void ProductQuantizer::MStep(
const real* x0,
real* centroids,
const uint8_t* codes,
int32_t d,
int32_t n) {
std::vector<int32_t> nelts(ksub_, 0);
memset(centroids, 0, sizeof(real) * d * ksub_);
const real* x = x0;
for (auto i = 0; i < n; i++) {
auto k = codes[i];
real* c = centroids... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, (%rsp)
movl %r8d, %r13d
movq %rcx, %rbp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movslq 0x4(%rdi), %rsi
leaq 0x54(%rsp), %rdx
movl $0x0, (%rdx)
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x1a0a8
movslq %r13d, %rax... | /Whadup[P]weightedFastText/src/productquantizer.cc |
zvgBanner | void zvgBanner( ZvgSpeeds_a speeds, ZvgID_s *id)
{
uint port, monFlags;
//uint dma, dmaMode, irq;
uint monSpeed;
// get port stuff
zvgGetPortInfo( &port, &monFlags);
// lookup monitor speed in speed table based on switch settings
monSpeed = speeds[(id->sws >> 4) & 0x03];
// print banner
f... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4(%rsp), %r12
movq %rsp, %r14
movq %r12, %rdi
movq %r14, %rsi
callq 0x2200
movl 0x44(%r15), %eax
shrl $0x2, %eax
andl $0xc, %eax
movl (%rbx,%rax), %ebx
movq 0x69b8(%rip), %rbp # 0x8fb8
movq (%rbp), %... | /rhew[P]zvg-linux/shared/zvgBan.c |
zvgEncSetClipWin | void zvgEncSetClipWin( int xMin, int yMin, int xMax, int yMax)
{
int tSwap;
// start by flipping window if needed
if (ZvgENC.encFlags & ENCF_FLIPX)
{ xMin = ~xMin;
xMax = ~xMax;
}
if (ZvgENC.encFlags & ENCF_FLIPY)
{ yMin = ~yMin;
yMax = ~yMax;
}
// clip, clip window
if (ZvgENC.encFl... | pushq %rbx
movq 0x6694(%rip), %rax # 0x8fc0
movl 0x1c(%rax), %r9d
movl %r9d, %r8d
andl $0x1, %r8d
negl %r8d
xorl %r8d, %edi
xorl %edx, %r8d
movl %r9d, %edx
shll $0x1e, %edx
sarl $0x1f, %edx
xorl %edx, %esi
xorl %ecx, %edx
testb $0x10, %r9b
jne 0x2989
movl $0x257, %ecx # imm = 0x257
cmpl %ecx, %edi
cmovg... | /rhew[P]zvg-linux/shared/zvgEnc.c |
zvgEnc | void zvgEnc( int xStart, int yStart, int xEnd, int yEnd)
{
uint xLen, yLen;
uint xSign, ySign, vRatio;
uint zvgCmd;
int diff;
ZvgENC.vecCount++; // count number of vectors
// check for axis flips
if (ZvgENC.encFlags & ENCF_FLIPX)
{ xStart = ~xStart;
xEnd = ~xEnd;
}
if (ZvgENC.encFla... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x6558(%rip), %r9 # 0x8fc0
incl 0x34(%r9)
movl %esi, %eax
movl %edi, %r8d
movl 0x1c(%r9), %ebx
movl %ebx, %r10d
andl $0x1, %r10d
negl %r10d
movl %r10d, %edi
xorl %r8d, %edi
xorl %edx, %r10d
movl %ebx, %r11d
shll $0x1e, %r11d
sarl $0x1f, %r11d
... | /rhew[P]zvg-linux/shared/zvgEnc.c |
zvgEncPoint_ | static void _zvgEncPoint_( int xStart, int yStart, uint color)
{
uint xLen, yLen, len, zvgCmd;
uint xSign, ySign, vRatio;
// Check to see if color has changed
if (color != ZvgENC.zColor)
zvgCmd = zbCOLOR; // indicate color information is to be sent
else
zvgCmd = 0; // reset command flag... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %edx, %ecx
movq 0x590c(%rip), %r8 # 0x8fc0
movl 0x8(%r8), %r10d
xorl %eax, %eax
cmpl %edx, %r10d
setne %al
shll $0x6, %eax
movl (%r8), %ebp
movl 0x4(%r8), %r15d
movl %ebp, %edx
subl %edi, %edx
movl %edx, %r9d
negl %r9d
cmovsl %edx, %r9d
xorl %... | /rhew[P]zvg-linux/shared/zvgEnc.c |
negotiate_1284 | static uint negotiate_1284( uchar mode)
{
// Setup a negotiation request, setup for at least 1us
outportb( ZvgIO.ecpData, mode); // setup data lines
outportb( ZvgIO.ecpData, mode);
outportb( ZvgIO.ecpData, mode);
outportb( ZvgIO.ecpData, mode);
// Set 1284_Active high and HostBusy low
scdcr( DC... | pushq %r14
pushq %rbx
pushq %rax
movl %edi, %eax
movq 0x4a3a(%rip), %r14 # 0x8fe0
movzwl 0x8(%r14), %edx
outb %al, %dx
movzwl 0x8(%r14), %edx
outb %al, %dx
movzwl 0x8(%r14), %edx
outb %al, %dx
movzwl 0x8(%r14), %edx
outb %al, %dx
movb 0x1c(%r14), %al
andb $-0xb, %al
orb $0x2, %al
movb %al, 0x1c(%r14)
movzwl 0x10(%... | /rhew[P]zvg-linux/shared/zvgPort.c |
zvgSetEcpMode | uint zvgSetEcpMode( void)
{
uint err;
if (ZvgIO.ecpFlags & ECPF_ECP)
return (errOk); // already in ECP mode
// negotiate to ECP mode
if ((err = (negotiate_1284( EMODE_ECP))) != errOk)
return (err);
// is ECP mode supported?
if (!(rdsr() & DSR_XFlag))
{ terminate_1284(); // exit ne... | pushq %rbx
movq 0x467e(%rip), %rbx # 0x8fe0
xorl %eax, %eax
testb $0x1, 0x20(%rbx)
jne 0x49de
movl $0x10, %edi
callq 0x4599
testl %eax, %eax
jne 0x49de
movzwl 0xc(%rbx), %edx
inb %dx, %al
testb $0x10, %al
jne 0x4988
callq 0x4519
jmp 0x49d9
orb $0x1, 0x20(%rbx)
movb 0x1c(%rbx), %al
orb $0x2, %al
movb %al, 0x1c(%rbx... | /rhew[P]zvg-linux/shared/zvgPort.c |
waitForDsrNE | static uint waitForDsrNE( uchar mask, uchar bitVal, ulong ms)
{
uchar testVal;
uchar readVal;
long long int timer;
bool foundF;
testVal = ( bitVal ^ DSR_InvMask) & mask;
foundF = zFalse;
//tmrReadTimer(&timer);
timer = tmrReadTimer();
do
{
if (((readVal = inportb( ZvgIO.ecpDsr)) & mask) !=... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movl %edi, %r14d
callq 0x21f0
movq %rax, %r15
movq 0x4590(%rip), %r12 # 0x8fe0
movzwl 0xc(%r12), %edx
inb %dx, %al
movl %eax, %ecx
xorb %bpl, %cl
testb %r14b, %cl
jne 0x4a76
movq %r15, %rdi
movl %ebx, %esi
callq 0x2070
testl %ea... | /rhew[P]zvg-linux/shared/zvgPort.c |
zvgReadMonitorInfo | uint zvgReadMonitorInfo( ZvgMon_s *mon)
{
uint readLen, ecpErr, err=0;
if (!(ZvgIO.ecpFlags & ECPF_ECP))
err = zvgSetEcpMode(); // if not ECP mode, set to ECP mode
if (err)
return (err); // return on any errors
// request monitor information
//
// The ZVG has a 9 byte look ahead buffer... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x40a0(%rip), %r15 # 0x8fe0
testb $0x1, 0x20(%r15)
jne 0x4f50
callq 0x2150
testl %eax, %eax
jne 0x4fb8
movl $0xec, %edi
callq 0x2120
movl $0xe0, %edi
callq 0x2120
movl $0xe0, %edi
callq 0x2120
movl $0xe0, %edi
callq 0x2120
movl $0xe0, %edi... | /rhew[P]zvg-linux/shared/zvgPort.c |
main | int main(int argc, char** argv) {
cnn::Initialize(argc, argv, 1989);
if (argc != 4) {
cerr << "Usage: " << argv[0] << " corpus.txt dev.txt [model.params]\n";
return 1;
}
vector<Instance> training,dev;
string line;
int tlc = 0;
int ttoks = 0;
cerr << "Reading training data from " << argv[1] <... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x968, %rsp # imm = 0x968
leaq 0xac(%rsp), %rbx
movq %rsp, %rax
movq %rsi, (%rax)
movl %edi, (%rbx)
movl $0x7c5, %edx # imm = 0x7C5
movq %rbx, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0xd00b8
cmpl $0x4, (%rbx)
jne 0xc046f
le... | /LeonCrashCode[P]LookAheadFeature/impl/e-hierarchy-decoder-CH.cc |
RNNLanguageModel<cnn::FastLSTMBuilder>::RNNLanguageModel(cnn::Model&) | explicit RNNLanguageModel(Model& model) :
l2rbuilder(LAYERS+1, INPUT_WINDOWS_DIM, HIDDEN_DIM, &model),
r2lbuilder(LAYERS+1, INPUT_WINDOWS_DIM, HIDDEN_DIM, &model),
orderbuilder(LAYERS, HIDDEN_DIM*4, HIDDEN_DIM, &model){
p_w = model.add_lookup_parameters(VOCAB_SIZE, {WORD_DIM});
p_c = model.a... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
leaq 0xf70fb(%rip), %rbx # 0x1b8484
leaq 0xf7134(%rip), %r15 # 0x1b84c4
leaq 0xf7105(%rip), %r14 # 0x1b849c
movq %rsi, %r13
movq %rdi, %r12
addq $0xb0, %rdi
movq %r13, %r8
movq %rdi, 0x40(%rsp)
movl (%rbx), %esi
movl (%r15), ... | /LeonCrashCode[P]LookAheadFeature/impl/e-hierarchy-decoder-CH.cc |
cnn::ComputationGraph::PrintGraphviz() const | void ComputationGraph::PrintGraphviz() const {
cerr << "digraph G {\n rankdir=LR;\n nodesep=.05;\n";
unsigned nc = 0;
for (auto node : nodes) {
vector<string> var_names;
for (auto arg : node->args)
var_names.push_back(string("v") + to_string((unsigned)arg));
cerr << " N" << nc << " [label=\"v... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
movq 0xeef69(%rip), %rdi # 0x1b7fe8
leaq 0x74b80(%rip), %rsi # 0x13dc06
callq 0xbf470
movq 0x8(%rbx), %rax
movq (%rbx), %rbp
leaq 0x68(%rsp), %r13
leaq 0x88(%rsp), %rbx
movl $0x0, 0xc(%rsp)
movq %rax, 0x30(%rsp)
c... | /LeonCrashCode[P]LookAheadFeature/cnn/cnn.cc |
cnn::SimpleExecutionEngine::backward() | void SimpleExecutionEngine::backward() {
assert(nfxs.size() == cg.nodes.size());
backward((VariableIndex)(cg.nodes.size()-1));
} | pushq %rax
movq 0x18(%rdi), %rax
movq 0x8(%rdi), %rcx
subq 0x10(%rdi), %rax
pushq $0x48
popq %rsi
cqto
idivq %rsi
movq 0x8(%rcx), %rdx
subq (%rcx), %rdx
sarq $0x3, %rdx
cmpq %rdx, %rax
jne 0xca274
decl %eax
leaq 0x4(%rsp), %rsi
movl %eax, (%rsi)
movq (%rdi), %rax
callq *0x48(%rax)
popq %rax
retq
leaq 0x73c89(%rip), %rd... | /LeonCrashCode[P]LookAheadFeature/cnn/exec.cc |
cnn::expr::operator+(cnn::expr::Expression const&, cnn::expr::Expression const&) | Expression operator+(const Expression& x, const Expression& y) { return Expression(x.pg, x.pg->add_function<Sum>({x.i, y.i})); } | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl 0x8(%rsi), %eax
movq (%rsi), %r14
movq %rsp, %rcx
movq %rdi, %rbx
addq $0x8, %rdi
movl %eax, (%rcx)
movq %r14, %rsi
movl 0x8(%rdx), %eax
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq $0x2, 0x8(%rdx)
movl %eax, 0x4(%rcx)
callq 0xcc0ec
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x18... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::operator*(cnn::expr::Expression const&, float) | Expression operator*(const Expression& x, float y) { return Expression(x.pg, x.pg->add_function<ConstScalarMultiply>({x.i}, y)); } | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x4(%rsp), %rcx
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
addq $0x8, %rdi
vmovss %xmm0, (%rcx)
movq (%rsi), %r14
movl 0x8(%rsi), %eax
movq %rsp, %rsi
movq %rsi, (%rdx)
movq $0x1, 0x8(%rdx)
movl %eax, (%rsi)
movq %r14, %rsi
callq 0xcc2d0
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x18... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::colwise_add(cnn::expr::Expression const&, cnn::expr::Expression const&) | Expression colwise_add(const Expression& x, const Expression& bias) { return Expression(x.pg, x.pg->add_function<AddVectorToAllColumns>({x.i, bias.i})); } | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl 0x8(%rsi), %eax
movq (%rsi), %r14
movq %rsp, %rcx
movq %rdi, %rbx
addq $0x8, %rdi
movl %eax, (%rcx)
movq %r14, %rsi
movl 0x8(%rdx), %eax
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq $0x2, 0x8(%rdx)
movl %eax, 0x4(%rcx)
callq 0xcc3c2
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x18... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::contract3d_1d_1d(cnn::expr::Expression const&, cnn::expr::Expression const&, cnn::expr::Expression const&, cnn::expr::Expression const&) | Expression contract3d_1d_1d(const Expression& x, const Expression& y, const Expression& z, const Expression& b) { return Expression(x.pg, x.pg->add_function<InnerProduct3D_1D_1D>({x.i, y.i, z.i, b.i})); } | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0x8(%rsi), %eax
movq (%rsi), %r14
leaq 0x18(%rsp), %rsi
movq %rdi, %rbx
addq $0x8, %rdi
movl %eax, (%rsi)
movl 0x8(%rdx), %eax
leaq 0x8(%rsp), %rdx
movl %eax, 0x4(%rsi)
movl 0x8(%rcx), %eax
movl %eax, 0x8(%rsi)
movl 0x8(%r8), %eax
movq %rsi, (%rdx)
movq $0x4, 0x8(%rdx)
movl %... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::contract3d_1d(cnn::expr::Expression const&, cnn::expr::Expression const&, cnn::expr::Expression const&) | Expression contract3d_1d(const Expression& x, const Expression& y, const Expression& b) { return Expression(x.pg, x.pg->add_function<InnerProduct3D_1D>({x.i, y.i, b.i})); } | pushq %r14
pushq %rbx
subq $0x28, %rsp
movl 0x8(%rsi), %eax
movq (%rsi), %r14
leaq 0xc(%rsp), %rsi
movq %rdi, %rbx
addq $0x8, %rdi
movl %eax, (%rsi)
movl 0x8(%rdx), %eax
leaq 0x18(%rsp), %rdx
movl %eax, 0x4(%rsi)
movl 0x8(%rcx), %eax
movq %rsi, (%rdx)
movq $0x3, 0x8(%rdx)
movl %eax, 0x8(%rsi)
movq %r14, %rsi
callq 0xcc... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::erf(cnn::expr::Expression const&) | Expression erf(const Expression& x) { return Expression(x.pg, x.pg->add_function<Erf>({x.i})); } | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq (%rsi), %r14
movl 0x8(%rsi), %eax
movq %rdi, %rbx
leaq 0x4(%rsp), %rcx
leaq 0x8(%rsp), %rdx
addq $0x8, %rdi
movq %rcx, (%rdx)
movq $0x1, 0x8(%rdx)
movq %r14, %rsi
movl %eax, (%rcx)
callq 0xcc582
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::hinge(cnn::expr::Expression const&, unsigned int const*, float) | Expression hinge(const Expression& x, const unsigned* pindex, float m) { return Expression(x.pg, x.pg->add_function<Hinge>({x.i}, pindex, m)); } | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rcx
leaq 0xc(%rsp), %r8
movq %rdi, %rbx
addq $0x8, %rdi
movq %rdx, (%rcx)
vmovss %xmm0, (%r8)
leaq 0x18(%rsp), %rdx
movq (%rsi), %r14
movl 0x8(%rsi), %eax
leaq 0x8(%rsp), %rsi
movq %rsi, (%rdx)
movq $0x1, 0x8(%rdx)
movl %eax, (%rsi)
movq %r14, %rsi
callq 0xcc9f8
... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::log_softmax(cnn::expr::Expression const&, std::vector<unsigned int, std::allocator<unsigned int>> const&) | Expression log_softmax(const Expression& x, const vector<unsigned>& d) { return Expression(x.pg, x.pg->add_function<RestrictedLogSoftmax>({x.i}, d)); } | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq (%rsi), %r14
movl 0x8(%rsi), %eax
movq %rdx, %rcx
movq %rdi, %rbx
leaq 0x4(%rsp), %rsi
leaq 0x8(%rsp), %rdx
addq $0x8, %rdi
movq %rsi, (%rdx)
movq $0x1, 0x8(%rdx)
movl %eax, (%rsi)
movq %r14, %rsi
callq 0xccaee
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::min(cnn::expr::Expression const&, cnn::expr::Expression const&) | Expression min(const Expression& x, const Expression& y) { return Expression(x.pg, x.pg->add_function<Min>({x.i, y.i})); } | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl 0x8(%rsi), %eax
movq (%rsi), %r14
movq %rsp, %rcx
movq %rdi, %rbx
addq $0x8, %rdi
movl %eax, (%rcx)
movq %r14, %rsi
movl 0x8(%rdx), %eax
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq $0x2, 0x8(%rdx)
movl %eax, 0x4(%rcx)
callq 0xcccbc
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x18... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::noise(cnn::expr::Expression const&, float) | Expression noise(const Expression& x, real stddev) { return Expression(x.pg, x.pg->add_function<GaussianNoise>({x.i}, stddev)); } | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x4(%rsp), %rcx
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
addq $0x8, %rdi
vmovss %xmm0, (%rcx)
movq (%rsi), %r14
movl 0x8(%rsi), %eax
movq %rsp, %rsi
movq %rsi, (%rdx)
movq $0x1, 0x8(%rdx)
movl %eax, (%rsi)
movq %r14, %rsi
callq 0xccd9c
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x18... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::transpose(cnn::expr::Expression const&) | Expression transpose(const Expression& x) { return Expression(x.pg, x.pg->add_function<Transpose>({x.i})); } | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq (%rsi), %r14
movl 0x8(%rsi), %eax
movq %rdi, %rbx
leaq 0x4(%rsp), %rcx
leaq 0x8(%rsp), %rdx
addq $0x8, %rdi
movq %rcx, (%rdx)
movq $0x1, 0x8(%rdx)
movq %r14, %rsi
movl %eax, (%rcx)
callq 0xccfa0
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
| /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::select_rows(cnn::expr::Expression const&, std::vector<unsigned int, std::allocator<unsigned int>> const*) | Expression select_rows(const Expression& x, const vector<unsigned>* prows) { return Expression(x.pg, x.pg->add_function<SelectRows>({x.i}, prows)); } | pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0x10(%rsp), %rcx
movq %rdi, %rbx
addq $0x8, %rdi
movq %rdx, (%rcx)
leaq 0x18(%rsp), %rdx
movq (%rsi), %r14
movl 0x8(%rsi), %eax
leaq 0xc(%rsp), %rsi
movq %rsi, (%rdx)
movq $0x1, 0x8(%rdx)
movl %eax, (%rsi)
movq %r14, %rsi
callq 0xcd08e
movq %r14, (%rbx)
movq %rbx, %rax
addq $... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::dot_product(cnn::expr::Expression const&, cnn::expr::Expression const&) | Expression dot_product(const Expression& x, const Expression& y) { return Expression(x.pg, x.pg->add_function<DotProduct>({x.i, y.i})); } | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl 0x8(%rsi), %eax
movq (%rsi), %r14
movq %rsp, %rcx
movq %rdi, %rbx
addq $0x8, %rdi
movl %eax, (%rcx)
movq %r14, %rsi
movl 0x8(%rdx), %eax
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq $0x2, 0x8(%rdx)
movl %eax, 0x4(%rcx)
callq 0xcd2ec
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x18... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::squared_distance(cnn::expr::Expression const&, cnn::expr::Expression const&) | Expression squared_distance(const Expression& x, const Expression& y) { return Expression(x.pg, x.pg->add_function<SquaredEuclideanDistance>({x.i, y.i})); } | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl 0x8(%rsi), %eax
movq (%rsi), %r14
movq %rsp, %rcx
movq %rdi, %rbx
addq $0x8, %rdi
movl %eax, (%rcx)
movq %r14, %rsi
movl 0x8(%rdx), %eax
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq $0x2, 0x8(%rdx)
movl %eax, 0x4(%rcx)
callq 0xcd35c
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x18... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::poisson_loss(cnn::expr::Expression const&, unsigned int) | Expression poisson_loss(const Expression& x, unsigned y) { return Expression(x.pg, x.pg->add_function<PoissonRegressionLoss>({x.i}, y)); } | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x4(%rsp), %rcx
movq %rdi, %rbx
addq $0x8, %rdi
movl %edx, (%rcx)
leaq 0x8(%rsp), %rdx
movq (%rsi), %r14
movl 0x8(%rsi), %eax
movq %rsp, %rsi
movq %rsi, (%rdx)
movq $0x1, 0x8(%rdx)
movl %eax, (%rsi)
movq %r14, %rsi
callq 0xcd5b0
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x18, %... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::conv1d_narrow(cnn::expr::Expression const&, cnn::expr::Expression const&) | Expression conv1d_narrow(const Expression& x, const Expression& f) { return Expression(x.pg, x.pg->add_function<Conv1DNarrow>({x.i, f.i})); } | pushq %r14
pushq %rbx
subq $0x18, %rsp
movl 0x8(%rsi), %eax
movq (%rsi), %r14
movq %rsp, %rcx
movq %rdi, %rbx
addq $0x8, %rdi
movl %eax, (%rcx)
movq %r14, %rsi
movl 0x8(%rdx), %eax
leaq 0x8(%rsp), %rdx
movq %rcx, (%rdx)
movq $0x2, 0x8(%rdx)
movl %eax, 0x4(%rcx)
callq 0xcd6b0
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x18... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::expr::pick(cnn::expr::Expression const&, unsigned int) | Expression pick(const Expression& x, unsigned v) { return Expression(x.pg, x.pg->add_function<PickElement>({x.i}, v)); } | pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x4(%rsp), %rcx
movq %rdi, %rbx
addq $0x8, %rdi
movl %edx, (%rcx)
leaq 0x8(%rsp), %rdx
movq (%rsi), %r14
movl 0x8(%rsi), %eax
movq %rsp, %rsi
movq %rsi, (%rdx)
movq $0x1, 0x8(%rdx)
movl %eax, (%rsi)
movq %r14, %rsi
callq 0xcd890
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x18, %... | /LeonCrashCode[P]LookAheadFeature/cnn/expr.cc |
cnn::VariableIndex cnn::ComputationGraph::add_function<cnn::Negate>(std::initializer_list<cnn::VariableIndex> const&) | inline VariableIndex ComputationGraph::add_function(const std::initializer_list<VariableIndex>& arguments) {
VariableIndex new_node_index(nodes.size());
nodes.push_back(new Function(arguments));
set_dim_for_new_node(new_node_index);
return new_node_index;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
subq (%rsi), %rax
shrq $0x3, %rax
movl %eax, (%rdi)
pushq $0x50
popq %rdi
callq 0xbf480
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xcdc76
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, (%r... | /LeonCrashCode[P]LookAheadFeature/cnn/cnn.h |
cnn::VariableIndex cnn::ComputationGraph::add_function<cnn::ConstantPlusX, float&>(std::initializer_list<cnn::VariableIndex> const&, float&) | inline VariableIndex ComputationGraph::add_function(const std::initializer_list<VariableIndex>& arguments,
Args&&... side_information) {
VariableIndex new_node_index(nodes.size());
nodes.push_back(new Function(arguments, std::forward<Args>(side_information)...));
set_... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rsi), %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
subq (%rsi), %rax
shrq $0x3, %rax
movl %eax, (%rdi)
pushq $0x58
popq %rdi
callq 0xbf480
vmovss (%r12), %xmm0
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
callq ... | /LeonCrashCode[P]LookAheadFeature/cnn/cnn.h |
cnn::VariableIndex cnn::ComputationGraph::add_function<cnn::MatrixMultiply>(std::initializer_list<cnn::VariableIndex> const&) | inline VariableIndex ComputationGraph::add_function(const std::initializer_list<VariableIndex>& arguments) {
VariableIndex new_node_index(nodes.size());
nodes.push_back(new Function(arguments));
set_dim_for_new_node(new_node_index);
return new_node_index;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
subq (%rsi), %rax
shrq $0x3, %rax
movl %eax, (%rdi)
pushq $0x50
popq %rdi
callq 0xbf480
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xcdde8
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, (%r... | /LeonCrashCode[P]LookAheadFeature/cnn/cnn.h |
cnn::VariableIndex cnn::ComputationGraph::add_function<cnn::Sqrt>(std::initializer_list<cnn::VariableIndex> const&) | inline VariableIndex ComputationGraph::add_function(const std::initializer_list<VariableIndex>& arguments) {
VariableIndex new_node_index(nodes.size());
nodes.push_back(new Function(arguments));
set_dim_for_new_node(new_node_index);
return new_node_index;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
subq (%rsi), %rax
shrq $0x3, %rax
movl %eax, (%rdi)
pushq $0x50
popq %rdi
callq 0xbf480
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xcde9c
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, (%r... | /LeonCrashCode[P]LookAheadFeature/cnn/cnn.h |
cnn::VariableIndex cnn::ComputationGraph::add_function<cnn::LogGamma>(std::initializer_list<cnn::VariableIndex> const&) | inline VariableIndex ComputationGraph::add_function(const std::initializer_list<VariableIndex>& arguments) {
VariableIndex new_node_index(nodes.size());
nodes.push_back(new Function(arguments));
set_dim_for_new_node(new_node_index);
return new_node_index;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
subq (%rsi), %rax
shrq $0x3, %rax
movl %eax, (%rdi)
pushq $0x50
popq %rdi
callq 0xbf480
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xcdeea
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, (%r... | /LeonCrashCode[P]LookAheadFeature/cnn/cnn.h |
cnn::VariableIndex cnn::ComputationGraph::add_function<cnn::Exp>(std::initializer_list<cnn::VariableIndex> const&) | inline VariableIndex ComputationGraph::add_function(const std::initializer_list<VariableIndex>& arguments) {
VariableIndex new_node_index(nodes.size());
nodes.push_back(new Function(arguments));
set_dim_for_new_node(new_node_index);
return new_node_index;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
subq (%rsi), %rax
shrq $0x3, %rax
movl %eax, (%rdi)
pushq $0x50
popq %rdi
callq 0xbf480
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xcdf1e
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, (%r... | /LeonCrashCode[P]LookAheadFeature/cnn/cnn.h |
cnn::VariableIndex cnn::ComputationGraph::add_function<cnn::Rectify>(std::initializer_list<cnn::VariableIndex> const&) | inline VariableIndex ComputationGraph::add_function(const std::initializer_list<VariableIndex>& arguments) {
VariableIndex new_node_index(nodes.size());
nodes.push_back(new Function(arguments));
set_dim_for_new_node(new_node_index);
return new_node_index;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
subq (%rsi), %rax
shrq $0x3, %rax
movl %eax, (%rdi)
pushq $0x50
popq %rdi
callq 0xbf480
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xcdf86
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, (%r... | /LeonCrashCode[P]LookAheadFeature/cnn/cnn.h |
cnn::VariableIndex cnn::ComputationGraph::add_function<cnn::Softmax>(std::initializer_list<cnn::VariableIndex> const&) | inline VariableIndex ComputationGraph::add_function(const std::initializer_list<VariableIndex>& arguments) {
VariableIndex new_node_index(nodes.size());
nodes.push_back(new Function(arguments));
set_dim_for_new_node(new_node_index);
return new_node_index;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
subq (%rsi), %rax
shrq $0x3, %rax
movl %eax, (%rdi)
pushq $0x50
popq %rdi
callq 0xbf480
movq %rax, %r15
movq %rax, %rdi
movq %r12, %rsi
callq 0xce080
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, (%r... | /LeonCrashCode[P]LookAheadFeature/cnn/cnn.h |
cnn::VariableIndex cnn::ComputationGraph::add_function<cnn::PickRange, unsigned int&, unsigned int&>(std::initializer_list<cnn::VariableIndex> const&, unsigned int&, unsigned int&) | inline VariableIndex ComputationGraph::add_function(const std::initializer_list<VariableIndex>& arguments,
Args&&... side_information) {
VariableIndex new_node_index(nodes.size());
nodes.push_back(new Function(arguments, std::forward<Args>(side_information)...));
set_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %rax
movq %r8, %r12
movq %rcx, %r13
movq %rdx, %rbp
movq %rsi, %r14
movq %rdi, %rbx
subq (%rsi), %rax
shrq $0x3, %rax
movl %eax, (%rdi)
pushq $0x58
popq %rdi
callq 0xbf480
movl (%r13), %edx
movl (%r12), %ecx
movq %rax, %r15
mov... | /LeonCrashCode[P]LookAheadFeature/cnn/cnn.h |
cnn::VariableIndex cnn::ComputationGraph::add_function<cnn::KMHNGram, unsigned int&>(std::initializer_list<cnn::VariableIndex> const&, unsigned int&) | inline VariableIndex ComputationGraph::add_function(const std::initializer_list<VariableIndex>& arguments,
Args&&... side_information) {
VariableIndex new_node_index(nodes.size());
nodes.push_back(new Function(arguments, std::forward<Args>(side_information)...));
set_... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq 0x8(%rsi), %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
subq (%rsi), %rax
shrq $0x3, %rax
movl %eax, (%rdi)
pushq $0x58
popq %rdi
callq 0xbf480
movl (%r12), %edx
movq %rax, %r15
movq %rax, %rdi
movq %r13, %rsi
callq 0xc... | /LeonCrashCode[P]LookAheadFeature/cnn/cnn.h |
cnn::FastLSTMBuilder::start_new_sequence_impl(std::vector<cnn::expr::Expression, std::allocator<cnn::expr::Expression>> const&) | void FastLSTMBuilder::start_new_sequence_impl(const vector<Expression>& hinit) {
h.clear();
c.clear();
if (hinit.size() > 0) {
assert(layers*2 == hinit.size());
h0.resize(layers);
c0.resize(layers);
for (unsigned i = 0; i < layers; ++i) {
c0[i] = hinit[i];
h0[i] = hinit[i + layers];
... | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x58, %rdi
movq %rsi, %r14
callq 0xcf68e
leaq 0x70(%rbx), %rdi
callq 0xcf68e
movq 0x8(%r14), %rax
subq (%r14), %rax
je 0xceda6
movl 0xc0(%rbx), %esi
sarq $0x4, %rax
leal (%rsi,%rsi), %ecx
cmpq %rcx, %rax
jne 0xcedb6
leaq 0x90(%rbx), %rdi
callq 0xc7356
movl 0xc0(%rb... | /LeonCrashCode[P]LookAheadFeature/cnn/fast-lstm.cc |
cnn::FastLSTMBuilder::back() const | Expression back() const override { return (cur == -1? h0.back() : h[cur].back()); } | movslq 0x8(%rsi), %rcx
leaq 0x98(%rsi), %rdx
movq 0x58(%rsi), %rsi
movq %rdi, %rax
imulq $0x18, %rcx, %rdi
cmpq $-0x1, %rcx
leaq 0x8(%rsi,%rdi), %rcx
cmoveq %rdx, %rcx
movq (%rcx), %rcx
movq -0x10(%rcx), %rdx
movq %rdx, (%rax)
movl -0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
retq
| /LeonCrashCode[P]LookAheadFeature/cnn/fast-lstm.h |
cnn::RemoveArgs(int&, char**&, int&, int) | static void RemoveArgs(int& argc, char**& argv, int& argi, int n) {
for (int i = argi + n; i < argc; ++i)
argv[i - n] = argv[i];
argc -= n;
assert(argc >= 0);
} | pushq %rax
movl (%rdx), %ecx
movslq (%rdi), %rax
addl $0x2, %ecx
movslq %ecx, %rcx
cmpq %rax, %rcx
jge 0xd04c5
movq (%rsi), %rdx
movq (%rdx,%rcx,8), %r8
movq %r8, -0x10(%rdx,%rcx,8)
incq %rcx
jmp 0xd04af
leal -0x2(%rax), %ecx
movl %ecx, (%rdi)
cmpl $0x1, %eax
jle 0xd04d1
popq %rax
retq
leaq 0x6de34(%rip), %rdi # 0x... | /LeonCrashCode[P]LookAheadFeature/cnn/init.cc |
cnn::ParametersBase::~ParametersBase() | Parameters::Parameters(const Dim& d, float scale) : dim(d) {
values.d = g.d = d;
values.v = static_cast<float*>(ps->allocate(d.size() * sizeof(float)));
if (scale) {
TensorTools::Randomize(values, scale);
}
else {
TensorTools::Randomize(values);
}
g.v = static_cast<float*>(ps->allocate(d.size() * ... | ud2
| /LeonCrashCode[P]LookAheadFeature/cnn/model.cc |
cnn::LookupParameters::squared_l2norm(float*) const | void LookupParameters::squared_l2norm(float* sqnorm) const {
#if HAVE_CUDA
bool acc = false;
for (unsigned i = 0; i < values.size(); ++i) {
gpu::l2_norm_reducer(values[i].d.size(), values[i].v, sqnorm, true, acc);
acc = true;
}
#else
float a = 0;
for (unsigned i = 0; i < values.size(); ++i)
a += (... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
vxorps %xmm0, %xmm0, %xmm0
movq %rsi, %rbx
movq %rdi, %r14
xorl %eax, %eax
pushq $0x48
popq %r12
leaq 0x10(%rsp), %r15
movl %eax, %r13d
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rax
subq %rsi, %rax
cqto
idivq %r12
cmpq %r13, %rax
jbe 0xd0c27
imulq $0... | /LeonCrashCode[P]LookAheadFeature/cnn/model.cc |
cnn::LookupParameters::copy(cnn::LookupParameters const&) | void LookupParameters::copy(const LookupParameters & param) {
assert(dim == param.dim);
for(size_t i = 0; i < param.values.size(); ++i)
TensorTools::CopyElements(values[i], param.values[i]);
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
addq $0x8, %rsi
callq 0xd12c6
testb %al, %al
je 0xd0c9b
xorl %r15d, %r15d
pushq $0x48
popq %r12
xorl %r13d, %r13d
movq 0x30(%rbx), %rsi
movq 0x38(%rbx), %rax
subq %rsi, %rax
cqto
idivq %r12
cmpq %rax, %r13
jae 0xd0c91... | /LeonCrashCode[P]LookAheadFeature/cnn/model.cc |
cnn::Model::project_weights(float) | void Model::project_weights(float radius) {
static float* project_scratch = 0;
if (!project_scratch)
project_scratch = (float*)cnn_mm_malloc(all_params.size() * sizeof(float), 256);
int pi = 0;
for (auto p : all_params) {
p->squared_l2norm(&project_scratch[pi]);
++pi;
}
double gg = 0;
for (int... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0xe7afb(%rip) # 0x1b88b0
movq %rdi, %rbx
jne 0xd0dd5
movq 0x8(%rbx), %rdi
movl $0x100, %esi # imm = 0x100
subq (%rbx), %rdi
sarq %rdi
callq 0xc6c19
movq %rax, 0xe7adb(%rip) # 0x1b88b0
movq (%rbx), %r14
movq 0x8(%rbx), ... | /LeonCrashCode[P]LookAheadFeature/cnn/model.cc |
cnn::Model::add_parameters(cnn::Dim const&, float) | Parameters* Model::add_parameters(const Dim& d, float scale) {
Parameters* p = new Parameters(d, scale);
all_params.push_back(p);
params.push_back(p);
return p;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl $0xc0, %edi
vmovss %xmm0, 0xc(%rsp)
movq %rsi, %r15
callq 0xbf480
movq %rax, %r14
vmovss 0xc(%rsp), %xmm0
movq %rax, %rdi
movq %r15, %rsi
callq 0xd0648
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r14, (%r15)
movq %r14, (%rsi)
c... | /LeonCrashCode[P]LookAheadFeature/cnn/model.cc |
cnn::Tensor::operator*() | Eigen::Map<Eigen::MatrixXf> operator*() {
assert(d.batch_elems() == 1);
assert(d.ndims() < 3);
return Eigen::Map<Eigen::MatrixXf>(v, d.rows(), d.cols());
} | pushq %rbx
cmpl $0x1, 0x20(%rsi)
jne 0xd1179
movl 0x1c(%rsi), %ecx
cmpl $0x3, %ecx
jae 0xd1192
movq 0x28(%rsi), %rax
movl (%rsi), %edx
movq %rdi, %rbx
cmpl $0x2, %ecx
pushq $0x1
popq %rcx
cmovel 0x4(%rsi), %ecx
movq %rax, %rsi
callq 0xd17ce
movq %rbx, %rax
popq %rbx
retq
leaq 0xb8936(%rip), %rdi # 0x189ab6
leaq 0x6... | /LeonCrashCode[P]LookAheadFeature/cnn/tensor.h |
cnn::Tensor::operator*() const | const Eigen::Map<Eigen::MatrixXf> operator*() const {
assert(d.batch_elems() == 1);
assert(d.ndims() < 3);
return Eigen::Map<Eigen::MatrixXf>(v, d.rows(), d.cols());
} | pushq %rbx
cmpl $0x1, 0x20(%rsi)
jne 0xd121d
movl 0x1c(%rsi), %ecx
cmpl $0x3, %ecx
jae 0xd1236
movq 0x28(%rsi), %rax
movl (%rsi), %edx
movq %rdi, %rbx
cmpl $0x2, %ecx
pushq $0x1
popq %rcx
cmovel 0x4(%rsi), %ecx
movq %rax, %rsi
callq 0xd17ce
movq %rbx, %rax
popq %rbx
retq
leaq 0xb8892(%rip), %rdi # 0x189ab6
leaq 0x6... | /LeonCrashCode[P]LookAheadFeature/cnn/tensor.h |
void cnn::Model::save<boost::archive::text_oarchive>(boost::archive::text_oarchive&, unsigned int) const | void save(Archive& ar, const unsigned int) const {
int np = params.size();
int nlp = lookup_params.size();
ar & np;
ar & nlp;
for (unsigned i = 0; i < params.size(); ++i)
ar & *params[i];
for (unsigned i = 0; i < lookup_params.size(); ++i)
ar & *lookup_params[i];
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq 0x20(%rdi), %rax
movq %rsi, %rbx
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %r15
movq %rdi, %r14
subq 0x18(%rdi), %rax
shrq $0x3, %rax
movl %eax, (%rsi)
movq 0x38(%rdi), %rax
subq 0x30(%rdi), %rax
movq %rbx, %rdi
shrq $0x3, %rax
movl %eax, (%r15)
callq 0xd2cc0
movq %rbx,... | /LeonCrashCode[P]LookAheadFeature/cnn/model.h |
void cnn::Tensor::save<boost::archive::text_oarchive>(boost::archive::text_oarchive&, unsigned int) const | void save(Archive& ar, const unsigned int) const {
ar & d;
#if HAVE_CUDA
float* vc = (float*)malloc(d.size() * sizeof(float));
CUDA_CHECK(cudaMemcpy(vc, v, d.size() * sizeof(float), cudaMemcpyDeviceToHost));
ar & boost::serialization::make_array(vc, d.size());
free(vc);
#else
ar & boost::seriali... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq %rsi, %rbx
movq %rsi, %rdi
movq %r14, %rsi
callq 0xd2f0c
movq 0x28(%r14), %r15
movq %r14, %rdi
callq 0xc6d22
movq %rsp, %rsi
movq %rbx, %rdi
movl %eax, %eax
movq %r15, (%rsi)
movq %rax, 0x8(%rsi)
callq 0xd332a
addq $0x10, %rsp
popq %rbx
popq %r14
po... | /LeonCrashCode[P]LookAheadFeature/cnn/tensor.h |
void cnn::LookupParameters::save<boost::archive::text_oarchive>(boost::archive::text_oarchive&, unsigned int) const | void save(Archive& ar, const unsigned int) const {
ar & dim;
int nv = values.size();
ar & nv;
for (unsigned i = 0; i < values.size(); ++i)
ar & values[i];
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x8(%rdi), %rsi
movq %rdi, %r14
movq %rbx, %rdi
callq 0xd2f0c
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
pushq $0x48
popq %r15
cqto
leaq 0x4(%rsp), %rsi
movq %rbx, %rdi
idivq %r15
movl %eax, (%rsi)
callq 0xd2cc0
xorl %eax, %eax
movl %eax, %r12... | /LeonCrashCode[P]LookAheadFeature/cnn/model.h |
cnn::Pow::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void Pow::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
assert(xs.size() == 2);
#ifdef HAVE_CUDA
throw std::runtime_error("Pow not yet implemented... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x220, %rsp # imm = 0x220
movq (%rsi), %rax
movq 0x8(%rsi), %rdi
movq %rcx, %r14
subq %rax, %rdi
cmpq $0x10, %rdi
jne 0xd3baa
movq %rsi, %r12
movq (%rax), %rsi
leaq 0x10(%rsp), %rdi
movq %r9, %rbx
movl %r8d, %ebp
movq %rdx, %r15
callq 0xd11ee
movq ... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::Min::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void Min::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
assert(i < 2);
#ifdef HAVE_CUDA
throw std::runtime_error("Min not yet implemented for CUDA");
#else
const Te... | pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp # imm = 0x100
cmpl $0x2, %r8d
jae 0xd3e45
movl 0x20(%r9), %edx
leaq 0xe0(%rsp), %rbx
movq 0x48(%rdi), %rax
movq %r9, %r14
movq %rcx, %r15
movl %edx, -0x10(%rbx)
vmovups (%r9), %ymm0
vmovups %ymm0, -0x30(%rbx)
movq %rax, -0x8(%rbx)
andq $0x0, 0x10(%rbx)
vxorp... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::Max::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void Max::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
assert(i < 2);
#ifdef HAVE_CUDA
throw std::runtime_error("Max not yet implemented for CUDA");
#else
const Te... | pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp # imm = 0x100
cmpl $0x2, %r8d
jae 0xd4101
movl 0x20(%r9), %edx
leaq 0xe0(%rsp), %rbx
movq 0x48(%rdi), %rax
movq %r9, %r14
movq %rcx, %r15
movl %edx, -0x10(%rbx)
vmovups (%r9), %ymm0
vmovups %ymm0, -0x30(%rbx)
movq %rax, -0x8(%rbx)
andq $0x0, 0x10(%rbx)
vxorp... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::TraceOfProduct::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void TraceOfProduct::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
assert(i < 2);
#ifdef HAVE_CUDA
throw std::runtime_erro... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
cmpl $0x2, %r8d
jae 0xd423a
movq 0x28(%rcx), %rax
leaq 0xc(%rsp), %r14
movq %r9, %rbx
vmovss (%rax), %xmm0
vmovss %xmm0, (%r14)
pushq $0x1
popq %rax
movq (%rsi), %rcx
subl %r8d, %eax
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq (%rcx,%rax,8), %rsi
callq 0xd11ee... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::ConstScalarMultiply::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void ConstScalarMultiply::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
assert(i == 0);
#ifdef HAVE_CUDA... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
testl %r8d, %r8d
jne 0xd432c
leaq 0x28(%rsp), %r15
movq %rdi, %r14
movq %r9, %rbx
movq %rcx, %rsi
movq %r15, %rdi
callq 0xd11ee
addq $0x50, %r14
leaq 0x48(%rsp), %r12
movq %r15, %rsi
movq %r12, %rdi
movq %r14, %rdx
callq 0xd94dc
leaq 0x8(%rsp), %r14
movq %rbx... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::SumColumns::forward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor&) const | void SumColumns::forward_impl(const vector<const Tensor*>& xs, Tensor& fx) const {
auto x = **xs[0];
auto y = *fx;
if (xs.size() == 1) {
y = x.rowwise().sum();
} else {
throw std::invalid_argument("two inputs in SumColumns::forward!");
}
} | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq (%rsi), %rax
movq %rsi, %r14
movq %rdx, %rbx
movq %rsp, %rdi
movq (%rax), %rsi
callq 0xd11ee
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0xd114a
movq 0x8(%r14), %rax
subq (%r14), %rax
cmpq $0x8, %rax
jne 0xd465e
vmovups (%rsp), %xmm0
movq 0x10(%rsp), %rax
leaq 0x40(%rsp), %rs... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::KMHNGram::forward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor&) const | void KMHNGram::forward_impl(const vector<const Tensor*>& xs, Tensor& fx) const {
auto x = **xs[0];
const int new_cols = x.cols() - n + 1;
assert(new_cols > 0);
auto res = *fx;
res.setZero();
for (int j = 0; j < new_cols; ++j) {
auto c_j = res.col(j);
for (unsigned k = 0; k < n; ++k)
c_j += x.c... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq (%rsi), %rax
leaq 0x28(%rsp), %r14
movq %rdi, %rbx
movq %rdx, %r15
movq %r14, %rdi
movq (%rax), %rsi
callq 0xd11ee
movl 0x10(%r14), %r14d
subl 0x50(%rbx), %r14d
cmpl $0x7fffffff, %r14d # imm = 0x7FFFFFFF
jae 0xd47d9
leaq 0x8(%r... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::KMHNGram::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void KMHNGram::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
const int c = dEdf.d.cols();
for (int j = 0; j < c; ++j)
for (unsigned k = 0; k <... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp # imm = 0x108
movl 0x4(%rcx), %eax
movq %r9, 0x18(%rsp)
movq %rdi, 0x20(%rsp)
movq %rcx, 0x10(%rsp)
movl %eax, %edx
sarl $0x1f, %edx
andnl %eax, %edx, %eax
cmpl $0x2, 0x1c(%rcx)
pushq $0x1
popq %rcx
cmovael %eax, %ecx
leaq 0x... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::InnerProduct3D_1D::forward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor&) const | void InnerProduct3D_1D::forward_impl(const vector<const Tensor*>& xs, Tensor& fx) const {
auto A = xs[0]->t<3>();
auto b = xs[1]->t<1>();
typedef Eigen::Tensor<float, 1>::DimensionPair DimPair;
Eigen::array<DimPair, 1> dims({{DimPair(2, 0)}});
if (xs.size() == 2) {
fx.t<2>() = A.contract(b, dims);
} els... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movq (%rsi), %rax
movq %rsi, %r12
movq %rdx, %rbx
movq %rsp, %rdi
movq (%rax), %rsi
callq 0xd9682
movq (%r12), %rax
movq 0x8(%rax), %rdi
callq 0xd96c6
movq %rax, %r15
movq (%r12), %rax
movq 0x8(%r12), %rcx
movq %rdx, %r14
subq %rax, %rcx
cmpq $0x10... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::Dropout::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void Dropout::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
#ifdef HAVE_CUDA
throw std::runtime_error("Pow not yet implemented for CUDA");
#else
Tenso... | pushq %r14
pushq %rbx
subq $0xc8, %rsp
movl 0x40(%rdi), %edx
leaq 0xb0(%rsp), %rbx
movq 0x48(%rdi), %rax
movq %r9, %r14
movl %edx, -0x10(%rbx)
vmovups 0x20(%rdi), %ymm0
vmovups %ymm0, -0x30(%rbx)
movq %rax, -0x8(%rbx)
andq $0x0, 0x10(%rbx)
vxorps %xmm0, %xmm0, %xmm0
vmovaps %xmm0, (%rbx)
leaq 0x30(%rsp), %rdi
movq %rcx... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::BlockDropout::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void BlockDropout::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
#ifdef HAVE_CUDA
throw std::runtime_error("BlockDropout not yet imp... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq 0x48(%rdi), %rax
leaq 0x28(%rsp), %r15
leaq 0x4(%rsp), %r14
movq %r9, %rbx
movq %rcx, %rsi
movq %r15, %rdi
vmovss (%rax), %xmm0
vmovss %xmm0, (%r14)
callq 0xd11ee
leaq 0x48(%rsp), %r12
movq %r15, %rsi
movq %r14, %rdx
movq %r12, %rdi
callq 0xd94dc
leaq 0x... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::Sqrt::forward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor&) const | void Sqrt::forward_impl(const vector<const Tensor*>& xs, Tensor& fx) const {
#ifdef HAVE_CUDA
throw std::runtime_error("Sqrt not yet implemented for CUDA");
#else
auto x = **xs[0];
(*fx) = x.cwiseSqrt();
#endif
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq (%rsi), %rax
leaq 0x20(%rsp), %r14
movq %rdx, %rbx
movq %r14, %rdi
movq (%rax), %rsi
callq 0xd11ee
vmovups (%r14), %xmm0
movq 0x10(%r14), %rax
leaq 0x40(%rsp), %r15
movq %rsp, %r14
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, 0x10(%r15)
vmovaps %xmm0, (%r15)
callq 0x... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::Erf::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void Erf::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
#ifdef HAVE_CUDA
throw std::runtime_error("Erf not yet implemented for CUDA");
#else
auto ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq (%rsi), %rax
leaq 0x50(%rsp), %r15
movq %r9, %rbx
movq %rcx, %r14
movq %r15, %rdi
movq (%rax), %rsi
callq 0xd11ee
leaq 0x30(%rsp), %r12
movq %r14, %rsi
movq %r12, %rdi
callq 0xd11ee
leaq 0x70(%rsp), %r14
leaq 0xf(%rsp), %rcx
movq %r15, %rsi
movq %r12, %r... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::Square::forward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor&) const | void Square::forward_impl(const vector<const Tensor*>& xs, Tensor& fx) const {
#ifdef HAVE_CUDA
throw std::runtime_error("Square not yet implemented for CUDA");
#else
auto x = **xs[0];
(*fx).array() = x.array().square();
#endif
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq (%rsi), %rax
leaq 0x40(%rsp), %r14
movq %rdx, %rbx
movq %r14, %rdi
movq (%rax), %rsi
callq 0xd11ee
vmovups (%r14), %xmm0
movq 0x10(%r14), %rax
leaq 0x60(%rsp), %r15
leaq 0x20(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rdi
movq %rax, 0x10(%r15)
vmovaps %xmm0, (%r15)
ca... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::Square::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void Square::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
#ifdef HAVE_CUDA
throw std::runtime_error("Square not yet implemented for CUDA");
#else
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp # imm = 0x128
movq (%rsi), %rax
leaq 0x50(%rsp), %r15
movq %r9, %rbx
movq %rcx, %r14
movq %r15, %rdi
movq (%rax), %rsi
callq 0xd11ee
leaq 0x30(%rsp), %r12
movq %r14, %rsi
movq %r12, %rdi
callq 0xd11ee
leaq 0x70(%rsp), %r14
movq %r12, %rsi
movq %r1... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::Cube::forward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor&) const | void Cube::forward_impl(const vector<const Tensor*>& xs, Tensor& fx) const {
#ifdef HAVE_CUDA
throw std::runtime_error("Square not yet implemented for CUDA");
#else
auto x = **xs[0];
(*fx).array() = x.array().cube();
#endif
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq (%rsi), %rax
leaq 0x40(%rsp), %r14
movq %rdx, %rbx
movq %r14, %rdi
movq (%rax), %rsi
callq 0xd11ee
vmovups (%r14), %xmm0
movq 0x10(%r14), %rax
leaq 0x60(%rsp), %r15
leaq 0x20(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rdi
movq %rax, 0x10(%r15)
vmovaps %xmm0, (%r15)
ca... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::Cube::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void Cube::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
#ifdef HAVE_CUDA
throw std::runtime_error("Cube not yet implemented for CUDA");
#else
auto x = **xs[0];
/... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq (%rsi), %rax
leaq 0x90(%rsp), %r15
movq %r9, %rbx
movq %rcx, %r14
movq %r15, %rdi
movq (%rax), %rsi
callq 0xd11ee
leaq 0x70(%rsp), %r12
movq %r14, %rsi
movq %r12, %rdi
callq 0xd11ee
movq 0x10(%r12), %rax
vmovups (%r12), %xmm0
vm... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::Concatenate::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void Concatenate::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
assert(i < src_row_indices.size());
const unsigned rows = dEdx... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movq 0x50(%rdi), %rdx
movq 0x58(%rdi), %rsi
movl %r8d, %eax
subq %rdx, %rsi
sarq $0x2, %rsi
cmpq %rax, %rsi
jbe 0xd6624
movl (%r9), %ebp
movl (%rdx,%rax,4), %r14d
leaq 0x20(%rsp), %r15
movq %r9, %rbx
movq %rcx, %rsi
movq %r15, %rdi
callq 0xd11ee
le... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::ConcatenateColumns::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void ConcatenateColumns::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
#if HAVE_CUDA
const unsigned ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
leaq 0x20(%rsp), %r12
movq %rdi, %r15
movq %r9, %rsi
movl %r8d, %ebx
movq %rcx, %r14
movq %r12, %rdi
callq 0xd114a
movq 0x48(%r15), %rax
movl %ebx, %ecx
movl 0x10(%r12), %ebp
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
movslq (%rax,%rcx,4), %rb... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::MaxPooling1D::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void MaxPooling1D::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
cerr << "FIX IMPL6\n"; abort();
#if 0
const Tensor& x = *xs.front();
const unsigned x_rows = x.rows();
... | pushq %rax
movq 0xe1464(%rip), %rdi # 0x1b7fe8
leaq 0x6a1e6(%rip), %rsi # 0x140d71
callq 0xbf470
callq 0xbf230
nop
| /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::Softmax::forward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor&) const | void Softmax::forward_impl(const vector<const Tensor*>& xs, Tensor& fx) const {
if (xs[0]->d.cols() == 1) {
#if HAVE_CUDA
gpu::softmax(xs[0]->d.size(), xs[0]->v, fx.v);
#else
auto x = **xs[0];
*fx = x.unaryExpr(FSoftmaxNormalize(logsumexp(x)));
#endif
} else {
throw std::runtime_error("Softmax not y... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq (%rsi), %rax
movq %rdx, %rbx
movq (%rax), %rsi
cmpl $0x2, 0x1c(%rsi)
jb 0xd6bb4
cmpl $0x1, 0x4(%rsi)
jne 0xd6c09
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xd11ee
movq %r14, %rdi
callq 0xd9a13
vmovups (%r14), %xmm1
movq 0x10(%r14), %rax
leaq 0x40(%rsp), %r15
movq... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::PickNegLogSoftmax::forward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor&) const | void PickNegLogSoftmax::forward_impl(const vector<const Tensor*>& xs, Tensor& fx) const {
if (xs[0]->d.cols() == 1) {
logz = (float*)fxs->allocate(sizeof(float)*fx.d.batch_elems());
#if HAVE_CUDA
if(pval) {
gpu::pnlsoftmax(xs[0]->d.size(), *pval, xs[0]->v, fx.v, logz);
} else {
// TODO: It'd b... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq (%rsi), %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rax), %rax
cmpl $0x2, 0x1c(%rax)
jb 0xd6d52
cmpl $0x1, 0x4(%rax)
jne 0xd6e74
leaq 0xe1b2f(%rip), %rax # 0x1b8888
movl 0x20(%rbx), %esi
movq (%rax), %rdi
shlq $0x2, %rsi
ca... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::PickElement::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void PickElement::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
assert(i == 0);
#ifdef HAVE_CUDA
throw std::runtime_error("PickElement not yet implemented for CUD... | pushq %r14
pushq %rbx
subq $0x28, %rsp
testl %r8d, %r8d
jne 0xd76f3
movq 0x28(%rcx), %rax
leaq 0x8(%rsp), %r14
movq %rdi, %rbx
movq %r9, %rsi
movq %r14, %rdi
vmovss (%rax), %xmm0
vmovss %xmm0, 0x4(%rsp)
callq 0xd114a
movq 0x58(%rbx), %rax
movq %r14, %rdi
movl (%rax), %esi
callq 0xd9e6a
vmovss 0x4(%rsp), %xmm0
vaddss (%... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::MatrixMultiply::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void MatrixMultiply::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
assert(i < 2);
int max_b = max(xs[0]->d.bd, xs[... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %r9, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
cmpl $0x2, %r8d
jae 0xd7cd8
movq (%rsi), %rax
movq %rsi, %r15
movq (%rax), %rsi
movq 0x8(%rax), %rax
movl 0x20(%rsi), %ecx
movl 0x20(%rax), %eax
cmpl %eax, %ecx
cmoval %ecx, %eax
testl %r8d, %r8... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::AffineTransform::forward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor&) const | void AffineTransform::forward_impl(const vector<const Tensor*>& xs, Tensor& fx) const {
assert(xs.size() % 2 == 1);
if (xs.size() == 1) {
fx.v = xs[0]->v;
return;
} else {
#if HAVE_CUDA
for (unsigned i = 1; i < xs.size(); i += 2)
// fx = (acc_sclar)*fx + xs[0] * xs[1]
CUDAMatrixMultiply(*x... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
subq %rax, %rcx
testb $0x8, %cl
je 0xd823f
cmpq $0x8, %rcx
jne 0xd8088
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movq 0x28(%rax), %rax
movq %rax, 0x28(%rcx)
a... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::Negate::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void Negate::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
assert(i == 0);
#if HAVE_CUDA
gpu::vnegate_backward(fx.d.size(), dEdf.v, dEdxi.v);
#else
*dEd... | pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
testl %r8d, %r8d
jne 0xd8676
leaq 0x20(%rsp), %r14
movq %r9, %rbx
movq %rcx, %rsi
movq %r14, %rdi
callq 0xd11ee
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xd114a
movq %r15, %rdi
movq %r14, %rsi
callq 0xd99b0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
ret... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::BinaryLogLoss::backward_impl(std::vector<cnn::Tensor const*, std::allocator<cnn::Tensor const*>> const&, cnn::Tensor const&, cnn::Tensor const&, unsigned int, cnn::Tensor&) const | void BinaryLogLoss::backward_impl(const vector<const Tensor*>& xs,
const Tensor& fx,
const Tensor& dEdf,
unsigned i,
Tensor& dEdxi) const {
#ifdef HAVE_CUDA
throw std::runtime_error("BinaryLogLoss not yet implemented for CUDA");
#else
*dEdxi +=... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq (%rsi), %rdx
movq %rsi, %r15
movl %r8d, %eax
leaq 0x48(%rsp), %r12
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r14
movq %r12, %rdi
movq (%rdx,%rax,8), %rsi
callq 0xd11ee
pushq $0x1
popq %rax
movq (%r15), %rcx
subl %ebp, %eax
leaq 0x28(%rsp), %r... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
float cnn::logsumexp<Eigen::Map<Eigen::Matrix<float, -1, -1, 0, -1, -1>, 0, Eigen::Stride<0, 0>>>(Eigen::Map<Eigen::Matrix<float, -1, -1, 0, -1, -1>, 0, Eigen::Stride<0, 0>> const&, std::vector<unsigned int, std::allocator<unsigned int>> const&) | EIGEN_STRONG_INLINE real logsumexp(const T& x, const vector<unsigned>& denom) {
real m = x(denom[0],0);
for (auto i : denom) {
real r = x(i,0);
if (r > m) m = r;
}
real z = 0;
for (auto i : denom)
z += expf(x(i,0) - m);
return m + logf(z);
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %rax
movq %rsi, %r14
movq %rdi, %rbx
xorl %edx, %edx
movl (%rax), %esi
callq 0xd99cc
vmovss (%rax), %xmm0
movq (%r14), %r15
movq 0x8(%r14), %r12
vmovss %xmm0, (%rsp)
cmpq %r12, %r15
je 0xd9f93
movl (%r15), %esi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xd... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes.cc |
cnn::SelectRows::dim_forward(std::vector<cnn::Dim, std::allocator<cnn::Dim>> const&) const | Dim SelectRows::dim_forward(const vector<Dim>& xs) const {
if (xs.size() != 1 || xs[0].ndims() > 2) {
cerr << "Bad arguments in SelectRows: " << xs << endl;
throw std::invalid_argument("invalid arguments to SelectRows");
}
unsigned nrows = prows->size();
if (xs[0].ndims() == 1) return Dim({nrows});
re... | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq %rdx, %r14
subq %rax, %rcx
cmpq $0x24, %rcx
jne 0x130b3f
movl 0x1c(%rax), %ecx
cmpl $0x3, %ecx
jae 0x130b3f
movq 0x68(%rsi), %rsi
movq %rdi, %rbx
movq 0x8(%rsi), %rdx
subq (%rsi), %rdx
shrq $0x2, %rdx
cmpl $0x1, %ecx
jne 0x130b10
leaq 0x... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
cnn::Min::as_string(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 | string Min::as_string(const vector<string>& arg_names) const {
ostringstream s;
s << "min{" << arg_names[0] << ", " << arg_names[1] << "}";
return s.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp # imm = 0x180
leaq 0x8(%rsp), %r15
movq %rdi, %rbx
movq %rdx, %r14
movq %r15, %rdi
callq 0xbf5a0
leaq 0x5729d(%rip), %rsi # 0x187fcd
movq %r15, %rdi
callq 0xbf470
movq (%r14), %rsi
movq %rax, %rdi
callq 0xbf410
leaq 0x57c27(%rip), %rsi # 0x188971
mov... | /LeonCrashCode[P]LookAheadFeature/cnn/nodes-common.cc |
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.