name string | code string | asm string | file string |
|---|---|---|---|
ExtPubkey_CreateExtPubkeyFromPubkey_Test::TestBody() | TEST(ExtPubkey, CreateExtPubkeyFromPubkey) {
ExtPubkey extkey;
EXPECT_NO_THROW((extkey = ExtPubkey(NetType::kTestnet,
Pubkey("02ca30dbb25a2cf96344a04ae2144fb28a17f006c34cfb973b9f21623db27c5cd3"),
ByteData256("87ced156b5641d416892046bbd1257c492c030967868aa8dc7a7067490fa08d5"),
3, 44)));
EXPECT_S... | pushq %r15
pushq %r14
pushq %rbx
subq $0x150, %rsp # imm = 0x150
leaq 0xc8(%rsp), %rdi
callq 0x6f150
callq 0x285981
testb %al, %al
je 0x132a04
callq 0x285981
testb %al, %al
je 0x132a72
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x191dae(%rip), %rsi # 0x2c4529
leaq 0x191de9(%rip), %rdx # 0x2c456b... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_extpubkey.cpp |
ExtPubkey_DerivePubkeyTest_Test::~ExtPubkey_DerivePubkeyTest_Test() | TEST(ExtPubkey, DerivePubkeyTest) {
std::string ext_serial = "043587cf02f4a831a200000000bdc76da475a6fbdc4f3758939ab2096d4ab53b7d66c0eed66fc0f4be242835fc030061b08c4c80dc04aaa0b44018d2c4bcdb0d9c0992fb4fddf9d2fb096a5164c0";
ExtPubkey extkey = ExtPubkey(ByteData(ext_serial));
ExtPubkey child;
ExtPubkey child1;
Ex... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_extpubkey.cpp |
ExtPrivkey_DefaultConstructorTest_Test::TestBody() | TEST(ExtPrivkey, DefaultConstructorTest) {
ExtPrivkey extkey = ExtPrivkey();
EXPECT_STREQ("", extkey.GetData().GetHex().c_str());
EXPECT_STREQ("00000000", extkey.GetVersionData().GetHex().c_str());
EXPECT_FALSE(extkey.IsValid());
} | pushq %r14
pushq %rbx
subq $0xc8, %rsp
leaq 0x50(%rsp), %rbx
movq %rbx, %rdi
callq 0x70a80
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x6c350
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x6c830
movq 0x28(%rsp), %r8
leaq 0x174876(%rip), %rsi # 0x2a8089
leaq 0x190521(%rip), %rdx # 0x2c3d3b
leaq 0x218ab2(%rip... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_extprivkey.cpp |
KeyData_Privkey_testnet_Test::~KeyData_Privkey_testnet_Test() | TEST(KeyData, Privkey_testnet) {
Privkey privkey1 = Privkey::FromWif("cQNmd1D8MqzijUuXHb2yS5oRSm2F3TSTTMvcHC3V7CiKxArpg1bg");
ByteData fingerprint1("3456789a");
std::vector<uint32_t> array1{0x80000001, 2, 0x80000003};
auto check_func = [](const KeyData& obj, const std::vector<uint32_t>& arr_obj) {
auto obj... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_keydata.cpp |
KeyData_FromStringExtPubkeyDerive_Test::~KeyData_FromStringExtPubkeyDerive_Test() | TEST(KeyData, FromStringExtPubkeyDerive) {
std::string key1 = "[3456789a/1h/2/3h]tpubDF7yNiHQHdfns9Mc3XM7PYcS2dqrPqcit3FLkebvHxS4atZxifANou2KTvpQQQP82ANDCkPc5MPQZ28pjYGgmDXGy1iyzaiX6MTBv8i4cua/1/2";
std::vector<uint32_t> array1{0x80000001, 2, 0x80000003, 1, 2};
auto check_func = [](const KeyData& obj, const std:... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_keydata.cpp |
KeyData_DerivePubkeyFromPrivkey_Test::~KeyData_DerivePubkeyFromPrivkey_Test() | TEST(KeyData, DerivePubkeyFromPrivkey) {
std::string key1 = "[3456789a/1h/2/3h]xprv9zt1onyw8BdEf7SQ6wUVH3bQQdGD9iy9QzXveQQRhX7i5iUN7jZgLbqFEe491LfjozztYa6bJAGZ65GmDCNcbjMdjZcgmdisPJwVjcfcDhV";
std::string path = "0h/1";
std::vector<uint32_t> array1{0x80000001, 2, 0x80000003, 0x80000000, 1};
std::vector<uint32_t... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_keydata.cpp |
Psbt_JoinTxOnly_Test::TestBody() | TEST(Psbt, JoinTxOnly) {
Psbt psbt;
Psbt psbt_txin_only("cHNidP8BAFwCAAAAAiZ//Xbq5rbBP/uGzquqJNQkhVICM8LDgF4K12RwlXjAAQAAAAD/////fSVGKkL/LLG6VAHliTJZ2zykvPXParlxXTUWPTHJ7MAAAAAAAP////8AAAAAAAAAAA==");
Psbt psbt_txout_only("cHNidP8BAEgCAAAAAAIA4fUFAAAAABYAFLMivdzmM7hRrHNwq0VPCzZ6BlTlAOH1BQAAAAAWABTKuMU6bo/AKW0c05F... | pushq %r14
pushq %rbx
subq $0x178, %rsp # imm = 0x178
leaq 0xd8(%rsp), %rdi
callq 0x6de60
leaq 0x98(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x17f4ec(%rip), %rsi # 0x2dddcc
leaq 0x17f571(%rip), %rdx # 0x2dde58
leaq 0x88(%rsp), %rdi
callq 0xb5d70
leaq 0x128(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x6c860... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_psbt.cpp |
Descriptor_Parse_raw_Test::~Descriptor_Parse_raw_Test() | TEST(Descriptor, Parse_raw) {
std::string descriptor = "raw(6a4c4f54686973204f505f52455455524e207472616e73616374696f6e206f7574707574207761732063726561746564206279206d6f646966696564206372656174657261777472616e73616374696f6e2e)#zf2avljj";
Descriptor desc;
Script locking_script;
std::string desc_str = "";
EXPEC... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_descriptor.cpp |
Address_P2pkhAddressTest_Test::~Address_P2pkhAddressTest_Test() | TEST(Address, P2pkhAddressTest) {
const Pubkey pubkey = Pubkey(
"027592aab5d43618dda13fba71e3993cd7517a712d3da49664c06ee1bd3d1f70af");
Address address;
EXPECT_NO_THROW((address = Address(NetType::kMainnet, pubkey)));
EXPECT_STREQ("1ELuNB5fLNUcrLzb93oJDPmjxjnsVwhNHn", address.GetAddress().c_str());
EXPEC... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_address.cpp |
Address_P2wpkhAddressTest_Test::~Address_P2wpkhAddressTest_Test() | TEST(Address, P2wpkhAddressTest) {
const Pubkey pubkey = Pubkey(
"027592aab5d43618dda13fba71e3993cd7517a712d3da49664c06ee1bd3d1f70af");
Address address;
EXPECT_NO_THROW((address = Address(NetType::kMainnet,
WitnessVersion::kVersion0, pubkey)));
EXPECT_STREQ("bc1qjfw5q2ygp0gvn450h3lu0hlw... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_address.cpp |
Address_PegoutAddressTest_Test::~Address_PegoutAddressTest_Test() | TEST(Address, PegoutAddressTest) {
Script pegout_script("6a2006226e46111a0b59caaf126043eb5bbf28c34f3a5e332a1fc7b2b73cf188910f17a914a722b257cabc3b8e7d46f8fb293f893f368219da872103700dcb030588ed828d85f645b48971de0d31e8c0244da46710d18681627f5a4a4101044e949dcf8ac2daac82a3e4999ee28e2711661793570c4daab34cd38d76a425d6bfe102f... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_address.cpp |
ScriptBuilder_MaxScriptSizeOverErrorTest_Test::~ScriptBuilder_MaxScriptSizeOverErrorTest_Test() | TEST(ScriptBuilder, MaxScriptSizeOverErrorTest) {
ScriptBuilder sb = ScriptBuilder();
// dummy_data = sha256("0000")
ByteData256 dummy_data = ByteData256(
"96a296d224f285c67bee93c30f8a309157f0daa35dc5b87e410b78630a09cfc7");
int64_t loop_num = (Script::kMaxScriptSize / 32) + 1;
for (int64_t i = 0; i < lo... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_scriptbuilder.cpp |
testing::AssertionResult testing::internal::CmpHelperEQ<char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const* const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs,... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq (%rcx), %rsi
movq %r8, %rdi
callq 0x6c7d0
movq %rbx, %rdi
testl %eax, %eax
je 0x20fc63
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x20fc75
jmp 0x20fc68
cal... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQ<char [208], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [208], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs,... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x6c7d0
movq %rbx, %rdi
testl %eax, %eax
je 0x20fd71
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x20fd83
jmp 0x20fd76
callq... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [208], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [208], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0xbe345
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xbe460
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [69], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [69], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0xbe345
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xbe460
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQ<char [137], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [137], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs,... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x6c7d0
movq %rbx, %rdi
testl %eax, %eax
je 0x210092
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x2100a4
jmp 0x210097
callq... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<char [137], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [137], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0xbe345
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xbe460
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQ<char [321], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(char const*, char const*, char const (&) [321], std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | AssertionResult CmpHelperEQ(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs,
const T2& rhs) {
if (lhs == rhs) {
return AssertionSuccess();
}
return CmpHelperEQFailure(lhs_expression, rhs_expression, lhs,... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq %r8, %rdi
movq %rcx, %rsi
callq 0x6c7d0
movq %rbx, %rdi
testl %eax, %eax
je 0x2103c5
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %rcx
movq %r14, %r8
callq 0x2103d7
jmp 0x2103ca
callq... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::CmpHelperEQFailure<cfd::core::ByteData256, cfd::core::ByteData256>(char const*, char const*, cfd::core::ByteData256 const&, cfd::core::ByteData256 const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0x210599
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x210599
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
x... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest.h |
TaprootUtil_CreateTapScriptControl_Test::~TaprootUtil_CreateTapScriptControl_Test() | TEST(TaprootUtil, CreateTapScriptControl) {
Privkey key("305e293b010d29bf3c888b617763a438fee9054c8cab66eb12ad078f819d9f27");
Pubkey pubkey = key.GeneratePubkey();
bool is_parity = false;
SchnorrPubkey schnorr_pubkey = SchnorrPubkey::FromPubkey(pubkey, &is_parity);
EXPECT_EQ("1777701648fa4dd93c74edd9d58cfcc7bd... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_taproot_util.cpp |
TaprootUtil_CreateTapScriptControlParityBit_Test::~TaprootUtil_CreateTapScriptControlParityBit_Test() | TEST(TaprootUtil, CreateTapScriptControlParityBit) {
Privkey key("305e293b010d29bf3c888b617763a438fee9054c8cab66eb12ad078f819d9f27");
Pubkey pubkey = key.GeneratePubkey();
bool is_parity = false;
SchnorrPubkey schnorr_pubkey = SchnorrPubkey::FromPubkey(pubkey, &is_parity);
EXPECT_EQ("1777701648fa4dd93c74edd9d... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_taproot_util.cpp |
ElementsConfidentialAddress_P2pkhAddressFromString_Test::TestBody() | TEST(ElementsConfidentialAddress, P2pkhAddressFromString) {
ElementsConfidentialAddress address;
EXPECT_NO_THROW(
(address =
ElementsConfidentialAddress(
"VTpyoufXeg8LByRmUeHt1zyzFm1RjEP7PvWYHsjGtj9Ef1ibxgVoGkPsUPDNvkKog17K7Qn5eQ3B7g9w")));
EXPECT_STREQ(
"VTpyoufXeg8LByRmUeHt1... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3a0, %rsp # imm = 0x3A0
leaq 0x1f0(%rsp), %rdi
callq 0x6f6b0
callq 0x285981
testb %al, %al
je 0x21e240
callq 0x285981
testb %al, %al
je 0x21e2b4
leaq 0x28(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xf5c76(%rip), %rsi # 0x313e2d
leaq 0xf5cbf(%ri... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialaddress.cpp |
ElementsConfidentialAddress_P2shAddress_Test::~ElementsConfidentialAddress_P2shAddress_Test() | TEST(ElementsConfidentialAddress, P2shAddress) {
const Pubkey pubkey = Pubkey(
"027592aab5d43618dda13fba71e3993cd7517a712d3da49664c06ee1bd3d1f70af");
ByteData160 pubkey_hash = HashUtil::Hash160(pubkey);
ScriptBuilder builder;
builder.AppendOperator(ScriptOperator::OP_DUP);
builder.AppendOperator(ScriptO... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialaddress.cpp |
ElementsConfidentialAddress_P2shWrappedP2wpkhAddress_Test::~ElementsConfidentialAddress_P2shWrappedP2wpkhAddress_Test() | TEST(ElementsConfidentialAddress, P2shWrappedP2wpkhAddress) {
const Pubkey pubkey = Pubkey(
"027592aab5d43618dda13fba71e3993cd7517a712d3da49664c06ee1bd3d1f70af");
// locking_script = ScriptUtil::CreateP2wpkhLockingScript(pubkey);
ByteData160 pubkey_hash = HashUtil::Hash160(pubkey);
ScriptBuilder builder;
... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialaddress.cpp |
ElementsConfidentialAddress_P2shWrappedP2wshAddress_Test::~ElementsConfidentialAddress_P2shWrappedP2wshAddress_Test() | TEST(ElementsConfidentialAddress, P2shWrappedP2wshAddress) {
const Pubkey pubkey = Pubkey(
"027592aab5d43618dda13fba71e3993cd7517a712d3da49664c06ee1bd3d1f70af");
ByteData160 pubkey_hash = HashUtil::Hash160(pubkey);
ScriptBuilder builder;
builder.AppendOperator(ScriptOperator::OP_DUP);
builder.AppendOper... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialaddress.cpp |
ElementsConfidentialAddress_P2wpkhAddressFromString_Test::~ElementsConfidentialAddress_P2wpkhAddressFromString_Test() | TEST(ElementsConfidentialAddress, P2wpkhAddressFromString) {
ElementsConfidentialAddress address;
EXPECT_NO_THROW(
(address =
ElementsConfidentialAddress(
"el1qqtrrepq74crfxf3xzx8804qq9w4pgkf2a2l9gwwtughqv4p3nk8gepg0y9q39qhjgmnyfwfz5z5c5ek0llwtc3jfqw5zvqx5q")));
EXPECT_STREQ(
... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialaddress.cpp |
ElementsConfidentialAddress_GetBlindingKey_Test::~ElementsConfidentialAddress_GetBlindingKey_Test() | TEST(ElementsConfidentialAddress, GetBlindingKey) {
const Privkey master_blinding_key(
"881a1ab07e99ab0626b4d93b3dddfd16cbc04342ee71aab4da7093e7b853fd80");
Address unblind_addr("ert1q0zln07l8vgm5qf4jhzz00668lfs7xssdlxlysh",
GetElementsAddressFormatList());
Privkey blinding_key;
EXPECT_NO_THROW(
... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialaddress.cpp |
ConfidentialTransaction_TxInTest_Test::TestBody() | TEST(ConfidentialTransaction, TxInTest) {
ConfidentialTransaction tx(2, static_cast<uint32_t>(0));
EXPECT_NO_THROW((tx = ConfidentialTransaction(exp_tx_hex)));
EXPECT_EQ(tx.GetTxInCount(), 1);
// GetTxIn
ConfidentialTxInReference txin_ref;
EXPECT_THROW((txin_ref = tx.GetTxIn(1)), CfdException);
EXPECT_NO_... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x380, %rsp # imm = 0x380
leaq 0x1e0(%rsp), %rdi
movl $0x2, %esi
xorl %edx, %edx
callq 0x6d3c0
callq 0x285981
testb %al, %al
je 0x22820b
callq 0x285981
testb %al, %al
je 0x22828e
leaq 0x1d3cf5(%rip), %rsi # 0x3fbea8
leaq 0x220(%rsp), %rdi
callq ... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialtransaction.cpp |
cfd::core::ConfidentialTxOutReference::ConfidentialTxOutReference(cfd::core::ConfidentialTxOutReference const&) | class CFD_CORE_EXPORT ConfidentialTxOutReference
: public AbstractTxOutReference {
public:
/**
* @brief constructor
* @param[in] tx_out Confidential Transaction's TxOut.
*/
explicit ConfidentialTxOutReference(const ConfidentialTxOut& tx_out);
/**
* @brief default constructor.
*/
C... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x190946(%rip), %r13 # 0x3e4e58
movq %r13, (%rdi)
movups 0x8(%rsi), %xmm0
movups %xmm0, 0x8(%rdi)
leaq 0x18(%rdi), %r14
addq $0x18, %rsi
movq %r14, %rdi
callq 0x6ce90
leaq 0x19ecf4(%rip), %rax # 0x3f3228
movq %rax, (%rbx)
... | /p2pderivatives[P]cfd-js/external/cfd-core/src/../include/cfdcore/cfdcore_elements_transaction.h |
ConfidentialTransaction_GetBitcoinTransactionTest_Test::~ConfidentialTransaction_GetBitcoinTransactionTest_Test() | TEST(ConfidentialTransaction, GetBitcoinTransactionTest) {
// no witness
ByteData no_witness_data(
"010000000136641869ca081e70f394c6948e8af409e18b619df2ed74aa106c1ca29787b96e0100000023220020a16b5755f7f6f96dbd65f5f0d6ab9418b89af4b1f14a1bb8a09062c35f0dcb54ffffffff0200e9a435000000001976a914389ffce9cd9ae88dcc0631... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialtransaction.cpp |
ConfidentialTransaction_TxOutTest_Test::~ConfidentialTransaction_TxOutTest_Test() | TEST(ConfidentialTransaction, TxOutTest) {
ConfidentialTransaction tx(exp_tx_empty_hex);
uint32_t index = 0;
uint32_t get_index = 0;
EXPECT_NO_THROW((index = tx.AddTxIn(exp_txid, exp_index, exp_sequence)));
// AddTxOut, GetTxOut, GetTxOutCount
EXPECT_EQ(tx.GetTxOutCount(), 0);
int64_t exp_satoshi = 12345... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialtransaction.cpp |
ConfidentialTransaction_BlindTxOutIgnorePegoutAndEnptyTest_Test::~ConfidentialTransaction_BlindTxOutIgnorePegoutAndEnptyTest_Test() | TEST(ConfidentialTransaction, BlindTxOutIgnorePegoutAndEnptyTest) {
std::string tx_hex = "020000000001a38845c1a19b389f27217b91e2120273b447db3e595bba628f0be833f301a24a0000000000fdffffff030125b251070e29ca19043cf33ccd7324e2ddab03ecc4ae0b5e77c4fc0e5cf6c95a010000befe33cc397c0017a914001d6db698e75a5a8af771730c4ab258af30546b... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialtransaction.cpp |
ConfidentialTransaction_BlindTransactionTest1_Test::~ConfidentialTransaction_BlindTransactionTest1_Test() | TEST(ConfidentialTransaction, BlindTransactionTest1) {
std::string tx_hex = "020000000001e6162f9bbac022e67327e717a3885b316a54e50c34ba266b58f1999854c596810000008000ffffffff0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000003b9aca000... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialtransaction.cpp |
ConfidentialTransaction_SignatureHashTest_Test::~ConfidentialTransaction_SignatureHashTest_Test() | TEST(ConfidentialTransaction, SignatureHashTest) {
ConfidentialTransaction tx(
"020000000001319bff5f4311e6255ecf4dd472650a6ef85fde7d11cd10d3e6ba5974174aeb560100000000ffffffff0201f38611eb688e6fcd06f25e2faf52b9f98364dc14c379ab085f1b57d56b4b1a6f0100000bd2cc1584c002deb65cc52301e1622f482a2f588b9800d2b8386ffabf74d6b2... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialtransaction.cpp |
ConfidentialTransaction_SetAssetReissuanceTest_Test::~ConfidentialTransaction_SetAssetReissuanceTest_Test() | TEST(ConfidentialTransaction, SetAssetReissuanceTest) {
ConfidentialTransaction tx_base(
"0200000000025e67a3542db02871642bdf0923d33ac5bd1105f3421520297f01617c6323918d0000000000ffffffff5e67a3542db02871642bdf0923d33ac5bd1105f3421520297f01617c6323918d0200000000ffffffff03017981c1f171d7973a1fd922652f559f47d6d1506a4b... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialtransaction.cpp |
ConfidentialTransaction_CalculateIssuanceValueTest_Test::~ConfidentialTransaction_CalculateIssuanceValueTest_Test() | TEST(ConfidentialTransaction, CalculateIssuanceValueTest) {
Txid txid("d1efb621591f94f66a9c3161addd6d7db0ae82cc1674e3b098051793fb70028a");
uint32_t vout = 1;
ByteData256 contract_hash_empty;
IssuanceParameter param;
// not blind
EXPECT_NO_THROW(
(param = ConfidentialTransaction::CalculateIssuanceValu... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialtransaction.cpp |
ConfidentialTransaction_UnblindTxOutTest_Test::~ConfidentialTransaction_UnblindTxOutTest_Test() | TEST(ConfidentialTransaction, UnblindTxOutTest) {
/** asset function **/
// assert UnblindParam struct func
auto CheckUnblindParams =
[](UnblindParameter actual, UnblindParameter expect) {
// check confidential asset id
EXPECT_STREQ(
actual.asset.GetHex().c_str(),
exp... | pushq %rbx
movq %rdi, %rbx
callq 0x289966
movq %rbx, %rdi
popq %rbx
jmp 0x6e300
| /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialtransaction.cpp |
testing::AssertionResult testing::internal::CmpHelperEQFailure<unsigned int, unsigned long>(char const*, char const*, unsigned int const&, unsigned long const&) | AssertionResult CmpHelperEQFailure(const char* lhs_expression,
const char* rhs_expression,
const T1& lhs, const T2& rhs) {
return EqFailure(lhs_expression,
rhs_expression,
FormatForComparisonFailureMessage(lhs,... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %r12
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %rdi
movq %rcx, %rsi
callq 0xbd5ef
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xb5eda
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
xor... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest.h |
ConfidentialTxIn_SetPeginWitnessStack_Test::TestBody() | TEST(ConfidentialTxIn, SetPeginWitnessStack) {
ScriptWitness exp_witness_stack = GetExpectWitnessStack();
ScriptWitness exp_pegin_witness = GetExpectPeginWitnessStack();
const ByteData exp_data("1234567890");
uint32_t target_index = 1;
ConfidentialTxIn txin(exp_txid, exp_index, exp_sequence, exp_script,
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x268, %rsp # imm = 0x268
leaq 0x88(%rsp), %rdi
callq 0x259b65
leaq 0xa8(%rsp), %rbx
movq %rbx, %rdi
callq 0x259c89
leaq 0x118(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x4e0f1(%rip), %rsi # 0x2a9e09
leaq 0x4e0f4(%rip), %rdx # 0x2a9e13
leaq 0x108(%rsp),... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialtxin.cpp |
ConfidentialTxOut_Constractor2_Test::TestBody() | TEST(ConfidentialTxOut, Constractor2) {
// Script, ConfidentialAssetId, ConfidentialValue, ConfidentialNonce, ByteData, ByteData
ConfidentialTxOut txout(exp_script, exp_asset, exp_value, exp_nonce,
exp_surjection_proof, exp_range_proof);
EXPECT_STREQ(txout.GetAsset().GetHex().c_str(), ex... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x298, %rsp # imm = 0x298
leaq 0x1953f6(%rip), %rax # 0x3fc4d0
movq %rax, (%rsp)
leaq 0x195323(%rip), %rsi # 0x3fc408
leaq 0x195354(%rip), %rdx # 0x3fc440
leaq 0x195375(%rip), %rcx # 0x3fc468
leaq 0x195396(%rip), %r8 # 0x... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_elements_confidentialtxout.cpp |
Secp256k1_TweakPrivkeySecp256k1EcTest_Test::TestBody() | TEST(Secp256k1, TweakPrivkeySecp256k1EcTest) {
struct secp256k1_context_struct *cxt = wally_get_secp_context();
Secp256k1 secp = Secp256k1(cxt);
for (TweakPrivkeyTestVector test_vector : tweak_privkey_test_vectors) {
ByteData actual_add;
EXPECT_NO_THROW(
actual_add = secp.AddTweakPrivkeySecp256k1E... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
callq 0x6ef30
leaq 0x50(%rsp), %rdi
movq %rax, %rsi
callq 0x6c420
movq 0x17bb84(%rip), %rbx # 0x3fc818
movq 0x17bb85(%rip), %r15 # 0x3fc820
cmpq %r15, %rbx
je 0x2810d7
movq %rsp, %r12
leaq 0x28(%rsp), %r13
leaq 0x40(%rsp), %rbp
lea... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_secp256k1.cpp |
Secp256k1_TweakPrivkeySecp256k1EcErrorTest_Test::TestBody() | TEST(Secp256k1, TweakPrivkeySecp256k1EcErrorTest) {
struct secp256k1_context_struct *cxt = wally_get_secp_context();
Secp256k1 secp = Secp256k1(cxt);
for (TweakPrivkeyTestVector test_vector : tweak_privkey_error_vectors) {
if (test_vector.expect_add.empty()) {
EXPECT_THROW(
ByteData actual = sec... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
callq 0x6ef30
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x6c420
movq 0x17b5f2(%rip), %rbx # 0x3fc830
movq 0x17b5f3(%rip), %rbp # 0x3fc838
cmpq %rbp, %rbx
je 0x281485
leaq 0x28(%rsp), %r15
leaq 0x18(%rsp), %r14
movq %r15, %rdi
mov... | /p2pderivatives[P]cfd-js/external/cfd-core/test/test_secp256k1.cpp |
testing::internal::edit_distance::(anonymous namespace)::Hunk::~Hunk() | Hunk(size_t left_start, size_t right_start)
: left_start_(left_start),
right_start_(right_start),
adds_(),
removes_(),
common_() {} | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x58(%rdi), %r14
movq 0x58(%rdi), %rdi
cmpq %r14, %rdi
je 0x286aba
movq (%rdi), %r15
movl $0x20, %esi
callq 0x6e510
movq %r15, %rdi
cmpq %r14, %r15
jne 0x286aa5
leaq 0x40(%rbx), %r14
movq 0x40(%rbx), %rdi
cmpq %r14, %rdi
je 0x286adc
movq (%rdi), %r15
movl $0x20, %es... | /p2pderivatives[P]cfd-js/external/googletest/googletest/src/gtest.cc |
testing::internal::Int32FromEnvOrDie(char const*, int) | Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) {
const char* str_val = posix::GetEnv(var);
if (str_val == NULL) {
return default_val;
}
Int32 result;
if (!ParseInt32(Message() << "The value of environment variable " << var,
str_val, &result)) {
exit(EXIT_FAILURE);
}
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebx
movq %rdi, %r15
callq 0x6ece0
testq %rax, %rax
je 0x28bef4
movq %rax, %r14
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x285984
movq (%rbx), %rbx
leaq 0x10(%rbx), %r12
leaq 0xc0ab8(%rip), %rsi # 0x34c945
movl $0x22, %edx
movq %r12, %r... | /p2pderivatives[P]cfd-js/external/googletest/googletest/src/gtest.cc |
testing::internal::FormatEpochTimeInMillisAsIso8601[abi:cxx11](long long) | std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) {
struct tm time_struct;
if (!PortableLocaltime(static_cast<time_t>(ms / 1000), &time_struct))
return "";
// YYYY-MM-DDThh:mm:ss
return StreamableToString(time_struct.tm_year + 1900) + "-" +
String::FormatIntWidth2(time_struct.tm_mon + 1) +... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp # imm = 0x228
movq %rsi, %rax
movabsq $0x20c49ba5e353f7cf, %rcx # imm = 0x20C49BA5E353F7CF
imulq %rcx
movq %rdi, %rbx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x7, %rdx
addq %rax, %rdx
leaq 0x88(%rsp), %rdi
movq %rdx, (%rdi)
le... | /p2pderivatives[P]cfd-js/external/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::ConfigureXmlOutput() | void UnitTestImpl::ConfigureXmlOutput() {
const std::string& output_format = UnitTestOptions::GetOutputFormat();
if (output_format == "xml") {
listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter(
UnitTestOptions::GetAbsolutePathToOutputFile().c_str()));
} else if (output_format == "json")... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x283a86
leaq 0xb64d7(%rip), %rsi # 0x34ac4c
movq %r14, %rdi
callq 0x6c7d0
testl %eax, %eax
je 0x29481f
leaq 0xb7f8a(%rip), %rsi # 0x34c716
leaq 0x20(%rsp), %rdi
callq 0x6c7d0
testl %eax, %eax
je 0x2948... | /p2pderivatives[P]cfd-js/external/googletest/googletest/src/gtest.cc |
testing::internal::UnitTestImpl::PostFlagParsingInit() | void UnitTestImpl::PostFlagParsingInit() {
// Ensures that this function does not execute more than once.
if (!post_flag_parse_init_performed_) {
post_flag_parse_init_performed_ = true;
#if defined(GTEST_CUSTOM_TEST_EVENT_LISTENER_)
// Register to send notifications about key process state changes.
lis... | cmpb $0x0, 0x1b0(%rdi)
je 0x294b10
retq
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x1b0(%rdi)
leaq 0x1d0(%rdi), %r14
callq 0x29c046
movq %r14, %rdi
movq %rax, %rsi
callq 0x2a4d1c
cmpq $0x0, 0x1d0(%rbx)
je 0x294b4a
movq 0x190(%rbx), %rax
movb $0x0, 0x8(%rax)
cmpb $0x0, 0x100(%rbx)
jne 0x294b79
movq 0xe... | /p2pderivatives[P]cfd-js/external/googletest/googletest/src/gtest.cc |
testing::internal::DefaultDeathTestFactory::Create(char const*, testing::internal::RE const*, char const*, int, testing::internal::DeathTest**) | bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex,
const char* file, int line,
DeathTest** test) {
UnitTestImpl* const impl = GetUnitTestImpl();
const InternalRunDeathTestFlag* const flag =
impl->internal_run_d... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %r9, %rbx
movl %r8d, %ebp
movq %rcx, %r13
movq %rdx, %r15
movq %rsi, %r12
callq 0x2832d0
movq 0x160f72(%rip), %rax # 0x3fc9f0
movq 0x1d0(%rax), %r14
movq 0x110(%rax), %rcx
movl 0xf8(%rcx), %eax
leal 0x1(%rax), %edx
movl %edx, 0xf... | /p2pderivatives[P]cfd-js/external/googletest/googletest/src/gtest-death-test.cc |
testing::operator<<(std::ostream&, testing::TestPartResult const&) | std::ostream& operator<<(std::ostream& os, const TestPartResult& result) {
return os
<< result.file_name() << ":" << result.line_number() << ": "
<< (result.type() == TestPartResult::kSuccess ? "Success" :
result.type() == TestPartResult::kFatalFailure ? "Fatal failure" :
"Non-fatal fa... | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x10(%rsi)
sete %al
movq 0x8(%rsi), %r15
testq %r15, %r15
sete %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x29d748
movq (%r14), %rax
movq -0x18(%rax), %rax
leaq (%r14,%rax), %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x70030
jmp 0x29d75e
mov... | /p2pderivatives[P]cfd-js/external/googletest/googletest/src/gtest-test-part.cc |
testing::AssertionResult& testing::AssertionResult::operator<<<char [2]>(char const (&) [2]) | AssertionResult& operator<<(const T& value) {
AppendMessage(Message() << value);
return *this;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x285984
movq (%r15), %r15
addq $0x10, %r15
movq %r14, %rdi
callq 0x6cd70
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x6ea30
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ff8dc
movq 0x... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest.h |
testing::AssertionResult testing::internal::FloatingPointLE<float>(char const*, char const*, float, float) | AssertionResult FloatingPointLE(const char* expr1,
const char* expr2,
RawType val1,
RawType val2) {
// Returns success if val1 is less than val2,
if (val1 < val2) {
return AssertionSuccess();
}
// or if val1 is ... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x380, %rsp # imm = 0x380
movq %rdi, %rbx
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
ucomiss %xmm0, %xmm1
ja 0x29fa28
leaq 0x1c(%rsp), %rdi
movss %xmm0, 0x4(%rsp)
movss %xmm0, (%rdi)
leaq 0x18(%rsp), %rsi
movss %xmm1, (%rsp)
movss %xmm1, (%rsi)
cal... | /p2pderivatives[P]cfd-js/external/googletest/googletest/src/gtest.cc |
void testing::internal::InitGoogleTestImpl<char>(int*, char**) | void InitGoogleTestImpl(int* argc, CharType** argv) {
// We don't want to run the initialization code twice.
if (GTestIsInitialized()) return;
if (*argc <= 0) return;
g_argvs.clear();
for (int i = 0; i != *argc; i++) {
g_argvs.push_back(StreamableToString(argv[i]));
}
#if GTEST_HAS_ABSL
absl::Initi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r13
movq %rdi, %r14
leaq 0x15ac51(%rip), %rsi # 0x3fc990
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xef108
movq 0x8(%r15), %rbx
movq (%r15), %r12
movq %r15, %rdi
callq 0xef02e
cmpq %r12, %rbx
jne 0x2a1dfb
cmpl $0x0, (%r14... | /p2pderivatives[P]cfd-js/external/googletest/googletest/src/gtest.cc |
testing::internal::Arguments::Arguments() | Arguments() {
args_.push_back(NULL);
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rsp, %rsi
movq %rax, (%rsi)
callq 0x2a4d8a
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2a1f71
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
ca... | /p2pderivatives[P]cfd-js/external/googletest/googletest/src/gtest-death-test.cc |
void testing::internal::PrintCharAndCodeTo<unsigned char, unsigned char>(unsigned char, std::ostream*) | void PrintCharAndCodeTo(Char c, ostream* os) {
// First, print c as a literal in the most readable form we can find.
*os << ((sizeof(c) > 1) ? "L'" : "'");
const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os);
*os << "'";
// To aid user debugging, we also print c's code in decimal, unless
//... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x52a16(%rip), %rsi # 0x2f4b07
movl $0x1, %edx
movq %rbx, %rdi
callq 0x6ea30
cmpl $0xd, %ebp
ja 0x2a211e
movl %ebp, %eax
leaq 0xa98fc(%rip), %rcx # 0x34ba08
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xa9be7(%... | /p2pderivatives[P]cfd-js/external/googletest/googletest/src/gtest-printers.cc |
testing::internal::DeathTestImpl::~DeathTestImpl() | ~DeathTestImpl() { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } | pushq %rbx
subq $0xf0, %rsp
leaq 0x154fdd(%rip), %rax # 0x3f76a8
movq %rax, (%rdi)
cmpl $-0x1, 0x24(%rdi)
jne 0x2a26dd
addq $0xf0, %rsp
popq %rbx
retq
leaq 0xe0(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0xaa3df(%rip), %rsi # 0x34cacf
leaq 0xaa3eb(%rip), %rdx # 0x34cae2
leaq 0xd0(%rsp), %rdi
callq 0xb5d70
leaq ... | /p2pderivatives[P]cfd-js/external/googletest/googletest/src/gtest-death-test.cc |
testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder* testing::internal::CheckedDowncastToActualType<testing::internal::ThreadLocal<std::vector<testing::internal::TraceInfo, std::allocator<testing::internal::TraceInfo>>>::ValueHolder, testi... | Derived* CheckedDowncastToActualType(Base* base) {
#if GTEST_HAS_RTTI
GTEST_CHECK_(typeid(*base) == typeid(Derived));
#endif
#if GTEST_HAS_DOWNCAST_
return ::down_cast<Derived*>(base);
#elif GTEST_HAS_RTTI
return dynamic_cast<Derived*>(base); // NOLINT
#else
return static_cast<Derived*>(base); // Poor man's ... | pushq %rbx
subq $0x10, %rsp
testq %rdi, %rdi
je 0x2a33b8
movq %rdi, %rbx
movq (%rdi), %rax
movq -0x8(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0xaaa35(%rip), %rax # 0x34dd79
cmpq %rax, %rdi
je 0x2a339b
cmpb $0x2a, (%rdi)
je 0x2a335e
leaq 0xaaa24(%rip), %rsi # 0x34dd79
callq 0x6f480
testl %eax, %eax
je 0x2a339b
leaq... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/internal/gtest-port.h |
testing::internal::StreamingListener::OnTestIterationStart(testing::UnitTest const&, int) | void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) {
SendLn("event=TestIterationStart&iteration=" +
StreamableToString(iteration));
} | pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x24(%rsp), %rsi
movl %edx, (%rsi)
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x2a0cef
leaq 0xa9f26(%rip), %rcx # 0x34d523
movl $0x23, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x6e9b0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%r... | /p2pderivatives[P]cfd-js/external/googletest/googletest/src/gtest-internal-inl.h |
std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> testing::internal::StreamableToString<wchar_t*>(wchar_t* const&) | std::string StreamableToString(const T& streamable) {
return (Message() << streamable).GetString();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x285984
movq (%r14), %rsi
movq %r15, %rdi
callq 0x285a84
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x285bf9
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2a75a1
movq (%rdi), %rax
callq *0x8(%rax)
... | /p2pderivatives[P]cfd-js/external/googletest/googletest/include/gtest/gtest-message.h |
main | int main(void) {
int i, N, M;
double *inp, *acf;
int method;
/*
acvf and acvf_opt functions will calculate autocovariance from lag 0 to lag M-1
*/
FILE *ifp;
double temp[1200];
ifp = fopen("../data/seriesC.txt", "r");
i = 0;
if (!ifp) {
printf("Cannot Open File");
exit(100);
}
while (!feof(ifp)) {
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2588, %rsp # imm = 0x2588
leaq 0x4cc8d(%rip), %rdi # 0x53004
leaq 0x4d2a6(%rip), %rsi # 0x53624
callq 0x61d0
testq %rax, %rax
je 0x6572
movq %rax, %rbx
movq %rax, %rdi
callq 0x6150
testl %eax, %eax
je 0x63aa
xorl... | /rafat[P]ctsa/test/acftest.c |
arima_init | arima_object arima_init(int p, int d, int q, int N) {
arima_object obj = NULL;
int i,M;
if (d > 0) {
M = 0;
}
else {
M = 1;
}
if (p < 0 || d < 0 || q < 0 || N <= 0) {
printf("\n Input Values cannot be Negative. Program Exiting. \n");
exit(-1);
}
//retval = 0 Input Error
// retval = 1 Probable Success... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %eax
orl %edi, %eax
orl %edx, %eax
js 0x66c1
testl %ecx, %ecx
jle 0x66c1
movl %edi, %ebx
xorl %r15d, %r15d
testl %esi, %esi
setle %r15b
leal (%rdx,%rbx), %r13d
movl %ecx, %r12d
subl %esi, %r12d
leal (%r12,%r13)... | /rafat[P]ctsa/src/ctsa.c |
sarima_init | sarima_object sarima_init(int p, int d, int q,int s, int P,int D,int Q, int N) {
sarima_object obj = NULL;
int i, M;
if (d == 0 && D == 0) {
M = 1;
}
else {
M = 0;
}
if (p < 0 || d < 0 || q < 0 || N <= 0 || P < 0 || D < 0 || Q < 0 || s < 0) {
printf("\n Input Values cannot be Negative. Program Exiting. \... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl 0x18(%rbp), %r14d
testl %r14d, %r14d
jle 0x68bc
movl %esi, %r15d
movl 0x10(%rbp), %r10d
movl %r9d, %eax
orl %esi, %eax
movl %edi, %r11d
orl %edx, %r11d
orl %eax, %r11d
movl %ecx, %esi
orl %r8d, %esi
orl %r11d, %esi
o... | /rafat[P]ctsa/src/ctsa.c |
ar_init | ar_object ar_init(int method, int N) {
ar_object obj = NULL;
int i, ordermax,logn,p;
if (N <= 0) {
printf("\n Input Values cannot be Negative. Program Exiting. \n");
exit(-1);
}
//retval = 0 Input Error
// retval = 1 Probable Success
// retval = 4 Optimization Routine didn't converge
// Retval = 15 Optimi... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
testl %esi, %esi
jle 0x69ae
movl %esi, %r14d
movl %edi, %ebx
cvtsi2sd %esi, %xmm0
callq 0x60f0
mulsd 0x4c79d(%rip), %xmm0 # 0x53098
cvttsd2si %xmm0, %esi
leal -0x1(%r14), %edi
callq 0x1ab41
movl %eax, %r15d
cmpl $0x2, %ebx
jne 0x6920
movl %r15d, ... | /rafat[P]ctsa/src/ctsa.c |
sarimax_init | sarimax_object sarimax_init(int p, int d, int q,int P, int D, int Q,int s, int r,int imean, int N) {
sarimax_object obj = NULL;
int i,ncxreg;
if (P + D + Q == 0) {
s = 0;
}
if (imean < 0 || imean > 1) {
printf("imean only accepts one of two values - 0 and 1 \n");
exit(-1);
}
if (d + D > 0) {
ncxreg = r... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %r9d, %r14d
movl %edi, %r10d
movl 0x20(%rbp), %r9d
leal (%r8,%rcx), %eax
xorl %ebx, %ebx
addl %r14d, %eax
je 0x69ed
movl 0x10(%rbp), %ebx
cmpl $0x2, %r9d
jae 0x6bec
movl %esi, %eax
orl %r10d, %eax
movl %edx, %edi
orl... | /rafat[P]ctsa/src/ctsa.c |
auto_arima_init | auto_arima_object auto_arima_init(int *pdqmax,int *PDQmax,int s, int r, int N) {
auto_arima_object obj = NULL;
int pmax,dmax,qmax,Pmax,Dmax,Qmax;
int i,ncxreg;
if (pdqmax == NULL) {
pmax = 5;
dmax = 2;
qmax = 5;
} else {
pmax = pdqmax[0];
dmax = pdqmax[1];
qmax = pdqmax[2];
}
if (PDQmax == NULL) {
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, -0x2c(%rbp)
movl $0x2, %edx
testq %rdi, %rdi
je 0x6c35
movl (%rdi), %r14d
movl 0x4(%rdi), %r15d
movl 0x8(%rdi), %edi
jmp 0x6c46
movl $0x5, %r14d
movl $0x2, %r15d
movl $0x5, %edi
testq %rsi, %rsi
je 0x6c56
movl ... | /rafat[P]ctsa/src/ctsa.c |
arima_exec | void arima_exec(arima_object obj, double *inp) {
int p,q,d,N,M;
double eps;
p = obj->p;
q = obj->q;
d = obj->d;
N = obj->N;
if (obj->d > 0) {
M = 0;
}
else {
M = 1;
}
if (obj->method == 0) {
obj->retval = as154(inp, obj->N, obj->optmethod, obj->p, obj->d, obj->q, obj->params, obj->params + p, &obj->... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movslq 0x10(%rdi), %r13
movslq 0x18(%rdi), %r15
movslq 0x14(%rdi), %r14
movslq (%rdi), %r12
movl 0x8(%rdi), %eax
cmpl $0x2, %eax
je 0x7117
cmpl $0x1, %eax
je 0x7079
testl %eax, %eax
jne 0x716d
leaq 0x78(%r... | /rafat[P]ctsa/src/ctsa.c |
sarimax_exec | void sarimax_exec(sarimax_object obj, double *inp,double *xreg) {
int p,q,d,N,M,P,D,Q,s,r,nd,ncxreg,cssml;
double eps;
p = obj->p;
q = obj->q;
d = obj->d;
N = obj->N;
P = obj->P;
D = obj->D;
Q = obj->Q;
s = obj->s;
r = obj->r;
M = obj->M;
if (obj->method == 0) {
cssml = 1;
obj->retval = as154x(inp,... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
movslq 0x10(%rdi), %r8
movslq 0x18(%rdi), %r10
movslq 0x14(%rdi), %r9
movslq (%rdi), %rax
movslq 0x20(%rdi), %r14
movl 0x24(%rdi), %r13d
movslq 0x28(%rdi), %r12
movl 0x8(%rdi), %ecx
movl 0x1c(%rdi), %r11d
... | /rafat[P]ctsa/src/ctsa.c |
auto_arima_exec | void auto_arima_exec(auto_arima_object obj, double *inp,double *xreg) {
aa_ret_object fit;
int p,d,q,P,D,Q,s,r,N,M;
int i,imean,idrift, retval, iter;
int order[3];
int seasonal[3];
int start[4];
order[0] = obj->pmax;
order[1] = obj->dmax;
order[2] = obj->qmax;
seasonal[0] = obj->Pmax;
seasonal[1] = obj->Dma... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp # imm = 0x118
movq %rdx, -0x40(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdi, %rbx
movl 0x10(%rdi), %ecx
leaq -0x80(%rbp), %rax
movl %ecx, (%rax)
movl 0x14(%rdi), %ecx
movl %ecx, 0x4(%rax)
movl 0x18(%rdi), %ecx
movl ... | /rafat[P]ctsa/src/ctsa.c |
aa_ret_free | void aa_ret_free(aa_ret_object object) {
// use proper free wrapers for given type
if (object->otype == 1) {
myarima_free(object->myarima);
} else {
sarimax_wrapper_free(object->Arima);
}
free(object);
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
cmpl $0x1, 0x10(%rdi)
sete %al
movq (%rdi,%rax,8), %r14
movq (%r14), %rdi
callq 0x6040
movq %r14, %rdi
callq 0x6040
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x6040
| /rafat[P]ctsa/src/ctsa.c |
sarima_exec | void sarima_exec(sarima_object obj, double *inp) {
int p, q, d, s,P,D,Q,N, M,cssml,trparams;
double eps;
p = obj->p;
q = obj->q;
d = obj->d;
N = obj->N;
P = obj->P;
Q = obj->Q;
D = obj->D;
s = obj->s;
M = obj->M;
if (obj->method == 0) {
obj->retval = as154_seas(inp, obj->N, obj->optmethod, obj->p, obj-... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movslq 0x10(%rdi), %r12
movslq 0x18(%rdi), %r9
movslq 0x14(%rdi), %r15
movslq (%rdi), %r13
movslq 0x20(%rdi), %rcx
movslq 0x28(%rdi), %rdi
movl 0x24(%rbx), %r14d
movl 0x8(%rbx), %eax
movl 0x1c(%rbx), %r8d
... | /rafat[P]ctsa/src/ctsa.c |
sarimax_wrapper | sarimax_wrapper_object sarimax_wrapper(sarimax_wrapper_object model,double *y, int N,int *order, int *seasonal, double *xreg, int r, int idrift,int mean,
double *lambda, int biasadj,int method) {
/*
Init here. { sarimax_object,drift}
*/
sarimax_wrapper_object obj = NULL;
int i, p,d,q,P,D,Q,s,ncoeff,drift,rr;
dou... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, -0x48(%rbp)
movq %r8, -0x40(%rbp)
movq %rcx, -0x58(%rbp)
movl %edx, %r13d
movq %rsi, %r12
movq %rdi, %r15
movslq %edx, %rax
movq %rax, -0x70(%rbp)
leaq (,%rax,8), %rbx
movq %rbx, %rdi
callq 0x6190
movq %rax, %r1... | /rafat[P]ctsa/src/ctsa.c |
myarima | myarima_object myarima(double *x, int N, int *order, int *seasonal, int constant, const char* ic, int trace, int approx,
double offset, double *xreg, int r, int *method) {
myarima_object fit = NULL;
int m,p,d,q,P,D,Q,s,diffs,i,j,imean,ncoeff,isum,imx,rr;
int use_season,rmethod,last_nonzero,ip,iq,ir,retval;
double... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movsd %xmm0, -0x80(%rbp)
movq %r9, -0x88(%rbp)
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, -0x48(%rbp)
movq %rdi, -0x58(%rbp)
movl $0x38, %edi
callq 0x6190
movabsq $0x7fefffffffffffff, %rcx # imm = 0x7FEFFF... | /rafat[P]ctsa/src/ctsa.c |
search_arima | myarima_object search_arima(double *x, int N,int d, int D, int p_max, int q_max, int P_max, int Q_max, int Order_max, int stationary,int s, const char *ic,
int approximation, double *xreg, int r, double offset,int allowdrift, int allowmean,int verbose, int method) {
int idrift, imean, maxK, i, j, I, J,K;
double bes... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movsd %xmm0, -0x90(%rbp)
movl %r9d, -0x30(%rbp)
movl %r8d, -0x38(%rbp)
movl %edx, %r8d
movl %esi, -0x34(%rbp)
movq %rdi, -0x88(%rbp)
movl 0x60(%rbp), %esi
movl 0x58(%rbp), %eax
xorl %edi, %edi
leaq -0x68(%rbp), %rdx
movl ... | /rafat[P]ctsa/src/ctsa.c |
newmodel | static int newmodel(int p, int d, int q, int P, int D, int Q, int constant, double *result, int n) {
int i,iter, lresult;
lresult = 8;
for(i = 0; i < n;++i) {
iter = i * lresult;
if ((double)p == result[iter+0] && (double)d == result[iter+1] && (double)q == result[iter+2] && (double)P == result[iter+3] &&
(... | pushq %rbp
movq %rsp, %rbp
movl 0x20(%rbp), %r10d
movl $0x1, %eax
testl %r10d, %r10d
jle 0xc890
cvtsi2sdl 0x10(%rbp), %xmm0
cvtsi2sd %edi, %xmm1
cvtsi2sd %esi, %xmm2
cvtsi2sd %edx, %xmm3
cvtsi2sd %ecx, %xmm4
cvtsi2sd %r8d, %xmm5
cvtsi2sd %r9d, %xmm6
movq 0x18(%rbp), %rcx
movl %r10d, %edx
shlq $0x6, %rdx
xorl %esi, %esi... | /rafat[P]ctsa/src/ctsa.c |
ar_estimate | int ar_estimate(double *x, int N, int method) {
int p, ordermax, logn, i;
double wmean, aic, loglik, var, lvar, aic0,cssml;
double *inp, *resid, *hess, *phi;
inp = (double*)malloc(sizeof(double)* N);
resid = (double*)malloc(sizeof(double)* N);
logn = (int) (10.0 * log((double)N));
ordermax = imin(N - 1, logn);... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %edx, %r15d
movq %rdi, %r12
movl %esi, -0x2c(%rbp)
movslq %esi, %r13
leaq (,%r13,8), %r14
movq %r14, %rdi
callq 0x6190
movq %rax, %rbx
movq %r14, %rdi
callq 0x6190
movq %rax, -0x58(%rbp)
cvtsi2sd %r13d, %xmm0
movsd %... | /rafat[P]ctsa/src/ctsa.c |
auto_arima_summary | void auto_arima_summary(auto_arima_object obj) {
int i, pq,t,ncxreg,mean,drift;
pq = obj->p + obj->q + obj->P + obj->Q + obj->M;
mean = obj->M - obj->r;
if (obj->method == 0 || obj->method == 1) {
printf("\n\nExit Status \n");
printf("Return Code : %d \n", obj->retval);
printf("Exit Message : ");
if (obj-... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0x30(%rdi), %eax
addl 0x28(%rdi), %eax
addl 0x38(%rdi), %eax
movl 0x48(%rdi), %r14d
movl 0x44(%rdi), %ecx
movl %ecx, -0x3c(%rbp)
addl 0x40(%rdi), %eax
movq %rax, -0x38(%rbp)
cmpl $0x1, 0x8(%rdi)
ja 0x... | /rafat[P]ctsa/src/ctsa.c |
sarimax_wrapper_summary | void sarimax_wrapper_summary(sarimax_wrapper_object obj) {
int i, pq,t,nd,ncxreg,mean;
pq = obj->sarimax->p + obj->sarimax->q + obj->sarimax->P + obj->sarimax->Q + obj->sarimax->M;
mean = obj->sarimax->M - obj->sarimax->r;
if (obj->sarimax->method == 0 || obj->sarimax->method == 1) {
printf("\n\nExit Status \n"... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x18(%rax), %r14d
addl 0x10(%rax), %r14d
addl 0x20(%rax), %r14d
movl 0x30(%rax), %r15d
movl 0x2c(%rax), %ecx
movl %ecx, -0x3c(%rbp)
addl 0x28(%rax), %r14d
cmpl $0x1, 0x8(%rax)
ja 0x1... | /rafat[P]ctsa/src/ctsa.c |
myarima_summary | void myarima_summary(myarima_object obj) {
int i, pq,t,nd,ncxreg,mean;
pq = obj->sarimax->p + obj->sarimax->q + obj->sarimax->P + obj->sarimax->Q + obj->sarimax->M;
mean = obj->sarimax->M - obj->sarimax->r;
if (obj->sarimax->method == 0 || obj->sarimax->method == 1) {
printf("\n\nExit Status \n");
printf("Ret... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movl 0x18(%rax), %r14d
addl 0x10(%rax), %r14d
addl 0x20(%rax), %r14d
movl 0x30(%rax), %r15d
movl 0x2c(%rax), %ecx
movl %ecx, -0x3c(%rbp)
addl 0x28(%rax), %r14d
cmpl $0x1, 0x8(%rax)
ja 0x1... | /rafat[P]ctsa/src/ctsa.c |
aa_ret_summary | void aa_ret_summary(aa_ret_object obj) {
if (obj->otype == 2) {
sarimax_wrapper_summary(obj->Arima);
} else if (obj->otype == 1) {
myarima_summary(obj->myarima);
} else {
printf("aa_ret Error \n");
}
} | pushq %rbp
movq %rsp, %rbp
movl 0x10(%rdi), %eax
cmpl $0x1, %eax
je 0x1121d
cmpl $0x2, %eax
jne 0x11227
movq (%rdi), %rdi
popq %rbp
jmp 0x10613
movq 0x8(%rdi), %rdi
popq %rbp
jmp 0x10c0b
leaq 0x42b18(%rip), %rdi # 0x53d46
popq %rbp
jmp 0x60a0
| /rafat[P]ctsa/src/ctsa.c |
ar_summary | void ar_summary(ar_object obj) {
int i;
printf("\n\n");
printf(" AR Order : ( %d) \n", obj->p);
printf("\n");
printf("%-20s%-20s \n\n", "Coefficients", "Value");
for (i = 0; i < obj->p; ++i) {
printf("AR%-15d%-20g \n", i + 1, obj->phi[i]);
}
printf("\n");
printf("%-17s%-20g \n", "MEAN", obj->mean);
pri... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x42151(%rip), %rdi # 0x53399
callq 0x60a0
movl 0xc(%rbx), %esi
leaq 0x424d3(%rip), %rdi # 0x5372a
xorl %eax, %eax
callq 0x60d0
movl $0xa, %edi
callq 0x6050
leaq 0x4211e(%rip), %rdi # 0x5338d
leaq 0x42125(%rip), %rsi... | /rafat[P]ctsa/src/ctsa.c |
pacf_opt | void pacf_opt(double* vec, int N, int method, double* par, int M) {
// Method 0 : Yule-Walker
// Method 1 : Burg
// Method 2 : Box-Jenkins Conditional MLE
if (method == 0) {
pacf_yw(vec, N, par, M);
}
else if (method == 1) {
pacf_burg(vec, N, par, M);
}
else if (method == 2) {
pacf_mle(vec, N, par, M);
... | cmpl $0x2, %edx
je 0x117f6
cmpl $0x1, %edx
je 0x117eb
testl %edx, %edx
jne 0x11801
movq %rcx, %rdx
movl %r8d, %ecx
jmp 0x1a974
movq %rcx, %rdx
movl %r8d, %ecx
jmp 0x1a8ed
movq %rcx, %rdx
movl %r8d, %ecx
jmp 0x1a9f2
pushq %rbp
movq %rsp, %rbp
leaq 0x42548(%rip), %rdi # 0x53d54
callq 0x60a0
leaq 0x42570(%rip), %rdi ... | /rafat[P]ctsa/src/ctsa.c |
pacf | void pacf(double* vec, int N, double* par, int M) {
pacf_yw(vec, N, par, M);
/*
auto_fft_object obj;
double *acorr;
acorr = (double*)malloc(sizeof(double)* M);
if (N < 50) {
autocorr(vec, N, acorr, M);
}
else {
obj = auto_fft_init(N);
autocorr_fft(obj, vec, acorr, M);
free_auto(obj);
}
free(acorr);
*/... | pushq %rbp
movq %rsp, %rbp
popq %rbp
jmp 0x1a974
| /rafat[P]ctsa/src/ctsa.c |
acvf_opt | void acvf_opt(double* vec, int N, int method, double* par, int M) {
//Method 0 : Regular Method. Slow for large input length.
//Method 1 : FFT based Method. Use it if data length is large
auto_fft_object obj;
if (method == 0) {
autocovar(vec, N, par, M);
}
else if (method == 1) {
obj = auto_fft_init(N);
au... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebx
movq %rcx, %r14
movq %rdi, %r15
cmpl $0x1, %edx
je 0x1187c
testl %edx, %edx
jne 0x118a6
movq %r15, %rdi
movq %r14, %rdx
movl %ebx, %ecx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2ff43
movl %esi, %edi
callq 0x2fee9
movq ... | /rafat[P]ctsa/src/ctsa.c |
acvf2acf | void acvf2acf(double *acorr, int M) {
// Converts Autocovariance to autocorrelation function
int i;
double var;
var = acorr[0];
acorr[0] = 1.0;
for (i = 1; i < M; i++) {
acorr[i] = acorr[i] / var;
}
} | pushq %rbp
movq %rsp, %rbp
movsd (%rdi), %xmm0
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, (%rdi)
cmpl $0x2, %esi
jl 0x11909
movl %esi, %eax
movl $0x1, %ecx
movsd (%rdi,%rcx,8), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rdi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x118f3
popq %rbp
retq
| /rafat[P]ctsa/src/ctsa.c |
alik_init | alik_object alik_init(int p, int d, int q, int N) {
alik_object obj = NULL;
int i,t;
if (p > 100 || q > 100) {
printf("\n p and q should be less than 100. \n");
printf("Use sarima_init if either p > 100 or q > 100 \n");
exit(1);
}
obj = (alik_object)malloc(sizeof(struct alik_set) + sizeof(double) * 3 * N);
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x64, %edi
jg 0x11bf3
movl %edx, %r15d
cmpl $0x65, %edx
jge 0x11bf3
movl %esi, %r12d
movl %edi, %r14d
movslq %ecx, %r13
leaq (,%r13,2), %rax
addq %r13, %rax
leaq 0x688(,%rax,8), %rdi
callq 0x6190
movq %rax, %rbx
movl %r14... | /rafat[P]ctsa/src/emle.c |
css | int css(double *inp, int N, int optmethod, int p, int d, int q, double *phi, double *theta, double *wmean,double *var,double *resid,double *loglik,double *hess) {
int i, pq, retval, length,M,ret;
double *b, *tf, *x,*dx,*thess;
int *ipiv;
double maxstep;
alik_css_object obj;
x = (double*)malloc(sizeof(double)* (N... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %r9, -0x40(%rbp)
movl %r8d, %r14d
movq %rcx, -0x38(%rbp)
movl %edx, -0x58(%rbp)
movl %esi, %r15d
movq %rdi, %rbx
movq 0x20(%rbp), %r12
movl %esi, %eax
subl %r8d, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x6190
te... | /rafat[P]ctsa/src/emle.c |
checkroots_cerr | static int checkroots_cerr(double *phi, int *p, double *theta, int *q, double *PHI, int *P, double *THETA, int *Q) {
int ret,out;
out = 1;
if (*p > 0) {
ret = archeck(*p,phi);
if (!ret) {
out = 10;
printf("\nnon-stationary AR part\n");
return out;
}
}
if (*q > 0) {
invertroot(*q,theta);
}
if... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r9, %r14
movq %r8, %rbx
movq %rcx, %r12
movq %rdx, %r15
testl %esi, %esi
jle 0x14b8e
movq %rdi, %rax
movl %esi, %edi
movq %rax, %rsi
callq 0x31b1f
testl %eax, %eax
je 0x14bcb
movl (%r12), %edi
testl %edi, %edi
jle 0x14b9e
movq %r15, %rsi
callq... | /rafat[P]ctsa/src/emle.c |
cssx | int cssx(double *inp, int N, double *xreg, int optmethod, int p, int d, int q, int s, int P, int D, int Q,
double *phi, double *theta, double *PHI, double *THETA, double *exog, int r, double *wmean, double *var,double *loglik,double *hess,int start,int imean) {
int i, pq, retval, length, offset,ret,nd,ncxreg,N1,rnk,... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r9d, -0x34(%rbp)
movl %r8d, %ebx
movl %ecx, -0x64(%rbp)
movq %rdx, %r15
movq %rdi, %r13
movl 0x28(%rbp), %eax
imull 0x18(%rbp), %eax
movl %esi, -0x30(%rbp)
movl %esi, %r14d
movl %eax, -0xb4(%rbp)
subl %eax, %r14d
mo... | /rafat[P]ctsa/src/emle.c |
fas154x_seas | double fas154x_seas(double *b, int pq, void *params) {
double value, ssq, sumlog, delta,temp;
int p, q, ps, qs,s,offset,naram,M;
int ip, iq, ir, i,j, np, ifault, N, iupd, nit, iter;
double *phi, *theta, *A, *P, *V,*reg;
value = ssq = sumlog = 0.0;
xlik_object obj = (xlik_object)params;
ip = obj->p + (obj->s * ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r12
xorl %eax, %eax
movq %rax, -0xa8(%rbp)
movq %rax, -0xb0(%rbp)
movslq (%rdx), %rcx
movq %rcx, -0x68(%rbp)
movl %ecx, %r14d
movslq 0xc(%rdx), %rax
movq %rax, -0x30(%rbp)
movl 0x8(%rdx), %r15d
movl 0x10(%rdx)... | /rafat[P]ctsa/src/emle.c |
fas154_seas | double fas154_seas(double *b, int pq, void *params) {
double value, ssq, sumlog, delta;
int p, q, ps, qs,s,offset;
int ip, iq, ir, i,j, np, ifault, N, iupd, nit, iter;
double *phi, *theta, *A, *P, *V;
value = ssq = sumlog = 0.0;
alik_seas_object obj = (alik_seas_object)params;
ip = obj->p + (obj->s * obj->P);
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r13
xorl %eax, %eax
movq %rax, -0xb0(%rbp)
movq %rax, -0x90(%rbp)
movslq (%rdx), %rcx
movq %rcx, -0x60(%rbp)
movl %ecx, %ebx
movslq 0xc(%rdx), %r14
movl 0x8(%rdx), %r15d
movl 0x10(%rdx), %eax
movq %rax, -0x98(... | /rafat[P]ctsa/src/emle.c |
as154_seas | int as154_seas(double *inp, int N, int optmethod, int p, int d, int q, int s, int P, int D, int Q,double *phi, double *theta,
double *PHI, double *THETA, double *wmean,double *var,double *loglik,double *hess,int cssml) {
int i, pq, retval, length, offset,ret,nd,rp,ERR;
double *b, *tf, *x,*inp2,*dx,*thess,*res,*varc... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %r9d, %ebx
movl %r8d, -0x2c(%rbp)
movl %ecx, %r15d
movl %edx, -0x70(%rbp)
movl %esi, %r12d
movq %rdi, %r13
movl 0x28(%rbp), %r14d
movl 0x20(%rbp), %ecx
movl 0x18(%rbp), %eax
movq %rax, -0x38(%rbp)
movl 0x10(%rbp), %e... | /rafat[P]ctsa/src/emle.c |
flikam | int flikam(double *P, int MP, double *Q, int MQ,double *W, double *E, int N,double *ssq,double *fact,double *VW,double *VL,int MRP1,double *VK,int MR,double TOLER) {
int ifault,MXPQ,MXPQP1,MQP1,MPP1,FLAG;
int k,j,jp2mk,jp1mk,LAST,LOOP,JFROM,i,NEXTI,imj;
double zero, p0625, one, two, four, sixteen,epsil1;
double A, ... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movsd %xmm0, -0xd0(%rbp)
movq %r9, -0xa8(%rbp)
movq %r8, -0x50(%rbp)
movl %ecx, %r15d
movq %rdx, -0x60(%rbp)
movl %esi, %r12d
movq %rdi, -0x48(%rbp)
movq 0x40(%rbp), %rbx
movq 0x30(%rbp), %r14
movq 0x28(%rbp), %r13
movq 0... | /rafat[P]ctsa/src/emle.c |
fas197 | double fas197(double *b, int pq, void *params) {
double value, ssq, fact, delta;
int ip, iq, i, ifault, N;
double *phi, *theta,*VW,*VK,*VL;
int MR, MRP1;
value = ssq = fact = 0.0;
alik_object obj = (alik_object)params;
ip = obj->p;
iq = obj->q;
N = obj->N;
MR = imax(ip, iq + 1);
MRP1 = MR + 1;
phi = (doub... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %rbx
movq %rdi, %r15
xorl %eax, %eax
movq %rax, -0x50(%rbp)
movq %rax, -0x58(%rbp)
movslq (%rdx), %r13
movslq 0x8(%rdx), %r12
movl 0x18(%rdx), %r14d
leal 0x1(%r12), %esi
movl %r13d, %edi
movq %r13, -0x30(%rbp)
... | /rafat[P]ctsa/src/emle.c |
as197 | void as197(double *inp, int N, int optmethod, int p, int d, int q, double *phi, double *theta, double *wmean, double *var,double *resid,double *loglik,double *hess) {
int i, pq, retval, length;
double *b, *tf, *x;
double maxstep;
alik_object obj;
//custom_function as154_min;
x = (double*)malloc(sizeof(double)* (... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %r9d, %ebx
movq %rbx, -0x38(%rbp)
movl %r8d, %r13d
movl %ecx, %r14d
movl %edx, -0x44(%rbp)
movl %esi, %r15d
movq %rdi, -0x50(%rbp)
movl %esi, %eax
subl %r8d, %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x6190
movq %... | /rafat[P]ctsa/src/emle.c |
norm2 | double norm2(double *array, int N) {
int i;
double nrm;
nrm = 0.0;
for (i = 0; i < N; ++i) {
nrm += array[i]*array[i];
}
nrm = sqrt(nrm);
return nrm;
} | pushq %rbp
movq %rsp, %rbp
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
testl %esi, %esi
jle 0x18fc9
movl %esi, %eax
xorl %ecx, %ecx
movsd (%rdi,%rcx,8), %xmm2
mulsd %xmm2, %xmm2
addsd %xmm2, %xmm0
incq %rcx
cmpq %rcx, %rax
jne 0x18fb4
ucomisd %xmm1, %xmm0
jb 0x18fd5
sqrtsd %xmm0, %xmm0
popq %rbp
retq
popq %rbp
jmp 0x6220
| /rafat[P]ctsa/src/filter.c |
filter | void filter(double *sig, int len_sig, double *filt, int len_filt, double *oup) {
int N,i;
double *temp;
/*
*
* filter returns the output which is of same length as the input
* unlike conv function
*
*/
N = len_sig + len_filt - 1;
temp = (double*) malloc (sizeof(double) * N);
conv_direct(sig,len_sig,... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, -0x30(%rbp)
movl %ecx, %r12d
movq %rdx, %r13
movl %esi, %r14d
movq %rdi, %rbx
leal (%r14,%r12), %eax
decl %eax
movslq %eax, %rdi
shlq $0x3, %rdi
callq 0x6190
movq %rax, %r15
movq %rbx, %rdi
movl %r14d, %esi
movq %r13,... | /rafat[P]ctsa/src/filter.c |
mafilter | void mafilter(double *sig,int N, int window,double *oup) {
int odd,q,N2,i,j;
double sum;
double *temp;
/*
* mafilter is a moving average filter that smoothes the signal using
* a smoothing window. In this implementation, the signal is extended
* by the length of the window. Length floor(window/2) extension is... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdi, -0x30(%rbp)
movl %edx, %r15d
shrl $0x1f, %r15d
addl %edx, %r15d
movl %r15d, %eax
andl $-0x2, %eax
cmpl %edx, %eax
movq %rdx, -0x48(%rbp)
movl %eax, -0x38(%rbp)
jne 0x190db
sarl %r15d
movl %eax, ... | /rafat[P]ctsa/src/filter.c |
mafilter_wt | void mafilter_wt(double *sig,int N, double *weights, int window,double *oup) {
int odd,q,N2,i,j,ct;
double sum;
double *temp;
/* Accepts Normalized weights.
* If the weight is not normalized then normalize it by
* dividing all the weights by the sum of all the weights
* [1,1,1,1,1] normalizes to [1,1,1... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rdx, %r14
movq %rdi, -0x30(%rbp)
movl %ecx, %r13d
shrl $0x1f, %r13d
addl %ecx, %r13d
movl %r13d, %eax
andl $-0x2, %eax
movl %eax, -0x3c(%rbp)
cmpl %ecx, %eax
movq %rsi, -0x48(%rbp)
movq %rcx, -0x50(%r... | /rafat[P]ctsa/src/filter.c |
ma_inn | void ma_inn(double *inp, int N,int q, double* theta, int lag) {
// Moving Average Parameters for a MA(q) process using Innovations
// Algorithm. lag is typically set at <= 17
int i;
double *v,*thetap;
thetap = (double*) malloc(sizeof(double) * (lag+1) * (lag+1));
v = (double*) malloc(sizeof(double) * (lag+1));
... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r12d
movq %rcx, %rbx
movl %edx, -0x30(%rbp)
movl %esi, -0x2c(%rbp)
movq %rdi, %r13
movslq %r8d, %rdi
leaq 0x8(,%rdi,8), %r15
incq %rdi
imulq %r15, %rdi
callq 0x6190
movq %rax, %r14
movq %r15, %rdi
callq 0x6190
movq ... | /rafat[P]ctsa/src/initest.c |
ywalg | void ywalg(double *x, int N, int p, double *phi) {
int lag,k,j;
double *acf,*z,*y,*temp1,*temp2;
double a, b;
lag = p + 1;
acf = (double*)malloc(sizeof(double)* lag);
y = (double*)malloc(sizeof(double)* lag);
z = (double*)malloc(sizeof(double)* p);
temp1 = (double*)malloc(sizeof(double)* p);
temp2 = (double*)... | pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, -0x68(%rbp)
movl %esi, -0x30(%rbp)
movq %rdi, -0x50(%rbp)
leal 0x1(%rdx), %eax
movl %eax, -0x38(%rbp)
movq %rdx, -0x58(%rbp)
movslq %edx, %rbx
leaq 0x8(,%rbx,8), %r14
movq %r14, %rdi
callq 0x6190
movq %rax, %r1... | /rafat[P]ctsa/src/initest.c |
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.