LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/apps/scninfo/scninfo.cpp
// Function: ReadScene(char*)
static R3Scene *
ReadScene(char *filename)
{
  // Allocate scene
  R3Scene *scene = new R3Scene();
  if (!scene) {
    RNFail("Unable to allocate scene for %s\n", filename);
    return NULL;
  }

  // Read scene from file
  if (!scene->ReadFile(filename)) {
    delete scene;
    return NULL;
  }

  // Process scene
  if (remove_references) scene->RemoveReferences();
  if (remove_transformations) scene->RemoveTransformations();
  if (remove_hierarchy) scene->RemoveHierarchy();
  
  // Return scene
  return scene;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl $0x160, %edi            # imm = 0x160
callq 0x22990
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
callq 0x2ae20
jmp 0x27065
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x270ba
movq 0x28(%rsp), %rsi
leaq 0x16506d(%rip), %rdi    # 0x18c0f0
movb $0x0, %al
callq 0xf1970
movq $0x0, 0x30(%rsp)
jmp 0x27146
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x160, %esi            # imm = 0x160
callq 0x229b0
jmp 0x27150
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x2d480
cmpl $0x0, %eax
jne 0x27103
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x270f8
movq (%rsp), %rdi
callq 0x2b0a0
movq (%rsp), %rdi
movl $0x160, %esi            # imm = 0x160
callq 0x229b0
movq $0x0, 0x30(%rsp)
jmp 0x27146
cmpl $0x0, 0x1d2a1a(%rip)    # 0x1f9b24
je 0x27116
movq 0x20(%rsp), %rdi
callq 0x2be50
cmpl $0x0, 0x1d2a0f(%rip)    # 0x1f9b2c
je 0x27129
movq 0x20(%rsp), %rdi
callq 0x2c230
cmpl $0x0, 0x1d29f8(%rip)    # 0x1f9b28
je 0x2713c
movq 0x20(%rsp), %rdi
callq 0x2c030
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x23210
nopw (%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/scninfo/scninfo.cpp
// Function: PrintLight(gaps::R3Light*, int, int)
static int
PrintLight(R3Light *light, int index, int level)
{
  // Construct indent
  char indent[4096] = { '\0' };
  for (int i = 0; i < level; i++) {
    strcat(indent, "  ");
  }

  // Print light
  const RNRgb& color = light->Color();
  printf("%sLight %d\n", indent, index);
  printf("%s  Intensity = %g\n", indent, light->Intensity());
  printf("%s  Color = %g %g %g\n", indent, color.R(), color.G(), color.B());
  printf("\n");

  // Return success
  return 1;
}

// Assembly:
subq $0x1048, %rsp           # imm = 0x1048
movq %rdi, 0x1040(%rsp)
movl %esi, 0x103c(%rsp)
movl %edx, 0x1038(%rsp)
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x224b0
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x1038(%rsp), %eax
jge 0x28861
leaq 0x30(%rsp), %rdi
leaq 0x167012(%rip), %rsi    # 0x18f861
callq 0x23230
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x28836
movq 0x1040(%rsp), %rdi
callq 0x2ac00
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rsi
movl 0x103c(%rsp), %edx
leaq 0x163c14(%rip), %rdi    # 0x18c49a
movb $0x0, %al
callq 0x22090
leaq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x1040(%rsp), %rdi
callq 0x2ac10
movq (%rsp), %rsi
leaq 0x163bf8(%rip), %rdi    # 0x18c4a6
movb $0x1, %al
callq 0x22090
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2ab70
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2ab80
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2ab90
movq 0x8(%rsp), %rsi
movsd 0x10(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x18(%rsp), %xmm0
leaq 0x163bb6(%rip), %rdi    # 0x18c4ba
movb $0x3, %al
callq 0x22090
leaq 0x16adf0(%rip), %rdi    # 0x193702
movb $0x0, %al
callq 0x22090
movl $0x1, %eax
addq $0x1048, %rsp           # imm = 0x1048
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/apps/scninfo/scninfo.cpp
// Function: PrintTexture(gaps::R2Texture*, int, int)
static int
PrintTexture(R2Texture *texture, int index, int level)
{
  // Construct indent
  char indent[4096] = { '\0' };
  for (int i = 0; i < level; i++) {
    strcat(indent, "  ");
  }

  // Print texture
  const char *name = texture->Name();
  const char *filename = texture->Filename();
  const R2Image *image = texture->Image();
  int width = (image) ? image->Width() : 0;
  int height = (image) ? image->Height() : 0;
  int ncomponents = (image) ? image->NComponents() : 0;
  printf("%sTexture %d\n", indent, index);
  if (name) printf("%s  Name = %s\n", indent, name);
  printf("%s  Scene index = %d\n", indent, texture->SceneIndex());
  printf("%s  Dimensions = %d %d\n", indent, width, height);
  printf("%s  NComponents = %d\n", indent, ncomponents);
  if (filename) printf("%s  Filename = %s\n", indent, filename);
  printf("\n");

  // Return success
  return 1;
}

// Assembly:
subq $0x1058, %rsp           # imm = 0x1058
movq %rdi, 0x1050(%rsp)
movl %esi, 0x104c(%rsp)
movl %edx, 0x1048(%rsp)
leaq 0x40(%rsp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x224b0
movl $0x0, 0x3c(%rsp)
movl 0x3c(%rsp), %eax
cmpl 0x1048(%rsp), %eax
jge 0x28dc1
leaq 0x40(%rsp), %rdi
leaq 0x166ab2(%rip), %rsi    # 0x18f861
callq 0x23230
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
jmp 0x28d96
movq 0x1050(%rsp), %rdi
callq 0x2ab60
movq %rax, 0x30(%rsp)
movq 0x1050(%rsp), %rdi
callq 0x2ad70
movq %rax, 0x28(%rsp)
movq 0x1050(%rsp), %rdi
callq 0x2ad80
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x28e0f
movq 0x20(%rsp), %rdi
callq 0x2ad90
movl %eax, 0x10(%rsp)
jmp 0x28e17
xorl %eax, %eax
movl %eax, 0x10(%rsp)
jmp 0x28e17
movl 0x10(%rsp), %eax
movl %eax, 0x1c(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x28e37
movq 0x20(%rsp), %rdi
callq 0x2ada0
movl %eax, 0xc(%rsp)
jmp 0x28e3f
xorl %eax, %eax
movl %eax, 0xc(%rsp)
jmp 0x28e3f
movl 0xc(%rsp), %eax
movl %eax, 0x18(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x28e5f
movq 0x20(%rsp), %rdi
callq 0x2adb0
movl %eax, 0x8(%rsp)
jmp 0x28e67
xorl %eax, %eax
movl %eax, 0x8(%rsp)
jmp 0x28e67
movl 0x8(%rsp), %eax
movl %eax, 0x14(%rsp)
leaq 0x40(%rsp), %rsi
movl 0x104c(%rsp), %edx
leaq 0x16370a(%rip), %rdi    # 0x18c58c
movb $0x0, %al
callq 0x22090
cmpq $0x0, 0x30(%rsp)
je 0x28ea9
leaq 0x40(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x1635a8(%rip), %rdi    # 0x18c44a
movb $0x0, %al
callq 0x22090
leaq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x1050(%rsp), %rdi
callq 0x2adc0
movq (%rsp), %rsi
movl %eax, %edx
leaq 0x163363(%rip), %rdi    # 0x18c22f
movb $0x0, %al
callq 0x22090
leaq 0x40(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
leaq 0x1636b3(%rip), %rdi    # 0x18c59a
movb $0x0, %al
callq 0x22090
leaq 0x40(%rsp), %rsi
movl 0x14(%rsp), %edx
leaq 0x1636b4(%rip), %rdi    # 0x18c5b2
movb $0x0, %al
callq 0x22090
cmpq $0x0, 0x28(%rsp)
je 0x28f25
leaq 0x40(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x16353b(%rip), %rdi    # 0x18c459
movb $0x0, %al
callq 0x22090
leaq 0x16a7d6(%rip), %rdi    # 0x193702
movb $0x0, %al
callq 0x22090
movl $0x1, %eax
addq $0x1058, %rsp           # imm = 0x1058
retq
// File: iZhangHui[P]CppPrimer/CH03_StringsVectorsAndArrays/examples/strcompare.cc
// Function: main
int main()
{
    string str = "Hello";
    string phrase = "Hello World";
    string slang  = "Hiya";

    if (str < phrase) cout << "str is smaller" << endl;
    if (slang > str) cout << "slang is greater" << endl;
    if (slang > phrase) cout << "slang is greater" << endl;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x10e0
movq -0x98(%rbp), %rdx
leaq 0xda4(%rip), %rsi       # 0x2004
leaq -0x28(%rbp), %rdi
callq 0x10b0
jmp 0x126b
leaq -0x29(%rbp), %rdi
callq 0x10a0
leaq -0x61(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x10e0
movq -0xa0(%rbp), %rdx
leaq 0xd78(%rip), %rsi       # 0x200a
leaq -0x60(%rbp), %rdi
callq 0x10b0
jmp 0x129d
leaq -0x61(%rbp), %rdi
callq 0x10a0
leaq -0x89(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x10e0
movq -0xa8(%rbp), %rdx
leaq 0xd4f(%rip), %rsi       # 0x2016
leaq -0x88(%rbp), %rdi
callq 0x10b0
jmp 0x12d5
leaq -0x89(%rbp), %rdi
callq 0x10a0
leaq -0x28(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x1480
testb $0x1, %al
jne 0x12f7
jmp 0x1398
movq 0x2cda(%rip), %rdi      # 0x3fd8
leaq 0xd16(%rip), %rsi       # 0x201b
callq 0x1080
movq %rax, -0xb0(%rbp)
jmp 0x1313
movq -0xb0(%rbp), %rdi
movq 0x2ca7(%rip), %rsi      # 0x3fc8
callq 0x1090
jmp 0x1328
jmp 0x1398
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x10a0
jmp 0x146d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x10a0
jmp 0x1464
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x89(%rbp), %rdi
callq 0x10a0
jmp 0x145b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1060
jmp 0x145b
leaq -0x88(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x14c0
testb $0x1, %al
jne 0x13ae
jmp 0x13e1
movq 0x2c23(%rip), %rdi      # 0x3fd8
leaq 0xc6e(%rip), %rsi       # 0x202a
callq 0x1080
movq %rax, -0xb8(%rbp)
jmp 0x13ca
movq -0xb8(%rbp), %rdi
movq 0x2bf0(%rip), %rsi      # 0x3fc8
callq 0x1090
jmp 0x13df
jmp 0x13e1
leaq -0x88(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x14c0
testb $0x1, %al
jne 0x13f7
jmp 0x142a
movq 0x2bda(%rip), %rdi      # 0x3fd8
leaq 0xc25(%rip), %rsi       # 0x202a
callq 0x1080
movq %rax, -0xc0(%rbp)
jmp 0x1413
movq -0xc0(%rbp), %rdi
movq 0x2ba7(%rip), %rsi      # 0x3fc8
callq 0x1090
jmp 0x1428
jmp 0x142a
movl $0x0, -0x4(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x1060
leaq -0x60(%rbp), %rdi
callq 0x1060
leaq -0x28(%rbp), %rdi
callq 0x1060
movl -0x4(%rbp), %eax
addq $0xc0, %rsp
popq %rbp
retq
leaq -0x60(%rbp), %rdi
callq 0x1060
leaq -0x28(%rbp), %rdi
callq 0x1060
movq -0x38(%rbp), %rdi
callq 0x10d0
nopw %cs:(%rax,%rax)
// File: ashlall[P]StreamStats/Test/./../SourceCode/ChiSquare/ChiSquareCategorical.cpp
// Function: ChiSquareCategorical::ChiSquareCategorical(double)
ChiSquareCategorical::ChiSquareCategorical(double p)
{
	chi_squared=0;
	stream_size=0;
	percent =p;
	range=pow(2,32);
	num_cat=0;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq $0x0, 0x28(%rdi)
addq $0x30, %rdi
movq %rdi, -0x38(%rbp)
callq 0x2f00
movq -0x30(%rbp), %rax
movq $0x0, (%rax)
movl $0x0, 0x20(%rax)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, 0x10(%rax)
movl $0x2, %edi
movl $0x20, %esi
callq 0x2f20
movsd %xmm0, -0x28(%rbp)
jmp 0x13c0
movq -0x30(%rbp), %rax
movsd -0x28(%rbp), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, 0x28(%rax)
movl $0x0, 0x24(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x2f50
movq -0x18(%rbp), %rdi
callq 0x1190
nopl (%rax)
// File: ashlall[P]StreamStats/Test/./../SourceCode/ChiSquare/ChiSquareCategorical.cpp
// Function: ChiSquareCategorical::insert(double)
void ChiSquareCategorical::insert(double c)
{
	stream_size++;
	HashTable HashA(71);
	long hash_value= HashA.hash(c);
	if(hash_value<((percent/100)*range))
	{	
		if(map.count(hash_value)<1)
		{	
			map.emplace(hash_value,1);
			num_cat++;
		}
		else
		{
			long cat_count=map.at(hash_value);
			cat_count++;
			map.at(hash_value)=cat_count;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
movl 0x20(%rax), %ecx
incl %ecx
movl %ecx, 0x20(%rax)
leaq -0x14(%rbp), %rdi
movl $0x47, %esi
callq 0x2f70
cvttsd2si -0x10(%rbp), %rax
movl %eax, %esi
leaq -0x14(%rbp), %rdi
callq 0x2f90
movl %eax, %ecx
movq -0x48(%rbp), %rax
movl %ecx, %ecx
movq %rcx, -0x20(%rbp)
cvtsi2sdq -0x20(%rbp), %xmm1
movsd 0x10(%rax), %xmm0
movsd 0x4ba9(%rip), %xmm2     # 0x6008
divsd %xmm2, %xmm0
cvtsi2sdq 0x28(%rax), %xmm2
mulsd %xmm2, %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1506
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
leaq -0x20(%rbp), %rsi
callq 0x3000
cmpq $0x1, %rax
jae 0x14c3
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
movl $0x1, -0x24(%rbp)
leaq -0x20(%rbp), %rsi
leaq -0x24(%rbp), %rdx
callq 0x3030
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x38(%rbp)
movb %dl, -0x30(%rbp)
movl 0x24(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x24(%rax)
jmp 0x1504
movq -0x48(%rbp), %rdi
addq $0x30, %rdi
leaq -0x20(%rbp), %rsi
callq 0x3080
movq -0x48(%rbp), %rdi
movslq (%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movl %eax, -0x4c(%rbp)
addq $0x30, %rdi
leaq -0x20(%rbp), %rsi
callq 0x3080
movl -0x4c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x1506
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: ashlall[P]StreamStats/Test/Chi_Square_Categorical_test.cpp
// Function: categorical_test5()
void categorical_test5()
{
		
	ChiSquareCategorical c1(10);
	ChiSquareCategorical c2(10);
	int num_cat=10000;
	int df=0;
	for(int i=0;i<num_cat;i++)
	{
		int v1= (int)(rand() % 250+50);
		int max_dif= 28;
		int v2= v1-max_dif+rand()%(2*max_dif+1);
	
		for(int j=0;j<v1;j++)
			c1.insert(i);
				
		for(int k=0;k<v2;k++)
			c2.insert(i);
	}
	
	
	double chi=c1.calculate_statistic(c2,df);
	cout<<chi<<endl;
	cout<<1-pochisq(chi,df--);
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
leaq -0x68(%rbp), %rdi
movsd 0x34b9(%rip), %xmm0     # 0x6140
movsd %xmm0, -0x110(%rbp)
callq 0x1360
movsd -0x110(%rbp), %xmm0
leaq -0xd0(%rbp), %rdi
callq 0x1360
jmp 0x2caa
movl $0x2710, -0xe0(%rbp)    # imm = 0x2710
movl $0x0, -0xe4(%rbp)
movl $0x0, -0xe8(%rbp)
movl -0xe8(%rbp), %eax
cmpl -0xe0(%rbp), %eax
jge 0x2dfc
callq 0x1040
movl $0xfa, %ecx
cltd
idivl %ecx
addl $0x32, %edx
movl %edx, -0xec(%rbp)
movl $0x1c, -0xf0(%rbp)
movl -0xec(%rbp), %eax
subl -0xf0(%rbp), %eax
movl %eax, -0x114(%rbp)
callq 0x1040
movl -0xf0(%rbp), %ecx
shll %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl -0x114(%rbp), %eax
addl %edx, %eax
movl %eax, -0xf4(%rbp)
movl $0x0, -0xf8(%rbp)
movl -0xf8(%rbp), %eax
cmpl -0xec(%rbp), %eax
jge 0x2da5
cvtsi2sdl -0xe8(%rbp), %xmm0
leaq -0x68(%rbp), %rdi
callq 0x1400
jmp 0x2d58
jmp 0x2d5a
movl -0xf8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xf8(%rbp)
jmp 0x2d37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0x2ec5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0xd0(%rbp), %rdi
callq 0x3400
jmp 0x2ec5
movl $0x0, -0xfc(%rbp)
movl -0xfc(%rbp), %eax
cmpl -0xf4(%rbp), %eax
jge 0x2de6
cvtsi2sdl -0xe8(%rbp), %xmm0
leaq -0xd0(%rbp), %rdi
callq 0x1400
jmp 0x2dd3
jmp 0x2dd5
movl -0xfc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xfc(%rbp)
jmp 0x2daf
jmp 0x2de8
movl -0xe8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xe8(%rbp)
jmp 0x2cc8
movl -0xe4(%rbp), %edx
leaq -0x68(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x1510
movsd %xmm0, -0x120(%rbp)
jmp 0x2e1c
movsd -0x120(%rbp), %xmm0
movsd %xmm0, -0x108(%rbp)
movsd -0x108(%rbp), %xmm0
movq 0x719d(%rip), %rdi      # 0x9fd8
callq 0x11b0
movq %rax, -0x128(%rbp)
jmp 0x2e49
movq -0x128(%rbp), %rdi
movq 0x7171(%rip), %rsi      # 0x9fc8
callq 0x1110
jmp 0x2e5e
movsd -0x108(%rbp), %xmm0
movl -0xe4(%rbp), %edi
movl %edi, %eax
decl %eax
movl %eax, -0xe4(%rbp)
callq 0x1e40
movsd %xmm0, -0x130(%rbp)
jmp 0x2e85
movsd -0x130(%rbp), %xmm1
movsd 0x3183(%rip), %xmm0     # 0x6018
subsd %xmm1, %xmm0
movq 0x7138(%rip), %rdi      # 0x9fd8
callq 0x11b0
jmp 0x2ea7
leaq -0xd0(%rbp), %rdi
callq 0x3400
leaq -0x68(%rbp), %rdi
callq 0x3400
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
leaq -0x68(%rbp), %rdi
callq 0x3400
movq -0xd8(%rbp), %rdi
callq 0x1190
nopw (%rax,%rax)
// File: ashlall[P]StreamStats/Test/./../SourceCode/ChiSquare/ChiSquareCategorical.h
// Function: HashTable::hash(unsigned int)
uint32_t hash(uint32_t a)
	{	
		a = (a+0x479ab41d) + (a<<8); //http://burtleburtle.net/bob/hash/integer.html
		a = (a^0xe4aa10ce) ^ (a>>5);
		a = (a+0x9942f0a6) - (a<<14);
		a = (a^0x5aedd67d) ^ (a>>3);
		a = (a+0x17bea992) + (a<<7);
		return a;

	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x479ab41d, %eax       # imm = 0x479AB41D
movl -0xc(%rbp), %ecx
shll $0x8, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
xorl $0xe4aa10ce, %eax       # imm = 0xE4AA10CE
movl -0xc(%rbp), %ecx
shrl $0x5, %ecx
xorl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x9942f0a6, %eax       # imm = 0x9942F0A6
movl -0xc(%rbp), %ecx
shll $0xe, %ecx
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
xorl $0x5aedd67d, %eax       # imm = 0x5AEDD67D
movl -0xc(%rbp), %ecx
shrl $0x3, %ecx
xorl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x17bea992, %eax       # imm = 0x17BEA992
movl -0xc(%rbp), %ecx
shll $0x7, %ecx
addl %ecx, %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
popq %rbp
retq
nop
// File: iZhangHui[P]CppPrimer/CH12_DynamicMemory/exercises/ex12_26.cc
// Function: main
int main(int argc, char const *argv[])
{
	allocator<string> alloc;
	string* const p = alloc.allocate(SIZE);

	string s;
	auto q = p;

	while (cin >> s && q != p + SIZE) {
		alloc.construct(q++, s);
	}

	for (auto r = p; r != q; ++r) {
		cout << *r << endl;
		alloc.destroy(r);
	}

	alloc.deallocate(p, SIZE);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x11(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1400
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %edx
movl $0xa, %esi
callq 0x1420
movq %rax, -0x68(%rbp)
jmp 0x128e
movq -0x68(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x10e0
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x2d32(%rip), %rdi      # 0x3fe0
leaq -0x50(%rbp), %rsi
callq 0x10d0
movq %rax, -0x78(%rbp)
jmp 0x12bd
movq -0x78(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x10c0
movb %al, -0x79(%rbp)
jmp 0x12d5
movb -0x79(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x7a(%rbp)
jne 0x12e4
jmp 0x12fc
movq -0x58(%rbp), %rax
movq -0x20(%rbp), %rcx
addq $0x140, %rcx            # imm = 0x140
cmpq %rcx, %rax
setne %al
movb %al, -0x7a(%rbp)
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0x1305
jmp 0x1350
movq -0x58(%rbp), %rsi
movq %rsi, %rax
addq $0x20, %rax
movq %rax, -0x58(%rbp)
leaq -0x11(%rbp), %rdi
leaq -0x50(%rbp), %rdx
callq 0x1480
jmp 0x1323
jmp 0x12a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
jmp 0x13e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1050
jmp 0x13e4
movq -0x20(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x58(%rbp), %rax
je 0x13ab
movq -0x60(%rbp), %rsi
movq 0x2c63(%rip), %rdi      # 0x3fd0
callq 0x1080
movq %rax, -0x88(%rbp)
jmp 0x137b
movq -0x88(%rbp), %rdi
movq 0x2c37(%rip), %rsi      # 0x3fc0
callq 0x10b0
jmp 0x1390
movq -0x60(%rbp), %rsi
leaq -0x11(%rbp), %rdi
callq 0x14b0
movq -0x60(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x60(%rbp)
jmp 0x1358
movq -0x20(%rbp), %rsi
leaq -0x11(%rbp), %rdi
movl $0xa, %edx
callq 0x14d0
jmp 0x13bf
movl $0x0, -0x4(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x1050
leaq -0x11(%rbp), %rdi
callq 0x1500
movl -0x4(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
leaq -0x11(%rbp), %rdi
callq 0x1500
movq -0x28(%rbp), %rdi
callq 0x1100
nopw %cs:(%rax,%rax)
// File: attractivechaos[P]udb2/khash/test.c
// Function: test_int
uint32_t test_int(uint32_t n, uint32_t x0)
{
	uint32_t i, x, z = 0;
	khash_t(32a) *h;
	h = kh_init(32a);
	for (i = 0, x = x0; i < n; ++i) {
		khint_t k;
		int absent;
		x = hash32(x);
		k = kh_put(32a, h, get_key(n, x), &absent);
#ifndef UDB2_TEST_DEL
		if (absent) kh_val(h, k) = 0;
		z += ++kh_val(h, k);
#else
		if (absent) ++z;
		else kh_del(32a, h, k);
#endif
	}
	fprintf(stderr, "# unique keys: %d; checksum: %u\n", kh_size(h), z);
	x = kh_size(h);
	kh_destroy(32a, h);
	return x;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movl $0x0, 0x24(%rsp)
callq 0x16a0
movq %rax, 0x18(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x30(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x34(%rsp), %eax
jae 0x1652
movl 0x28(%rsp), %edi
callq 0x1250
movl %eax, 0x28(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x34(%rsp), %edi
movl 0x28(%rsp), %esi
callq 0x12c0
movq 0x8(%rsp), %rdi
movl %eax, %esi
leaq 0x10(%rsp), %rdx
callq 0x16c0
movl %eax, 0x14(%rsp)
cmpl $0x0, 0x10(%rsp)
je 0x1635
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1643
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x1a80
jmp 0x1645
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x15de
movq 0x399f(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movl 0x4(%rax), %edx
movl 0x24(%rsp), %ecx
leaq 0x1a16(%rip), %rsi      # 0x3085
movb $0x0, %al
callq 0x1070
movq 0x18(%rsp), %rax
movl 0x4(%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1b00
movl 0x28(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: FFY00[P]uicc/include/milenage.h
// Function: milenage_generate(unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, unsigned char*, unsigned char*, unsigned char*, unsigned char*)
bool milenage_generate(const u8 *opc, const u8 *amf, const u8 *k,
                       const u8 *sqn, const u8 *_rand, u8 *autn, u8 *ik,
                       u8 *ck, u8 *res) {
  int i;
  u8 mac_a[8], ak[6];

  if (!milenage_f1(opc, k, _rand, sqn, amf, mac_a, NULL) ||
      !milenage_f2345(opc, k, _rand, res, ck, ik, ak, NULL))
    return false;

  /* AUTN = (SQN ^ AK) || AMF || MAC */
  for (i = 0; i < 6; i++)
    autn[i] = sqn[i] ^ ak[i];

  memcpy(autn + 6, amf, 2);
  memcpy(autn + 8, mac_a, 8);
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq %r9, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %r8
leaq -0x44(%rbp), %r9
xorl %eax, %eax
movq $0x0, (%rsp)
callq 0x3670
testb $0x1, %al
jne 0x3bb9
jmp 0x3bee
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq 0x20(%rbp), %rcx
movq 0x18(%rbp), %r8
movq 0x10(%rbp), %r9
leaq -0x4a(%rbp), %rax
xorl %r10d, %r10d
movq %rax, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x3840
testb $0x1, %al
jne 0x3bf4
movb $0x0, -0x1(%rbp)
jmp 0x3c4f
movl $0x0, -0x3c(%rbp)
cmpl $0x6, -0x3c(%rbp)
jge 0x3c30
movq -0x28(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movslq -0x3c(%rbp), %rcx
movzbl -0x4a(%rbp,%rcx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x38(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x3bfb
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movw (%rcx), %cx
movw %cx, 0x6(%rax)
movq -0x38(%rbp), %rax
movq -0x44(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: FFY00[P]uicc/include/milenage.h
// Function: milenage_auts(unsigned char const*, unsigned char const*, unsigned char const*, unsigned char const*, unsigned char*)
bool milenage_auts(const u8 *opc, const u8 *k, const u8 *_rand, const u8 *auts,
                   u8 *sqn) {
  u8 amf[2] = { 0x00, 0x00 }; /* TS 33.102 v7.0.0, 6.3.3 */
  u8 ak[6], mac_s[8];
  int i;

  if (!milenage_f2345(opc, k, _rand, NULL, NULL, NULL, NULL, ak))
    return false;

  for (i = 0; i < 6; i++)
    sqn[i] = auts[i] ^ ak[i];

  if (!milenage_f1(opc, k, _rand, sqn, amf, NULL, mac_s) ||
      memcmp(mac_s, auts + 6, 8) != 0)
    return false;

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
leaq -0x32(%rbp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x3160
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rax
xorl %ecx, %ecx
movl %ecx, %r9d
movq %r9, %rcx
movq %r9, %r8
movq $0x0, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x3840
testb $0x1, %al
jne 0x3cc6
movb $0x0, -0x1(%rbp)
jmp 0x3d56
movl $0x0, -0x44(%rbp)
cmpl $0x6, -0x44(%rbp)
jge 0x3d02
movq -0x28(%rbp), %rax
movslq -0x44(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movslq -0x44(%rbp), %rcx
movzbl -0x38(%rbp,%rcx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x30(%rbp), %rax
movslq -0x44(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x3ccd
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq -0x32(%rbp), %r8
leaq -0x40(%rbp), %rax
xorl %r9d, %r9d
movq %rax, (%rsp)
callq 0x3670
testb $0x1, %al
jne 0x3d2c
jmp 0x3d4c
leaq -0x40(%rbp), %rax
movq -0x28(%rbp), %rcx
addq $0x6, %rcx
movq (%rcx), %rcx
movq (%rax), %rax
subq %rcx, %rax
setne %al
movzbl %al, %eax
cmpl $0x0, %eax
je 0x3d52
movb $0x0, -0x1(%rbp)
jmp 0x3d56
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: FFY00[P]uicc/include/milenage.h
// Function: gsm_milenage(unsigned char const*, unsigned char const*, unsigned char const*, unsigned char*, unsigned char*)
bool gsm_milenage(const u8 *opc, const u8 *k, const u8 *_rand, u8 *sres, u8 *kc) {
  u8 res[8], ck[16], ik[16];
  int i;

  if (milenage_f2345(opc, k, _rand, res, ck, ik, NULL, NULL))
    return false;

  for (i = 0; i < 8; i++)
    kc[i] = ck[i] ^ ck[i + 8] ^ ik[i] ^ ik[i + 8];

#ifdef GSM_MILENAGE_ALT_SRES
  memcpy(sres, res, 4);
#else /* GSM_MILENAGE_ALT_SRES */

  for (i = 0; i < 4; i++)
    sres[i] = res[i] ^ res[i + 4];

#endif /* GSM_MILENAGE_ALT_SRES */
  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
leaq -0x38(%rbp), %rcx
leaq -0x50(%rbp), %r8
leaq -0x60(%rbp), %r9
xorl %eax, %eax
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x3840
testb $0x1, %al
jne 0x3dc5
jmp 0x3dce
movb $0x0, -0x1(%rbp)
jmp 0x3e69
movl $0x0, -0x64(%rbp)
cmpl $0x8, -0x64(%rbp)
jge 0x3e27
movslq -0x64(%rbp), %rax
movzbl -0x50(%rbp,%rax), %eax
movl -0x64(%rbp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movzbl -0x50(%rbp,%rcx), %ecx
xorl %ecx, %eax
movslq -0x64(%rbp), %rcx
movzbl -0x60(%rbp,%rcx), %ecx
xorl %ecx, %eax
movl -0x64(%rbp), %ecx
addl $0x8, %ecx
movslq %ecx, %rcx
movzbl -0x60(%rbp,%rcx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x30(%rbp), %rax
movslq -0x64(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x3dd5
movl $0x0, -0x64(%rbp)
cmpl $0x4, -0x64(%rbp)
jge 0x3e65
movslq -0x64(%rbp), %rax
movzbl -0x38(%rbp,%rax), %eax
movl -0x64(%rbp), %ecx
addl $0x4, %ecx
movslq %ecx, %rcx
movzbl -0x38(%rbp,%rcx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x28(%rbp), %rax
movslq -0x64(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x64(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x64(%rbp)
jmp 0x3e2e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: FFY00[P]uicc/include/milenage.h
// Function: milenage_opc_gen(unsigned char const*, unsigned char const*, unsigned char*)
void milenage_opc_gen(const u8 *k, const u8 *op, u8 *opc) {
  int i;
  /* Encrypt OP using K */
  aes_128_encrypt_block(k, op, opc);

  /* XOR the resulting Ek(OP) with OP */
  for (i = 0; i < 16; i++)
    opc[i] = opc[i] ^ op[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x37f0
movl $0x0, -0x1c(%rbp)
cmpl $0x10, -0x1c(%rbp)
jge 0x4114
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x10(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movzbl (%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x40dc
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: FFY00[P]uicc/include/uicc.h
// Function: bcdToAscii(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static inline string bcdToAscii(string data) {
    string ret="";

    for (size_t i=0; i<data.size(); i++) {
        char c= (data[i] & 0xF) + '0';

        if ( c >= '0' && c <= '9' )
            ret+=c;

        c= (data[i]>>4 & 0xF) + '0';

        if ( c >= '0' && c <= '9' )
            ret+=c;
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x34d0
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rdx
leaq 0x20c85(%rip), %rsi     # 0x25c64
callq 0x33e0
jmp 0x4fe6
leaq -0x12(%rbp), %rdi
callq 0x3300
movq $0x0, -0x30(%rbp)
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x31f0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x50eb
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3520
movq %rax, -0x68(%rbp)
jmp 0x502b
movq -0x68(%rbp), %rax
movsbl (%rax), %eax
andl $0xf, %eax
addl $0x30, %eax
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x30, %eax
jl 0x508f
movsbl -0x31(%rbp), %eax
cmpl $0x39, %eax
jg 0x508f
movq -0x48(%rbp), %rdi
movsbl -0x31(%rbp), %esi
callq 0x31b0
jmp 0x505c
jmp 0x508f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x3300
jmp 0x5108
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31a0
jmp 0x5108
movq -0x58(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x3520
movq %rax, -0x70(%rbp)
jmp 0x50a2
movq -0x70(%rbp), %rax
movsbl (%rax), %eax
sarl $0x4, %eax
andl $0xf, %eax
addl $0x30, %eax
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %eax
cmpl $0x30, %eax
jl 0x50d8
movsbl -0x31(%rbp), %eax
cmpl $0x39, %eax
jg 0x50d8
movq -0x48(%rbp), %rdi
movsbl -0x31(%rbp), %esi
callq 0x31b0
jmp 0x50d6
jmp 0x50d8
jmp 0x50da
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x4ff7
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x50fe
movq -0x48(%rbp), %rdi
callq 0x31a0
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: FFY00[P]uicc/include/uicc.h
// Function: luhn(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static inline bool luhn( const string &id) {
    static const int m[10]  = {0,2,4,6,8,1,3,5,7,9}; // mapping for rule 3
    bool is_odd_dgt = false;
    auto lambda = [&](int a, char c) {
        return a + ((is_odd_dgt = !is_odd_dgt) ? c-'0' : m[c-'0']);
    };
    int s = std::accumulate(id.rbegin(), id.rend(), 0, lambda);
    return 0 == s%10;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
leaq -0x9(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x3460
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3060
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rcx
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
xorl %edx, %edx
callq 0xe810
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl $0xa, %ecx
cltd
idivl %ecx
xorl %eax, %eax
cmpl %edx, %eax
sete %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: FFY00[P]uicc/include/uicc.h
// Function: printable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static inline string printable(string in) {
    string ret="";

    for (auto c:in )
        if(isprint(c))
            ret+=c;

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x0, -0x11(%rbp)
leaq -0x12(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x34d0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0x20a95(%rip), %rsi     # 0x25c64
callq 0x33e0
jmp 0x51d6
leaq -0x12(%rbp), %rdi
callq 0x3300
movq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3240
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0x3170
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1ef80
testb $0x1, %al
jne 0x5214
jmp 0x527c
leaq -0x38(%rbp), %rdi
callq 0x1efc0
movb (%rax), %al
movb %al, -0x41(%rbp)
movsbl -0x41(%rbp), %edi
callq 0x34c0
cmpl $0x0, %eax
je 0x526f
movq -0x58(%rbp), %rdi
movsbl -0x41(%rbp), %esi
callq 0x31b0
jmp 0x523f
jmp 0x526f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x12(%rbp), %rdi
callq 0x3300
jmp 0x5299
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31a0
jmp 0x5299
jmp 0x5271
leaq -0x38(%rbp), %rdi
callq 0x1efe0
jmp 0x5201
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x528f
movq -0x58(%rbp), %rdi
callq 0x31a0
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34b0
nopw %cs:(%rax,%rax)
// File: FFY00[P]uicc/include/uicc.h
// Function: dump_hex(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static inline void dump_hex(string name, string data) {
    printf("%s: 0x", name.c_str());

    for (size_t i=0; i<data.size(); i++)
        printf("%02hhx", data[i]);

    printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x3110
movq %rax, %rsi
leaq 0x19149(%rip), %rdi     # 0x2631c
movb $0x0, %al
callq 0x3050
movq $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x31f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0xd22b
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3520
movsbl (%rax), %esi
leaq 0x17df8(%rip), %rdi     # 0x2500e
movb $0x0, %al
callq 0x3050
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xd1e2
leaq 0x184aa(%rip), %rdi     # 0x256dc
movb $0x0, %al
callq 0x3050
addq $0x30, %rsp
popq %rbp
retq
nop
// File: FFY00[P]uicc/include/aes.h
// Function: RijndaelEncrypt(unsigned char const*, unsigned char*, unsigned char (*) [4][4])
static inline void RijndaelEncrypt ( const uint8_t input[16], uint8_t output[16], uint8_t roundKeys[11][4][4]) {
  uint8_t state[4][4];
  int r;

  // initialise state array from input byte string
  for (int i = 0; i < 16; i++)
    state[i & 0x3][i >> 2] = input[i];

  // add first round_key
  KeyAdd (state, roundKeys, 0);

  // do lots of full rounds
  for (r = 1; r <= 9; r++) {
    ByteSub (state);
    ShiftRow (state);
    MixColumn (state);
    KeyAdd (state, roundKeys, r);
  }

  // final round
  ByteSub (state);
  ShiftRow (state);
  KeyAdd (state, roundKeys, r);

  // produce output byte string from state array
  for (int i = 0; i < 16; i++)
    output[i] = state[i & 0x3][i >> 2];

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x38(%rbp)
cmpl $0x10, -0x38(%rbp)
jge 0xde27
movq -0x8(%rbp), %rax
movslq -0x38(%rbp), %rcx
movb (%rax,%rcx), %dl
movl -0x38(%rbp), %eax
andl $0x3, %eax
movslq %eax, %rcx
leaq -0x30(%rbp), %rax
shlq $0x2, %rcx
addq %rcx, %rax
movl -0x38(%rbp), %ecx
sarl $0x2, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0xddeb
leaq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0xdef0
movl $0x1, -0x34(%rbp)
cmpl $0x9, -0x34(%rbp)
jg 0xde79
leaq -0x30(%rbp), %rdi
callq 0xdf80
leaq -0x30(%rbp), %rdi
callq 0xe000
leaq -0x30(%rbp), %rdi
callq 0xe0d0
leaq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0xdef0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xde3d
leaq -0x30(%rbp), %rdi
callq 0xdf80
leaq -0x30(%rbp), %rdi
callq 0xe000
leaq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x34(%rbp), %edx
callq 0xdef0
movl $0x0, -0x3c(%rbp)
cmpl $0x10, -0x3c(%rbp)
jge 0xdede
movl -0x3c(%rbp), %eax
andl $0x3, %eax
movslq %eax, %rcx
leaq -0x30(%rbp), %rax
shlq $0x2, %rcx
addq %rcx, %rax
movl -0x3c(%rbp), %ecx
sarl $0x2, %ecx
movslq %ecx, %rcx
movb (%rax,%rcx), %dl
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xdea2
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: FFY00[P]uicc/include/aes.h
// Function: KeyAdd(unsigned char (*) [4], unsigned char (*) [4][4], int)
static inline void KeyAdd (uint8_t state[4][4], uint8_t roundKeys[11][4][4], int round) {
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < 4; j++)
      state[i][j] ^= roundKeys[round][i][j];

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x4, -0x18(%rbp)
jge 0xdf6f
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jge 0xdf62
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movslq -0x18(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %esi
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xdf13
jmp 0xdf64
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xdf06
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: FFY00[P]uicc/include/aes.h
// Function: ByteSub(unsigned char (*) [4])
static inline void ByteSub (uint8_t state[4][4]) {
  for (int i = 0; i < 4; i++)
    for (int j = 0; j < 4; j++)
      state[i][j] = S[state[i][j]];

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0xdff3
movl $0x0, -0x10(%rbp)
cmpl $0x4, -0x10(%rbp)
jge 0xdfe6
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x1509e(%rip), %rax     # 0x23060
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
shlq $0x2, %rcx
addq %rcx, %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xdf9c
jmp 0xdfe8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xdf8f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: FFY00[P]uicc/include/aes.h
// Function: ShiftRow(unsigned char (*) [4])
static inline void ShiftRow (uint8_t state[4][4]) {
  // left rotate row 1 by 1
  uint8_t temp = state[1][0];
  state[1][0]  = state[1][1];
  state[1][1]  = state[1][2];
  state[1][2]  = state[1][3];
  state[1][3]  = temp;
  //left rotate row 2 by 2
  temp        = state[2][0];
  state[2][0] = state[2][2];
  state[2][2] = temp;
  temp        = state[2][1];
  state[2][1] = state[2][3];
  state[2][3] = temp;
  // left rotate row 3 by 3
  temp        = state[3][0];
  state[3][0] = state[3][3];
  state[3][3] = state[3][2];
  state[3][2] = state[3][1];
  state[3][1] = temp;
  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movb 0x4(%rax), %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb 0x5(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x4(%rax)
movq -0x8(%rbp), %rax
movb 0x6(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x5(%rax)
movq -0x8(%rbp), %rax
movb 0x7(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x6(%rax)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x7(%rax)
movq -0x8(%rbp), %rax
movb 0x8(%rax), %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb 0xa(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x8(%rax)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0xa(%rax)
movq -0x8(%rbp), %rax
movb 0x9(%rax), %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb 0xb(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0x9(%rax)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0xb(%rax)
movq -0x8(%rbp), %rax
movb 0xc(%rax), %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb 0xf(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0xc(%rax)
movq -0x8(%rbp), %rax
movb 0xe(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0xf(%rax)
movq -0x8(%rbp), %rax
movb 0xd(%rax), %cl
movq -0x8(%rbp), %rax
movb %cl, 0xe(%rax)
movb -0x9(%rbp), %cl
movq -0x8(%rbp), %rax
movb %cl, 0xd(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: FFY00[P]uicc/include/aes.h
// Function: MixColumn(unsigned char (*) [4])
static inline void MixColumn ( uint8_t state[4][4]) {
  // do one column at a time
  for (int i = 0; i < 4; i++) {
    uint8_t temp = state[0][i] ^ state[1][i] ^ state[2][i] ^ state[3][i];
    uint8_t tmp0 = state[0][i];
    // Xtime array does multiply by x in GF2^8
    uint8_t tmp = Xtime[state[0][i] ^ state[1][i]];
    state[0][i] ^= temp ^ tmp;
    tmp = Xtime[state[1][i] ^ state[2][i]];
    state[1][i] ^= temp ^ tmp;
    tmp = Xtime[state[2][i] ^ state[3][i]];
    state[2][i] ^= temp ^ tmp;
    tmp = Xtime[state[3][i] ^ tmp0];
    state[3][i] ^= temp ^ tmp;
  }

  return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0xe259
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movzbl 0x4(%rcx,%rdx), %ecx
xorl %ecx, %eax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movzbl 0x8(%rcx,%rdx), %ecx
xorl %ecx, %eax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movzbl 0xc(%rcx,%rdx), %ecx
xorl %ecx, %eax
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0xe(%rbp)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movzbl 0x4(%rcx,%rdx), %ecx
xorl %ecx, %eax
movslq %eax, %rcx
leaq 0x15008(%rip), %rax     # 0x23160
movb (%rax,%rcx), %al
movb %al, -0xf(%rbp)
movzbl -0xd(%rbp), %esi
movzbl -0xf(%rbp), %eax
xorl %eax, %esi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl 0x4(%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movzbl 0x8(%rcx,%rdx), %ecx
xorl %ecx, %eax
movslq %eax, %rcx
leaq 0x14fc1(%rip), %rax     # 0x23160
movb (%rax,%rcx), %al
movb %al, -0xf(%rbp)
movzbl -0xd(%rbp), %esi
movzbl -0xf(%rbp), %eax
xorl %eax, %esi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl 0x4(%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, 0x4(%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl 0x8(%rax,%rcx), %eax
movq -0x8(%rbp), %rcx
movslq -0xc(%rbp), %rdx
movzbl 0xc(%rcx,%rdx), %ecx
xorl %ecx, %eax
movslq %eax, %rcx
leaq 0x14f78(%rip), %rax     # 0x23160
movb (%rax,%rcx), %al
movb %al, -0xf(%rbp)
movzbl -0xd(%rbp), %esi
movzbl -0xf(%rbp), %eax
xorl %eax, %esi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl 0x8(%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, 0x8(%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl 0xc(%rax,%rcx), %eax
movzbl -0xe(%rbp), %ecx
xorl %ecx, %eax
movslq %eax, %rcx
leaq 0x14f38(%rip), %rax     # 0x23160
movb (%rax,%rcx), %al
movb %al, -0xf(%rbp)
movzbl -0xd(%rbp), %esi
movzbl -0xf(%rbp), %eax
xorl %eax, %esi
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movzbl 0xc(%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, 0xc(%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xe0df
popq %rbp
retq
nopl (%rax,%rax)
// File: FFY00[P]uicc/include/uicc.h
// Function: mkDigit(unsigned char)
static inline unsigned char mkDigit(unsigned char in) {
    unsigned char v=tolower(in);

    if ( v >= '0'&& v <= '9' )
        return v-'0';

    if ( v >= 'a'&& v <= 'f' )
        return v-'a'+10;

    printf("Invalid hexa value: %x \n", (int)in);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movzbl -0x2(%rbp), %edi
callq 0x3430
movb %al, -0x3(%rbp)
movzbl -0x3(%rbp), %eax
cmpl $0x30, %eax
jl 0xe918
movzbl -0x3(%rbp), %eax
cmpl $0x39, %eax
jg 0xe918
movzbl -0x3(%rbp), %eax
subl $0x30, %eax
movb %al, -0x1(%rbp)
jmp 0xe94f
movzbl -0x3(%rbp), %eax
cmpl $0x61, %eax
jl 0xe939
movzbl -0x3(%rbp), %eax
cmpl $0x66, %eax
jg 0xe939
movzbl -0x3(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movb %al, -0x1(%rbp)
jmp 0xe94f
movzbl -0x2(%rbp), %esi
leaq 0x178c2(%rip), %rdi     # 0x26206
movb $0x0, %al
callq 0x3050
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: FFY00[P]uicc/include/uicc.h
// Function: UICC::decodeIMSI(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string decodeIMSI(string raw) {
        //int l=raw.c_str()[0];
        string imsi=bcdToAscii(raw.substr(1)); // First byte is length
        //IMSI length bytes, then parity is second byte
        return imsi.substr(1);
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x88(%rbp)
movq %rsi, %rax
movq -0x88(%rbp), %rsi
movq %rdi, -0x80(%rbp)
movq %rdi, %rcx
movq %rcx, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
leaq -0x58(%rbp), %rdi
movq %rdi, -0x70(%rbp)
movl $0x1, %edx
movq $-0x1, %rcx
callq 0x32c0
movq -0x70(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x4fa0
jmp 0xeccb
leaq -0x58(%rbp), %rdi
callq 0x31a0
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x1, %edx
movq $-0x1, %rcx
callq 0x32c0
jmp 0xecef
leaq -0x38(%rbp), %rdi
callq 0x31a0
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x31a0
jmp 0xed31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31a0
movq -0x60(%rbp), %rdi
callq 0x34b0
nopw (%rax,%rax)
// File: FFY00[P]uicc/include/uicc.h
// Function: UICC::decodeISDN(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string decodeISDN(string raw) {
        // ISDN is in last 14 bytes
        string isdn=raw.substr(raw.size()-14);
        char isdnLength=isdn[0];
        //char TON=isdn[1]; // should be 0x81
        // two last bytes should be FF (capability , extensions)
        return bcdToAscii(isdn.substr(2,isdnLength));
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdx, -0x88(%rbp)
movq %rdi, %rax
movq -0x88(%rbp), %rdi
movq %rax, -0x98(%rbp)
movq %rax, %rcx
movq %rcx, -0x90(%rbp)
movq %rax, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
callq 0x31f0
movq -0x88(%rbp), %rsi
movq %rax, %rdx
addq $-0xe, %rdx
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movq $-0x1, %rcx
callq 0x32c0
movq -0x80(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3520
movq %rax, -0x78(%rbp)
jmp 0xf783
movq -0x78(%rbp), %rax
movb (%rax), %al
movb %al, -0x39(%rbp)
movsbq -0x39(%rbp), %rcx
leaq -0x70(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x2, %edx
callq 0x32c0
jmp 0xf7a5
movq -0x98(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x4fa0
jmp 0xf7b7
leaq -0x70(%rbp), %rdi
callq 0x31a0
leaq -0x38(%rbp), %rdi
callq 0x31a0
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xf7fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x31a0
leaq -0x38(%rbp), %rdi
callq 0x31a0
movq -0x48(%rbp), %rdi
callq 0x34b0
nop