// File: /workspace/github_cpp_makefile_star2_O3/UTSASRG[P]Guarder/./bibopheap.hh
// Function: BibopHeap::initialize()
void * initialize() {
		unsigned threadNum, bagNum;
		size_t lastUsableBagSize;

		BibopHeap::_cacheSize = BIBOP_CACHE_SIZE;
		BibopHeap::_overProvObjBufSize = OVER_PROV_OBJ_BUF_SZ;

		#ifdef BIBOP_BAG_SIZE
		#pragma message "BIBOP_BAG_SIZE in use: overrides randomized bag size"
		_bibopBagSize = BIBOP_BAG_SIZE;
		#else		// randomized bag size
		unsigned randPower = getRandomNumber() % (LOG2(MAX_RANDOM_BAG_SIZE / MIN_RANDOM_BAG_SIZE) + 1);
		_bibopBagSize = MIN_RANDOM_BAG_SIZE << randPower;
		#endif

		if(_bibopBagSize > LARGE_OBJECT_THRESHOLD) {
				lastUsableBagSize = LARGE_OBJECT_THRESHOLD;
		} else {
				lastUsableBagSize = _bibopBagSize;
		}
		_numUsableBags = LOG2(lastUsableBagSize) - LOG2(BIBOP_MIN_BLOCK_SIZE) + 1;
		if(_numUsableBags > BIBOP_NUM_BAGS) {
				_numUsableBags = BIBOP_NUM_BAGS;
		}
		_lastUsableBag = _numUsableBags - 1;

		assert(BIBOP_HEAP_SIZE > 0);

		BibopHeap::_bagShiftBits = LOG2(_bibopBagSize);
		_threadShiftBits = LOG2((_bibopBagSize * BIBOP_NUM_BAGS));
		BibopHeap::_bagMask = _bibopBagSize - 1;

		PRINF("_bibopBagSize=0x%lx, _bagShiftBits=%ld, sizeof(PerThreadBag)=%zu",
			_bibopBagSize, BibopHeap::_bagShiftBits, sizeof(PerThreadBag));
		PRINF("BIBOP_NUM_BAGS=%u, _numUsableBags=%u", BIBOP_NUM_BAGS, _numUsableBags);
		PRINF("sizeof(PerThreadBag)=%zu, sizeof(BibopObjCache)=%zu, sizeof(BibopFreeCache)=%zu",
				sizeof(PerThreadBag), sizeof(BibopObjCache), sizeof(BibopFreeCache));

		// Bag size cannot be smaller than the large object threshold.
		assert(_bibopBagSize >= LARGE_OBJECT_THRESHOLD);

		// Allocate the heap all at once.
		allocHeap(BIBOP_HEAP_SIZE);

    unsigned long numBagObjects;
    unsigned long numCumObjects = 0;
    size_t unusableHeapSpace = (BIBOP_NUM_BAGS - _numUsableBags) * _bibopBagSize;

    // Initialize each thread bag's free list, and other information
    for(threadNum = 0; threadNum < MAX_ALIVE_THREADS; threadNum++) {
      size_t classSize = BIBOP_MIN_BLOCK_SIZE;

      for(bagNum = 0; bagNum < _numUsableBags; bagNum++) {
        numBagObjects = _bibopBagSize / classSize;

        #ifdef ENABLE_GUARDPAGE
            // We must perform this >1 test or else we will underflow this value
            // for bags which have 0 objects in them. Also, the last usable bag
            // will only contain a single object, but it will not be reduced to
            // make room for a guard page, but rather the next bag (which is
            // unusable) will be converted entirely into a guard page. 
            if(numBagObjects > 1) {
                if(classSize < PageSize) {
                    numBagObjects -= (PageSize / classSize);
                } else {
                    numBagObjects--;
                }
            }
        #endif

        // Update the following values; 
        numCumObjects += numBagObjects;
        classSize <<= 1;
      }
    }

		_shadowObjectInfoSizeShiftBits = LOG2(sizeof(shadowObjectInfo));
    _numBagsPerSubHeapMask = BIBOP_NUM_BAGS - 1;
    size_t numObjectsInHeap = numCumObjects;

		//unsigned freeCacheDivisor = 1;		// no reduction to deallocation buffer size
		unsigned freeCacheDivisor = 16;
		unsigned long numFreeAreaObjects = numObjectsInHeap / freeCacheDivisor;

		allocShadowMem(numObjectsInHeap);
		allocFreeArea(numFreeAreaObjects);
		allocGlobalFreeCache(numObjectsInHeap);

		// Allocate memory for use by each bag's object cache
		size_t objectCacheSize = OVER_PROV_OBJ_BUF_SZ + BIBOP_CACHE_SIZE;
		size_t objectCacheAreaSize = sizeof(uintptr_t) * objectCacheSize * BIBOP_NUM_BAGS * MAX_ALIVE_THREADS;
		uintptr_t * objectCacheStart = (uintptr_t *)MM::mmapAllocatePrivate(objectCacheAreaSize);
		uintptr_t * currentObjectCachePos = objectCacheStart;

		uintptr_t _uHeapStart = (uintptr_t)_heapBegin;
		uintptr_t _uShadowMemStart = (uintptr_t)_shadowMemBegin;
		uintptr_t _uFreeAreaBegin = (uintptr_t)_freeAreaBegin;
		unsigned long offsetShadowMem = 0;
		unsigned long offsetFreeArea = 0;
    unsigned long offsetBag = 0;

		// Initialize each thread bag's free list, and other information
		for(threadNum = 0; threadNum < MAX_ALIVE_THREADS; threadNum++) {
			PerThreadMap& curMap = _threadMap[threadNum];
			curMap.initialize(_bagShiftBits);

			for(bagNum = 0; bagNum < _numUsableBags; bagNum++) {
				unsigned shiftBits = curMap.getClassSize(bagNum);
				size_t classSize = (1U << shiftBits);
				if(threadNum == 0)
						PRDBG("bag %d classSize = %zu, shiftBits = %u", bagNum, classSize, shiftBits);
				PerThreadBag * curBag = &_threadBag[threadNum][bagNum];
				
				curBag->cache = &_bagCache[threadNum][bagNum];
				curBag->freeCache = &_freeCache[threadNum][bagNum];
				curBag->classSize = classSize;
				curBag->classMask = classSize - 1;
				curBag->shiftBits = shiftBits;
				curBag->bagNum = bagNum;
				curBag->threadIndex = threadNum; 

				numBagObjects = _bibopBagSize / classSize;
				uintptr_t bagStart = _uHeapStart + offsetBag;
				uintptr_t bagEnd = bagStart + _bibopBagSize;
				uintptr_t bagShadowMemStart = _uShadowMemStart + offsetShadowMem;
				uintptr_t bagFreeAreaStart = _uFreeAreaBegin + offsetFreeArea;

				//PRDBG("thread %d bag %d: heap start @ 0x%lx, shadow mem @ 0x%lx, free cache @ 0x%lx, Cache=%p, FreeCache=%p",
				//				threadNum, bagNum, bagStart, bagShadowMemStart, bagFreeAreaStart, curBag->cache, curBag->freeCache);

				#ifdef ENABLE_GUARDPAGE
						size_t guardsize = classSize > PAGESIZE ? classSize : PAGESIZE;
						size_t guardoffset = guardsize;
						if(bagNum == _lastUsableBag) {
								// If this bag can only fit one object,
								// forego the use of a guard object at the end of the bag.
								if(_bibopBagSize == lastUsableBagSize) {
										guardoffset = 0;
										guardsize = 0;
								}
								// Add to the guard size the amount of unusable space left on the heap.
								guardsize += (BIBOP_NUM_BAGS - LOG2(lastUsableBagSize) + LOG2(BIBOP_MIN_BLOCK_SIZE) - 1) * _bibopBagSize;

								//PRDBG("last usable bag: lastUsableBagSize=%zu, _bibopBagSize=%zu, guardsize=%zu, guardoffset=%zu",
								//		lastUsableBagSize, _bibopBagSize, guardsize, guardoffset);
						}
						curBag->guardsize = guardsize;
						curBag->guardoffset = guardoffset;
				#else
						size_t guardoffset = 0;
				#endif

				#ifdef ENABLE_GUARDPAGE
						// We must perform this >1 test or else we will underflow this value
						// for bags which have 0 objects in them. Also, the last usable bag
						// will only contain a single object, but it will not be reduced to
						// make room for a guard page, but rather the next bag (which is
						// unusable) will be converted entirely into a guard page. 
						if(numBagObjects > 1) {
								if(classSize < PageSize) {
										numBagObjects -= (PageSize / classSize);
								} else {
										numBagObjects--;
								}
						}
				#endif

				unsigned long bagFreeCacheCapacity = numBagObjects / freeCacheDivisor;

				curBag->startShadowMem = bagShadowMemStart;
				curBag->cache->initialize(bagStart, bagEnd, currentObjectCachePos, curBag->freeCache, shiftBits);
				// In order to prevent false sharing, do not utilize a global
				// free buffer for size classes smaller than the cache line size
				if(classSize >= CACHE_LINE_SIZE) {
						curBag->freeCache->initialize(bagFreeAreaStart, bagFreeCacheCapacity, NULL);
				} else {
						curBag->freeCache->initialize(bagFreeAreaStart, bagFreeCacheCapacity, &_globalFreeCache[shiftBits]);
				}

				currentObjectCachePos += objectCacheSize;

				curBag->startOffset = offsetBag;
				curBag->lastObjectIndex = numBagObjects - 1;

				// Update loop variables
				offsetBag += _bibopBagSize;
				offsetShadowMem += numBagObjects;
				offsetFreeArea += bagFreeCacheCapacity * sizeof(uintptr_t);
				}
			offsetBag += unusableHeapSpace;
		}

		#ifndef NDEBUG
		// DEBUG
		uintptr_t _uFreeAreaEnd = _uFreeAreaBegin + (numFreeAreaObjects * sizeof(uintptr_t));
		assert((_uFreeAreaBegin + offsetFreeArea) <= _uFreeAreaEnd);
		#endif

		_numBagsPerSubHeapMask = BIBOP_NUM_BAGS - 1;

		PRINF("_heapBegin=%p, _heapEnd=%p", _heapBegin, _heapEnd);
		PRINF("_shadowMemBegin=%p, _shadowMemEnd=%p, _freeAreaBegin=%p, _freeAreaEnd=%p",
						_shadowMemBegin, _shadowMemEnd, _freeAreaBegin, _freeAreaEnd);

		return _heapBegin;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rbp
movq 0x79d3(%rip), %rax      # 0xcf20
movl 0x8(%rax), %eax
movq 0x7a19(%rip), %rcx      # 0xcf70
movl %eax, (%rcx)
shrl %eax
movq 0x7a36(%rip), %rcx      # 0xcf98
movl %eax, (%rcx)
callq 0x40a0
movabsq $0x1ffffffff, %rax      # imm = 0x1FFFFFFFF
leaq 0x1(%rax), %rcx
movq 0x7a2a(%rip), %r14      # 0xcfa8
movq %rcx, (%r14)
movabsq $0xf00000010, %rcx      # imm = 0xF00000010
movq %rcx, 0x30(%rbp)
movq 0x79d2(%rip), %r13      # 0xcf68
movq $0x21, (%r13)
movl $0x25, 0x38(%rbp)
movq 0x7a3c(%rip), %rcx      # 0xcfe8
movq %rax, (%rcx)
callq 0x41e0
movq %rax, %r15
callq 0x4250
movq %rax, %rbx
subq $0x8, %rsp
movl $0x80, %r10d
leaq 0x40a6(%rip), %rdx      # 0x9676
leaq 0x3fb3(%rip), %r8       # 0x958a
xorl %r12d, %r12d
movl $0x1000, %esi           # imm = 0x1000
movq %r15, %rdi
movq %rax, %rcx
movl $0x2f6, %r9d            # imm = 0x2F6
xorl %eax, %eax
pushq %r10
pushq (%r13)
pushq (%r14)
callq 0x4490
addq $0x20, %rsp
callq 0x41e0
movq %rax, %r15
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0x40f0
callq 0x41e0
movl 0x30(%rbp), %r10d
leaq 0x40a4(%rip), %rdx      # 0x96d8
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdi
movq %rbx, %rcx
leaq 0x3f44(%rip), %r8       # 0x958a
movl $0x2f7, %r9d            # imm = 0x2F7
xorl %eax, %eax
pushq %r10
pushq $0x10
callq 0x4490
addq $0x10, %rsp
callq 0x41e0
movq %rax, %r15
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %r15, %rsi
movq %rax, %rdx
callq 0x40f0
callq 0x41e0
subq $0x8, %rsp
leaq 0x408e(%rip), %rdx      # 0x971e
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdi
movq %rbx, 0x28(%rsp)
movq %rbx, %rcx
movq %r14, %rbx
leaq 0x3ee0(%rip), %r8       # 0x958a
movl $0x2f9, %r9d            # imm = 0x2F9
xorl %eax, %eax
pushq $0x40
movl $0x80, %r10d
pushq %r10
pushq %r10
callq 0x4490
addq $0x20, %rsp
callq 0x41e0
movq %rax, %r14
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %r14, %rsi
movq %rax, %rdx
callq 0x40f0
movq (%rbx), %r14
cmpq $0x7ffff, %r14          # imm = 0x7FFFF
jbe 0x5c45
shlq $0xb, %r14
xorl %edi, %edi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x43c0
movq %rax, (%rbp)
leaq (%rax,%r14), %rcx
movq %rcx, 0x8(%rbp)
movq %rax, %rdi
movq %r14, %rsi
movl $0xf, %edx
callq 0x4360
movl 0x30(%rbp), %esi
movl $0x10, %ecx
subl %esi, %ecx
movq (%rbx), %rbx
xorl %r14d, %r14d
testl %esi, %esi
je 0x575c
movl $0x10, %edi
movl %esi, %r8d
movq %rbx, %rax
xorl %edx, %edx
divq %rdi
addq %rax, %r14
addq %rdi, %rdi
decl %r8d
jne 0x5749
incl %r12d
cmpl $0x80, %r12d
jne 0x573d
movl %ecx, %eax
imulq %rax, %rbx
movl $0x0, 0x48(%rbp)
movq $0xf, 0x40(%rbp)
xorl %edi, %edi
movq %r14, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x43c0
movq %rax, 0x10(%rbp)
leaq (%rax,%r14), %rcx
movq %rcx, 0x18(%rbp)
movq %rax, %rdi
movq %r14, %rsi
movl $0xf, %edx
callq 0x4360
movq %r14, %r15
shrq $0x4, %r15
leaq (,%r15,8), %r12
xorl %edi, %edi
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x43c0
movq %rax, 0x20(%rbp)
leaq (%rax,%r15,8), %rcx
movq %rcx, 0x28(%rbp)
movq %rax, %rdi
movq %r12, 0x40(%rsp)
movq %r12, %rsi
movl $0xf, %edx
callq 0x4360
movq %rbp, %rdi
movl %r14d, %esi
callq 0x4480
movq 0x7723(%rip), %rax      # 0xcf20
movl 0x8(%rax), %eax
movl %eax, %r14d
shrl %r14d
addl %eax, %r14d
movq %r14, %rsi
shlq $0xe, %rsi
xorl %edi, %edi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
callq 0x43c0
movq %rax, %r10
movq (%rbp), %rax
movq %rax, 0x78(%rsp)
movq 0x10(%rbp), %rax
movq %rax, 0x70(%rsp)
movq 0x20(%rbp), %rax
movq %rax, 0x28(%rsp)
leaq 0x4c(%rbp), %rax
movq %rax, 0x48(%rsp)
leaq 0x41980(%rbp), %r15
leaq 0x81980(%rbp), %r13
leaq 0xa1980(%rbp), %rax
movq %rax, 0x68(%rsp)
leaq 0x6e(%rbp), %rax
movq %rax, 0x30(%rsp)
shlq $0x3, %r14
movq %r14, 0x80(%rsp)
xorl %eax, %eax
xorl %r9d, %r9d
xorl %edi, %edi
xorl %esi, %esi
movq %rbp, 0x88(%rsp)
movq %rbx, 0x50(%rsp)
movq %rsi, (%rsp)
movq %r9, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %r10, %r12
movq %rax, 0x18(%rsp)
imulq $0x32, %rax, %rdi
addq 0x48(%rsp), %rdi
movq 0x76b8(%rip), %rax      # 0xcf68
movl (%rax), %esi
callq 0x4350
cmpl $0x0, 0x30(%rbp)
movq %r15, 0x60(%rsp)
movq %r13, 0x58(%rsp)
je 0x5af6
movq %r15, %r14
movq %r13, %r8
xorl %r15d, %r15d
movq 0x76cd(%rip), %rdx      # 0xcfa8
movq %r12, %r10
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %r9
movq (%rsp), %rsi
movq 0x30(%rsp), %rax
movzbl (%rax,%r15), %r12d
movl $0x1, %ebx
movl %r12d, %ecx
shlq %cl, %rbx
movq 0x18(%rsp), %rax
testq %rax, %rax
movq %r10, 0x38(%rsp)
movq %rdi, 0x10(%rsp)
movq %r9, 0x8(%rsp)
jne 0x59a6
movq %rsi, %rbp
movq %r8, %r13
callq 0x41e0
subq $0x8, %rsp
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdi
leaq 0x3e7b(%rip), %rdx      # 0x97b7
movq 0x28(%rsp), %rcx
leaq 0x3c42(%rip), %r8       # 0x958a
movl $0x343, %r9d            # imm = 0x343
xorl %eax, %eax
pushq %r12
pushq %rbx
pushq %r15
callq 0x4490
addq $0x20, %rsp
callq 0x41e0
movq %rax, (%rsp)
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq (%rsp), %rsi
movq %rax, %rdx
callq 0x40f0
movq %r13, %r8
movq %rbp, %rsi
movq 0x8(%rsp), %r9
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %r10
movq 0x7602(%rip), %rdx      # 0xcfa8
movq %r14, -0x40000(%r14)
movq %r8, -0x3fff8(%r14)
movq %rbx, -0x3ffe0(%r14)
decq %rbx
movq %rbx, -0x3ffd8(%r14)
movl %r12d, -0x3ffd0(%r14)
movl %r15d, -0x3ffec(%r14)
movl %eax, -0x3ffe8(%r14)
movq (%rdx), %rdx
movq %rdx, %r13
movl %r12d, %ecx
shrq %cl, %r13
movq 0x78(%rsp), %rax
movq %rsi, (%rsp)
addq %rax, %rsi
addq %rsi, %rdx
movq 0x70(%rsp), %rax
addq %r9, %rax
movq 0x28(%rsp), %rcx
leaq (%rdi,%rcx), %rbp
movq %rax, -0x3ffc0(%r14)
movq %r13, %rbx
shrq $0x4, %rbx
movq %r14, %rdi
movq %r10, %rcx
movq %r8, 0x90(%rsp)
movl %r12d, %r9d
callq 0x44b0
movq -0x3fff8(%r14), %rax
leaq (,%rbx,8), %rcx
addq %rbp, %rcx
cmpb $0x6, %r12b
jb 0x5a63
movq %rbp, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rbp, 0x18(%rax)
movq %rbp, 0x20(%rax)
movq %rbx, 0x28(%rax)
shlq $0x3, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rax)
jmp 0x5a90
shll $0x7, %r12d
addq 0x68(%rsp), %r12
movq %rbp, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rbp, 0x18(%rax)
movq %rbp, 0x20(%rax)
movq %rbx, 0x28(%rax)
shlq $0x3, %rbx
movq $0x0, 0x38(%rax)
movq %r12, 0x30(%rax)
movq (%rsp), %rsi
movq %rsi, -0x3ffc8(%r14)
leal -0x1(%r13), %eax
movl %eax, -0x3fff0(%r14)
movq 0x74fb(%rip), %rdx      # 0xcfa8
addq (%rdx), %rsi
movq 0x8(%rsp), %r9
addq %r13, %r9
movq 0x10(%rsp), %rdi
addq %rbx, %rdi
incq %r15
movq 0x88(%rsp), %rbp
movl 0x30(%rbp), %eax
movq 0x90(%rsp), %r8
addq $0x40, %r8
subq $-0x80, %r14
movq 0x38(%rsp), %r10
addq 0x80(%rsp), %r10
cmpq %rax, %r15
jb 0x58ec
jmp 0x5b07
movq %r12, %r10
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %r9
movq (%rsp), %rsi
movq 0x50(%rsp), %rbx
addq %rbx, %rsi
movq 0x18(%rsp), %rax
incq %rax
addq $0x32, 0x30(%rsp)
movq 0x58(%rsp), %r13
addq $0x400, %r13            # imm = 0x400
movq 0x60(%rsp), %r15
addq $0x800, %r15            # imm = 0x800
cmpq $0x80, %rax
jne 0x588a
movq 0x40(%rsp), %rax
movq 0x28(%rsp), %rcx
addq %rcx, %rax
addq %rcx, %rdi
cmpq %rax, %rdi
ja 0x5c64
movq $0xf, 0x40(%rbp)
callq 0x41e0
movaps (%rbp), %xmm0
subq $0x10, %rsp
movups %xmm0, (%rsp)
leaq 0x3cb8(%rip), %rdx      # 0x9832
leaq 0x3a09(%rip), %r14      # 0x958a
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdi
movq 0x30(%rsp), %r15
movq %r15, %rcx
movq %r14, %r8
movl $0x39d, %r9d            # imm = 0x39D
xorl %eax, %eax
callq 0x4490
addq $0x10, %rsp
callq 0x41e0
movq %rax, %rbx
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x40f0
callq 0x41e0
movaps 0x10(%rbp), %xmm0
movaps 0x20(%rbp), %xmm1
subq $0x20, %rsp
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x3c83(%rip), %rdx      # 0x986e
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdi
movq %r15, %rcx
movq %r14, %r8
movl $0x39f, %r9d            # imm = 0x39F
xorl %eax, %eax
callq 0x4490
addq $0x20, %rsp
callq 0x41e0
movq %rax, %rbx
callq 0x41e0
movq %rax, %rdi
callq 0x4120
movl $0x2, %edi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x40f0
movq (%rbp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3b43(%rip), %rdi      # 0x978f
leaq 0x3937(%rip), %rsi      # 0x958a
leaq 0x39fe(%rip), %rcx      # 0x9658
movl $0x2fc, %edx            # imm = 0x2FC
callq 0x4200
leaq 0x3b93(%rip), %rdi      # 0x97fe
leaq 0x3918(%rip), %rsi      # 0x958a
leaq 0x39df(%rip), %rcx      # 0x9658
movl $0x398, %edx            # imm = 0x398
callq 0x4200
nop