LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_misc.c
// Function: fghErrorString
static const char* fghErrorString( GLenum error )
{
  switch ( error ) {
  case GL_INVALID_ENUM: return "invalid enumerant";
  case GL_INVALID_VALUE: return "invalid value";
  case GL_INVALID_OPERATION: return "invalid operation";
  case GL_STACK_OVERFLOW: return "stack overflow";
  case GL_STACK_UNDERFLOW: return "stack underflow";
  case GL_OUT_OF_MEMORY: return "out of memory";
  case GL_TABLE_TOO_LARGE: return "table too large";
  case GL_INVALID_FRAMEBUFFER_OPERATION: return "invalid framebuffer operation";
  case GL_TEXTURE_TOO_LARGE: return "texture too large";
  default: return "unknown GL error";
  }
}

// Assembly:
movl %edi, -0xc(%rsp)
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
subl $0x500, %eax            # imm = 0x500
je 0x18cb6d
jmp 0x18cb05
movl -0x10(%rsp), %eax
subl $0x501, %eax            # imm = 0x501
je 0x18cb7b
jmp 0x18cb12
movl -0x10(%rsp), %eax
subl $0x502, %eax            # imm = 0x502
je 0x18cb89
jmp 0x18cb1f
movl -0x10(%rsp), %eax
subl $0x503, %eax            # imm = 0x503
je 0x18cb97
jmp 0x18cb2c
movl -0x10(%rsp), %eax
subl $0x504, %eax            # imm = 0x504
je 0x18cba5
jmp 0x18cb39
movl -0x10(%rsp), %eax
subl $0x505, %eax            # imm = 0x505
je 0x18cbb3
jmp 0x18cb46
movl -0x10(%rsp), %eax
subl $0x506, %eax            # imm = 0x506
je 0x18cbcf
jmp 0x18cb53
movl -0x10(%rsp), %eax
subl $0x8031, %eax           # imm = 0x8031
je 0x18cbc1
jmp 0x18cb60
movl -0x10(%rsp), %eax
subl $0x8065, %eax           # imm = 0x8065
je 0x18cbdd
jmp 0x18cbeb
leaq 0x22a7f(%rip), %rax     # 0x1af5f3
movq %rax, -0x8(%rsp)
jmp 0x18cbf7
leaq 0x22a83(%rip), %rax     # 0x1af605
movq %rax, -0x8(%rsp)
jmp 0x18cbf7
leaq 0x22a83(%rip), %rax     # 0x1af613
movq %rax, -0x8(%rsp)
jmp 0x18cbf7
leaq 0x22a87(%rip), %rax     # 0x1af625
movq %rax, -0x8(%rsp)
jmp 0x18cbf7
leaq 0x22a88(%rip), %rax     # 0x1af634
movq %rax, -0x8(%rsp)
jmp 0x18cbf7
leaq 0x22a8a(%rip), %rax     # 0x1af644
movq %rax, -0x8(%rsp)
jmp 0x18cbf7
leaq 0x22a8a(%rip), %rax     # 0x1af652
movq %rax, -0x8(%rsp)
jmp 0x18cbf7
leaq 0x22a8c(%rip), %rax     # 0x1af662
movq %rax, -0x8(%rsp)
jmp 0x18cbf7
leaq 0x22a9c(%rip), %rax     # 0x1af680
movq %rax, -0x8(%rsp)
jmp 0x18cbf7
leaq 0x22aa0(%rip), %rax     # 0x1af692
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_misc.c
// Function: glutSetKeyRepeat
void FGAPIENTRY glutSetKeyRepeat( int repeatMode )
{
    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutSetKeyRepeat" );

    switch( repeatMode )
    {
    case GLUT_KEY_REPEAT_OFF:
    case GLUT_KEY_REPEAT_ON:
     fgState.KeyRepeat = repeatMode;
     break;

    case GLUT_KEY_REPEAT_DEFAULT:
     fgState.KeyRepeat = GLUT_KEY_REPEAT_ON;
     break;

    default:
        fgError ("Invalid glutSetKeyRepeat mode: %d", repeatMode);
        break;
    }
}

