name string | code string | asm string | file string |
|---|---|---|---|
OpenMD::AtomTypesSectionParser::parseLine(OpenMD::ForceField&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void AtomTypesSectionParser::parseLine(ForceField& ff,
const std::string& line, int lineNo) {
StringTokenizer tokenizer(line);
int nTokens = tokenizer.countTokens();
// in AtomTypeSection, a line at least contains 2 tokens
// atomTypeName and mass
if (nToken... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r14
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x74df6(%rip), %rsi # 0xe82da
leaq 0x74df4(%rip), %rdx # 0xe82df
leaq 0x8(%rsp), %rdi
callq 0x1eea8
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx... | /OpenMD[P]OpenMD/src/io/AtomTypesSectionParser.cpp |
OpenMD::SimpleTypeData<double>::~SimpleTypeData() | SimpleTypeData() : GenericData(), data_(ElemDataType()) {} | pushq %rbx
movq %rdi, %rbx
leaq 0xb5871(%rip), %rax # 0x129470
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x73c1a
movq (%rax), %rsi
incq %rsi
callq 0x12430
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x12430
| /OpenMD[P]OpenMD/src/utils/GenericData.hpp |
OpenMD::BendTypesSectionParser::parseLine(OpenMD::ForceField&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void BendTypesSectionParser::parseLine(ForceField& ff,
const std::string& line, int lineNo) {
StringTokenizer tokenizer(line);
BendTypeParser btParser;
BendType* bendType = NULL;
int nTokens = tokenizer.countTokens();
if (nTokens < 5) {
snprintf(painC... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp # imm = 0x110
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x7451f(%rip), %rsi # 0xe82da
leaq 0x7451d(%rip), %rdx # 0xe82df
leaq 0x8(%rsp), %rdi
callq 0x1eea8
... | /OpenMD[P]OpenMD/src/io/BendTypesSectionParser.cpp |
OpenMD::BondTypesSectionParser::parseLine(OpenMD::ForceField&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void BondTypesSectionParser::parseLine(ForceField& ff,
const std::string& line, int lineNo) {
StringTokenizer tokenizer(line);
BondTypeParser btParser;
BondType* bondType = NULL;
int nTokens = tokenizer.countTokens();
if (nTokens < 4) {
snprintf... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf0, %rsp
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x740cf(%rip), %rsi # 0xe82da
leaq 0x740cd(%rip), %rdx # 0xe82df
leaq 0x8(%rsp), %rdi
callq 0x1eea8
leaq 0x98(%rsp), %rdi
leaq... | /OpenMD[P]OpenMD/src/io/BondTypesSectionParser.cpp |
OpenMD::EAMAtomTypesSectionParser::parseFuncflFile(OpenMD::ForceField&, OpenMD::EAMAdapter, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void EAMAtomTypesSectionParser::parseFuncflFile(ForceField& ff, EAMAdapter ea,
const string& funcflFile,
int) {
ifstrstream* ppfStream = ff.openForceFieldFile(funcflFile);
const int bufferSize = 65535;
char... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x101b8, %rsp # imm = 0x101B8
movq %rdi, %r14
movq %rdx, 0x170(%rsp)
movq %rsi, %rdi
movq %rcx, %rsi
callq 0x5b93c
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x12400
movsbl %al, %ecx
leaq... | /OpenMD[P]OpenMD/src/io/EAMAtomTypesSectionParser.cpp |
OpenMD::FluctuatingChargeAtomTypesSectionParser::FluctuatingChargeAtomTypesSectionParser(OpenMD::ForceFieldOptions&) | FluctuatingChargeAtomTypesSectionParser::
FluctuatingChargeAtomTypesSectionParser(ForceFieldOptions& options) :
options_(options) {
setSectionName("FluctuatingChargeAtomTypes");
stringToEnumMap_["Hardness"] = fqtHardness;
stringToEnumMap_["EAM"] = fqtEAM;
stringToEnumMap_["EAMPoly"] =... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0xb1203(%rip), %rcx # 0x129a60
movq %rcx, (%rdi)
leaq 0x28(%rdi), %r14
leaq 0x30(%rdi), %rcx
movl $0x0, 0x30(%rdi)
movq ... | /OpenMD[P]OpenMD/src/io/FluctuatingChargeAtomTypesSectionParser.cpp |
OpenMD::FluctuatingChargeAtomTypesSectionParser::getFluctuatingTypeEnum(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | FluctuatingChargeAtomTypesSectionParser::FluctuatingTypeEnum
FluctuatingChargeAtomTypesSectionParser::getFluctuatingTypeEnum(
const std::string& str) {
std::map<std::string, FluctuatingTypeEnum>::iterator i;
i = stringToEnumMap_.find(str);
return i == stringToEnumMap_.end() ? fqtUnknown : i... | pushq %rbx
movq %rdi, %rbx
addq $0x28, %rdi
callq 0x799be
addq $0x30, %rbx
cmpq %rbx, %rax
je 0x790c9
movl 0x40(%rax), %eax
jmp 0x790ce
movl $0x4, %eax
popq %rbx
retq
| /OpenMD[P]OpenMD/src/io/FluctuatingChargeAtomTypesSectionParser.cpp |
OpenMD::GayBerneAtomTypesSectionParser::parseLine(OpenMD::ForceField&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void GayBerneAtomTypesSectionParser::parseLine(ForceField& ff,
const std::string& line,
int lineNo) {
StringTokenizer tokenizer(line);
int nTokens = tokenizer.countTokens();
// in GayBerneAtomTypesSection, a li... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x6bf03(%rip), %rsi # 0xe82da
leaq 0x6bf01(%rip), %rdx # 0xe82df
leaq 0x8(%rsp), %rdi
callq 0x1eea8
leaq 0x60(%rsp), %rdi
leaq... | /OpenMD[P]OpenMD/src/io/GayBerneAtomTypesSectionParser.cpp |
OpenMD::Globals::~Globals() | Globals::~Globals() {
Utils::deletePointers(moleculeStamps_);
Utils::deletePointers(components_);
Utils::deletePointers(zconstraints_);
Utils::deletePointers(restraints_);
delete flucQpars_;
delete rnemdPars_;
delete lightPars_;
delete minimizerPars_;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0xa4290(%rip), %rax # 0x129af0
movq %rax, (%rdi)
leaq 0x1568(%rdi), %r14
movq %r14, %rdi
callq 0x90954
movq 0x1520(%rbx), %r15
movq 0x1528(%rbx), %r12
cmpq %r12, %r15
je 0x85899
movq (%r15), %rdi
testq %rdi, %rdi
je 0x85893
movq (%rdi), %ra... | /OpenMD[P]OpenMD/src/io/Globals.cpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::... | inline OrParamConstraint<Cons1T, Cons2T> operator||(
const ParamConstraintFacade<Cons1T>& cons1,
const ParamConstraintFacade<Cons2T>& cons2) {
return OrParamConstraint<Cons1T, Cons2T>(
*static_cast<const Cons1T*>(&cons1),
*static_cast<const Cons2T*>(&cons2));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x688, %rsp # imm = 0x688
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x950fc
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x185b0
leaq 0x28(%rsp), %rdi
leaq 0x3... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::... | inline OrParamConstraint<Cons1T, Cons2T> operator||(
const ParamConstraintFacade<Cons1T>& cons1,
const ParamConstraintFacade<Cons2T>& cons2) {
return OrParamConstraint<Cons1T, Cons2T>(
*static_cast<const Cons1T*>(&cons1),
*static_cast<const Cons2T*>(&cons2));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x508, %rsp # imm = 0x508
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x943ac
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x185b0
leaq 0x28(%rsp), %rdi
leaq 0x3... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::... | inline OrParamConstraint<Cons1T, Cons2T> operator||(
const ParamConstraintFacade<Cons1T>& cons1,
const ParamConstraintFacade<Cons2T>& cons2) {
return OrParamConstraint<Cons1T, Cons2T>(
*static_cast<const Cons1T*>(&cons1),
*static_cast<const Cons2T*>(&cons2));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x4a8, %rsp # imm = 0x4A8
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x94058
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x185b0
leaq 0x28(%rsp), %rdi
leaq 0x3... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint,... | inline OrParamConstraint<Cons1T, Cons2T> operator||(
const ParamConstraintFacade<Cons1T>& cons1,
const ParamConstraintFacade<Cons2T>& cons2) {
return OrParamConstraint<Cons1T, Cons2T>(
*static_cast<const Cons1T*>(&cons1),
*static_cast<const Cons2T*>(&cons2));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x448, %rsp # imm = 0x448
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x93d04
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x185b0
leaq 0x28(%rsp), %rdi
leaq 0x3... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCa... | inline OrParamConstraint<Cons1T, Cons2T> operator||(
const ParamConstraintFacade<Cons1T>& cons1,
const ParamConstraintFacade<Cons2T>& cons2) {
return OrParamConstraint<Cons1T, Cons2T>(
*static_cast<const Cons1T*>(&cons1),
*static_cast<const Cons2T*>(&cons2));
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x92c60
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x185b0
leaq 0x28(%rsp), %rdi
leaq 0x3... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbx
movq %rdi, %rbx
movq 0x620(%rdi), %rdi
leaq 0x630(%rbx), %rax
cmpq %rax, %rdi
je 0x918d8
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq 0x600(%rbx), %rdi
leaq 0x610(%rbx), %rax
cmpq %rax, %rdi
je 0x918f6
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq 0x5e0(%rbx), %rdi
leaq 0x5f0(%rbx), %rax
cmpq %rax, %rdi
j... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbx
movq %rdi, %rbx
movq 0x4a0(%rdi), %rdi
leaq 0x4b0(%rbx), %rax
cmpq %rax, %rdi
je 0x91b10
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq 0x480(%rbx), %rdi
leaq 0x490(%rbx), %rax
cmpq %rax, %rdi
je 0x91b2e
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq 0x460(%rbx), %rdi
leaq 0x470(%rbx), %rax
cmpq %rax, %rdi
j... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseCo... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbx
movq %rdi, %rbx
movq 0x3e0(%rdi), %rdi
leaq 0x3f0(%rbx), %rax
cmpq %rax, %rdi
je 0x91c2c
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq 0x3c0(%rbx), %rdi
leaq 0x3d0(%rbx), %rax
cmpq %rax, %rdi
je 0x91c4a
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq 0x3a0(%rbx), %rdi
leaq 0x3b0(%rbx), %rax
cmpq %rax, %rdi
j... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIg... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbx
movq %rdi, %rbx
movq 0x380(%rdi), %rdi
leaq 0x390(%rbx), %rax
cmpq %rax, %rdi
je 0x91ce4
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq 0x360(%rbx), %rdi
leaq 0x370(%rbx), %rax
cmpq %rax, %rdi
je 0x91d02
movq (%rax), %rsi
incq %rsi
callq 0x12430
leaq 0x20(%rbx), %rdi
callq 0x91d26
movq (%rbx), %rdi
addq $0x1... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstrai... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbx
movq %rdi, %rbx
movq 0x2c0(%rdi), %rdi
leaq 0x2d0(%rbx), %rax
cmpq %rax, %rdi
je 0x91e00
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq 0x2a0(%rbx), %rdi
leaq 0x2b0(%rbx), %rax
cmpq %rax, %rdi
je 0x91e1e
movq (%rax), %rsi
incq %rsi
callq 0x12430
leaq 0x20(%rbx), %rdi
callq 0x91e42
movq (%rbx), %rdi
addq $0x1... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCa... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbx
movq %rdi, %rbx
movq 0x260(%rdi), %rdi
leaq 0x270(%rbx), %rax
cmpq %rax, %rdi
je 0x91e64
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq 0x240(%rbx), %rdi
leaq 0x250(%rbx), %rax
cmpq %rax, %rdi
je 0x91e82
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq 0x220(%rbx), %rdi
leaq 0x230(%rbx), %rax
cmpq %rax, %rdi
j... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
bool OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseCon... | bool operator()(DataType data) const {
return cons1_(data) || cons2_(data);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x185b0
movq %r15, %rdi
movq %r12, %rsi... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
Parameter<unsigned long>::getParamType[abi:cxx11]() | virtual std::string getParamType() {
return ParameterTraits<ParamType>::getParamType();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %rsp, %r14
movq $0x11, (%r14)
movq %r14, %rsi
xorl %edx, %edx
callq 0x12880
movq %rax, (%rbx)
movq (%r14), %rcx
movq %rcx, 0x10(%rbx)
movups 0x5ab6c(%rip), %xmm0 # 0xecccb
movups %xmm0, (%rax)
movb $0x74, 0x10(%rax)
movq %r... | /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
Parameter<std::pair<int, int>>::setData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | virtual bool setData(std::string sval) {
return internalSetData<std::string>(sval);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x185b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9237e
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r15, %... | /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
Parameter<std::pair<int, int>>::setData(std::vector<double, std::allocator<double>>) | virtual bool setData(std::vector<RealType> pval) {
return internalSetData<std::vector<RealType>>(pval);
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x4c696
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9255a
movl %eax, %ebx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x922fe
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x12430
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
m... | /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
ParameterTraits<std::pair<int, int>>::convert(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::pair<int, int>&) | static bool convert(std::string v, RepType& r) {
OpenMD::StringTokenizer tokenizer(v, " ;,\t\n\r");
if (tokenizer.countTokens() == 2) {
int atom1 = tokenizer.nextTokenAsInt();
int atom2 = tokenizer.nextTokenAsInt();
r = std::make_pair(atom1, atom2);
return true;
} else {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5a899(%rip), %rsi # 0xeccdd
leaq 0x5a898(%rip), %rdx # 0xecce3
movq %rsp, %rdi
callq 0x1eea8
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
callq 0xd4b28
movq (... | /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
Parameter<std::vector<double, std::allocator<double>>>::setData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | virtual bool setData(std::string sval) {
return internalSetData<std::string>(sval);
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x185b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9272a
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r15, %... | /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
Parameter<std::vector<double, std::allocator<double>>>::getParamType[abi:cxx11]() | virtual std::string getParamType() {
return ParameterTraits<ParamType>::getParamType();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq %rsp, %r14
movq $0x15, (%r14)
movq %r14, %rsi
xorl %edx, %edx
callq 0x12880
movq %rax, (%rbx)
movq (%r14), %rcx
movq %rcx, 0x10(%rbx)
movabsq $0x3e657079546c6165, %rdx # imm = 0x3E657079546C6165
movq %rdx, 0xd(%rax)
movups 0x5... | /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
bool Parameter<std::vector<double, std::allocator<double>>>::internalSetData<std::vector<double, std::allocator<double>>>(std::vector<double, std::allocator<double>>) | bool internalSetData(T data) {
ParamType tmp {};
bool result = ValueType::convert(data, tmp);
if (result) {
empty_ = false;
data_ = tmp;
}
return result;
} | pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x4c696
movq %rsp, %rdi
leaq 0x18(%rsp), %rsi
callq 0x4d2d2
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x92b02
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x12430
movb $0x0, 0x2a(%rbx)
ad... | /OpenMD[P]OpenMD/src/utils/ParameterManager.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::Equ... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x185b0
leaq 0x20(%rbx), %r14
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x727fa
leaq 0x1e0(%rbx), %r12
leaq ... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCa... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x92c60
leaq 0x240(%rbx), %r15
... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenM... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x185b0
leaq 0x20(%rbx), %r14
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x93308
leaq 0x300(%rbx), %r12
leaq ... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseCo... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x185b0
leaq 0x20(%rbx), %r14
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x939b0
leaq 0x3c0(%rbx), %r12
leaq ... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint,... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x185b0
leaq 0x20(%rbx), %r14
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x93d04
leaq 0x420(%rbx), %r12
leaq ... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x94058
leaq 0x480(%rbx), %r15
... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x185b0
leaq 0x20(%rbx), %r14
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x94058
leaq 0x480(%rbx), %r12
leaq ... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x94700
leaq 0x540(%rbx), %r15
... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
callq 0x185b0
leaq 0x20(%rbx), %r14
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x94a54
leaq 0x5a0(%rbx), %r12
leaq ... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::... | OrParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << cons1_.getConstraintDescription() << " or "
<< cons2_.getConstraintDescription() << "";
this->description_ = iss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
movq %r14, %rdi
callq 0x94da8
leaq 0x600(%rbx), %r15
... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
bool OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<Ope... | bool operator()(DataType data) const {
return cons1_(data) || cons2_(data);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x185b0
movq %r15, %rdi
movq %r12, %rsi... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
bool OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<Ope... | bool operator()(DataType data) const {
return cons1_(data) || cons2_(data);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x185b0
movq %r15, %rdi
movq %r12, %rsi... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
bool OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<Ope... | bool operator()(DataType data) const {
return cons1_(data) || cons2_(data);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x185b0
movq %r15, %rdi
movq %r12, %rsi... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
bool OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstr... | bool operator()(DataType data) const {
return cons1_(data) || cons2_(data);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x185b0
movq %r15, %rdi
movq %r12, %rsi... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
bool OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreC... | bool operator()(DataType data) const {
return cons1_(data) || cons2_(data);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x185b0
movq %r15, %rdi
movq %r12, %rsi... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
bool OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, ... | bool operator()(DataType data) const {
return cons1_(data) || cons2_(data);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x185b0
movq %r15, %rdi
movq %r12, %rsi... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
bool OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::OrParamConstraint<OpenMD::EqualIgnoreCaseConstraint, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgnoreCaseConstraint>, OpenMD::EqualIgn... | bool operator()(DataType data) const {
return cons1_(data) || cons2_(data);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rdi), %r15
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x185b0
movq %r15, %rdi
movq %r12, %rsi... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::LennardJonesAtomTypesSectionParser::parseLine(OpenMD::ForceField&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void LennardJonesAtomTypesSectionParser::parseLine(ForceField& ff,
const std::string& line,
int lineNo) {
StringTokenizer tokenizer(line);
int nTokens = tokenizer.countTokens();
// in LennardJonesAtomT... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x51723(%rip), %rsi # 0xe82da
leaq 0x51721(%rip), %rdx # 0xe82df
leaq 0x10(%rsp), %rdi
callq 0x1eea8
leaq 0x58(%rsp), %rdi
lea... | /OpenMD[P]OpenMD/src/io/LennardJonesAtomTypesSectionParser.cpp |
OpenMD::MultipoleAtomTypesSectionParser::MultipoleAtomTypesSectionParser(OpenMD::ForceFieldOptions&) | MultipoleAtomTypesSectionParser::MultipoleAtomTypesSectionParser(
ForceFieldOptions&) {
setSectionName("MultipoleAtomTypes");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x92ec3(%rip), %rax # 0x129d28
movq %rax, (%rdi)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x560e7(%rip), %rsi # 0xecf60
leaq 0x560f2(%... | /OpenMD[P]OpenMD/src/io/MultipoleAtomTypesSectionParser.cpp |
OpenMD::MultipoleAtomTypesSectionParser::parseLine(OpenMD::ForceField&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void MultipoleAtomTypesSectionParser::parseLine(ForceField& ff,
const std::string& line,
int lineNo) {
StringTokenizer tokenizer(line);
int nTokens = tokenizer.countTokens();
// name multipole_type theta phi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x320, %rsp # imm = 0x320
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r14
leaq 0xc0(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x513af(%rip), %rsi # 0xe82da
leaq 0x513ad(%rip), %rdx # 0xe82df
leaq 0xb0(%rsp), %rdi
callq 0x1eea8
leaq 0xf8(%rsp)... | /OpenMD[P]OpenMD/src/io/MultipoleAtomTypesSectionParser.cpp |
OpenMD::MultipoleAtomTypesSectionParser::parseQuadrupole(OpenMD::StringTokenizer&, OpenMD::Vector3<double>&, int) | void MultipoleAtomTypesSectionParser::parseQuadrupole(
StringTokenizer& tokenizer, Vector3d& quadrupoleMoments, int lineNo) {
int nTokens = tokenizer.countTokens();
if (nTokens >= 3) {
quadrupoleMoments[0] = tokenizer.nextTokenAsDouble();
quadrupoleMoments[1] = tokenizer.nextTokenAsDouble();
... | pushq %rbp
pushq %r14
pushq %rbx
movl %ecx, %ebp
movq %rdx, %rbx
movq %rsi, %r14
movq %rsi, %rdi
callq 0xd4ca4
cmpl $0x3, %eax
jl 0x97914
movq %r14, %rdi
callq 0xd5132
movsd %xmm0, (%rbx)
movq %r14, %rdi
callq 0xd5132
movsd %xmm0, 0x8(%rbx)
movq %r14, %rdi
callq 0xd5132
movsd %xmm0, 0x10(%rbx)
popq %rbx
popq %r14
popq ... | /OpenMD[P]OpenMD/src/io/MultipoleAtomTypesSectionParser.cpp |
OpenMD::NonBondedInteractionsSectionParser::NonBondedInteractionsSectionParser(OpenMD::ForceFieldOptions&) | NonBondedInteractionsSectionParser::NonBondedInteractionsSectionParser(
ForceFieldOptions& options) :
options_(options) {
setSectionName("NonBondedInteractions");
stringToEnumMap_["MAW"] = MAW;
stringToEnumMap_["ShiftedMorse"] = ShiftedMorse;
stringToEnumMap_["LennardJo... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
movq %r12, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x923cb(%rip), %rcx # 0x129d70
movq %rcx, (%rdi)
leaq 0x28(%rdi), %r14
leaq 0x30(%rdi), %rcx
movl $0x0, 0x30(%rdi)
movq ... | /OpenMD[P]OpenMD/src/io/NonBondedInteractionsSectionParser.cpp |
OpenMD::NonBondedInteractionsSectionParser::parseLine(OpenMD::ForceField&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void NonBondedInteractionsSectionParser::parseLine(ForceField& ff,
const std::string& line,
int lineNo) {
StringTokenizer tokenizer(line);
int nTokens = tokenizer.countTokens();
if (nTokens < 3) {
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x158, %rsp # imm = 0x158
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, 0xf8(%rsp)
movq %rdi, %r14
leaq 0xc0(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x50552(%rip), %rsi # 0xe82da
leaq 0x50550(%rip), %rdx # 0xe82df
leaq 0xb0(%rsp), %... | /OpenMD[P]OpenMD/src/io/NonBondedInteractionsSectionParser.cpp |
OpenMD::MAWInteractionType::MAWInteractionType(double, double, double, double, double) | MAWInteractionType(RealType myD0, RealType myBeta0, RealType myR0,
RealType myCa1, RealType myCb1) {
D_e = myD0;
beta = myBeta0;
r_e = myR0;
ca1 = myCa1;
cb1 = myCb1;
setMAW();
} | pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm4, 0x20(%rsp)
movsd %xmm3, 0x18(%rsp)
movsd %xmm2, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, (%rsp)
movq %rdi, %rbx
callq 0xcd1dc
leaq 0x912c3(%rip), %rax # 0x129db8
movq %rax, (%rbx)
movsd (%rsp), %xmm0
movsd %xmm0, 0x60(%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0... | /OpenMD[P]OpenMD/src/types/MAWInteractionType.hpp |
OpenMD::LennardJonesInteractionType::LennardJonesInteractionType(double, double) | LennardJonesInteractionType(RealType mySigma, RealType myEpsilon) {
setLennardJones();
sigma = mySigma;
epsilon = myEpsilon;
} | pushq %r14
pushq %rbx
subq $0x18, %rsp
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0xcd1dc
leaq 0x91238(%rip), %rax # 0x129e58
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0xcd2d8
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x60(%rbx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x68(%rbx)
addq $0x18, %rsp
popq... | /OpenMD[P]OpenMD/src/types/LennardJonesInteractionType.hpp |
OpenMD::BuckinghamInteractionType::BuckinghamInteractionType(double, double, double, OpenMD::BuckinghamType) | BuckinghamInteractionType(RealType myA, RealType myB, RealType myC,
BuckinghamType myType) {
A = myA;
B = myB;
C = myC;
interactionType = myType;
setBuckingham();
} | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0xcd1dc
leaq 0x910a7(%rip), %rax # 0x129f00
movq %rax, (%rbx)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x60(%rbx)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x68(%rbx)
... | /OpenMD[P]OpenMD/src/types/BuckinghamInteractionType.hpp |
OpenMD::EAMInteractionType::EAMInteractionType(double, double, double, double, double) | EAMInteractionType(RealType re, RealType alpha, RealType A, RealType Ci,
RealType Cj) {
interactionType_ = eamitOxides;
setEAMOxides();
re_ = re;
alpha_ = alpha;
A_ = A;
Ci_ = Ci;
Cj_ = Cj;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movsd %xmm4, 0x28(%rsp)
movsd %xmm3, 0x20(%rsp)
movsd %xmm2, 0x18(%rsp)
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %rbx
callq 0xcd1dc
leaq 0x90f26(%rip), %rax # 0x129f38
movq %rax, (%rbx)
leaq 0x78(%rbx), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x78(%rb... | /OpenMD[P]OpenMD/src/types/EAMInteractionType.hpp |
OpenMD::MAWInteractionType::~MAWInteractionType() | MAWInteractionType(RealType myD0, RealType myBeta0, RealType myR0,
RealType myCa1, RealType myCb1) {
D_e = myD0;
beta = myBeta0;
r_e = myR0;
ca1 = myCa1;
cb1 = myCb1;
setMAW();
} | pushq %rbx
movq %rdi, %rbx
leaq 0x90a97(%rip), %rax # 0x129e00
movq %rax, (%rdi)
leaq 0x8f00d(%rip), %rax # 0x128380
movq %rax, 0x28(%rdi)
addq $0x30, %rdi
callq 0x23d9e
movl $0x88, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x12430
| /OpenMD[P]OpenMD/src/types/MAWInteractionType.hpp |
OpenMD::EAMInteractionType::~EAMInteractionType() | EAMInteractionType(RealType re, RealType alpha, RealType beta, RealType A,
RealType B, RealType kappa, RealType lambda) {
interactionType_ = eamitZhou;
setEAMZhou();
re_ = re;
alpha_ = alpha;
beta_ = beta;
A_ = A;
B_ = B;
kappa_ = ... | pushq %rbx
movq %rdi, %rbx
leaq 0x90a61(%rip), %rax # 0x129f38
movq %rax, (%rdi)
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0x994f2
movq 0x88(%rbx), %rsi
subq %rdi, %rsi
callq 0x12430
leaq 0x90907(%rip), %rax # 0x129e00
movq %rax, (%rbx)
leaq 0x8ee7d(%rip), %rax # 0x128380
movq %rax, 0x28(%rbx)
addq $0x30, %... | /OpenMD[P]OpenMD/src/types/EAMInteractionType.hpp |
OpenMD::EAMInteractionType::~EAMInteractionType() | EAMInteractionType(RealType re, RealType alpha, RealType beta, RealType A,
RealType B, RealType kappa, RealType lambda) {
interactionType_ = eamitZhou;
setEAMZhou();
re_ = re;
alpha_ = alpha;
beta_ = beta;
A_ = A;
B_ = B;
kappa_ = ... | pushq %rbx
movq %rdi, %rbx
leaq 0x90a19(%rip), %rax # 0x129f38
movq %rax, (%rdi)
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0x9953a
movq 0x88(%rbx), %rsi
subq %rdi, %rsi
callq 0x12430
leaq 0x908bf(%rip), %rax # 0x129e00
movq %rax, (%rbx)
leaq 0x8ee35(%rip), %rax # 0x128380
movq %rax, 0x28(%rbx)
leaq 0x30(%rb... | /OpenMD[P]OpenMD/src/types/EAMInteractionType.hpp |
OpenMD::InversePowerSeriesInteractionType::~InversePowerSeriesInteractionType() | InversePowerSeriesInteractionType(
std::vector<std::pair<int, RealType>> series) {
powers.clear();
coefficients.clear();
std::vector<std::pair<int, RealType>>::iterator it;
for (it = series.begin(); it != series.end(); ++it) {
powers.push_back((*it).first);
coefficients... | pushq %rbx
movq %rdi, %rbx
leaq 0x909ff(%rip), %rax # 0x129f70
movq %rax, (%rdi)
movq 0x78(%rdi), %rdi
testq %rdi, %rdi
je 0x9958c
movq 0x88(%rbx), %rsi
subq %rdi, %rsi
callq 0x12430
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x995a1
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x12430
leaq 0x90858(%rip), %rax # ... | /OpenMD[P]OpenMD/src/types/InversePowerSeriesInteractionType.hpp |
OpenMD::OptionSectionParser::OptionSectionParser(OpenMD::ForceFieldOptions&) | OptionSectionParser::OptionSectionParser(ForceFieldOptions& options) :
options_(options) {
setSectionName("Options");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x904a7(%rip), %rax # 0x129fa8
movq %rax, (%rdi)
movq %rsi, 0x28(%rdi)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x53b4d(%rip), %rsi # ... | /OpenMD[P]OpenMD/src/io/OptionSectionParser.cpp |
OpenMD::ForceFieldOptions::setData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool setData(const std::string& keyword, const std::string& value) {
bool result(false);
ParamMap::iterator i = parameters_.find(keyword);
if (i != parameters_.end()) {
if (isInteger(value)) {
int ival = lexi_cast<int>(value);
result = i->second->setData(ival);
} ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
addq $0x680, %rdi # imm = 0x680
callq 0x4d63c
addq $0x688, %r12 # imm = 0x688
cmpq %r12, %rax
je 0x99dac
movq %rax, %r15
movq %rbx, %rdi
callq 0xd5982
movq %rbx, %rdi
... | /OpenMD[P]OpenMD/src/io/ForceFieldOptions.hpp |
bool OpenMD::isType<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | bool isType(const std::string& str) {
T result;
std::istringstream iss(str);
bool ret = true;
if (!(iss >> result)) { ret = false; }
return ret;
} | pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
movl $0x8, %edx
callq 0x127c0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x12280
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
sete %bl
movq 0x8f61a(%rip), %rsi # 0x12bfa0
leaq 0x10(%rs... | /OpenMD[P]OpenMD/src/utils/StringUtils.hpp |
OpenMD::NotEmptyConstraint::NotEmptyConstraint() | NotEmptyConstraint() { description_ = "nonempty"; } | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x50c3e(%rip), %rcx # 0xed72c
movl $0x8, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x126f0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::PositiveConstraint::PositiveConstraint() | PositiveConstraint() { this->description_ = "positive"; } | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x50ba3(%rip), %rcx # 0xed73d
movl $0x8, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x126f0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::NegativeConstraint::NegativeConstraint() | NegativeConstraint() { this->description_ = "negative"; } | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x50b03(%rip), %rcx # 0xed749
movl $0x8, %r8d
xorl %esi, %esi
xorl %edx, %edx
callq 0x126f0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::EqualIgnoreCaseConstraint::EqualIgnoreCaseConstraint(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | EqualIgnoreCaseConstraint(std::string rhs) :
rhs_(OpenMD::toUpperCopy(rhs)) {
std::stringstream iss;
iss << "equal to (case insensitive) " << rhs;
this->description_ = iss.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b0, %rsp # imm = 0x1B0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r13
movq %r13, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x12930
movq %r15, %rdi
movq %r14, %rsi
m... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::PolarizableAtomTypesSectionParser::PolarizableAtomTypesSectionParser(OpenMD::ForceFieldOptions&) | PolarizableAtomTypesSectionParser::PolarizableAtomTypesSectionParser(
ForceFieldOptions&) {
setSectionName("PolarizableAtomTypes");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x8d147(%rip), %rax # 0x129ff0
movq %rax, (%rdi)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x508b7(%rip), %rsi # 0xed774
leaq 0x508c4(%... | /OpenMD[P]OpenMD/src/io/PolarizableAtomTypesSectionParser.cpp |
OpenMD::SectionParserManager::~SectionParserManager() | SectionParserManager::~SectionParserManager() {
SectionParserManager::iterator i;
for (i = sectionParsers_.begin(); i != sectionParsers_.end(); ++i) {
delete (i->sectionParser);
}
sectionParsers_.clear();
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
addq $0x8, %rbx
cmpq %rbx, %r14
je 0x9d498
movq 0x18(%r14), %rdi
testq %rdi, %rdi
je 0x9d493
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r14), %r14
jmp 0x9d47f
movq %rbx, %rdi
callq 0x9df70
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x9d4bd
movq (%rdi), %r14... | /OpenMD[P]OpenMD/src/io/SectionParserManager.cpp |
OpenMD::SectionParserManager::parse(std::istream&, OpenMD::ForceField&) | void SectionParserManager::parse(std::istream& input, ForceField& ff) {
// reset active flags
SectionParserManager::iterator i;
for (i = sectionParsers_.begin(); i != sectionParsers_.end(); ++i) {
i->isActive = false;
}
const int bufferSize = 65535;
char buffer[bufferSize];
int lineNo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10168, %rsp # imm = 0x10168
movq %rdx, 0xb0(%rsp)
movq %rsi, %r14
movq 0x8(%rdi), %rax
addq $0x8, %rdi
cmpq %rdi, %rax
je 0x9d4f8
movb $0x0, 0x38(%rax)
movq (%rax), %rax
jmp 0x9d4ea
movq %rdi, 0x48(%rsp)
xorps %xmm0, %xmm0
leaq 0x110(%rs... | /OpenMD[P]OpenMD/src/io/SectionParserManager.cpp |
OpenMD::SectionParserManager::findSectionParser(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | SectionParserManager::iterator SectionParserManager::findSectionParser(
const std::string& sectionName) {
SectionParserManager::iterator i;
for (i = sectionParsers_.begin(); i != sectionParsers_.end(); ++i) {
if (i->sectionParser->getSectionName() == sectionName) { break; }
}
return i;
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x8(%rdi), %rbx
addq $0x8, %r14
cmpq %r14, %rbx
je 0x9dd29
movq (%rsi), %r15
movq 0x8(%rsi), %r12
movq 0x18(%rbx), %rax
cmpq %r12, 0x10(%rax)
jne 0x9dd21
testq %r12, %r12
je 0x9dd29
movq 0x8(%rax), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x1... | /OpenMD[P]OpenMD/src/io/SectionParserManager.cpp |
OpenMD::ShapeAtomTypesSectionParser::ShapeAtomTypesSectionParser(OpenMD::ForceFieldOptions&) | ShapeAtomTypesSectionParser::ShapeAtomTypesSectionParser(ForceFieldOptions&) {
setSectionName("ShapeAtomTypes");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x8b8ef(%rip), %rax # 0x12a080
movq %rax, (%rdi)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4f2c1(%rip), %rsi # 0xeda66
leaq 0x4f2c8(%... | /OpenMD[P]OpenMD/src/io/ShapeAtomTypesSectionParser.cpp |
OpenMD::ShapeAtomTypesSectionParser::parseShapeFile(OpenMD::ForceField&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, OpenMD::AtomType*) | void ShapeAtomTypesSectionParser::parseShapeFile(ForceField&,
std::string& shapeFileName,
AtomType* at) {
const int bufferSize = 65535;
char buffer[bufferSize];
std::string token;
Mat3x3d momInert;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10468, %rsp # imm = 0x10468
movq %rcx, 0xd0(%rsp)
movq %rdx, 0x48(%rsp)
leaq 0xe8(%rsp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb $0x0, (%rcx)
movq %rax, 0x40(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp... | /OpenMD[P]OpenMD/src/io/ShapeAtomTypesSectionParser.cpp |
OpenMD::SimpleTypeData<OpenMD::ShapeAtomType*>::~SimpleTypeData() | SimpleTypeData() : GenericData(), data_(ElemDataType()) {} | pushq %rbx
movq %rdi, %rbx
leaq 0x89549(%rip), %rax # 0x129470
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
leaq 0x18(%rbx), %rax
cmpq %rax, %rdi
je 0x9ff42
movq (%rax), %rsi
incq %rsi
callq 0x12430
movl $0x30, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x12430
| /OpenMD[P]OpenMD/src/utils/GenericData.hpp |
OpenMD::StickyAtomTypesSectionParser::parseLine(OpenMD::ForceField&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void StickyAtomTypesSectionParser::parseLine(ForceField& ff,
const string& line, int lineNo) {
StringTokenizer tokenizer(line);
int nTokens = tokenizer.countTokens();
RealType dus = options_.getDistanceUnitScaling();
RealType eus = options_.getEnergyUnitSc... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x481f7(%rip), %rsi # 0xe82da
leaq 0x481f5(%rip), %rdx # 0xe82df
movq %rsp, %rdi
callq 0x1eea8
leaq 0x68(%rsp), %rdi
movq %rsp... | /OpenMD[P]OpenMD/src/io/StickyAtomTypesSectionParser.cpp |
OpenMD::StickyPowerAtomTypesSectionParser::StickyPowerAtomTypesSectionParser(OpenMD::ForceFieldOptions&) | StickyPowerAtomTypesSectionParser::StickyPowerAtomTypesSectionParser(
ForceFieldOptions& options) :
options_(options) {
setSectionName("StickyPowerAtomTypes");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x89ddf(%rip), %rax # 0x12a198
movq %rax, (%rdi)
movq %rsi, 0x28(%rdi)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4da8c(%rip), %rsi # ... | /OpenMD[P]OpenMD/src/io/StickyPowerAtomTypesSectionParser.cpp |
OpenMD::TorsionTypesSectionParser::TorsionTypesSectionParser(OpenMD::ForceFieldOptions&) | TorsionTypesSectionParser::TorsionTypesSectionParser(
ForceFieldOptions& options) :
options_(options) {
setSectionName("TorsionTypes");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x89a83(%rip), %rax # 0x12a1e0
movq %rax, (%rdi)
movq %rsi, 0x28(%rdi)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4d7bd(%rip), %rsi # ... | /OpenMD[P]OpenMD/src/io/TorsionTypesSectionParser.cpp |
OpenMD::TorsionTypesSectionParser::parseLine(OpenMD::ForceField&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int) | void TorsionTypesSectionParser::parseLine(ForceField& ff,
const std::string& line,
int lineNo) {
StringTokenizer tokenizer(line);
TorsionTypeParser ttParser;
TorsionType* torsionType = NULL;
std::string torsionConve... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x150, %rsp # imm = 0x150
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x47ab3(%rip), %rsi # 0xe82da
leaq 0x47ab1(%rip), %rdx # 0xe82df
leaq 0x40(%rsp), %rdi
callq 0x1eea8... | /OpenMD[P]OpenMD/src/io/TorsionTypesSectionParser.cpp |
OpenMD::UFFAtomTypesSectionParser::UFFAtomTypesSectionParser(OpenMD::ForceFieldOptions&) | UFFAtomTypesSectionParser::UFFAtomTypesSectionParser(
ForceFieldOptions& options) :
options_(options) {
setSectionName("UFFAtomTypes");
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x8956b(%rip), %rax # 0x12a228
movq %rax, (%rdi)
movq %rsi, 0x28(%rdi)
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4d30f(%rip), %rsi # ... | /OpenMD[P]OpenMD/src/io/UFFAtomTypesSectionParser.cpp |
OpenMD::MinimizerParameters::MinimizerParameters() | MinimizerParameters::MinimizerParameters() {
DefineOptionalParameterWithDefaultValue(UseMinimizer, "useMinimizer",
false);
DefineOptionalParameterWithDefaultValue(Method, "method", "SD");
DefineOptionalParameterWithDefaultValue(MaxIterations, "maxIterations",
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xf8, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rcx
xorl %eax, %eax
movl %eax, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rcx, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movl %eax, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %r... | /OpenMD[P]OpenMD/src/optimization/MinimizerParameters.cpp |
OpenMD::AndParamConstraint<OpenMD::GreaterThanOrEqualTo<int>, OpenMD::LessThanOrEqualToConstraint<int>> OpenMD::operator&&<OpenMD::GreaterThanOrEqualTo<int>, OpenMD::LessThanOrEqualToConstraint<int>>(OpenMD::ParamConstraintFacade<OpenMD::GreaterThanOrEqualTo<int>> const&, OpenMD::ParamConstraintFacade<OpenMD::LessThanO... | inline AndParamConstraint<Cons1T, Cons2T> operator&&(
const ParamConstraintFacade<Cons1T>& cons1,
const ParamConstraintFacade<Cons2T>& cons2) {
return AndParamConstraint<Cons1T, Cons2T>(
*static_cast<const Cons1T*>(&cons1),
*static_cast<const Cons2T*>(&cons2));
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x185b0
movl 0x20(%r15), %eax
movl %eax, 0x20(%r12)
leaq... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::GreaterThanOrEqualTo<int>::GreaterThanOrEqualTo(int) | GreaterThanOrEqualTo(T rhs) : rhs_(rhs) {
std::stringstream iss;
iss << "greater than or equal to" << rhs;
this->description_ = iss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl %esi, 0x20(%rdi)
leaq 0x20(%rsp), %rdi
callq 0x122d0
leaq 0x30(%rsp), %r14
leaq 0x4acf8(%rip), %rsi # 0xee160... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::AndParamConstraint<OpenMD::GreaterThanOrEqualTo<int>, OpenMD::LessThanOrEqualToConstraint<int>>::AndParamConstraint(OpenMD::GreaterThanOrEqualTo<int>, OpenMD::LessThanOrEqualToConstraint<int>) | AndParamConstraint(Cons1T cons1, Cons2T cons2) :
cons1_(cons1), cons2_(cons2) {
std::stringstream iss;
iss << "(" << cons1_.getConstraintDescription() << " and "
<< cons2_.getConstraintDescription() << ")";
this->description_ = iss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1e8, %rsp # imm = 0x1E8
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
leaq 0x30(%rdi), %rax
movq %rax, 0x8... | /OpenMD[P]OpenMD/src/io/ParamConstraint.hpp |
OpenMD::Perturbations::LightParameters::~LightParameters() | virtual ~LightParameters() = default; | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x85f81(%rip), %rax # 0x12a2e0
movq %rax, (%rdi)
leaq 0x84f27(%rip), %rax # 0x129290
movq %rax, 0x1d0(%rdi)
movq 0x200(%rdi), %rdi
leaq 0x210(%rbx), %rax
cmpq %rax, %rdi
je 0xa438e
movq (%rax), %rsi
incq %rsi
callq 0x12430
leaq 0x84e8b(%rip), %r14 # 0x12... | /OpenMD[P]OpenMD/src/perturbations/LightParameters.hpp |
OpenMD::Atom::getI() | Mat3x3d Atom::getI() { return Mat3x3d::identity(); } | movq %rdi, %rax
xorps %xmm0, %xmm0
leaq -0x40(%rsp), %rcx
movaps %xmm0, 0x28(%rcx)
movaps %xmm0, 0x18(%rcx)
movaps %xmm0, 0x8(%rcx)
movaps %xmm0, -0x8(%rcx)
movq $0x0, 0x38(%rcx)
xorl %edx, %edx
movdqa 0x438e1(%rip), %xmm0 # 0xe7ec0
movdqa 0x438e9(%rip), %xmm1 # 0xe7ed0
movdqa 0x49c31(%rip), %xmm2 # 0xee220
ps... | /OpenMD[P]OpenMD/src/primitives/Atom.cpp |
OpenMD::StuntDouble::setA(OpenMD::SquareMatrix3<double> const&, int) | virtual void setA(const RotMat3x3d& a, int snapshotNo) {
((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_] =
a;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
movl %edx, %esi
callq *0x20(%rax)
movq 0x10(%r14), %rdx
movslq 0x30(%r14), %rcx
leaq (%rcx,%rcx,8), %rcx
shlq $0x3, %rcx
addq 0x48(%rax,%rdx), %rcx
cmpq %rbx, %rcx
je 0xa487a
xorl %eax, %eax
xorl %edx, %edx
movsd (%... | /OpenMD[P]OpenMD/src/primitives/StuntDouble.hpp |
OpenMD::Bend::calcForce(double&, bool) | void Bend::calcForce(RealType& angle, bool doParticlePot) {
Vector3d pos1 = atoms_[0]->getPos();
Vector3d pos2 = atoms_[1]->getPos();
Vector3d pos3 = atoms_[2]->getPos();
Vector3d r21 = pos1 - pos2;
snapshotMan_->getCurrentSnapshot()->wrapVector(r21);
RealType d21 = r21.length();
RealType ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1a0, %rsp # imm = 0x1A0
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq (%rax), %rcx
movq 0x10(%rcx), %rdx
movq 0x18(%rcx), %rsi
movq 0x18(%rsi), %rsi
movslq 0x30(%rcx), %rcx
movq (%rsi,%rdx), %rdx
leaq (%rcx,%rcx,2), %... | /OpenMD[P]OpenMD/src/primitives/Bend.cpp |
OpenMD::DirectionalAtom::DirectionalAtom(OpenMD::AtomType*) | DirectionalAtom::DirectionalAtom(AtomType* dAtomType) : Atom(dAtomType) {
objType_ = otDAtom;
DirectionalAdapter da = DirectionalAdapter(dAtomType);
I_ = da.getI();
MultipoleAdapter ma = MultipoleAdapter(dAtomType);
if (ma.isDipole()) { dipole_ = ma.getDipole(); }
if (ma.isQ... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0xa451c
leaq 0x8521f(%rip), %rax # 0x12a470
movq %rax, (%rbx)
leaq 0x88(%rbx), %r15
movl $0xa8, %edx
movq %r15, %rdi
xorl %esi, %esi
callq 0x12230
movl $0x1, 0x8(%rbx)
leaq 0x50(%rsp), %rsi
movq %r14, (%rsi)
leaq 0x8(... | /OpenMD[P]OpenMD/src/primitives/DirectionalAtom.cpp |
OpenMD::DirectionalAtom::setA(OpenMD::SquareMatrix3<double> const&, int) | void DirectionalAtom::setA(const RotMat3x3d& a, int snapshotNo) {
((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_] = a;
if (atomType_->isMultipole()) {
RotMat3x3d atrans = a.transpose();
if (atomType_->isDipole()) {
((snapshotMan_->getSnapshot(snapshotNo))->*storage_)... | pushq %rbp
pushq %r14
pushq %rbx
subq $0xf0, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rdi), %rdi
movq (%rdi), %rax
movl %edx, %esi
callq *0x20(%rax)
movq 0x10(%rbx), %rdx
movslq 0x30(%rbx), %rcx
leaq (%rcx,%rcx,8), %rcx
shlq $0x3, %rcx
addq 0x48(%rax,%rdx), %rcx
cmpq %r14, %rcx
je 0xa5a1e
xorl %e... | /OpenMD[P]OpenMD/src/primitives/DirectionalAtom.cpp |
OpenMD::DirectionalAtom::getGrad() | std::vector<RealType> DirectionalAtom::getGrad() {
std::vector<RealType> grad(6, 0.0);
Vector3d force;
Vector3d torque;
Vector3d myEuler;
RealType phi, theta;
RealType cphi, sphi, ctheta, stheta;
Vector3d ephi;
Vector3d etheta;
Vector3d epsi;
force = getFrc();
torque = getT... | pushq %r15
pushq %r14
pushq %rbx
subq $0x140, %rsp # imm = 0x140
movq %rsi, %r15
movq %rdi, %r14
movl $0x30, %edi
callq 0x12420
movq %rax, %rbx
movq %rax, (%r14)
addq $0x30, %rax
movq %rax, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movq %rax, 0x8(%r1... | /OpenMD[P]OpenMD/src/primitives/DirectionalAtom.cpp |
OpenMD::SquareMatrix3<double>::toEulerAngles() | Vector3<Real> toEulerAngles() {
Vector3<Real> myEuler;
Real phi;
Real theta;
Real psi;
Real ctheta;
Real stheta;
// set the tolerance for Euler angles and rotation elements
theta = acos(
std::min((RealType)1.0, std::max((RealType)-1.0, this->data_[2][2])));
... | pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movsd 0x40(%rsi), %xmm0
maxsd 0x427d8(%rip), %xmm0 # 0xe87a0
minsd 0x41048(%rip), %xmm0 # 0xe7018
callq 0x123f0
movsd %xmm0, 0x8(%rsp)
movsd 0x40(%r14), %xmm0
mulsd %xmm0, %xmm0
movsd 0x4102b(%rip), %xmm1 # 0xe7018
subsd %xmm0, %xmm1
xorpd ... | /OpenMD[P]OpenMD/src/math/SquareMatrix3.hpp |
OpenMD::GhostTorsion::calcForce(double&, bool) | void GhostTorsion::calcForce(RealType& angle, bool doParticlePot) {
DirectionalAtom* ghostAtom = static_cast<DirectionalAtom*>(atoms_[2]);
Vector3d pos1 = atoms_[0]->getPos();
Vector3d pos2 = atoms_[1]->getPos();
Vector3d pos3 = ghostAtom->getPos();
Vector3d r21 = pos1 - pos2;
snapshotMan_->ge... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rdi), %rax
movq 0x10(%rax), %r14
movq (%rax), %rcx
movq 0x10(%rcx), %rdx
movq 0x18(%rcx), %rsi
movq 0x18(%rsi), %rsi
movslq 0x30(%rcx), %rcx
movq (%rsi,... | /OpenMD[P]OpenMD/src/primitives/GhostTorsion.cpp |
OpenMD::Inversion::~Inversion() | virtual ~Inversion() {} | pushq %rbx
movq %rdi, %rbx
leaq 0x8222b(%rip), %rax # 0x12a5d8
movq %rax, (%rdi)
movq 0x78(%rdi), %rdi
leaq 0x88(%rbx), %rax
cmpq %rax, %rdi
je 0xa83cb
movq (%rax), %rsi
incq %rsi
callq 0x12430
movq %rbx, %rdi
popq %rbx
jmp 0xb0192
| /OpenMD[P]OpenMD/src/primitives/Inversion.hpp |
OpenMD::Inversion::getName[abi:cxx11]() | virtual std::string getName() { return name_; } | pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq 0x78(%rsi), %rax
movq 0x80(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x185b0
movq %rbx, %rax
popq %rbx
retq
| /OpenMD[P]OpenMD/src/primitives/Inversion.hpp |
OpenMD::Inversion::getValue(int) | RealType getValue(int snapshotNo) {
// In OpenMD's version of an inversion, the central atom
// comes first. However, to get the planarity in a typical cosine
// version of this potential (i.e. Amber-style), the central atom
// is treated as atom *3* in a standard torsion form:
Vector3d ... | pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp # imm = 0x120
movl %esi, %ebx
movq %rdi, %r14
movq 0x10(%rdi), %rax
movq 0x8(%rax), %r15
movq 0x18(%r15), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x10(%r15), %rcx
movslq 0x30(%r15), %rdx
movq (%rax,%rcx), %rax
leaq (%rdx,%rdx,2), %rcx
movups (%rax,%rcx... | /OpenMD[P]OpenMD/src/primitives/Inversion.hpp |
OpenMD::Molecule::Molecule(int, OpenMD::MoleculeStamp*) | Molecule::Molecule(int globalIndex, MoleculeStamp* molStamp) :
globalIndex_(globalIndex), molStamp_ {molStamp},
constrainTotalCharge_(false) {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x81e72(%rip), %rax # 0x12a650
movq %rax, (%rdi)
movl %esi, 0x8(%rdi)
addq $0x10, %rdi
xorl %r15d, %r15d
movl $0x138, %edx # imm = 0x138
xorl %esi, %esi
callq 0x12230
leaq 0x7fb82(%rip), %rax # 0x128380
movq %rax, 0x148(%r14)
leaq ... | /OpenMD[P]OpenMD/src/primitives/Molecule.cpp |
OpenMD::Molecule::addBond(OpenMD::Bond*) | void Molecule::addBond(Bond* bond) {
if (std::find(bonds_.begin(), bonds_.end(), bond) == bonds_.end()) {
bonds_.push_back(bond);
}
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x28(%rdi), %rdi
movq 0x30(%rbx), %rsi
callq 0xaa5d4
movq 0x30(%rbx), %rsi
cmpq %rsi, %rax
jne 0xa8bfc
cmpq 0x38(%rbx), %rax
je 0xa8beb
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x30(%rbx)
jmp 0xa8bfc
addq $0x28, %rbx
leaq 0... | /OpenMD[P]OpenMD/src/primitives/Molecule.cpp |
OpenMD::Molecule::addTorsion(OpenMD::Torsion*) | void Molecule::addTorsion(Torsion* torsion) {
if (std::find(torsions_.begin(), torsions_.end(), torsion) ==
torsions_.end()) {
torsions_.push_back(torsion);
}
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x58(%rdi), %rdi
movq 0x60(%rbx), %rsi
callq 0xaa9a1
movq 0x60(%rbx), %rsi
cmpq %rsi, %rax
jne 0xa8ca0
cmpq 0x68(%rbx), %rax
je 0xa8c8f
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x60(%rbx)
jmp 0xa8ca0
addq $0x58, %rbx
leaq 0... | /OpenMD[P]OpenMD/src/primitives/Molecule.cpp |
OpenMD::Molecule::addInversion(OpenMD::Inversion*) | void Molecule::addInversion(Inversion* inversion) {
if (std::find(inversions_.begin(), inversions_.end(), inversion) ==
inversions_.end()) {
inversions_.push_back(inversion);
}
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x70(%rdi), %rdi
movq 0x78(%rbx), %rsi
callq 0xaab87
movq 0x78(%rbx), %rsi
cmpq %rsi, %rax
jne 0xa8cf5
cmpq 0x80(%rbx), %rax
je 0xa8ce4
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x78(%rbx)
jmp 0xa8cf5
addq $0x70, %rbx
leaq 0... | /OpenMD[P]OpenMD/src/primitives/Molecule.cpp |
OpenMD::Molecule::addConstraintPair(OpenMD::ConstraintPair*) | void Molecule::addConstraintPair(ConstraintPair* cp) {
if (std::find(constraintPairs_.begin(), constraintPairs_.end(), cp) ==
constraintPairs_.end()) {
constraintPairs_.push_back(cp);
}
} | pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0xd0(%rdi), %rdi
movq 0xd8(%rbx), %rsi
callq 0xab139
movq 0xd8(%rbx), %rsi
cmpq %rsi, %rax
jne 0xa8e22
cmpq 0xe0(%rbx), %rax
je 0xa8e0e
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0xd8(%rbx)
jmp 0xa8e22
addq $0xd0, %rbx
leaq 0... | /OpenMD[P]OpenMD/src/primitives/Molecule.cpp |
OpenMD::Molecule::complete() | void Molecule::complete() {
std::set<Atom*> rigidAtoms;
Atom* atom;
Atom* atom1;
Atom* atom2;
AtomIterator ai, aj;
RigidBody* rb;
RigidBodyIterator rbIter;
Bond* bond;
BondIterator bi;
// Get list of all the atoms that are part of rigid bodies
for (rb = beginRigidBody(rbIte... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, (%rsp)
leaq 0xc0(%rsp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq %r14, 0x10(%r14)
movq %r14, 0x18(%r14)
movq %rax, 0x20(%r14)
movq 0x88(%rdi), %rbx
movq 0x90(%rdi), %rcx
cmpq %rcx, %rbx
je 0xa8f38
movq ... | /OpenMD[P]OpenMD/src/primitives/Molecule.cpp |
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.