// File: /workspace/github_c_makefile_star2_O0/gadget114514[P]fatfs-example/fatfs/source/ff.c
// Function: find_volume
static
FRESULT find_volume (	/* FR_OK(0): successful, !=0: any error occurred */
	const TCHAR** path,	/* Pointer to pointer to the path name (drive number) */
	FATFS** rfs,		/* Pointer to pointer to the found filesystem object */
	BYTE mode			/* !=0: Check write protection for write access */
)
{
	BYTE fmt, *pt;
	int vol;
	DSTATUS stat;
	DWORD bsect, fasize, tsect, sysect, nclst, szbfat, br[4];
	WORD nrsv;
	FATFS *fs;
	UINT i;


	/* Get logical drive number */
	*rfs = 0;
	vol = get_ldnumber(path);
	if (vol < 0) return FR_INVALID_DRIVE;

	/* Check if the filesystem object is valid or not */
	fs = FatFs[vol];					/* Get pointer to the filesystem object */
	if (!fs) return FR_NOT_ENABLED;		/* Is the filesystem object available? */
#if FF_FS_REENTRANT
	if (!lock_fs(fs)) return FR_TIMEOUT;	/* Lock the volume */
#endif
	*rfs = fs;							/* Return pointer to the filesystem object */

	mode &= (BYTE)~FA_READ;				/* Desired access mode, write access or not */
	if (fs->fs_type != 0) {				/* If the volume has been mounted */
		stat = disk_status(fs->pdrv);
		if (!(stat & STA_NOINIT)) {		/* and the physical drive is kept initialized */
			if (!FF_FS_READONLY && mode && (stat & STA_PROTECT)) {	/* Check write protection if needed */
				return FR_WRITE_PROTECTED;
			}
			return FR_OK;				/* The filesystem object is valid */
		}
	}

	/* The filesystem object is not valid. */
	/* Following code attempts to mount the volume. (analyze BPB and initialize the filesystem object) */

	fs->fs_type = 0;					/* Clear the filesystem object */
	fs->pdrv = LD2PD(vol);				/* Bind the logical drive and a physical drive */
	stat = disk_initialize(fs->pdrv);	/* Initialize the physical drive */
	if (stat & STA_NOINIT) { 			/* Check if the initialization succeeded */
		return FR_NOT_READY;			/* Failed to initialize due to no medium or hard error */
	}
	if (!FF_FS_READONLY && mode && (stat & STA_PROTECT)) { /* Check disk write protection if needed */
		return FR_WRITE_PROTECTED;
	}
#if FF_MAX_SS != FF_MIN_SS				/* Get sector size (multiple sector size cfg only) */
	if (disk_ioctl(fs->pdrv, GET_SECTOR_SIZE, &SS(fs)) != RES_OK) return FR_DISK_ERR;
	if (SS(fs) > FF_MAX_SS || SS(fs) < FF_MIN_SS || (SS(fs) & (SS(fs) - 1))) return FR_DISK_ERR;
#endif

	/* Find an FAT partition on the drive. Supports only generic partitioning rules, FDISK and SFD. */
	bsect = 0;
	fmt = check_fs(fs, bsect);			/* Load sector 0 and check if it is an FAT-VBR as SFD */
	if (fmt == 2 || (fmt < 2 && LD2PT(vol) != 0)) {	/* Not an FAT-VBR or forced partition number */
		for (i = 0; i < 4; i++) {		/* Get partition offset */
			pt = fs->win + (MBR_Table + i * SZ_PTE);
			br[i] = pt[PTE_System] ? ld_dword(pt + PTE_StLba) : 0;
		}
		i = LD2PT(vol);					/* Partition number: 0:auto, 1-4:forced */
		if (i != 0) i--;
		do {							/* Find an FAT volume */
			bsect = br[i];
			fmt = bsect ? check_fs(fs, bsect) : 3;	/* Check the partition */
		} while (LD2PT(vol) == 0 && fmt >= 2 && ++i < 4);
	}
	if (fmt == 4) return FR_DISK_ERR;		/* An error occured in the disk I/O layer */
	if (fmt >= 2) return FR_NO_FILESYSTEM;	/* No FAT volume is found */

	/* An FAT volume is found (bsect). Following code initializes the filesystem object */

#if FF_FS_EXFAT
	if (fmt == 1) {
		QWORD maxlba;

		for (i = BPB_ZeroedEx; i < BPB_ZeroedEx + 53 && fs->win[i] == 0; i++) ;	/* Check zero filler */
		if (i < BPB_ZeroedEx + 53) return FR_NO_FILESYSTEM;

		if (ld_word(fs->win + BPB_FSVerEx) != 0x100) return FR_NO_FILESYSTEM;	/* Check exFAT version (must be version 1.0) */

		if (1 << fs->win[BPB_BytsPerSecEx] != SS(fs)) {	/* (BPB_BytsPerSecEx must be equal to the physical sector size) */
			return FR_NO_FILESYSTEM;
		}

		maxlba = ld_qword(fs->win + BPB_TotSecEx) + bsect;	/* Last LBA + 1 of the volume */
		if (maxlba >= 0x100000000) return FR_NO_FILESYSTEM;	/* (It cannot be handled in 32-bit LBA) */

		fs->fsize = ld_dword(fs->win + BPB_FatSzEx);	/* Number of sectors per FAT */

		fs->n_fats = fs->win[BPB_NumFATsEx];			/* Number of FATs */
		if (fs->n_fats != 1) return FR_NO_FILESYSTEM;	/* (Supports only 1 FAT) */

		fs->csize = 1 << fs->win[BPB_SecPerClusEx];		/* Cluster size */
		if (fs->csize == 0)	return FR_NO_FILESYSTEM;	/* (Must be 1..32768) */

		nclst = ld_dword(fs->win + BPB_NumClusEx);		/* Number of clusters */
		if (nclst > MAX_EXFAT) return FR_NO_FILESYSTEM;	/* (Too many clusters) */
		fs->n_fatent = nclst + 2;

		/* Boundaries and Limits */
		fs->volbase = bsect;
		fs->database = bsect + ld_dword(fs->win + BPB_DataOfsEx);
		fs->fatbase = bsect + ld_dword(fs->win + BPB_FatOfsEx);
		if (maxlba < (QWORD)fs->database + nclst * fs->csize) return FR_NO_FILESYSTEM;	/* (Volume size must not be smaller than the size requiered) */
		fs->dirbase = ld_dword(fs->win + BPB_RootClusEx);

		/* Check if bitmap location is in assumption (at the first cluster) */
		if (move_window(fs, clst2sect(fs, fs->dirbase)) != FR_OK) return FR_DISK_ERR;
		for (i = 0; i < SS(fs); i += SZDIRE) {
			if (fs->win[i] == 0x81 && ld_dword(fs->win + i + 20) == 2) break;	/* 81 entry with cluster #2? */
		}
		if (i == SS(fs)) return FR_NO_FILESYSTEM;
#if !FF_FS_READONLY
		fs->last_clst = fs->free_clst = 0xFFFFFFFF;		/* Initialize cluster allocation information */
#endif
		fmt = FS_EXFAT;			/* FAT sub-type */
	} else
#endif	/* FF_FS_EXFAT */
	{
		if (ld_word(fs->win + BPB_BytsPerSec) != SS(fs)) return FR_NO_FILESYSTEM;	/* (BPB_BytsPerSec must be equal to the physical sector size) */

		fasize = ld_word(fs->win + BPB_FATSz16);		/* Number of sectors per FAT */
		if (fasize == 0) fasize = ld_dword(fs->win + BPB_FATSz32);
		fs->fsize = fasize;

		fs->n_fats = fs->win[BPB_NumFATs];				/* Number of FATs */
		if (fs->n_fats != 1 && fs->n_fats != 2) return FR_NO_FILESYSTEM;	/* (Must be 1 or 2) */
		fasize *= fs->n_fats;							/* Number of sectors for FAT area */

		fs->csize = fs->win[BPB_SecPerClus];			/* Cluster size */
		if (fs->csize == 0 || (fs->csize & (fs->csize - 1))) return FR_NO_FILESYSTEM;	/* (Must be power of 2) */

		fs->n_rootdir = ld_word(fs->win + BPB_RootEntCnt);	/* Number of root directory entries */
		if (fs->n_rootdir % (SS(fs) / SZDIRE)) return FR_NO_FILESYSTEM;	/* (Must be sector aligned) */

		tsect = ld_word(fs->win + BPB_TotSec16);		/* Number of sectors on the volume */
		if (tsect == 0) tsect = ld_dword(fs->win + BPB_TotSec32);

		nrsv = ld_word(fs->win + BPB_RsvdSecCnt);		/* Number of reserved sectors */
		if (nrsv == 0) return FR_NO_FILESYSTEM;			/* (Must not be 0) */

		/* Determine the FAT sub type */
		sysect = nrsv + fasize + fs->n_rootdir / (SS(fs) / SZDIRE);	/* RSV + FAT + DIR */
		if (tsect < sysect) return FR_NO_FILESYSTEM;	/* (Invalid volume size) */
		nclst = (tsect - sysect) / fs->csize;			/* Number of clusters */
		if (nclst == 0) return FR_NO_FILESYSTEM;		/* (Invalid volume size) */
		fmt = 0;
		if (nclst <= MAX_FAT32) fmt = FS_FAT32;
		if (nclst <= MAX_FAT16) fmt = FS_FAT16;
		if (nclst <= MAX_FAT12) fmt = FS_FAT12;
		if (fmt == 0) return FR_NO_FILESYSTEM;

		/* Boundaries and Limits */
		fs->n_fatent = nclst + 2;						/* Number of FAT entries */
		fs->volbase = bsect;							/* Volume start sector */
		fs->fatbase = bsect + nrsv; 					/* FAT start sector */
		fs->database = bsect + sysect;					/* Data start sector */
		if (fmt == FS_FAT32) {
			if (ld_word(fs->win + BPB_FSVer32) != 0) return FR_NO_FILESYSTEM;	/* (Must be FAT32 revision 0.0) */
			if (fs->n_rootdir != 0) return FR_NO_FILESYSTEM;	/* (BPB_RootEntCnt must be 0) */
			fs->dirbase = ld_dword(fs->win + BPB_RootClus32);	/* Root directory start cluster */
			szbfat = fs->n_fatent * 4;					/* (Needed FAT size) */
		} else {
			if (fs->n_rootdir == 0)	return FR_NO_FILESYSTEM;	/* (BPB_RootEntCnt must not be 0) */
			fs->dirbase = fs->fatbase + fasize;			/* Root directory start sector */
			szbfat = (fmt == FS_FAT16) ?				/* (Needed FAT size) */
				fs->n_fatent * 2 : fs->n_fatent * 3 / 2 + (fs->n_fatent & 1);
		}
		if (fs->fsize < (szbfat + (SS(fs) - 1)) / SS(fs)) return FR_NO_FILESYSTEM;	/* (BPB_FATSz must not be less than the size needed) */

#if !FF_FS_READONLY
		/* Get FSInfo if available */
		fs->last_clst = fs->free_clst = 0xFFFFFFFF;		/* Initialize cluster allocation information */
		fs->fsi_flag = 0x80;
#if (FF_FS_NOFSINFO & 3) != 3
		if (fmt == FS_FAT32				/* Allow to update FSInfo only if BPB_FSInfo32 == 1 */
			&& ld_word(fs->win + BPB_FSInfo32) == 1
			&& move_window(fs, bsect + 1) == FR_OK)
		{
			fs->fsi_flag = 0;
			if (ld_word(fs->win + BS_55AA) == 0xAA55	/* Load FSInfo data if available */
				&& ld_dword(fs->win + FSI_LeadSig) == 0x41615252
				&& ld_dword(fs->win + FSI_StrucSig) == 0x61417272)
			{
#if (FF_FS_NOFSINFO & 1) == 0
				fs->free_clst = ld_dword(fs->win + FSI_Free_Count);
#endif
#if (FF_FS_NOFSINFO & 2) == 0
				fs->last_clst = ld_dword(fs->win + FSI_Nxt_Free);
#endif
			}
		}
#endif	/* (FF_FS_NOFSINFO & 3) != 3 */
#endif	/* !FF_FS_READONLY */
	}

	fs->fs_type = fmt;		/* FAT sub-type */
	fs->id = ++Fsid;		/* Volume mount ID */
#if FF_USE_LFN == 1
	fs->lfnbuf = LfnBuf;	/* Static LFN working buffer */
#if FF_FS_EXFAT
	fs->dirbuf = DirBuf;	/* Static directory block scratchpad buuffer */
#endif
#endif
#if FF_FS_RPATH != 0
	fs->cdir = 0;			/* Initialize current directory */
#endif
#if FF_FS_LOCK != 0			/* Clear file lock semaphores */
	clear_lock(fs);
#endif
	return FR_OK;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movb %al, -0x19(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, (%rax)
movq -0x10(%rbp), %rdi
callq 0x1690
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
jge 0x17b1
movl $0xb, -0x4(%rbp)
jmp 0x1f9e
movslq -0x2c(%rbp), %rcx
leaq 0x88a4(%rip), %rax      # 0xa060
movq (%rax,%rcx,8), %rax
movq %rax, -0x90(%rbp)
cmpq $0x0, -0x90(%rbp)
jne 0x17dd
movl $0xc, -0x4(%rbp)
jmp 0x1f9e
movq -0x90(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movzbl -0x19(%rbp), %eax
andl $0xfe, %eax
movb %al, -0x19(%rbp)
movq -0x90(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x0, %eax
je 0x1854
movq -0x90(%rbp), %rax
movzbl 0x1(%rax), %edi
callq 0x13e0
movb %al, -0x2d(%rbp)
movzbl -0x2d(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x1852
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
je 0x1846
movzbl -0x2d(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x1846
movl $0xa, -0x4(%rbp)
jmp 0x1f9e
movl $0x0, -0x4(%rbp)
jmp 0x1f9e
jmp 0x1854
movq -0x90(%rbp), %rax
movb $0x0, (%rax)
movl -0x2c(%rbp), %eax
movb %al, %cl
movq -0x90(%rbp), %rax
movb %cl, 0x1(%rax)
movq -0x90(%rbp), %rax
movzbl 0x1(%rax), %edi
callq 0x13f0
movb %al, -0x2d(%rbp)
movzbl -0x2d(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x1898
movl $0x3, -0x4(%rbp)
jmp 0x1f9e
movzbl -0x19(%rbp), %eax
cmpl $0x0, %eax
je 0x18b9
movzbl -0x2d(%rbp), %eax
andl $0x4, %eax
cmpl $0x0, %eax
je 0x18b9
movl $0xa, -0x4(%rbp)
jmp 0x1f9e
movq $0x0, -0x38(%rbp)
movq -0x90(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x6170
movb %al, -0x1a(%rbp)
movzbl -0x1a(%rbp), %eax
cmpl $0x2, %eax
je 0x18f5
movzbl -0x1a(%rbp), %eax
cmpl $0x2, %eax
jge 0x1a1f
xorl %eax, %eax
testb $0x1, %al
jne 0x18f5
jmp 0x1a1f
movl $0x0, -0x94(%rbp)
cmpl $0x4, -0x94(%rbp)
jae 0x197c
movq -0x90(%rbp), %rax
addq $0x58, %rax
movl -0x94(%rbp), %ecx
shll $0x4, %ecx
addl $0x1be, %ecx            # imm = 0x1BE
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movzbl 0x4(%rax), %eax
cmpl $0x0, %eax
je 0x194e
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
callq 0x2940
movq %rax, -0xa0(%rbp)
jmp 0x1959
xorl %eax, %eax
movq %rax, -0xa0(%rbp)
jmp 0x1959
movq -0xa0(%rbp), %rcx
movl -0x94(%rbp), %eax
movq %rcx, -0x80(%rbp,%rax,8)
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x18ff
movl $0x0, -0x94(%rbp)
cmpl $0x0, -0x94(%rbp)
je 0x199e
movl -0x94(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x19a0
movl -0x94(%rbp), %eax
movq -0x80(%rbp,%rax,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x19d1
movq -0x90(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x6170
movzbl %al, %eax
movl %eax, -0xa4(%rbp)
jmp 0x19de
movl $0x3, %eax
movl %eax, -0xa4(%rbp)
jmp 0x19de
movl -0xa4(%rbp), %eax
movb %al, -0x1a(%rbp)
movzbl -0x1a(%rbp), %ecx
xorl %eax, %eax
cmpl $0x2, %ecx
movb %al, -0xa5(%rbp)
jl 0x1a13
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
cmpl $0x4, %eax
setb %al
movb %al, -0xa5(%rbp)
movb -0xa5(%rbp), %al
testb $0x1, %al
jne 0x19a0
jmp 0x1a1f
movzbl -0x1a(%rbp), %eax
cmpl $0x4, %eax
jne 0x1a34
movl $0x1, -0x4(%rbp)
jmp 0x1f9e
movzbl -0x1a(%rbp), %eax
cmpl $0x2, %eax
jl 0x1a49
movl $0xd, -0x4(%rbp)
jmp 0x1f9e
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
addq $0xb, %rdi
callq 0x4960
movzwl %ax, %eax
cmpl $0x200, %eax            # imm = 0x200
je 0x1a73
movl $0xd, -0x4(%rbp)
jmp 0x1f9e
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
addq $0x16, %rdi
callq 0x4960
movzwl %ax, %eax
movq %rax, -0x40(%rbp)
cmpq $0x0, -0x40(%rbp)
jne 0x1aad
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
addq $0x24, %rdi
callq 0x2940
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x90(%rbp), %rax
movb 0x68(%rax), %cl
movq -0x90(%rbp), %rax
movb %cl, 0x2(%rax)
movq -0x90(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x1, %eax
je 0x1afc
movq -0x90(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x2, %eax
je 0x1afc
movl $0xd, -0x4(%rbp)
jmp 0x1f9e
movq -0x90(%rbp), %rax
movzbl 0x2(%rax), %eax
imulq -0x40(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x90(%rbp), %rax
movzbl 0x65(%rax), %eax
movw %ax, %cx
movq -0x90(%rbp), %rax
movw %cx, 0xa(%rax)
movq -0x90(%rbp), %rax
movzwl 0xa(%rax), %eax
cmpl $0x0, %eax
je 0x1b59
movq -0x90(%rbp), %rax
movzwl 0xa(%rax), %eax
movq -0x90(%rbp), %rcx
movzwl 0xa(%rcx), %ecx
subl $0x1, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0x1b65
movl $0xd, -0x4(%rbp)
jmp 0x1f9e
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
addq $0x11, %rdi
callq 0x4960
movw %ax, %cx
movq -0x90(%rbp), %rax
movw %cx, 0x8(%rax)
movq -0x90(%rbp), %rax
movzwl 0x8(%rax), %eax
andl $0xf, %eax
cmpl $0x0, %eax
je 0x1ba6
movl $0xd, -0x4(%rbp)
jmp 0x1f9e
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
addq $0x13, %rdi
callq 0x4960
movzwl %ax, %eax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x1be0
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
addq $0x20, %rdi
callq 0x2940
movq %rax, -0x48(%rbp)
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
addq $0xe, %rdi
callq 0x4960
movw %ax, -0x82(%rbp)
movzwl -0x82(%rbp), %eax
cmpl $0x0, %eax
jne 0x1c13
movl $0xd, -0x4(%rbp)
jmp 0x1f9e
movzwl -0x82(%rbp), %eax
addq -0x40(%rbp), %rax
movq -0x90(%rbp), %rcx
movzwl 0x8(%rcx), %ecx
shrl $0x4, %ecx
movl %ecx, %ecx
addq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rax
cmpq -0x50(%rbp), %rax
jae 0x1c4b
movl $0xd, -0x4(%rbp)
jmp 0x1f9e
movq -0x48(%rbp), %rax
subq -0x50(%rbp), %rax
movq -0x90(%rbp), %rcx
movzwl 0xa(%rcx), %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0x1c7a
movl $0xd, -0x4(%rbp)
jmp 0x1f9e
movb $0x0, -0x1a(%rbp)
cmpq $0xffffff5, -0x58(%rbp) # imm = 0xFFFFFF5
ja 0x1c8c
movb $0x3, -0x1a(%rbp)
cmpq $0xfff5, -0x58(%rbp)    # imm = 0xFFF5
ja 0x1c9a
movb $0x2, -0x1a(%rbp)
cmpq $0xff5, -0x58(%rbp)     # imm = 0xFF5
ja 0x1ca8
movb $0x1, -0x1a(%rbp)
movzbl -0x1a(%rbp), %eax
cmpl $0x0, %eax
jne 0x1cbd
movl $0xd, -0x4(%rbp)
jmp 0x1f9e
movq -0x58(%rbp), %rcx
addq $0x2, %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x38(%rbp), %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x38(%rbp), %rcx
movzwl -0x82(%rbp), %eax
addq %rax, %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x38(%rbp), %rcx
addq -0x50(%rbp), %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x48(%rax)
movzbl -0x1a(%rbp), %eax
cmpl $0x3, %eax
jne 0x1d92
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
addq $0x2a, %rdi
callq 0x4960
movzwl %ax, %eax
cmpl $0x0, %eax
je 0x1d3c
movl $0xd, -0x4(%rbp)
jmp 0x1f9e
movq -0x90(%rbp), %rax
movzwl 0x8(%rax), %eax
cmpl $0x0, %eax
je 0x1d58
movl $0xd, -0x4(%rbp)
jmp 0x1f9e
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
addq $0x2c, %rdi
callq 0x2940
movq %rax, %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x40(%rax)
movq -0x90(%rbp), %rax
movq 0x20(%rax), %rax
shlq $0x2, %rax
movq %rax, -0x60(%rbp)
jmp 0x1e1b
movq -0x90(%rbp), %rax
movzwl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0x1dae
movl $0xd, -0x4(%rbp)
jmp 0x1f9e
movq -0x90(%rbp), %rax
movq 0x38(%rax), %rcx
addq -0x40(%rbp), %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x40(%rax)
movzbl -0x1a(%rbp), %eax
cmpl $0x2, %eax
jne 0x1de8
movq -0x90(%rbp), %rax
movq 0x20(%rax), %rax
shlq %rax
movq %rax, -0xb0(%rbp)
jmp 0x1e10
movq -0x90(%rbp), %rax
imulq $0x3, 0x20(%rax), %rax
shrq %rax
movq -0x90(%rbp), %rcx
movq 0x20(%rcx), %rcx
andq $0x1, %rcx
addq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x90(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x60(%rbp), %rcx
addq $0x1ff, %rcx            # imm = 0x1FF
shrq $0x9, %rcx
cmpq %rcx, %rax
jae 0x1e46
movl $0xd, -0x4(%rbp)
jmp 0x1f9e
movq -0x90(%rbp), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0x18(%rax)
movq -0x90(%rbp), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movq %rcx, 0x10(%rax)
movq -0x90(%rbp), %rax
movb $-0x80, 0x4(%rax)
movzbl -0x1a(%rbp), %eax
cmpl $0x3, %eax
jne 0x1f6e
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
addq $0x30, %rdi
callq 0x4960
movzwl %ax, %eax
cmpl $0x1, %eax
jne 0x1f6e
movq -0x90(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq $0x1, %rsi
callq 0x28b0
cmpl $0x0, %eax
jne 0x1f6e
movq -0x90(%rbp), %rax
movb $0x0, 0x4(%rax)
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
addq $0x1fe, %rdi            # imm = 0x1FE
callq 0x4960
movzwl %ax, %eax
cmpl $0xaa55, %eax           # imm = 0xAA55
jne 0x1f6c
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
callq 0x2940
cmpq $0x41615252, %rax       # imm = 0x41615252
jne 0x1f6c
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
addq $0x1e4, %rdi            # imm = 0x1E4
callq 0x2940
cmpq $0x61417272, %rax       # imm = 0x61417272
jne 0x1f6c
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
addq $0x1e8, %rdi            # imm = 0x1E8
callq 0x2940
movq %rax, %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x90(%rbp), %rdi
addq $0x58, %rdi
addq $0x1ec, %rdi            # imm = 0x1EC
callq 0x2940
movq %rax, %rcx
movq -0x90(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1f6e
movb -0x1a(%rbp), %cl
movq -0x90(%rbp), %rax
movb %cl, (%rax)
movw 0x80e7(%rip), %cx       # 0xa068
addw $0x1, %cx
movw %cx, 0x80dc(%rip)       # 0xa068
movq -0x90(%rbp), %rax
movw %cx, 0x6(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
nopw (%rax,%rax)