name
stringlengths 1
473k
| code
stringlengths 7
647k
| asm
stringlengths 4
3.39M
| file
stringlengths 8
196
|
|---|---|---|---|
KDIS::UTILS::IndentString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned short, char) | static inline KString IndentString( const KString & S, KUINT16 Tabs = 1, KCHAR8 Tab = '\t' )
{
KStringStream NewS;
// Add tab to first item and then check all new lines
AddTabsToStringStream( NewS, Tabs, Tab );
for( KUINT16 i = 0; i < S.size(); ++i )
{
if( S.c_str()[i] == '\n' && i != ( S.size() - 1 ) )
{
NewS << S.c_str()[i];
AddTabsToStringStream( NewS, Tabs, Tab );
}
else
{
NewS << S.c_str()[i];
}
}
return NewS.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25250
leaq 0x18(%rsp), %r15
leaq 0x7(%rsp), %rsi
movb $0x9, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x253e0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x5f992
movw $0x1, %r13w
xorl %ecx, %ecx
leaq 0x7(%rsp), %r12
movq (%r14), %rdx
movb (%rdx,%rcx), %dl
cmpb $0xa, %dl
setne %sil
decq %rax
cmpq %rcx, %rax
sete %al
orb %sil, %al
je 0x5f958
movb %dl, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x253e0
jmp 0x5f982
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x253e0
movb $0x9, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x253e0
movzwl %r13w, %ecx
movq 0x8(%r14), %rax
incl %r13d
cmpq %rcx, %rax
ja 0x5f927
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x25480
movq 0xd5612(%rip), %rsi # 0x134fb8
leaq 0x8(%rsp), %rdi
callq 0x25280
leaq 0x88(%rsp), %rdi
callq 0x25120
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x5f9d0
movq %rax, %rbx
movq 0xd55de(%rip), %rsi # 0x134fb8
leaq 0x8(%rsp), %rdi
callq 0x25280
leaq 0x88(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management/./././.././././.././Extras/KUtils.h |
KDIS::PDU::Stop_Freeze_PDU::SetRealWorldTime(KDIS::DATA_TYPE::ClockTime const&) | class KDIS_EXPORT ClockTime : public DataTypeBase
{
protected:
KINT32 m_i32Hour;
KUINT32 m_ui32TimePastHour;
public:
static const KUINT16 CLOCK_TIME_SIZE = 8;
ClockTime();
ClockTime( KINT32 Hour, KUINT32 TimePastHour );
explicit ClockTime(KDataStream &stream) noexcept(false);
~ClockTime() override = default;
//************************************
// FullName: KDIS::DATA_TYPE::ClockTime::SetHour
// KDIS::DATA_TYPE::ClockTime::GetHour
// Description: Time.
// Parameter: KINT32 H, void
//************************************
void SetHour( KINT32 H );
KINT32 GetHour() const;
//************************************
// FullName: KDIS::DATA_TYPE::ClockTime::SetTimePastHour
// KDIS::DATA_TYPE::ClockTime::GetTimePastHour
// Description: Time Past Hour. The time past the hour field.
// Parameter: KFLOAT32 Z, void
//************************************
void SetTimePastHour( KUINT32 TPH );
KUINT32 GetTimePastHour() const;
//************************************
// FullName: KDIS::DATA_TYPE::ClockTime::GetAsString
// Description: Returns a string representation
//************************************
KString GetAsString() const override;
//************************************
// FullName: KDIS::DATA_TYPE::ClockTime::Decode
// Description: Convert From Network Data.
// Parameter: KDataStream & stream
//************************************
void Decode(KDataStream &stream) noexcept(false) override;
//************************************
// FullName: KDIS::DATA_TYPE::ClockTime::Encode
// Description: Convert To Network Data.
// Parameter: KDataStream & stream
//************************************
KDataStream Encode() const override;
void Encode(KDataStream &stream) const override;
KBOOL operator == ( const ClockTime & Value ) const;
KBOOL operator != ( const ClockTime & Value ) const;
KBOOL operator < ( const ClockTime & Value ) const;
} | movq 0x8(%rsi), %rax
movq %rax, 0x50(%rdi)
retq
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management/././../../DataTypes/ClockTime.h |
KDIS::PDU::Stop_Freeze_PDU::operator==(KDIS::PDU::Stop_Freeze_PDU const&) const | KBOOL Stop_Freeze_PDU::operator == ( const Stop_Freeze_PDU & Value ) const
{
if( Simulation_Management_Header::operator !=( Value ) ) return false;
if( m_RealWorldTime != Value.m_RealWorldTime ) return false;
if( m_ui8Reason != Value.m_ui8Reason ) return false;
if( m_ui8FrozenBehaviour != Value.m_ui8FrozenBehaviour ) return false;
if( m_ui32RequestID != Value.m_ui32RequestID ) return false;
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5f28a
testb %al, %al
jne 0x604b6
leaq 0x48(%r14), %rdi
leaq 0x48(%rbx), %rsi
callq 0x7ac04
testb %al, %al
jne 0x604b6
movb 0x58(%r14), %al
cmpb 0x58(%rbx), %al
jne 0x604b6
movb 0x59(%r14), %al
cmpb 0x59(%rbx), %al
jne 0x604b6
movl 0x5c(%r14), %eax
cmpl 0x5c(%rbx), %eax
sete %al
jmp 0x604b8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management/Stop_Freeze_PDU.cpp |
KDIS::PDU::Acknowledge_R_PDU::GetAsString[abi:cxx11]() const | KString Acknowledge_R_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Acknowledge-R PDU-\n"
<< Simulation_Management_Header::GetAsString()
<< "\tAcknowledge Flag: " << GetEnumAsStringAcknowledgeFlag( m_ui16AcknowledgeFlag )
<< "\n\tResponse Flag: " << GetEnumAsStringAcknowledgeResponseFlag( m_ui16ResponseFlag )
<< "\n\tRequest ID: " << m_ui32RequestID
<< "\n";
return ss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x210, %rsp # imm = 0x210
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x88(%rsp), %rdi
callq 0x25250
leaq 0x68(%rsp), %rdi
movq %r14, %rsi
callq 0x2b662
leaq 0x98(%rsp), %rdi
movq 0x68(%rsp), %rsi
movq 0x70(%rsp), %rdx
callq 0x253e0
movq %rax, %r15
leaq 0x5e47a(%rip), %rsi # 0xbecd9
movl $0x14, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x5ed86
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
movq %rax, %r15
leaq 0x5e459(%rip), %rsi # 0xbecee
movl $0x15, %edx
movq %rax, %rdi
callq 0x253e0
movzwl 0x48(%r14), %esi
leaq 0x28(%rsp), %rdi
callq 0xb1119
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
movq %rax, %r15
leaq 0x5e437(%rip), %rsi # 0xbed04
movl $0x16, %edx
movq %rax, %rdi
callq 0x253e0
movzwl 0x4a(%r14), %esi
leaq 0x8(%rsp), %rdi
callq 0xb1163
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
movq %rax, %r15
leaq 0x5e416(%rip), %rsi # 0xbed1b
movl $0x16, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x4c(%r14), %esi
movq %r15, %rdi
callq 0x25220
leaq 0x5e1a1(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6094d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60968
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60983
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6099e
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xa0(%rsp), %rsi
movq %rbx, %rdi
callq 0x25480
movq 0xd4603(%rip), %rsi # 0x134fb8
leaq 0x88(%rsp), %rdi
callq 0x25280
leaq 0x108(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x210, %rsp # imm = 0x210
popq %rbx
popq %r14
popq %r15
retq
jmp 0x609e7
jmp 0x609ec
jmp 0x609f1
jmp 0x609f6
movq %rax, %rbx
jmp 0x60a6a
movq %rax, %rbx
jmp 0x60a19
movq %rax, %rbx
jmp 0x60a34
movq %rax, %rbx
jmp 0x60a4f
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60a19
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60a34
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60a4f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x60a6a
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0xd4547(%rip), %rsi # 0x134fb8
leaq 0x88(%rsp), %rdi
callq 0x25280
leaq 0x108(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Acknowledge_R_PDU.cpp |
KDIS::PDU::Action_Request_R_PDU::Encode(KDIS::KDataStream&) const | void Action_Request_R_PDU::Encode( KDataStream & stream ) const
{
Simulation_Management_Header::Encode( stream );
Reliability_Header::Encode( stream );
stream << m_ui32RequestID
<< m_ui32ActionID
<< m_ui32NumFixedDatum
<< m_ui32NumVariableDatum;
vector<FixDtmPtr>::const_iterator citrFixed = m_vFixedDatum.begin();
vector<FixDtmPtr>::const_iterator citrFixedEnd = m_vFixedDatum.end();
for( ; citrFixed != citrFixedEnd; ++citrFixed )
{
( *citrFixed )->Encode( stream );
}
vector<VarDtmPtr>::const_iterator citrVar = m_vVariableDatum.begin();
vector<VarDtmPtr>::const_iterator citrVarEnd = m_vVariableDatum.end();
for( ; citrVar != citrVarEnd; ++citrVar )
{
( *citrVar )->Encode( stream );
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5f20c
leaq 0x90(%r14), %rdi
movq %rbx, %rsi
callq 0x658cc
movl 0x80(%r14), %esi
movq %rbx, %rdi
callq 0x2b2fa
movl 0x88(%r14), %esi
movq %rbx, %rdi
callq 0x2b2fa
movl 0x48(%r14), %esi
movq %rbx, %rdi
callq 0x2b2fa
movl 0x4c(%r14), %esi
movq %rbx, %rdi
callq 0x2b2fa
movq 0x50(%r14), %r15
movq 0x58(%r14), %r12
cmpq %r12, %r15
je 0x61628
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x28(%rax)
addq $0x18, %r15
jmp 0x61610
movq 0x68(%r14), %r15
movq 0x70(%r14), %r14
cmpq %r14, %r15
je 0x61648
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x28(%rax)
addq $0x18, %r15
jmp 0x61630
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Action_Request_R_PDU.cpp |
KDIS::UTILS::IndentString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned short, char) | static inline KString IndentString( const KString & S, KUINT16 Tabs = 1, KCHAR8 Tab = '\t' )
{
KStringStream NewS;
// Add tab to first item and then check all new lines
AddTabsToStringStream( NewS, Tabs, Tab );
for( KUINT16 i = 0; i < S.size(); ++i )
{
if( S.c_str()[i] == '\n' && i != ( S.size() - 1 ) )
{
NewS << S.c_str()[i];
AddTabsToStringStream( NewS, Tabs, Tab );
}
else
{
NewS << S.c_str()[i];
}
}
return NewS.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25250
leaq 0x18(%rsp), %r15
leaq 0x7(%rsp), %rsi
movb $0x9, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x253e0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x61c24
movw $0x1, %r13w
xorl %ecx, %ecx
leaq 0x7(%rsp), %r12
movq (%r14), %rdx
movb (%rdx,%rcx), %dl
cmpb $0xa, %dl
setne %sil
decq %rax
cmpq %rcx, %rax
sete %al
orb %sil, %al
je 0x61bea
movb %dl, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x253e0
jmp 0x61c14
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x253e0
movb $0x9, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x253e0
movzwl %r13w, %ecx
movq 0x8(%r14), %rax
incl %r13d
cmpq %rcx, %rax
ja 0x61bb9
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x25480
movq 0xd3380(%rip), %rsi # 0x134fb8
leaq 0x8(%rsp), %rdi
callq 0x25280
leaq 0x88(%rsp), %rdi
callq 0x25120
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x61c62
movq %rax, %rbx
movq 0xd334c(%rip), %rsi # 0x134fb8
leaq 0x8(%rsp), %rdi
callq 0x25280
leaq 0x88(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/././../Simulation_Management/././././.././././.././Extras/KUtils.h |
KDIS::PDU::Comment_R_PDU::GetAsString[abi:cxx11]() const | KString Comment_R_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Comment PDU-R -\n"
<< Simulation_Management_Header::GetAsString()
<< "\nNumber Fixed Datum: " << m_ui32NumFixedDatum
<< "\nNumber Variable Datum: " << m_ui32NumVariableDatum
<< "\n";
ss << "Fixed Datum\n";
vector<FixDtmPtr>::const_iterator citrFixed = m_vFixedDatum.begin();
vector<FixDtmPtr>::const_iterator citrFixedEnd = m_vFixedDatum.end();
for( ; citrFixed != citrFixedEnd; ++citrFixed )
{
ss << IndentString( ( *citrFixed )->GetAsString() );
}
ss << "Variable Datum\n";
vector<VarDtmPtr>::const_iterator citrVar = m_vVariableDatum.begin();
vector<VarDtmPtr>::const_iterator citrVarEnd = m_vVariableDatum.end();
for( ; citrVar != citrVarEnd; ++citrVar )
{
ss << IndentString( ( *citrVar )->GetAsString() );
}
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp # imm = 0x1D8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x50(%rsp), %rdi
callq 0x25250
movq %rsp, %rdi
movq %r14, %rsi
callq 0x2b662
leaq 0x60(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x253e0
movq %rax, %r12
leaq 0x5cff6(%rip), %rsi # 0xbedcb
movl $0x11, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x5ed86
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x5cb7d(%rip), %rsi # 0xbe988
movl $0x1d, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x48(%r14), %esi
movq %r12, %rdi
callq 0x25220
movq %rax, %r12
leaq 0x5cb78(%rip), %rsi # 0xbe9a6
movl $0x1d, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x4c(%r14), %esi
movq %r12, %rdi
callq 0x25220
leaq 0x5cc78(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
movq %rbx, 0x40(%rsp)
leaq 0x30(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x61e7b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x10(%rsp), %rbx
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x61e96
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x5cb27(%rip), %rsi # 0xbe9c4
movl $0xc, %edx
leaq 0x60(%rsp), %rdi
callq 0x253e0
movq 0x50(%r14), %r15
movq %r14, 0x48(%rsp)
movq 0x58(%r14), %r14
cmpq %r14, %r15
je 0x61f27
leaq 0x20(%rsp), %r12
movq %rsp, %r13
movq 0x8(%r15), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x10(%rax)
movq %r13, %rdi
movq %r12, %rsi
callq 0x620a5
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x253e0
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x61f07
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x61f1e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
addq $0x18, %r15
cmpq %r14, %r15
jne 0x61ec6
leaq 0x5caa3(%rip), %rsi # 0xbe9d1
movl $0xf, %edx
leaq 0x60(%rsp), %rdi
callq 0x253e0
movq 0x48(%rsp), %rax
movq 0x68(%rax), %r13
movq 0x70(%rax), %r14
cmpq %r14, %r13
je 0x61fb8
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movq 0x8(%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x620a5
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x253e0
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x61f98
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x61faf
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
addq $0x18, %r13
cmpq %r14, %r13
jne 0x61f57
leaq 0x68(%rsp), %rsi
movq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x25480
movq 0xd2fe7(%rip), %rsi # 0x134fb8
leaq 0x50(%rsp), %rdi
callq 0x25280
leaq 0xd0(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x1d8, %rsp # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x62045
jmp 0x62045
jmp 0x62045
jmp 0x62007
jmp 0x62045
movq %rax, %r14
jmp 0x6202a
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6202a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6207f
movq 0x10(%rsp), %rsi
jmp 0x62077
jmp 0x62045
jmp 0x6204a
jmp 0x6204f
movq %rax, %r14
jmp 0x6207f
movq %rax, %r14
jmp 0x62068
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x62068
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6207f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0xd2f32(%rip), %rsi # 0x134fb8
leaq 0x50(%rsp), %rdi
callq 0x25280
leaq 0xd0(%rsp), %rdi
callq 0x25120
movq %r14, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Comment_R_PDU.cpp |
non-virtual thunk to KDIS::PDU::Create_Entity_R_PDU::GetAsString[abi:cxx11]() const | KString Create_Entity_R_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Create Entity-R PDU-\n"
<< Simulation_Management_Header::GetAsString()
<< Reliability_Header::GetAsString()
<< "Request ID: " << m_ui32RequestID
<< "\n";
return ss.str();
} | pushq %rbx
movq %rdi, %rbx
addq $-0x50, %rsi
callq 0x62444
movq %rbx, %rax
popq %rbx
retq
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Create_Entity_R_PDU.cpp |
KDIS::PDU::Data_Query_R_PDU::GetAsString[abi:cxx11]() const | KString Data_Query_R_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Data Query PDU-R-\n"
<< Simulation_Management_Header::GetAsString()
<< Reliability_Header::GetAsString()
<< "Request ID: " << m_ui32RequestID
<< "\nTime Interval: \n" << IndentString( m_TimeInterval.GetAsString() )
<< "\nNumber Fixed Datum: " << m_ui32NumFixedDatum
<< "\nNumber Variable Datum: " << m_ui32NumVariableDatum
<< "\n";
ss << "Fixed Datum ID's\n";
vector<KUINT32>::const_iterator citrFixed = m_vFixedDatum.begin();
vector<KUINT32>::const_iterator citrFixedEnd = m_vFixedDatum.end();
for( ; citrFixed != citrFixedEnd; ++citrFixed )
{
ss << "\t" << *citrFixed << "\n";
}
ss << "Variable Datum ID's\n";
vector<KUINT32>::const_iterator citrVar = m_vVariableDatum.begin();
vector<KUINT32>::const_iterator citrVarEnd = m_vVariableDatum.end();
for( ; citrVar != citrVarEnd; ++citrVar )
{
ss << "\t" << *citrVar << "\n";
}
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3c8, %rsp # imm = 0x3C8
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
leaq 0xb8(%rsp), %rdi
callq 0x25250
leaq 0x98(%rsp), %rdi
movq %r15, %rsi
callq 0x2b662
leaq 0xc8(%rsp), %r14
movq 0x98(%rsp), %rsi
movq 0xa0(%rsp), %rdx
movq %r14, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x5c43e(%rip), %rsi # 0xbee30
movl $0x13, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x78(%rsp), %rdi
movq %r15, %rsi
callq 0x5ed86
movq 0x78(%rsp), %rsi
movq 0x80(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x98(%r15), %rsi
leaq 0x58(%rsp), %rdi
callq 0x656a4
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x5a721(%rip), %rsi # 0xbd172
movl $0x1e, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x48(%r15), %esi
movq %r12, %rdi
callq 0x25220
movq %rax, %r12
leaq 0x5c037(%rip), %rsi # 0xbeaab
movl $0x1c, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x50(%r15), %rsi
leaq 0x18(%rsp), %rdi
callq 0x2b00a
leaq 0x240(%rsp), %rdi
callq 0x25250
leaq 0x250(%rsp), %r13
leaq 0xf(%rsp), %rsi
movb $0x9, (%rsi)
movl $0x1, %edx
movq %r13, %rdi
callq 0x253e0
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x62b32
movw $0x1, %bx
xorl %ecx, %ecx
leaq 0xf(%rsp), %rbp
movq 0x18(%rsp), %rdx
movb (%rdx,%rcx), %dl
decq %rax
cmpq %rcx, %rax
je 0x62b0f
cmpb $0xa, %dl
jne 0x62b0f
movb $0xa, 0xf(%rsp)
movl $0x1, %edx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x253e0
movb $0x9, 0xf(%rsp)
movl $0x1, %edx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x253e0
jmp 0x62b23
movb %dl, 0xf(%rsp)
movl $0x1, %edx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x253e0
movzwl %bx, %ecx
movq 0x20(%rsp), %rax
incl %ebx
cmpq %rcx, %rax
ja 0x62ace
leaq 0x258(%rsp), %rsi
leaq 0x38(%rsp), %rdi
callq 0x25480
movq 0xd246d(%rip), %rsi # 0x134fb8
leaq 0x240(%rsp), %rdi
callq 0x25280
leaq 0x2c0(%rsp), %rdi
callq 0x25120
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x5be07(%rip), %rsi # 0xbe988
movl $0x1d, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x60(%r15), %esi
movq %r12, %rdi
callq 0x25220
movq %rax, %r12
leaq 0x5be02(%rip), %rsi # 0xbe9a6
movl $0x1d, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x64(%r15), %esi
movq %r12, %rdi
callq 0x25220
leaq 0x5bf02(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62bec
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62c07
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62c22
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62c43
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xa8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62c64
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x5be5d(%rip), %rsi # 0xbeac8
movl $0x11, %edx
movq %r14, %rdi
callq 0x253e0
movq 0x68(%r15), %rbx
movq 0x70(%r15), %rbp
cmpq %rbp, %rbx
je 0x62cc6
leaq 0x5f84d(%rip), %r12 # 0xc24d9
leaq 0x5be33(%rip), %r13 # 0xbeac6
movl $0x1, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x253e0
movl (%rbx), %esi
movq %r14, %rdi
callq 0x25220
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x253e0
addq $0x4, %rbx
cmpq %rbp, %rbx
jne 0x62c93
leaq 0x5be0d(%rip), %rsi # 0xbeada
movl $0x14, %edx
movq %r14, %rdi
callq 0x253e0
movq 0x80(%r15), %rbx
movq 0x88(%r15), %r13
cmpq %r13, %rbx
je 0x62d2e
leaq 0x5f7e5(%rip), %r15 # 0xc24d9
leaq 0x5bdcb(%rip), %r12 # 0xbeac6
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x253e0
movl (%rbx), %esi
movq %r14, %rdi
callq 0x25220
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x253e0
addq $0x4, %rbx
cmpq %r13, %rbx
jne 0x62cfb
leaq 0xd0(%rsp), %rsi
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x25480
movq 0xd226e(%rip), %rsi # 0x134fb8
leaq 0xb8(%rsp), %rdi
callq 0x25280
leaq 0x138(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x3c8, %rsp # imm = 0x3C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x62e6f
jmp 0x62e6f
jmp 0x62e6f
movq %rax, %rbx
jmp 0x62df3
jmp 0x62daa
jmp 0x62d91
movq %rax, %rbx
jmp 0x62e29
jmp 0x62da2
jmp 0x62e6f
jmp 0x62dcf
movq %rax, %rbx
jmp 0x62e4a
movq %rax, %rbx
jmp 0x62e0e
movq %rax, %rbx
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62df3
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x25390
jmp 0x62df3
movq %rax, %rbx
movq 0xd21df(%rip), %rsi # 0x134fb8
leaq 0x240(%rsp), %rdi
callq 0x25280
leaq 0x2c0(%rsp), %rdi
callq 0x25120
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62e0e
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62e29
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62e4a
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0xa8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x62e72
movq 0xa8(%rsp), %rsi
incq %rsi
callq 0x25390
jmp 0x62e72
jmp 0x62e6f
movq %rax, %rbx
movq 0xd213f(%rip), %rsi # 0x134fb8
leaq 0xb8(%rsp), %rdi
callq 0x25280
leaq 0x138(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Data_Query_R_PDU.cpp |
non-virtual thunk to KDIS::PDU::Data_Query_R_PDU::Encode(KDIS::KDataStream&) const | void Data_Query_R_PDU::Encode( KDataStream & stream ) const
{
Simulation_Management_Header::Encode( stream );
Reliability_Header::Encode( stream );
stream << m_ui32RequestID
<< KDIS_STREAM m_TimeInterval
<< m_ui32NumFixedDatum
<< m_ui32NumVariableDatum;
vector<KUINT32>::const_iterator citrFixed = m_vFixedDatum.begin();
vector<KUINT32>::const_iterator citrFixedEnd = m_vFixedDatum.end();
for( ; citrFixed != citrFixedEnd; ++citrFixed )
{
stream << *citrFixed;
}
vector<KUINT32>::const_iterator citrVar = m_vVariableDatum.begin();
vector<KUINT32>::const_iterator citrVarEnd = m_vVariableDatum.end();
for( ; citrVar != citrVarEnd; ++citrVar )
{
stream << *citrVar;
}
} | addq $-0x98, %rdi
jmp 0x630c8
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Data_Query_R_PDU.cpp |
KDIS::PDU::Data_R_PDU::GetAsString[abi:cxx11]() const | KString Data_R_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Data PDU-\n"
<< Simulation_Management_Header::GetAsString()
<< "\tRequest ID: " << m_ui32RequestID
<< Reliability_Header::GetAsString()
<< "\n\tNumber Fixed Datum: " << m_ui32NumFixedDatum
<< "\n\tNumber Variable Datum: " << m_ui32NumVariableDatum
<< "\n";
ss << "Fixed Datumn";
vector<FixDtmPtr>::const_iterator citrFixed = m_vFixedDatum.begin();
vector<FixDtmPtr>::const_iterator citrFixedEnd = m_vFixedDatum.end();
for( ; citrFixed != citrFixedEnd; ++citrFixed )
{
ss << IndentString( ( *citrFixed )->GetAsString() );
}
ss << "Variable Datumn";
vector<VarDtmPtr>::const_iterator citrVar = m_vVariableDatum.begin();
vector<VarDtmPtr>::const_iterator citrVarEnd = m_vVariableDatum.end();
for( ; citrVar != citrVarEnd; ++citrVar )
{
ss << IndentString( ( *citrVar )->GetAsString() );
}
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x70(%rsp), %rdi
callq 0x25250
movq %rsp, %rdi
movq %r14, %rsi
callq 0x2b662
leaq 0x80(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x253e0
movq %rax, %r12
leaq 0x5b5d2(%rip), %rsi # 0xbea2e
movl $0xb, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x5ed86
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x5b9d0(%rip), %rsi # 0xbee62
movl $0x1c, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x80(%r14), %esi
movq %r12, %rdi
callq 0x25220
movq %rax, %r12
leaq 0x88(%r14), %rsi
leaq 0x50(%rsp), %rdi
callq 0x656a4
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x5b9a1(%rip), %rsi # 0xbee7f
movl $0x1d, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x48(%r14), %esi
movq %r12, %rdi
callq 0x25220
movq %rax, %r12
leaq 0x5b99c(%rip), %rsi # 0xbee9d
movl $0x1d, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x4c(%r14), %esi
movq %r12, %rdi
callq 0x25220
leaq 0x5b5a5(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x63549
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x25390
movq %rbx, 0x40(%rsp)
leaq 0x30(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x63569
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x10(%rsp), %rbx
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x63584
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x5b800(%rip), %rsi # 0xbed8b
movl $0xc, %edx
leaq 0x80(%rsp), %rdi
callq 0x253e0
movq 0x50(%r14), %r15
movq %r14, 0x48(%rsp)
movq 0x58(%r14), %r14
cmpq %r14, %r15
je 0x6361b
leaq 0x20(%rsp), %r12
movq %rsp, %r13
movq 0x8(%r15), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x10(%rax)
movq %r13, %rdi
movq %r12, %rsi
callq 0x637c4
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0x253e0
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x635fb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x63612
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
addq $0x18, %r15
cmpq %r14, %r15
jne 0x635b7
leaq 0x5b776(%rip), %rsi # 0xbed98
movl $0xf, %edx
leaq 0x80(%rsp), %rdi
callq 0x253e0
movq 0x48(%rsp), %rax
movq 0x68(%rax), %r13
movq 0x70(%rax), %r14
cmpq %r14, %r13
je 0x636b2
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movq 0x8(%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x637c4
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0x253e0
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x63692
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x636a9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
addq $0x18, %r13
cmpq %r14, %r13
jne 0x6364e
leaq 0x88(%rsp), %rsi
movq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x25480
movq 0xd18ea(%rip), %rsi # 0x134fb8
leaq 0x70(%rsp), %rdi
callq 0x25280
leaq 0xf0(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x1f8, %rsp # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x63764
jmp 0x63764
jmp 0x63764
jmp 0x6370b
jmp 0x63706
jmp 0x63764
movq %rax, %r14
jmp 0x63749
movq %rax, %r14
jmp 0x6372e
movq %rax, %r14
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6372e
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x63749
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6379e
movq 0x10(%rsp), %rsi
jmp 0x63796
jmp 0x63764
jmp 0x63769
jmp 0x6376e
movq %rax, %r14
jmp 0x6379e
movq %rax, %r14
jmp 0x63787
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x63787
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x6379e
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0xd1813(%rip), %rsi # 0x134fb8
leaq 0x70(%rsp), %rdi
callq 0x25280
leaq 0xf0(%rsp), %rdi
callq 0x25120
movq %r14, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Data_R_PDU.cpp |
KDIS::PDU::Data_R_PDU::Encode(KDIS::KDataStream&) const | void Data_R_PDU::Encode( KDataStream & stream ) const
{
Simulation_Management_Header::Encode( stream );
stream << m_ui32RequestID;
Reliability_Header::Encode( stream );
stream << m_ui32NumFixedDatum
<< m_ui32NumVariableDatum;
vector<FixDtmPtr>::const_iterator citrFixed = m_vFixedDatum.begin();
vector<FixDtmPtr>::const_iterator citrFixedEnd = m_vFixedDatum.end();
for( ; citrFixed != citrFixedEnd; ++citrFixed )
{
( *citrFixed )->Encode( stream );
}
vector<VarDtmPtr>::const_iterator citrVar = m_vVariableDatum.begin();
vector<VarDtmPtr>::const_iterator citrVarEnd = m_vVariableDatum.end();
for( ; citrVar != citrVarEnd; ++citrVar )
{
( *citrVar )->Encode( stream );
}
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5f20c
movl 0x80(%r14), %esi
movq %rbx, %rdi
callq 0x2b2fa
leaq 0x88(%r14), %rdi
movq %rbx, %rsi
callq 0x658cc
movl 0x48(%r14), %esi
movq %rbx, %rdi
callq 0x2b2fa
movl 0x4c(%r14), %esi
movq %rbx, %rdi
callq 0x2b2fa
movq 0x50(%r14), %r15
movq 0x58(%r14), %r12
cmpq %r12, %r15
je 0x63cf5
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x28(%rax)
addq $0x18, %r15
jmp 0x63cdd
movq 0x68(%r14), %r15
movq 0x70(%r14), %r14
cmpq %r14, %r15
je 0x63d15
movq 0x8(%r15), %rdi
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x28(%rax)
addq $0x18, %r15
jmp 0x63cfd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Data_R_PDU.cpp |
non-virtual thunk to KDIS::PDU::Data_R_PDU::Encode(KDIS::KDataStream&) const | void Data_R_PDU::Encode( KDataStream & stream ) const
{
Simulation_Management_Header::Encode( stream );
stream << m_ui32RequestID;
Reliability_Header::Encode( stream );
stream << m_ui32NumFixedDatum
<< m_ui32NumVariableDatum;
vector<FixDtmPtr>::const_iterator citrFixed = m_vFixedDatum.begin();
vector<FixDtmPtr>::const_iterator citrFixedEnd = m_vFixedDatum.end();
for( ; citrFixed != citrFixedEnd; ++citrFixed )
{
( *citrFixed )->Encode( stream );
}
vector<VarDtmPtr>::const_iterator citrVar = m_vVariableDatum.begin();
vector<VarDtmPtr>::const_iterator citrVarEnd = m_vVariableDatum.end();
for( ; citrVar != citrVarEnd; ++citrVar )
{
( *citrVar )->Encode( stream );
}
} | addq $-0x88, %rdi
jmp 0x63c8c
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Data_R_PDU.cpp |
KDIS::PDU::Event_Report_R_PDU::GetAsString[abi:cxx11]() const | KString Event_Report_R_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Event Report-R PDU-\n"
<< Simulation_Management_Header::GetAsString()
<< "Event Type: " << GetEnumAsStringEventType( m_ui32EventType )
<< "\nNumber Fixed Datum: " << m_ui32NumFixedDatum
<< "\nNumber Variable Datum: " << m_ui32NumVariableDatum
<< "\n";
ss << "Fixed Datumn";
vector<FixDtmPtr>::const_iterator citrFixed = m_vFixedDatum.begin();
vector<FixDtmPtr>::const_iterator citrFixedEnd = m_vFixedDatum.end();
for( ; citrFixed != citrFixedEnd; ++citrFixed )
{
ss << IndentString( ( *citrFixed )->GetAsString() );
}
ss << "Variable Datumn";
vector<VarDtmPtr>::const_iterator citrVar = m_vVariableDatum.begin();
vector<VarDtmPtr>::const_iterator citrVarEnd = m_vVariableDatum.end();
for( ; citrVar != citrVarEnd; ++citrVar )
{
ss << IndentString( ( *citrVar )->GetAsString() );
}
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1f8, %rsp # imm = 0x1F8
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x70(%rsp), %rdi
callq 0x25250
movq %rsp, %rdi
movq %r14, %rsi
callq 0x2b662
leaq 0x80(%rsp), %rdi
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x253e0
movq %rax, %r12
leaq 0x5b00f(%rip), %rsi # 0xbeed3
movl $0x15, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x5ed86
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x5ac25(%rip), %rsi # 0xbeb1f
movl $0x1c, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x80(%r14), %esi
leaq 0x50(%rsp), %rdi
callq 0xb1241
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x5aa54(%rip), %rsi # 0xbe988
movl $0x1d, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x48(%r14), %esi
movq %r12, %rdi
callq 0x25220
movq %rax, %r12
leaq 0x5aa4f(%rip), %rsi # 0xbe9a6
movl $0x1d, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x4c(%r14), %esi
movq %r12, %rdi
callq 0x25220
leaq 0x5ab4f(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x63f9f
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x25390
movq %rbx, 0x40(%rsp)
leaq 0x30(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x63fbf
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x10(%rsp), %rbx
movq -0x10(%rbx), %rdi
cmpq %rbx, %rdi
je 0x63fda
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x5adaa(%rip), %rsi # 0xbed8b
movl $0xc, %edx
leaq 0x80(%rsp), %rdi
callq 0x253e0
movq 0x50(%r14), %r15
movq %r14, 0x48(%rsp)
movq 0x58(%r14), %r14
cmpq %r14, %r15
je 0x64071
leaq 0x20(%rsp), %r12
movq %rsp, %r13
movq 0x8(%r15), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x10(%rax)
movq %r13, %rdi
movq %r12, %rsi
callq 0x6421a
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0x253e0
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x64051
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x64068
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
addq $0x18, %r15
cmpq %r14, %r15
jne 0x6400d
leaq 0x5ad20(%rip), %rsi # 0xbed98
movl $0xf, %edx
leaq 0x80(%rsp), %rdi
callq 0x253e0
movq 0x48(%rsp), %rax
movq 0x68(%rax), %r13
movq 0x70(%rax), %r14
cmpq %r14, %r13
je 0x64108
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movq 0x8(%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x10(%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x6421a
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0x253e0
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x640e8
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x640ff
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
addq $0x18, %r13
cmpq %r14, %r13
jne 0x640a4
leaq 0x88(%rsp), %rsi
movq 0x40(%rsp), %rbx
movq %rbx, %rdi
callq 0x25480
movq 0xd0e94(%rip), %rsi # 0x134fb8
leaq 0x70(%rsp), %rdi
callq 0x25280
leaq 0xf0(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x1f8, %rsp # imm = 0x1F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x641ba
jmp 0x641ba
jmp 0x641ba
jmp 0x6415c
jmp 0x64161
jmp 0x641ba
movq %rax, %r14
jmp 0x64184
movq %rax, %r14
jmp 0x6419f
movq %rax, %r14
leaq 0x60(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x64184
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6419f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x641f4
movq 0x10(%rsp), %rsi
jmp 0x641ec
jmp 0x641ba
jmp 0x641bf
jmp 0x641c4
movq %rax, %r14
jmp 0x641f4
movq %rax, %r14
jmp 0x641dd
movq %rax, %r14
movq (%rsp), %rdi
cmpq %rbx, %rdi
je 0x641dd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x641f4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0xd0dbd(%rip), %rsi # 0x134fb8
leaq 0x70(%rsp), %rdi
callq 0x25280
leaq 0xf0(%rsp), %rdi
callq 0x25120
movq %r14, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Event_Report_R_PDU.cpp |
KDIS::UTILS::IndentString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned short, char) | static inline KString IndentString( const KString & S, KUINT16 Tabs = 1, KCHAR8 Tab = '\t' )
{
KStringStream NewS;
// Add tab to first item and then check all new lines
AddTabsToStringStream( NewS, Tabs, Tab );
for( KUINT16 i = 0; i < S.size(); ++i )
{
if( S.c_str()[i] == '\n' && i != ( S.size() - 1 ) )
{
NewS << S.c_str()[i];
AddTabsToStringStream( NewS, Tabs, Tab );
}
else
{
NewS << S.c_str()[i];
}
}
return NewS.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25250
leaq 0x18(%rsp), %r15
leaq 0x7(%rsp), %rsi
movb $0x9, (%rsi)
movl $0x1, %edx
movq %r15, %rdi
callq 0x253e0
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x642d4
movw $0x1, %r13w
xorl %ecx, %ecx
leaq 0x7(%rsp), %r12
movq (%r14), %rdx
movb (%rdx,%rcx), %dl
cmpb $0xa, %dl
setne %sil
decq %rax
cmpq %rcx, %rax
sete %al
orb %sil, %al
je 0x6429a
movb %dl, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x253e0
jmp 0x642c4
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x253e0
movb $0x9, 0x7(%rsp)
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x253e0
movzwl %r13w, %ecx
movq 0x8(%r14), %rax
incl %r13d
cmpq %rcx, %rax
ja 0x64269
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x25480
movq 0xd0cd0(%rip), %rsi # 0x134fb8
leaq 0x8(%rsp), %rdi
callq 0x25280
leaq 0x88(%rsp), %rdi
callq 0x25120
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x64312
movq %rax, %rbx
movq 0xd0c9c(%rip), %rsi # 0x134fb8
leaq 0x8(%rsp), %rdi
callq 0x25280
leaq 0x88(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/././../Simulation_Management/./././.././././.././Extras/KUtils.h |
KDIS::PDU::Record_Query_R_PDU::Record_Query_R_PDU(KDIS::KDataStream&) | Record_Query_R_PDU::Record_Query_R_PDU(KDataStream &stream) noexcept(false)
{
Decode( stream, false );
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
callq 0x5e9b0
leaq 0x48(%rbx), %r14
movq %r14, %rdi
callq 0x65648
leaq 0xc08f0(%rip), %rax # 0x124cd0
movq %rax, (%rbx)
leaq 0xc0926(%rip), %rax # 0x124d10
movq %rax, 0x48(%rbx)
leaq 0x68(%rbx), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
movq $0x0, 0x78(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x649ec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq (%r12), %rdi
testq %rdi, %rdi
je 0x64432
movq 0x78(%rbx), %rsi
subq %rdi, %rsi
callq 0x25390
movq %r14, %rdi
callq 0x6568c
jmp 0x6443f
movq %rax, %r15
movq %rbx, %rdi
callq 0x5ed0c
movq %r15, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Record_Query_R_PDU.cpp |
KDIS::PDU::Record_Query_R_PDU::SetRecordIDs(std::vector<unsigned int, std::allocator<unsigned int>> const&) | void Record_Query_R_PDU::SetRecordIDs( const vector<KUINT32> & ID )
{
m_vui32RecID.clear();
m_vui32RecID = ID;
m_ui32NumRecs = m_vui32RecID.size();
m_ui16PDULength = RECORD_QUERY_R_PDU_SIZE + ( m_ui32NumRecs * 4 );
} | pushq %rbx
movq %rdi, %rbx
addq $0x68, %rdi
movq 0x68(%rbx), %rax
cmpq %rax, 0x70(%rbx)
je 0x64676
movq %rax, 0x70(%rbx)
callq 0x5d514
movq 0x70(%rbx), %rax
subq 0x68(%rbx), %rax
shrq $0x2, %rax
movl %eax, 0x64(%rbx)
leal 0x28(,%rax,4), %eax
movw %ax, 0x20(%rbx)
popq %rbx
retq
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Record_Query_R_PDU.cpp |
KDIS::PDU::Record_Query_R_PDU::GetAsString[abi:cxx11]() const | KString Record_Query_R_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Record Query-R PDU-\n"
<< Simulation_Management_Header::GetAsString()
<< "\tRequest ID: " << m_ui32RqId
<< Reliability_Header::GetAsString()
<< "\tEvent Type: " << GetEnumAsStringEventType( m_ui16EvntTyp ) << "\n"
<< "\tTime: " << m_ui32Time << "\n"
<< "\tNumber Of Record IDs: " << m_ui32NumRecs << "\n";
vector<KUINT32>::const_iterator citr = m_vui32RecID.begin();
vector<KUINT32>::const_iterator citrEnd = m_vui32RecID.end();
for( ; citr != citrEnd; ++citr )
{
ss << "\t" << *citr << "\n";
}
return ss.str();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp # imm = 0x208
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x80(%rsp), %rdi
callq 0x25250
leaq 0x60(%rsp), %rdi
movq %r15, %rsi
callq 0x2b662
leaq 0x90(%rsp), %r14
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq %r14, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x5a816(%rip), %rsi # 0xbef09
movl $0x15, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x5ed86
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x5a739(%rip), %rsi # 0xbee62
movl $0x1c, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x58(%r15), %esi
movq %r12, %rdi
callq 0x25220
movq %rax, %r12
leaq 0x48(%r15), %rsi
leaq 0x20(%rsp), %rdi
callq 0x656a4
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x5a7b0(%rip), %rsi # 0xbef1f
movl $0x1c, %edx
movq %rax, %rdi
callq 0x253e0
movzwl 0x5c(%r15), %esi
movq %rsp, %rdi
callq 0xb1241
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x253e0
movq %rax, %r12
leaq 0x5a322(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x5a784(%rip), %rsi # 0xbef3c
movl $0x1c, %edx
movq %r12, %rdi
callq 0x253e0
movl 0x60(%r15), %esi
movq %r12, %rdi
callq 0x25220
movq %rax, %r12
leaq 0x5a2eb(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x5a76a(%rip), %rsi # 0xbef59
movl $0x1c, %edx
movq %r12, %rdi
callq 0x253e0
movl 0x64(%r15), %esi
movq %r12, %rdi
callq 0x25220
leaq 0x5a2b7(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x64837
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x64852
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6486d
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x64888
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x68(%r15), %r13
movq 0x70(%r15), %rbp
cmpq %rbp, %r13
je 0x648d8
leaq 0x5dc3d(%rip), %r15 # 0xc24d9
leaq 0x5a223(%rip), %r12 # 0xbeac6
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x253e0
movl (%r13), %esi
movq %r14, %rdi
callq 0x25220
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x253e0
addq $0x4, %r13
cmpq %rbp, %r13
jne 0x648a3
leaq 0x98(%rsp), %rsi
movq %rbx, %rdi
callq 0x25480
movq 0xd06c9(%rip), %rsi # 0x134fb8
leaq 0x80(%rsp), %rdi
callq 0x25280
leaq 0x100(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x208, %rsp # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x649ae
jmp 0x6492e
jmp 0x64938
jmp 0x64933
jmp 0x649ae
movq %rax, %rbx
jmp 0x6495b
movq %rax, %rbx
jmp 0x64991
movq %rax, %rbx
jmp 0x64976
movq %rax, %rbx
leaq 0x10(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6495b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x64976
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x64991
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x649b1
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x25390
jmp 0x649b1
movq %rax, %rbx
movq 0xd0600(%rip), %rsi # 0x134fb8
leaq 0x80(%rsp), %rdi
callq 0x25280
leaq 0x100(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Record_Query_R_PDU.cpp |
KDIS::PDU::Record_Query_R_PDU::Encode(KDIS::KDataStream&) const | void Record_Query_R_PDU::Encode( KDataStream & stream ) const
{
Simulation_Management_Header::Encode( stream );
stream << m_ui32RqId
<< m_ui8ReqRelSrv
<< m_ui8Padding
<< m_ui16EvntTyp
<< m_ui32Time
<< m_ui32NumRecs;
vector<KUINT32>::const_iterator citr = m_vui32RecID.begin();
vector<KUINT32>::const_iterator citrEnd = m_vui32RecID.end();
for( ; citr != citrEnd; ++citr )
{
stream << *citr;
}
} | pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x5f20c
movl 0x58(%r14), %esi
movq %rbx, %rdi
callq 0x2b2fa
movzbl 0x50(%r14), %esi
movq %rbx, %rdi
callq 0x26a4c
movzbl 0x54(%r14), %esi
movq %rbx, %rdi
callq 0x26a4c
movzwl 0x5c(%r14), %esi
movq %rbx, %rdi
callq 0x29f54
movl 0x60(%r14), %esi
movq %rbx, %rdi
callq 0x2b2fa
movl 0x64(%r14), %esi
movq %rbx, %rdi
callq 0x2b2fa
movq 0x68(%r14), %r15
movq 0x70(%r14), %r14
cmpq %r14, %r15
je 0x64c29
movl (%r15), %esi
movq %rbx, %rdi
callq 0x2b2fa
addq $0x4, %r15
jmp 0x64c13
popq %rbx
popq %r14
popq %r15
retq
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Record_Query_R_PDU.cpp |
non-virtual thunk to KDIS::PDU::Record_Query_R_PDU::Encode(KDIS::KDataStream&) const | void Record_Query_R_PDU::Encode( KDataStream & stream ) const
{
Simulation_Management_Header::Encode( stream );
stream << m_ui32RqId
<< m_ui8ReqRelSrv
<< m_ui8Padding
<< m_ui16EvntTyp
<< m_ui32Time
<< m_ui32NumRecs;
vector<KUINT32>::const_iterator citr = m_vui32RecID.begin();
vector<KUINT32>::const_iterator citrEnd = m_vui32RecID.end();
for( ; citr != citrEnd; ++citr )
{
stream << *citr;
}
} | addq $-0x48, %rdi
jmp 0x64bb0
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Record_Query_R_PDU.cpp |
non-virtual thunk to KDIS::PDU::Record_R_PDU::Encode(KDIS::KDataStream&) const | void Record_R_PDU::Encode( KDataStream & stream ) const
{
Simulation_Management_Header::Encode( stream );
stream << m_ui32RqId
<< m_ui8ReqRelSrv
<< m_ui8Padding2
<< m_ui16EvntTyp
<< m_ui32SrlNm
<< m_ui32NumRecSets;
vector<RecordSet>::const_iterator citr = m_vRecs.begin();
vector<RecordSet>::const_iterator citrEnd = m_vRecs.end();
for( ; citr != citrEnd; ++citr )
{
stream << citr->Encode();
}
} | addq $-0x48, %rdi
jmp 0x654ec
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Record_R_PDU.cpp |
KDIS::PDU::Reliability_Header::Decode(KDIS::KDataStream&) | void Reliability_Header::Decode(KDataStream &stream) noexcept(false)
{
if( stream.GetBufferSize() < RELIABILITY_SIZE )throw KException( __FUNCTION__, NOT_ENOUGH_DATA_IN_BUFFER );
stream >> m_ui8ReqRelSrv
>> m_ui16Padding1
>> m_ui8Padding;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x26758
cmpw $0x3, %ax
jbe 0x657ff
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x26a8e
leaq 0xa(%r14), %rsi
movq %rbx, %rdi
callq 0x29ef0
addq $0xc, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x26a8e
movl $0x30, %edi
callq 0x25180
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x55fc8(%rip), %rsi # 0xbb7e4
leaq 0x55fc7(%rip), %rdx # 0xbb7ea
leaq 0x8(%rsp), %rdi
callq 0x2652e
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x2746c
xorl %ebp, %ebp
leaq 0xbd325(%rip), %rsi # 0x122b70
leaq -0x3e966(%rip), %rdx # 0x26eec
movq %rbx, %rdi
callq 0x25500
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x65874
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
testb %bpl, %bpl
jne 0x6587e
jmp 0x65886
movq %rax, %r14
movq %rbx, %rdi
callq 0x25270
movq %r14, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Reliability_Header.cpp |
KDIS::PDU::Remove_Entity_R_PDU::GetAsString[abi:cxx11]() const | KString Remove_Entity_R_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Remove Entity-R PDU-\n"
<< Simulation_Management_Header::GetAsString()
<< Reliability_Header::GetAsString()
<< "Request ID: " << m_ui32RequestID
<< "\n";
return ss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1f0, %rsp # imm = 0x1F0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x68(%rsp), %rdi
callq 0x25250
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x2b662
leaq 0x78(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x253e0
movq %rax, %r15
leaq 0x5954f(%rip), %rsi # 0xbf01a
movl $0x16, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq 0x5ed86
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
movq %rax, %r15
leaq 0x50(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x656a4
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
movq %rax, %r15
leaq 0x5838a(%rip), %rsi # 0xbdeae
movl $0xc, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x48(%r14), %esi
movq %r15, %rdi
callq 0x25220
leaq 0x58f82(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65b6c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65b87
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65ba2
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x25480
movq 0xcf3ff(%rip), %rsi # 0x134fb8
leaq 0x68(%rsp), %rdi
callq 0x25280
leaq 0xe8(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x1f0, %rsp # imm = 0x1F0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x65beb
jmp 0x65be4
movq %rax, %rbx
jmp 0x65c13
jmp 0x65bf0
movq %rax, %rbx
jmp 0x65c49
movq %rax, %rbx
jmp 0x65c2e
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65c13
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65c2e
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x65c49
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0xcf368(%rip), %rsi # 0x134fb8
leaq 0x68(%rsp), %rdi
callq 0x25280
leaq 0xe8(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Remove_Entity_R_PDU.cpp |
non-virtual thunk to KDIS::PDU::Remove_Entity_R_PDU::GetAsString[abi:cxx11]() const | KString Remove_Entity_R_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Remove Entity-R PDU-\n"
<< Simulation_Management_Header::GetAsString()
<< Reliability_Header::GetAsString()
<< "Request ID: " << m_ui32RequestID
<< "\n";
return ss.str();
} | pushq %rbx
movq %rdi, %rbx
addq $-0x50, %rsi
callq 0x65a84
movq %rbx, %rax
popq %rbx
retq
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Remove_Entity_R_PDU.cpp |
non-virtual thunk to KDIS::PDU::Set_Data_R_PDU::GetAsString[abi:cxx11]() const | KString Set_Data_R_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Set Data-R PDU-\n"
<< Simulation_Management_Header::GetAsString()
<< Reliability_Header::GetAsString()
<< "Request ID: " << m_ui32RequestID
<< "\nNumber Fixed Datum: " << m_ui32NumFixedDatum
<< "\nNumber Variable Datum: " << m_ui32NumVariableDatum
<< "\n";
ss << "Fixed Datum\n";
vector<FixDtmPtr>::const_iterator citrFixed = m_vFixedDatum.begin();
vector<FixDtmPtr>::const_iterator citrFixedEnd = m_vFixedDatum.end();
for( ; citrFixed != citrFixedEnd; ++citrFixed )
{
ss << IndentString( ( *citrFixed )->GetAsString() );
}
ss << "Variable Datum\n";
vector<VarDtmPtr>::const_iterator citrVar = m_vVariableDatum.begin();
vector<VarDtmPtr>::const_iterator citrVarEnd = m_vVariableDatum.end();
for( ; citrVar != citrVarEnd; ++citrVar )
{
ss << IndentString( ( *citrVar )->GetAsString() );
}
return ss.str();
} | pushq %rbx
movq %rdi, %rbx
addq $-0x88, %rsi
callq 0x65dde
movq %rbx, %rax
popq %rbx
retq
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Set_Data_R_PDU.cpp |
KDIS::PDU::Start_Resume_R_PDU::Decode(KDIS::KDataStream&, bool) | void Start_Resume_R_PDU::Decode(KDataStream &stream, bool ignoreHeader /*= true*/ ) noexcept(false)
{
if( ( stream.GetBufferSize() + ( ignoreHeader ? Header::HEADER6_PDU_SIZE : 0 ) ) < START_RESUME_R_PDU_SIZE )throw KException( __FUNCTION__, NOT_ENOUGH_DATA_IN_BUFFER );
Simulation_Management_Header::Decode( stream, ignoreHeader );
stream >> KDIS_STREAM m_RealWorldTime
>> KDIS_STREAM m_SimTime;
Reliability_Header::Decode( stream );
stream >> m_ui32RequestID;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x26758
movzwl %ax, %eax
testl %ebp, %ebp
movl $0xc, %ecx
cmovel %ebp, %ecx
addl %eax, %ecx
cmpl $0x2f, %ecx
jbe 0x67978
movzbl %bpl, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x5f0b8
leaq 0x48(%r14), %rdi
movq 0x48(%r14), %rax
movq %rbx, %rsi
callq *0x18(%rax)
leaq 0x58(%r14), %rdi
movq 0x58(%r14), %rax
movq %rbx, %rsi
callq *0x18(%rax)
leaq 0x70(%r14), %rdi
movq %rbx, %rsi
callq 0x657b0
addq $0x68, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2b290
movl $0x30, %edi
callq 0x25180
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x53e4f(%rip), %rsi # 0xbb7e4
leaq 0x53e4e(%rip), %rdx # 0xbb7ea
leaq 0x8(%rsp), %rdi
callq 0x2652e
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x2746c
xorl %ebp, %ebp
leaq 0xbb1ac(%rip), %rsi # 0x122b70
leaq -0x40adf(%rip), %rdx # 0x26eec
movq %rbx, %rdi
callq 0x25500
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x679ed
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
testb %bpl, %bpl
jne 0x679f7
jmp 0x679ff
movq %rax, %r14
movq %rbx, %rdi
callq 0x25270
movq %r14, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Start_Resume_R_PDU.cpp |
non-virtual thunk to KDIS::PDU::Stop_Freeze_R_PDU::GetAsString[abi:cxx11]() const | KString Stop_Freeze_R_PDU::GetAsString() const
{
KStringStream ss;
ss << Header::GetAsString()
<< "-Stop/Freeze-R PDU-\n"
<< Simulation_Management_Header::GetAsString()
<< "Real World Time:\n"
<< IndentString( m_RealWorldTime.GetAsString(), 1 )
<< "\tReason: " << GetEnumAsStringStopFreezeReason( m_ui8Reason )
<< "\n\tFrozen Behavior: " << GetEnumAsStringFrozenBehavior( m_ui8FrozenBehaviour )
<< "\n" << Reliability_Header::GetAsString()
<< "\n\tRequest ID: " << m_ui32RequestID
<< "\n";
return ss.str();
} | pushq %rbx
movq %rdi, %rbx
addq $-0x60, %rsi
callq 0x67d26
movq %rbx, %rax
popq %rbx
retq
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Stop_Freeze_R_PDU.cpp |
non-virtual thunk to KDIS::PDU::Stop_Freeze_R_PDU::Encode(KDIS::KDataStream&) const | void Stop_Freeze_R_PDU::Encode( KDataStream & stream ) const
{
Simulation_Management_Header::Encode( stream );
stream << KDIS_STREAM m_RealWorldTime
<< m_ui8Reason
<< m_ui8FrozenBehaviour
<< m_ui8ReqRelSrv
<< m_ui8Padding2
<< m_ui32RequestID;
} | addq $-0x60, %rdi
jmp 0x6838c
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Simulation_Management_With_Reliability/Stop_Freeze_R_PDU.cpp |
KDIS::PDU::Areal_Object_State_PDU::SetObjectType(KDIS::DATA_TYPE::ObjectType const&) | class KDIS_EXPORT ObjectType : public DataTypeBase
{
protected:
KUINT8 m_ui8Domain;
KUINT8 m_ui8EntityKind;
KUINT8 m_ui8Category;
KUINT8 m_ui8SubCategory;
public:
static const KUINT16 OBJECT_TYPE_SIZE = 4;
ObjectType();
ObjectType( KUINT8 Domain, KUINT8 Kind, KUINT8 Categoy, KUINT8 SubCategory );
ObjectType(KDataStream &stream) noexcept(false);
virtual ~ObjectType();
//************************************
// FullName: KDIS::DATA_TYPE::ObjectType::SetDomain
// KDIS::DATA_TYPE::ObjectType::GetDomain
// Description: Objects domain.
// Parameter: EntityDomain UI
//************************************
void SetDomain( KDIS::DATA_TYPE::ENUMS::EntityDomain UI );
KDIS::DATA_TYPE::ENUMS::EntityDomain GetDomain() const;
//************************************
// FullName: KDIS::DATA_TYPE::ObjectType::SetEntityKind
// KDIS::DATA_TYPE::ObjectType::GetEntityKind
// Description: Object Kind.
// Parameter: KUINT8 UI
//************************************
void SetEntityKind( KUINT8 UI );
KUINT8 GetEntityKind() const;
//************************************
// FullName: KDIS::DATA_TYPE::ObjectType::SetCategory
// KDIS::DATA_TYPE::ObjectType::GetCategory
// Description: Category.
// Parameter: KUINT8 UI
//************************************
void SetCategory( KUINT8 UI );
KUINT8 GetCategory() const;
//************************************
// FullName: KDIS::DATA_TYPE::ObjectType::SetSubCategory
// KDIS::DATA_TYPE::ObjectType::GetSubCategory
// Description: Sub Category.
// Parameter: KUINT8 UI
//************************************
void SetSubCategory( KUINT8 UI );
KUINT8 GetSubCategory() const;
//************************************
// FullName: KDIS::DATA_TYPE::ObjectType::GetAsString
// Description: Returns a string representation.
//************************************
virtual KString GetAsString() const;
//************************************
// FullName: KDIS::DATA_TYPE::ObjectType::Decode
// Description: Convert From Network Data.
// Parameter: KDataStream & stream
//************************************
virtual void Decode(KDataStream &stream) noexcept(false);
//************************************
// FullName: KDIS::DATA_TYPE::ObjectType::Encode
// Description: Convert To Network Data.
// Parameter: KDataStream & stream
//************************************
virtual KDataStream Encode() const;
virtual void Encode( KDataStream & stream ) const;
KBOOL operator == ( const ObjectType & Value ) const;
KBOOL operator != ( const ObjectType & Value ) const;
KBOOL operator < ( const ObjectType & Value ) const;
} | movl 0x8(%rsi), %eax
movl %eax, 0x58(%rdi)
retq
nop
| /jarvisfriends[P]KDIS/KDIS/PDU/Synthetic_Environment/././../../DataTypes/ObjectType.h |
KDIS::PDU::Areal_Object_State_PDU::AddPoint(KDIS::DATA_TYPE::WorldCoordinates const&) | void Areal_Object_State_PDU::AddPoint( const WorldCoordinates & P )
{
m_ui16PDULength += WorldCoordinates::WORLD_COORDINATES_SIZE;
m_vPoints.push_back( P );
++m_ui16NumPoints;
} | pushq %rbx
movq %rdi, %rbx
addw $0x18, 0x20(%rdi)
movq %rsi, %rdx
movq 0xa0(%rdi), %rsi
cmpq 0xa8(%rdi), %rsi
je 0x68a22
leaq 0xbd817(%rip), %rax # 0x126218
addq $0x10, %rax
movq %rax, (%rsi)
movups 0x8(%rdx), %xmm0
movups %xmm0, 0x8(%rsi)
movq 0x18(%rdx), %rax
movq %rax, 0x18(%rsi)
addq $0x20, 0xa0(%rbx)
jmp 0x68a2e
leaq 0x98(%rbx), %rdi
callq 0x6960e
incw 0x70(%rbx)
popq %rbx
retq
| /jarvisfriends[P]KDIS/KDIS/PDU/Synthetic_Environment/Areal_Object_State_PDU.cpp |
KDIS::PDU::Environmental_Process_PDU::~Environmental_Process_PDU() | Environmental_Process_PDU::~Environmental_Process_PDU()
{
m_vEnvRecords.clear();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0xbb519(%rip), %rax # 0x125228
movq %rax, (%rdi)
leaq 0x50(%rdi), %r14
movq 0x50(%rdi), %r12
movq 0x58(%rdi), %r13
cmpq %r12, %r13
je 0x69d3b
movq %r12, %r15
movq (%r15), %rax
movq %r15, %rdi
callq *(%rax)
addq $0x18, %r15
cmpq %r13, %r15
jne 0x69d26
movq %r12, 0x58(%rbx)
movq %r14, %rdi
callq 0x6a72e
leaq 0x38(%rbx), %rdi
callq 0x8bb06
leaq 0x28(%rbx), %rdi
callq 0x7f1aa
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2b55a
| /jarvisfriends[P]KDIS/KDIS/PDU/Synthetic_Environment/Environmental_Process_PDU.cpp |
KDIS::DATA_TYPE::EmitterBeam::operator==(KDIS::DATA_TYPE::EmitterBeam const&) const | KBOOL EmitterBeam::operator == ( const EmitterBeam & Value ) const
{
if( m_ui8BeamDataLength != Value.m_ui8BeamDataLength ) return false;
if( m_ui8EmitterBeamIDNumber != Value.m_ui8EmitterBeamIDNumber ) return false;
if( m_ui16BeamParamIndex != Value.m_ui16BeamParamIndex ) return false;
if( m_FundamentalParameterData != Value.m_FundamentalParameterData ) return false;
if( m_ui8BeamFunction != Value.m_ui8BeamFunction ) return false;
if( m_ui8NumTargetInTrackJamField != Value.m_ui8NumTargetInTrackJamField ) return false;
if( m_ui8HighDensityTrackJam != Value.m_ui8HighDensityTrackJam ) return false;
#if DIS_VERSION < 7
if( m_ui32JammingModeSequence != Value.m_ui32JammingModeSequence ) return false;
#elif DIS_VERSION > 6
if( m_BeamStatus != Value.m_BeamStatus ) return false;
if( m_JammingTechnique != Value.m_JammingTechnique ) return false;
#endif
if( m_vTrackJamTargets != Value.m_vTrackJamTargets ) return false;
return true;
} | movb 0x8(%rdi), %al
cmpb 0x8(%rsi), %al
jne 0x7d8f7
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movb 0x9(%rdi), %al
cmpb 0x9(%rsi), %al
jne 0x7d8ed
movzwl 0xa(%r14), %eax
cmpw 0xa(%rbx), %ax
jne 0x7d8ed
leaq 0x10(%r14), %rdi
leaq 0x10(%rbx), %rsi
callq 0x81902
testb %al, %al
jne 0x7d8ed
movb 0x40(%r14), %al
cmpb 0x40(%rbx), %al
jne 0x7d8ed
movb 0x41(%r14), %al
cmpb 0x41(%rbx), %al
jne 0x7d8ed
movb 0x42(%r14), %al
cmpb 0x42(%rbx), %al
jne 0x7d8ed
leaq 0x48(%r14), %rdi
leaq 0x48(%rbx), %rsi
callq 0xaaa24
testb %al, %al
jne 0x7d8ed
leaq 0x58(%r14), %rdi
leaq 0x58(%rbx), %rsi
callq 0xac030
testb %al, %al
je 0x7d8fa
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %eax, %eax
retq
addq $0x68, %r14
addq $0x68, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x7d9ad
xorb $0x1, %al
jmp 0x7d8ef
nop
| /jarvisfriends[P]KDIS/KDIS/DataTypes/EmitterBeam.cpp |
KDIS::DATA_TYPE::EntityCapabilities::EntityCapabilities(bool, bool, bool, bool) | EntityCapabilities::EntityCapabilities( KBOOL AmunitionSupply, KBOOL FuelSupply, KBOOL RecoveryService, KBOOL RepairService )
{
m_Unused = 0;
m_AmmunitionSupply = AmunitionSupply;
m_FuelSupply = FuelSupply;
m_RecoveryService = RecoveryService;
m_RepairService = RepairService;
m_ADSB = 0;
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %r14d
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r13
callq 0x7b160
leaq 0xa6e48(%rip), %rax # 0x125ba8
movq %rax, (%r13)
leal (%r12,%r15,2), %eax
leal (%rax,%r14,4), %eax
leal (%rax,%rbx,8), %eax
movl %eax, 0x8(%r13)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
| /jarvisfriends[P]KDIS/KDIS/DataTypes/EntityCapabilities.cpp |
KDIS::DATA_TYPE::EntityCapabilities::GetAsString[abi:cxx11]() const | KString EntityCapabilities::GetAsString() const
{
KStringStream ss;
ss << "Entity Capabilities"
<< "\n\tAmmunition Supply: " << m_AmmunitionSupply
<< "\n\tFuel Supply: " << m_FuelSupply
<< "\n\tRecovery Service: " << m_RecoveryService
<< "\n\tRepair Service: " << m_RepairService
<< "\n\tADS-B Service: " << m_ADSB
<< "\n";
return ss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25250
leaq 0x18(%rsp), %r15
leaq 0x412bd(%rip), %rsi # 0xc014d
movl $0x13, %edx
movq %r15, %rdi
callq 0x253e0
leaq 0x412bd(%rip), %rsi # 0xc0161
movl $0x18, %edx
movq %r15, %rdi
callq 0x253e0
movl 0x8(%r14), %esi
andl $0x1, %esi
movq %r15, %rdi
callq 0x25220
movq %rax, %r15
leaq 0x412b0(%rip), %rsi # 0xc017a
movl $0x18, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x8(%r14), %esi
shrl %esi
andl $0x1, %esi
movq %r15, %rdi
callq 0x25220
movq %rax, %r15
leaq 0x412a1(%rip), %rsi # 0xc0193
movl $0x18, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x8(%r14), %esi
shrl $0x2, %esi
andl $0x1, %esi
movq %r15, %rdi
callq 0x25220
movq %rax, %r15
leaq 0x41291(%rip), %rsi # 0xc01ac
movl $0x18, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x8(%r14), %esi
shrl $0x3, %esi
andl $0x1, %esi
movq %r15, %rdi
callq 0x25220
movq %rax, %r15
leaq 0x41281(%rip), %rsi # 0xc01c5
movl $0x18, %edx
movq %rax, %rdi
callq 0x253e0
movl 0x8(%r14), %esi
shrl $0x4, %esi
andl $0x1, %esi
movq %r15, %rdi
callq 0x25220
leaq 0x3fb5c(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x25480
movq 0xb602d(%rip), %rsi # 0x134fb8
leaq 0x8(%rsp), %rdi
callq 0x25280
leaq 0x88(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0xb5ffc(%rip), %rsi # 0x134fb8
leaq 0x8(%rsp), %rdi
callq 0x25280
leaq 0x88(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/DataTypes/EntityCapabilities.cpp |
KDIS::DATA_TYPE::EntityIdentifier::Decode(KDIS::KDataStream&) | void EntityIdentifier::Decode(KDataStream &stream) noexcept(false)
{
if( stream.GetBufferSize() < EntityIdentifier::ENTITY_IDENTIFER_SIZE )throw KException( __FUNCTION__, NOT_ENOUGH_DATA_IN_BUFFER );
SimulationIdentifier::Decode( stream );
stream >> m_ui16EntityID;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x26758
cmpw $0x5, %ax
jbe 0x7f32c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x84a1a
addq $0xc, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x29ef0
movl $0x30, %edi
callq 0x25180
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3c49b(%rip), %rsi # 0xbb7e4
leaq 0x3c49a(%rip), %rdx # 0xbb7ea
leaq 0x8(%rsp), %rdi
callq 0x2652e
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x2746c
xorl %ebp, %ebp
leaq 0xa37f8(%rip), %rsi # 0x122b70
leaq -0x58493(%rip), %rdx # 0x26eec
movq %rbx, %rdi
callq 0x25500
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7f3a1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
testb %bpl, %bpl
jne 0x7f3ab
jmp 0x7f3b3
movq %rax, %r14
movq %rbx, %rdi
callq 0x25270
movq %r14, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/DataTypes/EntityIdentifier.cpp |
KDIS::DATA_TYPE::EntityMarking::GetAsString[abi:cxx11]() const | KString EntityMarking::GetAsString() const
{
KStringStream ss;
ss << "Entity Marking:"
<< "\n\tMaring Char Set: " << GetEnumAsStringEntityMarkingCharacterSet( m_ui8EntityMarkingCharacterSet )
<< "\n\tMarking String: " << GetEntityMarkingString()
<< "\n";
return ss.str();
} | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d0, %rsp # imm = 0x1D0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x48(%rsp), %rdi
callq 0x25250
leaq 0x58(%rsp), %r15
leaq 0x40961(%rip), %rsi # 0xc025b
movl $0xf, %edx
movq %r15, %rdi
callq 0x253e0
leaq 0x4095d(%rip), %rsi # 0xc026b
movl $0x18, %edx
movq %r15, %rdi
callq 0x253e0
movzbl 0x8(%r14), %esi
leaq 0x28(%rsp), %rdi
callq 0xafdfb
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
movq %rax, %r15
leaq 0x4093e(%rip), %rsi # 0xc0284
movl $0x18, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x9(%r14), %r12
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq %r12, %rdi
callq 0x25150
leaq (%r14,%rax), %rdx
addq $0x9, %rdx
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x2652e
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
leaq 0x3f130(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x7f9ba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7f9d5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
callq 0x25480
movq 0xb55cf(%rip), %rsi # 0x134fb8
leaq 0x48(%rsp), %rdi
callq 0x25280
leaq 0xc8(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x1d0, %rsp # imm = 0x1D0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x7fa34
jmp 0x7fa54
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x7fa37
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
jmp 0x7fa37
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7fa57
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x25390
jmp 0x7fa57
movq %rax, %rbx
movq 0xb555a(%rip), %rsi # 0x134fb8
leaq 0x48(%rsp), %rdi
callq 0x25280
leaq 0xc8(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
nop
| /jarvisfriends[P]KDIS/KDIS/DataTypes/EntityMarking.cpp |
KDIS::DATA_TYPE::MunitionDescriptor::operator==(KDIS::DATA_TYPE::MunitionDescriptor const&) const | KBOOL MunitionDescriptor::operator == ( const MunitionDescriptor & Value ) const
{
if( Descriptor::operator != ( Value ) ) return false;
if( m_ui16Warhead != Value.m_ui16Warhead ) return false;
if( m_ui16Fuse != Value.m_ui16Fuse ) return false;
if( m_ui16Quantity != Value.m_ui16Quantity ) return false;
if( m_ui16Rate != Value.m_ui16Rate ) return false;
return true;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x7bb00
testb %al, %al
jne 0x83986
movzwl 0x18(%r14), %eax
cmpw 0x18(%rbx), %ax
jne 0x83986
movzwl 0x1a(%r14), %eax
cmpw 0x1a(%rbx), %ax
jne 0x83986
movzwl 0x1c(%r14), %eax
cmpw 0x1c(%rbx), %ax
jne 0x83986
movzwl 0x1e(%r14), %eax
cmpw 0x1e(%rbx), %ax
sete %al
jmp 0x83988
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /jarvisfriends[P]KDIS/KDIS/DataTypes/MunitionDescriptor.cpp |
KDIS::DATA_TYPE::NonHumanLifeFormAppearance::operator!=(KDIS::DATA_TYPE::NonHumanLifeFormAppearance const&) const | KBOOL NonHumanLifeFormAppearance::operator == ( const NonHumanLifeFormAppearance & Value ) const
{
// Lets do a single comparison instead of checking every field.
// This struct is basically a KUINT32 so lets cast it to one and compare.
KUINT32 a = *( KUINT32 * )this;
KUINT32 b = *( KUINT32 * )&Value;
if( a != b )return false;
return true;
} | movl (%rdi), %eax
cmpl (%rsi), %eax
setne %al
retq
| /jarvisfriends[P]KDIS/KDIS/DataTypes/NonHumanLifeFormAppearance.cpp |
KDIS::DATA_TYPE::RadioAppearance::operator==(KDIS::DATA_TYPE::RadioAppearance const&) const | KBOOL RadioAppearance::operator == ( const RadioAppearance & Value ) const
{
// Lets do a single comparison instead of checking every field.
// This struct is basically a KUINT32 so lets cast it to one and compare.
KUINT32 a = *( KUINT32 * )this;
KUINT32 b = *( KUINT32 * )&Value;
if( a != b )return false;
return true;
} | movl (%rdi), %eax
cmpl (%rsi), %eax
sete %al
retq
| /jarvisfriends[P]KDIS/KDIS/DataTypes/RadioAppearance.cpp |
KDIS::DATA_TYPE::RadioEntityType::GetAsString[abi:cxx11]() const | KString RadioEntityType::GetAsString() const
{
KStringStream ss;
ss << ( KUINT16 )m_ui8EntityKind << " , "
<< ( KUINT16 )m_ui8Domain << " , "
<< ( KUINT16 )m_ui16Country << " , "
<< ( KUINT16 )m_ui8Category << " , "
<< ( KUINT16 )m_ui8NomenclatureVersion << " , "
<< ( KUINT16 )m_ui16Nomenclature << " , "
<< "\n";
return ss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp # imm = 0x190
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x25250
leaq 0x18(%rsp), %rdi
movzbl 0x8(%r14), %esi
callq 0x25220
movq %rax, %r15
leaq 0x3922d(%rip), %rsi # 0xbd0ea
movl $0x3, %edx
movq %rax, %rdi
callq 0x253e0
movzbl 0x9(%r14), %esi
movq %r15, %rdi
callq 0x25220
movq %rax, %r15
leaq 0x39209(%rip), %rsi # 0xbd0ea
movl $0x3, %edx
movq %rax, %rdi
callq 0x253e0
movzwl 0xa(%r14), %esi
movq %r15, %rdi
callq 0x25220
movq %rax, %r15
leaq 0x391e5(%rip), %rsi # 0xbd0ea
movl $0x3, %edx
movq %rax, %rdi
callq 0x253e0
movzbl 0xc(%r14), %esi
movq %r15, %rdi
callq 0x25220
movq %rax, %r15
leaq 0x391c1(%rip), %rsi # 0xbd0ea
movl $0x3, %edx
movq %rax, %rdi
callq 0x253e0
movzbl 0xd(%r14), %esi
movq %r15, %rdi
callq 0x25220
movq %rax, %r15
leaq 0x3919d(%rip), %rsi # 0xbd0ea
movl $0x3, %edx
movq %rax, %rdi
callq 0x253e0
movzwl 0xe(%r14), %esi
movq %r15, %rdi
callq 0x25220
movq %rax, %r14
leaq 0x39179(%rip), %rsi # 0xbd0ea
movl $0x3, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x3ab41(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %r14, %rdi
callq 0x253e0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x25480
movq 0xb1012(%rip), %rsi # 0x134fb8
leaq 0x8(%rsp), %rdi
callq 0x25280
leaq 0x88(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x190, %rsp # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0xb0fe1(%rip), %rsi # 0x134fb8
leaq 0x8(%rsp), %rdi
callq 0x25280
leaq 0x88(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/DataTypes/RadioEntityType.cpp |
KDIS::DATA_TYPE::RadioEntityType::Decode(KDIS::KDataStream&) | void RadioEntityType::Decode(KDataStream &stream) noexcept(false)
{
if( stream.GetBufferSize() < RADIO_ENTITY_TYPE_SIZE )throw KException( __FUNCTION__, NOT_ENOUGH_DATA_IN_BUFFER );
stream >> m_ui8EntityKind
>> m_ui8Domain
>> m_ui16Country
>> m_ui8Category
>> m_ui8NomenclatureVersion
>> m_ui16Nomenclature;
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x26758
cmpw $0x7, %ax
jbe 0x84069
leaq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x26a8e
leaq 0x9(%r14), %rsi
movq %rbx, %rdi
callq 0x26a8e
leaq 0xa(%r14), %rsi
movq %rbx, %rdi
callq 0x29ef0
leaq 0xc(%r14), %rsi
movq %rbx, %rdi
callq 0x26a8e
leaq 0xd(%r14), %rsi
movq %rbx, %rdi
callq 0x26a8e
addq $0xe, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x29ef0
movl $0x30, %edi
callq 0x25180
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x3775e(%rip), %rsi # 0xbb7e4
leaq 0x3775d(%rip), %rdx # 0xbb7ea
leaq 0x8(%rsp), %rdi
callq 0x2652e
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movl $0x2, %edx
callq 0x2746c
xorl %ebp, %ebp
leaq 0x9eabb(%rip), %rsi # 0x122b70
leaq -0x5d1d0(%rip), %rdx # 0x26eec
movq %rbx, %rdi
callq 0x25500
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x840de
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
testb %bpl, %bpl
jne 0x840e8
jmp 0x840f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x25270
movq %r14, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/DataTypes/RadioEntityType.cpp |
KDIS::DATA_TYPE::RadioEntityType::operator==(KDIS::DATA_TYPE::RadioEntityType const&) const | KBOOL RadioEntityType::operator == ( const RadioEntityType & Value ) const
{
if( m_ui8EntityKind != Value.m_ui8EntityKind ) return false;
if( m_ui8Domain != Value.m_ui8Domain ) return false;
if( m_ui16Country != Value.m_ui16Country ) return false;
if( m_ui8Category != Value.m_ui8Category ) return false;
if( m_ui8NomenclatureVersion != Value.m_ui8NomenclatureVersion ) return false;
if( m_ui16Nomenclature != Value.m_ui16Nomenclature ) return false;
return true;
} | movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
sete %al
retq
| /jarvisfriends[P]KDIS/KDIS/DataTypes/RadioEntityType.cpp |
KDIS::DATA_TYPE::ConeRecord1::GetAsString[abi:cxx11]() const | KString ConeRecord1::GetAsString() const
{
KStringStream ss;
ss << EnvironmentRecord::GetAsString()
<< "\tVertex Location: " << m_Loc.GetAsString()
<< "\tOrientation: " << m_Ori.GetAsString()
<< "\tHeight: " << m_f32Height << "\n"
<< "\tPeak Angle: " << m_f32PeakAngle << "\n";
return ss.str();
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x1f0, %rsp # imm = 0x1F0
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x68(%rsp), %rdi
callq 0x25250
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x8af16
leaq 0x78(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x50(%rsp), %rdx
callq 0x253e0
movq %rax, %r15
leaq 0x1a5f4(%rip), %rsi # 0xcf77b
movl $0x12, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x10(%r14), %rsi
leaq 0x28(%rsp), %rdi
callq 0x88048
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
movq %rax, %r15
leaq 0xd13e(%rip), %rsi # 0xc22fc
movl $0x12, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x30(%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x80916
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x253e0
movq %rax, %r15
leaq 0xd140(%rip), %rsi # 0xc2335
movl $0x12, %edx
movq %rax, %rdi
callq 0x253e0
cvtss2sd 0x48(%r14), %xmm0
movq %r15, %rdi
callq 0x254a0
movq %rax, %r15
leaq 0x98ac(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x1a560(%rip), %rsi # 0xcf78e
movl $0x12, %edx
movq %r15, %rdi
callq 0x253e0
xorps %xmm0, %xmm0
cvtss2sd 0x4c(%r14), %xmm0
movq %r15, %rdi
callq 0x254a0
leaq 0x9873(%rip), %rsi # 0xbeac6
movl $0x1, %edx
movq %rax, %rdi
callq 0x253e0
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb527b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb5296
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb52b1
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x80(%rsp), %rsi
movq %rbx, %rdi
callq 0x25480
movq 0x7fcf0(%rip), %rsi # 0x134fb8
leaq 0x68(%rsp), %rdi
callq 0x25280
leaq 0xe8(%rsp), %rdi
callq 0x25120
movq %rbx, %rax
addq $0x1f0, %rsp # imm = 0x1F0
popq %rbx
popq %r14
popq %r15
retq
jmp 0xb52f5
jmp 0xb52fa
jmp 0xb52ff
movq %rax, %rbx
jmp 0xb5358
movq %rax, %rbx
jmp 0xb5322
movq %rax, %rbx
jmp 0xb533d
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb5322
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb533d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x25390
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb5358
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x25390
movq 0x7fc59(%rip), %rsi # 0x134fb8
leaq 0x68(%rsp), %rdi
callq 0x25280
leaq 0xe8(%rsp), %rdi
callq 0x25120
movq %rbx, %rdi
callq 0x25530
| /jarvisfriends[P]KDIS/KDIS/DataTypes/ConeRecord1.cpp |
KDIS::DATA_TYPE::ConeRecord2::ConeRecord2(unsigned char, KDIS::DATA_TYPE::WorldCoordinates const&, KDIS::DATA_TYPE::EulerAngles const&, KDIS::DATA_TYPE::Vector const&, KDIS::DATA_TYPE::Vector const&, float, float, float, float) | ConeRecord2::ConeRecord2( KUINT8 Index, const WorldCoordinates & VertexLocation, const EulerAngles & Orientation,
const Vector & Velocity, const Vector & AngularVelocity, KFLOAT32 Height,
KFLOAT32 PeakAngle, KFLOAT32 DHeightOverDt, KFLOAT32 DPeakAngleOverDt ) :
ConeRecord1( Index, VertexLocation, Orientation, Height, PeakAngle ),
m_Velocity( Velocity ),
m_AngularVelocity( AngularVelocity ),
m_f32ddtHeight( DHeightOverDt ),
m_f32ddtPeak( DPeakAngleOverDt )
{
m_ui32EnvRecTyp = ConeRecord2Type;
m_ui16Length = CONE_RECORD_2_SIZE * 8;
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movss %xmm3, 0xc(%rsp)
movss %xmm2, 0x8(%rsp)
movq %r9, %rbx
movq %r8, %r14
movq %rdi, %r15
callq 0xb5004
leaq 0x7f236(%rip), %rax # 0x134920
movq %rax, (%r15)
leaq 0x70acc(%rip), %rax # 0x1261c0
addq $0x10, %rax
movq %rax, 0x58(%r15)
movq 0x8(%r14), %rcx
movq %rcx, 0x60(%r15)
movl 0x10(%r14), %ecx
movl %ecx, 0x68(%r15)
movq %rax, 0x70(%r15)
movq 0x8(%rbx), %rax
movq %rax, 0x78(%r15)
movl 0x10(%rbx), %eax
movl %eax, 0x80(%r15)
movss 0x8(%rsp), %xmm0
movss %xmm0, 0x88(%r15)
movss 0xc(%rsp), %xmm0
movss %xmm0, 0x8c(%r15)
movl $0x30000000, 0x8(%r15) # imm = 0x30000000
movw $0x2c0, 0xc(%r15) # imm = 0x2C0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
| /jarvisfriends[P]KDIS/KDIS/DataTypes/ConeRecord2.cpp |
main | int main()
{
Ticket obj({{1975, 1, 2},"Vietnam"},{{1955,1,1},"Sweet home Alabama"},500);
Ticket obj1({{2014, 3, 10},"Minsk"},{{2014,2,2},"London"},1999);
Ticket obj2({{2014, 4, 10},"Moscow"},{{2014,4,2},"Amsterdam"},1999);
Ticket obj3({{2014, 5, 10},"Minsk"},{{2014,5,3},"London"},1999);
Airport airport;
airport.set_name("Sheremetyevo - A.S. Pushkin international airport");
airport.set_runway_strips(2);
airport.push_ticket(obj);
airport.push_ticket(obj1);
airport.push_ticket(obj2);
airport.push_ticket(obj3);
User user;
user.set_first_name("Egor");
user.set_second_name("Sviridenko");
user.set_age(19);
user.set_passport_id("123123123123"); // without correct passport id(only digits) user can't buy any tickets.
menu(airport,user);
//airport.delete_ticket(1); //cancel flight for example
/*
std::cout << "Show available tickets in the airport" << std::endl;
airport.show();
std::cout << std::endl;
std::cout << std::endl;
*/
//user.set_passport_id("12344125643AFDAFDAF"); // validation works;
/*
//user.buy_tickets(airport,1);
//user.buy_tickets(airport,2);
std::cout << "Show user's personal data" << std::endl;
user.show_info();
std::cout << std::endl;
std::cout << "Find ticket with rule example"<< std::endl;
user.find_ticket(airport,"20140502","20140512","London","Minsk");
// "20140502","20140512" - data period, in which algorithm will search available tickets with given cities.
std::cout << "____________________" << std::endl;
user.buyuser's wallet and info_tickets(airport,4);
std::cout << "Find ticket with rule example(Already bought)"<< std::endl;
std::cout << std::endl;
std::cout << "____________________"<<std::endl;
//user.find_ticket(airport,"19520105","20000302","Sweet home Alabama","Vietnam");
std::cout <<"Showing tickets that are available in airport right now" << std::endl;
airport.show();
std::cout << std::endl;
std::cout << "Show user's information and his wallet" << std::endl;
//user.show_info();
//user.cancel_flight(); TODO in future . move back from std::list ticket pair to airport
//to_file(airport,"data.data");// works exception with regex match txt file
//to_file(airport,"data.txt");
//save_users_wallet(user,"wallet.txt");
*/
} | pushq %r15
pushq %r14
pushq %rbx
subq $0x3c0, %rsp # imm = 0x3C0
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
movl $0x7b7, %esi # imm = 0x7B7
movl $0x1, %edx
movl $0x2, %ecx
callq 0x8a62
movl (%rbx), %eax
leaq 0x1c8(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0x1d8(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x175df(%rip), %rsi # 0x1f43e
leaq 0x175df(%rip), %rdx # 0x1f445
callq 0x9bae
leaq 0x300(%rsp), %rdi
movl $0x7a3, %esi # imm = 0x7A3
movl $0x1, %edx
movl $0x1, %ecx
callq 0x8a62
movl 0x300(%rsp), %eax
leaq 0x1a0(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0x1b0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1759a(%rip), %rsi # 0x1f446
leaq 0x175a5(%rip), %rdx # 0x1f458
callq 0x9bae
leaq 0x360(%rsp), %rdi
leaq 0x1c0(%rsp), %rsi
leaq 0x198(%rsp), %rdx
movsd 0x17158(%rip), %xmm0 # 0x1f030
callq 0x1b5f8
movq 0x1a0(%rsp), %rdi
cmpq %r15, %rdi
je 0x7efa
movq 0x1b0(%rsp), %rsi
incq %rsi
callq 0x6320
movq 0x1c8(%rsp), %rdi
cmpq %r14, %rdi
je 0x7f17
movq 0x1d8(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x28(%rsp), %rdi
movl $0x7de, %esi # imm = 0x7DE
movl $0x3, %edx
movl $0xa, %ecx
callq 0x8a62
movl 0x28(%rsp), %eax
leaq 0x178(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0x188(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x17507(%rip), %rsi # 0x1f459
leaq 0x17505(%rip), %rdx # 0x1f45e
callq 0x9bae
leaq 0x2a0(%rsp), %rdi
movl $0x7de, %esi # imm = 0x7DE
movl $0x2, %edx
movl $0x2, %ecx
callq 0x8a62
movl 0x2a0(%rsp), %eax
leaq 0x150(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0x160(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x174c0(%rip), %rsi # 0x1f45f
leaq 0x174bf(%rip), %rdx # 0x1f465
callq 0x9bae
leaq 0x300(%rsp), %rdi
leaq 0x170(%rsp), %rsi
leaq 0x148(%rsp), %rdx
movsd 0x1706d(%rip), %xmm0 # 0x1f038
callq 0x1b5f8
movq 0x150(%rsp), %rdi
cmpq %r15, %rdi
je 0x7fed
movq 0x160(%rsp), %rsi
incq %rsi
callq 0x6320
movq 0x178(%rsp), %rdi
cmpq %r14, %rdi
je 0x800a
movq 0x188(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x28(%rsp), %rdi
movl $0x7de, %esi # imm = 0x7DE
movl $0x4, %edx
movl $0xa, %ecx
callq 0x8a62
movl 0x28(%rsp), %eax
leaq 0x128(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0x138(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x17421(%rip), %rsi # 0x1f466
leaq 0x17420(%rip), %rdx # 0x1f46c
callq 0x9bae
leaq 0x240(%rsp), %rdi
movl $0x7de, %esi # imm = 0x7DE
movl $0x4, %edx
movl $0x2, %ecx
callq 0x8a62
movl 0x240(%rsp), %eax
leaq 0x100(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0x110(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x173db(%rip), %rsi # 0x1f46d
leaq 0x173dd(%rip), %rdx # 0x1f476
callq 0x9bae
leaq 0x2a0(%rsp), %rdi
leaq 0x120(%rsp), %rsi
leaq 0xf8(%rsp), %rdx
movsd 0x16f7a(%rip), %xmm0 # 0x1f038
callq 0x1b5f8
movq 0x100(%rsp), %rdi
cmpq %r15, %rdi
je 0x80e0
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x6320
movq 0x128(%rsp), %rdi
cmpq %r14, %rdi
je 0x80fd
movq 0x138(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x28(%rsp), %rdi
movl $0x7de, %esi # imm = 0x7DE
movl $0x5, %edx
movl $0xa, %ecx
callq 0x8a62
movl 0x28(%rsp), %eax
leaq 0xd8(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0xe8(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x17321(%rip), %rsi # 0x1f459
leaq 0x1731f(%rip), %rdx # 0x1f45e
callq 0x9bae
leaq 0x1e8(%rsp), %rdi
movl $0x7de, %esi # imm = 0x7DE
movl $0x5, %edx
movl $0x3, %ecx
callq 0x8a62
movl 0x1e8(%rsp), %eax
leaq 0xb0(%rsp), %rdi
movl %eax, -0x8(%rdi)
leaq 0xc0(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x172da(%rip), %rsi # 0x1f45f
leaq 0x172d9(%rip), %rdx # 0x1f465
callq 0x9bae
leaq 0x240(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
leaq 0xa8(%rsp), %rdx
movsd 0x16e87(%rip), %xmm0 # 0x1f038
callq 0x1b5f8
movq 0xb0(%rsp), %rdi
cmpq %r15, %rdi
je 0x81d3
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x6320
movq 0xd8(%rsp), %rdi
cmpq %r14, %rdi
je 0x81f0
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x1e8(%rsp), %rdi
callq 0x1b8fe
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1726a(%rip), %rsi # 0x1f477
leaq 0x17294(%rip), %rdx # 0x1f4a8
leaq 0x28(%rsp), %rdi
callq 0x9bae
leaq 0x1e8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1ba40
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x8247
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x28(%rsp), %rsi
movl $0x2, (%rsi)
leaq 0x1e8(%rsp), %rdi
callq 0x1ba4a
leaq 0x1e8(%rsp), %rdi
leaq 0x360(%rsp), %rsi
callq 0x1ba86
leaq 0x1e8(%rsp), %rdi
leaq 0x300(%rsp), %rsi
callq 0x1ba86
leaq 0x1e8(%rsp), %rdi
leaq 0x2a0(%rsp), %rsi
callq 0x1ba86
leaq 0x1e8(%rsp), %rdi
leaq 0x240(%rsp), %rsi
callq 0x1ba86
leaq 0x28(%rsp), %rdi
callq 0x1c7a4
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x171dc(%rip), %rsi # 0x1f4a9
leaq 0x171d9(%rip), %rdx # 0x1f4ad
leaq 0x8(%rsp), %rdi
callq 0x9bae
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1c8be
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x8304
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x1719b(%rip), %rsi # 0x1f4ae
leaq 0x1719e(%rip), %rdx # 0x1f4b8
callq 0x9bae
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1c8b4
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x8345
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x8(%rsp), %rsi
movl $0x13, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x1c8ae
leaq 0x8(%rsp), %rdi
movq %r14, (%rdi)
leaq 0x17150(%rip), %rsi # 0x1f4b9
leaq 0x17155(%rip), %rdx # 0x1f4c5
callq 0x9bae
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1c8c8
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x839b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x1e8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x7511
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83ce
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x83e9
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8404
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x28(%rsp), %rdi
callq 0x8ca6
leaq 0x230(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x842f
movq 0x230(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x1e8(%rsp), %rdi
callq 0x8c08
leaq 0x280(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x845d
movq 0x280(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x258(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x847e
movq 0x258(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x2e0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x849f
movq 0x2e0(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x2b8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x84c0
movq 0x2b8(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x340(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x84e1
movq 0x340(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x318(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8502
movq 0x318(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x3a0(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8523
movq 0x3a0(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x378(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8544
movq 0x378(%rsp), %rsi
incq %rsi
callq 0x6320
xorl %eax, %eax
addq $0x3c0, %rsp # imm = 0x3C0
popq %rbx
popq %r14
popq %r15
retq
jmp 0x857b
jmp 0x855f
jmp 0x857b
jmp 0x857b
jmp 0x855f
jmp 0x857b
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x857e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6320
jmp 0x857e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8b54
jmp 0x8710
jmp 0x870d
jmp 0x870d
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x8710
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x6320
jmp 0x8710
jmp 0x870d
movq %rax, %rbx
jmp 0x871d
movq %rax, %rbx
movq 0xb0(%rsp), %rdi
cmpq %r15, %rdi
je 0x866b
movq 0xc0(%rsp), %rsi
incq %rsi
callq 0x6320
jmp 0x866b
movq %rax, %rbx
movq 0x100(%rsp), %rdi
cmpq %r15, %rdi
je 0x869c
movq 0x110(%rsp), %rsi
incq %rsi
callq 0x6320
jmp 0x869c
movq %rax, %rbx
movq 0x150(%rsp), %rdi
cmpq %r15, %rdi
je 0x86c7
movq 0x160(%rsp), %rsi
incq %rsi
callq 0x6320
jmp 0x86c7
movq %rax, %rbx
movq 0x1a0(%rsp), %rdi
cmpq %r15, %rdi
je 0x86ee
movq 0x1b0(%rsp), %rsi
incq %rsi
callq 0x6320
jmp 0x86ee
movq %rax, %rbx
movq 0xd8(%rsp), %rdi
cmpq %r14, %rdi
je 0x872a
movq 0xe8(%rsp), %rsi
incq %rsi
callq 0x6320
jmp 0x872a
movq %rax, %rbx
jmp 0x872a
movq %rax, %rbx
movq 0x128(%rsp), %rdi
cmpq %r14, %rdi
je 0x8737
movq 0x138(%rsp), %rsi
incq %rsi
callq 0x6320
jmp 0x8737
movq %rax, %rbx
jmp 0x8737
movq %rax, %rbx
movq 0x178(%rsp), %rdi
cmpq %r14, %rdi
je 0x8744
movq 0x188(%rsp), %rsi
incq %rsi
callq 0x6320
jmp 0x8744
movq %rax, %rbx
jmp 0x8744
movq %rax, %rbx
movq 0x1c8(%rsp), %rdi
cmpq %r14, %rdi
je 0x8751
movq 0x1d8(%rsp), %rsi
incq %rsi
callq 0x6320
jmp 0x8751
movq %rax, %rbx
leaq 0x1e8(%rsp), %rdi
callq 0x8baa
leaq 0x240(%rsp), %rdi
callq 0x8bd0
leaq 0x2a0(%rsp), %rdi
callq 0x8bd0
leaq 0x300(%rsp), %rdi
callq 0x8bd0
leaq 0x360(%rsp), %rdi
callq 0x8bd0
movq %rbx, %rdi
callq 0x6580
nop
| /EgorWK4[P]Flights-booking-/main.cpp |
Airport::Airport(std::map<unsigned int, Ticket, std::less<unsigned int>, std::allocator<std::pair<unsigned int const, Ticket>>>, unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | Airport::Airport(std::map<unsigned,Ticket> tickets, unsigned runway_strips, string name)
: tickets(tickets), runway_strips(runway_strips), name(name){} | pushq %rbp
pushq %r14
pushq %rbx
movq %rcx, %r14
movl %edx, %ebp
movq %rdi, %rbx
callq 0x1bfbc
movl %ebp, 0x30(%rbx)
leaq 0x38(%rbx), %rdi
leaq 0x48(%rbx), %rax
movq %rax, 0x38(%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0xf82e
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8c08
movq %r14, %rdi
callq 0x6580
nop
| /EgorWK4[P]Flights-booking-/airport.cpp |
Airport::push_ticket(Ticket const&) | void Airport::push_ticket(const Ticket &obj)
{
tickets.insert({obj.id,obj});
} | pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rdx
movq %rdi, %rbx
addq $0x58, %rsi
movq %rsp, %r14
movq %r14, %rdi
callq 0x1bec2
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1c4d0
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1bac8
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1bae3
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x6320
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1bf56
movq %rbx, %rdi
callq 0x6580
| /EgorWK4[P]Flights-booking-/airport.cpp |
User::User() | User::User()
{
tickets = std::list<Ticket>();
first_name = std::string();
second_name = std::string();
string passport_id();
age = int();
} | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
xorl %r13d, %r13d
movq %r13, 0x10(%rdi)
leaq 0x18(%rdi), %r15
leaq 0x28(%rdi), %rax
movq %rax, 0x18(%rdi)
movq %r13, 0x20(%rdi)
movb %r13b, 0x28(%rdi)
leaq 0x38(%rdi), %r14
leaq 0x48(%rdi), %rax
movq %rax, 0x38(%rdi)
movq %r13, 0x40(%rdi)
movb %r13b, 0x48(%rdi)
leaq 0x68(%rdi), %rax
movq %rax, 0x58(%rdi)
movq %r13, 0x60(%rdi)
movb %r13b, 0x68(%rdi)
leaq 0x8(%rsp), %r12
movq %r12, 0x8(%r12)
movq %r12, (%r12)
movq %r13, 0x10(%r12)
movq %r12, %rsi
callq 0x1e54e
movq %r12, %rdi
callq 0x8ca6
leaq 0x18(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %r13, -0x8(%rbp)
movb %r13b, (%rbp)
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x65f2
movq (%r12), %rdi
cmpq %rbp, %rdi
je 0x1c855
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6320
leaq 0x8(%rsp), %r15
movq %rbp, (%r15)
movq $0x0, 0x8(%r15)
movb $0x0, 0x10(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x65f2
movq (%r15), %rdi
cmpq %rbp, %rdi
je 0x1c88a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x6320
movl $0x0, 0x78(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
| /EgorWK4[P]Flights-booking-/customer.cpp |
process_ctl | static void
process_ctl(ps_decoder_t *ps, cmd_ln_t *config, FILE *ctlfh)
{
int32 ctloffset, ctlcount, ctlincr;
int32 i;
char *line;
size_t len;
FILE *hypfh = NULL, *hypsegfh = NULL, *ctmfh = NULL;
FILE *mllrfh = NULL, *lmfh = NULL, *fsgfh = NULL, *alignfh = NULL;
double n_speech, n_cpu, n_wall;
char const *outlatdir;
char const *nbestdir;
char const *str;
int frate;
ctloffset = ps_config_int(config, "ctloffset");
ctlcount = ps_config_int(config, "ctlcount");
ctlincr = ps_config_int(config, "ctlincr");
outlatdir = ps_config_str(config, "outlatdir");
nbestdir = ps_config_str(config, "nbestdir");
frate = ps_config_int(config, "frate");
if ((str = ps_config_str(config, "mllrctl"))) {
mllrfh = fopen(str, "r");
if (mllrfh == NULL) {
E_ERROR_SYSTEM("Failed to open MLLR control file file %s", str);
goto done;
}
}
if ((str = ps_config_str(config, "fsgctl"))) {
fsgfh = fopen(str, "r");
if (fsgfh == NULL) {
E_ERROR_SYSTEM("Failed to open FSG control file file %s", str);
goto done;
}
}
if ((str = ps_config_str(config, "alignctl"))) {
alignfh = fopen(str, "r");
if (alignfh == NULL) {
E_ERROR_SYSTEM("Failed to open alignment control file file %s", str);
goto done;
}
}
if ((str = ps_config_str(config, "lmnamectl"))) {
lmfh = fopen(str, "r");
if (lmfh == NULL) {
E_ERROR_SYSTEM("Failed to open LM name control file file %s", str);
goto done;
}
}
if ((str = ps_config_str(config, "hyp"))) {
hypfh = fopen(str, "w");
if (hypfh == NULL) {
E_ERROR_SYSTEM("Failed to open hypothesis file %s for writing", str);
goto done;
}
setbuf(hypfh, NULL);
}
if ((str = ps_config_str(config, "hypseg"))) {
hypsegfh = fopen(str, "w");
if (hypsegfh == NULL) {
E_ERROR_SYSTEM("Failed to open hypothesis file %s for writing", str);
goto done;
}
setbuf(hypsegfh, NULL);
}
if ((str = ps_config_str(config, "ctm"))) {
ctmfh = fopen(str, "w");
if (ctmfh == NULL) {
E_ERROR_SYSTEM("Failed to open hypothesis file %s for writing", str);
goto done;
}
setbuf(ctmfh, NULL);
}
i = 0;
while ((line = fread_line(ctlfh, &len))) {
char *wptr[4];
int32 nf, sf, ef;
char *mllrline = NULL, *lmline = NULL, *fsgline = NULL;
char *fsgfile = NULL, *lmname = NULL, *mllrfile = NULL;
char *alignline = NULL, *alignfile = NULL;
if (mllrfh) {
mllrline = fread_line(mllrfh, &len);
if (mllrline == NULL) {
E_ERROR("File size mismatch between control and MLLR control\n");
ckd_free(line);
ckd_free(mllrline);
goto done;
}
mllrfile = string_trim(mllrline, STRING_BOTH);
}
if (lmfh) {
lmline = fread_line(lmfh, &len);
if (lmline == NULL) {
E_ERROR("File size mismatch between control and LM control\n");
ckd_free(line);
ckd_free(lmline);
goto done;
}
lmname = string_trim(lmline, STRING_BOTH);
}
if (fsgfh) {
fsgline = fread_line(fsgfh, &len);
if (fsgline == NULL) {
E_ERROR("File size mismatch between control and FSG control\n");
ckd_free(line);
ckd_free(fsgline);
goto done;
}
fsgfile = string_trim(fsgline, STRING_BOTH);
}
if (alignfh) {
alignline = fread_line(alignfh, &len);
if (alignline == NULL) {
E_ERROR("File size mismatch between control and align control\n");
ckd_free(line);
ckd_free(alignline);
goto done;
}
alignfile = string_trim(alignline, STRING_BOTH);
}
if (i < ctloffset) {
i += ctlincr;
goto nextline;
}
if (ctlcount != -1 && i >= ctloffset + ctlcount) {
goto nextline;
}
sf = 0;
ef = -1;
nf = str2words(line, wptr, 4);
if (nf == 0) {
/* Do nothing. */
}
else if (nf < 0) {
E_ERROR("Unexpected extra data in control file at line %d\n", i);
}
else {
char const *hyp = NULL, *file, *uttid;
int32 score;
file = wptr[0];
if (nf > 1)
sf = atoi(wptr[1]);
if (nf > 2)
ef = atoi(wptr[2]);
if (nf > 3)
uttid = wptr[3];
else
uttid = file;
E_INFO("Decoding '%s'\n", uttid);
/* Do actual decoding. */
if(process_mllrctl_line(ps, config, mllrfile) < 0)
continue;
if(process_lmnamectl_line(ps, config, lmname) < 0)
continue;
if(process_fsgctl_line(ps, config, fsgfile) < 0)
continue;
if(process_alignctl_line(ps, config, alignfile) < 0)
continue;
if(process_ctl_line(ps, config, file, uttid, sf, ef) < 0)
continue;
/* Special case for force-alignment: report silences and
* alternate pronunciations. This isn't done
* automatically because Reasons. (API consistency but
* also because force-alignment is really secretly FSG
* search at the moment). */
if (hypfh) {
if (alignfile) {
char *align_hyp = get_align_hyp(ps, &score);
fprintf(hypfh, "%s (%s %d)\n", align_hyp, uttid, score);
ckd_free(align_hyp);
}
else {
hyp = ps_get_hyp(ps, &score);
fprintf(hypfh, "%s (%s %d)\n", hyp ? hyp : "", uttid, score);
}
}
if (hypsegfh) {
write_hypseg(hypsegfh, ps, uttid);
}
if (ctmfh) {
ps_seg_t *itor = ps_seg_iter(ps);
write_ctm(ctmfh, ps, itor, uttid, frate);
}
if (outlatdir) {
write_lattice(ps, outlatdir, uttid);
}
if (nbestdir) {
write_nbest(ps, nbestdir, uttid);
}
ps_get_utt_time(ps, &n_speech, &n_cpu, &n_wall);
E_INFO("%s: %.2f seconds speech, %.2f seconds CPU, %.2f seconds wall\n",
uttid, n_speech, n_cpu, n_wall);
E_INFO("%s: %.2f xRT (CPU), %.2f xRT (elapsed)\n",
uttid, n_cpu / n_speech, n_wall / n_speech);
/* help make the logfile somewhat less opaque (air) */
E_INFO_NOFN("%s (%s %d)\n", hyp ? hyp : "", uttid, score);
E_INFO_NOFN("%s done --------------------------------------\n", uttid);
}
i += ctlincr;
nextline:
ckd_free(alignline);
ckd_free(mllrline);
ckd_free(fsgline);
ckd_free(lmline);
ckd_free(line);
}
ps_get_all_time(ps, &n_speech, &n_cpu, &n_wall);
E_INFO("TOTAL %.2f seconds speech, %.2f seconds CPU, %.2f seconds wall\n",
n_speech, n_cpu, n_wall);
E_INFO("AVERAGE %.2f xRT (CPU), %.2f xRT (elapsed)\n",
n_cpu / n_speech, n_wall / n_speech);
done:
if (hypfh)
fclose(hypfh);
if (hypsegfh)
fclose(hypsegfh);
if (ctmfh)
fclose(ctmfh);
if (alignfh)
fclose(alignfh);
} | pushq %rbp
movq %rsp, %rbp
subq $0x170, %rsp # imm = 0x170
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x40(%rbp)
movq $0x0, -0x48(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x68(%rbp)
movq $0x0, -0x70(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6f1d6(%rip), %rsi # 0x76980
callq 0x14360
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6f20b(%rip), %rsi # 0x769c8
callq 0x14360
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6f247(%rip), %rsi # 0x76a17
callq 0x14360
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6f65b(%rip), %rsi # 0x76e3e
callq 0x13700
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6f76f(%rip), %rsi # 0x76f69
callq 0x13700
movq %rax, -0x98(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6d9e2(%rip), %rsi # 0x751f3
callq 0x14360
movl %eax, -0xa4(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6f21e(%rip), %rsi # 0x76a45
callq 0x13700
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x7884
movq -0xa0(%rbp), %rdi
leaq 0x7ae3b(%rip), %rsi # 0x82682
callq 0x7380
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x7882
movq -0xa0(%rbp), %r8
movl $0x3, %edi
leaq 0x6d7a2(%rip), %rsi # 0x7500c
movl $0x2c2, %edx # imm = 0x2C2
leaq 0x6f7ad(%rip), %rcx # 0x77023
movb $0x0, %al
callq 0x23600
jmp 0x828a
jmp 0x7884
movq -0x10(%rbp), %rdi
leaq 0x6f2ac(%rip), %rsi # 0x76b3b
callq 0x13700
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x78ec
movq -0xa0(%rbp), %rdi
leaq 0x7add3(%rip), %rsi # 0x82682
callq 0x7380
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0x78ea
movq -0xa0(%rbp), %r8
movl $0x3, %edi
leaq 0x6d73a(%rip), %rsi # 0x7500c
movl $0x2c9, %edx # imm = 0x2C9
leaq 0x6f76e(%rip), %rcx # 0x7704c
movb $0x0, %al
callq 0x23600
jmp 0x828a
jmp 0x78ec
movq -0x10(%rbp), %rdi
leaq 0x6f2e3(%rip), %rsi # 0x76bda
callq 0x13700
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x7954
movq -0xa0(%rbp), %rdi
leaq 0x7ad6b(%rip), %rsi # 0x82682
callq 0x7380
movq %rax, -0x70(%rbp)
cmpq $0x0, -0x70(%rbp)
jne 0x7952
movq -0xa0(%rbp), %r8
movl $0x3, %edi
leaq 0x6d6d2(%rip), %rsi # 0x7500c
movl $0x2d0, %edx # imm = 0x2D0
leaq 0x6f72e(%rip), %rcx # 0x77074
movb $0x0, %al
callq 0x23600
jmp 0x828a
jmp 0x7954
movq -0x10(%rbp), %rdi
leaq 0x6f19b(%rip), %rsi # 0x76afa
callq 0x13700
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x79bc
movq -0xa0(%rbp), %rdi
leaq 0x7ad03(%rip), %rsi # 0x82682
callq 0x7380
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
jne 0x79ba
movq -0xa0(%rbp), %r8
movl $0x3, %edi
leaq 0x6d66a(%rip), %rsi # 0x7500c
movl $0x2d7, %edx # imm = 0x2D7
leaq 0x6f6f4(%rip), %rcx # 0x770a2
movb $0x0, %al
callq 0x23600
jmp 0x828a
jmp 0x79bc
movq -0x10(%rbp), %rdi
leaq 0x6f5e3(%rip), %rsi # 0x76faa
callq 0x13700
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x7a2f
movq -0xa0(%rbp), %rdi
leaq 0x70c97(%rip), %rsi # 0x7867e
callq 0x7380
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x7a22
movq -0xa0(%rbp), %r8
movl $0x3, %edi
leaq 0x6d602(%rip), %rsi # 0x7500c
movl $0x2de, %edx # imm = 0x2DE
leaq 0x6f6b8(%rip), %rcx # 0x770ce
movb $0x0, %al
callq 0x23600
jmp 0x828a
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7150
movq -0x10(%rbp), %rdi
leaq 0x6f389(%rip), %rsi # 0x76dc3
callq 0x13700
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x7aa2
movq -0xa0(%rbp), %rdi
leaq 0x70c24(%rip), %rsi # 0x7867e
callq 0x7380
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x7a95
movq -0xa0(%rbp), %r8
movl $0x3, %edi
leaq 0x6d58f(%rip), %rsi # 0x7500c
movl $0x2e6, %edx # imm = 0x2E6
leaq 0x6f645(%rip), %rcx # 0x770ce
movb $0x0, %al
callq 0x23600
jmp 0x828a
movq -0x48(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7150
movq -0x10(%rbp), %rdi
leaq 0x6f34c(%rip), %rsi # 0x76df9
callq 0x13700
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x7b15
movq -0xa0(%rbp), %rdi
leaq 0x70bb1(%rip), %rsi # 0x7867e
callq 0x7380
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0x7b08
movq -0xa0(%rbp), %r8
movl $0x3, %edi
leaq 0x6d51c(%rip), %rsi # 0x7500c
movl $0x2ee, %edx # imm = 0x2EE
leaq 0x6f5d2(%rip), %rcx # 0x770ce
movb $0x0, %al
callq 0x23600
jmp 0x828a
movq -0x50(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7150
movl $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x276a0
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x820b
movq $0x0, -0xe8(%rbp)
movq $0x0, -0xf0(%rbp)
movq $0x0, -0xf8(%rbp)
movq $0x0, -0x100(%rbp)
movq $0x0, -0x108(%rbp)
movq $0x0, -0x110(%rbp)
movq $0x0, -0x118(%rbp)
movq $0x0, -0x120(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0x7c05
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x276a0
movq %rax, -0xe8(%rbp)
cmpq $0x0, -0xe8(%rbp)
jne 0x7bed
movl $0x3, %edi
leaq 0x6d44c(%rip), %rsi # 0x7500c
movl $0x2ff, %edx # imm = 0x2FF
leaq 0x6f530(%rip), %rcx # 0x770fc
movb $0x0, %al
callq 0x23450
movq -0x30(%rbp), %rdi
callq 0x23e40
movq -0xe8(%rbp), %rdi
callq 0x23e40
jmp 0x828a
movq -0xe8(%rbp), %rdi
movl $0x2, %esi
callq 0x1b990
movq %rax, -0x110(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0x7c7b
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x276a0
movq %rax, -0xf0(%rbp)
cmpq $0x0, -0xf0(%rbp)
jne 0x7c63
movl $0x3, %edi
leaq 0x6d3d6(%rip), %rsi # 0x7500c
movl $0x309, %edx # imm = 0x309
leaq 0x6f4ef(%rip), %rcx # 0x77131
movb $0x0, %al
callq 0x23450
movq -0x30(%rbp), %rdi
callq 0x23e40
movq -0xf0(%rbp), %rdi
callq 0x23e40
jmp 0x828a
movq -0xf0(%rbp), %rdi
movl $0x2, %esi
callq 0x1b990
movq %rax, -0x108(%rbp)
cmpq $0x0, -0x68(%rbp)
je 0x7cf1
movq -0x68(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x276a0
movq %rax, -0xf8(%rbp)
cmpq $0x0, -0xf8(%rbp)
jne 0x7cd9
movl $0x3, %edi
leaq 0x6d360(%rip), %rsi # 0x7500c
movl $0x313, %edx # imm = 0x313
leaq 0x6f4ac(%rip), %rcx # 0x77164
movb $0x0, %al
callq 0x23450
movq -0x30(%rbp), %rdi
callq 0x23e40
movq -0xf8(%rbp), %rdi
callq 0x23e40
jmp 0x828a
movq -0xf8(%rbp), %rdi
movl $0x2, %esi
callq 0x1b990
movq %rax, -0x100(%rbp)
cmpq $0x0, -0x70(%rbp)
je 0x7d67
movq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x276a0
movq %rax, -0x118(%rbp)
cmpq $0x0, -0x118(%rbp)
jne 0x7d4f
movl $0x3, %edi
leaq 0x6d2ea(%rip), %rsi # 0x7500c
movl $0x31d, %edx # imm = 0x31D
leaq 0x6f46a(%rip), %rcx # 0x77198
movb $0x0, %al
callq 0x23450
movq -0x30(%rbp), %rdi
callq 0x23e40
movq -0x118(%rbp), %rdi
callq 0x23e40
jmp 0x828a
movq -0x118(%rbp), %rdi
movl $0x2, %esi
callq 0x1b990
movq %rax, -0x120(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x7d7d
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x81cd
cmpl $-0x1, -0x20(%rbp)
je 0x7d95
movl -0x28(%rbp), %eax
movl -0x1c(%rbp), %ecx
addl -0x20(%rbp), %ecx
cmpl %ecx, %eax
jl 0x7d95
jmp 0x81cd
movl $0x0, -0xd8(%rbp)
movl $0xffffffff, -0xdc(%rbp) # imm = 0xFFFFFFFF
movq -0x30(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
movl $0x4, %edx
callq 0x1ba80
movl %eax, -0xd4(%rbp)
cmpl $0x0, -0xd4(%rbp)
jne 0x7dd2
jmp 0x81c4
cmpl $0x0, -0xd4(%rbp)
jge 0x7e03
movl -0x28(%rbp), %r8d
movl $0x3, %edi
leaq 0x6d221(%rip), %rsi # 0x7500c
movl $0x334, %edx # imm = 0x334
leaq 0x6f3d7(%rip), %rcx # 0x771ce
movb $0x0, %al
callq 0x23450
jmp 0x81c2
movq $0x0, -0x128(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, -0x130(%rbp)
cmpl $0x1, -0xd4(%rbp)
jle 0x7e37
movq -0xc8(%rbp), %rdi
callq 0x73e0
movl %eax, -0xd8(%rbp)
cmpl $0x2, -0xd4(%rbp)
jle 0x7e52
movq -0xc0(%rbp), %rdi
callq 0x73e0
movl %eax, -0xdc(%rbp)
cmpl $0x3, -0xd4(%rbp)
jle 0x7e6b
movq -0xb8(%rbp), %rax
movq %rax, -0x138(%rbp)
jmp 0x7e79
movq -0x130(%rbp), %rax
movq %rax, -0x138(%rbp)
movq -0x138(%rbp), %r8
movl $0x1, %edi
leaq 0x6d180(%rip), %rsi # 0x7500c
movl $0x344, %edx # imm = 0x344
leaq 0x6f368(%rip), %rcx # 0x77200
movb $0x0, %al
callq 0x23450
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x110(%rbp), %rdx
callq 0x82e0
cmpl $0x0, %eax
jge 0x7ebd
jmp 0x7b1c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x108(%rbp), %rdx
callq 0x84b0
cmpl $0x0, %eax
jge 0x7edb
jmp 0x7b1c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x100(%rbp), %rdx
callq 0x8550
cmpl $0x0, %eax
jge 0x7ef9
jmp 0x7b1c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x120(%rbp), %rdx
callq 0x8710
cmpl $0x0, %eax
jge 0x7f17
jmp 0x7b1c
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x130(%rbp), %rdx
movq -0x138(%rbp), %rcx
movl -0xd8(%rbp), %r8d
movl -0xdc(%rbp), %r9d
callq 0x8990
cmpl $0x0, %eax
jge 0x7f4a
jmp 0x7b1c
cmpq $0x0, -0x40(%rbp)
je 0x8023
cmpq $0x0, -0x120(%rbp)
je 0x7fab
movq -0x8(%rbp), %rdi
leaq -0x13c(%rbp), %rsi
callq 0x8db0
movq %rax, -0x148(%rbp)
movq -0x40(%rbp), %rdi
movq -0x148(%rbp), %rdx
movq -0x138(%rbp), %rcx
movl -0x13c(%rbp), %r8d
leaq 0x6f279(%rip), %rsi # 0x7720f
movb $0x0, %al
callq 0x7280
movq -0x148(%rbp), %rdi
callq 0x23e40
jmp 0x8021
movq -0x8(%rbp), %rdi
leaq -0x13c(%rbp), %rsi
callq 0x10b40
movq %rax, -0x128(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x158(%rbp)
cmpq $0x0, -0x128(%rbp)
je 0x7fe7
movq -0x128(%rbp), %rax
movq %rax, -0x160(%rbp)
jmp 0x7ff7
leaq 0x7a6c8(%rip), %rax # 0x826b6
movq %rax, -0x160(%rbp)
jmp 0x7ff7
movq -0x158(%rbp), %rdi
movq -0x160(%rbp), %rdx
movq -0x138(%rbp), %rcx
movl -0x13c(%rbp), %r8d
leaq 0x6f1f5(%rip), %rsi # 0x7720f
movb $0x0, %al
callq 0x7280
jmp 0x8023
cmpq $0x0, -0x48(%rbp)
je 0x803e
movq -0x48(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x138(%rbp), %rdx
callq 0x8f30
cmpq $0x0, -0x50(%rbp)
je 0x8077
movq -0x8(%rbp), %rdi
callq 0xf5a0
movq %rax, -0x150(%rbp)
movq -0x50(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x150(%rbp), %rdx
movq -0x138(%rbp), %rcx
movl -0xa4(%rbp), %r8d
callq 0x9060
cmpq $0x0, -0x90(%rbp)
je 0x8098
movq -0x8(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq -0x138(%rbp), %rdx
callq 0x9300
cmpq $0x0, -0x98(%rbp)
je 0x80b9
movq -0x8(%rbp), %rdi
movq -0x98(%rbp), %rsi
movq -0x138(%rbp), %rdx
callq 0x94a0
movq -0x8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x80(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x11050
movq -0x138(%rbp), %r8
movsd -0x78(%rbp), %xmm0
movsd -0x80(%rbp), %xmm1
movsd -0x88(%rbp), %xmm2
movl $0x1, %edi
leaq 0x6cf16(%rip), %rsi # 0x7500c
movl $0x370, %edx # imm = 0x370
leaq 0x6f119(%rip), %rcx # 0x7721b
movb $0x3, %al
callq 0x23450
movq -0x138(%rbp), %r8
movsd -0x80(%rbp), %xmm0
divsd -0x78(%rbp), %xmm0
movsd -0x88(%rbp), %xmm1
divsd -0x78(%rbp), %xmm1
movl $0x1, %edi
leaq 0x6ced9(%rip), %rsi # 0x7500c
movl $0x372, %edx # imm = 0x372
leaq 0x6f11a(%rip), %rcx # 0x77259
movb $0x2, %al
callq 0x23450
cmpq $0x0, -0x128(%rbp)
je 0x8160
movq -0x128(%rbp), %rax
movq %rax, -0x168(%rbp)
jmp 0x8170
leaq 0x7a54f(%rip), %rax # 0x826b6
movq %rax, -0x168(%rbp)
jmp 0x8170
movq -0x168(%rbp), %r8
movq -0x138(%rbp), %r9
movl -0x13c(%rbp), %eax
movl $0x1, %edi
xorl %ecx, %ecx
movl %ecx, %edx
leaq 0x6f07b(%rip), %rcx # 0x7720f
movq %rdx, %rsi
movl %eax, (%rsp)
movb $0x0, %al
callq 0x23450
movq -0x138(%rbp), %r8
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
leaq 0x6f0c9(%rip), %rcx # 0x77281
movq %rdx, %rsi
movb $0x0, %al
callq 0x23450
jmp 0x81c4
movl -0x24(%rbp), %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x118(%rbp), %rdi
callq 0x23e40
movq -0xe8(%rbp), %rdi
callq 0x23e40
movq -0xf8(%rbp), %rdi
callq 0x23e40
movq -0xf0(%rbp), %rdi
callq 0x23e40
movq -0x30(%rbp), %rdi
callq 0x23e40
jmp 0x7b1c
movq -0x8(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x80(%rbp), %rdx
leaq -0x88(%rbp), %rcx
callq 0x110d0
movsd -0x78(%rbp), %xmm0
movsd -0x80(%rbp), %xmm1
movsd -0x88(%rbp), %xmm2
movl $0x1, %edi
leaq 0x6cdcb(%rip), %rsi # 0x7500c
movl $0x382, %edx # imm = 0x382
leaq 0x6f064(%rip), %rcx # 0x772b1
movb $0x3, %al
callq 0x23450
movsd -0x80(%rbp), %xmm0
divsd -0x78(%rbp), %xmm0
movsd -0x88(%rbp), %xmm1
divsd -0x78(%rbp), %xmm1
movl $0x1, %edi
leaq 0x6cd95(%rip), %rsi # 0x7500c
movl $0x384, %edx # imm = 0x384
leaq 0x6f06e(%rip), %rcx # 0x772f1
movb $0x2, %al
callq 0x23450
cmpq $0x0, -0x40(%rbp)
je 0x829a
movq -0x40(%rbp), %rdi
callq 0x7120
cmpq $0x0, -0x48(%rbp)
je 0x82aa
movq -0x48(%rbp), %rdi
callq 0x7120
cmpq $0x0, -0x50(%rbp)
je 0x82ba
movq -0x50(%rbp), %rdi
callq 0x7120
cmpq $0x0, -0x70(%rbp)
je 0x82ca
movq -0x70(%rbp), %rdi
callq 0x7120
addq $0x170, %rsp # imm = 0x170
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/programs/pocketsphinx_batch.c |
process_lmnamectl_line | static int
process_lmnamectl_line(ps_decoder_t *ps, cmd_ln_t *config, char const *lmname)
{
(void)config;
if (!lmname)
return 0;
E_INFO("Using language model: %s\n", lmname);
if (ps_activate_search(ps, lmname)) {
E_ERROR("No such language model: %s\n", lmname);
return -1;
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x84d4
movl $0x0, -0x4(%rbp)
jmp 0x853c
movq -0x20(%rbp), %r8
movl $0x1, %edi
leaq 0x6cb28(%rip), %rsi # 0x7500c
movl $0x14f, %edx # imm = 0x14F
leaq 0x6ee3f(%rip), %rcx # 0x7732f
movb $0x0, %al
callq 0x23450
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xe690
cmpl $0x0, %eax
je 0x8535
movq -0x20(%rbp), %r8
movl $0x3, %edi
leaq 0x6caf3(%rip), %rsi # 0x7500c
movl $0x151, %edx # imm = 0x151
leaq 0x6ee24(%rip), %rcx # 0x77349
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x853c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/programs/pocketsphinx_batch.c |
write_ctm | static int
write_ctm(FILE *fh, ps_decoder_t *ps, ps_seg_t *itor, char const *uttid, int32 frate)
{
logmath_t *lmath = ps_get_logmath(ps);
char *dupid, *show, *channel, *c;
double ustart = 0.0;
/* We have semi-standardized on comma-separated uttids which
* correspond to the fields of the STM file. So if there's a
* comma in the uttid, take the first two fields as show and
* channel, and also try to find the start time. */
show = dupid = ckd_salloc(uttid ? uttid : "(null)");
if ((c = strchr(dupid, ',')) != NULL) {
*c++ = '\0';
channel = c;
if ((c = strchr(c, ',')) != NULL) {
*c++ = '\0';
if ((c = strchr(c, ',')) != NULL) {
ustart = atof_c(c + 1);
}
}
}
else {
channel = NULL;
}
while (itor) {
int32 prob, sf, ef, wid;
char const *w;
/* Skip things that aren't "real words" (FIXME: currently
* requires s3kr3t h34d3rz...) */
w = ps_seg_word(itor);
wid = dict_wordid(ps->dict, w);
if (wid >= 0 && dict_real_word(ps->dict, wid)) {
prob = ps_seg_prob(itor, NULL, NULL, NULL);
ps_seg_frames(itor, &sf, &ef);
fprintf(fh, "%s %s %.2f %.2f %s %.3f\n",
show,
channel ? channel : "1",
ustart + (double)sf / frate,
(double)(ef - sf) / frate,
/* FIXME: More s3kr3tz */
dict_basestr(ps->dict, wid),
logmath_exp(lmath, prob));
}
itor = ps_seg_next(itor);
}
ckd_free(dupid);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movq -0x10(%rbp), %rdi
callq 0xece0
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x58(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x90a5
movq -0x20(%rbp), %rax
movq %rax, -0x78(%rbp)
jmp 0x90b2
leaq 0x6e47b(%rip), %rax # 0x77527
movq %rax, -0x78(%rbp)
jmp 0x90b2
movq -0x78(%rbp), %rdi
leaq 0x6bf4f(%rip), %rsi # 0x7500c
movl $0x25e, %edx # imm = 0x25E
callq 0x23d20
movq %rax, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movl $0x2c, %esi
callq 0x7160
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x9159
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x50(%rbp)
movb $0x0, (%rax)
movq -0x50(%rbp), %rax
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rdi
movl $0x2c, %esi
callq 0x7160
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x9157
movq -0x50(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x50(%rbp)
movb $0x0, (%rax)
movq -0x50(%rbp), %rdi
movl $0x2c, %esi
callq 0x7160
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0x9155
movq -0x50(%rbp), %rdi
addq $0x1, %rdi
callq 0x1b770
movsd %xmm0, -0x58(%rbp)
jmp 0x9157
jmp 0x9161
movq $0x0, -0x48(%rbp)
jmp 0x9163
cmpq $0x0, -0x18(%rbp)
je 0x92e8
movq -0x18(%rbp), %rdi
callq 0x10be0
movq %rax, -0x70(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x70(%rbp), %rsi
callq 0xabd0
movl %eax, -0x68(%rbp)
cmpl $0x0, -0x68(%rbp)
jl 0x92d6
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x68(%rbp), %esi
callq 0xa090
cmpl $0x0, %eax
je 0x92d6
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rsi
movq %rcx, %rdx
callq 0x10c40
movl %eax, -0x5c(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x64(%rbp), %rdx
callq 0x10c00
movq -0x8(%rbp), %rax
movq %rax, -0x88(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0x9200
movq -0x48(%rbp), %rax
movq %rax, -0x90(%rbp)
jmp 0x9210
leaq 0x73e4f(%rip), %rax # 0x7d056
movq %rax, -0x90(%rbp)
jmp 0x9210
movq -0x90(%rbp), %rax
movq %rax, -0xb0(%rbp)
movsd -0x58(%rbp), %xmm0
cvtsi2sdl -0x60(%rbp), %xmm1
cvtsi2sdl -0x24(%rbp), %xmm2
divsd %xmm2, %xmm1
addsd %xmm1, %xmm0
movsd %xmm0, -0x98(%rbp)
movl -0x64(%rbp), %eax
subl -0x60(%rbp), %eax
cvtsi2sd %eax, %xmm0
cvtsi2sdl -0x24(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0xa8(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x18(%rcx), %rcx
movq 0x10(%rcx), %rcx
movslq -0x68(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movslq 0x18(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0xa0(%rbp)
movq -0x30(%rbp), %rdi
movl -0x5c(%rbp), %esi
callq 0x25c80
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rdx
movq -0xb0(%rbp), %rcx
movsd -0xa8(%rbp), %xmm1
movq -0xa0(%rbp), %r8
movaps %xmm0, %xmm2
movsd -0x98(%rbp), %xmm0
leaq 0x6e25f(%rip), %rsi # 0x7752e
movb $0x3, %al
callq 0x7280
movq -0x18(%rbp), %rdi
callq 0xf630
movq %rax, -0x18(%rbp)
jmp 0x9163
movq -0x38(%rbp), %rdi
callq 0x23e40
xorl %eax, %eax
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
| /cmusphinx[P]pocketsphinx/programs/pocketsphinx_batch.c |
build_outdirs | static int
build_outdirs(cmd_ln_t *config, char const *uttid)
{
char *uttpath = ckd_salloc(uttid);
path2dirname(uttid, uttpath);
build_outdir_one(config, "outlatdir", uttpath);
build_outdir_one(config, "mfclogdir", uttpath);
build_outdir_one(config, "rawlogdir", uttpath);
build_outdir_one(config, "senlogdir", uttpath);
build_outdir_one(config, "nbestdir", uttpath);
ckd_free(uttpath);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x6b9e1(%rip), %rsi # 0x7500c
movl $0x19b, %edx # imm = 0x19B
callq 0x23d20
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20cb0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6d7e9(%rip), %rsi # 0x76e3e
callq 0x99d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6d236(%rip), %rsi # 0x7689f
callq 0x99d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6d24e(%rip), %rsi # 0x768cb
callq 0x99d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6d268(%rip), %rsi # 0x768f9
callq 0x99d0
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x6d8c4(%rip), %rsi # 0x76f69
callq 0x99d0
movq -0x18(%rbp), %rdi
callq 0x23e40
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /cmusphinx[P]pocketsphinx/programs/pocketsphinx_batch.c |
dict_word2basestr | int32
dict_word2basestr(char *word)
{
int32 i, len;
len = strlen(word);
if (word[len - 1] == ')') {
for (i = len - 2; (i > 0) && (word[i] != '('); --i);
if (i > 0) {
/* The word is of the form <baseword>(...); strip from left-paren */
word[i] = '\0';
return i;
}
}
return -1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7130
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x29, %eax
jne 0x9e79
movl -0x18(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x19(%rbp)
jle 0x9e47
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x28, %eax
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x9e50
jmp 0x9e5d
jmp 0x9e52
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9e27
cmpl $0x0, -0x14(%rbp)
jle 0x9e77
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x9e80
jmp 0x9e79
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
| /cmusphinx[P]pocketsphinx/src/dict.c |
dict_free | int
dict_free(dict_t * d)
{
int i;
dictword_t *word;
if (d == NULL)
return 0;
if (--d->refcnt > 0)
return d->refcnt;
/* First Step, free all memory allocated for each word */
for (i = 0; i < d->n_word; i++) {
word = (dictword_t *) & (d->word[i]);
if (word->word)
ckd_free((void *) word->word);
if (word->ciphone)
ckd_free((void *) word->ciphone);
}
if (d->word)
ckd_free((void *) d->word);
if (d->ht)
hash_table_free(d->ht);
if (d->mdef)
bin_mdef_free(d->mdef);
ckd_free((void *) d);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xac8f
movl $0x0, -0x4(%rbp)
jmp 0xad6a
movq -0x10(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jle 0xacad
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xad6a
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x24(%rcx), %eax
jge 0xad12
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0xaced
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x23e40
movq -0x20(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xad05
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x23e40
jmp 0xad07
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xacb4
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xad2a
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x23e40
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0xad42
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x23160
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xad5a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2e220
movq -0x10(%rbp), %rdi
callq 0x23e40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/dict.c |
fsg_model_trans | glist_t
fsg_model_trans(fsg_model_t * fsg, int32 i, int32 j)
{
void *val;
if (fsg->trans[i].trans == NULL)
return NULL;
if (hash_table_lookup_bkey(fsg->trans[i].trans, (char const *) &j,
sizeof(j), &val) < 0)
return NULL;
return (glist_t) val;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
jne 0xb0e6
movq $0x0, -0x8(%rbp)
jmp 0xb126
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
leaq -0x20(%rbp), %rcx
callq 0x22540
cmpl $0x0, %eax
jge 0xb11e
movq $0x0, -0x8(%rbp)
jmp 0xb126
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
| /cmusphinx[P]pocketsphinx/src/lm/fsg_model.c |
fsg_model_null_trans | fsg_link_t *
fsg_model_null_trans(fsg_model_t * fsg, int32 i, int32 j)
{
void *val;
if (fsg->trans[i].null_trans == NULL)
return NULL;
if (hash_table_lookup_bkey(fsg->trans[i].null_trans, (char const *) &j,
sizeof(j), &val) < 0)
return NULL;
return (fsg_link_t *) val;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0xb305
movq $0x0, -0x8(%rbp)
jmp 0xb344
movq -0x10(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
leaq -0x18(%rbp), %rsi
movl $0x4, %edx
leaq -0x20(%rbp), %rcx
callq 0x22540
cmpl $0x0, %eax
jge 0xb33c
movq $0x0, -0x8(%rbp)
jmp 0xb344
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| /cmusphinx[P]pocketsphinx/src/lm/fsg_model.c |
fsg_model_null_trans_closure | glist_t
fsg_model_null_trans_closure(fsg_model_t * fsg, glist_t nulls)
{
gnode_t *gn1;
int updated;
fsg_link_t *tl1, *tl2;
int32 k, n;
E_INFO("Computing transitive closure for null transitions\n");
/* If our caller didn't give us a list of null-transitions,
make such a list. Just loop through all the FSG states,
and all the null-transitions in that state (which are kept in
their own hash table). */
if (nulls == NULL) {
int i;
for (i = 0; i < fsg->n_state; ++i) {
hash_iter_t *itor;
hash_table_t *null_trans = fsg->trans[i].null_trans;
if (null_trans == NULL)
continue;
for (itor = hash_table_iter(null_trans);
itor != NULL; itor = hash_table_iter_next(itor)) {
nulls = glist_add_ptr(nulls, hash_entry_val(itor->ent));
}
}
}
/*
* Probably not the most efficient closure implementation, in general, but
* probably reasonably efficient for a sparse null transition matrix.
*/
n = 0;
do {
updated = FALSE;
for (gn1 = nulls; gn1; gn1 = gnode_next(gn1)) {
hash_iter_t *itor;
tl1 = (fsg_link_t *) gnode_ptr(gn1);
assert(tl1->wid < 0);
if (fsg->trans[tl1->to_state].null_trans == NULL)
continue;
for (itor =
hash_table_iter(fsg->trans[tl1->to_state].null_trans);
itor; itor = hash_table_iter_next(itor)) {
tl2 = (fsg_link_t *) hash_entry_val(itor->ent);
k = fsg_model_null_trans_add(fsg,
tl1->from_state,
tl2->to_state,
tl1->logs2prob +
tl2->logs2prob);
if (k >= 0) {
updated = TRUE;
if (k > 0) {
nulls = glist_add_ptr(nulls, (void *)
fsg_model_null_trans
(fsg, tl1->from_state,
tl2->to_state));
n++;
}
}
}
}
} while (updated);
E_INFO("%d null transitions added\n", n);
return nulls;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, %edi
leaq 0x6c774(%rip), %rsi # 0x77b20
movl $0xbe, %edx
leaq 0x6c853(%rip), %rcx # 0x77c0b
movb $0x0, %al
callq 0x23450
cmpq $0x0, -0x10(%rbp)
jne 0xb44b
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0xb449
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x3c(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
jne 0xb400
jmp 0xb43e
movq -0x50(%rbp), %rdi
callq 0x22fe0
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
je 0xb43c
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rsi
callq 0x25e50
movq %rax, -0x10(%rbp)
movq -0x48(%rbp), %rdi
callq 0x23030
movq %rax, -0x48(%rbp)
jmp 0xb40d
jmp 0xb43e
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xb3d1
jmp 0xb44b
movl $0x0, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xb59c
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x0, 0xc(%rax)
jge 0xb483
jmp 0xb4a2
leaq 0x6c7b4(%rip), %rdi # 0x77c3e
leaq 0x6c68f(%rip), %rsi # 0x77b20
movl $0xde, %edx
leaq 0x6c7ae(%rip), %rcx # 0x77c4b
callq 0x71c0
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x28(%rbp), %rcx
movslq 0x4(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
jne 0xb4c4
jmp 0xb58b
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x28(%rbp), %rcx
movslq 0x4(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x22fe0
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
je 0xb589
movq -0x58(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
movq -0x30(%rbp), %rax
movl 0x4(%rax), %edx
movq -0x28(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x30(%rbp), %rax
addl 0x8(%rax), %ecx
callq 0xb350
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0xb575
movl $0x1, -0x1c(%rbp)
cmpl $0x0, -0x34(%rbp)
jle 0xb573
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
movq -0x30(%rbp), %rax
movl 0x4(%rax), %edx
callq 0xb2d0
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x25e50
movq %rax, -0x10(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xb575
jmp 0xb577
movq -0x58(%rbp), %rdi
callq 0x23030
movq %rax, -0x58(%rbp)
jmp 0xb4e7
jmp 0xb58b
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xb461
jmp 0xb59e
cmpl $0x0, -0x1c(%rbp)
jne 0xb452
movl -0x38(%rbp), %r8d
movl $0x1, %edi
leaq 0x6c568(%rip), %rsi # 0x77b20
movl $0xfc, %edx
leaq 0x6c6c4(%rip), %rcx # 0x77c88
movb $0x0, %al
callq 0x23450
movq -0x10(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/lm/fsg_model.c |
nextline_str2words | static int32
nextline_str2words(FILE * fp, int32 * lineno,
char **lineptr, char ***wordptr)
{
for (;;) {
size_t len;
int32 n;
ckd_free(*lineptr);
if ((*lineptr = fread_line(fp, &len)) == NULL)
return -1;
(*lineno)++;
if ((*lineptr)[0] == FSG_MODEL_COMMENT_CHAR)
continue; /* Skip comment lines */
n = str2words(*lineptr, NULL, 0);
if (n == 0)
continue; /* Skip blank lines */
/* Abuse of realloc(), but this doesn't have to be fast. */
if (*wordptr == NULL)
*wordptr = ckd_calloc(n, sizeof(**wordptr));
else
*wordptr = ckd_realloc(*wordptr, n * sizeof(**wordptr));
return str2words(*lineptr, *wordptr, n);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x23e40
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x276a0
movq -0x20(%rbp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
jne 0xc87a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc926
movq -0x18(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0xc896
jmp 0xc848
movq -0x20(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x1ba80
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jne 0xc8b3
jmp 0xc848
movq -0x28(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xc8e3
movslq -0x34(%rbp), %rdi
movl $0x8, %esi
leaq 0x6b253(%rip), %rdx # 0x77b20
movl $0x55, %ecx
callq 0x23c10
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
jmp 0xc90d
movq -0x28(%rbp), %rax
movq (%rax), %rdi
movslq -0x34(%rbp), %rsi
shlq $0x3, %rsi
leaq 0x6b227(%rip), %rdx # 0x77b20
movl $0x57, %ecx
callq 0x23cc0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movl -0x34(%rbp), %edx
callq 0x1ba80
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nop
| /cmusphinx[P]pocketsphinx/src/lm/fsg_model.c |
fsg_model_writefile | void
fsg_model_writefile(fsg_model_t * fsg, char const *file)
{
FILE *fp;
assert(fsg);
E_INFO("Writing FSG file '%s'\n", file);
if ((fp = fopen(file, "w")) == NULL) {
E_ERROR_SYSTEM("Failed to open FSG file '%s' for reading", file);
return;
}
fsg_model_write(fsg, fp);
fclose(fp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0xcdc9
jmp 0xcde8
leaq 0x6988c(%rip), %rdi # 0x7665c
leaq 0x6ad49(%rip), %rsi # 0x77b20
movl $0x33b, %edx # imm = 0x33B
leaq 0x6b1ea(%rip), %rcx # 0x77fcd
callq 0x71c0
movq -0x10(%rbp), %r8
movl $0x1, %edi
leaq 0x6ad28(%rip), %rsi # 0x77b20
movl $0x33d, %edx # imm = 0x33D
leaq 0x6b1ff(%rip), %rcx # 0x78003
movb $0x0, %al
callq 0x23450
movq -0x10(%rbp), %rdi
leaq 0x6b868(%rip), %rsi # 0x7867e
callq 0x7380
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0xce4a
movq -0x10(%rbp), %r8
movl $0x3, %edi
leaq 0x6aceb(%rip), %rsi # 0x77b20
movl $0x340, %edx # imm = 0x340
leaq 0x6b145(%rip), %rcx # 0x77f86
movb $0x0, %al
callq 0x23600
jmp 0xce60
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xcbb0
movq -0x18(%rbp), %rdi
callq 0x7120
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/lm/fsg_model.c |
fsg_model_write_fsm | void
fsg_model_write_fsm(fsg_model_t * fsg, FILE * fp)
{
int i;
/* Write transitions from initial state first. */
fsg_model_write_fsm_trans(fsg, fsg_model_start_state(fsg), fp);
/* Other states. */
for (i = 0; i < fsg->n_state; i++) {
if (i == fsg_model_start_state(fsg))
continue;
fsg_model_write_fsm_trans(fsg, i, fp);
}
/* Final state. */
fprintf(fp, "%d 0\n", fsg_model_final_state(fsg));
fflush(fp);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x3c(%rax), %esi
movq -0x10(%rbp), %rdx
callq 0xcf00
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0xced0
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x3c(%rcx), %eax
jne 0xceb5
jmp 0xcec5
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x10(%rbp), %rdx
callq 0xcf00
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xce9b
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x40(%rax), %edx
leaq 0x6b138(%rip), %rsi # 0x7801a
movb $0x0, %al
callq 0x7280
movq -0x10(%rbp), %rdi
callq 0x72f0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/lm/fsg_model.c |
apply_closure | static void
apply_closure(fsg_model_t *fsg, bitvec_t *active)
{
int state;
/* This is a bit slow, sorry. */
for (state = 0; state < fsg_model_n_state(fsg); ++state) {
hash_table_t *null_trans;
hash_iter_t *itor;
if (!bitvec_is_set(active, state))
continue;
null_trans = fsg->trans[state].null_trans;
if (null_trans == NULL)
continue;
/* We assume closure has already been done, so no need to
* continue following epsilons. */
for (itor = hash_table_iter(null_trans);
itor != NULL; itor = hash_table_iter_next(itor)) {
fsg_link_t *link = (fsg_link_t *)hash_entry_val(itor->ent);
bitvec_set(active, link->to_state);
E_INFO("epsilon %d -> %d\n", state, link->to_state);
}
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jge 0xd721
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x38(%rbp), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl -0x14(%rbp), %ecx
andl $0x1f, %ecx
movl %ecx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
andq %rcx, %rax
cmpq $0x0, %rax
jne 0xd647
jmp 0xd713
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xd66d
jmp 0xd713
movq -0x20(%rbp), %rdi
callq 0x22fe0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xd711
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
andl $0x1f, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %esi
shlq %cl, %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %eax
movl $0x20, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq -0x40(%rbp), %rax
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
orq %rsi, %rdx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %r8d
movq -0x30(%rbp), %rax
movl 0x4(%rax), %r9d
movl $0x1, %edi
leaq 0x6a434(%rip), %rsi # 0x77b20
movl $0x3b4, %edx # imm = 0x3B4
leaq 0x6aa79(%rip), %rcx # 0x78171
movb $0x0, %al
callq 0x23450
movq -0x28(%rbp), %rdi
callq 0x23030
movq %rax, -0x28(%rbp)
jmp 0xd67a
jmp 0xd713
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xd5f7
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/lm/fsg_model.c |
ps_expand_file_config | static void
ps_expand_file_config(ps_config_t *config, const char *arg,
const char *hmmdir, const char *file)
{
const char *val;
if ((val = ps_config_str(config, arg)) == NULL) {
char *tmp = string_join(hmmdir, "/", file, NULL);
if (file_exists(tmp))
ps_config_set_str(config, arg, tmp);
else
ps_config_set_str(config, arg, NULL);
ckd_free(tmp);
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x13700
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0xd958
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x69a0f(%rip), %rsi # 0x7731d
xorl %eax, %eax
movl %eax, %ecx
movb $0x0, %al
callq 0x1b790
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xdd00
cmpl $0x0, %eax
je 0xd93e
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x13e10
jmp 0xd94f
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x13e10
movq -0x30(%rbp), %rdi
callq 0x23e40
addq $0x30, %rsp
popq %rbp
retq
nop
| /cmusphinx[P]pocketsphinx/src/pocketsphinx.c |
hmmdir_exists | static int
hmmdir_exists(const char *path)
{
FILE *tmp;
char *mdef = string_join(path, "/means", NULL);
tmp = fopen(mdef, "rb");
if (tmp) fclose(tmp);
ckd_free(mdef);
return (tmp != NULL);
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x6ab78(%rip), %rsi # 0x7881f
xorl %eax, %eax
movl %eax, %edx
movb $0x0, %al
callq 0x1b790
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
leaq 0x6976b(%rip), %rsi # 0x7742c
callq 0x7380
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xdcda
movq -0x10(%rbp), %rdi
callq 0x7120
movq -0x18(%rbp), %rdi
callq 0x23e40
cmpq $0x0, -0x10(%rbp)
setne %al
andb $0x1, %al
movzbl %al, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/pocketsphinx.c |
ps_reinit | int
ps_reinit(ps_decoder_t *ps, ps_config_t *config)
{
const char *path;
const char *keyphrase;
int32 lw;
/* Enforce only one of keyphrase, kws, fsg, jsgf, allphone, lm */
if (config) {
if (ps_config_validate(config) < 0)
return -1;
}
else if (ps->config) {
if (ps_config_validate(ps->config) < 0)
return -1;
}
if (config && config != ps->config) {
ps_config_free(ps->config);
ps->config = ps_config_retain(config);
}
/* Set up logging. We need to do this earlier because we want to dump
* the information to the configured log, not to the stderr. */
if (config) {
const char *logfn, *loglevel;
logfn = ps_config_str(ps->config, "logfn");
if (logfn) {
if (err_set_logfile(logfn) < 0) {
E_ERROR("Cannot redirect log output\n");
return -1;
}
}
loglevel = ps_config_str(ps->config, "loglevel");
if (loglevel) {
if (err_set_loglevel_str(loglevel) == NULL) {
E_ERROR("Invalid log level: %s\n", loglevel);
return -1;
}
}
}
ps->mfclogdir = ps_config_str(ps->config, "mfclogdir");
ps->rawlogdir = ps_config_str(ps->config, "rawlogdir");
ps->senlogdir = ps_config_str(ps->config, "senlogdir");
/* Fill in some default arguments. */
ps_expand_model_config(ps->config);
/* Print out the config for logging. */
cmd_ln_log_values_r(ps->config, ps_args());
/* Free old searches (do this before other reinit) */
ps_free_searches(ps);
ps->searches = hash_table_new(3, HASH_CASE_YES);
/* Free old acmod. */
acmod_free(ps->acmod);
ps->acmod = NULL;
/* Free old dictionary (must be done after the two things above) */
dict_free(ps->dict);
ps->dict = NULL;
/* Free d2p */
dict2pid_free(ps->d2p);
ps->d2p = NULL;
/* Logmath computation (used in acmod and search) */
if (ps->lmath == NULL
|| (logmath_get_base(ps->lmath) !=
ps_config_float(ps->config, "logbase"))) {
if (ps->lmath)
logmath_free(ps->lmath);
ps->lmath = logmath_init
(ps_config_float(ps->config, "logbase"), 0, TRUE);
}
/* Acoustic model (this is basically everything that
* uttproc.c, senscr.c, and others used to do) */
if ((ps->acmod = acmod_init(ps->config, ps->lmath, NULL, NULL)) == NULL)
return -1;
if (ps_config_int(ps->config, "pl_window") > 0) {
/* Initialize an auxiliary phone loop search, which will run in
* "parallel" with FSG or N-Gram search. */
if ((ps->phone_loop =
phone_loop_search_init(ps->config, ps->acmod, ps->dict)) == NULL)
return -1;
hash_table_enter(ps->searches,
ps_search_name(ps->phone_loop),
ps->phone_loop);
}
/* Dictionary and triphone mappings (depends on acmod). */
/* FIXME: pass config, change arguments, implement LTS, etc. */
if ((ps->dict = dict_init(ps->config, ps->acmod->mdef)) == NULL)
return -1;
if ((ps->d2p = dict2pid_build(ps->acmod->mdef, ps->dict)) == NULL)
return -1;
lw = ps_config_float(ps->config, "lw");
/* Determine whether we are starting out in FSG or N-Gram search mode.
* If neither is used skip search initialization. */
if ((keyphrase = ps_config_str(ps->config, "keyphrase"))) {
if (ps_add_keyphrase(ps, PS_DEFAULT_SEARCH, keyphrase))
return -1;
ps_activate_search(ps, PS_DEFAULT_SEARCH);
}
else if ((path = ps_config_str(ps->config, "kws"))) {
if (ps_add_kws(ps, PS_DEFAULT_SEARCH, path))
return -1;
ps_activate_search(ps, PS_DEFAULT_SEARCH);
}
else if ((path = ps_config_str(ps->config, "fsg"))) {
fsg_model_t *fsg = fsg_model_readfile(path, ps->lmath, lw);
if (!fsg)
return -1;
if (ps_add_fsg(ps, PS_DEFAULT_SEARCH, fsg)) {
fsg_model_free(fsg);
return -1;
}
fsg_model_free(fsg);
ps_activate_search(ps, PS_DEFAULT_SEARCH);
}
else if ((path = ps_config_str(ps->config, "jsgf"))) {
if (ps_add_jsgf_file(ps, PS_DEFAULT_SEARCH, path)
|| ps_activate_search(ps, PS_DEFAULT_SEARCH))
return -1;
}
else if ((path = ps_config_str(ps->config, "allphone"))) {
if (ps_add_allphone_file(ps, PS_DEFAULT_SEARCH, path)
|| ps_activate_search(ps, PS_DEFAULT_SEARCH))
return -1;
}
else if ((path = ps_config_str(ps->config, "lm"))) {
if (ps_add_lm_file(ps, PS_DEFAULT_SEARCH, path)
|| ps_activate_search(ps, PS_DEFAULT_SEARCH))
return -1;
}
else if ((path = ps_config_str(ps->config, "lmctl"))) {
const char *name;
ngram_model_t *lmset;
ngram_model_set_iter_t *lmset_it;
if (!(lmset = ngram_model_set_read(ps->config, path, ps->lmath))) {
E_ERROR("Failed to read language model control file: %s\n", path);
return -1;
}
for(lmset_it = ngram_model_set_iter(lmset);
lmset_it; lmset_it = ngram_model_set_iter_next(lmset_it)) {
ngram_model_t *lm = ngram_model_set_iter_model(lmset_it, &name);
E_INFO("adding search %s\n", name);
if (ps_add_lm(ps, name, lm)) {
ngram_model_set_iter_free(lmset_it);
ngram_model_free(lmset);
return -1;
}
}
ngram_model_free(lmset);
name = ps_config_str(ps->config, "lmname");
if (name)
ps_activate_search(ps, name);
else {
E_ERROR("No default LM name (-lmname) for `-lmctl'\n");
return -1;
}
}
/* Initialize performance timer. */
ps->perf.name = "decode";
ptmr_init(&ps->perf);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xdde6
movq -0x18(%rbp), %rdi
callq 0x13580
cmpl $0x0, %eax
jge 0xdde4
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
jmp 0xde11
movq -0x10(%rbp), %rax
cmpq $0x0, (%rax)
je 0xde0f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x13580
cmpl $0x0, %eax
jge 0xde0d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
jmp 0xde0f
jmp 0xde11
cmpq $0x0, -0x18(%rbp)
je 0xde44
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
je 0xde44
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x13430
movq -0x18(%rbp), %rdi
callq 0x13410
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0xdf08
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x689d7(%rip), %rsi # 0x76834
callq 0x13700
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0xdea8
movq -0x38(%rbp), %rdi
callq 0x239f0
cmpl $0x0, %eax
jge 0xdea6
movl $0x3, %edi
leaq 0x6a34d(%rip), %rsi # 0x781d4
movl $0x105, %edx # imm = 0x105
leaq 0x6a57e(%rip), %rcx # 0x78411
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
jmp 0xdea8
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x689a2(%rip), %rsi # 0x76858
callq 0x13700
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
je 0xdf06
movq -0x40(%rbp), %rdi
callq 0x23390
cmpq $0x0, %rax
jne 0xdf04
movq -0x40(%rbp), %r8
movl $0x3, %edi
leaq 0x6a2ef(%rip), %rsi # 0x781d4
movl $0x10c, %edx # imm = 0x10C
leaq 0x6a53c(%rip), %rcx # 0x7842d
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
jmp 0xdf06
jmp 0xdf08
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x68989(%rip), %rsi # 0x7689f
callq 0x13700
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x90(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x68994(%rip), %rsi # 0x768cb
callq 0x13700
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x689a1(%rip), %rsi # 0x768f9
callq 0x13700
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0xa0(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xd730
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x70(%rbp)
callq 0x13280
movq -0x70(%rbp), %rdi
movq %rax, %rsi
callq 0x21e40
movq -0x10(%rbp), %rdi
callq 0xe5a0
movl $0x3, %edi
xorl %esi, %esi
callq 0x22110
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x28880
movq -0x10(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xac70
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32360
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xe040
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x25a00
movsd %xmm0, -0x78(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x67c23(%rip), %rsi # 0x75c4c
callq 0x14430
movaps %xmm0, %xmm1
movsd -0x78(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jne 0xe040
jp 0xe040
jmp 0xe082
movq -0x10(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0xe058
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x255e0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x67be6(%rip), %rsi # 0x75c4c
callq 0x14430
xorl %edi, %edi
movl $0x1, %esi
callq 0x24ca0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0x28340
movq -0x10(%rbp), %rcx
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
jne 0xe0b7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x67d7e(%rip), %rsi # 0x75e43
callq 0x14360
cmpq $0x0, %rax
jle 0xe127
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdx
callq 0x5aaf0
movq -0x10(%rbp), %rcx
movq %rax, 0x40(%rcx)
cmpq $0x0, %rax
jne 0xe106
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rdx
callq 0x227c0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rax), %rsi
callq 0xa170
movq -0x10(%rbp), %rcx
movq %rax, 0x18(%rcx)
cmpq $0x0, %rax
jne 0xe159
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0x314e0
movq -0x10(%rbp), %rcx
movq %rax, 0x20(%rcx)
cmpq $0x0, %rax
jne 0xe18c
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x68369(%rip), %rsi # 0x76503
callq 0x14430
cvttsd2si %xmm0, %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x68588(%rip), %rsi # 0x7673c
callq 0x13700
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xe1fd
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rdx
leaq 0x6a272(%rip), %rsi # 0x78444
callq 0xe630
cmpl $0x0, %eax
je 0xe1e8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
movq -0x10(%rbp), %rdi
leaq 0x6a251(%rip), %rsi # 0x78444
callq 0xe690
jmp 0xe569
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x6854d(%rip), %rsi # 0x76758
callq 0x13700
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe254
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x6a21b(%rip), %rsi # 0x78444
callq 0xe790
cmpl $0x0, %eax
je 0xe23f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
movq -0x10(%rbp), %rdi
leaq 0x6a1fa(%rip), %rsi # 0x78444
callq 0xe690
jmp 0xe567
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x683fa(%rip), %rsi # 0x7665c
callq 0x13700
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe2ea
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rsi
cvtsi2ssl -0x2c(%rbp), %xmm0
callq 0xca40
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0xe29e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
movq -0x10(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0x6a197(%rip), %rsi # 0x78444
callq 0xe7f0
cmpl $0x0, %eax
je 0xe2cc
movq -0x48(%rbp), %rdi
callq 0xc930
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
movq -0x48(%rbp), %rdi
callq 0xc930
movq -0x10(%rbp), %rdi
leaq 0x6a164(%rip), %rsi # 0x78444
callq 0xe690
jmp 0xe565
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x68390(%rip), %rsi # 0x76688
callq 0x13700
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe346
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x6a12e(%rip), %rsi # 0x78444
callq 0xe850
cmpl $0x0, %eax
jne 0xe335
movq -0x10(%rbp), %rdi
leaq 0x6a119(%rip), %rsi # 0x78444
callq 0xe690
cmpl $0x0, %eax
je 0xe341
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
jmp 0xe563
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x6800b(%rip), %rsi # 0x7635f
callq 0x13700
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe3a2
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x6a0d2(%rip), %rsi # 0x78444
callq 0xe9c0
cmpl $0x0, %eax
jne 0xe391
movq -0x10(%rbp), %rdi
leaq 0x6a0bd(%rip), %rsi # 0x78444
callq 0xe690
cmpl $0x0, %eax
je 0xe39d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
jmp 0xe561
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x68048(%rip), %rsi # 0x763f8
callq 0x13700
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe3fe
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x6a076(%rip), %rsi # 0x78444
callq 0xea30
cmpl $0x0, %eax
jne 0xe3ed
movq -0x10(%rbp), %rdi
leaq 0x6a061(%rip), %rsi # 0x78444
callq 0xe690
cmpl $0x0, %eax
je 0xe3f9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
jmp 0xe55f
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x68016(%rip), %rsi # 0x76422
callq 0x13700
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0xe55d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
callq 0x43c30
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
jne 0xe470
movq -0x20(%rbp), %r8
movl $0x3, %edi
leaq 0x69d83(%rip), %rsi # 0x781d4
movl $0x17c, %edx # imm = 0x17C
leaq 0x69ff0(%rip), %rcx # 0x7844d
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
movq -0x58(%rbp), %rdi
callq 0x445c0
movq %rax, -0x60(%rbp)
cmpq $0x0, -0x60(%rbp)
je 0xe4fd
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x446a0
movq %rax, -0x68(%rbp)
movq -0x50(%rbp), %r8
movl $0x1, %edi
leaq 0x69d2f(%rip), %rsi # 0x781d4
movl $0x183, %edx # imm = 0x183
leaq 0x69fcc(%rip), %rcx # 0x7847d
movb $0x0, %al
callq 0x23450
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x68(%rbp), %rdx
callq 0xeaa0
cmpl $0x0, %eax
je 0xe4ec
movq -0x60(%rbp), %rdi
callq 0x44680
movq -0x58(%rbp), %rdi
callq 0x48680
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
jmp 0xe4ee
movq -0x60(%rbp), %rdi
callq 0x44630
movq %rax, -0x60(%rbp)
jmp 0xe47d
movq -0x58(%rbp), %rdi
callq 0x48680
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x67f34(%rip), %rsi # 0x76448
callq 0x13700
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x50(%rbp)
je 0xe533
movq -0x10(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0xe690
jmp 0xe55b
movl $0x3, %edi
leaq 0x69c95(%rip), %rsi # 0x781d4
movl $0x190, %edx # imm = 0x190
leaq 0x69f44(%rip), %rcx # 0x7848f
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe58c
jmp 0xe55d
jmp 0xe55f
jmp 0xe561
jmp 0xe563
jmp 0xe565
jmp 0xe567
jmp 0xe569
movq -0x10(%rbp), %rax
leaq 0x69f46(%rip), %rcx # 0x784ba
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x249e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/pocketsphinx.c |
ps_activate_search | int
ps_activate_search(ps_decoder_t *ps, const char *name)
{
ps_search_t *search;
if (ps->acmod->state != ACMOD_ENDED && ps->acmod->state != ACMOD_IDLE) {
E_ERROR("Cannot change search while decoding, end utterance first\n");
return -1;
}
if (name == NULL)
name = PS_DEFAULT_SEARCH;
if (!(search = ps_find_search(ps, name)))
return -1;
ps->search = search;
/* Set pl window depending on the search */
if (!strcmp(PS_SEARCH_TYPE_NGRAM, ps_search_type(search))) {
ps->pl_window = ps_config_int(ps->config, "pl_window");
} else {
ps->pl_window = 0;
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movzbl 0xa8(%rax), %eax
cmpl $0x3, %eax
je 0xe6f3
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movzbl 0xa8(%rax), %eax
cmpl $0x0, %eax
je 0xe6f3
movl $0x3, %edi
leaq 0x69b00(%rip), %rsi # 0x781d4
movl $0x1f7, %edx # imm = 0x1F7
leaq 0x69de1(%rip), %rcx # 0x784c1
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe77a
cmpq $0x0, -0x18(%rbp)
jne 0xe705
leaq 0x69d43(%rip), %rax # 0x78444
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xed70
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0xe725
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xe77a
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0x69dbb(%rip), %rdi # 0x784fb
callq 0x7260
cmpl $0x0, %eax
jne 0xe768
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x676eb(%rip), %rsi # 0x75e43
callq 0x14360
movl %eax, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x48(%rax)
jmp 0xe773
movq -0x10(%rbp), %rax
movl $0x0, 0x48(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/pocketsphinx.c |
ps_free | int
ps_free(ps_decoder_t *ps)
{
if (ps == NULL)
return 0;
if (--ps->refcount > 0)
return ps->refcount;
ps_free_searches(ps);
dict_free(ps->dict);
dict2pid_free(ps->d2p);
acmod_free(ps->acmod);
logmath_free(ps->lmath);
ps_config_free(ps->config);
ckd_free(ps);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xec1c
movl $0x0, -0x4(%rbp)
jmp 0xec93
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rcx)
cmpl $0x0, %eax
jle 0xec3a
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0xec93
movq -0x10(%rbp), %rdi
callq 0xe5a0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xac70
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x32360
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x28880
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x255e0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x13430
movq -0x10(%rbp), %rdi
callq 0x23e40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
| /cmusphinx[P]pocketsphinx/src/pocketsphinx.c |
ps_set_alignment | int
ps_set_alignment(ps_decoder_t *ps, ps_alignment_t *al)
{
ps_search_t *search;
int new_alignment = FALSE;
if (al == NULL) {
ps_seg_t *seg;
seg = ps_seg_iter(ps);
if (seg == NULL)
return -1;
al = ps_alignment_init(ps->d2p);
new_alignment = TRUE;
while (seg) {
if (seg->wid == BAD_S3WID) {
E_ERROR("No word ID for segment %s, cannot align\n",
seg->text);
goto error_out;
}
ps_alignment_add_word(al, seg->wid, seg->sf, seg->ef - seg->sf + 1);
seg = ps_seg_next(seg);
}
/* FIXME: Add cionly parameter as in SoundSwallower */
if (ps_alignment_populate(al) < 0)
goto error_out;
}
else
al = ps_alignment_retain(al);
search = state_align_search_init("_state_align", ps->config, ps->acmod, al);
if (search == NULL)
goto error_out;
if (new_alignment)
ps_alignment_free(al);
if (set_search_internal(ps, search) < 0)
goto error_out;
return ps_activate_search(ps, "_state_align");
error_out:
if (new_alignment)
ps_alignment_free(al);
return -1;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0xf510
movq -0x10(%rbp), %rdi
callq 0xf5a0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xf472
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf597
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x113f0
movq %rax, -0x18(%rbp)
movl $0x1, -0x24(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0xf4fe
movq -0x30(%rbp), %rax
cmpl $-0x1, 0x20(%rax)
jne 0xf4c7
movq -0x30(%rbp), %rax
movq 0x10(%rax), %r8
movl $0x3, %edi
leaq 0x68d25(%rip), %rsi # 0x781d4
movl $0x2ed, %edx # imm = 0x2ED
leaq 0x6905c(%rip), %rcx # 0x78517
movb $0x0, %al
callq 0x23450
jmp 0xf581
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movl 0x20(%rax), %esi
movq -0x30(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x30(%rbp), %rax
movl 0x1c(%rax), %ecx
movq -0x30(%rbp), %rax
subl 0x18(%rax), %ecx
addl $0x1, %ecx
callq 0x11500
movq -0x30(%rbp), %rdi
callq 0xf630
movq %rax, -0x30(%rbp)
jmp 0xf48a
movq -0x18(%rbp), %rdi
callq 0x11610
cmpl $0x0, %eax
jge 0xf50e
jmp 0xf581
jmp 0xf51d
movq -0x18(%rbp), %rdi
callq 0x11450
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdx
movq -0x18(%rbp), %rcx
leaq 0x69009(%rip), %rdi # 0x78540
callq 0x1a6e0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0xf549
jmp 0xf581
cmpl $0x0, -0x24(%rbp)
je 0xf558
movq -0x18(%rbp), %rdi
callq 0x11470
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xf0f0
cmpl $0x0, %eax
jge 0xf56c
jmp 0xf581
movq -0x10(%rbp), %rdi
leaq 0x68fc9(%rip), %rsi # 0x78540
callq 0xe690
movl %eax, -0x4(%rbp)
jmp 0xf597
cmpl $0x0, -0x24(%rbp)
je 0xf590
movq -0x18(%rbp), %rdi
callq 0x11470
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
| /cmusphinx[P]pocketsphinx/src/pocketsphinx.c |
ps_add_jsgf_string | int
ps_add_jsgf_string(ps_decoder_t *ps, const char *name, const char *jsgf_string)
{
fsg_model_t *fsg;
jsgf_rule_t *rule;
char const *toprule;
jsgf_t *jsgf = jsgf_parse_string(jsgf_string, NULL);
float lw;
int result;
if (!jsgf)
return -1;
rule = NULL;
/* Take the -toprule if specified. */
if ((toprule = ps_config_str(ps->config, "toprule"))) {
rule = jsgf_get_rule(jsgf, toprule);
if (rule == NULL) {
E_ERROR("Start rule %s not found\n", toprule);
jsgf_grammar_free(jsgf);
return -1;
}
} else {
rule = jsgf_get_public_rule(jsgf);
if (rule == NULL) {
E_ERROR("No public rules found in input string\n");
jsgf_grammar_free(jsgf);
return -1;
}
}
lw = ps_config_float(ps->config, "lw");
fsg = jsgf_build_fsg(jsgf, rule, ps->lmath, lw);
result = ps_add_fsg(ps, name, fsg);
fsg_model_free(fsg);
jsgf_grammar_free(jsgf);
return result;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x426b0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0xf698
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf7bc
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x66ff1(%rip), %rsi # 0x7669f
callq 0x13700
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xf70f
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x41e20
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xf70d
movq -0x38(%rbp), %r8
movl $0x3, %edi
leaq 0x68aef(%rip), %rsi # 0x781d4
movl $0x358, %edx # imm = 0x358
leaq 0x68e5c(%rip), %rcx # 0x7854d
movb $0x0, %al
callq 0x23450
movq -0x40(%rbp), %rdi
callq 0x41820
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf7bc
jmp 0xf756
movq -0x40(%rbp), %rdi
callq 0x41ea0
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0xf754
movl $0x3, %edi
leaq 0x68aa5(%rip), %rsi # 0x781d4
movl $0x35f, %edx # imm = 0x35F
leaq 0x68e48(%rip), %rcx # 0x78583
movb $0x0, %al
callq 0x23450
movq -0x40(%rbp), %rdi
callq 0x41820
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xf7bc
jmp 0xf756
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x66d9f(%rip), %rsi # 0x76503
callq 0x14430
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x44(%rbp)
movq -0x40(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdx
movss -0x44(%rbp), %xmm0
callq 0x42040
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xe7f0
movl %eax, -0x48(%rbp)
movq -0x28(%rbp), %rdi
callq 0xc930
movq -0x40(%rbp), %rdi
callq 0x41820
movl -0x48(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/pocketsphinx.c |
ps_process_raw | int
ps_process_raw(ps_decoder_t *ps,
int16 const *data,
size_t n_samples,
int no_search,
int full_utt)
{
int n_searchfr = 0;
if (ps->acmod->state == ACMOD_IDLE) {
E_ERROR("Failed to process data, utterance is not started. Use start_utt to start it\n");
return 0;
}
if (no_search)
acmod_set_grow(ps->acmod, TRUE);
while (n_samples) {
int nfr;
/* Process some data into features. */
if ((nfr = acmod_process_raw(ps->acmod, &data,
&n_samples, full_utt)) < 0)
return nfr;
/* Score and search as much data as possible */
if (no_search)
continue;
if ((nfr = ps_search_forward(ps)) < 0)
return nfr;
n_searchfr += nfr;
}
return n_searchfr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movzbl 0xa8(%rax), %eax
cmpl $0x0, %eax
jne 0x103de
movl $0x3, %edi
leaq 0x67e12(%rip), %rsi # 0x781d4
movl $0x4ce, %edx # imm = 0x4CE
leaq 0x68337(%rip), %rcx # 0x78705
movb $0x0, %al
callq 0x23450
movl $0x0, -0x4(%rbp)
jmp 0x10459
cmpl $0x0, -0x24(%rbp)
je 0x103f6
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl $0x1, %esi
callq 0x28d60
jmp 0x103f8
cmpq $0x0, -0x20(%rbp)
je 0x10453
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0x28(%rbp), %ecx
leaq -0x18(%rbp), %rsi
leaq -0x20(%rbp), %rdx
callq 0x291f0
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
jge 0x10427
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x10459
cmpl $0x0, -0x24(%rbp)
je 0x1042f
jmp 0x103f8
movq -0x10(%rbp), %rdi
callq 0x10950
movl %eax, -0x30(%rbp)
cmpl $0x0, %eax
jge 0x10448
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x10459
movl -0x30(%rbp), %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x103f8
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/pocketsphinx.c |
ps_end_utt | int
ps_end_utt(ps_decoder_t *ps)
{
int rv, i;
if (ps->search == NULL) {
E_ERROR("No search module is selected, did you forget to "
"specify a language model or grammar?\n");
return -1;
}
if (ps->acmod->state == ACMOD_ENDED || ps->acmod->state == ACMOD_IDLE) {
E_ERROR("Utterance is not started\n");
return -1;
}
acmod_end_utt(ps->acmod);
/* Search any remaining frames. */
if ((rv = ps_search_forward(ps)) < 0) {
ptmr_stop(&ps->perf);
return rv;
}
/* Finish phone loop search. */
if (ps->phone_loop) {
if ((rv = ps_search_finish(ps->phone_loop)) < 0) {
ptmr_stop(&ps->perf);
return rv;
}
}
/* Search any frames remaining in the lookahead window. */
if (ps->acmod->output_frame >= ps->pl_window) {
for (i = ps->acmod->output_frame - ps->pl_window;
i < ps->acmod->output_frame; ++i)
ps_search_step(ps->search, i);
}
/* Finish main search. */
if ((rv = ps_search_finish(ps->search)) < 0) {
ptmr_stop(&ps->perf);
return rv;
}
ptmr_stop(&ps->perf);
/* Log a backtrace if requested. */
if (ps_config_bool(ps->config, "backtrace")) {
const char* hyp;
ps_seg_t *seg;
int32 score;
hyp = ps_get_hyp(ps, &score);
if (hyp != NULL) {
E_INFO("%s (%d)\n", hyp, score);
E_INFO_NOFN("%-20s %-5s %-5s %-5s %-10s %-10s %-3s\n",
"word", "start", "end", "pprob", "ascr", "lscr", "lback");
for (seg = ps_seg_iter(ps); seg;
seg = ps_seg_next(seg)) {
char const *word;
int sf, ef;
int32 post, lscr, ascr, lback;
word = ps_seg_word(seg);
ps_seg_frames(seg, &sf, &ef);
post = ps_seg_prob(seg, &ascr, &lscr, &lback);
E_INFO_NOFN("%-20s %-5d %-5d %-1.3f %-10d %-10d %-3d\n",
word, sf, ef, logmath_exp(ps_get_logmath(ps), post),
ascr, lscr, lback);
}
}
}
return rv;
} | pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x90, %rsp
movq %rdi, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x104b8
movl $0x3, %edi
leaq 0x67d3b(%rip), %rsi # 0x781d4
movl $0x51b, %edx # imm = 0x51B
leaq 0x68145(%rip), %rcx # 0x785ea
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x107c7
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movzbl 0xa8(%rax), %eax
cmpl $0x3, %eax
je 0x104e0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movzbl 0xa8(%rax), %eax
cmpl $0x0, %eax
jne 0x1050b
movl $0x3, %edi
leaq 0x67ce8(%rip), %rsi # 0x781d4
movl $0x51f, %edx # imm = 0x51F
leaq 0x6825a(%rip), %rcx # 0x78752
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
jmp 0x107c7
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x28e60
movq -0x20(%rbp), %rdi
callq 0x10950
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jge 0x10541
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
callq 0x248d0
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x107c7
movq -0x20(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x10587
movq -0x20(%rbp), %rax
movq 0x40(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x40(%rcx), %rdi
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jge 0x10585
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
callq 0x248d0
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x107c7
jmp 0x10587
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl 0xac(%rax), %eax
movq -0x20(%rbp), %rcx
cmpl 0x48(%rcx), %eax
jl 0x105f2
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movl 0xac(%rax), %eax
movq -0x20(%rbp), %rcx
subl 0x48(%rcx), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl 0xac(%rcx), %eax
jge 0x105f0
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x38(%rcx), %rdi
movl -0x28(%rbp), %esi
callq *%rax
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x105b6
jmp 0x105f2
movq -0x20(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x38(%rcx), %rdi
callq *%rax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jge 0x1062b
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
callq 0x248d0
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x107c7
movq -0x20(%rbp), %rdi
addq $0x50, %rdi
callq 0x248d0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
leaq 0x65a3c(%rip), %rsi # 0x76082
callq 0x143f0
cmpl $0x0, %eax
je 0x107c1
movq -0x20(%rbp), %rdi
leaq -0x3c(%rbp), %rsi
callq 0x10b40
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x107bf
movq -0x30(%rbp), %r8
movl -0x3c(%rbp), %r9d
movl $0x1, %edi
leaq 0x67b50(%rip), %rsi # 0x781d4
movl $0x546, %edx # imm = 0x546
leaq 0x680dc(%rip), %rcx # 0x7876c
movb $0x0, %al
callq 0x23450
movl $0x1, %edi
xorl %eax, %eax
movl %eax, %edx
leaq 0x680ce(%rip), %rcx # 0x78775
leaq 0x6728d(%rip), %r8 # 0x7793b
leaq 0x680e7(%rip), %r9 # 0x7879c
leaq 0x6ee95(%rip), %r14 # 0x7f551
leaq 0x680df(%rip), %rbx # 0x787a2
leaq 0x680de(%rip), %r11 # 0x787a8
leaq 0x680dc(%rip), %r10 # 0x787ad
leaq 0x680da(%rip), %rax # 0x787b2
movq %rdx, %rsi
movq %r14, (%rsp)
movq %rbx, 0x8(%rsp)
movq %r11, 0x10(%rsp)
movq %r10, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movb $0x0, %al
callq 0x23450
movq -0x20(%rbp), %rdi
callq 0xf5a0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x107bd
movq -0x38(%rbp), %rdi
callq 0x10be0
movq %rax, -0x48(%rbp)
movq -0x38(%rbp), %rdi
leaq -0x4c(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0x10c00
movq -0x38(%rbp), %rdi
leaq -0x5c(%rbp), %rsi
leaq -0x58(%rbp), %rdx
leaq -0x60(%rbp), %rcx
callq 0x10c40
movl %eax, -0x54(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, -0x64(%rbp)
movl -0x50(%rbp), %ebx
movq -0x20(%rbp), %rdi
callq 0xece0
movq %rax, %rdi
movl -0x54(%rbp), %esi
callq 0x25c80
movq -0x70(%rbp), %r8
movl -0x64(%rbp), %r9d
movl -0x5c(%rbp), %r11d
movl -0x58(%rbp), %r10d
movl -0x60(%rbp), %eax
movl $0x1, %edi
xorl %ecx, %ecx
movl %ecx, %edx
leaq 0x68028(%rip), %rcx # 0x787b8
movq %rdx, %rsi
movl %ebx, (%rsp)
movl %r11d, 0x8(%rsp)
movl %r10d, 0x10(%rsp)
movl %eax, 0x18(%rsp)
movb $0x1, %al
callq 0x23450
movq -0x38(%rbp), %rdi
callq 0xf630
movq %rax, -0x38(%rbp)
jmp 0x10707
jmp 0x107bf
jmp 0x107c1
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addq $0x90, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/pocketsphinx.c |
ps_get_hyp | char const *
ps_get_hyp(ps_decoder_t *ps, int32 *out_best_score)
{
char const *hyp;
if (ps->search == NULL) {
E_ERROR("No search module is selected, did you forget to "
"specify a language model or grammar?\n");
return NULL;
}
ptmr_start(&ps->perf);
hyp = ps_search_hyp(ps->search, out_best_score);
ptmr_stop(&ps->perf);
return hyp;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x10b84
movl $0x3, %edi
leaq 0x6766d(%rip), %rsi # 0x781d4
movl $0x562, %edx # imm = 0x562
leaq 0x67a77(%rip), %rcx # 0x785ea
movb $0x0, %al
callq 0x23450
movq $0x0, -0x8(%rbp)
jmp 0x10bc7
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x24810
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq 0x30(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x248d0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/pocketsphinx.c |
ps_get_prob | int32
ps_get_prob(ps_decoder_t *ps)
{
int32 prob;
if (ps->search == NULL) {
E_ERROR("No search module is selected, did you forget to "
"specify a language model or grammar?\n");
return -1;
}
ptmr_start(&ps->perf);
prob = ps_search_prob(ps->search);
ptmr_stop(&ps->perf);
return prob;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
jne 0x10cdf
movl $0x3, %edi
leaq 0x67511(%rip), %rsi # 0x781d4
movl $0x572, %edx # imm = 0x572
leaq 0x6791b(%rip), %rcx # 0x785ea
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x10d1b
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x24810
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq (%rax), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rdi
callq *%rax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x50, %rdi
callq 0x248d0
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/pocketsphinx.c |
ps_alignment_free | int
ps_alignment_free(ps_alignment_t *al)
{
if (al == NULL)
return 0;
if (--al->refcount > 0)
return al->refcount;
dict2pid_free(al->d2p);
ckd_free(al->word.seq);
ckd_free(al->sseq.seq);
ckd_free(al->state.seq);
ckd_free(al);
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1148c
movl $0x0, -0x4(%rbp)
jmp 0x114eb
movq -0x10(%rbp), %rcx
movl (%rcx), %eax
addl $-0x1, %eax
movl %eax, (%rcx)
cmpl $0x0, %eax
jle 0x114a7
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x114eb
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x32360
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x23e40
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x23e40
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x23e40
movq -0x10(%rbp), %rdi
callq 0x23e40
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/ps_alignment.c |
ps_alignment_add_word | int
ps_alignment_add_word(ps_alignment_t *al,
int32 wid, int start, int duration)
{
ps_alignment_entry_t *ent;
if ((ent = ps_alignment_vector_grow_one(&al->word)) == NULL)
return 0;
ent->id.wid = wid;
ent->start = start;
ent->duration = duration;
ent->score = 0;
ent->parent = PS_ALIGNMENT_NONE;
ent->child = PS_ALIGNMENT_NONE;
return al->word.n_ent;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x11590
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x11535
movl $0x0, -0x4(%rbp)
jmp 0x1157e
movl -0x14(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x18(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x28(%rbp), %rax
movl $0xffffffff, 0xc(%rax) # imm = 0xFFFFFFFF
movq -0x28(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movzwl 0x18(%rax), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/ps_alignment.c |
ps_alignment_populate | int
ps_alignment_populate(ps_alignment_t *al)
{
dict2pid_t *d2p;
dict_t *dict;
bin_mdef_t *mdef;
int i, lc;
/* Clear phone and state sequences. */
ps_alignment_vector_empty(&al->sseq);
ps_alignment_vector_empty(&al->state);
/* For each word, expand to phones/senone sequences. */
d2p = al->d2p;
dict = d2p->dict;
mdef = d2p->mdef;
lc = bin_mdef_silphone(mdef);
for (i = 0; i < al->word.n_ent; ++i) {
ps_alignment_entry_t *went = al->word.seq + i;
ps_alignment_entry_t *sent;
int wid = went->id.wid;
int len = dict_pronlen(dict, wid);
int j, rc;
if (i < al->word.n_ent - 1)
rc = dict_first_phone(dict, al->word.seq[i+1].id.wid);
else
rc = bin_mdef_silphone(mdef);
/* First phone. */
if ((sent = ps_alignment_vector_grow_one(&al->sseq)) == NULL) {
E_ERROR("Failed to add phone entry!\n");
return -1;
}
sent->id.pid.cipid = dict_first_phone(dict, wid);
sent->id.pid.tmatid = bin_mdef_pid2tmatid(mdef, sent->id.pid.cipid);
sent->start = went->start;
sent->duration = went->duration;
sent->score = 0;
sent->parent = i;
went->child = (uint16)(sent - al->sseq.seq);
if (len == 1)
sent->id.pid.ssid
= dict2pid_lrdiph_rc(d2p, sent->id.pid.cipid, lc, rc);
else
sent->id.pid.ssid
= dict2pid_ldiph_lc(d2p, sent->id.pid.cipid,
dict_second_phone(dict, wid), lc);
assert(sent->id.pid.ssid != BAD_SSID);
/* Internal phones. */
for (j = 1; j < len - 1; ++j) {
if ((sent = ps_alignment_vector_grow_one(&al->sseq)) == NULL) {
E_ERROR("Failed to add phone entry!\n");
return -1;
}
sent->id.pid.cipid = dict_pron(dict, wid, j);
sent->id.pid.tmatid = bin_mdef_pid2tmatid(mdef, sent->id.pid.cipid);
sent->id.pid.ssid = dict2pid_internal(d2p, wid, j);
assert(sent->id.pid.ssid != BAD_SSID);
sent->start = went->start;
sent->duration = went->duration;
sent->score = 0;
sent->parent = i;
}
/* Last phone. */
if (j < len) {
xwdssid_t *rssid;
assert(j == len - 1);
if ((sent = ps_alignment_vector_grow_one(&al->sseq)) == NULL) {
E_ERROR("Failed to add phone entry!\n");
return -1;
}
sent->id.pid.cipid = dict_last_phone(dict, wid);
sent->id.pid.tmatid = bin_mdef_pid2tmatid(mdef, sent->id.pid.cipid);
rssid = dict2pid_rssid(d2p, sent->id.pid.cipid,
dict_second_last_phone(dict, wid));
sent->id.pid.ssid = rssid->ssid[rssid->cimap[rc]];
assert(sent->id.pid.ssid != BAD_SSID);
sent->start = went->start;
sent->duration = went->duration;
sent->score = 0;
sent->parent = i;
}
/* Update lc. Could just use sent->id.pid.cipid here but that
* seems needlessly obscure. */
lc = dict_last_phone(dict, wid);
}
/* For each senone sequence, expand to senones. (we could do this
* nested above but this makes it more clear and easier to
* refactor) */
for (i = 0; i < al->sseq.n_ent; ++i) {
ps_alignment_entry_t *pent = al->sseq.seq + i;
ps_alignment_entry_t *sent;
int j;
for (j = 0; j < bin_mdef_n_emit_state(mdef); ++j) {
if ((sent = ps_alignment_vector_grow_one(&al->state)) == NULL) {
E_ERROR("Failed to add state entry!\n");
return -1;
}
sent->id.senid = bin_mdef_sseq2sen(mdef, pent->id.pid.ssid, j);
assert(sent->id.senid != BAD_SENID);
sent->start = pent->start;
sent->duration = pent->duration;
sent->score = 0;
sent->parent = i;
if (j == 0)
pent->child = (uint16)(sent - al->state.seq);
}
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x11d20
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x11d20
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x18(%rcx), %ecx
cmpl %ecx, %eax
jge 0x11bb7
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x44(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movl %eax, -0x48(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x18(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x11701
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x2c(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
imulq $0x1c, %rdx, %rdx
addq %rdx, %rcx
movslq 0x14(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movswl (%rax), %eax
movl %eax, -0x50(%rbp)
jmp 0x1170b
movq -0x28(%rbp), %rax
movl 0x28(%rax), %eax
movl %eax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x11590
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x1174d
movl $0x3, %edi
leaq 0x670f8(%rip), %rsi # 0x78826
movl $0xa1, %edx
leaq 0x6714a(%rip), %rcx # 0x78884
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11d14
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x44(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movw (%rax), %cx
movq -0x40(%rbp), %rax
movw %cx, 0x14(%rax)
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x40(%rbp), %rcx
movswq 0x14(%rcx), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x38(%rbp), %rax
movl (%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x40(%rbp), %rax
movl $0x0, 0x8(%rax)
movl -0x2c(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x20(%rcx), %rcx
subq %rcx, %rax
movl $0x1c, %ecx
cqto
idivq %rcx
movzwl %ax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
cmpl $0x1, -0x48(%rbp)
jne 0x11818
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x40(%rbp), %rcx
movswq 0x14(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x50(%rbp), %rcx
movw (%rax,%rcx,2), %cx
movq -0x40(%rbp), %rax
movw %cx, 0x16(%rax)
jmp 0x1185d
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x40(%rbp), %rcx
movswq 0x14(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x44(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movswq 0x2(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x30(%rbp), %rcx
movw (%rax,%rcx,2), %cx
movq -0x40(%rbp), %rax
movw %cx, 0x16(%rax)
movq -0x40(%rbp), %rax
movzwl 0x16(%rax), %eax
cmpl $0xffff, %eax # imm = 0xFFFF
je 0x1186e
jmp 0x1188d
leaq 0x6702b(%rip), %rdi # 0x788a0
leaq 0x66faa(%rip), %rsi # 0x78826
movl $0xb2, %edx
leaq 0x67036(%rip), %rcx # 0x788be
callq 0x71c0
movl $0x1, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
movl -0x48(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x119b7
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x11590
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x118e7
movl $0x3, %edi
leaq 0x66f5e(%rip), %rsi # 0x78826
movl $0xb7, %edx
leaq 0x66fb0(%rip), %rcx # 0x78884
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11d14
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x44(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movslq -0x4c(%rbp), %rcx
movw (%rax,%rcx,2), %cx
movq -0x40(%rbp), %rax
movw %cx, 0x14(%rax)
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x40(%rbp), %rcx
movswq 0x14(%rcx), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rdi
movl -0x44(%rbp), %esi
movl -0x4c(%rbp), %edx
callq 0x313d0
movw %ax, %cx
movq -0x40(%rbp), %rax
movw %cx, 0x16(%rax)
movq -0x40(%rbp), %rax
movzwl 0x16(%rax), %eax
cmpl $0xffff, %eax # imm = 0xFFFF
je 0x1195b
jmp 0x1197a
leaq 0x66f3e(%rip), %rdi # 0x788a0
leaq 0x66ebd(%rip), %rsi # 0x78826
movl $0xbd, %edx
leaq 0x66f49(%rip), %rcx # 0x788be
callq 0x71c0
movq -0x38(%rbp), %rax
movl (%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x40(%rbp), %rax
movl $0x0, 0x8(%rax)
movl -0x2c(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0x11894
movl -0x4c(%rbp), %eax
cmpl -0x48(%rbp), %eax
jge 0x11b6f
movl -0x4c(%rbp), %eax
movl -0x48(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x119d2
jmp 0x119f1
leaq 0x66f11(%rip), %rdi # 0x788ea
leaq 0x66e46(%rip), %rsi # 0x78826
movl $0xc7, %edx
leaq 0x66ed2(%rip), %rcx # 0x788be
callq 0x71c0
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
callq 0x11590
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
jne 0x11a33
movl $0x3, %edi
leaq 0x66e12(%rip), %rsi # 0x78826
movl $0xc9, %edx
leaq 0x66e64(%rip), %rcx # 0x78884
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11d14
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x44(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x44(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movw (%rax,%rcx,2), %cx
movq -0x40(%rbp), %rax
movw %cx, 0x14(%rax)
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq -0x40(%rbp), %rcx
movswq 0x14(%rcx), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x40(%rbp), %rcx
movswq 0x14(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x44(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movq 0x8(%rcx), %rcx
movq -0x20(%rbp), %rdx
movq 0x10(%rdx), %rdx
movslq -0x44(%rbp), %rsi
shlq $0x5, %rsi
addq %rsi, %rdx
movl 0x10(%rdx), %edx
subl $0x2, %edx
movslq %edx, %rdx
movswq (%rcx,%rdx,2), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq -0x58(%rbp), %rcx
movq 0x8(%rcx), %rcx
movslq -0x50(%rbp), %rdx
movswq (%rcx,%rdx,2), %rcx
movw (%rax,%rcx,2), %cx
movq -0x40(%rbp), %rax
movw %cx, 0x16(%rax)
movq -0x40(%rbp), %rax
movzwl 0x16(%rax), %eax
cmpl $0xffff, %eax # imm = 0xFFFF
je 0x11b21
jmp 0x11b40
leaq 0x66d78(%rip), %rdi # 0x788a0
leaq 0x66cf7(%rip), %rsi # 0x78826
movl $0xd1, %edx
leaq 0x66d83(%rip), %rcx # 0x788be
callq 0x71c0
movq -0x38(%rbp), %rax
movl (%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x40(%rbp), %rax
movl $0x0, 0x8(%rax)
movl -0x2c(%rbp), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0xc(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x44(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0x44(%rbp), %rdx
shlq $0x5, %rdx
addq %rdx, %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movswl (%rax,%rcx,2), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1166b
movl $0x0, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
movzwl 0x28(%rcx), %ecx
cmpl %ecx, %eax
jge 0x11d0d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x2c(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x60(%rbp)
movl $0x0, -0x6c(%rbp)
movl -0x6c(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jge 0x11cfd
movq -0x10(%rbp), %rdi
addq $0x30, %rdi
callq 0x11590
movq %rax, -0x68(%rbp)
cmpq $0x0, %rax
jne 0x11c41
movl $0x3, %edi
leaq 0x66c04(%rip), %rsi # 0x78826
movl $0xe6, %edx
leaq 0x66cc9(%rip), %rcx # 0x788f7
movb $0x0, %al
callq 0x23450
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x11d14
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rax
movq -0x60(%rbp), %rcx
movzwl 0x16(%rcx), %ecx
movq (%rax,%rcx,8), %rax
movslq -0x6c(%rbp), %rcx
movw (%rax,%rcx,2), %cx
movq -0x68(%rbp), %rax
movw %cx, 0x14(%rax)
movq -0x68(%rbp), %rax
movzwl 0x14(%rax), %eax
cmpl $0xffff, %eax # imm = 0xFFFF
je 0x11c76
jmp 0x11c95
leaq 0x66c96(%rip), %rdi # 0x78913
leaq 0x66ba2(%rip), %rsi # 0x78826
movl $0xea, %edx
leaq 0x66c2e(%rip), %rcx # 0x788be
callq 0x71c0
movq -0x60(%rbp), %rax
movl (%rax), %ecx
movq -0x68(%rbp), %rax
movl %ecx, (%rax)
movq -0x60(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x68(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x68(%rbp), %rax
movl $0x0, 0x8(%rax)
movl -0x2c(%rbp), %ecx
movq -0x68(%rbp), %rax
movl %ecx, 0xc(%rax)
cmpl $0x0, -0x6c(%rbp)
jne 0x11ced
movq -0x68(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
subq %rcx, %rax
movl $0x1c, %ecx
cqto
idivq %rcx
movzwl %ax, %ecx
movq -0x60(%rbp), %rax
movl %ecx, 0x10(%rax)
jmp 0x11cef
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x11bef
jmp 0x11cff
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x11bbe
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
| /cmusphinx[P]pocketsphinx/src/ps_alignment.c |
ps_alignment_propagate | int
ps_alignment_propagate(ps_alignment_t *al)
{
ps_alignment_entry_t *last_ent = NULL;
int i;
/* Propagate duration up from states to phones. */
for (i = 0; i < al->state.n_ent; ++i) {
ps_alignment_entry_t *sent = al->state.seq + i;
ps_alignment_entry_t *pent = al->sseq.seq + sent->parent;
if (pent != last_ent) {
pent->start = sent->start;
pent->duration = 0;
pent->score = 0;
}
pent->duration += sent->duration;
pent->score += sent->score;
last_ent = pent;
}
/* Propagate duration up from phones to words. */
last_ent = NULL;
for (i = 0; i < al->sseq.n_ent; ++i) {
ps_alignment_entry_t *pent = al->sseq.seq + i;
ps_alignment_entry_t *went = al->word.seq + pent->parent;
if (went != last_ent) {
went->start = pent->start;
went->duration = 0;
went->score = 0;
}
went->duration += pent->duration;
went->score += pent->score;
last_ent = went;
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0x38(%rcx), %ecx
cmpl %ecx, %eax
jge 0x12150
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rcx
movslq 0xc(%rcx), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x12118
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x28(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x20(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x28(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x28(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x120a7
movq $0x0, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0x28(%rcx), %ecx
cmpl %ecx, %eax
jge 0x12208
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x30(%rbp), %rcx
movslq 0xc(%rcx), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x121d0
movq -0x30(%rbp), %rax
movl (%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x30(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x38(%rbp), %rax
addl 0x4(%rax), %ecx
movl %ecx, 0x4(%rax)
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x38(%rbp), %rax
addl 0x8(%rax), %ecx
movl %ecx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq %rax, -0x10(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1215f
xorl %eax, %eax
popq %rbp
retq
nopl (%rax)
| /cmusphinx[P]pocketsphinx/src/ps_alignment.c |
ps_alignment_phones | ps_alignment_iter_t *
ps_alignment_phones(ps_alignment_t *al)
{
ps_alignment_iter_t *itor;
if (al->sseq.n_ent == 0)
return NULL;
itor = ckd_calloc(1, sizeof(*itor));
itor->al = al;
itor->vec = &al->sseq;
itor->pos = 0;
/* Iterate over *all* phones */
itor->parent = PS_ALIGNMENT_NONE;
return itor;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzwl 0x28(%rax), %eax
cmpl $0x0, %eax
jne 0x122c3
movq $0x0, -0x8(%rbp)
jmp 0x1231b
movl $0x1, %edi
movl $0x20, %esi
leaq 0x66552(%rip), %rdx # 0x78826
movl $0x176, %ecx # imm = 0x176
callq 0x23c10
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
addq $0x20, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/ps_alignment.c |
ps_alignment_iter_name | const char *
ps_alignment_iter_name(ps_alignment_iter_t *itor)
{
ps_alignment_entry_t *ent;
if (itor == NULL)
return NULL;
ent = ps_alignment_iter_get(itor);
if (itor->vec == &itor->al->word) {
return dict_wordstr(itor->al->d2p->dict,
ent->id.wid);
}
else if (itor->vec == &itor->al->sseq) {
return bin_mdef_ciphone_str(itor->al->d2p->mdef,
ent->id.pid.cipid);
}
else if (itor->vec == &itor->al->state) {
int len = snprintf(NULL, 0, "%u", ent->id.senid);
if (len == 0) {
E_ERROR_SYSTEM("snprintf() failed");
return NULL;
}
if (itor->name)
ckd_free(itor->name);
itor->name = ckd_malloc(len + 1);
if (snprintf(itor->name, len + 1, "%u", ent->id.senid) != len) {
E_ERROR_SYSTEM("snprintf() failed");
return NULL;
}
return itor->name;
}
else
return NULL;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x12410
movq $0x0, -0x8(%rbp)
jmp 0x125d0
movq -0x10(%rbp), %rdi
callq 0x123c0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x1247d
movq -0x18(%rbp), %rax
cmpl $0x0, 0x14(%rax)
jge 0x12447
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x12470
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movslq 0x14(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x125d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addq $0x20, %rcx
cmpq %rcx, %rax
jne 0x124ba
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rax
movswl 0x14(%rax), %esi
callq 0x30320
movq %rax, -0x8(%rbp)
jmp 0x125d0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addq $0x30, %rcx
cmpq %rcx, %rax
jne 0x125c8
movq -0x18(%rbp), %rax
movzwl 0x14(%rax), %ecx
xorl %eax, %eax
movl %eax, %esi
leaq 0x66475(%rip), %rdx # 0x7895e
movq %rsi, %rdi
movb $0x0, %al
callq 0x7190
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x12528
movl $0x3, %edi
leaq 0x6631e(%rip), %rsi # 0x78826
movl $0x1a7, %edx # imm = 0x1A7
leaq 0x6644d(%rip), %rcx # 0x78961
movb $0x0, %al
callq 0x23600
movq $0x0, -0x8(%rbp)
jmp 0x125d0
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x12540
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x23e40
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
leaq 0x662d6(%rip), %rsi # 0x78826
movl $0x1ac, %edx # imm = 0x1AC
callq 0x23c70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movq -0x18(%rbp), %rax
movzwl 0x14(%rax), %ecx
leaq 0x663d9(%rip), %rdx # 0x7895e
movb $0x0, %al
callq 0x7190
cmpl -0x1c(%rbp), %eax
je 0x125ba
movl $0x3, %edi
leaq 0x66289(%rip), %rsi # 0x78826
movl $0x1ae, %edx # imm = 0x1AE
leaq 0x663b8(%rip), %rcx # 0x78961
movb $0x0, %al
callq 0x23600
movq $0x0, -0x8(%rbp)
jmp 0x125d0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x125d0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/ps_alignment.c |
ps_alignment_iter_children | ps_alignment_iter_t *
ps_alignment_iter_children(ps_alignment_iter_t *itor)
{
ps_alignment_iter_t *itor2;
if (itor == NULL)
return NULL;
if (itor->vec == &itor->al->state)
return NULL;
if (itor->vec->seq[itor->pos].child == PS_ALIGNMENT_NONE)
return NULL;
itor2 = ckd_calloc(1, sizeof(*itor2));
itor2->al = itor->al;
itor2->pos = itor->vec->seq[itor->pos].child;
/* Iterate over only parent's phones/states */
itor2->parent = itor->pos;
if (itor->vec == &itor->al->word)
itor2->vec = &itor->al->sseq;
else
itor2->vec = &itor->al->state;
return itor2;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x127f0
movq $0x0, -0x8(%rbp)
jmp 0x128e9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addq $0x30, %rcx
cmpq %rcx, %rax
jne 0x12815
movq $0x0, -0x8(%rbp)
jmp 0x128e9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x10(%rcx), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
cmpl $-0x1, 0x10(%rax)
jne 0x12842
movq $0x0, -0x8(%rbp)
jmp 0x128e9
movl $0x1, %edi
movl $0x20, %esi
leaq 0x65fd3(%rip), %rdx # 0x78826
movl $0x1f9, %ecx # imm = 0x1F9
callq 0x23c10
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x10(%rcx), %rcx
imulq $0x1c, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addq $0x10, %rcx
cmpq %rcx, %rax
jne 0x128ce
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x20, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x128e1
movq -0x10(%rbp), %rax
movq (%rax), %rcx
addq $0x30, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/ps_alignment.c |
jsmn_parse | JSMN_API int jsmn_parse(jsmn_parser *parser, const char *js, const size_t len,
jsmntok_t *tokens, const unsigned int num_tokens) {
int r;
int i;
jsmntok_t *token;
int count = parser->toknext;
for (; parser->pos < len && js[parser->pos] != '\0'; parser->pos++) {
char c;
jsmntype_t type;
c = js[parser->pos];
switch (c) {
case '{':
case '[':
count++;
if (tokens == NULL) {
break;
}
token = jsmn_alloc_token(parser, tokens, num_tokens);
if (token == NULL) {
return JSMN_ERROR_NOMEM;
}
if (parser->toksuper != -1) {
jsmntok_t *t = &tokens[parser->toksuper];
#ifdef JSMN_STRICT
/* In strict mode an object or array can't become a key */
if (t->type == JSMN_OBJECT) {
return JSMN_ERROR_INVAL;
}
#endif
t->size++;
#ifdef JSMN_PARENT_LINKS
token->parent = parser->toksuper;
#endif
}
token->type = (c == '{' ? JSMN_OBJECT : JSMN_ARRAY);
token->start = parser->pos;
parser->toksuper = parser->toknext - 1;
break;
case '}':
case ']':
if (tokens == NULL) {
break;
}
type = (c == '}' ? JSMN_OBJECT : JSMN_ARRAY);
#ifdef JSMN_PARENT_LINKS
if (parser->toknext < 1) {
return JSMN_ERROR_INVAL;
}
token = &tokens[parser->toknext - 1];
for (;;) {
if (token->start != -1 && token->end == -1) {
if (token->type != type) {
return JSMN_ERROR_INVAL;
}
token->end = parser->pos + 1;
parser->toksuper = token->parent;
break;
}
if (token->parent == -1) {
if (token->type != type || parser->toksuper == -1) {
return JSMN_ERROR_INVAL;
}
break;
}
token = &tokens[token->parent];
}
#else
for (i = parser->toknext - 1; i >= 0; i--) {
token = &tokens[i];
if (token->start != -1 && token->end == -1) {
if (token->type != type) {
return JSMN_ERROR_INVAL;
}
parser->toksuper = -1;
token->end = parser->pos + 1;
break;
}
}
/* Error if unmatched closing bracket */
if (i == -1) {
return JSMN_ERROR_INVAL;
}
for (; i >= 0; i--) {
token = &tokens[i];
if (token->start != -1 && token->end == -1) {
parser->toksuper = i;
break;
}
}
#endif
break;
case '\"':
r = jsmn_parse_string(parser, js, len, tokens, num_tokens);
if (r < 0) {
return r;
}
count++;
if (parser->toksuper != -1 && tokens != NULL) {
tokens[parser->toksuper].size++;
}
break;
case '\t':
case '\r':
case '\n':
case ' ':
break;
case ':':
parser->toksuper = parser->toknext - 1;
break;
case ',':
if (tokens != NULL && parser->toksuper != -1 &&
tokens[parser->toksuper].type != JSMN_ARRAY &&
tokens[parser->toksuper].type != JSMN_OBJECT) {
#ifdef JSMN_PARENT_LINKS
parser->toksuper = tokens[parser->toksuper].parent;
#else
for (i = parser->toknext - 1; i >= 0; i--) {
if (tokens[i].type == JSMN_ARRAY || tokens[i].type == JSMN_OBJECT) {
if (tokens[i].start != -1 && tokens[i].end == -1) {
parser->toksuper = i;
break;
}
}
}
#endif
}
break;
#ifdef JSMN_STRICT
/* In strict mode primitives are: numbers and booleans */
case '-':
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
case 't':
case 'f':
case 'n':
/* And they must not be keys of the object */
if (tokens != NULL && parser->toksuper != -1) {
const jsmntok_t *t = &tokens[parser->toksuper];
if (t->type == JSMN_OBJECT ||
(t->type == JSMN_STRING && t->size != 0)) {
return JSMN_ERROR_INVAL;
}
}
#else
/* In non-strict mode every unquoted value is a primitive */
default:
#endif
r = jsmn_parse_primitive(parser, js, len, tokens, num_tokens);
if (r < 0) {
return r;
}
count++;
if (parser->toksuper != -1 && tokens != NULL) {
tokens[parser->toksuper].size++;
}
break;
#ifdef JSMN_STRICT
/* Unexpected char in strict mode */
default:
return JSMN_ERROR_INVAL;
#endif
}
}
if (tokens != NULL) {
for (i = parser->toknext - 1; i >= 0; i--) {
/* Unmatched opened object or array */
if (tokens[i].start != -1 && tokens[i].end == -1) {
return JSMN_ERROR_PART;
}
}
}
return count;
} | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
xorl %eax, %eax
cmpq -0x20(%rbp), %rcx
movb %al, -0x59(%rbp)
jae 0x12a10
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %al
testb $0x1, %al
jne 0x12a1c
jmp 0x12e33
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl (%rcx), %ecx
movb (%rax,%rcx), %al
movb %al, -0x45(%rbp)
movsbl -0x45(%rbp), %eax
movl %eax, -0x60(%rbp)
addl $-0x9, %eax
subl $0x2, %eax
jb 0x12cca
jmp 0x12a41
movl -0x60(%rbp), %eax
subl $0xd, %eax
je 0x12cca
jmp 0x12a4f
movl -0x60(%rbp), %eax
subl $0x20, %eax
je 0x12cca
jmp 0x12a5d
movl -0x60(%rbp), %eax
subl $0x22, %eax
je 0x12c60
jmp 0x12a6b
movl -0x60(%rbp), %eax
subl $0x2c, %eax
je 0x12ce5
jmp 0x12a79
movl -0x60(%rbp), %eax
subl $0x3a, %eax
je 0x12ccf
jmp 0x12a87
movl -0x60(%rbp), %eax
subl $0x5b, %eax
je 0x12aba
jmp 0x12a91
movl -0x60(%rbp), %eax
subl $0x5d, %eax
je 0x12b63
jmp 0x12a9f
movl -0x60(%rbp), %eax
subl $0x7b, %eax
je 0x12aba
jmp 0x12aa9
movl -0x60(%rbp), %eax
subl $0x7d, %eax
je 0x12b63
jmp 0x12dba
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x12acf
jmp 0x12e21
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %eax
movl %eax, %edx
callq 0x12ea0
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x12af8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x12e95
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
je 0x12b26
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
movsbl -0x45(%rbp), %edx
movl $0x2, %ecx
movl $0x1, %eax
cmpl $0x7b, %edx
cmovel %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x12e21
cmpq $0x0, -0x28(%rbp)
jne 0x12b6f
jmp 0x12e21
movsbl -0x45(%rbp), %edx
movl $0x2, %eax
movl $0x1, %ecx
cmpl $0x7d, %edx
cmovel %ecx, %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x12c01
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpl $-0x1, 0x4(%rax)
je 0x12bf4
movq -0x40(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
jne 0x12bf4
movq -0x40(%rbp), %rax
movl (%rax), %eax
cmpl -0x4c(%rbp), %eax
je 0x12bd7
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x12e95
movq -0x10(%rbp), %rax
movl $0xffffffff, 0x8(%rax) # imm = 0xFFFFFFFF
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x12c01
jmp 0x12bf6
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x12b93
cmpl $-0x1, -0x34(%rbp)
jne 0x12c13
movl $0xfffffffe, -0x4(%rbp) # imm = 0xFFFFFFFE
jmp 0x12e95
jmp 0x12c15
cmpl $0x0, -0x34(%rbp)
jl 0x12c5b
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpl $-0x1, 0x4(%rax)
je 0x12c4e
movq -0x40(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
jne 0x12c4e
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x12c5b
jmp 0x12c50
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x12c15
jmp 0x12e21
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %eax
movl %eax, %r8d
callq 0x12f20
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jge 0x12c8f
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12e95
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
je 0x12cc5
cmpq $0x0, -0x28(%rbp)
je 0x12cc5
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x12e21
jmp 0x12e21
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
subl $0x1, %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x12e21
cmpq $0x0, -0x28(%rbp)
je 0x12db8
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
je 0x12db8
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
je 0x12db8
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x1, (%rax)
je 0x12db8
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x12db6
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x2, (%rax)
je 0x12d71
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $0x1, (%rax)
jne 0x12da9
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $-0x1, 0x4(%rax)
je 0x12da7
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $-0x1, 0x8(%rax)
jne 0x12da7
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
jmp 0x12db6
jmp 0x12da9
jmp 0x12dab
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x12d43
jmp 0x12db8
jmp 0x12e21
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movl -0x2c(%rbp), %eax
movl %eax, %r8d
callq 0x130d0
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jge 0x12de9
movl -0x30(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x12e95
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rax
cmpl $-0x1, 0x8(%rax)
je 0x12e1f
cmpq $0x0, -0x28(%rbp)
je 0x12e1f
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq 0x8(%rcx), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movl 0xc(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc(%rax)
jmp 0x12e21
jmp 0x12e23
movq -0x10(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x129e6
cmpq $0x0, -0x28(%rbp)
je 0x12e8f
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
subl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x12e8d
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $-0x1, 0x4(%rax)
je 0x12e80
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $-0x1, 0x8(%rax)
jne 0x12e80
movl $0xfffffffd, -0x4(%rbp) # imm = 0xFFFFFFFD
jmp 0x12e95
jmp 0x12e82
movl -0x34(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x12e47
jmp 0x12e8f
movl -0x44(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop
| /cmusphinx[P]pocketsphinx/src/jsmn.h |
ps_config_init | ps_config_t *
ps_config_init(const ps_arg_t *defn)
{
ps_config_t *config = ckd_calloc(1, sizeof(*config));
int i, ndef;
config->refcount = 1;
if (defn)
config->defn = defn;
else
config->defn = ps_args_def;
for (ndef = 0; config->defn[ndef].name; ndef++)
;
config->ht = hash_table_new(ndef, FALSE);
for (i = 0; i < ndef; i++) {
cmd_ln_val_t *val;
if ((val = cmd_ln_val_init(config->defn[i].type,
config->defn[i].name,
config->defn[i].deflt)) == NULL) {
E_ERROR
("Bad default argument value for %s: %s\n",
config->defn[i].name, config->defn[i].deflt);
continue;
}
hash_table_enter(config->ht, val->name, (void *)val);
}
return config;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x30, %esi
leaq 0x65797(%rip), %rdx # 0x78a44
movl $0x37, %ecx
callq 0x23c10
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0x1, (%rax)
cmpq $0x0, -0x8(%rbp)
je 0x132da
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x20(%rax)
jmp 0x132e9
movq -0x10(%rbp), %rax
leaq 0x7fbfb(%rip), %rcx # 0x92ee0
movq %rcx, 0x20(%rax)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x13316
jmp 0x1330b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x132f0
movl -0x18(%rbp), %edi
xorl %esi, %esi
callq 0x22110
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x13405
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x8(%rax), %edi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdx
callq 0x20e70
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x133de
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %r8
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movslq -0x14(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x10(%rax), %r9
movl $0x3, %edi
leaq 0x6567b(%rip), %rsi # 0x78a44
movl $0x49, %edx
leaq 0x656ca(%rip), %rcx # 0x78a9f
movb $0x0, %al
callq 0x23450
jmp 0x133f7
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
callq 0x227c0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x13332
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| /cmusphinx[P]pocketsphinx/src/ps_config.c |
ps_config_validate | int
ps_config_validate(ps_config_t *config)
{
int i, found = 0;
for (i = 0; i < nsearches; ++i) {
if (ps_config_str(config, searches[i]) != NULL)
if (++found > 1)
break;
}
if (found > 1) {
int len = strlen("Only one of ");
char *msg;
for (i = 0; i < nsearches; ++i)
len += strlen(searches[i]) + 2;
len += strlen("can be enabled at a time in config\n");
msg = ckd_malloc(len + 1);
strcpy(msg, "Only one of ");
for (i = 0; i < nsearches; ++i) {
strcat(msg, searches[i]);
strcat(msg, ", ");
}
strcat(msg, "can be enabled at a time in config\n");
E_ERROR(msg);
ckd_free(msg);
return -1;
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x7, -0x14(%rbp)
jge 0x135dd
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x80cb1(%rip), %rax # 0x94260
movq (%rax,%rcx,8), %rsi
callq 0x13700
cmpq $0x0, %rax
je 0x135d0
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x1, %eax
jle 0x135ce
jmp 0x135dd
jmp 0x135d0
jmp 0x135d2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1359a
cmpl $0x1, -0x18(%rbp)
jle 0x136e2
movl $0xc, -0x1c(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x7, -0x14(%rbp)
jge 0x1362b
movslq -0x14(%rbp), %rcx
leaq 0x80c5a(%rip), %rax # 0x94260
movq (%rax,%rcx,8), %rdi
callq 0x7130
movq %rax, %rcx
addq $0x2, %rcx
movslq -0x1c(%rbp), %rax
addq %rcx, %rax
movl %eax, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x135f5
movslq -0x1c(%rbp), %rax
addq $0x23, %rax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
leaq 0x653fe(%rip), %rsi # 0x78a44
movl $0x97, %edx
callq 0x23c70
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
leaq 0x65467(%rip), %rsi # 0x78ac6
callq 0x70a0
movl $0x0, -0x14(%rbp)
cmpl $0x7, -0x14(%rbp)
jge 0x136a4
movq -0x28(%rbp), %rdi
movslq -0x14(%rbp), %rcx
leaq 0x80be0(%rip), %rax # 0x94260
movq (%rax,%rcx,8), %rsi
callq 0x73f0
movq -0x28(%rbp), %rdi
leaq 0x6543f(%rip), %rsi # 0x78ad3
callq 0x73f0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1366b
movq -0x28(%rbp), %rdi
leaq 0x65427(%rip), %rsi # 0x78ad6
callq 0x73f0
movq -0x28(%rbp), %rcx
movl $0x3, %edi
leaq 0x65380(%rip), %rsi # 0x78a44
movl $0x9e, %edx
movb $0x0, %al
callq 0x23450
movq -0x28(%rbp), %rdi
callq 0x23e40
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x136e9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/ps_config.c |
ps_config_str | char const *
ps_config_str(cmd_ln_t *config, char const *name)
{
cmd_ln_val_t *val;
val = cmd_ln_access_r(config, name);
if (val == NULL)
return NULL;
if (!(val->type & ARG_STRING)) {
E_ERROR("Argument %s does not have string type\n", name);
return NULL;
}
return (char const *)val->val.ptr;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20e00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x13732
movq $0x0, -0x8(%rbp)
jmp 0x13779
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
jne 0x1376e
movq -0x18(%rbp), %r8
movl $0x3, %edi
leaq 0x652f3(%rip), %rsi # 0x78a44
movl $0x25d, %edx # imm = 0x25D
leaq 0x65578(%rip), %rcx # 0x78cd5
movb $0x0, %al
callq 0x23450
movq $0x0, -0x8(%rbp)
jmp 0x13779
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/ps_config.c |
ps_config_set_str | const anytype_t *
ps_config_set_str(ps_config_t *config, char const *name, char const *val)
{
cmd_ln_val_t *cval = cmd_ln_access_r(config, name);
if (cval == NULL) {
E_ERROR("Unknown parameter %s\n", name);
return NULL;
}
if (anytype_from_str(&cval->val, cval->type, val) == NULL) {
return NULL;
}
return &cval->val;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20e00
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x13e69
movq -0x18(%rbp), %r8
movl $0x3, %edi
leaq 0x64bf8(%rip), %rsi # 0x78a44
movl $0x2c9, %edx # imm = 0x2C9
leaq 0x64ef7(%rip), %rcx # 0x78d4f
movb $0x0, %al
callq 0x23450
movq $0x0, -0x8(%rbp)
jmp 0x13e95
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x8(%rax), %esi
movq -0x20(%rbp), %rdx
callq 0x147b0
cmpq $0x0, %rax
jne 0x13e8d
movq $0x0, -0x8(%rbp)
jmp 0x13e95
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
| /cmusphinx[P]pocketsphinx/src/ps_config.c |
build_json | static int
build_json(ps_config_t *config, char *json, int len)
{
hash_iter_t *itor;
char *ptr = json;
int l, rv = 0;
if ((l = snprintf(ptr, len, "{\n")) < 0)
return -1;
rv += l;
if (ptr) {
len -= l;
ptr += l;
}
for (itor = hash_table_iter(config->ht); itor;
itor = hash_table_iter_next(itor)) {
const char *key = hash_entry_key(itor->ent);
cmd_ln_val_t *cval = hash_entry_val(itor->ent);
if (cval->type & ARG_STRING && cval->val.ptr == NULL)
continue;
if ((l = serialize_key(ptr, len, key)) < 0)
return -1;
rv += l;
if (ptr) {
len -= l;
ptr += l;
}
if (cval->type & ARG_STRING) {
if ((l = serialize_value(ptr, len,
(char *)cval->val.ptr)) < 0)
return -1;
}
else if (cval->type & ARG_INTEGER) {
if ((l = snprintf(ptr, len, "%ld,\n",
cval->val.i)) < 0)
return -1;
}
else if (cval->type & ARG_BOOLEAN) {
if ((l = snprintf(ptr, len, "%s,\n",
cval->val.i ? "true" : "false")) < 0)
return -1;
}
else if (cval->type & ARG_FLOATING) {
if ((l = snprintf(ptr, len, "%g,\n",
cval->val.fl)) < 0)
return -1;
}
else {
E_ERROR("Unknown type %d for parameter %s\n",
cval->type, key);
}
rv += l;
if (ptr) {
len -= l;
ptr += l;
}
}
/* Back off last comma because JSON is awful */
if (ptr && ptr > json + 1) {
len += 2;
ptr -= 2;
}
if ((l = snprintf(ptr, len, "\n}\n")) < 0)
return -1;
rv += l;
if (ptr) {
len -= l;
ptr += l;
}
return rv;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
leaq 0x64dd7(%rip), %rdx # 0x78d68
movb $0x0, %al
callq 0x7190
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jge 0x13fac
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14293
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x13fd8
movl -0x34(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x22fe0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x1420d
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x14031
movq -0x48(%rbp), %rax
cmpq $0x0, (%rax)
jne 0x14031
jmp 0x141fb
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x40(%rbp), %rdx
callq 0x14e30
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jge 0x14055
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14293
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x14081
movl -0x34(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x8, %eax
cmpl $0x0, %eax
je 0x140bc
movq -0x30(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x48(%rbp), %rax
movq (%rax), %rdx
callq 0x14fa0
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jge 0x140b7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14293
jmp 0x141cd
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x2, %eax
cmpl $0x0, %eax
je 0x14101
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movq -0x48(%rbp), %rax
movq (%rax), %rcx
leaq 0x64c8a(%rip), %rdx # 0x78d6b
movb $0x0, %al
callq 0x7190
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jge 0x140fc
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14293
jmp 0x141cb
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x14159
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movq -0x48(%rbp), %rax
movq (%rax), %rdx
leaq 0x64c55(%rip), %rcx # 0x78d7b
leaq 0x64c49(%rip), %rax # 0x78d76
cmpq $0x0, %rdx
cmovneq %rax, %rcx
leaq 0x64c35(%rip), %rdx # 0x78d71
movb $0x0, %al
callq 0x7190
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jge 0x14157
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14293
jmp 0x141c9
movq -0x48(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1419c
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
movq -0x48(%rbp), %rax
movsd (%rax), %xmm0
leaq 0x64c02(%rip), %rdx # 0x78d81
movb $0x1, %al
callq 0x7190
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jge 0x1419a
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14293
jmp 0x141c7
movq -0x48(%rbp), %rax
movl 0x8(%rax), %r8d
movq -0x40(%rbp), %r9
movl $0x3, %edi
leaq 0x64890(%rip), %rsi # 0x78a44
movl $0x1f5, %edx # imm = 0x1F5
leaq 0x64bc6(%rip), %rcx # 0x78d86
movb $0x0, %al
callq 0x23450
jmp 0x141c9
jmp 0x141cb
jmp 0x141cd
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x141f9
movl -0x34(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
jmp 0x141fb
movq -0x28(%rbp), %rdi
callq 0x23030
movq %rax, -0x28(%rbp)
jmp 0x13fe9
cmpq $0x0, -0x30(%rbp)
je 0x1423a
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x1423a
movl -0x1c(%rbp), %eax
addl $0x2, %eax
movl %eax, -0x1c(%rbp)
movq -0x30(%rbp), %rax
addq $-0x2, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
leaq 0x64b5f(%rip), %rdx # 0x78da8
movb $0x0, %al
callq 0x7190
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
jge 0x14261
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x14293
movl -0x34(%rbp), %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x1428d
movl -0x34(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
movl -0x34(%rbp), %ecx
movq -0x30(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| /cmusphinx[P]pocketsphinx/src/ps_config.c |
ps_config_float | double
ps_config_float(ps_config_t *config, char const *name)
{
cmd_ln_val_t *val;
val = cmd_ln_access_r(config, name);
if (val == NULL)
return 0.0;
if (!(val->type & ARG_FLOATING)) {
E_ERROR("Argument %s does not have floating-point type\n", name);
return 0.0;
}
return val->val.fl;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x20e00
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x14462
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x144ab
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x4, %eax
cmpl $0x0, %eax
jne 0x1449e
movq -0x18(%rbp), %r8
movl $0x3, %edi
leaq 0x645c3(%rip), %rsi # 0x78a44
movl $0x24f, %edx # imm = 0x24F
leaq 0x64819(%rip), %rcx # 0x78ca6
movb $0x0, %al
callq 0x23450
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x144ab
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/ps_config.c |
anytype_from_float | anytype_t *
anytype_from_float(anytype_t *val, int t, double f)
{
if (val == NULL)
return NULL;
switch (t) {
case ARG_INTEGER:
case REQARG_INTEGER:
val->i = (long)f;
break;
case ARG_FLOATING:
case REQARG_FLOATING:
val->fl = f;
break;
case ARG_BOOLEAN:
case REQARG_BOOLEAN:
val->i = (f != 0.0);
break;
case ARG_STRING:
case REQARG_STRING: {
int len = snprintf(NULL, 0, "%g", f);
if (len < 0) {
E_ERROR_SYSTEM("snprintf() failed");
return NULL;
}
val->ptr = ckd_malloc(len + 1);
if (snprintf(val->ptr, len + 1, "%g", f) != len) {
E_ERROR_SYSTEM("snprintf() failed");
return NULL;
}
break;
}
default:
E_ERROR("Unknown argument type: %d\n", t);
return NULL;
}
return val;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x14bc8
movq $0x0, -0x8(%rbp)
jmp 0x14d38
movl -0x14(%rbp), %eax
addl $-0x2, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0xf, %eax
ja 0x14d03
movq -0x30(%rbp), %rax
leaq 0x63e1c(%rip), %rcx # 0x78a04
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
cvttsd2si -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x14d30
movsd -0x20(%rbp), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x14d30
movsd -0x20(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
jmp 0x14d30
movsd -0x20(%rbp), %xmm0
xorl %eax, %eax
movl %eax, %esi
leaq 0x64118(%rip), %rdx # 0x78d65
movq %rsi, %rdi
movb $0x1, %al
callq 0x7190
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x14c8c
movl $0x3, %edi
leaq 0x63dd8(%rip), %rsi # 0x78a44
movl $0x31d, %edx # imm = 0x31D
leaq 0x63ce9(%rip), %rcx # 0x78961
movb $0x0, %al
callq 0x23600
movq $0x0, -0x8(%rbp)
jmp 0x14d38
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
leaq 0x63da8(%rip), %rsi # 0x78a44
movl $0x320, %edx # imm = 0x320
callq 0x23c70
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x24(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rsi
movsd -0x20(%rbp), %xmm0
leaq 0x64099(%rip), %rdx # 0x78d65
movb $0x1, %al
callq 0x7190
cmpl -0x24(%rbp), %eax
je 0x14d01
movl $0x3, %edi
leaq 0x63d60(%rip), %rsi # 0x78a44
movl $0x322, %edx # imm = 0x322
leaq 0x63c71(%rip), %rcx # 0x78961
movb $0x0, %al
callq 0x23600
movq $0x0, -0x8(%rbp)
jmp 0x14d38
jmp 0x14d30
movl -0x14(%rbp), %r8d
movl $0x3, %edi
leaq 0x63d31(%rip), %rsi # 0x78a44
movl $0x328, %edx # imm = 0x328
leaq 0x64015(%rip), %rcx # 0x78d34
movb $0x0, %al
callq 0x23450
movq $0x0, -0x8(%rbp)
jmp 0x14d38
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/ps_config.c |
remove_dangling_links | static void
remove_dangling_links(ps_lattice_t *dag, ps_latnode_t *node)
{
latlink_list_t *x, *prev_x, *next_x;
prev_x = NULL;
for (x = node->exits; x; x = next_x) {
next_x = x->next;
if (x->link->to == NULL) {
if (prev_x)
prev_x->next = next_x;
else
node->exits = next_x;
listelem_free(dag->latlink_alloc, x->link);
listelem_free(dag->latlink_list_alloc, x);
}
else
prev_x = x;
}
prev_x = NULL;
for (x = node->entries; x; x = next_x) {
next_x = x->next;
if (x->link->from == NULL) {
if (prev_x)
prev_x->next = next_x;
else
node->entries = next_x;
listelem_free(dag->latlink_alloc, x->link);
listelem_free(dag->latlink_list_alloc, x);
}
else
prev_x = x;
}
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x15860
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x15849
cmpq $0x0, -0x20(%rbp)
je 0x157fe
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x1580a
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x63630(%rip), %rdx # 0x78e50
movl $0x95, %ecx
callq 0x269a0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq 0x63613(%rip), %rdx # 0x78e50
movl $0x96, %ecx
callq 0x269a0
jmp 0x15851
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x15853
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x157c4
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1590f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpq $0x0, (%rax)
jne 0x158f8
cmpq $0x0, -0x20(%rbp)
je 0x158ad
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x158b9
movq -0x28(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x18(%rbp), %rax
movq (%rax), %rsi
leaq 0x63581(%rip), %rdx # 0x78e50
movl $0xa3, %ecx
callq 0x269a0
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
movq -0x18(%rbp), %rsi
leaq 0x63564(%rip), %rdx # 0x78e50
movl $0xa4, %ecx
callq 0x269a0
jmp 0x15900
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x15902
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x15874
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/ps_lattice.c |
ps_lattice_read | ps_lattice_t *
ps_lattice_read(ps_decoder_t *ps,
char const *file)
{
FILE *fp;
int32 ispipe;
lineiter_t *line;
float64 lb;
float32 logratio;
ps_latnode_t **darray;
ps_lattice_t *dag;
int i, k, n_nodes;
int32 pip, silpen, fillpen;
ps_latnode_t **pnodes;
dag = ckd_calloc(1, sizeof(*dag));
if (ps) {
dag->search = ps->search;
dag->dict = dict_retain(ps->dict);
dag->lmath = logmath_retain(ps->lmath);
dag->frate = ps_config_int(dag->search->config, "frate");
}
else {
dag->dict = dict_init(NULL, NULL);
dag->lmath = logmath_init(1.0001, 0, FALSE);
dag->frate = 100;
}
dag->silence = dict_silwid(dag->dict);
dag->latnode_alloc = listelem_alloc_init(sizeof(ps_latnode_t));
dag->latlink_alloc = listelem_alloc_init(sizeof(ps_latlink_t));
dag->latlink_list_alloc = listelem_alloc_init(sizeof(latlink_list_t));
dag->refcount = 1;
darray = NULL;
E_INFO("Reading DAG file: %s\n", file);
if ((fp = fopen_compchk(file, &ispipe)) == NULL) {
E_ERROR_SYSTEM("Failed to open DAG file '%s' for reading", file);
return NULL;
}
line = lineiter_start(fp);
/* Read and verify logbase (ONE BIG HACK!!) */
if (line == NULL) {
E_ERROR("Premature EOF(%s)\n", file);
goto load_error;
}
if (strncmp(line->buf, "# getcwd: ", 10) != 0) {
E_ERROR("%s does not begin with '# getcwd: '\n%s", file, line->buf);
goto load_error;
}
if ((line = lineiter_next(line)) == NULL) {
E_ERROR("Premature EOF(%s)\n", file);
goto load_error;
}
if ((strncmp(line->buf, "# -logbase ", 11) != 0)
|| (sscanf(line->buf + 11, "%lf", &lb) != 1)) {
E_WARN("%s: Cannot find -logbase in header\n", file);
lb = 1.0001;
}
logratio = 1.0f;
if (dag->lmath == NULL)
dag->lmath = logmath_init(lb, 0, TRUE);
else {
float32 pb = logmath_get_base(dag->lmath);
if (fabs(lb - pb) >= 0.0001) {
E_WARN("Inconsistent logbases: %f vs %f: will compensate\n", lb, pb);
logratio = (float32)(log(lb) / log(pb));
E_INFO("Lattice log ratio: %f\n", logratio);
}
}
/* Read Frames parameter */
dag->n_frames = dag_param_read(line, "Frames");
if (dag->n_frames <= 0) {
E_ERROR("Frames parameter missing or invalid\n");
goto load_error;
}
/* Read Nodes parameter */
n_nodes = dag_param_read(line, "Nodes");
if (n_nodes <= 0) {
E_ERROR("Nodes parameter missing or invalid\n");
goto load_error;
}
/* Read nodes */
darray = ckd_calloc(n_nodes, sizeof(*darray));
pnodes = &dag->nodes;
for (i = 0; i < n_nodes; i++) {
int32 w;
int seqid, sf, fef, lef;
char wd[256];
ps_latnode_t *node;
if ((line = lineiter_next(line)) == NULL) {
E_ERROR("Premature EOF while loading Nodes(%s)\n", file);
goto load_error;
}
if ((k =
sscanf(line->buf, "%d %255s %d %d %d", &seqid, wd, &sf, &fef,
&lef)) != 5) {
E_ERROR("Cannot parse line: %s, value of count %d\n", line->buf, k);
goto load_error;
}
w = dict_wordid(dag->dict, wd);
if (w < 0) {
if (dag->search == NULL) {
char *ww = ckd_salloc(wd);
if (dict_word2basestr(ww) != -1) {
if (dict_wordid(dag->dict, ww) == BAD_S3WID)
dict_add_word(dag->dict, ww, NULL, 0);
}
ckd_free(ww);
w = dict_add_word(dag->dict, wd, NULL, 0);
}
if (w < 0) {
E_ERROR("Unknown word in line: %s\n", line->buf);
goto load_error;
}
}
if (seqid != i) {
E_ERROR("Seqno error: %s\n", line->buf);
goto load_error;
}
*pnodes = listelem_malloc(dag->latnode_alloc);
node = *pnodes;
darray[i] = node;
node->wid = w;
node->basewid = dict_basewid(dag->dict, w);
node->id = seqid;
node->sf = sf;
node->fef = fef;
node->lef = lef;
node->reachable = 0;
node->exits = node->entries = NULL;
node->next = NULL;
pnodes = &node->next;
}
/* Read initial node ID */
k = dag_param_read(line, "Initial");
if ((k < 0) || (k >= n_nodes)) {
E_ERROR("Initial node parameter missing or invalid\n");
goto load_error;
}
dag->start = darray[k];
/* Read final node ID */
k = dag_param_read(line, "Final");
if ((k < 0) || (k >= n_nodes)) {
E_ERROR("Final node parameter missing or invalid\n");
goto load_error;
}
dag->end = darray[k];
/* Read bestsegscore entries and ignore them. */
if ((k = dag_param_read(line, "BestSegAscr")) < 0) {
E_ERROR("BestSegAscr parameter missing\n");
goto load_error;
}
for (i = 0; i < k; i++) {
if ((line = lineiter_next(line)) == NULL) {
E_ERROR("Premature EOF while (%s) ignoring BestSegAscr\n",
line);
goto load_error;
}
}
/* Read in edges. */
while ((line = lineiter_next(line)) != NULL) {
if (line->buf[0] == '#')
continue;
if (0 == strncmp(line->buf, "Edges", 5))
break;
}
if (line == NULL) {
E_ERROR("Edges missing\n");
goto load_error;
}
while ((line = lineiter_next(line)) != NULL) {
int from, to, ascr;
ps_latnode_t *pd, *d;
if (sscanf(line->buf, "%d %d %d", &from, &to, &ascr) != 3)
break;
if (ascr WORSE_THAN WORST_SCORE)
continue;
pd = darray[from];
d = darray[to];
if (logratio != 1.0f)
/* FIXME: possible under/overflow!!! */
ascr = (int32)(ascr * logratio);
ps_lattice_link(dag, pd, d, ascr, d->sf - 1);
}
if (strcmp(line->buf, "End\n") != 0) {
E_ERROR("Terminating 'End' missing\n");
goto load_error;
}
lineiter_free(line);
fclose_comp(fp, ispipe);
ckd_free(darray);
/* Minor hack: If the final node is a filler word and not </s>,
* then set its base word ID to </s>, so that the language model
* scores won't be screwed up. */
if (dict_filler_word(dag->dict, dag->end->wid))
dag->end->basewid = dag->search
? ps_search_finish_wid(dag->search)
: dict_wordid(dag->dict, S3_FINISH_WORD);
/* Mark reachable from dag->end */
dag_mark_reachable(dag->end);
/* Free nodes unreachable from dag->end and their links */
ps_lattice_delete_unreachable(dag);
if (ps) {
/* Build links around silence and filler words, since they do
* not exist in the language model. FIXME: This is
* potentially buggy, as we already do this before outputting
* lattices. */
pip = logmath_log(dag->lmath, ps_config_float(ps->config, "pip"));
silpen = pip + logmath_log(dag->lmath,
ps_config_float(ps->config, "silprob"));
fillpen = pip + logmath_log(dag->lmath,
ps_config_float(ps->config, "fillprob"));
ps_lattice_penalize_fillers(dag, silpen, fillpen);
}
return dag;
load_error:
E_ERROR("Failed to load %s\n", file);
lineiter_free(line);
fclose_comp(fp, ispipe);
ckd_free(darray);
return NULL;
} | pushq %rbp
movq %rsp, %rbp
subq $0x200, %rsp # imm = 0x200
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x1, %edi
movl $0x80, %esi
leaq 0x62c8c(%rip), %rdx # 0x78e50
movl $0x192, %ecx # imm = 0x192
callq 0x23c10
movq %rax, -0x50(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x1623c
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xae60
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x25970
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x5efc7(%rip), %rsi # 0x751f3
callq 0x14360
movl %eax, %ecx
movq -0x50(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x1627a
xorl %eax, %eax
movl %eax, %esi
movq %rsi, %rdi
callq 0xa170
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x18(%rax)
movsd 0x62bd5(%rip), %xmm0 # 0x78e30
xorl %esi, %esi
movl %esi, %edi
callq 0x24ca0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x50(%rbp), %rax
movl $0x64, 0x24(%rax)
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x38(%rax), %ecx
movq -0x50(%rbp), %rax
movl %ecx, 0x20(%rax)
movl $0x48, %edi
callq 0x263a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x58(%rax)
movl $0x30, %edi
callq 0x263a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x60(%rax)
movl $0x10, %edi
callq 0x263a0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x50(%rbp), %rax
movl $0x1, (%rax)
movq $0x0, -0x48(%rbp)
movq -0x18(%rbp), %r8
movl $0x1, %edi
leaq 0x62b63(%rip), %rsi # 0x78e50
movl $0x1a7, %edx # imm = 0x1A7
leaq 0x62e13(%rip), %rcx # 0x7910c
movb $0x0, %al
callq 0x23450
movq -0x18(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x26fb0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x16347
movq -0x18(%rbp), %r8
movl $0x3, %edi
leaq 0x62b29(%rip), %rsi # 0x78e50
movl $0x1a9, %edx # imm = 0x1A9
leaq 0x62def(%rip), %rcx # 0x79122
movb $0x0, %al
callq 0x23600
movq $0x0, -0x8(%rbp)
jmp 0x16db3
movq -0x20(%rbp), %rdi
callq 0x27260
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x16383
movq -0x18(%rbp), %r8
movl $0x3, %edi
leaq 0x62ae5(%rip), %rsi # 0x78e50
movl $0x1b0, %edx # imm = 0x1B0
leaq 0x62dd4(%rip), %rcx # 0x7914b
movb $0x0, %al
callq 0x23450
jmp 0x16d6a
movq -0x30(%rbp), %rax
movq (%rax), %rdi
leaq 0x62dcd(%rip), %rsi # 0x7915e
movl $0xa, %edx
callq 0x7090
cmpl $0x0, %eax
je 0x163cf
movq -0x18(%rbp), %r8
movq -0x30(%rbp), %rax
movq (%rax), %r9
movl $0x3, %edi
leaq 0x62a99(%rip), %rsi # 0x78e50
movl $0x1b4, %edx # imm = 0x1B4
leaq 0x62da6(%rip), %rcx # 0x79169
movb $0x0, %al
callq 0x23450
jmp 0x16d6a
movq -0x30(%rbp), %rdi
callq 0x27360
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x1640a
movq -0x18(%rbp), %r8
movl $0x3, %edi
leaq 0x62a5e(%rip), %rsi # 0x78e50
movl $0x1b8, %edx # imm = 0x1B8
leaq 0x62d4d(%rip), %rcx # 0x7914b
movb $0x0, %al
callq 0x23450
jmp 0x16d6a
movq -0x30(%rbp), %rax
movq (%rax), %rdi
leaq 0x62d78(%rip), %rsi # 0x79190
movl $0xb, %edx
callq 0x7090
cmpl $0x0, %eax
jne 0x16449
movq -0x30(%rbp), %rax
movq (%rax), %rdi
addq $0xb, %rdi
leaq 0x62d63(%rip), %rsi # 0x7919c
leaq -0x38(%rbp), %rdx
movb $0x0, %al
callq 0x7300
cmpl $0x1, %eax
je 0x16479
movq -0x18(%rbp), %r8
movl $0x2, %edi
leaq 0x629f7(%rip), %rsi # 0x78e50
movl $0x1bd, %edx # imm = 0x1BD
leaq 0x62d3b(%rip), %rcx # 0x791a0
movb $0x0, %al
callq 0x23450
movsd 0x629bc(%rip), %xmm0 # 0x78e30
movsd %xmm0, -0x38(%rbp)
movss 0x61d03(%rip), %xmm0 # 0x78184
movss %xmm0, -0x3c(%rbp)
movq -0x50(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x164b2
movsd -0x38(%rbp), %xmm0
xorl %edi, %edi
movl $0x1, %esi
callq 0x24ca0
movq %rax, %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x16586
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x25a00
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x74(%rbp)
movsd -0x38(%rbp), %xmm0
movss -0x74(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
subsd %xmm1, %xmm0
movaps 0x6295f(%rip), %xmm1 # 0x78e40
pand %xmm1, %xmm0
movsd 0x6294b(%rip), %xmm1 # 0x78e38
ucomisd %xmm1, %xmm0
jb 0x16584
movsd -0x38(%rbp), %xmm0
movss -0x74(%rbp), %xmm1
cvtss2sd %xmm1, %xmm1
movl $0x2, %edi
leaq 0x6293f(%rip), %rsi # 0x78e50
movl $0x1c6, %edx # imm = 0x1C6
leaq 0x62ca7(%rip), %rcx # 0x791c4
movb $0x2, %al
callq 0x23450
movsd -0x38(%rbp), %xmm0
callq 0x7200
movsd %xmm0, -0x1c8(%rbp)
movss -0x74(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x7200
movaps %xmm0, %xmm1
movsd -0x1c8(%rbp), %xmm0
divsd %xmm1, %xmm0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x3c(%rbp)
movss -0x3c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movl $0x1, %edi
leaq 0x628df(%rip), %rsi # 0x78e50
movl $0x1c8, %edx # imm = 0x1C8
leaq 0x62c79(%rip), %rcx # 0x791f6
movb $0x1, %al
callq 0x23450
jmp 0x16586
movq -0x30(%rbp), %rdi
leaq 0x62c7c(%rip), %rsi # 0x7920d
callq 0x16dc0
movl %eax, %ecx
movq -0x50(%rbp), %rax
movl %ecx, 0x40(%rax)
movq -0x50(%rbp), %rax
cmpl $0x0, 0x40(%rax)
jg 0x165cd
movl $0x3, %edi
leaq 0x6289b(%rip), %rsi # 0x78e50
movl $0x1ce, %edx # imm = 0x1CE
leaq 0x62c53(%rip), %rcx # 0x79214
movb $0x0, %al
callq 0x23450
jmp 0x16d6a
movq -0x30(%rbp), %rdi
leaq 0x62c61(%rip), %rsi # 0x79239
callq 0x16dc0
movl %eax, -0x5c(%rbp)
cmpl $0x0, -0x5c(%rbp)
jg 0x1660a
movl $0x3, %edi
leaq 0x6285e(%rip), %rsi # 0x78e50
movl $0x1d4, %edx # imm = 0x1D4
leaq 0x62c41(%rip), %rcx # 0x7923f
movb $0x0, %al
callq 0x23450
jmp 0x16d6a
movslq -0x5c(%rbp), %rdi
movl $0x8, %esi
leaq 0x62836(%rip), %rdx # 0x78e50
movl $0x1d9, %ecx # imm = 0x1D9
callq 0x23c10
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x70(%rbp)
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x5c(%rbp), %eax
jge 0x16918
movq -0x30(%rbp), %rdi
callq 0x27360
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x16682
movq -0x18(%rbp), %r8
movl $0x3, %edi
leaq 0x627e6(%rip), %rsi # 0x78e50
movl $0x1e2, %edx # imm = 0x1E2
leaq 0x62bed(%rip), %rcx # 0x79263
movb $0x0, %al
callq 0x23450
jmp 0x16d6a
movq -0x30(%rbp), %rax
movq (%rax), %rdi
leaq -0x190(%rbp), %rcx
leaq 0x62bf3(%rip), %rsi # 0x7928a
leaq -0x7c(%rbp), %rdx
leaq -0x80(%rbp), %r8
leaq -0x84(%rbp), %r9
leaq -0x88(%rbp), %rax
movq %rax, (%rsp)
movb $0x0, %al
callq 0x7300
movl %eax, -0x58(%rbp)
cmpl $0x5, %eax
je 0x166ef
movq -0x30(%rbp), %rax
movq (%rax), %r8
movl -0x58(%rbp), %r9d
movl $0x3, %edi
leaq 0x62779(%rip), %rsi # 0x78e50
movl $0x1e9, %edx # imm = 0x1E9
leaq 0x62bb9(%rip), %rcx # 0x7929c
movb $0x0, %al
callq 0x23450
jmp 0x16d6a
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x190(%rbp), %rsi
callq 0xabd0
movl %eax, -0x78(%rbp)
cmpl $0x0, -0x78(%rbp)
jge 0x167e0
movq -0x50(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x167ad
leaq -0x190(%rbp), %rdi
leaq 0x62723(%rip), %rsi # 0x78e50
movl $0x1f0, %edx # imm = 0x1F0
callq 0x23d20
movq %rax, -0x1a0(%rbp)
movq -0x1a0(%rbp), %rdi
callq 0x9df0
cmpl $-0x1, %eax
je 0x16784
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x1a0(%rbp), %rsi
callq 0xabd0
cmpl $-0x1, %eax
jne 0x16782
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x1a0(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x9b30
jmp 0x16784
movq -0x1a0(%rbp), %rdi
callq 0x23e40
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rdi
leaq -0x190(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
callq 0x9b30
movl %eax, -0x78(%rbp)
cmpl $0x0, -0x78(%rbp)
jge 0x167de
movq -0x30(%rbp), %rax
movq (%rax), %r8
movl $0x3, %edi
leaq 0x6268a(%rip), %rsi # 0x78e50
movl $0x1f9, %edx # imm = 0x1F9
leaq 0x62af4(%rip), %rcx # 0x792c6
movb $0x0, %al
callq 0x23450
jmp 0x16d6a
jmp 0x167e0
movl -0x7c(%rbp), %eax
cmpl -0x54(%rbp), %eax
je 0x16813
movq -0x30(%rbp), %rax
movq (%rax), %r8
movl $0x3, %edi
leaq 0x62655(%rip), %rsi # 0x78e50
movl $0x1ff, %edx # imm = 0x1FF
leaq 0x62ad9(%rip), %rcx # 0x792e0
movb $0x0, %al
callq 0x23450
jmp 0x16d6a
movq -0x50(%rbp), %rax
movq 0x58(%rax), %rdi
leaq 0x6262e(%rip), %rsi # 0x78e50
movl $0x203, %edx # imm = 0x203
callq 0x266d0
movq %rax, %rcx
movq -0x70(%rbp), %rax
movq %rcx, (%rax)
movq -0x70(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x198(%rbp)
movq -0x198(%rbp), %rdx
movq -0x48(%rbp), %rax
movslq -0x54(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x78(%rbp), %ecx
movq -0x198(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rax
movslq -0x78(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movl 0x18(%rax), %ecx
movq -0x198(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x7c(%rbp), %ecx
movq -0x198(%rbp), %rax
movl %ecx, (%rax)
movl -0x80(%rbp), %ecx
movq -0x198(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x84(%rbp), %ecx
movq -0x198(%rbp), %rax
movl %ecx, 0xc(%rax)
movl -0x88(%rbp), %ecx
movq -0x198(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x198(%rbp), %rax
movw $0x0, 0x18(%rax)
movq -0x198(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x198(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x198(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x198(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x70(%rbp)
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x1663b
movq -0x30(%rbp), %rdi
leaq 0x629ce(%rip), %rsi # 0x792f1
callq 0x16dc0
movl %eax, -0x58(%rbp)
cmpl $0x0, -0x58(%rbp)
jl 0x16939
movl -0x58(%rbp), %eax
cmpl -0x5c(%rbp), %eax
jl 0x1695d
movl $0x3, %edi
leaq 0x6250b(%rip), %rsi # 0x78e50
movl $0x215, %edx # imm = 0x215
leaq 0x629a8(%rip), %rcx # 0x792f9
movb $0x0, %al
callq 0x23450
jmp 0x16d6a
movq -0x48(%rbp), %rax
movslq -0x58(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rdi
leaq 0x629a8(%rip), %rsi # 0x79324
callq 0x16dc0
movl %eax, -0x58(%rbp)
cmpl $0x0, -0x58(%rbp)
jl 0x16992
movl -0x58(%rbp), %eax
cmpl -0x5c(%rbp), %eax
jl 0x169b6
movl $0x3, %edi
leaq 0x624b2(%rip), %rsi # 0x78e50
movl $0x21d, %edx # imm = 0x21D
leaq 0x62980(%rip), %rcx # 0x7932a
movb $0x0, %al
callq 0x23450
jmp 0x16d6a
movq -0x48(%rbp), %rax
movslq -0x58(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x50(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x30(%rbp), %rdi
leaq 0x6297e(%rip), %rsi # 0x79353
callq 0x16dc0
movl %eax, -0x58(%rbp)
cmpl $0x0, %eax
jge 0x16a06
movl $0x3, %edi
leaq 0x62462(%rip), %rsi # 0x78e50
movl $0x224, %edx # imm = 0x224
leaq 0x62965(%rip), %rcx # 0x7935f
movb $0x0, %al
callq 0x23450
jmp 0x16d6a
movl $0x0, -0x54(%rbp)
movl -0x54(%rbp), %eax
cmpl -0x58(%rbp), %eax
jge 0x16a5d
movq -0x30(%rbp), %rdi
callq 0x27360
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x16a50
movq -0x30(%rbp), %r8
movl $0x3, %edi
leaq 0x62418(%rip), %rsi # 0x78e50
movl $0x22a, %edx # imm = 0x22A
leaq 0x6293a(%rip), %rcx # 0x7937e
movb $0x0, %al
callq 0x23450
jmp 0x16d6a
jmp 0x16a52
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x16a0d
jmp 0x16a5f
movq -0x30(%rbp), %rdi
callq 0x27360
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x16aa7
movq -0x30(%rbp), %rax
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
jne 0x16a83
jmp 0x16a5f
movq -0x30(%rbp), %rax
movq (%rax), %rdi
leaq 0x6291c(%rip), %rsi # 0x793ad
movl $0x5, %edx
callq 0x7090
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x16aa5
jmp 0x16aa7
jmp 0x16a5f
cmpq $0x0, -0x30(%rbp)
jne 0x16ad2
movl $0x3, %edi
leaq 0x62396(%rip), %rsi # 0x78e50
movl $0x237, %edx # imm = 0x237
leaq 0x628ed(%rip), %rcx # 0x793b3
movb $0x0, %al
callq 0x23450
jmp 0x16d6a
jmp 0x16ad4
movq -0x30(%rbp), %rdi
callq 0x27360
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x16bb7
movq -0x30(%rbp), %rax
movq (%rax), %rdi
leaq 0x6279a(%rip), %rsi # 0x79293
leaq -0x1a4(%rbp), %rdx
leaq -0x1a8(%rbp), %rcx
leaq -0x1ac(%rbp), %r8
movb $0x0, %al
callq 0x7300
cmpl $0x3, %eax
je 0x16b1f
jmp 0x16bb7
cmpl $0xe0000000, -0x1ac(%rbp) # imm = 0xE0000000
jge 0x16b2d
jmp 0x16ad4
movq -0x48(%rbp), %rax
movslq -0x1a4(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x1b8(%rbp)
movq -0x48(%rbp), %rax
movslq -0x1a8(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x1c0(%rbp)
movss -0x3c(%rbp), %xmm0
movss 0x6161e(%rip), %xmm1 # 0x78184
ucomiss %xmm1, %xmm0
jne 0x16b6f
jp 0x16b6f
jmp 0x16b86
cvtsi2ssl -0x1ac(%rbp), %xmm0
mulss -0x3c(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x1ac(%rbp)
movq -0x50(%rbp), %rdi
movq -0x1b8(%rbp), %rsi
movq -0x1c0(%rbp), %rdx
movl -0x1ac(%rbp), %ecx
movq -0x1c0(%rbp), %rax
movl 0x14(%rax), %r8d
subl $0x1, %r8d
callq 0x15380
jmp 0x16ad4
movq -0x30(%rbp), %rax
movq (%rax), %rdi
leaq 0x62468(%rip), %rsi # 0x7902d
callq 0x7260
cmpl $0x0, %eax
je 0x16bf3
movl $0x3, %edi
leaq 0x62275(%rip), %rsi # 0x78e50
movl $0x24a, %edx # imm = 0x24A
leaq 0x627db(%rip), %rcx # 0x793c2
movb $0x0, %al
callq 0x23450
jmp 0x16d6a
movq -0x30(%rbp), %rdi
callq 0x27670
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x26f80
movq -0x48(%rbp), %rdi
callq 0x23e40
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x50(%rbp), %rax
movq 0x38(%rax), %rax
movl 0x4(%rax), %esi
callq 0xad80
cmpl $0x0, %eax
je 0x16c77
movq -0x50(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x16c4c
movq -0x50(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x68(%rax), %eax
movl %eax, -0x1cc(%rbp)
jmp 0x16c66
movq -0x50(%rbp), %rax
movq 0x18(%rax), %rdi
leaq 0x60bf0(%rip), %rsi # 0x7784b
callq 0xabd0
movl %eax, -0x1cc(%rbp)
movl -0x1cc(%rbp), %ecx
movq -0x50(%rbp), %rax
movq 0x38(%rax), %rax
movl %ecx, 0x8(%rax)
movq -0x50(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x16e90
movq -0x50(%rbp), %rdi
callq 0x155c0
cmpq $0x0, -0x10(%rbp)
je 0x16d60
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x1f0(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x5f24c(%rip), %rsi # 0x75f01
callq 0x14430
movq -0x1f0(%rbp), %rdi
callq 0x25c20
movl %eax, -0x60(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x1dc(%rbp)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x1e8(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x5f90a(%rip), %rsi # 0x765f9
callq 0x14430
movq -0x1e8(%rbp), %rdi
callq 0x25c20
movl %eax, %ecx
movl -0x1dc(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x64(%rbp)
movl -0x60(%rbp), %eax
movl %eax, -0x1d0(%rbp)
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x1d8(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x5f8f8(%rip), %rsi # 0x7662b
callq 0x14430
movq -0x1d8(%rbp), %rdi
callq 0x25c20
movl %eax, %ecx
movl -0x1d0(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x68(%rbp)
movq -0x50(%rbp), %rdi
movl -0x64(%rbp), %esi
movl -0x68(%rbp), %edx
callq 0x154f0
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x16db3
movq -0x18(%rbp), %r8
movl $0x3, %edi
leaq 0x620d6(%rip), %rsi # 0x78e50
movl $0x26f, %edx # imm = 0x26F
leaq 0x62657(%rip), %rcx # 0x793dd
movb $0x0, %al
callq 0x23450
movq -0x30(%rbp), %rdi
callq 0x27670
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x26f80
movq -0x48(%rbp), %rdi
callq 0x23e40
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x200, %rsp # imm = 0x200
popq %rbp
retq
| /cmusphinx[P]pocketsphinx/src/ps_lattice.c |
ps_lattice_init_search | ps_lattice_t *
ps_lattice_init_search(ps_search_t *search, int n_frame)
{
ps_lattice_t *dag;
dag = ckd_calloc(1, sizeof(*dag));
dag->search = search;
dag->dict = dict_retain(search->dict);
dag->lmath = logmath_retain(search->acmod->lmath);
dag->frate = ps_config_int(dag->search->config, "frate");
dag->silence = dict_silwid(dag->dict);
dag->n_frames = n_frame;
dag->latnode_alloc = listelem_alloc_init(sizeof(ps_latnode_t));
dag->latlink_alloc = listelem_alloc_init(sizeof(ps_latlink_t));
dag->latlink_list_alloc = listelem_alloc_init(sizeof(latlink_list_t));
dag->refcount = 1;
return dag;
} | pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x1, %edi
movl $0x80, %esi
leaq 0x61f10(%rip), %rdx # 0x78e50
movl $0x281, %ecx # imm = 0x281
callq 0x23c10
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0xae60
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x25970
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rdi
leaq 0x5e252(%rip), %rsi # 0x751f3
callq 0x14360
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x38(%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x20(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x40(%rax)
movl $0x48, %edi
callq 0x263a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
movl $0x30, %edi
callq 0x263a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x60(%rax)
movl $0x10, %edi
callq 0x263a0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x68(%rax)
movq -0x18(%rbp), %rax
movl $0x1, (%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
| /cmusphinx[P]pocketsphinx/src/ps_lattice.c |
ps_lattice_link2itor | static void
ps_lattice_link2itor(ps_seg_t *seg, ps_latlink_t *link, int to)
{
dag_seg_t *itor = (dag_seg_t *)seg;
ps_latnode_t *node;
if (to) {
node = link->to;
seg->ef = node->lef;
seg->prob = 0; /* norm + beta - norm */
}
else {
latlink_list_t *x;
ps_latnode_t *n;
logmath_t *lmath = ps_search_acmod(seg->search)->lmath;
node = link->from;
seg->ef = link->ef;
seg->prob = link->alpha + link->beta - itor->norm;
/* Sum over all exits for this word and any alternate
pronunciations at the same frame. */
for (n = node; n; n = n->alt) {
for (x = n->exits; x; x = x->next) {
if (x->link == link)
continue;
seg->prob = logmath_add(lmath, seg->prob,
x->link->alpha + x->link->beta - itor->norm);
}
}
}
seg->text = dict_wordstr(ps_search_dict(seg->search), node->wid);
seg->wid = node->wid;
seg->sf = node->sf;
seg->ascr = link->ascr << SENSCR_SHIFT;
/* Compute language model score from best predecessors. */
ps_lattice_compute_lscr(seg, link, to);
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x17a4b
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
jmp 0x17b19
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x10(%rbp), %rax
movl 0x24(%rax), %ecx
movq -0x10(%rbp), %rax
addl 0x28(%rax), %ecx
movq -0x20(%rbp), %rax
subl 0x40(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x17b17
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x17b07
movq -0x30(%rbp), %rax
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x17ac5
jmp 0x17af9
movq -0x40(%rbp), %rdi
movq -0x8(%rbp), %rax
movl 0x2c(%rax), %esi
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl 0x24(%rax), %edx
movq -0x30(%rbp), %rax
movq (%rax), %rax
addl 0x28(%rax), %edx
movq -0x20(%rbp), %rax
subl 0x40(%rax), %edx
callq 0x25a80
movl %eax, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x2c(%rax)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
jmp 0x17aaf
jmp 0x17b09
movq -0x38(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x17a9c
jmp 0x17b19
movq -0x28(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jge 0x17b2b
xorl %eax, %eax
movq %rax, -0x48(%rbp)
jmp 0x17b51
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movslq 0x4(%rcx), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x20(%rax)
movq -0x28(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl 0x18(%rax), %ecx
shll $0xa, %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x24(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x19de0
addq $0x50, %rsp
popq %rbp
retq
| /cmusphinx[P]pocketsphinx/src/ps_lattice.c |
ps_lattice_joint | static int32
ps_lattice_joint(ps_lattice_t *dag, ps_latlink_t *link, float32 ascale)
{
ngram_model_t *lmset;
int32 jprob;
/* Sort of a hack... */
if (dag->search && 0 == strcmp(ps_search_type(dag->search), PS_SEARCH_TYPE_NGRAM))
lmset = ((ngram_search_t *)dag->search)->lmset;
else
lmset = NULL;
jprob = (int32)((dag->final_node_ascr << SENSCR_SHIFT) * ascale);
while (link) {
if (lmset) {
int lback;
int32 from_wid, to_wid;
int16 from_is_fil, to_is_fil;
from_wid = link->from->basewid;
to_wid = link->to->basewid;
from_is_fil = dict_filler_word(dag->dict, from_wid) && link->from != dag->start;
to_is_fil = dict_filler_word(dag->dict, to_wid) && link->to != dag->end;
/* Find word predecessor if from-word is filler */
if (!to_is_fil && from_is_fil) {
ps_latlink_t *prev_link = link;
while (prev_link->best_prev != NULL) {
prev_link = prev_link->best_prev;
from_wid = prev_link->from->basewid;
if (!dict_filler_word(dag->dict, from_wid) || prev_link->from == dag->start) {
from_is_fil = FALSE;
break;
}
}
}
/* Compute unscaled language model probability. Note that
this is actually not the language model probability
that corresponds to this link, but that is okay,
because we are just taking the sum over all links in
the best path. */
if (!from_is_fil && !to_is_fil)
jprob += ngram_ng_prob(lmset, to_wid,
&from_wid, 1, &lback);
}
/* If there is no language model, we assume that the language
model probability (such as it is) has been included in the
link score. */
jprob += (int32)((link->ascr << SENSCR_SHIFT) * ascale);
link = link->best_prev;
}
E_INFO("Joint P(O,S) = %d P(S|O) = %d\n", jprob, jprob - dag->norm);
return jprob;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x18c22
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
leaq 0x5f8f8(%rip), %rsi # 0x784fb
callq 0x7260
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x18c22
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x70(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x18c2a
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x48(%rax), %eax
shll $0xa, %eax
cvtsi2ss %eax, %xmm0
mulss -0x14(%rbp), %xmm0
cvttss2si %xmm0, %eax
movl %eax, -0x24(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x18dbb
cmpq $0x0, -0x20(%rbp)
je 0x18d8d
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x2c(%rbp), %esi
callq 0xad80
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x41(%rbp)
je 0x18ca6
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
setne %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, -0x32(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x30(%rbp), %esi
callq 0xad80
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x42(%rbp)
je 0x18ce4
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x38(%rcx), %rax
setne %al
movb %al, -0x42(%rbp)
movb -0x42(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movw %ax, -0x34(%rbp)
cmpw $0x0, -0x34(%rbp)
jne 0x18d5e
movswl -0x32(%rbp), %eax
cmpl $0x0, %eax
je 0x18d5e
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x18d5c
movq -0x40(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movl -0x2c(%rbp), %esi
callq 0xad80
cmpl $0x0, %eax
je 0x18d52
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x30(%rcx), %rax
jne 0x18d5a
movw $0x0, -0x32(%rbp)
jmp 0x18d5c
jmp 0x18d08
jmp 0x18d5e
cmpw $0x0, -0x32(%rbp)
jne 0x18d8b
cmpw $0x0, -0x34(%rbp)
jne 0x18d8b
movq -0x20(%rbp), %rdi
movl -0x30(%rbp), %esi
leaq -0x2c(%rbp), %rdx
movl $0x1, %ecx
leaq -0x28(%rbp), %r8
callq 0x48fa0
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x18d8d
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
shll $0xa, %eax
cvtsi2ss %eax, %xmm0
mulss -0x14(%rbp), %xmm0
cvttss2si %xmm0, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x18c44
movl -0x24(%rbp), %r8d
movl -0x24(%rbp), %r9d
movq -0x8(%rbp), %rax
subl 0x4c(%rax), %r9d
movl $0x1, %edi
leaq 0x60079(%rip), %rsi # 0x78e50
movl $0x5a3, %edx # imm = 0x5A3
leaq 0x606be(%rip), %rcx # 0x794a1
movb $0x0, %al
callq 0x23450
movl -0x24(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/ps_lattice.c |
ps_astar_start | ps_astar_t *
ps_astar_start(ps_lattice_t *dag,
ngram_model_t *lmset,
float32 lwf,
int sf, int ef,
int w1, int w2)
{
ps_astar_t *nbest;
ps_latnode_t *node;
nbest = ckd_calloc(1, sizeof(*nbest));
nbest->dag = dag;
nbest->lmset = lmset;
nbest->lwf = lwf;
nbest->sf = sf;
if (ef < 0)
nbest->ef = dag->n_frames + 1;
else
nbest->ef = ef;
nbest->w1 = w1;
nbest->w2 = w2;
nbest->latpath_alloc = listelem_alloc_init(sizeof(ps_latpath_t));
/* Initialize rem_score (A* heuristic) to default values */
for (node = dag->nodes; node; node = node->next) {
if (node == dag->end)
node->info.rem_score = 0;
else if (node->exits == NULL)
node->info.rem_score = WORST_SCORE;
else
node->info.rem_score = 1; /* +ve => unknown value */
}
/* Create initial partial hypotheses list consisting of nodes starting at sf */
nbest->path_list = nbest->path_tail = NULL;
for (node = dag->nodes; node; node = node->next) {
if (node->sf == sf) {
ps_latpath_t *path;
int32 n_used;
best_rem_score(nbest, node);
path = listelem_malloc(nbest->latpath_alloc);
path->node = node;
path->parent = NULL;
if (nbest->lmset)
path->score = nbest->lwf *
((w1 < 0)
? ngram_bg_score(nbest->lmset, node->basewid, w2, &n_used)
: ngram_tg_score(nbest->lmset, node->basewid, w2, w1, &n_used));
else
path->score = 0;
path->score >>= SENSCR_SHIFT;
path_insert(nbest, path, path->score + node->info.rem_score);
}
}
return nbest;
} | pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movl $0x1, %edi
movl $0x60, %esi
leaq 0x5fe3c(%rip), %rdx # 0x78e50
movl $0x6bb, %ecx # imm = 0x6BB
callq 0x23c10
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movss -0x14(%rbp), %xmm0
movq -0x30(%rbp), %rax
movss %xmm0, 0x10(%rax)
movl -0x18(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x14(%rax)
cmpl $0x0, -0x1c(%rbp)
jge 0x1906a
movq -0x8(%rbp), %rax
movl 0x40(%rax), %ecx
addl $0x1, %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x18(%rax)
jmp 0x19074
movl -0x1c(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x20(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x1c(%rax)
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x20(%rax)
movl $0x20, %edi
callq 0x263a0
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x58(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x19100
movq -0x38(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jne 0x190cb
movq -0x38(%rbp), %rax
movl $0x0, 0x20(%rax)
jmp 0x190f0
movq -0x38(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0x190e3
movq -0x38(%rbp), %rax
movl $0xe0000000, 0x20(%rax) # imm = 0xE0000000
jmp 0x190ee
movq -0x38(%rbp), %rax
movl $0x1, 0x20(%rax)
jmp 0x190f0
jmp 0x190f2
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x190a9
movq -0x30(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x30(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x19243
movq -0x38(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x19230
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x19250
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rdi
leaq 0x5fcf5(%rip), %rsi # 0x78e50
movl $0x6da, %edx # imm = 0x6DA
callq 0x266d0
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rcx
movq -0x40(%rbp), %rax
movq %rcx, (%rax)
movq -0x40(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x30(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x191fd
movq -0x30(%rbp), %rax
movss 0x10(%rax), %xmm0
movss %xmm0, -0x48(%rbp)
cmpl $0x0, -0x20(%rbp)
jge 0x191bf
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x38(%rbp), %rax
movl 0x8(%rax), %esi
movl -0x24(%rbp), %edx
leaq -0x44(%rbp), %rcx
callq 0x48f60
movl %eax, -0x4c(%rbp)
jmp 0x191e0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x38(%rbp), %rax
movl 0x8(%rax), %esi
movl -0x24(%rbp), %edx
movl -0x20(%rbp), %ecx
leaq -0x44(%rbp), %r8
callq 0x48f10
movl %eax, -0x4c(%rbp)
movss -0x48(%rbp), %xmm0
movl -0x4c(%rbp), %eax
cvtsi2ss %eax, %xmm1
mulss %xmm1, %xmm0
cvttss2si %xmm0, %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x18(%rax)
jmp 0x19208
movq -0x40(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x40(%rbp), %rax
movl 0x18(%rax), %ecx
sarl $0xa, %ecx
movl %ecx, 0x18(%rax)
movq -0x30(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x40(%rbp), %rax
movl 0x18(%rax), %edx
movq -0x38(%rbp), %rax
addl 0x20(%rax), %edx
callq 0x19350
jmp 0x19232
movq -0x38(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x19124
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
| /cmusphinx[P]pocketsphinx/src/ps_lattice.c |
evaluate_hmms | static int32
evaluate_hmms(state_align_search_t *sas, int16 const *senscr, int frame_idx)
{
int32 bs = WORST_SCORE;
int i;
hmm_context_set_senscore(sas->hmmctx, senscr);
for (i = 0; i < sas->n_phones; ++i) {
hmm_t *hmm = sas->hmms + i;
int32 score;
if (hmm_frame(hmm) < frame_idx)
continue;
score = hmm_vit_eval(hmm);
if (score BETTER_THAN bs) {
bs = score;
}
}
return bs;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0xe0000000, -0x18(%rbp) # imm = 0xE0000000
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rax
movq %rcx, 0x10(%rax)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x98(%rcx), %eax
jge 0x1b2af
movq -0x8(%rbp), %rax
movq 0x80(%rax), %rax
movslq -0x1c(%rbp), %rcx
imulq $0x58, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x4c(%rax), %eax
cmpl -0x14(%rbp), %eax
jge 0x1b288
jmp 0x1b2a4
movq -0x28(%rbp), %rdi
callq 0x3e5b0
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jle 0x1b2a2
movl -0x2c(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x1b2a4
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1b251
movl -0x18(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/state_align_search.c |
s2b | static Bigint *
s2b(const char *s, int nd0, int nd, ULong y9)
{
Bigint *b;
int i, k;
Long x, y;
x = (nd + 8) / 9;
for(k = 0, y = 1; x > y; y <<= 1, k++) ;
b = Balloc(k);
if (b == NULL)
return NULL;
b->x[0] = y9;
b->wds = 1;
if (nd <= 9)
return b;
s += 9;
for (i = 9; i < nd0; i++) {
b = multadd(b, 10, *s++ - '0');
if (b == NULL)
return NULL;
}
s++;
for(; i < nd; i++) {
b = multadd(b, 10, *s++ - '0');
if (b == NULL)
return NULL;
}
return b;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl -0x18(%rbp), %eax
addl $0x8, %eax
movl $0x9, %ecx
cltd
idivl %ecx
movl %eax, -0x34(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x1, -0x38(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x38(%rbp), %eax
jle 0x1d841
jmp 0x1d82e
movl -0x38(%rbp), %eax
shll %eax
movl %eax, -0x38(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1d824
movl -0x30(%rbp), %edi
callq 0x1d960
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1d861
movq $0x0, -0x8(%rbp)
jmp 0x1d94a
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x28(%rbp), %rax
movl $0x1, 0x14(%rax)
cmpl $0x9, -0x18(%rbp)
jg 0x1d889
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1d94a
movq -0x10(%rbp), %rax
addq $0x9, %rax
movq %rax, -0x10(%rbp)
movl $0x9, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1d8e9
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %edx
subl $0x30, %edx
movl $0xa, %esi
callq 0x204a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1d8dc
movq $0x0, -0x8(%rbp)
jmp 0x1d94a
jmp 0x1d8de
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1d89c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl -0x2c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x1d942
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movsbl (%rax), %edx
subl $0x30, %edx
movl $0xa, %esi
callq 0x204a0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1d935
movq $0x0, -0x8(%rbp)
jmp 0x1d94a
jmp 0x1d937
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1d8f5
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/dtoa.c |
pow5mult | static Bigint *
pow5mult(Bigint *b, int k)
{
Bigint *b1, *p5, *p51;
int i;
static int p05[3] = { 5, 25, 125 };
if ((i = k & 3)) {
b = multadd(b, p05[i-1], 0);
if (b == NULL)
return NULL;
}
if (!(k >>= 2))
return b;
p5 = i2b(625);
if (p5 == NULL) {
Bfree(b);
return NULL;
}
for(;;) {
if (k & 1) {
b1 = mult(b, p5);
Bfree(b);
b = b1;
if (b == NULL) {
Bfree(p5);
return NULL;
}
}
if (!(k >>= 1))
break;
p51 = mult(p5, p5);
Bfree(p5);
p5 = p51;
if (p5 == NULL) {
Bfree(b);
return NULL;
}
}
Bfree(p5);
return b;
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl -0x14(%rbp), %eax
andl $0x3, %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, %eax
je 0x1dd25
movq -0x10(%rbp), %rdi
movl -0x34(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rcx
leaq 0x7660f(%rip), %rax # 0x94310
movl (%rax,%rcx,4), %esi
xorl %edx, %edx
callq 0x204a0
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1dd23
movq $0x0, -0x8(%rbp)
jmp 0x1de17
jmp 0x1dd25
movl -0x14(%rbp), %eax
sarl $0x2, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x1dd40
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1de17
movl $0x271, %edi # imm = 0x271
callq 0x1dc70
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1dd6b
movq -0x10(%rbp), %rdi
callq 0x1da10
movq $0x0, -0x8(%rbp)
jmp 0x1de17
jmp 0x1dd6d
movl -0x14(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1ddb6
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1de30
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1da10
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x1ddb4
movq -0x28(%rbp), %rdi
callq 0x1da10
movq $0x0, -0x8(%rbp)
jmp 0x1de17
jmp 0x1ddb6
movl -0x14(%rbp), %eax
sarl %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jne 0x1ddc5
jmp 0x1de06
movq -0x28(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x1de30
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1da10
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x1de01
movq -0x10(%rbp), %rdi
callq 0x1da10
movq $0x0, -0x8(%rbp)
jmp 0x1de17
jmp 0x1dd6d
movq -0x28(%rbp), %rdi
callq 0x1da10
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/dtoa.c |
cmp | static int
cmp(Bigint *a, Bigint *b)
{
ULong *xa, *xa0, *xb, *xb0;
int i, j;
i = a->wds;
j = b->wds;
#ifdef DEBUG
if (i > 1 && !a->x[i-1])
Bug("cmp called with a->x[a->wds-1] == 0");
if (j > 1 && !b->x[j-1])
Bug("cmp called with b->x[b->wds-1] == 0");
#endif
if (i -= j)
return i;
xa0 = a->x;
xa = xa0 + j;
xb0 = b->x;
xb = xb0 + j;
for(;;) {
if (*--xa != *--xb)
return *xa < *xb ? -1 : 1;
if (xa <= xa0)
break;
}
return 0;
} | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %ecx
movl -0x3c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, %eax
je 0x1e56b
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x1e604
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movslq -0x40(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $-0x4, %rcx
movq %rcx, -0x20(%rbp)
movl -0x4(%rax), %eax
movq -0x30(%rbp), %rcx
movq %rcx, %rdx
addq $-0x4, %rdx
movq %rdx, -0x30(%rbp)
cmpl -0x4(%rcx), %eax
je 0x1e5ef
movq -0x20(%rbp), %rax
movl (%rax), %edx
movq -0x30(%rbp), %rax
movl (%rax), %esi
movl $0x1, %eax
movl $0xffffffff, %ecx # imm = 0xFFFFFFFF
cmpl %esi, %edx
cmovbl %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x1e604
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
ja 0x1e5fb
jmp 0x1e5fd
jmp 0x1e5a9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
| /cmusphinx[P]pocketsphinx/src/util/dtoa.c |
ratio | static double
ratio(Bigint *a, Bigint *b)
{
U da, db;
int k, ka, kb;
dval(&da) = b2d(a, &ka);
dval(&db) = b2d(b, &kb);
k = ka - kb + 32*(a->wds - b->wds);
if (k > 0)
word0(&da) += k*Exp_msk1;
else {
k = -k;
word0(&db) += k*Exp_msk1;
}
return dval(&da) / dval(&db);
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x208c0
movsd %xmm0, -0x18(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x208c0
movsd %xmm0, -0x20(%rbp)
movl -0x28(%rbp), %eax
subl -0x2c(%rbp), %eax
movq -0x8(%rbp), %rcx
movl 0x14(%rcx), %ecx
movq -0x10(%rbp), %rdx
subl 0x14(%rdx), %ecx
shll $0x5, %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jle 0x1e714
movl -0x24(%rbp), %eax
shll $0x14, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
jmp 0x1e728
xorl %eax, %eax
subl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
shll $0x14, %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movsd -0x18(%rbp), %xmm0
divsd -0x20(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/dtoa.c |
quorem | static int
quorem(Bigint *b, Bigint *S)
{
int n;
ULong *bx, *bxe, q, *sx, *sxe;
#ifdef ULLong
ULLong borrow, carry, y, ys;
#else
ULong borrow, carry, y, ys;
ULong si, z, zs;
#endif
n = S->wds;
#ifdef DEBUG
/*debug*/ if (b->wds > n)
/*debug*/ Bug("oversize b in quorem");
#endif
if (b->wds < n)
return 0;
sx = S->x;
sxe = sx + --n;
bx = b->x;
bxe = bx + n;
q = *bxe / (*sxe + 1); /* ensure q <= true quotient */
#ifdef DEBUG
/*debug*/ if (q > 9)
/*debug*/ Bug("oversized quotient in quorem");
#endif
if (q) {
borrow = 0;
carry = 0;
do {
#ifdef ULLong
ys = *sx++ * (ULLong)q + carry;
carry = ys >> 32;
y = *bx - (ys & FFFFFFFF) - borrow;
borrow = y >> 32 & (ULong)1;
*bx++ = (ULong)(y & FFFFFFFF);
#else
si = *sx++;
ys = (si & 0xffff) * q + carry;
zs = (si >> 16) * q + (ys >> 16);
carry = zs >> 16;
y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
borrow = (y & 0x10000) >> 16;
z = (*bx >> 16) - (zs & 0xffff) - borrow;
borrow = (z & 0x10000) >> 16;
Storeinc(bx, z, y);
#endif
}
while(sx <= sxe);
if (!*bxe) {
bx = b->x;
while(--bxe > bx && !*bxe)
--n;
b->wds = n;
}
}
if (cmp(b, S) >= 0) {
q++;
borrow = 0;
carry = 0;
bx = b->x;
sx = S->x;
do {
#ifdef ULLong
ys = *sx++ + carry;
carry = ys >> 32;
y = *bx - (ys & FFFFFFFF) - borrow;
borrow = y >> 32 & (ULong)1;
*bx++ = (ULong)(y & FFFFFFFF);
#else
si = *sx++;
ys = (si & 0xffff) + carry;
zs = (si >> 16) + (ys >> 16);
carry = zs >> 16;
y = (*bx & 0xffff) - (ys & 0xffff) - borrow;
borrow = (y & 0x10000) >> 16;
z = (*bx >> 16) - (zs & 0xffff) - borrow;
borrow = (z & 0x10000) >> 16;
Storeinc(bx, z, y);
#endif
}
while(sx <= sxe);
bx = b->x;
bxe = bx + n;
if (!*bxe) {
while(--bxe > bx && !*bxe)
--n;
b->wds = n;
}
}
return q;
} | pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x14(%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl 0x14(%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x20612
movl $0x0, -0x4(%rbp)
jmp 0x208a9
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $-0x1, %ecx
movl %ecx, -0x1c(%rbp)
movslq %ecx, %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movl (%rax), %eax
movq -0x48(%rbp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
xorl %edx, %edx
divl %ecx
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x2076d
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl (%rax), %eax
movl -0x34(%rbp), %ecx
imulq %rcx, %rax
addq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movabsq $0xffffffff, %rcx # imm = 0xFFFFFFFF
andq -0x68(%rbp), %rcx
subq %rcx, %rax
subq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
shrq $0x20, %rax
andq $0x1, %rax
movq %rax, -0x50(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x60(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rbp)
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jbe 0x20688
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x2076b
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rcx
addq $-0x4, %rcx
movq %rcx, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x69(%rbp)
jbe 0x2074d
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x20756
jmp 0x20761
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x20727
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0x2076d
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1e530
cmpl $0x0, %eax
jl 0x208a3
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
movq $0x0, -0x50(%rbp)
movq $0x0, -0x58(%rbp)
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x40(%rbp)
movl (%rax), %eax
addq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rax
shrq $0x20, %rax
movq %rax, -0x58(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %eax
movabsq $0xffffffff, %rcx # imm = 0xFFFFFFFF
andq -0x68(%rbp), %rcx
subq %rcx, %rax
subq -0x50(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
shrq $0x20, %rax
andq $0x1, %rax
movq %rax, -0x50(%rbp)
movabsq $0xffffffff, %rax # imm = 0xFFFFFFFF
andq -0x60(%rbp), %rax
movl %eax, %ecx
movq -0x28(%rbp), %rax
movq %rax, %rdx
addq $0x4, %rdx
movq %rdx, -0x28(%rbp)
movl %ecx, (%rax)
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
jbe 0x207b4
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x208a1
jmp 0x2085d
movq -0x30(%rbp), %rcx
addq $-0x4, %rcx
movq %rcx, -0x30(%rbp)
xorl %eax, %eax
cmpq -0x28(%rbp), %rcx
movb %al, -0x6a(%rbp)
jbe 0x20883
movq -0x30(%rbp), %rax
cmpl $0x0, (%rax)
setne %al
xorb $-0x1, %al
movb %al, -0x6a(%rbp)
movb -0x6a(%rbp), %al
testb $0x1, %al
jne 0x2088c
jmp 0x20897
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2085d
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x14(%rax)
jmp 0x208a3
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/dtoa.c |
hi0bits | static int
hi0bits(ULong x)
{
int k = 0;
if (!(x & 0xffff0000)) {
k = 16;
x <<= 16;
}
if (!(x & 0xff000000)) {
k += 8;
x <<= 8;
}
if (!(x & 0xf0000000)) {
k += 4;
x <<= 4;
}
if (!(x & 0xc0000000)) {
k += 2;
x <<= 2;
}
if (!(x & 0x80000000)) {
k++;
if (!(x & 0x40000000))
return 32;
}
return k;
} | pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0xffff0000, %eax # imm = 0xFFFF0000
cmpl $0x0, %eax
jne 0x20a8b
movl $0x10, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x10, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xff000000, %eax # imm = 0xFF000000
cmpl $0x0, %eax
jne 0x20aaa
movl -0xc(%rbp), %eax
addl $0x8, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x8, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xf0000000, %eax # imm = 0xF0000000
cmpl $0x0, %eax
jne 0x20ac9
movl -0xc(%rbp), %eax
addl $0x4, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x4, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xc0000000, %eax # imm = 0xC0000000
cmpl $0x0, %eax
jne 0x20ae8
movl -0xc(%rbp), %eax
addl $0x2, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll $0x2, %eax
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0x80000000, %eax # imm = 0x80000000
cmpl $0x0, %eax
jne 0x20b16
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x8(%rbp), %eax
andl $0x40000000, %eax # imm = 0x40000000
cmpl $0x0, %eax
jne 0x20b14
movl $0x20, -0x4(%rbp)
jmp 0x20b1c
jmp 0x20b16
movl -0xc(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
| /cmusphinx[P]pocketsphinx/src/util/dtoa.c |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.