name string | code string | asm string | file string |
|---|---|---|---|
sptk::SymmetricMatrix::At(int, int) const | const double& SymmetricMatrix::At(int row, int column) const {
if (row < column) {
std::swap(row, column);
}
if (column < 0 || num_dimension_ <= row) {
throw std::out_of_range(kErrorMessageForOutOfRange);
}
return index_[row][column];
} | subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0x1d4e4
leaq 0x2c(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1e1d0
cmpl $0x0, 0x28(%rsp)
jl 0x1d4f9
movq 0x10(%rsp), %rax
movl 0x8(%rax), %eax
cmp... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
sptk::SymmetricMatrix::CholeskyDecomposition(sptk::SymmetricMatrix*, std::vector<double, std::allocator<double>>*) const | bool SymmetricMatrix::CholeskyDecomposition(
SymmetricMatrix* lower_triangular_matrix,
std::vector<double>* diagonal_elements) const {
if (NULL == lower_triangular_matrix || NULL == diagonal_elements ||
this == lower_triangular_matrix || 0.0 == index_[0][0]) {
return false;
}
if (lower_triangul... | subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
xorl %eax, %eax
cmpq 0x50(%rsp), %rax
je 0x1d7bb
xorl %eax, %eax
cmpq 0x48(%rsp), %rax
je 0x1d7bb
movq 0x20(%rsp), %rax
cmpq 0x50(%rsp), %rax
je 0x1d7bb
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
x... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
sptk::SymmetricMatrix::Invert(sptk::SymmetricMatrix*) const | bool SymmetricMatrix::Invert(SymmetricMatrix* inverse_matrix) const {
if (NULL == inverse_matrix || this == inverse_matrix) {
return false;
}
if (inverse_matrix->num_dimension_ != num_dimension_) {
inverse_matrix->Resize(num_dimension_);
}
SymmetricMatrix lower_triangular_matrix(num_dimension_);
s... | subq $0x148, %rsp # imm = 0x148
movq %rdi, 0x138(%rsp)
movq %rsi, 0x130(%rsp)
movq 0x138(%rsp), %rax
movq %rax, 0x70(%rsp)
xorl %eax, %eax
cmpq 0x130(%rsp), %rax
je 0x1db5f
movq 0x70(%rsp), %rax
cmpq 0x130(%rsp), %rax
jne 0x1db6c
movb $0x0, 0x147(%rsp)
jmp 0x1e1af
movq 0x70(%rsp), %rcx
movq 0x130(%rsp), %rax... | /sp-nitech[P]SPTK/src/math/symmetric_matrix.cc |
basic_suite::test_empty() | void test_zero()
{
std::vector<output_type> result;
format::oarchive ar(result);
int value = 0;
ar << value;
TRIAL_PROTOCOL_TEST_EQUAL(result.size(), 1);
TRIAL_PROTOCOL_TEST_EQUAL(result[0], 0x00);
} | pushq %rbx
subq $0xc0, %rsp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x30(%rsp), %rdi
callq 0x720e
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
leaq 0x28(%rsp), %r9
movq %rax, (%r9)
leaq 0xc(%rsp), %rax
andl $0x0, (%rax)
movq %rax, (%rsp)
leaq 0xc253(%rip), %rdi # 0x1... | /breese[P]trial/test/bintoken/oarchive_suite.cpp |
basic_suite::test_const_false() | void test_zero()
{
std::vector<output_type> result;
format::oarchive ar(result);
int value = 0;
ar << value;
TRIAL_PROTOCOL_TEST_EQUAL(result.size(), 1);
TRIAL_PROTOCOL_TEST_EQUAL(result[0], 0x00);
} | pushq %rbx
subq $0xd0, %rsp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x40(%rsp), %rdi
callq 0x720e
leaq 0xf(%rsp), %rsi
movb $0x0, (%rsi)
leaq 0x40(%rsp), %rdi
callq 0x8c46
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
leaq 0x30(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x3c(%rsp)... | /breese[P]trial/test/bintoken/oarchive_suite.cpp |
basic_suite::test_const_true() | void test_zero()
{
std::vector<output_type> result;
format::oarchive ar(result);
int value = 0;
ar << value;
TRIAL_PROTOCOL_TEST_EQUAL(result.size(), 1);
TRIAL_PROTOCOL_TEST_EQUAL(result[0], 0x00);
} | pushq %rbx
subq $0xd0, %rsp
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x40(%rsp), %rdi
callq 0x720e
leaq 0xf(%rsp), %rsi
movb $0x1, (%rsi)
leaq 0x40(%rsp), %rdi
callq 0x8c46
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
leaq 0x30(%rsp), %rbx
movq %rax, (%rbx)
leaq 0x3c(%rsp)... | /breese[P]trial/test/bintoken/oarchive_suite.cpp |
ColorFunction::checkCollision(ColorCircle*, ColorCircle*) | bool ColorFunction::checkCollision(ColorCircle* clr1, ColorCircle* clr2){
bool flag_collision = false;
if(clr1->_state()==1 && clr2->_state()==1){
double rho1 = clr1->getRho();
double rho2 = clr2->getRho();
double threshold = rho1 / 5;
if( threshold > rho2 / 5)... | pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
movq -0x8(%rbp), %rdi
callq 0x14a50
cmpl $0x1, %eax
jne 0x12a23
movq -0x10(%rbp), %rdi
callq 0x14a50
cmpl $0x1, %eax
jne 0x12a23
movq -0x8(%rbp), %rdi
movq (%rdi), %rax
xorps %xmm0, %xmm0
callq *(%rax)
movsd ... | /fu-bo[P]AirCombat_RedBlue/src/ColorFunction.cpp |
Colored::setRGB(int, int*) | bool Colored::setRGB(int color, int rgb[]){
bool flag = true;
switch (color) {
case -1:
rgb[0] = 153; rgb[1] = 204; rgb[2] = 255; //blue
break;
case 0:
rgb[0] = 255; rgb[1] = 255; rgb[2] = 255; //white
break;
case 1:
rgb... | pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movb $0x1, -0x19(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $-0x1, %eax
je 0x140ae
jmp 0x14080
movl -0x20(%rbp), %eax
testl %eax, %eax
je 0x140d3
jmp 0x14089
movl -0x20(%rbp), %eax
subl $0x1, %eax
je 0x140f5
jmp 0... | /fu-bo[P]AirCombat_RedBlue/src/Colored.cpp |
FsOpenWindow(FsOpenWindowOption const&) | void FsOpenWindow(const FsOpenWindowOption &opt)
{
int x0=opt.x0;
int y0=opt.y0;
int wid=opt.wid;
int hei=opt.hei;
int useDoubleBuffer=(int)opt.useDoubleBuffer;
// int useMultiSampleBuffer=(int)opt.useMultiSampleBuffer;
const char *title=(NULL!=opt.windowTitle ? opt.windowTitle : "Main Window");
int ... | pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp # imm = 0x190
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movl 0xc(%ra... | /fu-bo[P]AirCombat_RedBlue/fssimplewindow/linux/fssimplewindow.cpp |
FsPushOnPaintEvent() | void FsPushOnPaintEvent(void)
{
XExposeEvent evt;
evt.type=Expose;
evt.serial=0;
evt.send_event=true;
evt.display=ysXDsp;
evt.window=ysXWnd;
evt.x=0;
evt.y=0;
evt.width=ysXWid;
evt.height=ysXHei;
evt.count=0;
XSendEvent(ysXDsp,ysXWnd,true,ExposureMask,(XEvent *)&evt);
} | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0xc, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movl $0x1, -0x30(%rbp)
movq 0x12cc3(%rip), %rax # 0x2c878
movq %rax, -0x28(%rbp)
movq 0x12cd8(%rip), %rax # 0x2c898
movq %rax, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl 0x12cc8(%rip), %eax # 0x2c8a... | /fu-bo[P]AirCombat_RedBlue/fssimplewindow/linux/fssimplewindow.cpp |
FsSubSecondTimer() | long long int FsSubSecondTimer(void)
{
timeval tm;
gettimeofday(&tm,NULL);
long long int sec=tm.tv_sec;
long long int usec=tm.tv_usec;
long long int clk=sec*(long long int)1000+usec/(long long int)1000;
static long long int lastValue=0;
static long long int base=0;
if(clk<lastValue) // Underflo... | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xd630
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
imulq $0x3e8, -0x18(%rbp), %rax # imm = 0x3E8
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl $0x3e8, %ecx ... | /fu-bo[P]AirCombat_RedBlue/fssimplewindow/linux/fssimplewindow.cpp |
FsStringToKeyCode(char const*) | int FsStringToKeyCode(const char str[])
{
if(nullptr==str)
{
return FSKEY_NULL;
}
char upper[256];
for(int i=0; i<255 && 0!=str[i]; ++i)
{
upper[i ]=str[i];
upper[i+1]=0;
if('a'<=upper[i] && upper[i]<='z')
{
upper[i]=upper[i]+'A'-'a';
}
}
for(int i=0; i<FSKEY_NUM_KEYCODE; ++i)
... | pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp # imm = 0x120
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
cmpq -0x10(%rbp), %rax
jne 0x1ad23
movl $0x0, -0x4(%rbp)
jmp 0x1ae60
movl $0x0, -0x114(%rbp)
xorl %eax, %eax
cmpl $0xff, -0x114(%rbp)
movb %al, -0x119(%rbp)
jge 0x1ad5d
movq -0x10(%rbp), %rax
movslq -0x114(%rbp)... | /fu-bo[P]AirCombat_RedBlue/fssimplewindow/linux/fssimplewindow.cpp |
YsSoundPlayer::SoundData::LoadWav(char const*) | YSRESULT YsSoundPlayer::SoundData::LoadWav(const char fn[])
{
FILE *fp;
printf("Loading %s\n",fn);
fp=fopen(fn,"rb");
if(fp!=NULL)
{
auto res=LoadWav(fp);
fclose(fp);
return res;
}
return YSERR;
} | pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rsi
leaq 0x8d03(%rip), %rdi # 0x24756
movb $0x0, %al
callq 0xd060
movq -0x18(%rbp), %rdi
leaq 0x8cfd(%rip), %rsi # 0x24762
callq 0xd450
movq %rax, -0x20(%r... | /fu-bo[P]AirCombat_RedBlue/yssimplesound/yssimplesound.cpp |
YsSoundPlayer::SoundData::LoadWav(YsSoundPlayer::SoundData::BinaryInStream&) | YSRESULT YsSoundPlayer::SoundData::LoadWav(BinaryInStream &inStream)
{
CleanUp();
unsigned char buf[256];
unsigned int l;
unsigned int fSize,hdrSize,dataSize;
// Wave Header
unsigned short wFormatTag,nChannels;
unsigned nSamplesPerSec,nAvgBytesPerSec;
unsigned short nBlockAlign,wBitsPerSample,cbSiz... | pushq %rbp
movq %rsp, %rbp
subq $0x160, %rsp # imm = 0x160
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x150(%rbp)
callq 0x1b730
movq -0x18(%rbp), %rdi
leaq -0x120(%rbp), %rsi
movq (%rdi), %rax
movl $0x4, %edx
callq *(%rax)
cmpq $0x4, %rax
je 0x1bb58
leaq 0x8c20(%rip), %r... | /fu-bo[P]AirCombat_RedBlue/yssimplesound/yssimplesound.cpp |
YsSoundPlayer::SoundData::ConvertTo8Bit() | YSRESULT YsSoundPlayer::SoundData::ConvertTo8Bit(void)
{
if(bit==8)
{
return YSOK;
}
else if(bit==16)
{
unsigned char *newDat=new unsigned char [sizeInBytes/2];
for(int i=0; i<sizeInBytes; i+=2)
{
newDat[i/2]=dat[i];
}
delete [] dat;
dat=newDat;
bit=8;
sizeInBytes/=2;
return... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x8, 0x18(%rax)
jne 0x1c2b6
movl $0x1, -0x4(%rbp)
jmp 0x1c374
movq -0x28(%rbp), %rax
cmpl $0x10, 0x18(%rax)
jne 0x1c36b
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
shrl %eax
movl %eax, %eax
movl %eax,... | /fu-bo[P]AirCombat_RedBlue/yssimplesound/yssimplesound.cpp |
YsSoundPlayer::SoundData::ConvertToStereo() | YSRESULT YsSoundPlayer::SoundData::ConvertToStereo(void)
{
if(stereo==YSTRUE)
{
return YSOK;
}
else
{
if(bit==8)
{
unsigned char *newDat=new unsigned char [sizeInBytes*2];
for(int i=0; i<sizeInBytes; i++)
{
newDat[i*2 ]=dat[i];
newDat[i*2+1]=dat[i];
}
delete [] dat;
... | pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpl $0x1, 0x14(%rax)
jne 0x1c3a6
movl $0x1, -0x4(%rbp)
jmp 0x1c564
movq -0x38(%rbp), %rax
cmpl $0x8, 0x18(%rax)
jne 0x1c467
movq -0x38(%rbp), %rax
movl 0x20(%rax), %eax
shll %eax
movl %eax, %eax
movl %eax, ... | /fu-bo[P]AirCombat_RedBlue/yssimplesound/yssimplesound.cpp |
YsSoundPlayer::SoundData::Resample(int) | YSRESULT YsSoundPlayer::SoundData::Resample(int newRate)
{
if(rate!=newRate)
{
const size_t nChannel=(YSTRUE==stereo ? 2 : 1);
const size_t bytePerSample=bit/8;
const size_t bytePerTimeStep=nChannel*bytePerSample;
const size_t curNTimeStep=sizeInBytes/bytePerTimeStep;
const size_t newNTimeStep=cur... | pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp # imm = 0x130
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x110(%rbp)
movl 0x1c(%rax), %eax
cmpl -0xc(%rbp), %eax
je 0x1cac8
movq -0x110(%rbp), %rcx
movl 0x14(%rcx), %esi
movl $0x1, %eax
movl $0x2, %edx
cmpl %esi, %eax
cmovel %edx... | /fu-bo[P]AirCombat_RedBlue/yssimplesound/yssimplesound.cpp |
cmsys::RegExpCompile::reg(int, int*) | char* RegExpCompile::reg(int paren, int* flagp)
{
char* ret;
char* br;
char* ender;
int parno = 0;
int flags;
*flagp = HASWIDTH; // Tentatively.
// Make an OPEN node, if parenthesized.
if (paren) {
if (regnpar >= RegularExpressionMatch::NSUBEXP) {
// RAISE Error, SYM(RegularExpression), SYM(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movl $0x1, (%rdx)
testl %esi, %esi
je 0xbdc7
movl 0x8(%rbx), %r13d
cmpl $0x9, %r13d
jle 0xbdcf
leaq 0x165b(%rip), %rdi # 0xd41d
jmp 0xbee0
xorl %r13d, %r13d
xorl %r14d, %r14d
jmp 0xbdec
leal... | /micst[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::regnext(char const*) | static const char* regnext(const char* p)
{
int offset;
if (p == regdummyptr)
return (KWSYS_NULLPTR);
offset = NEXT(p);
if (offset == 0)
return (KWSYS_NULLPTR);
if (OP(p) == BACK)
return (p - offset);
else
return (p + offset);
} | leaq 0x75c7(%rip), %rcx # 0x134c8
cmpq %rcx, %rdi
je 0xbf24
movq %rdi, %rax
movzwl 0x1(%rdi), %ecx
rolw $0x8, %cx
testw %cx, %cx
je 0xbf24
movzwl %cx, %ecx
cmpb $0x7, (%rax)
movl %ecx, %ecx
jne 0xbf27
subq %rcx, %rax
retq
xorl %eax, %eax
retq
addq %rcx, %rax
retq
nop
| /micst[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::RegExpCompile::regnode(char) | char* RegExpCompile::regnode(char op)
{
char* ret;
char* ptr;
ret = regcode;
if (ret == regdummyptr) {
regsize += 3;
return (ret);
}
ptr = ret;
*ptr++ = op;
*ptr++ = '\0'; // Null "next" pointer.
*ptr++ = '\0';
regcode = ptr;
return (ret);
} | movq 0x10(%rdi), %rax
leaq 0x7591(%rip), %rcx # 0x134c8
cmpq %rcx, %rax
je 0xbf4d
movb %sil, (%rax)
andw $0x0, 0x1(%rax)
leaq 0x3(%rax), %rcx
movq %rcx, 0x10(%rdi)
retq
addq $0x3, 0x18(%rdi)
retq
nop
| /micst[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::regnext(char*) | static char* regnext(char* p)
{
int offset;
if (p == regdummyptr)
return (KWSYS_NULLPTR);
offset = NEXT(p);
if (offset == 0)
return (KWSYS_NULLPTR);
if (OP(p) == BACK)
return (p - offset);
else
return (p + offset);
} | leaq 0x745b(%rip), %rcx # 0x134c8
cmpq %rcx, %rdi
je 0xc090
movq %rdi, %rax
movzwl 0x1(%rdi), %ecx
rolw $0x8, %cx
testw %cx, %cx
je 0xc090
movzwl %cx, %ecx
cmpb $0x7, (%rax)
movl %ecx, %ecx
jne 0xc093
subq %rcx, %rax
retq
xorl %eax, %eax
retq
addq %rcx, %rax
retq
nop
| /micst[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::RegExpCompile::regpiece(int*) | char* RegExpCompile::regpiece(int* flagp)
{
char* ret;
char op;
char* next;
int flags;
ret = regatom(&flags);
if (ret == KWSYS_NULLPTR)
return (KWSYS_NULLPTR);
op = *regparse;
if (!ISMULT(op)) {
*flagp = flags;
return (ret);
}
if (!(flags & HASWIDTH) && op != '?') {
// RAISE Error... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r15
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
callq 0xc268
testq %rax, %rax
je 0xc256
movq %rax, %rbx
movq (%r14), %rax
movzbl (%rax), %eax
cmpq $0x3f, %rax
ja 0xc158
movabsq $-0x7ffff40000000000, %r12 # imm = 0x80000C0000000000
btq %rax, %r... | /micst[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::RegExpCompile::reginsert(char, char*) | void RegExpCompile::reginsert(char op, char* opnd)
{
char* src;
char* dst;
char* place;
if (regcode == regdummyptr) {
regsize += 3;
return;
}
src = regcode;
regcode += 3;
dst = regcode;
while (src > opnd)
*--dst = *--src;
place = opnd; // Op node, where operand used to be.
*place++ ... | movq 0x10(%rdi), %rax
leaq 0x6ee7(%rip), %rcx # 0x134c8
cmpq %rcx, %rax
je 0xc607
leaq 0x3(%rax), %rcx
movq %rcx, 0x10(%rdi)
cmpq %rdx, %rax
jbe 0xc5fe
movb -0x1(%rax), %cl
movb %cl, 0x2(%rax)
decq %rax
jmp 0xc5ee
movb %sil, (%rdx)
andw $0x0, 0x1(%rdx)
retq
addq $0x3, 0x18(%rdi)
retq
nop
| /micst[P]CMake/Source/kwsys/RegularExpression.cxx |
cmsys::RegExpFind::regmatch(char const*) | int RegExpFind::regmatch(const char* prog)
{
const char* scan; // Current node.
const char* next; // Next node.
scan = prog;
while (scan != KWSYS_NULLPTR) {
next = regnext(scan);
switch (OP(scan)) {
case BOL:
if (reginput != regbol)
return (0);
break;
case EOL:
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbp
movq (%rdi), %r15
movq 0x8(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0xa93(%rip), %rbx # 0xd28c
movq %rdi, 0x8(%rsp)
testq %r14, %r14
je 0xc90c
movq %r14, %r12
movq %r14, %rdi
callq 0xbefa
movzbl (%r14)... | /micst[P]CMake/Source/kwsys/RegularExpression.cxx |
ACTable::build(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int, int) | LTFlightData* ACTable::build (const std::string& _filter, int _x, int _y)
{
// return value: the just selected aircraft, if any
LTFlightData* pSelFD = nullptr;
// Determine size, basis is the available content region
ImVec2 tblSize = ImGui::GetContentRegionAvail();
if (_x <= 0) tblSize.x += flo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %rbx
movq %rdi, %r14
callq 0x10d9d1
movd %ebp, %xmm1
movd %r15d, %xmm2
punpckldq %xmm1, %xmm2 # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
pxor %xmm1, %xmm1
movdqa %xmm2, %xmm3
cvtdq2ps %xmm2, %... | /TwinFan[P]LiveTraffic/Src/ACTable.cpp |
InfoListWnd::~InfoListWnd() | InfoListWnd::~InfoListWnd()
{
// save state
gIlwState.activeTab = activeTab;
gIlwState.bFilterAcOnly = acList.bFilterAcOnly;
strncpy(gIlwState.sAcFilter, sAcFilter, sizeof(gIlwState.sAcFilter));
gIlwState.msgLvlFilter = msgLvlFilter;
strncpy(gIlwState.sMsgFilter, sMsgFilter, sizeof(gIlwState.sMs... | pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x19bb2f(%rip), %rax # 0x1dded0
movq %rax, (%rdi)
movl 0x158(%rdi), %eax
movl %eax, 0x1a0220(%rip) # 0x1e25d0
movb 0x180(%rdi), %al
movb %al, 0x1a0218(%rip) # 0x1e25d4
leaq 0x1d0(%rdi), %rsi
leaq 0x1a020b(%rip), %rdi # 0x1e25d5
movl $0x32, %edx
callq 0x... | /TwinFan[P]LiveTraffic/Src/InfoListWnd.cpp |
InfoListWnd::ToggleDisplay(int) | bool InfoListWnd::ToggleDisplay (int _force)
{
// If we toggle then do what current is not the state
if (!_force)
_force = InfoListWnd::IsDisplayed() ? -1 : 1;
// Open the window?
if (_force > 0)
{
// Create the object and window if needed
if (!gpILW)
gpILW =... | pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
testl %edi, %edi
jne 0x43f3a
movq 0x1a1fb7(%rip), %rdi # 0x1e5ed8
testq %rdi, %rdi
je 0x43f35
callq 0x11c0c4
movzbl %al, %ebx
negl %ebx
orl $0x1, %ebx
jmp 0x43f3a
movl $0x1, %ebx
movq 0x1a1f97(%rip), %rdi # 0x1e5ed8
testl %ebx, %ebx
jle 0x43f92
testq %rdi, %rdi
jne... | /TwinFan[P]LiveTraffic/Src/InfoListWnd.cpp |
ADSBBase::FetchMsg[abi:cxx11](char const*) | std::string ADSBBase::FetchMsg (const char* buf)
{
// try to interpret it as JSON, then fetch 'msg' field content
JSONRootPtr pRoot (buf);
if (!pRoot) return std::string();
const JSON_Object* pObj = json_object(pRoot.get());
if (!pObj) return std::string();
const std::string s = jog_s(pObj, ADSB... | pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %r14
movq %rsi, %rdi
callq 0xc0463
movq %rax, %rbx
testq %rax, %rax
je 0x46ecc
movq %rbx, %rdi
callq 0xc39dd
movq %rax, %r15
testq %rax, %rax
je 0x46ecc
leaq 0x107c09(%rip), %rsi # 0x14ea98
movq %r15, %rdi
callq 0x66a30
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp)... | /TwinFan[P]LiveTraffic/Src/LTADSBEx.cpp |
ADSBExchangeConnection::MakeCurlSList(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) | struct curl_slist* ADSBExchangeConnection::MakeCurlSList (const std::string theKey)
{
struct curl_slist* slist = curl_slist_append(NULL, ADSBEX_RAPIDAPI_HOST);
return curl_slist_append(slist, (std::string(ADSBEX_RAPIDAPI_KEY)+theKey).c_str());
} | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x106236(%rip), %rsi # 0x14eedf
xorl %edi, %edi
callq 0x151b0
movq %rax, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x10624d(%rip), %rsi # 0x14ef11
leaq 0x106256(%rip), %rdx # 0x14ef21
leaq 0x28(%rsp), %r15
movq %r15,... | /TwinFan[P]LiveTraffic/Src/LTADSBEx.cpp |
ADSBHubConnection::Stop(bool) | void ADSBHubConnection::Stop (bool bWaitJoin)
{
if (isRunning()) {
if (eThrStatus < THR_STOP)
eThrStatus = THR_STOP; // indicate to the thread that it has to end itself
#if APL == 1 || LIN == 1
// Mac/Lin: Try writing something to the self-pipe to stop gracefully
... | pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
cmpq $0x0, 0x78(%rdi)
je 0x4ae53
movl 0x88(%rbx), %eax
cmpl $0x2, %eax
jg 0x4ae26
movl $0x3, 0x88(%rbx)
movl 0x24c(%rbx), %edi
cmpl $-0x1, %edi
je 0x4ae47
leaq 0x10490b(%rip), %rsi # 0x14f743
movl $0x4, %edx
callq 0x144b0
testq %rax, %rax
jns 0x4ae53
l... | /TwinFan[P]LiveTraffic/Src/LTADSBHub.cpp |
BezierCurve::Define(positionTy const&, positionTy const&, positionTy const&) | void BezierCurve::Define (const positionTy& _start,
const positionTy& _mid,
const positionTy& _end)
{
// init
start = _start;
ptCtrl = _mid;
end = _end;
#ifdef DEBUG
if (gSelAcCalc)
LOG_MSG(logDEBUG, "Quadratic Bezier defined:\n... | movq %rcx, %rax
movq %rdi, %r8
movl $0x9, %ecx
rep movsq (%rsi), %es:(%rdi)
movups (%rdx), %xmm0
shufps $0x4e, %xmm0, %xmm0 # xmm0 = xmm0[2,3,0,1]
movups %xmm0, 0x90(%r8)
leaq 0x48(%r8), %rdi
movl $0x9, %ecx
movq %rax, %rsi
rep movsq (%rsi), %es:(%rdi)
movq %r8, %rdi
jmp 0x4f038
| /TwinFan[P]LiveTraffic/Src/LTAircraft.cpp |
LTAircraft::CopyBulkData(LTAPIAircraft::LTAPIBulkInfoTexts*, unsigned long) const | void LTAircraft::CopyBulkData (LTAPIAircraft::LTAPIBulkInfoTexts* pOut,
size_t size) const
{
// If size isn't enough for original structure we bail:
if (size < LTAPIBulkInfoTexts_v120)
return;
// Fill the output buffer one by one
const LTFlightData::FDStaticDa... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x408, %rsp # imm = 0x408
cmpq $0x108, %rdx # imm = 0x108
jb 0x57730
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x348(%rdi), %rsi
leaq 0x228(%rsp), %rdi
callq 0x7558c
movq 0x348(%r14), %rsi
leaq 0x3c0(%rsp), %rdi
mov... | /TwinFan[P]LiveTraffic/Src/LTAircraft.cpp |
LTAircraft::SetVisible(bool) | void LTAircraft::SetVisible (bool b)
{
bAutoVisible = false;
bSetVisible = b;
if (b != IsVisible()) // is new visibility a change?
{
XPMP2::Aircraft::SetVisible(b);
LOG_MSG(logINFO, IsVisible() ? INFO_AC_SHOWN : INFO_AC_HIDDEN,
labelInternal.c_str());
}
} | pushq %rbx
movb $0x0, 0x8e3(%rdi)
movb %sil, 0x8e2(%rdi)
movb 0x1f0(%rdi), %al
andb 0x1f1(%rdi), %al
cmpb %sil, %al
je 0x57a0b
movq %rdi, %rbx
movzbl %sil, %esi
callq 0x1242a4
leaq 0x18e533(%rip), %rax # 0x1e5ef0
cmpl $0x1, 0x62c(%rax)
jg 0x57a0b
movb 0x1f0(%rbx), %al
leaq 0xf9095(%rip), %rcx # 0x150a68
leaq 0xf... | /TwinFan[P]LiveTraffic/Src/LTAircraft.cpp |
LTChannel::_Main() | void LTChannel::_Main()
{
eThrStatus = THR_RUNNING;
LOG_MSG(logDEBUG, "%s: Thread starts", pszChName);
Main();
LOG_MSG(logDEBUG, "%s: Thread ends", pszChName);
eThrStatus = THR_ENDED;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x2, 0x88(%rdi)
leaq 0x17f170(%rip), %r14 # 0x1e5ef0
cmpl $0x0, 0x62c(%r14)
jg 0x66db1
movq 0x68(%rbx), %r9
leaq 0xea92f(%rip), %rdi # 0x1516c4
leaq 0xea982(%rip), %rdx # 0x15171e
leaq 0xea981(%rip), %r8 # 0x151724
movl $0xcc, %esi
xorl %ecx, %ecx
x... | /TwinFan[P]LiveTraffic/Src/LTChannel.cpp |
LTChannel::Stop(bool) | int LTFlightDataChannel::GetNumAcServed () const
{
// only try to re-count every second, and needs the mapFd lock
if (timeLastAcCnt + 1.0f < dataRefs.GetMiscNetwTime()) {
std::unique_lock<std::mutex> lockFd(mapFdMutex, std::try_to_lock);
if (lockFd) {
timeLastAcCnt = dataRefs.GetMisc... | pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x78(%rdi)
je 0x66e4a
movq %rdi, %rbx
movl 0x88(%rdi), %eax
cmpl $0x2, %eax
jg 0x66e21
movl $0x3, 0x88(%rbx)
testb %sil, %sil
je 0x66e4a
leaq 0x78(%rbx), %r14
movq %r14, %rdi
callq 0x15bf8
cmpq $0x0, (%r14)
jne 0x66e52
movq $0x0, 0x78(%rbx)
movl $0x0, 0x88(%rbx)
addq $0x8, %r... | /TwinFan[P]LiveTraffic/Src/LTChannel.cpp |
LTFlightDataHideAircraft() | int LTFlightDataChannel::GetNumAcServed () const
{
// only try to re-count every second, and needs the mapFd lock
if (timeLastAcCnt + 1.0f < dataRefs.GetMiscNetwTime()) {
std::unique_lock<std::mutex> lockFd(mapFdMutex, std::try_to_lock);
if (lockFd) {
timeLastAcCnt = dataRefs.GetMisc... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpq $0x0, 0x17db76(%rip) # 0x1e7060
je 0x69550
movb $0x1, 0x179235(%rip) # 0x1e2728
leaq 0x17db96(%rip), %rdi # 0x1e7090
callq 0x15890
movq 0x17dbba(%rip), %rbx # 0x1e70c0
leaq 0x17dbb3(%rip), %r14 # 0x1e70c0
cmpq %r14, %rbx
je 0x6952b
movq 0x10(%rbx), %... | /TwinFan[P]LiveTraffic/Src/LTChannel.cpp |
LTFlightData::TryDeriveGrndStatus(positionTy&) | bool LTFlightData::TryDeriveGrndStatus (positionTy& pos)
{
try {
std::unique_lock<std::recursive_mutex> lock (dataAccessMutex, std::try_to_lock );
if ( lock )
{
// what's the terrain altitude at that pos?
double terrainAlt = YProbe_at_m(pos);
if (std::isna... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %r15
addq $0x378, %rdi # imm = 0x378
movq %rdi, 0x20(%rsp)
callq 0x141a0
movl %eax, %ebx
testl %eax, %eax
sete 0x28(%rsp)
jne 0x73d59
leaq 0x368(%r15), %rsi
movq %r14, %rdi
callq 0x28030
ucomisd %xmm0, %xmm0
setnp %bpl
jp... | /TwinFan[P]LiveTraffic/Src/LTFlightData.cpp |
LTFlightData::AircraftMaintenance(double) | bool LTFlightData::AircraftMaintenance ( double simTime )
{
try {
// try to lock data access
std::unique_lock<std::recursive_mutex> lock (dataAccessMutex, std::try_to_lock);
if ( !lock ) // we didn't get the lock, just return w/o deletion
return false;
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movapd %xmm0, 0x10(%rsp)
movq %rdi, %rbx
addq $0x378, %rdi # imm = 0x378
movq %rdi, 0x28(%rsp)
callq 0x141a0
testl %eax, %eax
sete 0x30(%rsp)
je 0x756bc
xorl %ebp, %ebp
jmp 0x7577f
leaq 0x17082d(%rip), %r12 # 0x1e5ef0
movl ... | /TwinFan[P]LiveTraffic/Src/LTFlightData.cpp |
ImGui::FilteredCfgNumber(char const*, char const*, dataRefsLT, int, int, int, char const*) | IMGUI_API bool FilteredCfgNumber(const char* label, const char* filter, dataRefsLT idx,
int v_min, int v_max, int v_step, const char* format)
{
// Draw label first
if (!FilteredLabel(label, filter))
return false;
// Next cell: Draw the checkbox with a value linked t... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %r12
movl $0x1, %edx
callq 0x82305
testb %al, %al
je 0x8263f
movq 0x40(%rsp), %r13
movq %r12, %rdi
callq 0x1104de
leaq 0xceaf9(%rip), %rdi # 0x151115
movl %r15d, ... | /TwinFan[P]LiveTraffic/Src/LTImgWindow.cpp |
ImGui::Indicator(bool, char const*, char const*) | IMGUI_API void Indicator (bool bOK, const char* okText, const char* nokText)
{
// right-aligned
ImGui::SetCursorPosX(ImGui::GetContentRegionMax().x - ImGui::GetWidthIconBtn());
// for the active line decide based on temporary check
ImGui::TextUnformatted(bOK ? ICON_FA_CHECK_CIRCLE : ICON_FA_EXCLAMATION_... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movl %edi, %ebp
callq 0x11163e
movaps %xmm0, %xmm1
movss 0x15fe87(%rip), %xmm0 # 0x1e27cc
ucomiss %xmm0, %xmm0
jp 0x8295d
movl 0x15fe78(%rip), %eax # 0x1e27c8
leal -0x1(%rax), %ecx
movl %ecx, 0x15fe6f(%rip) # 0x1e27c8
testl %eax, ... | /TwinFan[P]LiveTraffic/Src/LTImgWindow.cpp |
safeGetline(std::istream&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) | std::istream& safeGetline(std::istream& is, std::string& t)
{
// read a line until LF
std::getline(is, t, '\n');
// if last character is CR then remove it
if (!t.empty() && t.back() == '\r')
t.pop_back();
return is;
} | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movl $0xa, %edx
callq 0x15a10
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x83ed2
movq (%r14), %rcx
cmpb $0xd, -0x1(%rcx,%rax)
jne 0x83ed2
movq %r14, %rdi
callq 0x15100
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
| /TwinFan[P]LiveTraffic/Src/LTMain.cpp |
str_concat(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::string str_concat (const std::vector<std::string>& vs, const std::string& separator)
{
// empty? return empty string
if (vs.empty()) return "";
// put together the return string, start with the first element
std::string s = vs.front();
for (auto iter = std::next(vs.begin()); iter != vs.end... | pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
leaq 0x10(%rdi), %r12
cmpq 0x8(%rsi), %rax
movq %r12, (%rdi)
je 0x8535c
movq %rdx, %r14
movq %rsi, %r15
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x225a8
movq (%r15), %r13
addq $0x20, %r13
cmpq 0x... | /TwinFan[P]LiveTraffic/Src/LTMain.cpp |
LoopCBAircraftMaintenance(float, float, int, void*) | float LoopCBAircraftMaintenance (float inElapsedSinceLastCall, float, int, void*)
{
static float elapsedSinceLastAcMaint = 0.0f;
do {
// *** check for new positons that require terrain altitude (Y Probes) ***
// LiveTraffic Top Level Exception handling: catch all, reinit if something happens
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movss %xmm0, 0x14(%rsp)
movss 0xc948f(%rip), %xmm0 # 0x14fd24
movss %xmm0, 0x4(%rsp)
leaq 0x15f64e(%rip), %rbx # 0x1e5ef0
leaq 0xef9df(%rip), %r14 # 0x176288
leaq 0xefea1(%rip), %r15 # 0x176751
leaq 0xefeb4(%rip), %r12 ... | /TwinFan[P]LiveTraffic/Src/LTMain.cpp |
RealTrafficConnection::GetStatusStr[abi:cxx11]() const | std::string RealTrafficConnection::GetStatusStr() const
{
switch (status) {
case RT_STATUS_NONE: return "";
case RT_STATUS_STARTING: return "Waiting for RealTraffic...";
case RT_STATUS_CONNECTED_PASSIVELY: return "Connected passively";
case RT_STATUS_CONNECT... | pushq %rbx
movq %rdi, %rbx
movl 0x214(%rsi), %eax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
cmpq $0x5, %rax
ja 0x9366d
leaq 0xe44c0(%rip), %rcx # 0x177b24
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xbdaa1(%rip), %rdx # 0x151115
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x936cd
leaq 0xe5268(%rip), %rsi ... | /TwinFan[P]LiveTraffic/Src/LTRealTraffic.cpp |
RealTrafficConnection::tcpConnection() | void RealTrafficConnection::tcpConnection ()
{
// This is a communication thread's main function, set thread's name and C locale
ThreadSettings TS ("LT_RT_TCP", LC_ALL_MASK);
eTcpThrStatus = THR_RUNNING;
// port to use is configurable
int tcpPort = DataRefs::GetCfgInt(DR_CFG_RT_LISTEN_PORT);
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0xdf53f(%rip), %rsi # 0x178907
leaq 0xf7dae(%rip), %rcx # 0x19117d
leaq 0x28(%rsp), %rdi
movl $0x1fbf, %edx # imm = 0x1FBF
callq 0xbfcf8
movl $0x2, 0x7d8(%rbx)
movl $0x57, %edi
callq 0x3145c
movl %e... | /TwinFan[P]LiveTraffic/Src/LTRealTraffic.cpp |
LTWeather::Log(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const | void LTWeather::Log (const std::string& msg) const
{
std::ostringstream lOut;
lOut << std::fixed << std::setprecision(1);
lOut << "pos: " << std::string(pos) << "\n";
lOut << "vis: " << visibility_reported_sm << "sm, ";
lOut << "sea_pressure: "<< sealevel_pressure_... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp # imm = 0x1A8
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rsp), %r15
movq %r15, %rdi
callq 0x15310
movq (%r15), %rax
movq -0x18(%rax), %rcx
movl $0xfffffefb, %edx # imm = 0xFFFFFEFB
andl 0x48(%rsp,%rcx), %edx
orl $0x4, %... | /TwinFan[P]LiveTraffic/Src/LTWeather.cpp |
WeatherQNHfromMETAR(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | float WeatherQNHfromMETAR (const std::string& metar)
{
// --- Parse ---
const ParseResult& r = ParseMETAR(metar);
if (r.reportMetadata.error == ReportError::NONE) {
// Find the pressure group
for (const GroupInfo& gi: r.groups)
if (const PressureGroup *pPg = std::get_if<Pr... | pushq %rax
callq 0xa16f9
cmpl $0x0, 0x1440bc(%rip) # 0x1e7f04
jne 0xa3ede
movq 0x14412b(%rip), %rcx # 0x1e7f80
movq 0x14412c(%rip), %rdx # 0x1e7f88
cmpq %rdx, %rcx
sete %al
je 0xa3eda
movss 0xa5d14(%rip), %xmm1 # 0x149b80
movsd 0xd528c(%rip), %xmm2 # 0x179100
movsd 0xd528c(%rip), %xmm3 # 0x179108
test... | /TwinFan[P]LiveTraffic/Src/LTWeather.cpp |
metaf::fractionStrToUint(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long, unsigned long) | std::optional<std::pair<unsigned int, unsigned int> >
fractionStrToUint(const std::string & str,
std::size_t startPos,
std::size_t length)
{
//Equivalent regex "(\\d\\d?)/(\\d\\d?)"
std::optional<std::pair<unsigned int, unsigned int> > error;
if (length + startPos > str.length()) length = str.length() - startPo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq (%rdx,%rsi), %rax
movq 0x8(%rdi), %rcx
movq %rcx, %r15
subq %rsi, %r15
cmpq %rcx, %rax
cmovbeq %rdx, %r15
movl $0x2f, %esi
movq %r14, %rdx
callq 0x15280
cmpq $-0x1, %rax
je 0xa95b5
movq %rax, %r9
subq %r14, %r9
sete %cl
cmpq $0x... | /TwinFan[P]LiveTraffic/Lib/metaf/include/metaf.hpp |
metaf::Direction::fromCardinalString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool, bool) | TrendGroup() = default; | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x8(%rdi)
je 0xa9806
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %r14
leaq 0xd0b4b(%rip), %rsi # 0x17a20e
callq 0x14340
movb $0x1, %bl
testl %eax, %eax
je 0xa980a
testb %r15b, %r15b
je 0xa970a
leaq 0xd0b34(%rip), %rsi # 0x17a212
movq %r14, %rdi
c... | /TwinFan[P]LiveTraffic/Lib/metaf/include/metaf.hpp |
metaf::WeatherGroup::append(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, metaf::ReportPart, metaf::ReportMetadata const&) | AppendResult WeatherGroup::append(const std::string & group,
ReportPart reportPart,
const ReportMetadata & reportMetadata)
{
(void)reportMetadata;
switch (incompleteText) {
case IncompleteText::NONE:
break;
case IncompleteText::WX:
if (group != "MISG") return AppendResult::GROUP_INVALIDATED;
incompleteTe... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl 0x1f0(%rdi), %eax
cmpl $0x3, %eax
je 0xaa492
cmpl $0x2, %eax
je 0xaa468
cmpl $0x1, %eax
jne 0xaa4c1
leaq 0xcfd58(%rip), %rsi # 0x17a1be
jmp 0xaa499
leaq 0xcfce9(%rip), %rsi # 0x17a158
movq %r14, %rdi
cal... | /TwinFan[P]LiveTraffic/Lib/metaf/include/metaf.hpp |
metaf::LightningGroup::fromLtgGroup(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::optional<LightningGroup> LightningGroup::fromLtgGroup(const std::string & group) {
std::optional<LightningGroup> notRecognised;
static const auto ltgLen = 3u; // length of string LTG
static const char ltg[ltgLen + 1] = "LTG";
LightningGroup result;
if (group == ltg) return (result);
if (group.length() < lt... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xcdd8a(%rip), %rsi # 0x17a94d
movq %r14, %rdi
callq 0x14340
testl %eax, %eax
je 0xacc23
cmpq $0x3, 0x8(%r14)
jb 0xacc1c
leaq 0x28(%rsp), %r15
movl $0x3, %ecx
movq %r15, %rdi
movq %r14, %rsi
xorl ... | /TwinFan[P]LiveTraffic/Lib/metaf/include/metaf.hpp |
metaf::RunwayStateGroup::depositsFromString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) | std::optional<RunwayStateGroup::Deposits> RunwayStateGroup::depositsFromString(
const std::string & s)
{
std::optional<Deposits> error;
if (s.length() != 1) return error;
switch (s[0]) {
case '0': return Deposits::CLEAR_AND_DRY;
case '1': return Deposits::DAMP;
case '2': return Deposits::WET_AND_WATER_PATCHES... | cmpq $0x1, 0x8(%rdi)
jne 0xb25b6
movq (%rdi), %rax
movb (%rax), %al
addb $-0x2f, %al
cmpb $0xa, %al
ja 0xb25b6
movzbl %al, %eax
leaq 0xc8722(%rip), %rcx # 0x17acc8
movq (%rcx,%rax,8), %rax
movabsq $0x100000000, %rcx # imm = 0x100000000
jmp 0xb25ba
xorl %eax, %eax
xorl %ecx, %ecx
orq %rcx, %rax
retq
| /TwinFan[P]LiveTraffic/Lib/metaf/include/metaf.hpp |
std::variant<metaf::KeywordGroup, metaf::LocationGroup, metaf::ReportTimeGroup, metaf::TrendGroup, metaf::WindGroup, metaf::VisibilityGroup, metaf::CloudGroup, metaf::WeatherGroup, metaf::TemperatureGroup, metaf::PressureGroup, metaf::RunwayStateGroup, metaf::SeaSurfaceGroup, metaf::MinMaxTemperatureGroup, metaf::Preci... | static Group parseAlternative(const std::string & group,
ReportPart reportPart,
const ReportMetadata & reportMetadata)
{
using Alternative = std::variant_alternative_t<I, Group>;
if constexpr (!std::is_same<Alternative, FallbackGroup>::value) {
const auto parsed = Alternative::parse(group, reportPart, repor... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rcx, %r14
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4(%rsp), %r12
movq %r12, %rdi
callq 0xb1d12
cmpb $0x1, 0x28(%r12)
jne 0xb5cdf
movq 0x24(%rsp), %rax
movq %rax, 0x20(%rbx)
movups 0x4(%rsp), %xmm0
movups 0x14(%rsp), %xmm1
movups... | /TwinFan[P]LiveTraffic/Lib/metaf/include/metaf.hpp |
CreateMsgWindow(float, int, int, int) | void CreateMsgWindow(float fTimeToDisplay, int numSee, int numShow, int bufTime)
{
// This entry shall always be the first one in the list
// So let's see if it is already the first one, then we'd remove it first
std::unique_lock<std::recursive_mutex> lock(gListMutex);
if (!listTexts.empty() && listText... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp # imm = 0x248
movl %edx, %ebx
movl %esi, %ebp
movl %edi, %r14d
movaps %xmm0, 0x20(%rsp)
leaq 0x1242be(%rip), %rax # 0x1e28a0
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
movb $0x0, 0x8(%r15)
movq %r15, %rdi
callq 0x41fc4
movb $... | /TwinFan[P]LiveTraffic/Src/TextIO.cpp |
AddLogMsg(char const*, int, char const*, logLevelTy, char const*, __va_list_tag*) | LogMsgListTy::iterator AddLogMsg (const char* szPath, int ln, const char* szFunc,
logLevelTy lvl, const char* szMsg, va_list args)
{
// We get the lock already to avoid having to lock twice if in main thread
std::lock_guard<std::recursive_mutex> lock(gLogMutex);
// Cut... | pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %r9, %r14
movq %r8, %rbx
movq %rdi, %r15
movl %esi, 0x4(%rsp)
movq %rdx, 0x10(%rsp)
movl %ecx, (%rsp)
leaq 0x123e99(%rip), %rdi # 0x1e28c8
callq 0x15510
testl %eax, %eax
jne 0xbeaf4
movq %r15, %rdi
movl $0x2f, %esi
callq 0x14f60
leaq 0x1(%rax), %rcx
testq %rax, ... | /TwinFan[P]LiveTraffic/Src/TextIO.cpp |
json_array_replace_value | JSON_Status json_array_replace_value(JSON_Array *array, size_t ix, JSON_Value *value) {
if (array == NULL || value == NULL || value->parent != NULL || ix >= json_array_get_count(array)) {
return JSONFailure;
}
json_value_free(json_array_get_value(array, ix));
value->parent = json_array_get_wrapp... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
sete %al
testq %rdx, %rdx
sete %cl
orb %al, %cl
movl $0xffffffff, %r14d # imm = 0xFFFFFFFF
jne 0xc24a6
movq %rdx, %rbx
cmpq $0x0, (%rdx)
jne 0xc24a6
movq %rsi, %r15
movq %rdi, %r12
cmpq %rsi, 0x10(%rdi)
jbe 0xc24a6
xorl %r14d, %r14d
cmpq %r15,... | /TwinFan[P]LiveTraffic/Lib/parson/parson.c |
ImDrawList::AddRectFilled(ImVec2 const&, ImVec2 const&, unsigned int, float, int) | void ImDrawList::AddRectFilled(const ImVec2& p_min, const ImVec2& p_max, ImU32 col, float rounding, ImDrawCornerFlags rounding_corners)
{
if ((col & IM_COL32_A_MASK) == 0)
return;
if (rounding > 0.0f)
{
PathRect(p_min, p_max, rounding, rounding_corners);
PathFillConvex(col);
}
... | pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x1000000, %ecx # imm = 0x1000000
jb 0xc805c
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jbe 0xc8068
movq %r12, %rsi
movq %r15, %rdx
movl %r8d, %ecx
callq 0xc793e
movq 0x88(%r14), %rsi
movl 0x... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_draw.cpp |
stbtt_FindGlyphIndex(stbtt_fontinfo const*, int) | STBTT_DEF int stbtt_FindGlyphIndex(const stbtt_fontinfo *info, int unicode_codepoint)
{
stbtt_uint8 *data = info->data;
stbtt_uint32 index_map = info->index_map;
stbtt_uint16 format = ttUSHORT(data + index_map + 0);
if (format == 0) { // apple byte encoding
stbtt_int32 bytes = ttUSHORT(data + index_m... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq 0x8(%rdi), %r15
movl 0x34(%rdi), %r12d
leaq (%r15,%r12), %r14
movzwl (%r15,%r12), %eax
rolw $0x8, %ax
cmpw $0x6, %ax
ja 0xd0108
movzwl %ax, %ecx
leaq 0xae55f(%rip), %rdx # 0x17e5c0
movslq (%rdx,%rcx,4), %rcx
addq %rdx,... | /TwinFan[P]LiveTraffic/Lib/ImGui/imstb_truetype.h |
ImFontAtlasBuildSetupFont(ImFontAtlas*, ImFont*, ImFontConfig*, float, float) | void ImFontAtlasBuildSetupFont(ImFontAtlas* atlas, ImFont* font, ImFontConfig* font_config, float ascent, float descent)
{
if (!font_config->MergeMode)
{
font->ClearOutputData();
font->FontSize = font_config->SizePixels;
font->ConfigData = font_config;
font->ContainerAtlas = atla... | pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
cmpb $0x0, 0x48(%rdx)
jne 0xd0f16
movq %rdx, %r14
movq %rdi, %r15
movq %rbx, %rdi
movss %xmm1, 0xc(%rsp)
movss %xmm0, 0x8(%rsp)
callq 0xd172c
movss 0x14(%r14), %xmm0
movss %xmm0, 0x14(%rbx)
movq %r14, 0x50(%rbx)
movq %r15, 0x48(%rbx)
movss 0x8(%rsp), %xm... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_draw.cpp |
ImFontAtlasBuildRender1bppRectFromString(ImFontAtlas*, int, int, int, int, char const*, char, unsigned char) | void ImFontAtlasBuildRender1bppRectFromString(ImFontAtlas* atlas, int x, int y, int w, int h, const char* in_str, char in_marker_char, unsigned char in_marker_pixel_value)
{
IM_ASSERT(x >= 0 && x + w <= atlas->TexWidth);
IM_ASSERT(y >= 0 && y + h <= atlas->TexHeight);
unsigned char* out_pixel = atlas->TexPi... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movl %r8d, %r14d
movl %ecx, %r15d
movl %edx, %r13d
movl %esi, %ebp
movq %rdi, %r12
testl %esi, %esi
js 0xd17d1
leal (%r15,%rbp), %eax
cmpl 0x28(%r12), %eax
jle 0xd17f9
leaq 0xb2d45(%rip), %rdi # 0x18451d
leaq 0xb33f0(%rip), ... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_draw.cpp |
ImFontAtlas::GetGlyphRangesChineseSimplifiedCommon() | const ImWchar* ImFontAtlas::GetGlyphRangesChineseSimplifiedCommon()
{
// Store 2500 regularly used characters for Simplified Chinese.
// Sourced from https://zh.wiktionary.org/wiki/%E9%99%84%E5%BD%95:%E7%8E%B0%E4%BB%A3%E6%B1%89%E8%AF%AD%E5%B8%B8%E7%94%A8%E5%AD%97%E8%A1%A8
// This table covers 97.97% of all... | cmpw $0x0, 0x118390(%rip) # 0x1ea1e0
jne 0xd1ea2
movaps 0xadcd7(%rip), %xmm0 # 0x17fb30
movaps %xmm0, 0x118380(%rip) # 0x1ea1e0
movl $0xffefff00, 0x118386(%rip) # imm = 0xFFEFFF00
movl $0x4e00, %ecx # imm = 0x4E00
xorl %eax, %eax
leaq 0x118368(%rip), %rdx # 0x1ea1e0
leaq 0xac921(%rip), %rsi # 0... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_draw.cpp |
ImFontGlyphRangesBuilder::BuildRanges(ImVector<unsigned short>*) | void ImFontGlyphRangesBuilder::BuildRanges(ImVector<ImWchar>* out_ranges)
{
const int max_codepoint = IM_UNICODE_CODEPOINT_MAX;
for (int n = 0; n <= max_codepoint; n++)
if (GetBit(n))
{
out_ranges->push_back((ImWchar)n);
while (n < max_codepoint && GetBit(n + 1))
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xb3436(%rip), %rbp # 0x1854b4
xorl %r15d, %r15d
movl %r15d, %eax
sarl $0x5, %eax
cmpl %eax, (%r14)
jg 0xd20b0
leaq 0xb2ce8(%rip), %rdi # 0x184d7b
movl $0x605, %esi # imm = 0x605
leaq 0xb... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_draw.cpp |
ImFont::SetGlyphVisible(unsigned short, bool) | const ImFontGlyph* ImFont::FindGlyph(ImWchar c) const
{
if (c >= (size_t)IndexLookup.Size)
return FallbackGlyph;
const ImWchar i = IndexLookup.Data[c];
if (i == (ImWchar)-1)
return FallbackGlyph;
return &Glyphs.Data[i];
} | movl %esi, %eax
movslq 0x18(%rdi), %rcx
cmpq %rcx, %rax
jae 0xd24d5
movq 0x20(%rdi), %rcx
movzwl (%rcx,%rax,2), %eax
cmpq $0xffff, %rax # imm = 0xFFFF
jne 0xd24db
movq 0x38(%rdi), %rax
jmp 0xd24e6
leaq (%rax,%rax,4), %rax
shll $0x3, %eax
addq 0x30(%rdi), %rax
testq %rax, %rax
je 0xd24fc
movzbl %dl, %ecx
shll ... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_draw.cpp |
ImFont::AddRemapChar(unsigned short, unsigned short, bool) | void ImFont::AddRemapChar(ImWchar dst, ImWchar src, bool overwrite_dst)
{
IM_ASSERT(IndexLookup.Size > 0); // Currently this can only be called AFTER the font has been built, aka after calling ImFontAtlas::GetTexDataAs*() function.
unsigned int index_size = (unsigned int)IndexLookup.Size;
if (dst < inde... | pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl %ecx, %r14d
movl %edx, %ebp
movl %esi, %r15d
movq %rdi, %rbx
cmpl $0x0, 0x18(%rdi)
jg 0xd2591
leaq 0xb1fad(%rip), %rdi # 0x18451d
leaq 0xb2776(%rip), %rdx # 0x184ced
leaq 0xb200b(%rip), %rcx # 0x184589
leaq 0xb2775(%rip), %r8 ... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_draw.cpp |
ImGui::RenderRectFilledRangeH(ImDrawList*, ImRect const&, unsigned int, float, float, float) | void ImGui::RenderRectFilledRangeH(ImDrawList* draw_list, const ImRect& rect, ImU32 col, float x_start_norm, float x_end_norm, float rounding)
{
if (x_end_norm == x_start_norm)
return;
if (x_start_norm > x_end_norm)
ImSwap(x_start_norm, x_end_norm);
ImVec2 p0 = ImVec2(ImLerp(rect.Min.x, rec... | ucomiss %xmm0, %xmm1
jne 0xd33c4
jp 0xd33c4
retq
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movaps %xmm0, %xmm5
maxss %xmm1, %xmm5
minss %xmm0, %xmm1
movss (%rsi), %xmm0
movss 0x4(%rsi), %xmm7
movss 0x8(%rsi), %xmm8
subss %xmm0, %xm... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_draw.cpp |
stbtt__find_table(unsigned char*, unsigned int, char const*) | static stbtt_uint32 stbtt__find_table(stbtt_uint8 *data, stbtt_uint32 fontstart, const char *tag)
{
stbtt_int32 num_tables = ttUSHORT(data+fontstart+4);
stbtt_uint32 tabledir = fontstart + 12;
stbtt_int32 i;
for (i=0; i < num_tables; ++i) {
stbtt_uint32 loc = tabledir + 16*i;
if (stbtt_tag(data+... | movl %esi, %eax
movzwl 0x4(%rdi,%rax), %ecx
rolw $0x8, %cx
xorl %eax, %eax
testw %cx, %cx
je 0xd3fbb
pushq %rbx
movzwl %cx, %r8d
movsbl (%rdx), %ecx
movl %r8d, %r8d
addl $0xc, %esi
movl %esi, %esi
movzbl (%rdi,%rsi), %r11d
movb $0x1, %r10b
cmpl %ecx, %r11d
jne 0xd3fa8
movzbl 0x1(%rdi,%rsi), %r11d
movsbl 0x1(%rdx), %ebx... | /TwinFan[P]LiveTraffic/Lib/ImGui/imstb_truetype.h |
stbtt__csctx_v(stbtt__csctx*, unsigned char, int, int, int, int, int, int) | static void stbtt__csctx_v(stbtt__csctx *c, stbtt_uint8 type, stbtt_int32 x, stbtt_int32 y, stbtt_int32 cx, stbtt_int32 cy, stbtt_int32 cx1, stbtt_int32 cy1)
{
if (c->bounds) {
stbtt__track_vertex(c, x, y);
if (type == STBTT_vcubic) {
stbtt__track_vertex(c, cx, cy);
stbtt__track_vertex(... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %r14d
movl %r8d, %r12d
movl %esi, %r13d
movq %rdi, %rbx
movl 0x48(%rsp), %ebp
movl 0x40(%rsp), %r15d
cmpl $0x0, (%rdi)
je 0xd5822
movq %rbx, %rdi
movl %edx, %esi
movl %ecx, %edx
callq 0xd586c
cmpb $0x4, %r13b
jne 0xd585a
movq %rbx, ... | /TwinFan[P]LiveTraffic/Lib/ImGui/imstb_truetype.h |
stbtt__close_shape(stbtt_vertex*, int, int, int, int, int, int, int, int, int) | static int stbtt__close_shape(stbtt_vertex *vertices, int num_vertices, int was_off, int start_off,
stbtt_int32 sx, stbtt_int32 sy, stbtt_int32 scx, stbtt_int32 scy, stbtt_int32 cx, stbtt_int32 cy)
{
if (start_off) {
if (was_off)
stbtt_setvertex(&vertices[num_vertices++], STBTT_vcurve, (cx+scx)>>1... | pushq %rbp
pushq %rbx
movl %esi, %eax
movl 0x30(%rsp), %r10d
movl 0x28(%rsp), %r11d
testl %ecx, %ecx
je 0xd649c
movl 0x20(%rsp), %ecx
movl 0x18(%rsp), %ebx
testl %edx, %edx
je 0xd6473
movslq %eax, %rdx
incl %eax
leaq (%rdx,%rdx), %rsi
shlq $0x4, %rdx
subq %rsi, %rdx
leal (%r11,%rbx), %esi
shrl %esi
leal (%r10,%rcx), %e... | /TwinFan[P]LiveTraffic/Lib/ImGui/imstb_truetype.h |
ImGui::TextWrappedV(char const*, __va_list_tag*) | void ImGui::TextWrappedV(const char* fmt, va_list args)
{
ImGuiWindow* window = GetCurrentWindow();
bool need_backup = (window->DC.TextWrapPos < 0.0f); // Keep existing wrap position if one is already set
if (need_backup)
PushTextWrapPos(0.0f);
TextV(fmt, args);
if (need_backup)
Pop... | pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x116ebb(%rip), %rax # 0x1ee7b0
movq (%rax), %rax
movq 0x1ae0(%rax), %rax
movb $0x1, 0x80(%rax)
xorps %xmm0, %xmm0
ucomiss 0x1c8(%rax), %xmm0
jbe 0xd792e
callq 0x10f914
movq %r14, %rdi
movq %rbx, %rsi
callq 0xd7659
addq $0x8, %rsp
popq %rbx
popq %... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::GetWindowScrollbarRect(ImGuiWindow*, ImGuiAxis) | ImRect ImGui::GetWindowScrollbarRect(ImGuiWindow* window, ImGuiAxis axis)
{
const ImRect outer_rect = window->Rect();
const ImRect inner_rect = window->InnerRect;
const float border_size = window->WindowBorderSize;
const float scrollbar_size = window->ScrollbarSizes[axis ^ 1]; // (ScrollbarSizes.x = wid... | pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %esi, %ebx
movq %rdi, %r14
movss 0x10(%rdi), %xmm1
movss 0x14(%rdi), %xmm2
movss 0x18(%rdi), %xmm0
movaps %xmm1, 0x60(%rsp)
addss %xmm1, %xmm0
movss %xmm0, 0xc(%rsp)
movss 0x1c(%rdi), %xmm4
movaps %xmm2, 0x40(%rsp)
addss %xmm2, %xmm4
movss 0x230(%rdi), %xmm0
movaps... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::CheckboxFlags(char const*, unsigned int*, unsigned int) | bool ImGui::CheckboxFlags(const char* label, unsigned int* flags, unsigned int flags_value)
{
bool v = ((*flags & flags_value) == flags_value);
bool pressed = Checkbox(label, &v);
if (pressed)
{
if (v)
*flags |= flags_value;
else
*flags &= ~flags_value;
}
... | pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movl (%rsi), %eax
notl %eax
testl %eax, %edx
leaq 0x7(%rsp), %rsi
sete (%rsi)
callq 0xd9a9a
testb %al, %al
je 0xd9df5
cmpb $0x1, 0x7(%rsp)
jne 0xd9ded
orl (%r14), %ebx
jmp 0xd9df2
notl %ebx
andl (%r14), %ebx
movl %ebx, (%r14)
addq $0x8, %rsp
popq %rbx
pop... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::PopColumnsBackground() | inline ImGuiWindow* GetCurrentWindowRead() { ImGuiContext& g = *GImGui; return g.CurrentWindow; } | leaq 0x113dd7(%rip), %rax # 0x1ee7b0
movq (%rax), %rax
movq 0x1ae0(%rax), %rax
movq 0x1a0(%rax), %rdi
cmpl $0x1, 0x10(%rdi)
jne 0xda9f1
retq
movups 0x3c(%rdi), %xmm0
movups 0x3c(%rdi), %xmm1
movups %xmm0, 0x260(%rax)
movq 0x2b8(%rax), %rcx
movups %xmm1, 0x90(%rcx)
movq 0x2b8(%rax), %rcx
movq 0x68(%rcx), %rdx
movslq ... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_internal.h |
ImGui::Combo(char const*, int*, bool (*)(void*, int, char const**), void*, int, int) | bool ImGui::Combo(const char* label, int* current_item, bool (*items_getter)(void*, int, const char**), void* data, int items_count, int popup_max_height_in_items)
{
ImGuiContext& g = *GImGui;
// Call the getter to obtain the preview string which is a parameter to BeginCombo()
const char* preview_value = N... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, %r12d
movl %r8d, %ebp
movq %rcx, 0x10(%rsp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
leaq 0x11314f(%rip), %rdx # 0x1ee7b0
movq (%rdx), %rbx
movq $0x0, 0x20(%rsp)
movl (%rsi), %esi
testl %esi, %esi
sets %al
cmpl %r8d,... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::DataTypeApplyOpFromText(char const*, char const*, int, void*, char const*) | bool ImGui::DataTypeApplyOpFromText(const char* buf, const char* initial_value_buf, ImGuiDataType data_type, void* p_data, const char* format)
{
while (ImCharIsBlankA(*buf))
buf++;
// We don't support '-' op because it would conflict with inputing negative value.
// Instead you can use +-100 to sub... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, %ebp
movq %rdi, %r15
movabsq $0x100000200, %rax # imm = 0x100000200
movzbl (%r15), %r14d
cmpq $0x2f, %r14
ja 0xdc274
btq %r14, %rax
jae 0xdc251
incq %r15
jmp 0xdc23c
movabsq $0x8c0000000000, %rax # imm = 0x8C0000000000
... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::TempInputScalar(ImRect const&, unsigned int, char const*, int, void*, char const*, void const*, void const*) | bool ImGui::TempInputScalar(const ImRect& bb, ImGuiID id, const char* label, ImGuiDataType data_type, void* p_data, const char* format, const void* p_clamp_min, const void* p_clamp_max)
{
ImGuiContext& g = *GImGui;
char fmt_buf[32];
char data_buf[32];
format = ImParseFormatTrimDecorations(format, fmt_b... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r14
movl %ecx, %ebp
movq %rdx, %r15
movl %esi, %ebx
movq %rdi, %r12
leaq 0x1115da(%rip), %rax # 0x1ee7b0
movq (%rax), %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rsi
movl $0x20, %edx
movq %r9, %rdi
callq 0xdeb32
leaq 0x10(%rsp... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::DragScalarN(char const*, int, void*, int, float, void const*, void const*, char const*, float) | bool ImGui::DragScalarN(const char* label, ImGuiDataType data_type, void* p_data, int components, float v_speed, const void* p_min, const void* p_max, const char* format, float power)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiContext& g = *GImGui;
boo... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movss %xmm1, 0x4(%rsp)
movq %r9, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movss %xmm0, (%rsp)
leaq 0x111470(%rip), %rax # 0x1ee7b0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x1ae0(%rax), %rax
movb $0x1, 0x80(%rax)
cmpb $0x0, 0x83(%rax)
je 0x... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::SliderScalarN(char const*, int, void*, int, void const*, void const*, char const*, float) | bool ImGui::SliderScalarN(const char* label, ImGuiDataType data_type, void* v, int components, const void* v_min, const void* v_max, const char* format, float power)
{
ImGuiWindow* window = GetCurrentWindow();
if (window->SkipItems)
return false;
ImGuiContext& g = *GImGui;
bool value_changed = ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movss %xmm0, 0x4(%rsp)
movq %r9, 0x20(%rsp)
movq %r8, 0x18(%rsp)
leaq 0x110485(%rip), %rax # 0x1ee7b0
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x1ae0(%rax), %rax
movb $0x1, 0x80(%rax)
cmpb $0x0, 0x83(%rax)
je 0xde351
xorl %ebp, %eb... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImParseFormatTrimDecorations(char const*, char*, unsigned long) | const char* ImParseFormatTrimDecorations(const char* fmt, char* buf, size_t buf_size)
{
const char* fmt_start = ImParseFormatFindStart(fmt);
if (fmt_start[0] != '%')
return fmt;
const char* fmt_end = ImParseFormatFindEnd(fmt_start);
if (fmt_end[0] == 0) // If we only have leading decoration, we ... | pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rax
movq %rdi, %r15
movb (%r15), %sil
testb %sil, %sil
je 0xdeb70
cmpb $0x25, %sil
jne 0xdeb5d
movl $0x1, %edx
cmpb $0x25, 0x1(%r15)
jne 0xdeb77
xorl %edx, %edx
cmpb $0x25, %sil
sete %dl
addq %rdx, %r15
incq %r15
xorl %edx, %edx
jmp 0xdeb7a
mo... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImParseFormatPrecision(char const*, int) | int ImParseFormatPrecision(const char* fmt, int default_precision)
{
fmt = ImParseFormatFindStart(fmt);
if (fmt[0] != '%')
return default_precision;
fmt++;
while (*fmt >= '0' && *fmt <= '9')
fmt++;
int precision = INT_MAX;
if (*fmt == '.')
{
fmt = ImAtoi<int>(fmt + 1,... | pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movb (%rdi), %dl
testb %dl, %dl
je 0xdebf0
cmpb $0x25, %dl
jne 0xdebde
movl $0x1, %ecx
cmpb $0x25, 0x1(%rdi)
jne 0xdebf7
xorl %ecx, %ecx
cmpb $0x25, %dl
sete %cl
addq %rcx, %rdi
incq %rdi
xorl %ecx, %ecx
jmp 0xdebfa
movl $0x3, %ecx
jmp 0xdebfa
movq %rdi, %rax
testl %ecx,... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGuiInputTextCallbackData::DeleteChars(int, int) | void ImGuiInputTextCallbackData::DeleteChars(int pos, int bytes_count)
{
IM_ASSERT(pos + bytes_count <= BufTextLen);
char* dst = Buf + pos;
const char* src = Buf + pos + bytes_count;
while (char c = *src++)
*dst++ = c;
*dst = '\0';
if (CursorPos + bytes_count >= pos)
CursorPos -... | pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
leal (%rbx,%r15), %eax
cmpl 0x20(%rdi), %eax
jle 0xe3348
leaq 0xa2641(%rip), %rdi # 0x185968
leaq 0xa2c66(%rip), %rdx # 0x185f94
leaq 0xa1254(%rip), %rcx # 0x184589
leaq 0xa2c64(%rip), %r8 # 0x185fa0
movl $0xd5d, %esi ... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGuiInputTextCallbackData::InsertChars(int, char const*, char const*) | void ImGuiInputTextCallbackData::InsertChars(int pos, const char* new_text, const char* new_text_end)
{
const bool is_resizable = (Flags & ImGuiInputTextFlags_CallbackResize) != 0;
const int new_text_len = new_text_end ? (int)(new_text_end - new_text) : (int)strlen(new_text);
if (new_text_len + BufTextLen >... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
movl 0x4(%rdi), %r12d
testq %rcx, %rcx
je 0xe33c9
movq %rcx, %r14
subq %r15, %r14
jmp 0xe33d4
movq %r15, %rdi
callq 0x145e0
movq %rax, %r14
movl 0x20(%rbx), %eax
addl %r14d, %eax
cmpl 0x24(... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
InputTextFilterCharacter(unsigned int*, int, int (*)(ImGuiInputTextCallbackData*), void*) | static bool InputTextFilterCharacter(unsigned int* p_char, ImGuiInputTextFlags flags, ImGuiInputTextCallback callback, void* user_data)
{
unsigned int c = *p_char;
// Filter non-printable (NB: isprint is unreliable! see #2467)
if (c < 0x20)
{
bool pass = false;
pass |= (c == '\n' && (fl... | pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
movl (%rdi), %r8d
cmpl $0x1f, %r8d
ja 0xe3687
cmpl $0xa, %r8d
sete %r9b
movl %esi, %r10d
shrl $0x14, %r10d
cmpl $0x9, %r8d
setne %al
btl $0xa, %esi
setae %dil
testb %r9b, %r10b
jne 0xe368d
orb %al, %dil
jne 0xe36ac
jmp 0xe368d
cmpl $0x7f, %r8d
je 0xe36ac
leal -0xe000(%r8), %e... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImStb::stb_textedit_paste(ImGuiInputTextState*, ImStb::STB_TexteditState*, unsigned short const*, int) | static int stb_textedit_paste(STB_TEXTEDIT_STRING *str, STB_TexteditState *state, STB_TEXTEDIT_CHARTYPE const *ctext, int len)
{
return stb_textedit_paste_internal(str, state, (STB_TEXTEDIT_CHARTYPE *) ctext, len);
} | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0xf59eb
movq %r15, %rdi
movq %rbx, %rsi
callq 0xf5958
movl (%rbx), %esi
movq %r15, %rdi
movq %r14, %rdx
movl %ebp, %ecx
callq 0xf5768
testb %al, %al
je 0xe3864
movl (%rbx), %esi
leaq 0x18(%rbx), ... | /TwinFan[P]LiveTraffic/Lib/ImGui/imstb_textedit.h |
InputTextCalcTextSizeW(unsigned short const*, unsigned short const*, unsigned short const**, ImVec2*, bool) | static ImVec2 InputTextCalcTextSizeW(const ImWchar* text_begin, const ImWchar* text_end, const ImWchar** remaining, ImVec2* out_offset, bool stop_on_new_line)
{
ImGuiContext& g = *GImGui;
ImFont* font = g.Font;
const float line_height = g.FontSize;
const float scale = line_height / font->FontSize;
... | leaq 0x10af25(%rip), %rax # 0x1ee7b0
movq (%rax), %r8
movq 0x1978(%r8), %rax
movss 0x1980(%r8), %xmm0
movaps %xmm0, %xmm3
divss 0x14(%rax), %xmm3
leaq 0x10(%rax), %r8
xorps %xmm2, %xmm2
xorps %xmm1, %xmm1
cmpq %rsi, %rdi
jae 0xe391b
movzwl (%rdi), %r9d
cmpl $0xd, %r9d
je 0xe390f
cmpl $0xa, %r9d
jne 0xe38ef
movaps %x... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::ColorPickerOptionsPopup(float const*, int) | void ImGui::ColorPickerOptionsPopup(const float* ref_col, ImGuiColorEditFlags flags)
{
bool allow_opt_picker = !(flags & ImGuiColorEditFlags__PickerMask);
bool allow_opt_alpha_bar = !(flags & ImGuiColorEditFlags_NoAlpha) && !(flags & ImGuiColorEditFlags_AlphaBar);
if ((!allow_opt_picker && !allow_opt_alpha_... | testl $0x6000000, %esi # imm = 0x6000000
setne %al
testl $0x10002, %esi # imm = 0x10002
setne %cl
testb %cl, %al
jne 0xe6d05
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0xa2bcc(%rip), %rdi # 0x1896c5
xorl %esi, %esi
callq 0x... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::SetColorEditOptions(int) | void ImGui::SetColorEditOptions(ImGuiColorEditFlags flags)
{
ImGuiContext& g = *GImGui;
if ((flags & ImGuiColorEditFlags__DisplayMask) == 0)
flags |= ImGuiColorEditFlags__OptionsDefault & ImGuiColorEditFlags__DisplayMask;
if ((flags & ImGuiColorEditFlags__DataTypeMask) == 0)
flags |= ImGuiCo... | pushq %rbp
pushq %rbx
pushq %rax
leaq 0x107714(%rip), %rax # 0x1ee7b0
movl %edi, %ecx
orl $0x100000, %ecx # imm = 0x100000
testl $0x700000, %edi # imm = 0x700000
cmovnel %edi, %ecx
movl %ecx, %edx
orl $0x800000, %edx # imm = 0x800000
testl $0x1800000, %ecx # imm = 0x1800000
cmovnel %ec... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::PopTableBackground() | void ImGui::PopTableBackground()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiTable* table = g.CurrentTable;
ImGuiTableColumn* column = &table->Columns[table->CurrentColumn];
// Optimization: avoid PopClipRect() + SetCurrentChannel()
SetWindowClipRectBeforeSetChan... | pushq %r15
pushq %r14
pushq %rbx
leaq 0x1063b4(%rip), %rax # 0x1ee7b0
movq (%rax), %rax
movq 0x1ae0(%rax), %r14
movq 0x20a0(%rax), %rbx
movslq 0x74(%rbx), %rax
imulq $0x68, %rax, %r15
addq 0x18(%rbx), %r15
cmpq 0x20(%rbx), %r15
jb 0xe8447
leaq 0x9cb32(%rip), %rdi # 0x184f58
leaq 0x9d07c(%rip), %rdx # 0x1854a... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::ListBox(char const*, int*, bool (*)(void*, int, char const**), void*, int, int) | bool ImGui::ListBox(const char* label, int* current_item, bool (*items_getter)(void*, int, const char**), void* data, int items_count, int height_in_items)
{
if (!ListBoxHeader(label, items_count, height_in_items))
return false;
// Assume all items have even height (= 1 line of text). If you need items... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, %ebx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl %r8d, %esi
movl %r9d, %edx
callq 0xe86a9
testb %al, %al
je 0xe889c
leaq 0x105fba(%rip), %rax # 0x1ee7b0
movq (%rax), %rax
movq %rax, 0x28(%rsp)
callq 0x1115e6
leaq 0... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGuiMenuColumns::DeclColumns(float, float, float) | float ImGuiMenuColumns::DeclColumns(float w0, float w1, float w2) // not using va_arg because they promote float to double
{
NextWidth = 0.0f;
NextWidths[0] = ImMax(NextWidths[0], w0);
NextWidths[1] = ImMax(NextWidths[1], w1);
NextWidths[2] = ImMax(NextWidths[2], w2);
for (int i = 0; i < IM_ARRAYSIZ... | movl $0x0, 0x8(%rdi)
movsd 0x18(%rdi), %xmm3
unpcklps %xmm1, %xmm0 # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movaps %xmm0, %xmm1
cmpleps %xmm3, %xmm1
andps %xmm1, %xmm3
andnps %xmm0, %xmm1
orps %xmm3, %xmm1
movlps %xmm1, 0x18(%rdi)
movss 0x20(%rdi), %xmm0
movaps %xmm2, %xmm1
cmpless %xmm0, %xmm1
andps %xmm1, ... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::BeginTabBar(char const*, int) | bool ImGui::BeginTabBar(const char* str_id, ImGuiTabBarFlags flags)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (window->SkipItems)
return false;
ImGuiID id = window->GetID(str_id);
ImGuiTabBar* tab_bar = g.TabBars.GetOrAddByKey(id);
ImRect tab_bar_bb = ImR... | pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
leaq 0x104200(%rip), %rax # 0x1ee7b0
movq (%rax), %r15
movq 0x1ae0(%r15), %r14
cmpb $0x0, 0x83(%r14)
je 0xea5c8
xorl %eax, %eax
jmp 0xea640
movl %esi, %ebx
movq %rdi, %rsi
movq %r14, %rdi
xorl %edx, %edx
callq 0x101872
movl %eax, %ebp
leaq 0x20f8(%r15), %r... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::TabBarLayout(ImGuiTabBar*) | static void ImGui::TabBarLayout(ImGuiTabBar* tab_bar)
{
ImGuiContext& g = *GImGui;
tab_bar->WantLayout = false;
// Garbage collect
int tab_dst_n = 0;
for (int tab_src_n = 0; tab_src_n < tab_bar->Tabs.Size; tab_src_n++)
{
ImGuiTabItem* tab = &tab_bar->Tabs[tab_src_n];
if (tab->La... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x103cad(%rip), %rax # 0x1ee7b0
movq (%rax), %r8
movb $0x0, 0x61(%rdi)
movl (%rdi), %eax
testl %eax, %eax
movq %r8, 0x8(%rsp)
jle 0xeabf6
leaq 0x9a994(%rip), %r13 # 0x1854b4
xorl %r15d, %r15d
xorl %r12d, %r12d... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::TabItemEx(ImGuiTabBar*, char const*, bool*, int) | bool ImGui::TabItemEx(ImGuiTabBar* tab_bar, const char* label, bool* p_open, ImGuiTabItemFlags flags)
{
// Layout whole tab bar if not already done
if (tab_bar->WantLayout)
TabBarLayout(tab_bar);
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (window->SkipItems)
... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %ecx, %r12d
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %r14
cmpb $0x1, 0x61(%rdi)
jne 0xebb63
movq %r14, %rdi
callq 0xeaae8
leaq 0x102c46(%rip), %rax # 0x1ee7b0
movq (%rax), %rbx
movq 0x1ae0(%rbx), %rax
cmpb $0x0, 0x83(%rax)
je 0... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::EndTabItem() | void ImGui::EndTabItem()
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
if (window->SkipItems)
return;
ImGuiTabBar* tab_bar = g.CurrentTabBar;
if (tab_bar == NULL)
{
IM_ASSERT(tab_bar != NULL && "Needs to be called between BeginTabBar() and EndTabBar()!")... | pushq %r15
pushq %r14
pushq %rbx
leaq 0x10240a(%rip), %rax # 0x1ee7b0
movq (%rax), %rax
movq 0x1ae0(%rax), %rbx
cmpb $0x0, 0x83(%rbx)
jne 0xec479
movq 0x20f0(%rax), %r14
testq %r14, %r14
je 0xec47f
cmpw $0x0, 0x64(%r14)
jns 0xec3fd
leaq 0x9958c(%rip), %rdi # 0x185968
leaq 0x9a509(%rip), %rdx # 0x1868ec
leaq ... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::TabItemBackground(ImDrawList*, ImRect const&, int, unsigned int) | void ImGui::TabItemBackground(ImDrawList* draw_list, const ImRect& bb, ImGuiTabItemFlags flags, ImU32 col)
{
// While rendering tabs, we trim 1 pixel off the top of our bounding box so they can fit within a regular frame height while looking "detached" from it.
ImGuiContext& g = *GImGui;
const float width =... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %ecx, 0x4(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10221b(%rip), %rax # 0x1ee7b0
movss 0x8(%rsi), %xmm2
subss (%rsi), %xmm2
movq (%rax), %r12
xorps %xmm3, %xmm3
ucomiss %xmm3, %xmm2
ja 0xec5de
leaq 0x993b8(%rip), %rdi # 0... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::GetColumnWidth(int) | float ImGui::GetColumnWidth(int column_index)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiColumns* columns = window->DC.CurrentColumns;
if (columns == NULL)
return GetContentRegionAvail().x;
if (column_index < 0)
column_index = columns->Current;
retu... | pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0x101874(%rip), %rax # 0x1ee7b0
movq (%rax), %rax
movq 0x1ae0(%rax), %rax
movq 0x1a0(%rax), %r14
testq %r14, %r14
je 0xed00b
movl %edi, %ebx
testl %edi, %edi
jns 0xecf60
movl 0xc(%r14), %ebx
leal 0x1(%rbx), %ebp
cmpl %ebp, 0x60(%r14)
jg 0xecf91
leaq 0x97e0b(%rip... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::SetColumnOffset(int, float) | void ImGui::SetColumnOffset(int column_index, float offset)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiColumns* columns = window->DC.CurrentColumns;
IM_ASSERT(columns != NULL);
if (column_index < 0)
column_index = columns->Current;
IM_ASSERT(column_index < ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edi, %ebx
leaq 0x101780(%rip), %r14 # 0x1ee7b0
leaq 0x97552(%rip), %r15 # 0x184589
movq (%r14), %r12
movq 0x1ae0(%r12), %rax
movq 0x1a0(%rax), %rbp
testq %rbp, %rbp
movss %xmm0, (%rsp)
jne 0xed07c
leaq 0x9890e(%rip), %rdi ... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::GetColumnsID(char const*, int) | ImGuiID ImGui::GetColumnsID(const char* str_id, int columns_count)
{
ImGuiWindow* window = GetCurrentWindow();
// Differentiate column ID with an arbitrary prefix for cases where users name their columns set the same as another widget.
// In addition, when an identifier isn't explicitly provided we include... | pushq %r14
pushq %rbx
pushq %rax
leaq 0x101133(%rip), %rax # 0x1ee7b0
movq (%rax), %rax
movq 0x1ae0(%rax), %rbx
movb $0x1, 0x80(%rbx)
movl $0x11223347, %ecx # imm = 0x11223347
leal (%rsi,%rcx), %eax
testq %rdi, %rdi
cmovnel %ecx, %eax
leaq 0x9934c(%rip), %r14 # 0x1869ef
cmovneq %rdi, %r14
movl %eax, %edi
c... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::BeginTableEx(char const*, unsigned int, int, int, ImVec2 const&, float) | bool ImGui::BeginTableEx(const char* name, ImGuiID id, int columns_count, ImGuiTableFlags flags, const ImVec2& outer_size, float inner_width)
{
ImGuiContext& g = *GImGui;
ImGuiWindow* outer_window = GetCurrentWindow();
if (outer_window->SkipItems) // Consistent with other tables + beneficial side effect ... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
leaq 0x1002a4(%rip), %rax # 0x1ee7b0
movq (%rax), %r15
movq 0x1ae0(%r15), %r12
movb $0x1, 0x80(%r12)
cmpb $0x0, 0x83(%r12)
jne 0xee614
movq %r8, %r14
movl %ecx, %ebp
movl %edx, %ebx
movq %rdi, %r13
movl %esi, 0x1c(%rsp)
leal -0x1(%rbx... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::TableLoadSettings(ImGuiTable*) | void ImGui::TableLoadSettings(ImGuiTable* table)
{
ImGuiContext& g = *GImGui;
table->IsSettingsRequestLoad = false;
if (table->Flags & ImGuiTableFlags_NoSavedSettings)
return;
// Bind settings
ImGuiTableSettings* settings;
if (table->SettingsOffset == -1)
{
settings = TableS... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0xff523(%rip), %rax # 0x1ee7b0
movq (%rax), %r15
movb $0x0, 0x1d9(%rdi)
testb $0x20, 0x4(%rdi)
jne 0xef448
movq %rdi, %rbx
cmpl $-0x1, 0x64(%rdi)
je 0xef2b7
movq %rbx, %rdi
callq 0xf4e0b
movq %rax, %r14
jmp 0xef2df
movl (%rbx), %edi
c... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
ImGui::TableUpdateDrawChannels(ImGuiTable*) | void ImGui::TableUpdateDrawChannels(ImGuiTable* table)
{
// Allocate draw channels.
// - We allocate them following storage order instead of display order so reordering columns won't needlessly
// increase overall dormant memory cost.
// - We isolate headers draw commands in their own channels instead... | pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %ebp
testb $0x40, 0x5(%rdi)
jne 0xefea8
movl 0x70(%rbx), %ebp
movb 0x1ce(%rbx), %cl
movl 0x70(%rbx), %edx
movb $0x1, %al
cmpl 0x6c(%rbx), %edx
jl 0xefec3
movq 0x58(%rbx), %rax
cmpq 0x48(%rbx), %rax
setne %al
testb %c... | /TwinFan[P]LiveTraffic/Lib/ImGui/imgui_widgets.cpp |
Subsets and Splits
SQL Console for LLM4Binary/decompile-bench
Filters out entries with file names ending in .cpp, providing a basic subset of the dataset that excludes C++ files.