// Assembly:
pushq %rax
movl %edi, 0x4(%rsp)
leaq 0x6d714(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x18cc97
leaq 0x10c49(%rip), %rdi     # 0x19d8d2
leaq 0x226c1(%rip), %rsi     # 0x1af351
movb $0x0, %al
callq 0x17de70
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
subl $0x2, %eax
jb 0x18ccaf
jmp 0x18cca5
movl (%rsp), %eax
subl $0x2, %eax
je 0x18ccbf
jmp 0x18cccf
movl 0x4(%rsp), %ecx
leaq 0x6d6d6(%rip), %rax     # 0x1fa390
movl %ecx, 0x28(%rax)
jmp 0x18cce1
leaq 0x6d6ca(%rip), %rax     # 0x1fa390
movl $0x1, 0x28(%rax)
jmp 0x18cce1
movl 0x4(%rsp), %esi
leaq 0x228f7(%rip), %rdi     # 0x1af5d1
movb $0x0, %al
callq 0x17de70
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_misc.c
// Function: glutForceJoystickFunc
void FGAPIENTRY glutForceJoystickFunc( void )
{
    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutForceJoystickFunc" );
#if !defined(_WIN32_WCE)
    freeglut_return_if_fail( fgStructure.CurrentWindow != NULL );
    freeglut_return_if_fail( FETCH_WCB( *( fgStructure.CurrentWindow ), Joystick ) );
    fgJoystickPollWindow( fgStructure.CurrentWindow );
#endif /* !defined(_WIN32_WCE) */
}

// Assembly:
pushq %rax
leaq 0x6d698(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x18cd13
leaq 0x10bcd(%rip), %rdi     # 0x19d8d2
leaq 0x22656(%rip), %rsi     # 0x1af362
movb $0x0, %al
callq 0x17de70
leaq 0x731c6(%rip), %rax     # 0x1ffee0
cmpq $0x0, 0x30(%rax)
jne 0x18cd23
jmp 0x18cd4a
leaq 0x731b6(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rax
cmpq $0x0, 0xd8(%rax)
jne 0x18cd3a
jmp 0x18cd4a
leaq 0x7319f(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rdi
callq 0x17cfc0
popq %rax
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_cursor.c
// Function: getEmptyCursor
static Cursor getEmptyCursor( void )
{
    static Cursor cursorNone = None;
    if( cursorNone == None ) {
        char cursorNoneBits[ 32 ];
        XColor dontCare;
        Pixmap cursorNonePixmap;
        memset( cursorNoneBits, 0, sizeof( cursorNoneBits ) );
        memset( &dontCare, 0, sizeof( dontCare ) );
        cursorNonePixmap = XCreateBitmapFromData ( fgDisplay.Display,
                                                   fgDisplay.RootWindow,
                                                   cursorNoneBits, 16, 16 );
        if( cursorNonePixmap != None ) {
            cursorNone = XCreatePixmapCursor( fgDisplay.Display,
                                              cursorNonePixmap, cursorNonePixmap,
                                              &dontCare, &dontCare, 0, 0 );
            XFreePixmap( fgDisplay.Display, cursorNonePixmap );
        }
    }
    return cursorNone;
}

// Assembly:
subq $0x48, %rsp
cmpq $0x0, 0x728dc(%rip)     # 0x1fff38
jne 0x18d701
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
movl $0x20, %edx
callq 0x224f0
leaq 0x10(%rsp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x224f0
leaq 0x727a5(%rip), %rax     # 0x1ffe30
movq (%rax), %rdi
leaq 0x7279b(%rip), %rax     # 0x1ffe30
movq 0x10(%rax), %rsi
leaq 0x20(%rsp), %rdx
movl $0x10, %r8d
movl %r8d, %ecx
callq 0x22bb0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x18d6ff
leaq 0x72770(%rip), %rax     # 0x1ffe30
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
movq 0x8(%rsp), %rdx
leaq 0x10(%rsp), %r8
xorl %r9d, %r9d
movq %r8, %rcx
movl $0x0, (%rsp)
callq 0x22720
movq %rax, 0x7284d(%rip)     # 0x1fff38
leaq 0x7273e(%rip), %rax     # 0x1ffe30
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x232e0
jmp 0x18d701
movq 0x72830(%rip), %rax     # 0x1fff38
addq $0x48, %rsp
retq
nopl (%rax)
// File: tomfunkhouser[P]gaps/pkgs/fglut/freeglut_cursor.c
// Function: glutWarpPointer
void FGAPIENTRY glutWarpPointer( int x, int y )
{
    FREEGLUT_EXIT_IF_NOT_INITIALISED ( "glutWarpPointer" );
    FREEGLUT_EXIT_IF_NO_WINDOW ( "glutWarpPointer" );

#if TARGET_HOST_POSIX_X11

    XWarpPointer(
        fgDisplay.Display,
        None,
        fgStructure.CurrentWindow->Window.Handle,
        0, 0, 0, 0,
        x, y
    );
    /* Make the warp visible immediately. */
    XFlush( fgDisplay.Display );

#elif TARGET_HOST_MS_WINDOWS

    {
        POINT coords;
        coords.x = x;
        coords.y = y;

        /* ClientToScreen() translates {coords} for us. */
        ClientToScreen( fgStructure.CurrentWindow->Window.Handle, &coords );
        SetCursorPos( coords.x, coords.y );
    }

#endif
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movl %esi, 0x20(%rsp)
leaq 0x6cc0d(%rip), %rax     # 0x1fa390
cmpb $0x0, 0x1c(%rax)
jne 0x18d79e
leaq 0x10142(%rip), %rdi     # 0x19d8d2
leaq 0x21925(%rip), %rsi     # 0x1af0bc
movb $0x0, %al
callq 0x17de70
leaq 0x7273b(%rip), %rax     # 0x1ffee0
cmpq $0x0, 0x30(%rax)
jne 0x18d7c1
leaq 0x10477(%rip), %rdi     # 0x19dc2a
leaq 0x21902(%rip), %rsi     # 0x1af0bc
movb $0x0, %al
callq 0x17de70
leaq 0x72668(%rip), %rax     # 0x1ffe30
movq (%rax), %rdi
leaq 0x7270e(%rip), %rax     # 0x1ffee0
movq 0x30(%rax), %rax
movq 0x18(%rax), %rdx
movl 0x24(%rsp), %r10d
movl 0x20(%rsp), %eax
xorl %ecx, %ecx
movl %ecx, %esi
xorl %r9d, %r9d
movl %r9d, %ecx
movl %r9d, %r8d
movl $0x0, (%rsp)
movl %r10d, 0x8(%rsp)
movl %eax, 0x10(%rsp)
callq 0x23000
leaq 0x72624(%rip), %rax     # 0x1ffe30
movq (%rax), %rdi
callq 0x23060
addq $0x28, %rsp
retq
// File: AbraaoHonorio[P]Page-Replacement-Algorithms/PageReplacement.cpp
// Function: PageReplacement::readFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void PageReplacement::readFile(std::string filename)
{

	std::ifstream myfile(filename);
	int element = 0;


	if (myfile.is_open())
	{
		myfile >> element; // get first value
		sizeRam_m = element;

		while (myfile >> element) // read the referenced strings
		{
			myPages.push_back(element);
		}
	}
	else
	{
		std::cout << "Unable to open file" << std::endl;
	}

	myfile.close();


}

// Assembly:
subq $0x258, %rsp            # imm = 0x258
movq %rdi, 0x250(%rsp)
movq %rsi, 0x248(%rsp)
movq 0x250(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movl $0x8, %edx
callq 0x2160
movq 0x20(%rsp), %rdi
movl $0x0, 0x3c(%rsp)
callq 0x2150
movb %al, 0x2b(%rsp)
jmp 0x3470
movb 0x2b(%rsp), %al
testb $0x1, %al
jne 0x347d
jmp 0x3507
leaq 0x40(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x2090
jmp 0x348e
movq 0x18(%rsp), %rax
movl 0x3c(%rsp), %ecx
movl %ecx, 0xc(%rax)
leaq 0x40(%rsp), %rdi
leaq 0x3c(%rsp), %rsi
callq 0x2090
movq %rax, 0x10(%rsp)
jmp 0x34b0
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x2120
movb %al, 0xf(%rsp)
jmp 0x34ca
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x34d4
jmp 0x3505
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
leaq 0x3c(%rsp), %rsi
callq 0x3760
jmp 0x34e9
jmp 0x349a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2040
jmp 0x3552
jmp 0x3534
movq 0x5aca(%rip), %rdi      # 0x8fd8
leaq 0x2b40(%rip), %rsi      # 0x6055
callq 0x20e0
movq %rax, (%rsp)
jmp 0x3520
movq (%rsp), %rdi
movq 0x5a9d(%rip), %rsi      # 0x8fc8
callq 0x2100
jmp 0x3532
jmp 0x3534
leaq 0x40(%rsp), %rdi
callq 0x2030
jmp 0x3540
leaq 0x40(%rsp), %rdi
callq 0x2040
addq $0x258, %rsp            # imm = 0x258
retq
movq 0x30(%rsp), %rdi
callq 0x2190
nopl (%rax)
// File: AbraaoHonorio[P]Page-Replacement-Algorithms/main.cpp
// Function: main
int main(void)
{
	PageReplacement *pageReplacement = new PageReplacement();

	pageReplacement->readFile("input/input.txt"); 
	pageReplacement->fifo();
	pageReplacement->otm();
	pageReplacement->lru();


	std::cout<<std::endl;
	delete pageReplacement;


	return 0;

}

// Assembly:
subq $0x68, %rsp
movl $0x0, 0x64(%rsp)
movl $0x40, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
callq 0x2330
jmp 0x5b88
movq 0x18(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x27(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x21a0
movq 0x10(%rsp), %rdx
leaq 0x50f(%rip), %rsi       # 0x60c6
leaq 0x28(%rsp), %rdi
callq 0x2130
jmp 0x5bc3
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3420
jmp 0x5bd4
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x27(%rsp), %rdi
callq 0x2110
movq 0x58(%rsp), %rdi
callq 0x2410
movq 0x58(%rsp), %rdi
callq 0x2b40
movq 0x58(%rsp), %rdi
callq 0x2ee0
movq 0x33cb(%rip), %rdi      # 0x8fd8
movq 0x33b4(%rip), %rsi      # 0x8fc8
callq 0x2100
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x5c32
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
xorl %eax, %eax
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x20d0
jmp 0x5c85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x5c7b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x20a0
leaq 0x27(%rsp), %rdi
callq 0x2110
movq 0x50(%rsp), %rdi
callq 0x2190
// File: NichtJens[P]lmf2txt/LMF_IO.cpp
// Function: LMF_IO::write_times(MyFILE*, long, long)
void LMF_IO::write_times(MyFILE * out_file,time_t _Starttime,time_t _Stoptime) {
	unsigned __int32 dummy;
	if (CTime_version_output > 2003) {
		dummy = INT_MIN_+10; *out_file << dummy;
		dummy = (unsigned __int32)_Starttime; *out_file << dummy;
		dummy =0;			*out_file << dummy;
		dummy =INT_MIN_+10;	*out_file << dummy;
		dummy = (unsigned __int32)_Stoptime;	*out_file << dummy;
		dummy = 0;			*out_file << dummy;
	} else {
		dummy = (unsigned __int32)_Starttime;	*out_file << dummy;
		dummy = (unsigned __int32)_Stoptime;	*out_file << dummy;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x7d3, 0x278(%rax)     # imm = 0x7D3
jle 0x252c
movl $0x8000000a, -0x24(%rbp) # imm = 0x8000000A
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x1caf0
movq -0x18(%rbp), %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x1caf0
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x1caf0
movl $0x8000000a, -0x24(%rbp) # imm = 0x8000000A
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x1caf0
movq -0x20(%rbp), %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x1caf0
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x1caf0
jmp 0x2552
movq -0x18(%rbp), %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x1caf0
movq -0x20(%rbp), %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x1caf0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: NichtJens[P]lmf2txt/LMF_IO.cpp
// Function: ReadCStringLength(MyFILE&)
unsigned __int32 ReadCStringLength(MyFILE &in_file)
{
	unsigned __int64 qwLength;
	unsigned __int32 dwLength;
	unsigned __int16 wLength;
	unsigned __int8  bLength;

//	__int32 nCharSize = sizeof(__int8);

	// First, try to read a one-byte length
	in_file >> bLength;

	if (bLength < 0xff) 
		return bLength;

	// Try a two-byte length
	in_file >> wLength;
	if (wLength == 0xfffe)
	{
//		// Unicode string.  Start over at 1-byte length
//		nCharSize = sizeof(wchar_t);

		in_file >> bLength;
		if (bLength < 0xff)
			return bLength;

		// Two-byte length
		in_file >> wLength;
		// Fall through to continue on same branch as ANSI string
	}
	if (wLength < 0xffff)
		return wLength;

	// 4-byte length
	in_file >> dwLength;
	if (dwLength < 0xffffffff)
		return dwLength;

	// 8-byte length
	in_file >> qwLength;

	return (unsigned __int32)qwLength;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x1f(%rbp), %rsi
callq 0x1cb20
movzbl -0x1f(%rbp), %eax
cmpl $0xff, %eax
jge 0x2590
movzbl -0x1f(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2619
movq -0x10(%rbp), %rdi
leaq -0x1e(%rbp), %rsi
callq 0x1cb50
movzwl -0x1e(%rbp), %eax
cmpl $0xfffe, %eax           # imm = 0xFFFE
jne 0x25d6
movq -0x10(%rbp), %rdi
leaq -0x1f(%rbp), %rsi
callq 0x1cb20
movzbl -0x1f(%rbp), %eax
cmpl $0xff, %eax
jge 0x25c9
movzbl -0x1f(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2619
movq -0x10(%rbp), %rdi
leaq -0x1e(%rbp), %rsi
callq 0x1cb50
movzwl -0x1e(%rbp), %eax
cmpl $0xffff, %eax           # imm = 0xFFFF
jge 0x25ea
movzwl -0x1e(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2619
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x1cb80
cmpl $-0x1, -0x1c(%rbp)
jae 0x2605
movl -0x1c(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x2619
movq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x1cbb0
movq -0x18(%rbp), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: NichtJens[P]lmf2txt/LMF_IO.cpp
// Function: Read_CString_as_StdString(MyFILE&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void Read_CString_as_StdString(MyFILE &in_file,std::string &stdstring)
{
	__int32 length = ReadCStringLength(in_file);
	__int8 * temp_string = new __int8[length+1];
	in_file.read(temp_string,length);
	temp_string[length] = 0;
	stdstring = temp_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2560
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1cbe0
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
callq 0x2250
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: NichtJens[P]lmf2txt/LMF_IO.cpp
// Function: WriteCStringLength(MyFILE&, unsigned int)
void WriteCStringLength(MyFILE &out_file, unsigned __int32 nLength)
{
	unsigned __int8 dummy_uint8;
	unsigned __int16 dummy_uint16;
	unsigned __int32 dummy_uint32;
	unsigned __int64 dummy_uint64;

	if (nLength < 255)
	{
		dummy_uint8 = nLength; out_file << dummy_uint8;
	}
	else if (nLength < 0xfffe)
	{
		dummy_uint8 = 0xff; out_file << dummy_uint8;
		dummy_uint16 = nLength; out_file << dummy_uint16;
	}
	else if (nLength < 0xffffffff)
	{
		dummy_uint8 = 0xff; out_file << dummy_uint8;
		dummy_uint16 = 0xffff; out_file << dummy_uint16;
		dummy_uint32 = nLength; out_file << dummy_uint32;
	}
	else
	{
		dummy_uint8 = 0xff; out_file << dummy_uint8;
		dummy_uint16 = 0xffff; out_file << dummy_uint16;
		dummy_uint32 = 0xffffffff; out_file << dummy_uint32;
		dummy_uint64 = nLength; out_file << dummy_uint64;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0xff, -0xc(%rbp)
jae 0x26c0
movl -0xc(%rbp), %eax
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0xd(%rbp), %esi
callq 0x1cc60
jmp 0x2780
cmpl $0xfffe, -0xc(%rbp)     # imm = 0xFFFE
jae 0x26f3
movb $-0x1, -0xd(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0xd(%rbp), %esi
callq 0x1cc60
movl -0xc(%rbp), %eax
movw %ax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movzwl -0x10(%rbp), %esi
callq 0x1cca0
jmp 0x277e
cmpl $-0x1, -0xc(%rbp)
jae 0x2731
movb $-0x1, -0xd(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0xd(%rbp), %esi
callq 0x1cc60
movw $0xffff, -0x10(%rbp)    # imm = 0xFFFF
movq -0x8(%rbp), %rdi
movzwl -0x10(%rbp), %esi
callq 0x1cca0
movl -0xc(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1caf0
jmp 0x277c
movb $-0x1, -0xd(%rbp)
movq -0x8(%rbp), %rdi
movzbl -0xd(%rbp), %esi
callq 0x1cc60
movw $0xffff, -0x10(%rbp)    # imm = 0xFFFF
movq -0x8(%rbp), %rdi
movzwl -0x10(%rbp), %esi
callq 0x1cca0
movl $0xffffffff, -0x14(%rbp) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x1caf0
movl -0xc(%rbp), %eax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x1cce0
jmp 0x277e
jmp 0x2780
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: NichtJens[P]lmf2txt/LMF_IO.cpp
// Function: LMF_IO::OpenNonCoboldFile()
bool LMF_IO::OpenNonCoboldFile(void)
/////////////////////////////////////////////////////////////////
{
	input_lmf->seek(0);

	if (skip_header) {
		DAQ_ID = DAQ_ID_RAW32BIT;
		data_format_in_userheader = 10;
		return true;
	}

	if (DAQ_ID == DAQ_ID_RAW32BIT) return true;

	DAQ_ID = DAQ_ID_SIMPLE;

	*input_lmf >> SIMPLE_DAQ_ID_Orignial;
	unsigned tempi;
	*input_lmf >> tempi; uint64_Numberofevents = tempi;
	*input_lmf >> data_format_in_userheader;

	User_header_size = 3*sizeof(__int32);
	Headersize = 0;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x2b18(%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2440
movq -0x20(%rbp), %rax
testb $0x1, 0x12e4(%rax)
je 0x4152
movq -0x20(%rbp), %rax
movl $0x64, 0x288(%rax)
movl $0xa, 0x290(%rax)
movb $0x1, -0x1(%rbp)
jmp 0x41d7
movq -0x20(%rbp), %rax
cmpl $0x64, 0x288(%rax)
jne 0x4165
movb $0x1, -0x1(%rbp)
jmp 0x41d7
movq -0x20(%rbp), %rsi
movl $0x65, 0x288(%rsi)
movq 0x2b18(%rsi), %rdi
addq $0x27c, %rsi            # imm = 0x27C
callq 0x1cb80
movq -0x20(%rbp), %rax
movq 0x2b18(%rax), %rdi
leaq -0x14(%rbp), %rsi
callq 0x1cb80
movq -0x20(%rbp), %rsi
movl -0x14(%rbp), %eax
movq %rax, 0x268(%rsi)
movq 0x2b18(%rsi), %rdi
addq $0x290, %rsi            # imm = 0x290
callq 0x1cf60
movq -0x20(%rbp), %rax
movl $0xc, 0x29c(%rax)
movl $0x0, 0x298(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: NichtJens[P]lmf2txt/LMF_IO.cpp
// Function: LMF_IO::ReadfADC8Header()
__int32	LMF_IO::ReadfADC8Header()
/////////////////////////////////////////////////////////////////
{
	__int32	byte_counter = 0;

	*input_lmf >> frequency;	byte_counter += sizeof(double);			// frequency is always 4th value
	*input_lmf >> IOaddress;	byte_counter += sizeof(__int32);		// IO address (parameter 1) always 5th value
	*input_lmf >> timestamp_format;	byte_counter += sizeof(__int32);	// TimeInfo (parameter 2) always 6th value  (0,1,2)*32Bit

	*input_lmf >> DAQ_info_Length;	byte_counter += sizeof(__int32);	// Length of DAQInfo always 7th value
	__int8 * __int8_temp = new __int8[DAQ_info_Length+1];
	input_lmf->read(__int8_temp,DAQ_info_Length);	byte_counter += DAQ_info_Length;  // DAQInfo always 8th value
	__int8_temp[DAQ_info_Length] = 0;
	DAQ_info = __int8_temp;
	delete[] __int8_temp; __int8_temp = 0;

	*input_lmf >> LMF_Version; byte_counter += sizeof(__int32);
	
	if (LMF_Version == 10) byte_counter += ReadfADC8_header_LMFversion10();
	if (LMF_Version == 9)  byte_counter += ReadfADC8_header_LMFversion9();

	return byte_counter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movl $0x0, -0xc(%rbp)
movq 0x2b18(%rsi), %rdi
addq $0x12c8, %rsi           # imm = 0x12C8
callq 0x1d1f0
movq -0x28(%rbp), %rsi
movslq -0xc(%rbp), %rax
addq $0x8, %rax
movl %eax, -0xc(%rbp)
movq 0x2b18(%rsi), %rdi
addq $0x2a4, %rsi            # imm = 0x2A4
callq 0x1cf60
movq -0x28(%rbp), %rsi
movslq -0xc(%rbp), %rax
addq $0x4, %rax
movl %eax, -0xc(%rbp)
movq 0x2b18(%rsi), %rdi
addq $0x2a8, %rsi            # imm = 0x2A8
callq 0x1cb80
movq -0x28(%rbp), %rsi
movslq -0xc(%rbp), %rax
addq $0x4, %rax
movl %eax, -0xc(%rbp)
movq 0x2b18(%rsi), %rdi
addq $0x129c, %rsi           # imm = 0x129C
callq 0x1cf60
movq -0x28(%rbp), %rax
movslq -0xc(%rbp), %rcx
addq $0x4, %rcx
movl %ecx, -0xc(%rbp)
movl 0x129c(%rax), %eax
addl $0x1, %eax
movslq %eax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x2b18(%rax), %rdi
movq -0x18(%rbp), %rsi
movl 0x129c(%rax), %edx
callq 0x1cbe0
movq -0x28(%rbp), %rdi
movl 0x129c(%rdi), %eax
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movslq 0x129c(%rdi), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rsi
addq $0xa0, %rdi
callq 0x2250
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8d6b
movq -0x20(%rbp), %rdi
callq 0x2240
movq -0x28(%rbp), %rsi
movq $0x0, -0x18(%rbp)
movq 0x2b18(%rsi), %rdi
addq $0x12a4, %rsi           # imm = 0x12A4
callq 0x1cf60
movq -0x28(%rbp), %rax
movslq -0xc(%rbp), %rcx
addq $0x4, %rcx
movl %ecx, -0xc(%rbp)
cmpl $0xa, 0x12a4(%rax)
jne 0x8db1
movq -0x28(%rbp), %rdi
callq 0xc090
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movq -0x28(%rbp), %rax
cmpl $0x9, 0x12a4(%rax)
jne 0x8dcd
movq -0x28(%rbp), %rdi
callq 0xb5a0
addl -0xc(%rbp), %eax
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: NichtJens[P]lmf2txt/LMF_IO.cpp
// Function: LMF_IO::WriteNextfADC8Signal(fADC8_signal_info_struct*, unsigned int*)
bool LMF_IO::WriteNextfADC8Signal(fADC8_signal_info_struct* signal_info, unsigned __int32 * ui32buffer)
/////////////////////////////////////////////////////////////////
{
	if (!output_lmf || !OutputFileIsOpen) {
		errorflag = 10;
		return false;
	}
	if (fADC8.at_least_1_signal_was_written) *output_lmf << __int32(0);

	output_lmf->write((char*)(signal_info),sizeof(fADC8_signal_info_struct));

	if (signal_info->signal_type != 8) {
		output_lmf->write((char*)ui32buffer, signal_info->signallength_including_header_in_32bit_words*4);
	}

	fADC8.at_least_1_signal_was_written = true;
	
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x2b20(%rax)
je 0xb443
movq -0x28(%rbp), %rax
testb $0x1, 0x2b29(%rax)
jne 0xb457
movq -0x28(%rbp), %rax
movl $0xa, 0x12e0(%rax)
movb $0x0, -0x1(%rbp)
jmp 0xb4c9
movq -0x28(%rbp), %rax
testb $0x1, 0x1a78(%rax)
je 0xb476
movq -0x28(%rbp), %rax
movq 0x2b20(%rax), %rdi
xorl %esi, %esi
callq 0x1d170
movq -0x28(%rbp), %rax
movq 0x2b20(%rax), %rdi
movq -0x18(%rbp), %rsi
movl $0x38, %edx
callq 0x1cd10
movq -0x18(%rbp), %rax
movsbl 0x18(%rax), %eax
cmpl $0x8, %eax
je 0xb4ba
movq -0x28(%rbp), %rax
movq 0x2b20(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rax
movl 0x28(%rax), %edx
shll $0x2, %edx
callq 0x1cd10
movq -0x28(%rbp), %rax
movb $0x1, 0x1a78(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: NichtJens[P]lmf2txt/LMF_IO.cpp
// Function: LMF_IO::WritefADC8EndGroupMarker()
bool LMF_IO::WritefADC8EndGroupMarker()
/////////////////////////////////////////////////////////////////
{
	if (fADC8.at_least_1_signal_was_written) *output_lmf << __int32(12345678);

	if (fADC8.bReadCustomData) {
		*output_lmf << number_of_bytes_in_PostEventData;
		for (__int32 i=0;i<number_of_bytes_in_PostEventData;i++) {
			*output_lmf << ui8_PostEventData[i];
		}
	}

	fADC8.at_least_1_signal_was_written = false;
	++uint64_number_of_written_events;

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, 0x1a78(%rax)
je 0xb512
movq -0x18(%rbp), %rax
movq 0x2b20(%rax), %rdi
movl $0xbc614e, %esi         # imm = 0xBC614E
callq 0x1d170
movq -0x18(%rbp), %rax
testb $0x1, 0x1854(%rax)
je 0xb574
movq -0x18(%rbp), %rax
movq 0x2b20(%rax), %rdi
movl 0x1280(%rax), %esi
callq 0x1d170
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x1280(%rcx), %eax
jge 0xb572
movq -0x18(%rbp), %rax
movq 0x2b20(%rax), %rdi
movslq -0xc(%rbp), %rcx
movzbl 0x2e0(%rax,%rcx), %esi
callq 0x1cc60
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xb53c
jmp 0xb574
movq -0x18(%rbp), %rax
movb $0x0, 0x1a78(%rax)
movq 0x2b10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x2b10(%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: NichtJens[P]lmf2txt/LMF_IO.cpp
// Function: LMF_IO::WriteEventHeader(unsigned long long, unsigned int*)
void LMF_IO::WriteEventHeader(unsigned __int64 timestamp, unsigned __int32 cnt[])
/////////////////////////////////////////////////////////////////
{
	unsigned __int64 HeaderLength = 0;
	// EventLength information in 64Bit
	if (DAQVersion_output >= 20080000 || data_format_in_userheader_output == LM_USERDEF) {
		HeaderLength = timestamp_format_output + 1 + number_of_channels_output;	// +1 for HeaderLength itself

		HeaderLength = timestamp_format_output*sizeof(__int32) + 2*sizeof(__int64);	// +2 for HeaderLength itself, +2 for EventCounter (size in __int32)
		for(__int32 iCount=0;iCount<number_of_channels_output;++iCount) HeaderLength += cnt[iCount]*sizeof(__int32);
		HeaderLength += number_of_channels_output*sizeof(__int16);
#ifdef __linux__
		HeaderLength = (HeaderLength & 0x00ffffffffffffffLL) | 0xff00000000000000LL;	// set 0xff in bits 63..56 as EventMarker
#else
		HeaderLength = (HeaderLength & 0x00ffffffffffffff) | 0xff00000000000000;	// set 0xff in bits 63..56 as EventMarker
#endif
		*output_lmf << HeaderLength;
		*output_lmf << uint64_number_of_written_events; 
	}

	myLARGE_INTEGER LARGE_Timestamp;
	LARGE_Timestamp.QuadPart = timestamp;

	if (timestamp_format_output > 0) {
		*output_lmf << LARGE_Timestamp.LowPart;
		if (timestamp_format_output == 2) *output_lmf << LARGE_Timestamp.HighPart;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x20(%rbp)
cmpl $0x1326580, 0x284(%rax) # imm = 0x1326580
jae 0x14631
movq -0x38(%rbp), %rax
cmpl $-0x1, 0x294(%rax)
jne 0x146f0
movq -0x38(%rbp), %rax
movl 0x2ac(%rax), %ecx
addl $0x1, %ecx
addl 0x2c4(%rax), %ecx
movl %ecx, %ecx
movq %rcx, -0x20(%rbp)
movl 0x2ac(%rax), %eax
shlq $0x2, %rax
addq $0x10, %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movq -0x38(%rbp), %rcx
movl -0x24(%rbp), %eax
cmpl 0x2c4(%rcx), %eax
jge 0x14694
movq -0x18(%rbp), %rax
movslq -0x24(%rbp), %rcx
movl (%rax,%rcx,4), %eax
shlq $0x2, %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x14663
movq -0x38(%rbp), %rax
movslq 0x2c4(%rax), %rcx
shlq %rcx
addq -0x20(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movabsq $0xffffffffffffff, %rcx # imm = 0xFFFFFFFFFFFFFF
andq -0x20(%rbp), %rcx
movabsq $-0x100000000000000, %rdx # imm = 0xFF00000000000000
orq %rdx, %rcx
movq %rcx, -0x20(%rbp)
movq 0x2b20(%rax), %rdi
movq -0x20(%rbp), %rsi
callq 0x1cce0
movq -0x38(%rbp), %rax
movq 0x2b20(%rax), %rdi
movq 0x2b10(%rax), %rsi
callq 0x1cce0
movq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
cmpl $0x0, 0x2ac(%rax)
jbe 0x1473a
movq -0x38(%rbp), %rax
movq 0x2b20(%rax), %rdi
movl -0x30(%rbp), %esi
callq 0x1caf0
movq -0x38(%rbp), %rax
cmpl $0x2, 0x2ac(%rax)
jne 0x14738
movq -0x38(%rbp), %rax
movq 0x2b20(%rax), %rdi
movl -0x2c(%rbp), %esi
callq 0x1d170
jmp 0x1473a
addq $0x40, %rsp
popq %rbp
retq
// File: NichtJens[P]lmf2txt/LMF_IO.cpp
// Function: LMF_IO::WriteTDCData(double, unsigned int*, int*)
void LMF_IO::WriteTDCData(double timestamp, unsigned __int32 cnt[], __int32 *i32TDC)
/////////////////////////////////////////////////////////////////
{
	if (!output_lmf|| !OutputFileIsOpen) {
		errorflag = 10;
		return;
	}

	unsigned __int64 new_timestamp = (unsigned __int64)(timestamp * frequency + 0.001);

	WriteTDCData(new_timestamp, cnt, i32TDC);

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x2b20(%rax)
je 0x151c8
movq -0x30(%rbp), %rax
testb $0x1, 0x2b29(%rax)
jne 0x151d8
movq -0x30(%rbp), %rax
movl $0xa, 0x12e0(%rax)
jmp 0x15234
movq -0x30(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd 0x12c8(%rdi), %xmm1
mulsd %xmm1, %xmm0
movsd 0x9e4b(%rip), %xmm1     # 0x1f040
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x9e38(%rip), %xmm1     # 0x1f048
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x14740
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: NichtJens[P]lmf2txt/LMF_IO.cpp
// Function: LMF_IO::WriteTDCData(double, unsigned int*, double*)
void LMF_IO::WriteTDCData(double timestamp, unsigned __int32 cnt[], double *dtdc)
/////////////////////////////////////////////////////////////////
{
	if (!output_lmf || !OutputFileIsOpen) {
		errorflag = 10;
		return;
	}
	unsigned __int64 new_timestamp = (unsigned __int64)(timestamp * frequency + 0.001);

	WriteTDCData(new_timestamp, cnt, dtdc);

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x2b20(%rax)
je 0x15d68
movq -0x30(%rbp), %rax
testb $0x1, 0x2b29(%rax)
jne 0x15d78
movq -0x30(%rbp), %rax
movl $0xa, 0x12e0(%rax)
jmp 0x15dd4
movq -0x30(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd 0x12c8(%rdi), %xmm1
mulsd %xmm1, %xmm0
movsd 0x92ab(%rip), %xmm1     # 0x1f040
addsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x9298(%rip), %xmm1     # 0x1f048
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x15240
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: NichtJens[P]lmf2txt/LMF_IO.cpp
// Function: LMF_IO::WriteTDCData(double, unsigned int*, unsigned short*)
void LMF_IO::WriteTDCData(double timestamp, unsigned __int32 cnt[], unsigned __int16 * us16TDC)
/////////////////////////////////////////////////////////////////
{
	if (!output_lmf || !OutputFileIsOpen) {
		errorflag = 10;
		return;
	}
	unsigned __int64 new_timestamp = (unsigned __int64)(timestamp * frequency);

	WriteTDCData(new_timestamp, cnt, us16TDC);

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, 0x2b20(%rax)
je 0x16828
movq -0x30(%rbp), %rax
testb $0x1, 0x2b29(%rax)
jne 0x16838
movq -0x30(%rbp), %rax
movl $0xa, 0x12e0(%rax)
jmp 0x16888
movq -0x30(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
movsd 0x12c8(%rdi), %xmm1
mulsd %xmm1, %xmm0
movaps %xmm0, %xmm1
cvttsd2si %xmm1, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
movsd 0x87e4(%rip), %xmm1     # 0x1f048
subsd %xmm1, %xmm0
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
callq 0x15de0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: NichtJens[P]lmf2txt/LMF_IO.cpp
// Function: LMF_IO::Read_TDC8HP_raw_format(unsigned long long&)
bool LMF_IO::Read_TDC8HP_raw_format(unsigned __int64 &ui64TDC8HP_AbsoluteTimeStamp_)
/////////////////////////////////////////////////////////////////
{
	__int32 count;
	*input_lmf >> count;
	if (input_lmf->error) return false;
	if (!count) return false;
	if (ui32buffer_size < count) {
		if (ui32buffer) {delete[] ui32buffer; ui32buffer = 0;}
		ui32buffer_size = count + 5000;
		ui32buffer = new unsigned __int32[ui32buffer_size];
	}
	input_lmf->read(this->ui32buffer,count*sizeof(__int32));
	if (input_lmf->error) return false;
	if (!PCIGetTDC_TDC8HP_25psGroupMode(ui64TDC8HP_AbsoluteTimeStamp_, count, this->ui32buffer)) return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq 0x2b18(%rax), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x1cf60
movq -0x28(%rbp), %rax
movq 0x2b18(%rax), %rax
cmpl $0x0, 0x8(%rax)
je 0x16f32
movb $0x0, -0x1(%rbp)
jmp 0x17036
cmpl $0x0, -0x1c(%rbp)
jne 0x16f41
movb $0x0, -0x1(%rbp)
jmp 0x17036
movq -0x28(%rbp), %rax
movl 0x2b38(%rax), %eax
cmpl -0x1c(%rbp), %eax
jge 0x16fd8
movq -0x28(%rbp), %rax
cmpq $0x0, 0x2b30(%rax)
je 0x16f8f
movq -0x28(%rbp), %rax
movq 0x2b30(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x16f80
movq -0x30(%rbp), %rdi
callq 0x2240
movq -0x28(%rbp), %rax
movq $0x0, 0x2b30(%rax)
movq -0x28(%rbp), %rax
movl -0x1c(%rbp), %ecx
addl $0x1388, %ecx           # imm = 0x1388
movl %ecx, 0x2b38(%rax)
movslq 0x2b38(%rax), %rax
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x2b30(%rax)
movq -0x28(%rbp), %rax
movq 0x2b18(%rax), %rdi
movq 0x2b30(%rax), %rsi
movslq -0x1c(%rbp), %rax
shlq $0x2, %rax
movl %eax, %edx
callq 0x1d250
movq -0x28(%rbp), %rax
movq 0x2b18(%rax), %rax
cmpl $0x0, 0x8(%rax)
je 0x17010
movb $0x0, -0x1(%rbp)
jmp 0x17036
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x1c(%rbp), %edx
movq 0x2b30(%rdi), %rcx
callq 0x16ad0
cmpl $0x0, %eax
jne 0x17032
movb $0x0, -0x1(%rbp)
jmp 0x17036
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: NichtJens[P]lmf2txt/LMF_IO.cpp
// Function: LMF_IO::GetNumberOfHitsArray(unsigned int*)
void LMF_IO::GetNumberOfHitsArray(unsigned __int32 cnt[]) {
/////////////////////////////////////////////////////////////////
	__int32 i;

	if (must_read_first) {
		if (!ReadNextEvent()) return;
	}

	for (i=0;i<num_channels;++i) cnt[i] = (number_of_hits[i] < (unsigned __int32)(num_ions)) ? number_of_hits[i] : num_ions;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x2b4c(%rax)
je 0x19e22
movq -0x20(%rbp), %rdi
callq 0x17050
testb $0x1, %al
jne 0x19e20
jmp 0x19e8f
jmp 0x19e22
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x2b70(%rcx), %eax
jge 0x19e8f
movq -0x20(%rbp), %rcx
movq 0x2b50(%rcx), %rax
movslq -0x14(%rbp), %rdx
movl (%rax,%rdx,4), %eax
cmpl 0x2b74(%rcx), %eax
jae 0x19e69
movq -0x20(%rbp), %rax
movq 0x2b50(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
jmp 0x19e76
movq -0x20(%rbp), %rax
movl 0x2b74(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19e29
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: NichtJens[P]lmf2txt/LMF_IO.cpp
// Function: LMF_IO::GetNumberOfHitsArray(int*)
void LMF_IO::GetNumberOfHitsArray(__int32 cnt[]) {
/////////////////////////////////////////////////////////////////
	__int32 i;

	if (must_read_first) {
		if (!ReadNextEvent()) return;
	}

	for (i=0;i<num_channels;++i) cnt[i] = (number_of_hits[i] < (unsigned __int32)(num_ions)) ? number_of_hits[i] : num_ions;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
testb $0x1, 0x2b4c(%rax)
je 0x19ed2
movq -0x20(%rbp), %rdi
callq 0x17050
testb $0x1, %al
jne 0x19ed0
jmp 0x19f3f
jmp 0x19ed2
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x2b70(%rcx), %eax
jge 0x19f3f
movq -0x20(%rbp), %rcx
movq 0x2b50(%rcx), %rax
movslq -0x14(%rbp), %rdx
movl (%rax,%rdx,4), %eax
cmpl 0x2b74(%rcx), %eax
jae 0x19f19
movq -0x20(%rbp), %rax
movq 0x2b50(%rax), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x24(%rbp)
jmp 0x19f26
movq -0x20(%rbp), %rax
movl 0x2b74(%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %edx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x19ed9
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: NichtJens[P]lmf2txt/./LMF_IO.h
// Function: MyFILE::read(char*, int)
void read(__int8* string,__int32 length_bytes) {
		unsigned __int32 read_bytes = (unsigned __int32)(fread(string,1,length_bytes,file));
		if (read_bytes != (unsigned)length_bytes) {
			error = 1;
			if (feof(file)) eof = true;
		}
		position += length_bytes;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movq (%rax), %rcx
movl $0x1, %esi
callq 0x22a0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x1cc3d
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movq (%rax), %rdi
callq 0x22c0
cmpl $0x0, %eax
je 0x1cc3b
movq -0x20(%rbp), %rax
movb $0x1, 0xc(%rax)
jmp 0x1cc3d
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: NichtJens[P]lmf2txt/./LMF_IO.h
// Function: MyFILE::open(char*)
bool open(__int8* name) {
		if (file) {error = 1; return false;}
		eof = false;
		if (mode_reading) {
			file = fopen(name,"rb");
			if (!file) {error = 1; return false;}
			_fseeki64(file,  (unsigned __int64)0, SEEK_END);
			filesize = _ftelli64(file);
			_fseeki64(file,  (unsigned __int64)0, SEEK_SET);
		} else file = fopen(name,"wb");
		if (file) return true; else {error = 1; return false;}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x1d012
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x1d0c6
movq -0x20(%rbp), %rax
movb $0x0, 0xc(%rax)
testb $0x1, 0x18(%rax)
je 0x1d08d
movq -0x18(%rbp), %rdi
leaq 0x23ac(%rip), %rsi      # 0x1f3d7
callq 0x2200
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, (%rax)
jne 0x1d051
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x1d0c6
movq -0x20(%rbp), %rax
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x20e0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x2220
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq (%rax), %rdi
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x20e0
jmp 0x1d0a7
movq -0x18(%rbp), %rdi
leaq 0x2342(%rip), %rsi      # 0x1f3da
callq 0x2200
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1d0b7
movb $0x1, -0x1(%rbp)
jmp 0x1d0c6
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: NichtJens[P]lmf2txt/./LMF_IO.h
// Function: MyFILE::read(unsigned int*, int)
void read(unsigned __int32 * dest,__int32 length_bytes) {
		unsigned __int32 read_bytes = (unsigned __int32)(fread(dest,1,length_bytes,file));
		if (read_bytes != (unsigned)length_bytes) {
			error = 1;
			if (feof(file)) eof = true;
		}
		position += length_bytes;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rdx
movq (%rax), %rcx
movl $0x1, %esi
callq 0x22a0
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0x1d2ad
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movq (%rax), %rdi
callq 0x22c0
cmpl $0x0, %eax
je 0x1d2ab
movq -0x20(%rbp), %rax
movb $0x1, 0xc(%rax)
jmp 0x1d2ad
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
addq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: godofecht[P]Slow-Feature-Analysis/./NN.cpp
// Function: Neuron::Neuron(unsigned int, unsigned int)
Neuron::Neuron(unsigned numOutputs, unsigned myIndex)
{
	for (unsigned c = 0; c < numOutputs; ++c) {

		m_outputWeights.push_back(connection());
		m_outputWeights[c].weight = ((rand() / double(RAND_MAX))*2.0f-1.0f);
		m_outputWeights[c].deltaweight = 0.0f;


	}

	m_myIndex = myIndex;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x10, %rdi
movq %rdi, -0x48(%rbp)
callq 0x3ec0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0x2648
movq -0x50(%rbp), %rdi
addq $0x10, %rdi
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
leaq -0x30(%rbp), %rsi
callq 0x3ee0
jmp 0x25c4
callq 0x2060
movq -0x50(%rbp), %rdi
cvtsi2sd %eax, %xmm0
movsd 0xba37(%rip), %xmm1     # 0xe010
divsd %xmm1, %xmm0
addsd %xmm0, %xmm0
movsd 0xba1f(%rip), %xmm1     # 0xe008
addsd %xmm1, %xmm0
movsd %xmm0, -0x58(%rbp)
addq $0x10, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3f10
movsd -0x58(%rbp), %xmm0
movq -0x50(%rbp), %rdi
movsd %xmm0, (%rax)
addq $0x10, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3f10
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x259e
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x3f30
jmp 0x2658
movq -0x50(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, 0x38(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x22f0
nopw %cs:(%rax,%rax)
// File: godofecht[P]Slow-Feature-Analysis/./NN.cpp
// Function: Neuron::feedForward(std::vector<Neuron, std::allocator<Neuron>>&)
void Neuron::feedForward(Layer &prevLayer)
{
	double sum = 0.0;
	for (unsigned n = 0; n < prevLayer.size(); ++n) {
		sum += prevLayer[n].getOutputVal() *
			prevLayer[n].m_outputWeights[m_myIndex].weight;
	}
	m_outputVal = sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3f90
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x2717
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x3fb0
movq %rax, %rdi
callq 0x2730
movsd %xmm0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x3fb0
movq %rax, %rdi
movq -0x28(%rbp), %rax
addq $0x10, %rdi
movl 0x38(%rax), %eax
movl %eax, %esi
callq 0x3f10
movsd -0x38(%rbp), %xmm0
movsd (%rax), %xmm2
movsd -0x18(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2697
movq -0x28(%rbp), %rax
movsd -0x18(%rbp), %xmm0
movsd %xmm0, 0x30(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: godofecht[P]Slow-Feature-Analysis/./Network.cpp
// Function: Network::UpdateWeights()
void Network::UpdateWeights()
{
	for (unsigned layerNum = 1; layerNum < m_layers.size(); layerNum++) {
		Layer& layer = m_layers[layerNum];
		Layer& prevLayer = m_layers[layerNum - 1];

		for (unsigned n = 0; n < prevLayer.size(); n++) {
			Neuron* neuron = &(prevLayer[n]);

			neuron->NaivelyUpdateWeights();
		}
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movq %rax, -0x40(%rbp)
callq 0x4230
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x2f2d
movq -0x38(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, %esi
callq 0x4260
movq -0x38(%rbp), %rdi
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x4260
movq %rax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x48(%rbp)
movq -0x20(%rbp), %rdi
callq 0x3f90
movq %rax, %rcx
movq -0x48(%rbp), %rax
cmpq %rcx, %rax
jae 0x2f1d
movq -0x20(%rbp), %rdi
movl -0x24(%rbp), %eax
movl %eax, %esi
callq 0x3fb0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2790
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2edb
jmp 0x2f1f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x2e8b
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)