/* SPDX-License-Identifier: GPL-2.0 */

/* Copyright (c) 2018-2021 Rockchip Electronics Co. Ltd.
 * date: 2023-03-21
 */
	.text
	.section	.note.gnu.property,"a",@note
	.p2align	3
	.word	4
	.word	16
	.word	5
	.asciz	"GNU"
	.word	3221225472
	.word	4
	.word	3
	.word	0
.Lsec_end0:
	.text
	.file	"rk_sftl.c"
	.globl	ftl_print_sblk_info             // -- Begin function ftl_print_sblk_info
	.p2align	2
	.type	ftl_print_sblk_info,@function
ftl_print_sblk_info:                    // @ftl_print_sblk_info
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	adrp	x0, .L.str
	adrp	x1, .L.str.1
	add	x0, x0, :lo12:.L.str
	add	x1, x1, :lo12:.L.str.1
	str	x19, [sp, #16]                  // 8-byte Folded Spill
	mov	x29, sp
	bl	sftl_printk
	adrp	x8, g_active_superblock
	add	x8, x8, :lo12:g_active_superblock
	adrp	x19, p_valid_page_count_table
	ldrh	w1, [x8]
	ldr	x9, [x19, :lo12:p_valid_page_count_table]
	ldrh	w2, [x8, #2]
	ldrb	w3, [x8, #6]
	ldrb	w4, [x8, #8]
	ldrh	w5, [x8, #4]
	ldrh	w6, [x9, x1, lsl #1]
	adrp	x0, .L.str.2
	add	x0, x0, :lo12:.L.str.2
                                        // kill: def $w1 killed $w1 killed $x1
	bl	sftl_printk
	adrp	x8, g_buffer_superblock
	add	x8, x8, :lo12:g_buffer_superblock
	ldrh	w1, [x8]
	ldr	x9, [x19, :lo12:p_valid_page_count_table]
	ldrh	w2, [x8, #2]
	ldrb	w3, [x8, #6]
	ldrb	w4, [x8, #8]
	ldrh	w5, [x8, #4]
	ldrh	w6, [x9, x1, lsl #1]
	adrp	x0, .L.str.3
	add	x0, x0, :lo12:.L.str.3
                                        // kill: def $w1 killed $w1 killed $x1
	bl	sftl_printk
	adrp	x8, g_gc_temp_superblock
	add	x8, x8, :lo12:g_gc_temp_superblock
	ldrh	w1, [x8]
	ldr	x9, [x19, :lo12:p_valid_page_count_table]
	ldrh	w2, [x8, #2]
	ldrb	w3, [x8, #6]
	ldrb	w4, [x8, #8]
	ldrh	w5, [x8, #4]
	ldrh	w6, [x9, x1, lsl #1]
	adrp	x0, .L.str.4
	add	x0, x0, :lo12:.L.str.4
                                        // kill: def $w1 killed $w1 killed $x1
	bl	sftl_printk
	adrp	x8, g_gc_superblock
	add	x8, x8, :lo12:g_gc_superblock
	ldrh	w1, [x8]
	ldr	x9, [x19, :lo12:p_valid_page_count_table]
	ldrh	w2, [x8, #2]
	ldrb	w3, [x8, #6]
	ldrb	w4, [x8, #8]
	ldrh	w5, [x8, #4]
	ldrh	w6, [x9, x1, lsl #1]
	adrp	x0, .L.str.5
	add	x0, x0, :lo12:.L.str.5
                                        // kill: def $w1 killed $w1 killed $x1
	bl	sftl_printk
	adrp	x8, g_num_free_superblocks
	adrp	x9, g_gc_next_blk
	adrp	x10, g_gc_next_blk_1
	ldrh	w1, [x8, :lo12:g_num_free_superblocks]
	ldrh	w2, [x9, :lo12:g_gc_next_blk]
	ldrh	w3, [x10, :lo12:g_gc_next_blk_1]
	adrp	x0, .L.str.6
	add	x0, x0, :lo12:.L.str.6
	bl	sftl_printk
	ldr	x19, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end0:
	.size	ftl_print_sblk_info, .Lfunc_end0-ftl_print_sblk_info
                                        // -- End function
	.globl	FtlPrintInfo2buf                // -- Begin function FtlPrintInfo2buf
	.p2align	2
	.type	FtlPrintInfo2buf,@function
FtlPrintInfo2buf:                       // @FtlPrintInfo2buf
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-96]!           // 16-byte Folded Spill
	adrp	x8, .L.str.7
	add	x8, x8, :lo12:.L.str.7
	ldur	x9, [x8, #5]
	ldr	x8, [x8]
	stp	x20, x19, [sp, #80]             // 16-byte Folded Spill
	add	x20, x0, #12                    // =12
	stur	x9, [x0, #5]
	str	x8, [x0]
	adrp	x8, DeviceCapacity
	ldr	w3, [x8, :lo12:DeviceCapacity]
	adrp	x2, .L.str.8
	mov	x19, x0
	add	x2, x2, :lo12:.L.str.8
	mov	w1, #64
	mov	x0, x20
	stp	x28, x27, [sp, #16]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #32]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #48]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #64]             // 16-byte Folded Spill
	mov	x29, sp
	bl	snprintf
	adrp	x8, .L.str.9
	add	x8, x8, :lo12:.L.str.9
	ldr	x8, [x8]
	mov	w10, #14927
	add	x9, x20, w0, sxtw
	movk	w10, #10, lsl #16
	str	x8, [x9]
	stur	w10, [x9, #7]
	adrp	x8, g_MaxLpn
	ldr	w3, [x8, :lo12:g_MaxLpn]
	add	x20, x9, #10                    // =10
	adrp	x2, .L.str.10
	add	x2, x2, :lo12:.L.str.10
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_VaildLpn
	ldr	w3, [x8, :lo12:g_VaildLpn]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.11
	add	x2, x2, :lo12:.L.str.11
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_totle_read_page_count
	ldr	w3, [x8, :lo12:g_totle_read_page_count]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.12
	add	x2, x2, :lo12:.L.str.12
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_totle_discard_page_count
	ldr	w3, [x8, :lo12:g_totle_discard_page_count]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.13
	add	x2, x2, :lo12:.L.str.13
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_totle_write_page_count
	ldr	w3, [x8, :lo12:g_totle_write_page_count]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.14
	add	x2, x2, :lo12:.L.str.14
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_totle_cache_write_count
	ldr	w3, [x8, :lo12:g_totle_cache_write_count]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.15
	add	x2, x2, :lo12:.L.str.15
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_totle_l2p_write_count
	ldr	w3, [x8, :lo12:g_totle_l2p_write_count]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.16
	add	x2, x2, :lo12:.L.str.16
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_totle_gc_page_count
	ldr	w3, [x8, :lo12:g_totle_gc_page_count]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.17
	add	x2, x2, :lo12:.L.str.17
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_totle_write_sector
	ldr	w8, [x8, :lo12:g_totle_write_sector]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.18
	add	x2, x2, :lo12:.L.str.18
	lsr	w3, w8, #11
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_totle_read_sector
	ldr	w8, [x8, :lo12:g_totle_read_sector]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.19
	add	x2, x2, :lo12:.L.str.19
	lsr	w3, w8, #11
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_GlobalSysVersion
	ldr	w3, [x8, :lo12:g_GlobalSysVersion]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.20
	add	x2, x2, :lo12:.L.str.20
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_GlobalDataVersion
	ldr	w3, [x8, :lo12:g_GlobalDataVersion]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.21
	add	x2, x2, :lo12:.L.str.21
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x22, gBbtInfo
	add	x22, x22, :lo12:gBbtInfo
	ldrh	w3, [x22, #6]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.22
	add	x2, x2, :lo12:.L.str.22
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x21, g_num_free_superblocks
	ldrh	w3, [x21, :lo12:g_num_free_superblocks]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.23
	add	x2, x2, :lo12:.L.str.23
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_totle_mlc_erase_count
	ldr	w3, [x8, :lo12:g_totle_mlc_erase_count]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.24
	add	x2, x2, :lo12:.L.str.24
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_totle_slc_erase_count
	ldr	w3, [x8, :lo12:g_totle_slc_erase_count]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.25
	add	x2, x2, :lo12:.L.str.25
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_totle_avg_erase_count
	ldr	w3, [x8, :lo12:g_totle_avg_erase_count]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.26
	add	x2, x2, :lo12:.L.str.26
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_totle_sys_slc_erase_count
	ldr	w3, [x8, :lo12:g_totle_sys_slc_erase_count]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.27
	add	x2, x2, :lo12:.L.str.27
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_max_erase_count
	ldr	w3, [x8, :lo12:g_max_erase_count]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.28
	add	x2, x2, :lo12:.L.str.28
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_min_erase_count
	ldr	w3, [x8, :lo12:g_min_erase_count]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.29
	add	x2, x2, :lo12:.L.str.29
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x23, g_sys_save_data+28
	add	x23, x23, :lo12:g_sys_save_data+28
	ldrh	w3, [x23, #2]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.30
	add	x2, x2, :lo12:.L.str.30
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrh	w3, [x23]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.31
	add	x2, x2, :lo12:.L.str.31
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_MaxLbaSector
	ldr	w3, [x8, :lo12:g_MaxLbaSector]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.32
	add	x2, x2, :lo12:.L.str.32
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, c_ftl_nand_init_sys_blks_per_plane
	ldr	w3, [x8, :lo12:c_ftl_nand_init_sys_blks_per_plane]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.33
	add	x2, x2, :lo12:.L.str.33
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, c_ftl_nand_sys_blks_per_plane
	ldr	w3, [x8, :lo12:c_ftl_nand_sys_blks_per_plane]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.34
	add	x2, x2, :lo12:.L.str.34
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, gSysFreeQueue+6
	ldrh	w3, [x8, :lo12:gSysFreeQueue+6]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.35
	add	x2, x2, :lo12:.L.str.35
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, c_ftl_nand_data_blks_per_plane
	ldrh	w3, [x8, :lo12:c_ftl_nand_data_blks_per_plane]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.36
	add	x2, x2, :lo12:.L.str.36
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, c_ftl_nand_data_op_blks_per_plane
	ldrh	w3, [x8, :lo12:c_ftl_nand_data_op_blks_per_plane]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.37
	add	x2, x2, :lo12:.L.str.37
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, c_ftl_nand_max_data_blks
	ldr	w3, [x8, :lo12:c_ftl_nand_max_data_blks]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.38
	add	x2, x2, :lo12:.L.str.38
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, gSysInfo
	ldrh	w3, [x8, :lo12:gSysInfo]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.39
	add	x2, x2, :lo12:.L.str.39
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrh	w3, [x22]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.40
	add	x2, x2, :lo12:.L.str.40
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x22, g_active_superblock
	add	x22, x22, :lo12:g_active_superblock
	ldrh	w3, [x22, #2]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.41
	add	x2, x2, :lo12:.L.str.41
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrb	w3, [x22, #6]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.42
	add	x2, x2, :lo12:.L.str.42
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrh	w3, [x22]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.43
	add	x2, x2, :lo12:.L.str.43
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrb	w3, [x22, #8]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.44
	add	x2, x2, :lo12:.L.str.44
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrh	w3, [x22, #4]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.45
	add	x2, x2, :lo12:.L.str.45
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x23, p_valid_page_count_table
	ldr	x8, [x23, :lo12:p_valid_page_count_table]
	ldrh	w9, [x22]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.46
	add	x2, x2, :lo12:.L.str.46
	ldrh	w3, [x8, x9, lsl #1]
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x22, g_buffer_superblock
	add	x22, x22, :lo12:g_buffer_superblock
	ldrh	w3, [x22, #2]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.47
	add	x2, x2, :lo12:.L.str.47
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrb	w3, [x22, #6]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.48
	add	x2, x2, :lo12:.L.str.48
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrh	w3, [x22]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.49
	add	x2, x2, :lo12:.L.str.49
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrb	w3, [x22, #8]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.50
	add	x2, x2, :lo12:.L.str.50
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrh	w3, [x22, #4]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.51
	add	x2, x2, :lo12:.L.str.51
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldr	x8, [x23, :lo12:p_valid_page_count_table]
	ldrh	w9, [x22]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.52
	add	x2, x2, :lo12:.L.str.52
	ldrh	w3, [x8, x9, lsl #1]
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x22, g_gc_temp_superblock
	add	x22, x22, :lo12:g_gc_temp_superblock
	ldrh	w3, [x22, #2]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.53
	add	x2, x2, :lo12:.L.str.53
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrb	w3, [x22, #6]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.54
	add	x2, x2, :lo12:.L.str.54
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrh	w3, [x22]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.55
	add	x2, x2, :lo12:.L.str.55
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrb	w3, [x22, #8]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.56
	add	x2, x2, :lo12:.L.str.56
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrh	w3, [x22, #4]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.57
	add	x2, x2, :lo12:.L.str.57
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x22, g_gc_superblock
	add	x22, x22, :lo12:g_gc_superblock
	ldrh	w3, [x22, #2]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.58
	add	x2, x2, :lo12:.L.str.58
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrb	w3, [x22, #6]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.59
	add	x2, x2, :lo12:.L.str.59
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrh	w3, [x22]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.60
	add	x2, x2, :lo12:.L.str.60
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrb	w3, [x22, #8]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.61
	add	x2, x2, :lo12:.L.str.61
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldrh	w3, [x22, #4]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.62
	add	x2, x2, :lo12:.L.str.62
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x22, g_sys_ext_data+72
	add	x22, x22, :lo12:g_sys_ext_data+72
	ldp	w3, w4, [x22, #8]
	ldr	w5, [x22, #4]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.63
	add	x2, x2, :lo12:.L.str.63
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldr	w3, [x22]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.64
	add	x2, x2, :lo12:.L.str.64
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldr	w3, [x22, #24]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.65
	add	x2, x2, :lo12:.L.str.65
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_gc_free_blk_threshold
	ldrh	w3, [x8, :lo12:g_gc_free_blk_threshold]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.66
	add	x2, x2, :lo12:.L.str.66
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_gc_merge_free_blk_threshold
	ldrh	w3, [x8, :lo12:g_gc_merge_free_blk_threshold]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.67
	add	x2, x2, :lo12:.L.str.67
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_gc_skip_write_count
	ldr	w3, [x8, :lo12:g_gc_skip_write_count]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.68
	add	x2, x2, :lo12:.L.str.68
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, g_gc_blk_index
	ldrh	w3, [x8, :lo12:g_gc_blk_index]
	add	x20, x20, w0, sxtw
	adrp	x2, .L.str.69
	add	x2, x2, :lo12:.L.str.69
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x26, p_free_data_block_list_head
	ldr	x8, [x26, :lo12:p_free_data_block_list_head]
	add	x20, x20, w0, sxtw
	adrp	x24, p_data_block_list_table
	adrp	x25, p_erase_count_table
	cbz	x8, .LBB1_2
// %bb.1:
	ldr	w9, [x24, :lo12:p_data_block_list_table]
	ldr	x10, [x25, :lo12:p_erase_count_table]
	sub	w8, w8, w9
	mov	w9, #43691
	lsr	w8, w8, #1
	movk	w9, #43690, lsl #16
	mul	w8, w8, w9
	and	x8, x8, #0xffff
	ldrh	w3, [x10, x8, lsl #1]
	b	.LBB1_3
.LBB1_2:
	mov	w3, wzr
.LBB1_3:
	adrp	x2, .L.str.70
	add	x2, x2, :lo12:.L.str.70
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	ldr	x9, [x26, :lo12:p_free_data_block_list_head]
	add	x20, x20, w0, sxtw
	cbz	x9, .LBB1_8
// %bb.4:
	ldrh	w10, [x21, :lo12:g_num_free_superblocks]
	ldr	x8, [x24, :lo12:p_data_block_list_table]
	lsl	w11, w10, #3
	sub	x9, x9, x8
	sub	w11, w11, w10
	lsr	x12, x9, #1
	lsr	w9, w11, #3
	cmp	w9, w10
	csel	w9, w9, w10, lo
	mov	w10, #43691
	movk	w10, #43690, lsl #16
	mul	w12, w12, w10
	cbz	w9, .LBB1_9
// %bb.5:
	mov	w10, wzr
	mov	w11, #6
	mov	w13, #65535
.LBB1_6:                                // =>This Inner Loop Header: Depth=1
	and	x14, x12, #0xffff
	mul	x14, x14, x11
	ldrh	w14, [x8, x14]
	mov	w15, w12
	cmp	w14, w13
	b.eq	.LBB1_10
// %bb.7:                               //   in Loop: Header=BB1_6 Depth=1
	add	w10, w10, #1                    // =1
	and	w12, w10, #0xffff
	cmp	w12, w9, uxth
	mov	w12, w14
	mov	w15, w14
	b.lo	.LBB1_6
	b	.LBB1_10
.LBB1_8:
	mov	w3, wzr
	b	.LBB1_11
.LBB1_9:
	mov	w15, w12
.LBB1_10:
	ldr	x8, [x25, :lo12:p_erase_count_table]
	and	x9, x15, #0xffff
	ldrh	w3, [x8, x9, lsl #1]
.LBB1_11:
	adrp	x2, .L.str.71
	add	x2, x2, :lo12:.L.str.71
	mov	w1, #64
	mov	x0, x20
	bl	snprintf
	adrp	x8, gFtlInitStatus
	ldr	w8, [x8, :lo12:gFtlInitStatus]
	add	x20, x20, w0, sxtw
	cmp	w8, #1                          // =1
	b.ne	.LBB1_24
// %bb.12:
	adrp	x8, g_gc_superblock
	ldrh	w8, [x8, :lo12:g_gc_superblock]
	mov	w9, #65535
	cmp	x8, x9
	b.eq	.LBB1_14
// %bb.13:
	ldr	x9, [x23, :lo12:p_valid_page_count_table]
	adrp	x2, .L.str.72
	add	x2, x2, :lo12:.L.str.72
	mov	w1, #64
	ldrh	w3, [x9, x8, lsl #1]
	mov	x0, x20
	bl	snprintf
	add	x20, x20, w0, sxtw
.LBB1_14:
	adrp	x8, p_data_block_list_head
	ldr	x8, [x8, :lo12:p_data_block_list_head]
	cbz	x8, .LBB1_19
// %bb.15:
	ldr	x9, [x24, :lo12:p_data_block_list_table]
	sub	x8, x8, x9
	mov	w9, #43691
	lsr	x8, x8, #1
	movk	w9, #43690, lsl #16
	mul	w9, w8, w9
	mvn	w8, w9
	tst	w8, #0xffff
	b.eq	.LBB1_19
// %bb.16:
	ldr	x8, [x24, :lo12:p_data_block_list_table]
	adrp	x22, .L.str.73
	mov	w21, wzr
	add	x22, x22, :lo12:.L.str.73
	mov	w27, #65535
.LBB1_17:                               // =>This Inner Loop Header: Depth=1
	and	x11, x9, #0xffff
	ldr	x10, [x23, :lo12:p_valid_page_count_table]
	ldr	x12, [x25, :lo12:p_erase_count_table]
	lsl	x13, x11, #1
	add	x11, x13, x11
	lsl	x28, x11, #1
	add	x8, x8, x28
	ldrh	w5, [x10, x13]
	ldrh	w6, [x8, #4]
	ldrh	w7, [x12, x13]
	and	w4, w9, #0xffff
	mov	w1, #64
	mov	x0, x20
	mov	x2, x22
	mov	w3, w21
	bl	snprintf
	ldr	x8, [x24, :lo12:p_data_block_list_table]
	cmp	w21, #14                        // =14
	add	x20, x20, w0, sxtw
	b.hi	.LBB1_20
// %bb.18:                              //   in Loop: Header=BB1_17 Depth=1
	ldrh	w9, [x8, x28]
	add	w21, w21, #1                    // =1
	cmp	w9, w27
	b.ne	.LBB1_17
	b	.LBB1_20
.LBB1_19:
	ldr	x8, [x24, :lo12:p_data_block_list_table]
.LBB1_20:
	ldr	x9, [x26, :lo12:p_free_data_block_list_head]
	mov	w10, #43691
	movk	w10, #43690, lsl #16
	sub	x9, x9, x8
	lsr	x9, x9, #1
	mul	w9, w9, w10
	mvn	w10, w9
	tst	w10, #0xffff
	b.eq	.LBB1_24
// %bb.21:
	adrp	x22, .L.str.74
	mov	w21, wzr
	add	x22, x22, :lo12:.L.str.74
	mov	w23, #65535
.LBB1_22:                               // =>This Inner Loop Header: Depth=1
	and	x10, x9, #0xffff
	ldr	x11, [x25, :lo12:p_erase_count_table]
	lsl	x12, x10, #1
	add	x10, x12, x10
	lsl	x26, x10, #1
	add	x8, x8, x26
	ldrh	w5, [x8, #4]
	ldrh	w6, [x11, x12]
	and	w4, w9, #0xffff
	mov	w1, #64
	mov	x0, x20
	mov	x2, x22
	mov	w3, w21
	bl	snprintf
	cmp	w21, #2                         // =2
	add	x20, x20, w0, sxtw
	b.hi	.LBB1_24
// %bb.23:                              //   in Loop: Header=BB1_22 Depth=1
	ldr	x8, [x24, :lo12:p_data_block_list_table]
	add	w21, w21, #1                    // =1
	ldrh	w9, [x8, x26]
	cmp	w9, w23
	b.ne	.LBB1_22
.LBB1_24:
	sub	w0, w20, w19
	ldp	x20, x19, [sp, #80]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #96             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end1:
	.size	FtlPrintInfo2buf, .Lfunc_end1-FtlPrintInfo2buf
                                        // -- End function
	.globl	GetFreeBlockMinEraseCount       // -- Begin function GetFreeBlockMinEraseCount
	.p2align	2
	.type	GetFreeBlockMinEraseCount,@function
GetFreeBlockMinEraseCount:              // @GetFreeBlockMinEraseCount
// %bb.0:
	hint	#25
	adrp	x8, p_free_data_block_list_head
	ldr	x8, [x8, :lo12:p_free_data_block_list_head]
	cbz	x8, .LBB2_2
// %bb.1:
	adrp	x9, p_data_block_list_table
	ldr	w9, [x9, :lo12:p_data_block_list_table]
	adrp	x10, p_erase_count_table
	ldr	x10, [x10, :lo12:p_erase_count_table]
	sub	w8, w8, w9
	mov	w9, #43691
	lsr	w8, w8, #1
	movk	w9, #43690, lsl #16
	mul	w8, w8, w9
	and	x8, x8, #0xffff
	ldrh	w0, [x10, x8, lsl #1]
	hint	#29
	ret
.LBB2_2:
	mov	w0, wzr
	hint	#29
	ret
.Lfunc_end2:
	.size	GetFreeBlockMinEraseCount, .Lfunc_end2-GetFreeBlockMinEraseCount
                                        // -- End function
	.globl	GetFreeBlockMaxEraseCount       // -- Begin function GetFreeBlockMaxEraseCount
	.p2align	2
	.type	GetFreeBlockMaxEraseCount,@function
GetFreeBlockMaxEraseCount:              // @GetFreeBlockMaxEraseCount
// %bb.0:
	hint	#25
	adrp	x8, p_free_data_block_list_head
	ldr	x9, [x8, :lo12:p_free_data_block_list_head]
	cbz	x9, .LBB3_5
// %bb.1:
	adrp	x8, g_num_free_superblocks
	adrp	x10, p_data_block_list_table
	ldrh	w11, [x8, :lo12:g_num_free_superblocks]
	ldr	x8, [x10, :lo12:p_data_block_list_table]
	mov	w12, #43691
	movk	w12, #43690, lsl #16
	lsl	w10, w11, #3
	sub	x9, x9, x8
	sub	w10, w10, w11
	lsr	x11, x9, #1
	lsr	w9, w10, #3
	cmp	w9, w0, uxth
	csel	w9, w9, w0, lo
	and	w10, w9, #0xffff
	mul	w12, w11, w12
	cbz	w10, .LBB3_6
// %bb.2:
	mov	w10, wzr
	mov	w11, #6
	mov	w13, #65535
.LBB3_3:                                // =>This Inner Loop Header: Depth=1
	and	x14, x12, #0xffff
	mul	x14, x14, x11
	ldrh	w14, [x8, x14]
	mov	w15, w12
	cmp	w14, w13
	b.eq	.LBB3_7
// %bb.4:                               //   in Loop: Header=BB3_3 Depth=1
	add	w10, w10, #1                    // =1
	and	w12, w10, #0xffff
	cmp	w12, w9, uxth
	mov	w12, w14
	mov	w15, w14
	b.lo	.LBB3_3
	b	.LBB3_7
.LBB3_5:
	mov	w0, wzr
	hint	#29
	ret
.LBB3_6:
	mov	w15, w12
.LBB3_7:
	adrp	x8, p_erase_count_table
	ldr	x8, [x8, :lo12:p_erase_count_table]
	and	x9, x15, #0xffff
	ldrh	w0, [x8, x9, lsl #1]
	hint	#29
	ret
.Lfunc_end3:
	.size	GetFreeBlockMaxEraseCount, .Lfunc_end3-GetFreeBlockMaxEraseCount
                                        // -- End function
	.globl	List_get_gc_head_node           // -- Begin function List_get_gc_head_node
	.p2align	2
	.type	List_get_gc_head_node,@function
List_get_gc_head_node:                  // @List_get_gc_head_node
// %bb.0:
	hint	#25
	adrp	x8, p_data_block_list_head
	ldr	x8, [x8, :lo12:p_data_block_list_head]
	cbz	x8, .LBB4_6
// %bb.1:
	adrp	x9, p_data_block_list_table
	ldr	x9, [x9, :lo12:p_data_block_list_table]
	tst	w0, #0xffff
	b.eq	.LBB4_5
// %bb.2:
	mov	w10, #6
.LBB4_3:                                // =>This Inner Loop Header: Depth=1
	ldrh	w11, [x8]
	mov	w8, #65535
	cmp	x11, x8
	b.eq	.LBB4_7
// %bb.4:                               //   in Loop: Header=BB4_3 Depth=1
	sub	w0, w0, #1                      // =1
	tst	w0, #0xffff
	madd	x8, x11, x10, x9
	b.ne	.LBB4_3
.LBB4_5:
	sub	w8, w8, w9
	mov	w9, #43691
	lsr	w8, w8, #1
	movk	w9, #43690, lsl #16
	mul	w8, w8, w9
	and	w8, w8, #0xffff
	b	.LBB4_7
.LBB4_6:
	mov	w8, #65535
.LBB4_7:
	mov	w0, w8
	hint	#29
	ret
.Lfunc_end4:
	.size	List_get_gc_head_node, .Lfunc_end4-List_get_gc_head_node
                                        // -- End function
	.globl	rknand_proc_ftlread             // -- Begin function rknand_proc_ftlread
	.p2align	2
	.type	rknand_proc_ftlread,@function
rknand_proc_ftlread:                    // @rknand_proc_ftlread
// %bb.0:
	hint	#34
	cmp	w0, #2048                       // =2048
	b.ge	.LBB5_2
// %bb.1:
	mov	w0, wzr
	ret
.LBB5_2:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #16]             // 16-byte Folded Spill
	mov	x19, x1
	adrp	x2, .L.str.75
	adrp	x3, .L.str.1
	add	x2, x2, :lo12:.L.str.75
	add	x3, x3, :lo12:.L.str.1
	mov	w1, #64
	mov	x0, x19
	mov	x29, sp
	bl	snprintf
	add	x20, x19, w0, sxtw
	mov	x0, x20
	bl	FtlPrintInfo2buf
	add	w8, w20, w0
	sub	w0, w8, w19
	ldp	x20, x19, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end5:
	.size	rknand_proc_ftlread, .Lfunc_end5-rknand_proc_ftlread
                                        // -- End function
	.globl	Ftl_log2                        // -- Begin function Ftl_log2
	.p2align	2
	.type	Ftl_log2,@function
Ftl_log2:                               // @Ftl_log2
// %bb.0:
	hint	#25
	cbz	w0, .LBB6_3
// %bb.1:
	mov	w10, wzr
	mov	w9, #1
.LBB6_2:                                // =>This Inner Loop Header: Depth=1
	lsl	w9, w9, #1
	mov	w8, w10
	cmp	w9, w0
	add	w10, w10, #1                    // =1
	b.ls	.LBB6_2
	b	.LBB6_4
.LBB6_3:
	mov	w8, #65535
.LBB6_4:
	mov	w0, w8
	hint	#29
	ret
.Lfunc_end6:
	.size	Ftl_log2, .Lfunc_end6-Ftl_log2
                                        // -- End function
	.globl	FtlPrintInfo                    // -- Begin function FtlPrintInfo
	.p2align	2
	.type	FtlPrintInfo,@function
FtlPrintInfo:                           // @FtlPrintInfo
// %bb.0:
	hint	#25
	hint	#29
	ret
.Lfunc_end7:
	.size	FtlPrintInfo, .Lfunc_end7-FtlPrintInfo
                                        // -- End function
	.globl	FtlSysBlkNumInit                // -- Begin function FtlSysBlkNumInit
	.p2align	2
	.type	FtlSysBlkNumInit,@function
FtlSysBlkNumInit:                       // @FtlSysBlkNumInit
// %bb.0:
	hint	#25
	and	w8, w0, #0xffff
	adrp	x9, c_ftl_nand_blk_pre_plane
	cmp	w8, #24                         // =24
	ldrh	w8, [x9, :lo12:c_ftl_nand_blk_pre_plane]
	mov	w9, #24
	csel	w9, w0, w9, hi
	adrp	x10, c_ftl_nand_data_blks_per_plane
	sub	w8, w8, w9
	strh	w8, [x10, :lo12:c_ftl_nand_data_blks_per_plane]
	adrp	x8, c_ftl_nand_sys_blks_per_plane
	adrp	x10, c_ftl_nand_planes_num
	and	w9, w9, #0xffff
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_num]
	str	w9, [x8, :lo12:c_ftl_nand_sys_blks_per_plane]
	adrp	x8, c_ftl_nand_totle_phy_blks
	ldr	w8, [x8, :lo12:c_ftl_nand_totle_phy_blks]
	mul	w9, w10, w9
	adrp	x10, c_ftl_nand_max_sys_blks
	str	w9, [x10, :lo12:c_ftl_nand_max_sys_blks]
	sub	w8, w8, w9
	adrp	x9, c_ftl_nand_max_data_blks
	str	w8, [x9, :lo12:c_ftl_nand_max_data_blks]
	mov	w0, wzr
	hint	#29
	ret
.Lfunc_end8:
	.size	FtlSysBlkNumInit, .Lfunc_end8-FtlSysBlkNumInit
                                        // -- End function
	.globl	FtlConstantsInit                // -- Begin function FtlConstantsInit
	.p2align	2
	.type	FtlConstantsInit,@function
FtlConstantsInit:                       // @FtlConstantsInit
// %bb.0:
	hint	#25
	ldrh	w12, [x0]
	adrp	x8, c_ftl_nand_type
	adrp	x14, c_ftl_nand_planes_per_die
	adrp	x13, c_ftl_nand_blk_pre_plane
	strh	w12, [x8, :lo12:c_ftl_nand_type]
	ldrh	w10, [x0, #2]
	adrp	x8, c_ftl_nand_die_num
	adrp	x15, c_ftl_nand_sec_pre_page
	strh	w10, [x8, :lo12:c_ftl_nand_die_num]
	ldrh	w11, [x0, #4]
	strh	w11, [x14, :lo12:c_ftl_nand_planes_per_die]
	ldrh	w8, [x0, #6]
	strh	w8, [x13, :lo12:c_ftl_nand_blk_pre_plane]
	ldrh	w9, [x0, #14]
	cmp	w9, #8                          // =8
	strh	w9, [x15, :lo12:c_ftl_nand_sec_pre_page]
	b.eq	.LBB9_3
// %bb.1:
	cmp	w9, #4                          // =4
	b.ne	.LBB9_6
// %bb.2:
	lsr	w8, w8, #1
	mov	w9, #8
	strh	w8, [x13, :lo12:c_ftl_nand_blk_pre_plane]
	strh	w9, [x15, :lo12:c_ftl_nand_sec_pre_page]
	b	.LBB9_6
.LBB9_3:
	cmp	w11, #1                         // =1
	b.ne	.LBB9_5
// %bb.4:
	lsr	w8, w8, #1
	mov	w11, #2
	strh	w8, [x13, :lo12:c_ftl_nand_blk_pre_plane]
	strh	w11, [x14, :lo12:c_ftl_nand_planes_per_die]
.LBB9_5:
	mov	w9, #8
.LBB9_6:
	mov	x15, #256
	mov	x16, #2312
	mov	x17, #4368
	mov	x18, #6424
	movk	x15, #770, lsl #16
	movk	x16, #2826, lsl #16
	movk	x17, #4882, lsl #16
	movk	x18, #6938, lsl #16
	adrp	x14, p_plane_order_table
	movk	x15, #1284, lsl #32
	movk	x16, #3340, lsl #32
	movk	x17, #5396, lsl #32
	movk	x18, #7452, lsl #32
	add	x14, x14, :lo12:p_plane_order_table
	movk	x15, #1798, lsl #48
	movk	x16, #3854, lsl #48
	movk	x17, #5910, lsl #48
	movk	x18, #7966, lsl #48
	adrp	x13, c_mlc_erase_count_value
	mov	w1, #5
	adrp	x2, c_ftl_nand_ext_blk_pre_plane
	cmp	w12, #1                         // =1
	stp	x15, x16, [x14]
	stp	x17, x18, [x14, #16]
	strh	w1, [x13, :lo12:c_mlc_erase_count_value]
	strh	wzr, [x2, :lo12:c_ftl_nand_ext_blk_pre_plane]
	b.ne	.LBB9_8
// %bb.7:
	strh	w12, [x13, :lo12:c_mlc_erase_count_value]
.LBB9_8:
	mul	w12, w11, w10
	adrp	x10, c_ftl_nand_planes_num
	mul	w11, w8, w11
	adrp	x13, c_ftl_vendor_part_size
	mov	w14, #640
	adrp	x15, c_ftl_nand_blks_per_die
	strh	w12, [x10, :lo12:c_ftl_nand_planes_num]
	ands	w10, w11, #0xffff
	strh	w14, [x13, :lo12:c_ftl_vendor_part_size]
	strh	w11, [x15, :lo12:c_ftl_nand_blks_per_die]
	b.eq	.LBB9_11
// %bb.9:
	mov	w14, wzr
	mov	w13, #1
.LBB9_10:                               // =>This Inner Loop Header: Depth=1
	lsl	w13, w13, #1
	mov	w11, w14
	cmp	w13, w10
	add	w14, w14, #1                    // =1
	b.ls	.LBB9_10
	b	.LBB9_12
.LBB9_11:
	mov	w11, #65535
.LBB9_12:
	adrp	x10, c_ftl_nand_blks_per_die_shift
	strh	w11, [x10, :lo12:c_ftl_nand_blks_per_die_shift]
	ldrh	w10, [x0, #12]
	adrp	x11, c_ftl_nand_page_pre_blk
	adrp	x13, c_ftl_nand_page_pre_slc_blk
	strh	w10, [x11, :lo12:c_ftl_nand_page_pre_blk]
	strh	w10, [x13, :lo12:c_ftl_nand_page_pre_slc_blk]
	mul	w11, w10, w12
	adrp	x13, c_ftl_nand_page_pre_super_blk
	strh	w11, [x13, :lo12:c_ftl_nand_page_pre_super_blk]
	cbz	w9, .LBB9_15
// %bb.13:
	mov	w14, wzr
	mov	w13, #1
.LBB9_14:                               // =>This Inner Loop Header: Depth=1
	lsl	w13, w13, #1
	mov	w11, w14
	cmp	w13, w9
	add	w14, w14, #1                    // =1
	b.ls	.LBB9_14
	b	.LBB9_16
.LBB9_15:
	mov	w11, #65535
.LBB9_16:
	adrp	x14, c_ftl_nand_sec_pre_page_shift
	lsl	w13, w9, #9
	adrp	x15, c_ftl_nand_byte_pre_page
	ubfiz	w16, w9, #1, #7
	adrp	x17, c_ftl_nand_byte_pre_oob
	strh	w13, [x15, :lo12:c_ftl_nand_byte_pre_page]
	strh	w16, [x17, :lo12:c_ftl_nand_byte_pre_oob]
	adrp	x17, c_ftl_nand_l2pmap_ram_region_num
	strh	w11, [x14, :lo12:c_ftl_nand_sec_pre_page_shift]
	mov	w14, #32
	ldrh	w18, [x0, #20]
	strh	w14, [x17, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	mov	w14, #640
	lsr	w14, w14, w11
	and	w12, w12, #0xffff
	adrp	x17, c_ftl_nand_vendor_region_num
	add	w14, w14, #2                    // =2
	mul	w9, w9, w10
	strh	w14, [x17, :lo12:c_ftl_nand_vendor_region_num]
	mul	w14, w8, w12
	mul	w17, w9, w14
	adrp	x16, DeviceCapacity
	asr	w17, w17, #11
	str	w17, [x16, :lo12:DeviceCapacity]
	mov	w16, #5120
	sdiv	w9, w16, w9
	and	w16, w9, #0xffff
	mov	w17, #4
	cmp	w16, #5                         // =5
	adrp	x15, c_ftl_nand_reserved_blks
	and	w11, w11, #0xffff
	csel	w9, w17, w9, lo
	strh	w18, [x15, :lo12:c_ftl_nand_reserved_blks]
	lsl	w15, w8, #6
	add	w17, w9, #3                     // =3
	add	w11, w11, #9                    // =9
	and	w9, w9, #0xffff
	lsr	w15, w15, w11
	udiv	w9, w9, w12
	adrp	x16, c_ftl_nand_max_vendor_blks
	add	w9, w15, w9
	strh	w17, [x16, :lo12:c_ftl_nand_max_vendor_blks]
	cmp	w12, #1                         // =1
	add	w17, w9, #8                     // =8
	add	w9, w9, #12                     // =12
	csel	w9, w9, w17, eq
	and	w17, w9, #0xffff
	mov	w16, #24
	cmp	w17, #24                        // =24
	adrp	x18, c_ftl_nand_map_blks_per_plane
	csel	w9, w9, w16, hi
	adrp	x16, c_ftl_nand_data_blks_per_plane
	sub	w8, w8, w9
	strh	w15, [x18, :lo12:c_ftl_nand_map_blks_per_plane]
	orr	w18, wzr, #0x3
	and	w9, w9, #0xffff
	strh	w8, [x16, :lo12:c_ftl_nand_data_blks_per_plane]
	adrp	x8, c_ftl_nand_max_sys_blks
	madd	w15, w15, w12, w18
	mul	w12, w9, w12
	adrp	x16, c_ftl_nand_max_data_blks
	str	w12, [x8, :lo12:c_ftl_nand_max_sys_blks]
	sub	w8, w14, w12
	str	w8, [x16, :lo12:c_ftl_nand_max_data_blks]
	mul	w8, w10, w8
	adrp	x13, c_ftl_nand_totle_phy_blks
	lsl	w8, w8, #2
	adrp	x17, c_ftl_nand_sys_blks_per_plane
	str	w14, [x13, :lo12:c_ftl_nand_totle_phy_blks]
	adrp	x13, g_MaxLbaSector
	lsr	w8, w8, w11
	str	wzr, [x13, :lo12:g_MaxLbaSector]
	adrp	x13, c_ftl_nand_init_sys_blks_per_plane
	adrp	x18, c_ftl_nand_map_region_num
	str	w9, [x17, :lo12:c_ftl_nand_sys_blks_per_plane]
	adrp	x17, c_ftl_nand_max_map_blks
	add	w8, w8, #2                      // =2
	str	w9, [x13, :lo12:c_ftl_nand_init_sys_blks_per_plane]
	strh	w8, [x18, :lo12:c_ftl_nand_map_region_num]
	str	w15, [x17, :lo12:c_ftl_nand_max_map_blks]
	mov	w0, wzr
	hint	#29
	ret
.Lfunc_end9:
	.size	FtlConstantsInit, .Lfunc_end9-FtlConstantsInit
                                        // -- End function
	.globl	FtlMemInit                      // -- Begin function FtlMemInit
	.p2align	2
	.type	FtlMemInit,@function
FtlMemInit:                             // @FtlMemInit
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-96]!           // 16-byte Folded Spill
	adrp	x9, g_gc_head_data_block
	mov	w10, #65535
	adrp	x8, g_GlobalSysVersion
	str	w10, [x9, :lo12:g_gc_head_data_block]
	adrp	x9, g_gc_next_blk
	strh	w10, [x9, :lo12:g_gc_next_blk]
	adrp	x9, g_gc_next_blk_1
	str	wzr, [x8, :lo12:g_GlobalSysVersion]
	adrp	x8, g_totle_write_page_count
	strh	w10, [x9, :lo12:g_gc_next_blk_1]
	adrp	x9, g_gc_free_blk_threshold
	mov	w10, #32
	str	wzr, [x8, :lo12:g_totle_write_page_count]
	adrp	x8, g_totle_l2p_write_count
	strh	w10, [x9, :lo12:g_gc_free_blk_threshold]
	adrp	x9, g_gc_merge_free_blk_threshold
	mov	w10, #128
	str	wzr, [x8, :lo12:g_totle_l2p_write_count]
	adrp	x8, g_totle_slc_erase_count
	strh	w10, [x9, :lo12:g_gc_merge_free_blk_threshold]
	adrp	x9, g_GlobalDataVersion
	str	wzr, [x8, :lo12:g_totle_slc_erase_count]
	adrp	x8, g_min_erase_count
	str	wzr, [x9, :lo12:g_GlobalDataVersion]
	adrp	x9, g_totle_discard_page_count
	str	wzr, [x8, :lo12:g_min_erase_count]
	adrp	x8, g_gc_head_data_block_count
	stp	x20, x19, [sp, #80]             // 16-byte Folded Spill
	adrp	x10, g_totle_gc_page_count
	str	wzr, [x9, :lo12:g_totle_discard_page_count]
	adrp	x9, g_totle_read_page_count
	str	wzr, [x8, :lo12:g_gc_head_data_block_count]
	adrp	x8, g_gc_blk_index
	adrp	x19, c_ftl_nand_page_pre_super_blk
	str	wzr, [x10, :lo12:g_totle_gc_page_count]
	adrp	x10, g_totle_cache_write_count
	str	wzr, [x9, :lo12:g_totle_read_page_count]
	adrp	x9, g_totle_sys_slc_erase_count
	strh	wzr, [x8, :lo12:g_gc_blk_index]
	ldrh	w8, [x19, :lo12:c_ftl_nand_page_pre_super_blk]
	str	wzr, [x10, :lo12:g_totle_cache_write_count]
	adrp	x10, g_totle_mlc_erase_count
	str	wzr, [x9, :lo12:g_totle_sys_slc_erase_count]
	adrp	x9, g_in_gc_progress
	str	wzr, [x10, :lo12:g_totle_mlc_erase_count]
	adrp	x10, g_max_erase_count
	str	wzr, [x9, :lo12:g_in_gc_progress]
	adrp	x9, g_gc_skip_write_count
	str	wzr, [x10, :lo12:g_max_erase_count]
	adrp	x10, g_in_swl_replace
	str	wzr, [x9, :lo12:g_gc_skip_write_count]
	adrp	x9, g_gc_bad_block_temp_num
	str	wzr, [x10, :lo12:g_in_swl_replace]
	adrp	x10, g_cur_erase_blk
	strh	wzr, [x9, :lo12:g_gc_bad_block_temp_num]
	adrp	x9, g_gc_bad_block_gc_index
	lsl	w0, w8, #1
	stp	x28, x27, [sp, #16]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #32]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #48]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #64]             // 16-byte Folded Spill
	mov	x29, sp
	str	wzr, [x10, :lo12:g_cur_erase_blk]
	strh	wzr, [x9, :lo12:g_gc_bad_block_gc_index]
	bl	ftl_malloc
	ldrh	w8, [x19, :lo12:c_ftl_nand_page_pre_super_blk]
	adrp	x9, p_gc_blk_tbl
	str	x0, [x9, :lo12:p_gc_blk_tbl]
	add	w8, w8, w8, lsl #1
	lsl	w0, w8, #2
	bl	ftl_malloc
	adrp	x21, c_ftl_nand_planes_num
	ldrh	w8, [x21, :lo12:c_ftl_nand_planes_num]
	adrp	x9, p_gc_page_info
	str	x0, [x9, :lo12:p_gc_page_info]
	lsl	w20, w8, #7
	mov	w0, w20
	lsl	w19, w8, #5
	bl	ftl_malloc
	adrp	x8, req_read
	str	x0, [x8, :lo12:req_read]
	mov	w0, w19
	bl	ftl_malloc
	adrp	x8, req_gc_dst
	str	x0, [x8, :lo12:req_gc_dst]
	mov	w0, w20
	bl	ftl_malloc
	adrp	x8, req_prgm
	str	x0, [x8, :lo12:req_prgm]
	mov	w0, w19
	bl	ftl_malloc
	adrp	x8, req_erase
	str	x0, [x8, :lo12:req_erase]
	mov	w0, w19
	bl	ftl_malloc
	adrp	x20, c_ftl_nand_byte_pre_page
	ldrh	w8, [x21, :lo12:c_ftl_nand_planes_num]
	ldrh	w19, [x20, :lo12:c_ftl_nand_byte_pre_page]
	adrp	x10, req_gc
	mov	w9, #1
	str	x0, [x10, :lo12:req_gc]
	bfi	w9, w8, #1, #16
	adrp	x22, c_gc_page_buf_num
	mov	w0, w19
	mov	w25, #1
	str	w9, [x22, :lo12:c_gc_page_buf_num]
	bl	ftl_malloc
	adrp	x8, p_sys_data_buf
	str	x0, [x8, :lo12:p_sys_data_buf]
	mov	w0, w19
	bl	ftl_malloc
	adrp	x8, p_sys_data_buf_1
	str	x0, [x8, :lo12:p_sys_data_buf_1]
	mov	w0, w19
	bl	ftl_malloc
	ldr	w8, [x22, :lo12:c_gc_page_buf_num]
	adrp	x9, p_vendor_data_buf
	str	x0, [x9, :lo12:p_vendor_data_buf]
	mul	w0, w8, w19
	bl	ftl_malloc
	adrp	x8, p_gc_data_buf
	str	x0, [x8, :lo12:p_gc_data_buf]
	mov	w0, w19
	bl	ftl_malloc
	adrp	x8, p_io_data_buf_0
	str	x0, [x8, :lo12:p_io_data_buf_0]
	mov	w0, w19
	bl	ftl_malloc
	ldr	w8, [x22, :lo12:c_gc_page_buf_num]
	adrp	x9, p_io_data_buf_1
	str	x0, [x9, :lo12:p_io_data_buf_1]
	add	w8, w8, w8, lsl #1
	lsl	w0, w8, #3
	bl	ftl_malloc
	adrp	x8, gp_gc_page_buf_info
	str	x0, [x8, :lo12:gp_gc_page_buf_info]
	mov	w0, w19
	bl	ftl_malloc
	adrp	x8, sftl_nand_check_buf
	str	x0, [x8, :lo12:sftl_nand_check_buf]
	mov	w0, w19
	bl	ftl_malloc
	adrp	x8, c_ftl_nand_sec_pre_page
	ldrh	w8, [x8, :lo12:c_ftl_nand_sec_pre_page]
	adrp	x9, sftl_temp_buf
	str	x0, [x9, :lo12:sftl_temp_buf]
	lsl	w0, w8, #2
	bl	ftl_malloc
	adrp	x23, c_ftl_nand_byte_pre_oob
	ldrh	w8, [x23, :lo12:c_ftl_nand_byte_pre_oob]
	ldrh	w9, [x21, :lo12:c_ftl_nand_planes_num]
	adrp	x10, sftl_nand_check_spare_buf
	str	x0, [x10, :lo12:sftl_nand_check_spare_buf]
	mul	w19, w9, w8
	mov	w0, w19
	bl	ftl_malloc
	adrp	x8, p_sys_spare_buf
	str	x0, [x8, :lo12:p_sys_spare_buf]
	lsl	w0, w19, #2
	bl	ftl_malloc
	ldrh	w8, [x23, :lo12:c_ftl_nand_byte_pre_oob]
	ldr	w9, [x22, :lo12:c_gc_page_buf_num]
	adrp	x10, p_io_spare_buf
	str	x0, [x10, :lo12:p_io_spare_buf]
	mul	w0, w9, w8
	bl	ftl_malloc
	adrp	x23, c_ftl_nand_blk_pre_plane
	ldrh	w8, [x23, :lo12:c_ftl_nand_blk_pre_plane]
	adrp	x9, p_gc_spare_buf
	adrp	x19, g_ect_tbl_info_size
	str	x0, [x9, :lo12:p_gc_spare_buf]
	lsl	w8, w8, #1
	and	w0, w8, #0xfffe
	strh	w8, [x19, :lo12:g_ect_tbl_info_size]
	bl	ftl_malloc
	ldrh	w8, [x19, :lo12:g_ect_tbl_info_size]
	adrp	x9, p_swl_mul_table
	str	x0, [x9, :lo12:p_swl_mul_table]
	add	w8, w8, #547                    // =547
	lsr	w9, w8, #9
	and	w0, w8, #0x1fe00
	strh	w9, [x19, :lo12:g_ect_tbl_info_size]
	bl	ftl_malloc
	ldrh	w9, [x23, :lo12:c_ftl_nand_blk_pre_plane]
	adrp	x8, gp_ect_tbl_info
	str	x0, [x8, :lo12:gp_ect_tbl_info]
	add	x8, x0, #32                     // =32
	lsl	w19, w9, #1
	adrp	x10, p_erase_count_table
	mov	w0, w19
	str	x8, [x10, :lo12:p_erase_count_table]
	bl	ftl_malloc
	adrp	x8, p_valid_page_count_check_table
	str	x0, [x8, :lo12:p_valid_page_count_check_table]
	mov	w0, w19
	bl	ftl_malloc
	adrp	x21, c_ftl_nand_max_map_blks
	ldr	w8, [x21, :lo12:c_ftl_nand_max_map_blks]
	adrp	x9, p_valid_page_count_table
	str	x0, [x9, :lo12:p_valid_page_count_table]
	lsl	w19, w8, #1
	mov	w0, w19
	bl	ftl_malloc
	adrp	x26, p_map_block_table
	str	x0, [x26, :lo12:p_map_block_table]
	mov	w0, w19
	bl	ftl_malloc
	adrp	x19, c_ftl_nand_max_vendor_blks
	ldrh	w8, [x19, :lo12:c_ftl_nand_max_vendor_blks]
	adrp	x22, p_map_block_valid_page_count
	str	x0, [x22, :lo12:p_map_block_valid_page_count]
	lsl	w0, w8, #1
	bl	ftl_malloc
	ldrh	w8, [x19, :lo12:c_ftl_nand_max_vendor_blks]
	adrp	x9, p_vendor_block_table
	str	x0, [x9, :lo12:p_vendor_block_table]
	lsl	w0, w8, #1
	bl	ftl_malloc
	ldrh	w8, [x19, :lo12:c_ftl_nand_max_vendor_blks]
	adrp	x9, p_vendor_block_valid_page_count
	str	x0, [x9, :lo12:p_vendor_block_valid_page_count]
	lsl	w0, w8, #2
	bl	ftl_malloc
	adrp	x19, c_ftl_nand_vendor_region_num
	ldrh	w8, [x19, :lo12:c_ftl_nand_vendor_region_num]
	adrp	x9, p_vendor_block_ver_table
	str	x0, [x9, :lo12:p_vendor_block_ver_table]
	lsl	w0, w8, #2
	bl	ftl_malloc
	ldrh	w8, [x19, :lo12:c_ftl_nand_vendor_region_num]
	adrp	x9, p_vendor_region_ppn_table
	mov	w1, wzr
	str	x0, [x9, :lo12:p_vendor_region_ppn_table]
	lsl	x2, x8, #2
	bl	memset
	adrp	x8, c_ftl_nand_map_region_num
	ldrh	w8, [x8, :lo12:c_ftl_nand_map_region_num]
	lsl	w0, w8, #2
	bl	ftl_malloc
	ldr	w8, [x21, :lo12:c_ftl_nand_max_map_blks]
	adrp	x21, p_map_region_ppn_table
	str	x0, [x21, :lo12:p_map_region_ppn_table]
	lsl	w0, w8, #2
	bl	ftl_malloc
	adrp	x24, c_ftl_nand_l2pmap_ram_region_num
	ldrh	w8, [x24, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	adrp	x19, p_map_block_ver_table
	str	x0, [x19, :lo12:p_map_block_ver_table]
	lsl	w0, w8, #4
	bl	ftl_malloc
	ldrh	w8, [x24, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	ldrh	w9, [x20, :lo12:c_ftl_nand_byte_pre_page]
	adrp	x20, p_l2p_ram_map
	str	x0, [x20, :lo12:p_l2p_ram_map]
	mul	w0, w9, w8
	bl	ftl_malloc
	ldrh	w8, [x23, :lo12:c_ftl_nand_blk_pre_plane]
	adrp	x24, p_l2p_map_buf
	str	x0, [x24, :lo12:p_l2p_map_buf]
	add	w8, w8, w8, lsl #1
	lsl	w0, w8, #1
	bl	ftl_malloc
	adrp	x8, c_ftl_nand_blks_per_die
	ldrh	w8, [x8, :lo12:c_ftl_nand_blks_per_die]
	adrp	x27, c_ftl_nand_die_num
	ldrh	w9, [x27, :lo12:c_ftl_nand_die_num]
	adrp	x28, c_ftl_nand_bbm_buf_size
	add	w8, w8, #31                     // =31
	lsr	w8, w8, #5
	adrp	x23, p_data_block_list_table
	strh	w8, [x28, :lo12:c_ftl_nand_bbm_buf_size]
	mul	w8, w9, w8
	str	x0, [x23, :lo12:p_data_block_list_table]
	lsl	w0, w8, #2
	bl	ftl_malloc
	ldrh	w9, [x27, :lo12:c_ftl_nand_die_num]
	adrp	x8, gBbtInfo
	adrp	x27, gBbtInfo+32
	add	x8, x8, :lo12:gBbtInfo
	cmp	w9, #2                          // =2
	str	x0, [x27, :lo12:gBbtInfo+32]
	b.lo	.LBB10_9
// %bb.1:
	ldrh	w10, [x28, :lo12:c_ftl_nand_bbm_buf_size]
	cmp	w9, #2                          // =2
	mov	w11, #2
	csel	w25, w9, w11, hi
	sub	x12, x25, #1                    // =1
	cmp	x12, #2                         // =2
	lsl	x9, x10, #2
	b.hs	.LBB10_3
// %bb.2:
	mov	w11, #1
	b	.LBB10_6
.LBB10_3:
	and	x13, x12, #0xfffffffffffffffe
	adrp	x15, gBbtInfo+48
	orr	x11, x12, #0x1
	lsl	x14, x10, #3
	add	x15, x15, :lo12:gBbtInfo+48
	mov	x16, x13
	mov	x17, x0
.LBB10_4:                               // =>This Inner Loop Header: Depth=1
	add	x18, x17, x9
	add	x17, x17, x14
	subs	x16, x16, #2                    // =2
	stp	x18, x17, [x15, #-8]
	add	x15, x15, #16                   // =16
	b.ne	.LBB10_4
// %bb.5:
	cmp	x12, x13
	b.eq	.LBB10_8
.LBB10_6:
	add	x12, x8, x11, lsl #3
	mul	x13, x11, x10
	add	x10, x12, #32                   // =32
	add	x12, x0, x13, lsl #2
	sub	x11, x25, x11
.LBB10_7:                               // =>This Inner Loop Header: Depth=1
	str	x12, [x10], #8
	subs	x11, x11, #1                    // =1
	add	x12, x12, x9
	b.ne	.LBB10_7
.LBB10_8:
	cmp	w25, #7                         // =7
	b.hi	.LBB10_10
.LBB10_9:
	add	x8, x8, w25, uxtw #3
	mov	w9, #7
	add	x0, x8, #32                     // =32
	sub	w8, w9, w25
	lsl	x8, x8, #3
	add	x2, x8, #8                      // =8
	mov	w1, wzr
	bl	memset
.LBB10_10:
	ldr	x8, [x26, :lo12:p_map_block_table]
	cbz	x8, .LBB10_43
// %bb.11:
	ldr	x8, [x22, :lo12:p_map_block_valid_page_count]
	cbz	x8, .LBB10_43
// %bb.12:
	ldr	x8, [x21, :lo12:p_map_region_ppn_table]
	cbz	x8, .LBB10_43
// %bb.13:
	ldr	x8, [x19, :lo12:p_map_block_ver_table]
	cbz	x8, .LBB10_43
// %bb.14:
	ldr	x8, [x20, :lo12:p_l2p_ram_map]
	cbz	x8, .LBB10_43
// %bb.15:
	ldr	x8, [x24, :lo12:p_l2p_map_buf]
	cbz	x8, .LBB10_43
// %bb.16:
	ldr	x8, [x23, :lo12:p_data_block_list_table]
	cbz	x8, .LBB10_43
// %bb.17:
	ldr	x8, [x27, :lo12:gBbtInfo+32]
	cbz	x8, .LBB10_43
// %bb.18:
	adrp	x8, p_valid_page_count_table
	ldr	x8, [x8, :lo12:p_valid_page_count_table]
	cbz	x8, .LBB10_43
// %bb.19:
	adrp	x8, p_gc_blk_tbl
	ldr	x8, [x8, :lo12:p_gc_blk_tbl]
	cbz	x8, .LBB10_43
// %bb.20:
	adrp	x8, p_gc_page_info
	ldr	x8, [x8, :lo12:p_gc_page_info]
	cbz	x8, .LBB10_43
// %bb.21:
	adrp	x8, req_read
	ldr	x8, [x8, :lo12:req_read]
	cbz	x8, .LBB10_43
// %bb.22:
	adrp	x8, req_prgm
	ldr	x8, [x8, :lo12:req_prgm]
	cbz	x8, .LBB10_43
// %bb.23:
	adrp	x8, req_erase
	ldr	x8, [x8, :lo12:req_erase]
	cbz	x8, .LBB10_43
// %bb.24:
	adrp	x8, req_gc
	ldr	x8, [x8, :lo12:req_gc]
	cbz	x8, .LBB10_43
// %bb.25:
	adrp	x8, req_gc_dst
	ldr	x8, [x8, :lo12:req_gc_dst]
	cbz	x8, .LBB10_43
// %bb.26:
	adrp	x8, p_sys_data_buf
	ldr	x8, [x8, :lo12:p_sys_data_buf]
	cbz	x8, .LBB10_43
// %bb.27:
	adrp	x8, p_sys_data_buf_1
	ldr	x8, [x8, :lo12:p_sys_data_buf_1]
	cbz	x8, .LBB10_43
// %bb.28:
	adrp	x8, p_vendor_data_buf
	ldr	x8, [x8, :lo12:p_vendor_data_buf]
	cbz	x8, .LBB10_43
// %bb.29:
	adrp	x8, p_gc_data_buf
	ldr	x8, [x8, :lo12:p_gc_data_buf]
	cbz	x8, .LBB10_43
// %bb.30:
	adrp	x8, p_io_data_buf_0
	ldr	x8, [x8, :lo12:p_io_data_buf_0]
	cbz	x8, .LBB10_43
// %bb.31:
	adrp	x8, p_io_data_buf_1
	ldr	x8, [x8, :lo12:p_io_data_buf_1]
	cbz	x8, .LBB10_43
// %bb.32:
	adrp	x8, gp_gc_page_buf_info
	ldr	x8, [x8, :lo12:gp_gc_page_buf_info]
	cbz	x8, .LBB10_43
// %bb.33:
	adrp	x8, p_sys_spare_buf
	ldr	x8, [x8, :lo12:p_sys_spare_buf]
	cbz	x8, .LBB10_43
// %bb.34:
	adrp	x8, p_io_spare_buf
	ldr	x8, [x8, :lo12:p_io_spare_buf]
	cbz	x8, .LBB10_43
// %bb.35:
	adrp	x8, p_gc_spare_buf
	ldr	x8, [x8, :lo12:p_gc_spare_buf]
	cbz	x8, .LBB10_43
// %bb.36:
	adrp	x8, p_erase_count_table
	ldr	x8, [x8, :lo12:p_erase_count_table]
	cbz	x8, .LBB10_43
// %bb.37:
	adrp	x8, p_swl_mul_table
	ldr	x8, [x8, :lo12:p_swl_mul_table]
	cbz	x8, .LBB10_43
// %bb.38:
	adrp	x8, p_vendor_block_table
	ldr	x8, [x8, :lo12:p_vendor_block_table]
	cbz	x8, .LBB10_43
// %bb.39:
	adrp	x8, p_vendor_block_valid_page_count
	ldr	x8, [x8, :lo12:p_vendor_block_valid_page_count]
	cbz	x8, .LBB10_43
// %bb.40:
	adrp	x8, p_vendor_block_ver_table
	ldr	x8, [x8, :lo12:p_vendor_block_ver_table]
	cbz	x8, .LBB10_43
// %bb.41:
	adrp	x8, p_vendor_region_ppn_table
	ldr	x8, [x8, :lo12:p_vendor_region_ppn_table]
	cbz	x8, .LBB10_43
// %bb.42:
	mov	w0, wzr
	b	.LBB10_44
.LBB10_43:
	adrp	x0, .L.str.76
	adrp	x1, .L__func__.FtlMemInit
	add	x0, x0, :lo12:.L.str.76
	add	x1, x1, :lo12:.L__func__.FtlMemInit
	bl	sftl_printk
	mov	w0, #-1
.LBB10_44:
	ldp	x20, x19, [sp, #80]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #96             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end10:
	.size	FtlMemInit, .Lfunc_end10-FtlMemInit
                                        // -- End function
	.globl	ftl_malloc                      // -- Begin function ftl_malloc
	.p2align	2
	.type	ftl_malloc,@function
ftl_malloc:                             // @ftl_malloc
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
                                        // kill: def $w0 killed $w0 def $x0
	mov	w1, #3265
	sxtw	x0, w0
	mov	x29, sp
	bl	__kmalloc
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end11:
	.size	ftl_malloc, .Lfunc_end11-ftl_malloc
                                        // -- End function
	.globl	ftl_memset                      // -- Begin function ftl_memset
	.p2align	2
	.type	ftl_memset,@function
ftl_memset:                             // @ftl_memset
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	mov	w2, w2
	str	x19, [sp, #16]                  // 8-byte Folded Spill
	mov	x29, sp
	mov	x19, x0
	bl	memset
	mov	x0, x19
	ldr	x19, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end12:
	.size	ftl_memset, .Lfunc_end12-ftl_memset
                                        // -- End function
	.globl	FtlVariablesInit                // -- Begin function FtlVariablesInit
	.p2align	2
	.type	FtlVariablesInit,@function
FtlVariablesInit:                       // @FtlVariablesInit
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-64]!           // 16-byte Folded Spill
	adrp	x9, g_recovery_page_min_ver
	mov	w10, #-1
	str	w10, [x9, :lo12:g_recovery_page_min_ver]
	adrp	x9, g_totle_swl_count
	stp	x20, x19, [sp, #48]             // 16-byte Folded Spill
	adrp	x8, g_tmp_data_superblock_id
	mov	w19, #65535
	str	wzr, [x9, :lo12:g_totle_swl_count]
	adrp	x9, c_ftl_nand_max_vendor_blks
	strh	w19, [x8, :lo12:g_tmp_data_superblock_id]
	adrp	x8, p_vendor_block_table
	ldrh	w9, [x9, :lo12:c_ftl_nand_max_vendor_blks]
	ldr	x0, [x8, :lo12:p_vendor_block_table]
	adrp	x10, ftl_gc_temp_power_lost_recovery_flag
	adrp	x8, g_totle_vendor_block
	lsl	x2, x9, #1
	mov	w1, wzr
	stp	x24, x23, [sp, #16]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #32]             // 16-byte Folded Spill
	mov	x29, sp
	str	wzr, [x10, :lo12:ftl_gc_temp_power_lost_recovery_flag]
	strh	wzr, [x8, :lo12:g_totle_vendor_block]
	bl	memset
	adrp	x20, c_ftl_nand_blk_pre_plane
	adrp	x8, p_erase_count_table
	ldrh	w9, [x20, :lo12:c_ftl_nand_blk_pre_plane]
	ldr	x0, [x8, :lo12:p_erase_count_table]
	mov	w1, wzr
	lsl	x2, x9, #1
	bl	memset
	adrp	x8, p_swl_mul_table
	ldrh	w9, [x20, :lo12:c_ftl_nand_blk_pre_plane]
	ldr	x0, [x8, :lo12:p_swl_mul_table]
	mov	w1, wzr
	lsl	x2, x9, #1
	bl	memset
	adrp	x8, g_sys_save_data
	adrp	x0, g_sys_ext_data
	add	x8, x8, :lo12:g_sys_save_data
	add	x0, x0, :lo12:g_sys_ext_data
	mov	w2, #512
	mov	w1, wzr
	stp	xzr, xzr, [x8]
	stp	xzr, xzr, [x8, #16]
	stp	xzr, xzr, [x8, #32]
	bl	memset
	bl	FtlGcBufInit
	adrp	x21, c_ftl_nand_max_map_blks
	adrp	x20, p_map_block_valid_page_count
	ldr	w8, [x21, :lo12:c_ftl_nand_max_map_blks]
	ldr	x0, [x20, :lo12:p_map_block_valid_page_count]
	mov	w1, wzr
	lsl	w2, w8, #1
	bl	memset
	adrp	x23, c_ftl_nand_byte_pre_page
	adrp	x24, c_ftl_nand_l2pmap_ram_region_num
	adrp	x22, p_l2p_map_buf
	ldrh	w8, [x23, :lo12:c_ftl_nand_byte_pre_page]
	ldrh	w9, [x24, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	ldr	x0, [x22, :lo12:p_l2p_map_buf]
	mov	w1, #255
	mul	x2, x9, x8
	bl	memset
	ldrh	w8, [x24, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	cbz	w8, .LBB13_3
// %bb.1:
	mov	x8, xzr
	mov	x9, xzr
	mov	x10, xzr
	adrp	x11, p_l2p_ram_map
	mov	x12, #4294967296
.LBB13_2:                               // =>This Inner Loop Header: Depth=1
	ldr	x13, [x11, :lo12:p_l2p_ram_map]
	add	x10, x10, #1                    // =1
	add	x13, x13, x8
	str	wzr, [x13, #4]
	ldr	x13, [x11, :lo12:p_l2p_ram_map]
	strh	w19, [x13, x8]
	ldrh	w13, [x23, :lo12:c_ftl_nand_byte_pre_page]
	ldr	x14, [x22, :lo12:p_l2p_map_buf]
	ldr	x15, [x11, :lo12:p_l2p_ram_map]
	mul	x13, x9, x13
	asr	x13, x13, #32
	and	x13, x13, #0xfffffffffffffffc
	add	x13, x14, x13
	add	x14, x15, x8
	str	x13, [x14, #8]
	ldrh	w13, [x24, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	add	x9, x9, x12
	add	x8, x8, #16                     // =16
	cmp	x10, x13
	b.lo	.LBB13_2
.LBB13_3:
	adrp	x8, gL2pMapInfo
	add	x8, x8, :lo12:gL2pMapInfo
	mov	w9, #-255655937
	stur	w9, [x8, #2]
	adrp	x9, g_totle_map_block
	adrp	x11, c_ftl_nand_map_region_num
	ldr	w10, [x21, :lo12:c_ftl_nand_max_map_blks]
	ldrh	w9, [x9, :lo12:g_totle_map_block]
	ldrh	w11, [x11, :lo12:c_ftl_nand_map_region_num]
	ldr	x12, [x20, :lo12:p_map_block_valid_page_count]
	strh	w10, [x8, #10]
	adrp	x10, p_map_block_table
	strh	w9, [x8, #8]
	adrp	x9, p_map_block_ver_table
	strh	w11, [x8, #6]
	adrp	x11, p_map_region_ppn_table
	ldr	x10, [x10, :lo12:p_map_block_table]
	ldr	x9, [x9, :lo12:p_map_block_ver_table]
	ldr	x11, [x11, :lo12:p_map_region_ppn_table]
	strh	w19, [x8]
	ldp	x20, x19, [sp, #48]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #32]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #16]             // 16-byte Folded Reload
	stp	x10, x9, [x8, #16]
	stp	x12, x11, [x8, #32]
	mov	w0, wzr
	ldp	x29, x30, [sp], #64             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end13:
	.size	FtlVariablesInit, .Lfunc_end13-FtlVariablesInit
                                        // -- End function
	.globl	FtlGcBufInit                    // -- Begin function FtlGcBufInit
	.p2align	2
	.type	FtlGcBufInit,@function
FtlGcBufInit:                           // @FtlGcBufInit
// %bb.0:
	hint	#25
	adrp	x8, c_ftl_nand_planes_num
	ldrh	w9, [x8, :lo12:c_ftl_nand_planes_num]
	adrp	x10, g_gc_num_req
	str	wzr, [x10, :lo12:g_gc_num_req]
	cbz	w9, .LBB14_4
// %bb.1:
	mov	x9, xzr
	mov	x10, xzr
	mov	x11, xzr
	adrp	x12, gp_gc_page_buf_info
	mov	w13, #1
	adrp	x14, p_gc_data_buf
	adrp	x15, c_ftl_nand_byte_pre_page
	adrp	x16, p_gc_spare_buf
	adrp	x17, c_ftl_nand_byte_pre_oob
	adrp	x18, req_gc
.LBB14_2:                               // =>This Inner Loop Header: Depth=1
	ldr	x0, [x12, :lo12:gp_gc_page_buf_info]
	add	x0, x0, x10
	str	w13, [x0, #16]
	ldrh	w0, [x15, :lo12:c_ftl_nand_byte_pre_page]
	ldr	x1, [x14, :lo12:p_gc_data_buf]
	ldr	x2, [x12, :lo12:gp_gc_page_buf_info]
	mul	w0, w11, w0
	add	w3, w0, #3                      // =3
	cmp	w0, #0                          // =0
	csel	w0, w3, w0, lt
	asr	w0, w0, #2
	add	x0, x1, w0, sxtw #2
	str	x0, [x2, x10]
	ldrh	w0, [x17, :lo12:c_ftl_nand_byte_pre_oob]
	ldr	x1, [x16, :lo12:p_gc_spare_buf]
	ldr	x2, [x12, :lo12:gp_gc_page_buf_info]
	mul	w0, w11, w0
	add	w3, w0, #3                      // =3
	cmp	w0, #0                          // =0
	csel	w0, w3, w0, lt
	asr	w0, w0, #2
	add	x2, x2, x10
	add	x0, x1, w0, sxtw #2
	str	x0, [x2, #8]
	ldr	x0, [x12, :lo12:gp_gc_page_buf_info]
	ldr	x1, [x18, :lo12:req_gc]
	add	x11, x11, #1                    // =1
	ldr	x0, [x0, x10]
	add	x1, x1, x9
	str	x0, [x1, #8]
	ldr	x0, [x12, :lo12:gp_gc_page_buf_info]
	ldr	x1, [x18, :lo12:req_gc]
	add	x0, x0, x10
	ldr	x0, [x0, #8]
	add	x1, x1, x9
	add	x10, x10, #24                   // =24
	add	x9, x9, #32                     // =32
	str	x0, [x1, #16]
	ldrh	w0, [x8, :lo12:c_ftl_nand_planes_num]
	cmp	x11, x0
	b.lo	.LBB14_2
// %bb.3:
	mov	w8, w0
	b	.LBB14_5
.LBB14_4:
	mov	w8, wzr
.LBB14_5:
	adrp	x9, c_gc_page_buf_num
	ldr	w10, [x9, :lo12:c_gc_page_buf_num]
	cmp	w10, w8
	b.ls	.LBB14_8
// %bb.6:
	adrp	x10, gp_gc_page_buf_info
	adrp	x11, p_gc_data_buf
	adrp	x12, c_ftl_nand_byte_pre_page
	adrp	x13, p_gc_spare_buf
	adrp	x14, c_ftl_nand_byte_pre_oob
.LBB14_7:                               // =>This Inner Loop Header: Depth=1
	ldr	x15, [x10, :lo12:gp_gc_page_buf_info]
	and	x16, x8, #0xffff
	add	x16, x16, w8, uxth #1
	lsl	x16, x16, #3
	add	x15, x15, x16
	str	wzr, [x15, #16]
	ldrh	w15, [x12, :lo12:c_ftl_nand_byte_pre_page]
	ldr	x17, [x11, :lo12:p_gc_data_buf]
	ldr	x18, [x10, :lo12:gp_gc_page_buf_info]
	mul	w15, w8, w15
	add	w0, w15, #3                     // =3
	cmp	w15, #0                         // =0
	csel	w15, w0, w15, lt
	asr	w15, w15, #2
	add	x15, x17, w15, sxtw #2
	str	x15, [x18, x16]
	ldrh	w15, [x14, :lo12:c_ftl_nand_byte_pre_oob]
	ldr	x17, [x13, :lo12:p_gc_spare_buf]
	ldr	x18, [x10, :lo12:gp_gc_page_buf_info]
	mul	w15, w8, w15
	add	w0, w15, #3                     // =3
	cmp	w15, #0                         // =0
	csel	w15, w0, w15, lt
	asr	w15, w15, #2
	add	x15, x17, w15, sxtw #2
	add	x16, x18, x16
	str	x15, [x16, #8]
	ldr	w15, [x9, :lo12:c_gc_page_buf_num]
	add	w8, w8, #1                      // =1
	and	w8, w8, #0xffff
	cmp	w15, w8
	b.hi	.LBB14_7
.LBB14_8:
	hint	#29
	ret
.Lfunc_end14:
	.size	FtlGcBufInit, .Lfunc_end14-FtlGcBufInit
                                        // -- End function
	.globl	FtlL2PDataInit                  // -- Begin function FtlL2PDataInit
	.p2align	2
	.type	FtlL2PDataInit,@function
FtlL2PDataInit:                         // @FtlL2PDataInit
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-64]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #48]             // 16-byte Folded Spill
	adrp	x20, c_ftl_nand_max_map_blks
	adrp	x19, p_map_block_valid_page_count
	ldr	w8, [x20, :lo12:c_ftl_nand_max_map_blks]
	ldr	x0, [x19, :lo12:p_map_block_valid_page_count]
	mov	w1, wzr
	str	x23, [sp, #16]                  // 8-byte Folded Spill
	lsl	w2, w8, #1
	stp	x22, x21, [sp, #32]             // 16-byte Folded Spill
	mov	x29, sp
	bl	memset
	adrp	x22, c_ftl_nand_byte_pre_page
	adrp	x23, c_ftl_nand_l2pmap_ram_region_num
	adrp	x21, p_l2p_map_buf
	ldrh	w8, [x22, :lo12:c_ftl_nand_byte_pre_page]
	ldrh	w9, [x23, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	ldr	x0, [x21, :lo12:p_l2p_map_buf]
	mov	w1, #255
	mul	x2, x9, x8
	bl	memset
	ldrh	w8, [x23, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	cbz	w8, .LBB15_3
// %bb.1:
	mov	x8, xzr
	mov	x9, xzr
	mov	x10, xzr
	adrp	x11, p_l2p_ram_map
	mov	w12, #65535
	mov	x13, #4294967296
.LBB15_2:                               // =>This Inner Loop Header: Depth=1
	ldr	x14, [x11, :lo12:p_l2p_ram_map]
	add	x10, x10, #1                    // =1
	add	x14, x14, x9
	str	wzr, [x14, #4]
	ldr	x14, [x11, :lo12:p_l2p_ram_map]
	strh	w12, [x14, x9]
	ldrh	w14, [x22, :lo12:c_ftl_nand_byte_pre_page]
	ldr	x15, [x21, :lo12:p_l2p_map_buf]
	ldr	x16, [x11, :lo12:p_l2p_ram_map]
	mul	x14, x8, x14
	asr	x14, x14, #32
	and	x14, x14, #0xfffffffffffffffc
	add	x14, x15, x14
	add	x15, x16, x9
	str	x14, [x15, #8]
	ldrh	w14, [x23, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	add	x9, x9, #16                     // =16
	add	x8, x8, x13
	cmp	x10, x14
	b.lo	.LBB15_2
.LBB15_3:
	adrp	x8, gL2pMapInfo
	add	x8, x8, :lo12:gL2pMapInfo
	mov	w9, #-255655937
	mov	w10, #65535
	stur	w9, [x8, #2]
	adrp	x9, g_totle_map_block
	strh	w10, [x8]
	adrp	x10, c_ftl_nand_map_region_num
	ldr	w11, [x20, :lo12:c_ftl_nand_max_map_blks]
	ldrh	w9, [x9, :lo12:g_totle_map_block]
	ldrh	w10, [x10, :lo12:c_ftl_nand_map_region_num]
	ldr	x12, [x19, :lo12:p_map_block_valid_page_count]
	strh	w11, [x8, #10]
	adrp	x11, p_map_block_table
	strh	w9, [x8, #8]
	adrp	x9, p_map_block_ver_table
	strh	w10, [x8, #6]
	adrp	x10, p_map_region_ppn_table
	ldr	x11, [x11, :lo12:p_map_block_table]
	ldr	x9, [x9, :lo12:p_map_block_ver_table]
	ldr	x10, [x10, :lo12:p_map_region_ppn_table]
	ldp	x20, x19, [sp, #48]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #32]             // 16-byte Folded Reload
	ldr	x23, [sp, #16]                  // 8-byte Folded Reload
	stp	x11, x9, [x8, #16]
	stp	x12, x10, [x8, #32]
	ldp	x29, x30, [sp], #64             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end15:
	.size	FtlL2PDataInit, .Lfunc_end15-FtlL2PDataInit
                                        // -- End function
	.globl	IsBlkInVendorPart               // -- Begin function IsBlkInVendorPart
	.p2align	2
	.type	IsBlkInVendorPart,@function
IsBlkInVendorPart:                      // @IsBlkInVendorPart
// %bb.0:
	hint	#25
	adrp	x8, g_totle_vendor_block
	ldrh	w9, [x8, :lo12:g_totle_vendor_block]
	mov	w8, wzr
	cbz	w9, .LBB16_7
// %bb.1:
	adrp	x9, c_ftl_nand_max_vendor_blks
	ldrh	w9, [x9, :lo12:c_ftl_nand_max_vendor_blks]
	cbz	w9, .LBB16_7
// %bb.2:
	adrp	x8, p_vendor_block_table
	ldr	x8, [x8, :lo12:p_vendor_block_table]
	cmp	w9, #1                          // =1
	csinc	w9, w9, wzr, hi
.LBB16_3:                               // =>This Inner Loop Header: Depth=1
	ldrh	w10, [x8]
	cmp	w10, w0, uxth
	b.eq	.LBB16_6
// %bb.4:                               //   in Loop: Header=BB16_3 Depth=1
	subs	x9, x9, #1                      // =1
	add	x8, x8, #2                      // =2
	b.ne	.LBB16_3
// %bb.5:
	mov	w8, wzr
	b	.LBB16_7
.LBB16_6:
	mov	w8, #1
.LBB16_7:
	mov	w0, w8
	hint	#29
	ret
.Lfunc_end16:
	.size	IsBlkInVendorPart, .Lfunc_end16-IsBlkInVendorPart
                                        // -- End function
	.globl	FtlLowFormatEraseBlock          // -- Begin function FtlLowFormatEraseBlock
	.p2align	2
	.type	FtlLowFormatEraseBlock,@function
FtlLowFormatEraseBlock:                 // @FtlLowFormatEraseBlock
// %bb.0:
	hint	#25
	sub	sp, sp, #112                    // =112
	adrp	x17, c_ftl_nand_planes_num
	ldrh	w8, [x17, :lo12:c_ftl_nand_planes_num]
	and	w9, w0, #0xffff
	adrp	x10, g_cur_erase_blk
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	stp	x28, x27, [sp, #32]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #48]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #64]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #80]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #96]             // 16-byte Folded Spill
	add	x29, sp, #16                    // =16
	str	w9, [x10, :lo12:g_cur_erase_blk]
	cbz	w8, .LBB17_35
// %bb.1:
	adrp	x18, p_plane_order_table
	adrp	x23, gBbtInfo
	mov	w19, w1
	mov	w20, w0
	mov	x8, xzr
	mov	w21, wzr
	mov	w24, wzr
	adrp	x25, req_erase
	add	x18, x18, :lo12:p_plane_order_table
	adrp	x16, c_ftl_nand_planes_per_die
	adrp	x27, c_ftl_nand_blks_per_die
	add	x23, x23, :lo12:gBbtInfo
	adrp	x0, p_io_data_buf_1
	adrp	x9, p_io_spare_buf
	adrp	x1, c_ftl_nand_byte_pre_oob
	adrp	x2, g_totle_vendor_block
	adrp	x3, c_ftl_nand_max_vendor_blks
	adrp	x4, p_vendor_block_table
	b	.LBB17_5
.LBB17_2:                               //   in Loop: Header=BB17_5 Depth=1
	and	w12, w11, #0xffff
	and	w13, w10, #0xffff
	udiv	w13, w12, w13
	add	x14, x23, w13, uxtw #3
	ldr	x14, [x14, #32]
	msub	w10, w13, w10, w11
	lsr	w11, w10, #3
	and	x11, x11, #0x1ffc
	ldr	w11, [x14, x11]
	lsr	w10, w11, w10
	tbz	w10, #0, .LBB17_11
// %bb.3:                               //   in Loop: Header=BB17_5 Depth=1
	add	w24, w24, #1                    // =1
.LBB17_4:                               //   in Loop: Header=BB17_5 Depth=1
	ldrh	w10, [x17, :lo12:c_ftl_nand_planes_num]
	add	x8, x8, #1                      // =1
	cmp	x8, x10
	b.hs	.LBB17_12
.LBB17_5:                               // =>This Loop Header: Depth=1
                                        //     Child Loop BB17_9 Depth 2
	ldr	x10, [x25, :lo12:req_erase]
	lsl	x11, x8, #5
	tst	w19, #0xff
	str	wzr, [x10, x11]
	ldrb	w11, [x18, x8]
	ldrh	w12, [x16, :lo12:c_ftl_nand_planes_per_die]
	ldrh	w10, [x27, :lo12:c_ftl_nand_blks_per_die]
	and	w13, w11, #0xffff
	and	w14, w12, #0xffff
	mul	w15, w12, w20
	udiv	w13, w13, w14
	madd	w14, w10, w13, w15
	msub	w11, w13, w12, w11
	add	w11, w14, w11
	b.eq	.LBB17_2
// %bb.6:                               //   in Loop: Header=BB17_5 Depth=1
	ldrh	w12, [x2, :lo12:g_totle_vendor_block]
	cbz	w12, .LBB17_2
// %bb.7:                               //   in Loop: Header=BB17_5 Depth=1
	ldrh	w13, [x3, :lo12:c_ftl_nand_max_vendor_blks]
	cbz	w13, .LBB17_2
// %bb.8:                               //   in Loop: Header=BB17_5 Depth=1
	ldr	x12, [x4, :lo12:p_vendor_block_table]
	cmp	w13, #1                         // =1
	csinc	w13, w13, wzr, hi
.LBB17_9:                               //   Parent Loop BB17_5 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldrh	w14, [x12]
	cmp	w14, w11, uxth
	b.eq	.LBB17_4
// %bb.10:                              //   in Loop: Header=BB17_9 Depth=2
	subs	x13, x13, #1                    // =1
	add	x12, x12, #2                    // =2
	b.ne	.LBB17_9
	b	.LBB17_2
.LBB17_11:                              //   in Loop: Header=BB17_5 Depth=1
	ldr	x10, [x25, :lo12:req_erase]
	lsl	w11, w12, #10
	and	x12, x21, #0xffff
	lsl	x12, x12, #5
	add	x10, x10, x12
	str	w11, [x10, #4]
	ldr	x10, [x25, :lo12:req_erase]
	ldr	x11, [x0, :lo12:p_io_data_buf_1]
	and	w13, w21, #0xffff
	add	w21, w21, #1                    // =1
	add	x10, x10, x12
	str	x11, [x10, #8]
	ldrh	w10, [x1, :lo12:c_ftl_nand_byte_pre_oob]
	ldr	x11, [x25, :lo12:req_erase]
	mul	w10, w10, w13
	ldr	x13, [x9, :lo12:p_io_spare_buf]
	add	x11, x11, x12
	add	w12, w10, #3                    // =3
	cmp	w10, #0                         // =0
	csel	w10, w12, w10, lt
	asr	w10, w10, #2
	add	x10, x13, w10, sxtw #2
	str	x10, [x11, #16]
	b	.LBB17_4
.LBB17_12:
	tst	w21, #0xffff
	b.eq	.LBB17_36
// %bb.13:
	ldr	x0, [x25, :lo12:req_erase]
	and	w2, w21, #0xffff
	bl	FlashEraseBlocks
                                        // kill: def $w21 killed $w21 killed $x21 def $x21
	and	x8, x21, #0xffff
	adrp	x22, .L.str.82
	mov	x26, xzr
	mov	w21, #1
	lsl	x28, x8, #5
	add	x22, x22, :lo12:.L.str.82
	b	.LBB17_15
.LBB17_14:                              //   in Loop: Header=BB17_15 Depth=1
	add	x26, x26, #32                   // =32
	cmp	x28, x26
	b.eq	.LBB17_17
.LBB17_15:                              // =>This Inner Loop Header: Depth=1
	ldr	x8, [x25, :lo12:req_erase]
	ldr	w9, [x8, x26]
	cmn	w9, #1                          // =1
	b.ne	.LBB17_14
// %bb.16:                              //   in Loop: Header=BB17_15 Depth=1
	add	x8, x8, x26
	ldr	w8, [x8, #4]
	ldrh	w9, [x27, :lo12:c_ftl_nand_blks_per_die]
	mov	x0, x22
	add	w24, w24, #1                    // =1
	ubfx	w1, w8, #10, #16
	udiv	w2, w1, w9
	lsr	w10, w8, #10
	add	x8, x23, w2, uxtw #3
	ldr	x8, [x8, #32]
	msub	w9, w2, w9, w10
	ubfx	w10, w9, #3, #13
	and	x10, x10, #0x1ffc
	ldr	w11, [x8, x10]
	and	w3, w9, #0xffff
	lsl	w9, w21, w9
	orr	w4, w9, w11
	str	w4, [x8, x10]
	bl	sftl_printk
	ldrh	w8, [x23, #6]
	add	w8, w8, #1                      // =1
	strh	w8, [x23, #6]
	b	.LBB17_14
.LBB17_17:
	adrp	x8, c_ftl_nand_page_pre_slc_blk
	ldrh	w8, [x8, :lo12:c_ftl_nand_page_pre_slc_blk]
	tst	w19, #0xff
	mov	w9, #2
	adrp	x22, .L.str.82
	mov	w5, wzr
	adrp	x6, p_io_data_buf_0
	cset	w10, ne
	csel	w8, w9, w8, eq
	add	x22, x22, :lo12:.L.str.82
	adrp	x16, c_ftl_nand_planes_per_die
	stp	w8, w10, [sp, #4]               // 8-byte Folded Spill
	b	.LBB17_19
.LBB17_18:                              //   in Loop: Header=BB17_19 Depth=1
	ldur	w5, [x29, #-4]                  // 4-byte Folded Reload
	ldr	w8, [sp, #4]                    // 4-byte Folded Reload
	adrp	x16, c_ftl_nand_planes_per_die
	adrp	x6, p_io_data_buf_0
	add	w5, w5, #1                      // =1
	cmp	w8, w5, uxth
	b.ls	.LBB17_37
.LBB17_19:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB17_23 Depth 2
                                        //       Child Loop BB17_27 Depth 3
                                        //     Child Loop BB17_33 Depth 2
	adrp	x17, c_ftl_nand_planes_num
	ldrh	w8, [x17, :lo12:c_ftl_nand_planes_num]
	cbz	w8, .LBB17_36
// %bb.20:                              //   in Loop: Header=BB17_19 Depth=1
	adrp	x18, p_plane_order_table
	mov	x8, xzr
	mov	w26, wzr
	and	w9, w5, #0xffff
	add	x18, x18, :lo12:p_plane_order_table
	adrp	x0, p_io_data_buf_1
	adrp	x1, c_ftl_nand_byte_pre_oob
	adrp	x2, g_totle_vendor_block
	adrp	x3, c_ftl_nand_max_vendor_blks
	adrp	x4, p_vendor_block_table
	b	.LBB17_23
.LBB17_21:                              //   in Loop: Header=BB17_23 Depth=2
	and	w12, w11, #0xffff
	and	w13, w10, #0xffff
	udiv	w13, w12, w13
	add	x14, x23, w13, uxtw #3
	ldr	x14, [x14, #32]
	msub	w10, w13, w10, w11
	lsr	w11, w10, #3
	and	x11, x11, #0x1ffc
	ldr	w11, [x14, x11]
	lsr	w10, w11, w10
	tbz	w10, #0, .LBB17_29
.LBB17_22:                              //   in Loop: Header=BB17_23 Depth=2
	ldrh	w10, [x17, :lo12:c_ftl_nand_planes_num]
	add	x8, x8, #1                      // =1
	cmp	x8, x10
	b.hs	.LBB17_30
.LBB17_23:                              //   Parent Loop BB17_19 Depth=1
                                        // =>  This Loop Header: Depth=2
                                        //       Child Loop BB17_27 Depth 3
	ldr	x10, [x25, :lo12:req_erase]
	lsl	x11, x8, #5
	tst	w19, #0xff
	str	wzr, [x10, x11]
	ldrb	w11, [x18, x8]
	ldrh	w12, [x16, :lo12:c_ftl_nand_planes_per_die]
	ldrh	w10, [x27, :lo12:c_ftl_nand_blks_per_die]
	and	w13, w11, #0xffff
	and	w14, w12, #0xffff
	mul	w15, w12, w20
	udiv	w13, w13, w14
	madd	w14, w10, w13, w15
	msub	w11, w13, w12, w11
	add	w11, w14, w11
	b.eq	.LBB17_21
// %bb.24:                              //   in Loop: Header=BB17_23 Depth=2
	ldrh	w12, [x2, :lo12:g_totle_vendor_block]
	cbz	w12, .LBB17_21
// %bb.25:                              //   in Loop: Header=BB17_23 Depth=2
	ldrh	w13, [x3, :lo12:c_ftl_nand_max_vendor_blks]
	cbz	w13, .LBB17_21
// %bb.26:                              //   in Loop: Header=BB17_23 Depth=2
	ldr	x12, [x4, :lo12:p_vendor_block_table]
	cmp	w13, #1                         // =1
	csinc	w13, w13, wzr, hi
.LBB17_27:                              //   Parent Loop BB17_19 Depth=1
                                        //     Parent Loop BB17_23 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	ldrh	w14, [x12]
	cmp	w14, w11, uxth
	b.eq	.LBB17_22
// %bb.28:                              //   in Loop: Header=BB17_27 Depth=3
	subs	x13, x13, #1                    // =1
	add	x12, x12, #2                    // =2
	b.ne	.LBB17_27
	b	.LBB17_21
.LBB17_29:                              //   in Loop: Header=BB17_23 Depth=2
	ldr	x10, [x25, :lo12:req_erase]
	add	w11, w9, w12, lsl #10
	and	x12, x26, #0xffff
	lsl	x12, x12, #5
	add	x10, x10, x12
	str	w11, [x10, #4]
	ldr	x10, [x25, :lo12:req_erase]
	ldr	x11, [x6, :lo12:p_io_data_buf_0]
	and	w13, w26, #0xffff
	add	w26, w26, #1                    // =1
	add	x10, x10, x12
	str	x11, [x10, #8]
	ldrh	w10, [x1, :lo12:c_ftl_nand_byte_pre_oob]
	ldr	x11, [x25, :lo12:req_erase]
	mul	w10, w10, w13
	ldr	x13, [x0, :lo12:p_io_data_buf_1]
	add	x11, x11, x12
	add	w12, w10, #3                    // =3
	cmp	w10, #0                         // =0
	csel	w10, w12, w10, lt
	asr	w10, w10, #2
	add	x10, x13, w10, sxtw #2
	str	x10, [x11, #16]
	b	.LBB17_22
.LBB17_30:                              //   in Loop: Header=BB17_19 Depth=1
	ands	w1, w26, #0xffff
	b.eq	.LBB17_36
// %bb.31:                              //   in Loop: Header=BB17_19 Depth=1
	ldr	x0, [x25, :lo12:req_erase]
	ldr	w2, [sp, #8]                    // 4-byte Folded Reload
	stur	w5, [x29, #-4]                  // 4-byte Folded Spill
	str	w1, [sp]                        // 4-byte Folded Spill
	bl	FlashProgPages
	mov	w8, w26
	and	x8, x8, #0xffff
	mov	x28, xzr
	lsl	x21, x8, #5
	b	.LBB17_33
.LBB17_32:                              //   in Loop: Header=BB17_33 Depth=2
	add	x28, x28, #32                   // =32
	cmp	x21, x28
	b.eq	.LBB17_18
.LBB17_33:                              //   Parent Loop BB17_19 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldr	x8, [x25, :lo12:req_erase]
	ldr	w9, [x8, x28]
	cbz	w9, .LBB17_32
// %bb.34:                              //   in Loop: Header=BB17_33 Depth=2
	add	x8, x8, x28
	ldr	w8, [x8, #4]
	ldrh	w9, [x27, :lo12:c_ftl_nand_blks_per_die]
	mov	w12, #1
	mov	x0, x22
	ubfx	w1, w8, #10, #16
	udiv	w2, w1, w9
	lsr	w10, w8, #10
	add	x8, x23, w2, uxtw #3
	ldr	x8, [x8, #32]
	msub	w9, w2, w9, w10
	ubfx	w10, w9, #3, #13
	and	x10, x10, #0x1ffc
	ldr	w11, [x8, x10]
	and	w3, w9, #0xffff
	lsl	w9, w12, w9
	add	w24, w24, #1                    // =1
	orr	w4, w9, w11
	str	w4, [x8, x10]
	bl	sftl_printk
	ldrh	w8, [x23, #6]
	add	w8, w8, #1                      // =1
	strh	w8, [x23, #6]
	b	.LBB17_32
.LBB17_35:
	mov	w24, wzr
.LBB17_36:
	and	w0, w24, #0xffff
	ldp	x20, x19, [sp, #96]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	add	sp, sp, #112                    // =112
	hint	#29
	ret
.LBB17_37:
	and	w8, w26, #0xffff
	cmp	w8, #1                          // =1
	csinc	w8, w26, wzr, hi
	and	x8, x8, #0xffff
	mov	x21, xzr
	mov	w12, #65535
	adrp	x23, gSysFreeQueue+6
	lsl	x26, x8, #5
	b	.LBB17_39
.LBB17_38:                              //   in Loop: Header=BB17_39 Depth=1
	add	x21, x21, #32                   // =32
	cmp	x26, x21
	b.eq	.LBB17_45
.LBB17_39:                              // =>This Inner Loop Header: Depth=1
	tst	w19, #0xff
	b.eq	.LBB17_38
// %bb.40:                              //   in Loop: Header=BB17_39 Depth=1
	ldr	x8, [x25, :lo12:req_erase]
	ldr	w9, [x8, x21]
	cbnz	w9, .LBB17_38
// %bb.41:                              //   in Loop: Header=BB17_39 Depth=1
	add	x9, x8, x21
	ldr	w10, [x9, #4]
	ubfx	w9, w10, #10, #16
	cbz	w9, .LBB17_38
// %bb.42:                              //   in Loop: Header=BB17_39 Depth=1
	cmp	w9, w12
	b.eq	.LBB17_38
// %bb.43:                              //   in Loop: Header=BB17_39 Depth=1
	ldrh	w11, [x23, :lo12:gSysFreeQueue+6]
	cmp	w11, #1024                      // =1024
	b.eq	.LBB17_38
// %bb.44:                              //   in Loop: Header=BB17_39 Depth=1
	lsr	w28, w10, #10
	ldrh	w11, [x27, :lo12:c_ftl_nand_blks_per_die]
	and	w10, w10, #0x3fffc00
	ldrh	w12, [x16, :lo12:c_ftl_nand_planes_per_die]
	str	w10, [x8, #4]
	ldr	x0, [x25, :lo12:req_erase]
	udiv	w8, w9, w11
	msub	w8, w8, w11, w9
	mov	w2, #1
	udiv	w22, w8, w12
	bl	FlashEraseBlocks
	adrp	x8, p_erase_count_table
	ldr	x8, [x8, :lo12:p_erase_count_table]
	lsl	x9, x22, #1
	adrp	x11, g_totle_sys_slc_erase_count
	adrp	x14, gSysFreeQueue
	ldrh	w10, [x8, x9]
	add	x14, x14, :lo12:gSysFreeQueue
	mov	w12, #65535
	adrp	x16, c_ftl_nand_planes_per_die
	add	w10, w10, #1                    // =1
	strh	w10, [x8, x9]
	ldr	w8, [x11, :lo12:g_totle_sys_slc_erase_count]
	ldrh	w9, [x14, #6]
	ldrh	w10, [x14, #4]
	add	w8, w8, #1                      // =1
	add	w9, w9, #1                      // =1
	str	w8, [x11, :lo12:g_totle_sys_slc_erase_count]
	add	x8, x14, x10, lsl #1
	add	w10, w10, #1                    // =1
	strh	w9, [x14, #6]
	strh	w28, [x8, #8]
	and	w8, w10, #0x3ff
	strh	w8, [x14, #4]
	b	.LBB17_38
.LBB17_45:
	and	w8, w20, #0xffff
	cmp	w8, #64                         // =64
	b.lo	.LBB17_47
// %bb.46:
	tst	w19, #0xff
	b.eq	.LBB17_36
.LBB17_47:
	ldr	x0, [x25, :lo12:req_erase]
	ldr	w2, [sp]                        // 4-byte Folded Reload
	bl	FlashEraseBlocks
	b	.LBB17_36
.Lfunc_end17:
	.size	FtlLowFormatEraseBlock, .Lfunc_end17-FtlLowFormatEraseBlock
                                        // -- End function
	.globl	V2P_block                       // -- Begin function V2P_block
	.p2align	2
	.type	V2P_block,@function
V2P_block:                              // @V2P_block
// %bb.0:
	hint	#25
	adrp	x8, c_ftl_nand_planes_per_die
	ldrh	w8, [x8, :lo12:c_ftl_nand_planes_per_die]
	adrp	x10, c_ftl_nand_blks_per_die
	ldrh	w10, [x10, :lo12:c_ftl_nand_blks_per_die]
	and	w9, w0, #0xffff
	and	w11, w8, #0xffff
	mul	w12, w8, w1
	udiv	w9, w9, w11
	madd	w10, w10, w9, w12
	msub	w8, w9, w8, w0
	add	w0, w10, w8
	hint	#29
	ret
.Lfunc_end18:
	.size	V2P_block, .Lfunc_end18-V2P_block
                                        // -- End function
	.globl	FtlBbmIsBadBlock                // -- Begin function FtlBbmIsBadBlock
	.p2align	2
	.type	FtlBbmIsBadBlock,@function
FtlBbmIsBadBlock:                       // @FtlBbmIsBadBlock
// %bb.0:
	hint	#25
	adrp	x8, c_ftl_nand_blks_per_die
	ldrh	w8, [x8, :lo12:c_ftl_nand_blks_per_die]
	and	w9, w0, #0xffff
	and	w10, w8, #0xffff
	udiv	w9, w9, w10
	adrp	x10, gBbtInfo
	add	x10, x10, :lo12:gBbtInfo
	add	x10, x10, w9, uxtw #3
	ldr	x10, [x10, #32]
	msub	w8, w9, w8, w0
	lsr	w9, w8, #3
	and	x9, x9, #0x1ffc
	ldr	w9, [x10, x9]
	hint	#29
	lsr	w8, w9, w8
	and	w0, w8, #0x1
	ret
.Lfunc_end19:
	.size	FtlBbmIsBadBlock, .Lfunc_end19-FtlBbmIsBadBlock
                                        // -- End function
	.globl	FlashEraseBlocks                // -- Begin function FlashEraseBlocks
	.p2align	2
	.type	FlashEraseBlocks,@function
FlashEraseBlocks:                       // @FlashEraseBlocks
// %bb.0:
	hint	#25
	sub	sp, sp, #112                    // =112
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	stp	x28, x27, [sp, #32]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #48]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #64]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #80]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #96]             // 16-byte Folded Spill
	add	x29, sp, #16                    // =16
	str	x0, [sp]                        // 8-byte Folded Spill
	cbz	w2, .LBB20_17
// %bb.1:
	adrp	x8, g_nand_phy_info+12
	ldrh	w23, [x8, :lo12:g_nand_phy_info+12]
	ldr	x19, [sp]                       // 8-byte Folded Reload
	adrp	x24, g_nand_phy_info+8
	mov	w22, w2
	add	x24, x24, :lo12:g_nand_phy_info+8
	adrp	x25, g_nand_ops+8
	adrp	x26, g_nand_phy_info+14
	lsl	w27, w23, #3
	mov	w28, #-1
	str	x22, [sp, #8]                   // 8-byte Folded Spill
	b	.LBB20_3
.LBB20_2:                               //   in Loop: Header=BB20_3 Depth=1
	subs	x22, x22, #1                    // =1
	add	x19, x19, #32                   // =32
	b.eq	.LBB20_17
.LBB20_3:                               // =>This Inner Loop Header: Depth=1
	ldrh	w8, [x24, #6]
	ldr	w9, [x19, #4]
	ldrh	w10, [x24]
	ldrh	w11, [x24, #2]
	cmp	w8, #4                          // =4
	cset	w12, eq
	ubfx	w8, w9, #10, #16
	lsr	w10, w10, w12
	lsl	w11, w11, w12
	udiv	w21, w8, w10
	and	w9, w9, #0x3ff
	and	w11, w11, #0xffff
	msub	w12, w10, w21, w8
	cmp	w10, w8
	madd	w20, w12, w11, w9
	b.ls	.LBB20_5
// %bb.4:                               //   in Loop: Header=BB20_3 Depth=1
	cmp	w20, w27
	b.lo	.LBB20_8
.LBB20_5:                               //   in Loop: Header=BB20_3 Depth=1
	ldr	x8, [x25, :lo12:g_nand_ops+8]
	mov	w0, w21
	mov	w1, w20
	blr	x8
	cmp	w0, #0                          // =0
	csetm	w8, ne
	str	w8, [x19]
	ldrh	w8, [x26, :lo12:g_nand_phy_info+14]
	cmp	w8, #4                          // =4
	b.ne	.LBB20_2
// %bb.6:                               //   in Loop: Header=BB20_3 Depth=1
	ldr	x8, [x25, :lo12:g_nand_ops+8]
	add	w1, w20, w23
	mov	w0, w21
	blr	x8
	cbz	w0, .LBB20_2
// %bb.7:                               //   in Loop: Header=BB20_3 Depth=1
	str	w28, [x19]
	b	.LBB20_2
.LBB20_8:
	ldr	x22, [sp]                       // 8-byte Folded Reload
	adrp	x23, .L.str.116
	adrp	x24, .L.str.124
	adrp	x25, .L.str.117
	adrp	x26, .L.str.120
	mov	x27, xzr
	add	x23, x23, :lo12:.L.str.116
	add	x24, x24, :lo12:.L.str.124
	add	x25, x25, :lo12:.L.str.117
	add	x26, x26, :lo12:.L.str.120
	b	.LBB20_10
.LBB20_9:                               //   in Loop: Header=BB20_10 Depth=1
	mov	x0, x26
	bl	sftl_printk
	add	x8, x22, x27, lsl #5
	ldr	x21, [x8, #16]
	adrp	x1, .L.str.125
	mov	x0, x23
	add	x1, x1, :lo12:.L.str.125
	mov	x2, x21
	mov	w3, wzr
	bl	sftl_printk
	ldr	w1, [x21]
	mov	x0, x25
	bl	sftl_printk
	ldr	w1, [x21, #4]
	mov	x0, x25
	bl	sftl_printk
	ldr	w1, [x21, #8]
	mov	x0, x25
	bl	sftl_printk
	ldr	w1, [x21, #12]
	mov	x0, x25
	bl	sftl_printk
	mov	x0, x26
	bl	sftl_printk
	ldr	x8, [sp, #8]                    // 8-byte Folded Reload
	add	x27, x27, #1                    // =1
	cmp	x27, x8
	b.eq	.LBB20_16
.LBB20_10:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB20_13 Depth 2
	adrp	x0, .L.str.123
	adrp	x1, .L__func__.FlashEraseBlocks
	add	x19, x22, x27, lsl #5
	mov	w8, #-1
	add	x0, x0, :lo12:.L.str.123
	add	x1, x1, :lo12:.L__func__.FlashEraseBlocks
	mov	w2, w20
	str	w8, [x19]
	bl	sftl_printk
	ldr	x21, [x19, #8]
	mov	x28, xzr
	mov	w19, wzr
	b	.LBB20_13
.LBB20_11:                              //   in Loop: Header=BB20_13 Depth=2
	ldr	w1, [x21, x28]
	mov	x0, x25
	bl	sftl_printk
	add	w19, w19, #1                    // =1
	cmp	w19, #16                        // =16
	b.hs	.LBB20_15
.LBB20_12:                              //   in Loop: Header=BB20_13 Depth=2
	add	x28, x28, #4                    // =4
	cmp	x28, #64                        // =64
	b.eq	.LBB20_9
.LBB20_13:                              //   Parent Loop BB20_10 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	cbnz	w19, .LBB20_11
// %bb.14:                              //   in Loop: Header=BB20_13 Depth=2
	mov	x0, x23
	mov	x1, x24
	mov	x2, x21
	mov	w3, w28
	bl	sftl_printk
	b	.LBB20_11
.LBB20_15:                              //   in Loop: Header=BB20_13 Depth=2
	mov	x0, x26
	bl	sftl_printk
	mov	w19, wzr
	b	.LBB20_12
.LBB20_16:
	bl	dump_stack
.LBB20_17:
	ldp	x20, x19, [sp, #96]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	add	sp, sp, #112                    // =112
	hint	#29
	ret
.Lfunc_end20:
	.size	FlashEraseBlocks, .Lfunc_end20-FlashEraseBlocks
                                        // -- End function
	.globl	FtlBbmMapBadBlock               // -- Begin function FtlBbmMapBadBlock
	.p2align	2
	.type	FtlBbmMapBadBlock,@function
FtlBbmMapBadBlock:                      // @FtlBbmMapBadBlock
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	adrp	x8, c_ftl_nand_blks_per_die
	ldrh	w8, [x8, :lo12:c_ftl_nand_blks_per_die]
	str	x19, [sp, #16]                  // 8-byte Folded Spill
	and	w1, w0, #0xffff
	adrp	x19, gBbtInfo
	udiv	w2, w1, w8
	add	x19, x19, :lo12:gBbtInfo
	add	x9, x19, w2, uxtw #3
	ldr	x9, [x9, #32]
	msub	w8, w2, w8, w0
	ubfx	w10, w8, #3, #13
	and	x10, x10, #0x1ffc
	ldr	w11, [x9, x10]
	mov	w12, #1
	lsl	w12, w12, w8
	adrp	x0, .L.str.82
	and	w3, w8, #0xffff
	orr	w4, w12, w11
	add	x0, x0, :lo12:.L.str.82
	mov	x29, sp
	str	w4, [x9, x10]
	bl	sftl_printk
	ldrh	w8, [x19, #6]
	mov	w0, wzr
	add	w8, w8, #1                      // =1
	strh	w8, [x19, #6]
	ldr	x19, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end21:
	.size	FtlBbmMapBadBlock, .Lfunc_end21-FtlBbmMapBadBlock
                                        // -- End function
	.globl	FlashProgPages                  // -- Begin function FlashProgPages
	.p2align	2
	.type	FlashProgPages,@function
FlashProgPages:                         // @FlashProgPages
// %bb.0:
	hint	#25
	sub	sp, sp, #160                    // =160
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	stp	x29, x30, [sp, #64]             // 16-byte Folded Spill
	add	x29, sp, #64                    // =64
	stp	x28, x27, [sp, #80]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #96]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #112]            // 16-byte Folded Spill
	stp	x22, x21, [sp, #128]            // 16-byte Folded Spill
	stp	x20, x19, [sp, #144]            // 16-byte Folded Spill
	stur	x8, [x29, #-8]
	cbz	w1, .LBB22_41
// %bb.1:
	adrp	x8, g_nand_phy_info+12
	ldrh	w8, [x8, :lo12:g_nand_phy_info+12]
	mov	w21, w1
	adrp	x26, .L.str.78
	adrp	x22, .L__func__.FlashProgPages
	adrp	x24, g_nand_phy_info+8
	mov	x19, x0
	add	x27, x0, #16                    // =16
	add	x26, x26, :lo12:.L.str.78
	add	x22, x22, :lo12:.L__func__.FlashProgPages
	add	x24, x24, :lo12:g_nand_phy_info+8
	adrp	x28, sftl_nand_check_buf
	stp	w1, w8, [sp, #4]                // 8-byte Folded Spill
	lsl	w8, w8, #3
	mov	x20, x21
	str	w8, [sp, #12]                   // 4-byte Folded Spill
	str	x21, [sp, #16]                  // 8-byte Folded Spill
	b	.LBB22_4
.LBB22_2:                               //   in Loop: Header=BB22_4 Depth=1
	mov	w8, #-1
	stur	w8, [x27, #-16]
.LBB22_3:                               //   in Loop: Header=BB22_4 Depth=1
	adrp	x24, g_nand_phy_info+8
	subs	x20, x20, #1                    // =1
	add	x27, x27, #32                   // =32
	add	x24, x24, :lo12:g_nand_phy_info+8
	b.eq	.LBB22_16
.LBB22_4:                               // =>This Inner Loop Header: Depth=1
	ldur	x8, [x27, #-8]
	cbz	x8, .LBB22_6
// %bb.5:                               //   in Loop: Header=BB22_4 Depth=1
	ldr	x8, [x27]
	cbnz	x8, .LBB22_7
.LBB22_6:                               //   in Loop: Header=BB22_4 Depth=1
	mov	w2, #148
	mov	x0, x26
	mov	x1, x22
	bl	sftl_printk
.LBB22_7:                               //   in Loop: Header=BB22_4 Depth=1
	ldrh	w9, [x24, #6]
	ldrh	w11, [x24]
	ldur	w8, [x27, #-12]
	cmp	w9, #4                          // =4
	cset	w10, eq
	lsr	w9, w11, w10
	ubfx	w11, w8, #10, #16
	udiv	w23, w11, w9
	cmp	w23, #4                         // =4
	b.hs	.LBB22_2
// %bb.8:                               //   in Loop: Header=BB22_4 Depth=1
	ldrh	w12, [x24, #2]
	msub	w11, w9, w23, w11
	and	w13, w8, #0x3ff
	lsr	w8, w8, #10
	lsl	w10, w12, w10
	and	w10, w10, #0xffff
	cmp	w9, w8, uxth
	madd	w24, w11, w10, w13
	b.ls	.LBB22_10
// %bb.9:                               //   in Loop: Header=BB22_4 Depth=1
	ldr	w8, [sp, #12]                   // 4-byte Folded Reload
	cmp	w24, w8
	b.lo	.LBB22_32
.LBB22_10:                              //   in Loop: Header=BB22_4 Depth=1
	ldur	x25, [x27, #-8]
	tst	x25, #0x3f
	b.eq	.LBB22_14
// %bb.11:                              //   in Loop: Header=BB22_4 Depth=1
	mov	x8, x28
	mov	x28, x26
	ldr	x26, [x8, :lo12:sftl_nand_check_buf]
	mov	x21, x22
	mov	x22, x8
	cmp	x25, x26
	b.eq	.LBB22_13
// %bb.12:                              //   in Loop: Header=BB22_4 Depth=1
	adrp	x8, c_ftl_nand_sec_pre_page
	ldrh	w8, [x8, :lo12:c_ftl_nand_sec_pre_page]
	mov	x0, x26
	mov	x1, x25
	lsl	x2, x8, #9
	bl	memcpy
	mov	x25, x26
.LBB22_13:                              //   in Loop: Header=BB22_4 Depth=1
	mov	x26, x28
	mov	x28, x22
	mov	x22, x21
	ldr	x21, [sp, #16]                  // 8-byte Folded Reload
.LBB22_14:                              //   in Loop: Header=BB22_4 Depth=1
	adrp	x8, g_nand_ops+16
	ldr	x8, [x8, :lo12:g_nand_ops+16]
	ldr	x3, [x27]
	mov	w0, w23
	mov	w1, w24
	mov	x2, x25
	blr	x8
	cmp	w0, #0                          // =0
	csetm	w8, ne
	stur	w8, [x27, #-16]
	adrp	x8, g_nand_phy_info+14
	ldrh	w8, [x8, :lo12:g_nand_phy_info+14]
	cmp	w8, #4                          // =4
	b.ne	.LBB22_3
// %bb.15:                              //   in Loop: Header=BB22_4 Depth=1
	ldr	x8, [x27]
	adrp	x9, g_nand_ops+16
	ldr	w10, [sp, #8]                   // 4-byte Folded Reload
	ldr	x9, [x9, :lo12:g_nand_ops+16]
	add	x2, x25, #2048                  // =2048
	add	x3, x8, #8                      // =8
	add	w1, w24, w10
	mov	w0, w23
	blr	x9
	cbnz	w0, .LBB22_2
	b	.LBB22_3
.LBB22_16:
	ldr	w8, [sp, #4]                    // 4-byte Folded Reload
	cbz	w8, .LBB22_41
// %bb.17:
	adrp	x24, .L.str.126
	adrp	x22, .L.str.129
	adrp	x20, .L.str.128
	adrp	x26, .L.str.127
	adrp	x23, sftl_nand_check_spare_buf
	add	x24, x24, :lo12:.L.str.126
	add	x22, x22, :lo12:.L.str.129
	mov	w25, #-1
	add	x20, x20, :lo12:.L.str.128
	add	x26, x26, :lo12:.L.str.127
	b	.LBB22_20
.LBB22_18:                              //   in Loop: Header=BB22_20 Depth=1
	ldr	w1, [x19, #4]
	ldr	w3, [x8, #4]
	ldr	w5, [x9, #4]
	mov	x0, x22
	bl	sftl_printk
	str	w25, [x19]
.LBB22_19:                              //   in Loop: Header=BB22_20 Depth=1
	subs	x21, x21, #1                    // =1
	add	x19, x19, #32                   // =32
	b.eq	.LBB22_41
.LBB22_20:                              // =>This Inner Loop Header: Depth=1
	ldr	x8, [x28, :lo12:sftl_nand_check_buf]
	add	x0, sp, #24                     // =24
	mov	w1, #1
	str	wzr, [x8]
	ldr	x8, [x23, :lo12:sftl_nand_check_spare_buf]
	str	wzr, [x8]
	ldr	w8, [x19, #4]
	ldr	x9, [x28, :lo12:sftl_nand_check_buf]
	ldr	x10, [x23, :lo12:sftl_nand_check_spare_buf]
	str	w8, [sp, #28]
	stp	x9, x10, [sp, #32]
	bl	FlashReadPages
	ldr	w27, [sp, #24]
	cmn	w27, #1                         // =1
	b.eq	.LBB22_23
// %bb.21:                              //   in Loop: Header=BB22_20 Depth=1
	cmp	w27, #256                       // =256
	b.ne	.LBB22_25
// %bb.22:                              //   in Loop: Header=BB22_20 Depth=1
	mov	x0, x26
	b	.LBB22_24
.LBB22_23:                              //   in Loop: Header=BB22_20 Depth=1
	mov	x0, x24
.LBB22_24:                              //   in Loop: Header=BB22_20 Depth=1
	ldr	w1, [x19, #4]
	bl	sftl_printk
	str	w27, [x19]
.LBB22_25:                              //   in Loop: Header=BB22_20 Depth=1
	ldr	x8, [x19, #16]
	cbz	x8, .LBB22_29
// %bb.26:                              //   in Loop: Header=BB22_20 Depth=1
	ldr	x9, [x23, :lo12:sftl_nand_check_spare_buf]
	ldr	w2, [x8]
	ldr	w4, [x9]
	cmp	w2, w4
	b.ne	.LBB22_28
// %bb.27:                              //   in Loop: Header=BB22_20 Depth=1
	ldr	w10, [x8, #8]
	ldr	w11, [x9, #8]
	cmp	w10, w11
	b.eq	.LBB22_29
.LBB22_28:                              //   in Loop: Header=BB22_20 Depth=1
	ldr	w1, [x19, #4]
	ldr	w3, [x8, #4]
	ldr	w5, [x9, #4]
	mov	x0, x20
	bl	sftl_printk
	str	w25, [x19]
.LBB22_29:                              //   in Loop: Header=BB22_20 Depth=1
	ldr	x8, [x19, #8]
	cbz	x8, .LBB22_19
// %bb.30:                              //   in Loop: Header=BB22_20 Depth=1
	ldr	x9, [x28, :lo12:sftl_nand_check_buf]
	ldr	w2, [x8]
	ldr	w4, [x9]
	cmp	w2, w4
	b.ne	.LBB22_18
// %bb.31:                              //   in Loop: Header=BB22_20 Depth=1
	ldr	w10, [x8, #2048]
	ldr	w11, [x9, #2048]
	cmp	w10, w11
	b.ne	.LBB22_18
	b	.LBB22_19
.LBB22_32:
	adrp	x22, .L.str.116
	adrp	x23, .L.str.124
	adrp	x24, .L.str.117
	adrp	x25, .L.str.120
	mov	x20, xzr
	add	x22, x22, :lo12:.L.str.116
	add	x23, x23, :lo12:.L.str.124
	add	x24, x24, :lo12:.L.str.117
	add	x25, x25, :lo12:.L.str.120
	b	.LBB22_34
.LBB22_33:                              //   in Loop: Header=BB22_34 Depth=1
	mov	x0, x25
	bl	sftl_printk
	add	x8, x19, x20, lsl #5
	ldr	x27, [x8, #16]
	adrp	x1, .L.str.125
	mov	x0, x22
	add	x1, x1, :lo12:.L.str.125
	mov	x2, x27
	mov	w3, wzr
	bl	sftl_printk
	ldr	w1, [x27]
	mov	x0, x24
	bl	sftl_printk
	ldr	w1, [x27, #4]
	mov	x0, x24
	bl	sftl_printk
	ldr	w1, [x27, #8]
	mov	x0, x24
	bl	sftl_printk
	ldr	w1, [x27, #12]
	mov	x0, x24
	bl	sftl_printk
	mov	x0, x25
	bl	sftl_printk
	add	x20, x20, #1                    // =1
	cmp	x20, x21
	b.eq	.LBB22_40
.LBB22_34:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB22_37 Depth 2
	add	x26, x19, x20, lsl #5
	ldr	w2, [x26, #4]
	adrp	x0, .L.str.123
	adrp	x1, .L__func__.FlashProgPages
	mov	w8, #-1
	add	x0, x0, :lo12:.L.str.123
	add	x1, x1, :lo12:.L__func__.FlashProgPages
	str	w8, [x26]
	bl	sftl_printk
	ldr	x28, [x26, #8]
	mov	x27, xzr
	mov	w26, wzr
	b	.LBB22_37
.LBB22_35:                              //   in Loop: Header=BB22_37 Depth=2
	ldr	w1, [x28, x27]
	mov	x0, x24
	bl	sftl_printk
	add	w26, w26, #1                    // =1
	cmp	w26, #16                        // =16
	b.hs	.LBB22_39
.LBB22_36:                              //   in Loop: Header=BB22_37 Depth=2
	add	x27, x27, #4                    // =4
	cmp	x27, #64                        // =64
	b.eq	.LBB22_33
.LBB22_37:                              //   Parent Loop BB22_34 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	cbnz	w26, .LBB22_35
// %bb.38:                              //   in Loop: Header=BB22_37 Depth=2
	mov	x0, x22
	mov	x1, x23
	mov	x2, x28
	mov	w3, w27
	bl	sftl_printk
	b	.LBB22_35
.LBB22_39:                              //   in Loop: Header=BB22_37 Depth=2
	mov	x0, x25
	bl	sftl_printk
	mov	w26, wzr
	b	.LBB22_36
.LBB22_40:
	bl	dump_stack
.LBB22_41:
	adrp	x9, __stack_chk_guard
	ldur	x8, [x29, #-8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB22_43
// %bb.42:
	ldp	x20, x19, [sp, #144]            // 16-byte Folded Reload
	ldp	x22, x21, [sp, #128]            // 16-byte Folded Reload
	ldp	x24, x23, [sp, #112]            // 16-byte Folded Reload
	ldp	x26, x25, [sp, #96]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #80]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #64]             // 16-byte Folded Reload
	mov	w0, wzr
	add	sp, sp, #160                    // =160
	hint	#29
	ret
.LBB22_43:
	bl	__stack_chk_fail
.Lfunc_end22:
	.size	FlashProgPages, .Lfunc_end22-FlashProgPages
                                        // -- End function
	.globl	FtlFreeSysBlkQueueIn            // -- Begin function FtlFreeSysBlkQueueIn
	.p2align	2
	.type	FtlFreeSysBlkQueueIn,@function
FtlFreeSysBlkQueueIn:                   // @FtlFreeSysBlkQueueIn
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-48]!           // 16-byte Folded Spill
	ands	w8, w0, #0xffff
	str	x21, [sp, #16]                  // 8-byte Folded Spill
	stp	x20, x19, [sp, #32]             // 16-byte Folded Spill
	mov	x29, sp
	b.eq	.LBB23_6
// %bb.1:
	mov	w9, #65535
	cmp	w8, w9
	b.eq	.LBB23_6
// %bb.2:
	adrp	x20, gSysFreeQueue+6
	ldrh	w9, [x20, :lo12:gSysFreeQueue+6]
	cmp	w9, #1024                       // =1024
	b.eq	.LBB23_6
// %bb.3:
	mov	w19, w0
	tst	w1, #0xffff
	b.eq	.LBB23_5
// %bb.4:
	adrp	x11, req_erase
	ldr	x12, [x11, :lo12:req_erase]
	adrp	x9, c_ftl_nand_blks_per_die
	ldrh	w9, [x9, :lo12:c_ftl_nand_blks_per_die]
	adrp	x13, c_ftl_nand_planes_per_die
	lsl	w8, w8, #10
	ldrh	w13, [x13, :lo12:c_ftl_nand_planes_per_die]
	str	w8, [x12, #4]
	ldr	x0, [x11, :lo12:req_erase]
	and	w10, w19, #0xffff
	udiv	w8, w10, w9
	msub	w8, w8, w9, w10
	mov	w2, #1
	udiv	w21, w8, w13
	bl	FlashEraseBlocks
	adrp	x8, p_erase_count_table
	ldr	x8, [x8, :lo12:p_erase_count_table]
	lsl	x9, x21, #1
	ldrh	w10, [x8, x9]
	add	w10, w10, #1                    // =1
	strh	w10, [x8, x9]
	adrp	x8, g_totle_sys_slc_erase_count
	ldr	w10, [x8, :lo12:g_totle_sys_slc_erase_count]
	ldrh	w9, [x20, :lo12:gSysFreeQueue+6]
	add	w10, w10, #1                    // =1
	str	w10, [x8, :lo12:g_totle_sys_slc_erase_count]
.LBB23_5:
	adrp	x8, gSysFreeQueue
	add	x8, x8, :lo12:gSysFreeQueue
	ldrh	w10, [x8, #4]
	add	w9, w9, #1                      // =1
	strh	w9, [x8, #6]
	add	x9, x8, x10, lsl #1
	add	w10, w10, #1                    // =1
	strh	w19, [x9, #8]
	and	w9, w10, #0x3ff
	strh	w9, [x8, #4]
.LBB23_6:
	ldp	x20, x19, [sp, #32]             // 16-byte Folded Reload
	ldr	x21, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #48             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end23:
	.size	FtlFreeSysBlkQueueIn, .Lfunc_end23-FtlFreeSysBlkQueueIn
                                        // -- End function
	.globl	ftl_low_format                  // -- Begin function ftl_low_format
	.p2align	2
	.type	ftl_low_format,@function
ftl_low_format:                         // @ftl_low_format
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-96]!           // 16-byte Folded Spill
	stp	x26, x25, [sp, #32]             // 16-byte Folded Spill
	adrp	x8, g_GlobalDataVersion
	adrp	x25, c_ftl_nand_max_sys_blks
	str	wzr, [x8, :lo12:g_GlobalDataVersion]
	ldr	w8, [x25, :lo12:c_ftl_nand_max_sys_blks]
	stp	x22, x21, [sp, #64]             // 16-byte Folded Spill
	adrp	x21, gSysFreeQueue
	add	x21, x21, :lo12:gSysFreeQueue
	adrp	x10, g_GlobalSysVersion
	adrp	x9, g_totle_avg_erase_count
	add	x0, x21, #8                     // =8
	mov	w2, #2048
	mov	w1, wzr
	stp	x28, x27, [sp, #16]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #48]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #80]             // 16-byte Folded Spill
	mov	x29, sp
	str	wzr, [x10, :lo12:g_GlobalSysVersion]
	str	wzr, [x9, :lo12:g_totle_avg_erase_count]
	stur	wzr, [x21, #2]
	strh	wzr, [x21, #6]
	strh	w8, [x21]
	bl	memset
	bl	FtlLoadBbt
	cbz	w0, .LBB24_2
// %bb.1:
	bl	FtlMakeBbt
.LBB24_2:
	adrp	x22, c_ftl_nand_sec_pre_page
	ldrh	w8, [x22, :lo12:c_ftl_nand_sec_pre_page]
	cbz	w8, .LBB24_5
// %bb.3:
	mov	w11, #23752
	mov	w8, wzr
	adrp	x9, p_io_data_buf_0
	adrp	x10, p_io_data_buf_1
	movk	w11, #2575, lsl #16
.LBB24_4:                               // =>This Inner Loop Header: Depth=1
	ldr	x13, [x9, :lo12:p_io_data_buf_0]
	mvn	w12, w8
	and	x14, x8, #0xffff
	orr	w12, w8, w12, lsl #16
	lsl	x14, x14, #2
	str	w12, [x13, x14]
	ldr	x12, [x10, :lo12:p_io_data_buf_1]
	add	w8, w8, #1                      // =1
	and	w8, w8, #0xffff
	str	w11, [x12, x14]
	ldrh	w12, [x22, :lo12:c_ftl_nand_sec_pre_page]
	cmp	w8, w12, lsl #7
	b.lo	.LBB24_4
.LBB24_5:
	adrp	x24, c_ftl_nand_data_blks_per_plane
	adrp	x23, c_ftl_nand_blk_pre_plane
	ldrh	w19, [x24, :lo12:c_ftl_nand_data_blks_per_plane]
	ldrh	w28, [x23, :lo12:c_ftl_nand_blk_pre_plane]
	cmp	w19, w28
	b.hs	.LBB24_8
// %bb.6:
	mov	w20, wzr
.LBB24_7:                               // =>This Inner Loop Header: Depth=1
	mov	w1, #1
	mov	w0, w19
	bl	FtlLowFormatEraseBlock
	ldrh	w28, [x23, :lo12:c_ftl_nand_blk_pre_plane]
	add	w8, w0, w20
	add	w19, w19, #1                    // =1
	and	w20, w8, #0xffff
	cmp	w28, w19, uxth
	b.hi	.LBB24_7
	b	.LBB24_9
.LBB24_8:
	mov	w20, wzr
.LBB24_9:
	adrp	x26, c_ftl_nand_planes_num
	ldrh	w8, [x26, :lo12:c_ftl_nand_planes_num]
	sub	w9, w20, #3                     // =3
	adrp	x27, c_ftl_nand_max_data_blks
	cmp	w9, w8, lsl #1
	b.ge	.LBB24_14
.LBB24_10:
	ldrh	w8, [x24, :lo12:c_ftl_nand_data_blks_per_plane]
	cbz	w8, .LBB24_16
// %bb.11:
	mov	w25, wzr
	mov	w19, wzr
.LBB24_12:                              // =>This Inner Loop Header: Depth=1
	mov	w0, w19
	mov	w1, wzr
	bl	FtlLowFormatEraseBlock
	ldrh	w8, [x24, :lo12:c_ftl_nand_data_blks_per_plane]
	add	w9, w0, w25
	add	w19, w19, #1                    // =1
	and	w25, w9, #0xffff
	cmp	w8, w19, uxth
	b.hi	.LBB24_12
// %bb.13:
	ldrh	w28, [x23, :lo12:c_ftl_nand_blk_pre_plane]
	b	.LBB24_17
.LBB24_14:
	adrp	x9, c_ftl_nand_init_sys_blks_per_plane
	ldrh	w9, [x9, :lo12:c_ftl_nand_init_sys_blks_per_plane]
	udiv	w10, w20, w8
	mov	w11, #24
	add	x0, x21, #8                     // =8
	add	w9, w10, w9
	and	w10, w9, #0xffff
	cmp	w10, #24                        // =24
	csel	w9, w9, w11, hi
	adrp	x10, c_ftl_nand_sys_blks_per_plane
	and	w11, w9, #0xffff
	str	w11, [x10, :lo12:c_ftl_nand_sys_blks_per_plane]
	adrp	x10, c_ftl_nand_totle_phy_blks
	ldr	w10, [x10, :lo12:c_ftl_nand_totle_phy_blks]
	mul	w8, w11, w8
	sub	w19, w28, w9
	mov	w2, #2048
	sub	w9, w10, w8
	mov	w1, wzr
	stur	wzr, [x21, #2]
	strh	wzr, [x21, #6]
	strh	w19, [x24, :lo12:c_ftl_nand_data_blks_per_plane]
	str	w8, [x25, :lo12:c_ftl_nand_max_sys_blks]
	str	w9, [x27, :lo12:c_ftl_nand_max_data_blks]
	strh	w8, [x21]
	bl	memset
	cmp	w28, w19, uxth
	b.ls	.LBB24_10
.LBB24_15:                              // =>This Inner Loop Header: Depth=1
	mov	w1, #1
	mov	w0, w19
	bl	FtlLowFormatEraseBlock
	ldrh	w28, [x23, :lo12:c_ftl_nand_blk_pre_plane]
	add	w19, w19, #1                    // =1
	cmp	w28, w19, uxth
	b.hi	.LBB24_15
	b	.LBB24_10
.LBB24_16:
	mov	w25, wzr
.LBB24_17:
	ldrh	w8, [x26, :lo12:c_ftl_nand_planes_num]
	ldr	w10, [x27, :lo12:c_ftl_nand_max_data_blks]
	adrp	x9, g_cur_erase_blk
	str	w28, [x9, :lo12:g_cur_erase_blk]
	add	w9, w8, w8, lsl #1
	cmp	w25, w9, lsl #3
	udiv	w9, w10, w8
	b.ls	.LBB24_19
// %bb.18:
	sub	w10, w10, w25
	udiv	w11, w10, w8
	lsr	w10, w11, #5
	add	w10, w10, #24                   // =24
	b	.LBB24_20
.LBB24_19:
	lsr	w10, w9, #5
	add	w10, w10, #36                   // =36
	mov	w11, w9
.LBB24_20:
	adrp	x12, c_ftl_nand_ext_blk_pre_plane
	ldrh	w13, [x12, :lo12:c_ftl_nand_ext_blk_pre_plane]
	adrp	x12, c_ftl_nand_data_op_blks_per_plane
	strh	w10, [x12, :lo12:c_ftl_nand_data_op_blks_per_plane]
	cbz	w13, .LBB24_23
// %bb.21:
	mul	w14, w13, w8
	add	w10, w10, w13, lsr #1
	cmp	w14, w25
	adrp	x25, g_GlobalSysVersion
	strh	w10, [x12, :lo12:c_ftl_nand_data_op_blks_per_plane]
	b.le	.LBB24_24
// %bb.22:
	add	w10, w13, w9, lsr #5
	add	w10, w10, #32                   // =32
	mov	w11, w9
	strh	w10, [x12, :lo12:c_ftl_nand_data_op_blks_per_plane]
	b	.LBB24_24
.LBB24_23:
	adrp	x25, g_GlobalSysVersion
.LBB24_24:
	sub	w9, w11, w10, uxth
	adrp	x10, c_ftl_nand_page_pre_blk
	ldrh	w10, [x10, :lo12:c_ftl_nand_page_pre_blk]
	ldrh	w12, [x22, :lo12:c_ftl_nand_sec_pre_page]
	adrp	x24, g_MaxLbn
	mul	w8, w9, w8
	adrp	x11, g_MaxLpn
	str	w8, [x24, :lo12:g_MaxLbn]
	mul	w8, w8, w10
	str	w8, [x11, :lo12:g_MaxLpn]
	mul	w8, w8, w12
	adrp	x9, g_MaxLbaSector
	str	w8, [x9, :lo12:g_MaxLbaSector]
	bl	FtlBbmTblFlush
	adrp	x22, p_valid_page_count_table
	ldrh	w8, [x23, :lo12:c_ftl_nand_blk_pre_plane]
	ldr	x0, [x22, :lo12:p_valid_page_count_table]
	mov	w1, wzr
	lsl	x2, x8, #1
	bl	memset
	adrp	x9, g_gc_superblock
	adrp	x19, g_active_superblock
	adrp	x8, g_VaildLpn
	add	x9, x9, :lo12:g_gc_superblock
	mov	w20, #65535
	add	x19, x19, :lo12:g_active_superblock
	mov	w23, #1
	str	wzr, [x8, :lo12:g_VaildLpn]
	str	w20, [x9]
	strb	wzr, [x9, #6]
	strb	wzr, [x9, #8]
	strb	wzr, [x19, #6]
	str	wzr, [x19]
	strb	w23, [x19, #8]
.LBB24_25:                              // =>This Inner Loop Header: Depth=1
	mov	x0, x19
	bl	make_superblock
	ldrb	w8, [x19, #7]
	cbnz	w8, .LBB24_27
// %bb.26:                              //   in Loop: Header=BB24_25 Depth=1
	ldr	x8, [x22, :lo12:p_valid_page_count_table]
	ldrh	w9, [x19]
	strh	w20, [x8, x9, lsl #1]
	ldrh	w8, [x19]
	add	w8, w8, #1                      // =1
	strh	w8, [x19]
	b	.LBB24_25
.LBB24_27:
	ldr	w8, [x25, :lo12:g_GlobalSysVersion]
	ldrh	w9, [x19, #4]
	ldr	x10, [x22, :lo12:p_valid_page_count_table]
	ldrh	w11, [x19]
	str	w8, [x19, #12]
	add	w8, w8, #1                      // =1
	str	w8, [x25, :lo12:g_GlobalSysVersion]
	strh	w9, [x10, x11, lsl #1]
	ldrh	w8, [x19]
	adrp	x19, g_buffer_superblock
	add	x19, x19, :lo12:g_buffer_superblock
	mov	x0, x19
	add	w8, w8, #1                      // =1
	strh	wzr, [x19, #2]
	strb	wzr, [x19, #6]
	strh	w8, [x19]
	strb	w23, [x19, #8]
	bl	make_superblock
	ldrb	w8, [x19, #7]
	cbnz	w8, .LBB24_30
// %bb.28:
	mov	w20, #65535
.LBB24_29:                              // =>This Inner Loop Header: Depth=1
	ldr	x8, [x22, :lo12:p_valid_page_count_table]
	ldrh	w9, [x19]
	mov	x0, x19
	strh	w20, [x8, x9, lsl #1]
	ldrh	w8, [x19]
	add	w8, w8, #1                      // =1
	strh	w8, [x19]
	bl	make_superblock
	ldrb	w8, [x19, #7]
	cbz	w8, .LBB24_29
.LBB24_30:
	ldr	w8, [x25, :lo12:g_GlobalSysVersion]
	ldrh	w9, [x19, #4]
	ldr	x10, [x22, :lo12:p_valid_page_count_table]
	ldrh	w11, [x19]
	str	w8, [x19, #12]
	add	w8, w8, #1                      // =1
	str	w8, [x25, :lo12:g_GlobalSysVersion]
	strh	w9, [x10, x11, lsl #1]
	adrp	x22, gSysFreeQueue+6
	ldrh	w8, [x22, :lo12:gSysFreeQueue+6]
	adrp	x9, g_gc_temp_superblock
	mov	w20, #65535
	strh	w20, [x9, :lo12:g_gc_temp_superblock]
	cbz	w8, .LBB24_36
// %bb.31:
	ldrh	w9, [x21, #2]
	sub	w8, w8, #1                      // =1
	mov	w2, #1
	add	x10, x21, x9, lsl #1
	ldrh	w19, [x10, #8]
	strh	w8, [x21, #6]
	adrp	x8, req_erase
	ldr	x10, [x8, :lo12:req_erase]
	add	w9, w9, #1                      // =1
	and	w9, w9, #0x3ff
	strh	w9, [x21, #2]
	lsl	w9, w19, #10
	str	w9, [x10, #4]
	ldr	x0, [x8, :lo12:req_erase]
	bl	FlashEraseBlocks
	adrp	x8, g_totle_sys_slc_erase_count
	ldr	w9, [x8, :lo12:g_totle_sys_slc_erase_count]
	cmp	w19, w20
	add	w9, w9, #1                      // =1
	str	w9, [x8, :lo12:g_totle_sys_slc_erase_count]
	b.eq	.LBB24_37
// %bb.32:
	cbz	w19, .LBB24_37
// %bb.33:
	ldr	w10, [x24, :lo12:g_MaxLbn]
	ldr	w11, [x25, :lo12:g_GlobalSysVersion]
	adrp	x8, gSysInfo
	add	x8, x8, :lo12:gSysInfo
	mov	w9, #-65536
	strh	w19, [x8]
	stur	w9, [x8, #2]
	strh	w10, [x8, #6]
	str	w11, [x8, #8]
	add	w8, w11, #1                     // =1
	str	w8, [x25, :lo12:g_GlobalSysVersion]
	bl	FtlVpcTblFlush
	bl	FtlSysBlkInit
	cbnz	w0, .LBB24_35
// %bb.34:
	adrp	x8, gFtlInitStatus
	mov	w9, #1
	str	w9, [x8, :lo12:gFtlInitStatus]
.LBB24_35:
	ldp	x20, x19, [sp, #80]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #96             // 16-byte Folded Reload
	hint	#29
	ret
.LBB24_36:
	mov	w19, #65535
.LBB24_37:
	ldrh	w2, [x22, :lo12:gSysFreeQueue+6]
	adrp	x0, .L.str.86
	add	x0, x0, :lo12:.L.str.86
	mov	w1, w19
	bl	sftl_printk
.LBB24_38:                              // =>This Inner Loop Header: Depth=1
	b	.LBB24_38
.Lfunc_end24:
	.size	ftl_low_format, .Lfunc_end24-ftl_low_format
                                        // -- End function
	.globl	FtlFreeSysBlkQueueInit          // -- Begin function FtlFreeSysBlkQueueInit
	.p2align	2
	.type	FtlFreeSysBlkQueueInit,@function
FtlFreeSysBlkQueueInit:                 // @FtlFreeSysBlkQueueInit
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
	adrp	x8, gSysFreeQueue
	add	x8, x8, :lo12:gSysFreeQueue
	strh	w0, [x8]
	add	x0, x8, #8                      // =8
	mov	w2, #2048
	mov	w1, wzr
	mov	x29, sp
	stur	wzr, [x8, #2]
	strh	wzr, [x8, #6]
	bl	memset
	mov	w0, wzr
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end25:
	.size	FtlFreeSysBlkQueueInit, .Lfunc_end25-FtlFreeSysBlkQueueInit
                                        // -- End function
	.globl	FtlLoadBbt                      // -- Begin function FtlLoadBbt
	.p2align	2
	.type	FtlLoadBbt,@function
FtlLoadBbt:                             // @FtlLoadBbt
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-64]!           // 16-byte Folded Spill
	stp	x24, x23, [sp, #16]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #32]             // 16-byte Folded Spill
	adrp	x21, p_sys_data_buf
	adrp	x8, p_sys_spare_buf
	adrp	x24, c_ftl_nand_blks_per_die
	stp	x20, x19, [sp, #48]             // 16-byte Folded Spill
	adrp	x20, gBbtInfo
	ldr	x10, [x21, :lo12:p_sys_data_buf]
	ldr	x22, [x8, :lo12:p_sys_spare_buf]
	ldrh	w8, [x24, :lo12:c_ftl_nand_blks_per_die]
	add	x20, x20, :lo12:gBbtInfo
	mov	w9, #65535
	strh	w9, [x20]
	adrp	x9, req_sys+8
	add	x9, x9, :lo12:req_sys+8
	stp	x10, x22, [x9]
	sub	w9, w8, #1                      // =1
	sub	w8, w8, #16                     // =16
	and	w23, w9, #0xffff
	cmp	w8, w23
	mov	x8, #-1
	mov	x29, sp
	strh	wzr, [x20, #6]
	stur	x8, [x20, #12]
	stur	x8, [x20, #20]
	b.ge	.LBB26_19
// %bb.1:
	adrp	x19, req_sys
	add	x19, x19, :lo12:req_sys
	b	.LBB26_4
.LBB26_2:                               //   in Loop: Header=BB26_4 Depth=1
	ldrsh	w8, [x22]
	cmn	w8, #3887                       // =3887
	b.eq	.LBB26_7
.LBB26_3:                               //   in Loop: Header=BB26_4 Depth=1
	ldrh	w8, [x24, :lo12:c_ftl_nand_blks_per_die]
	sub	w9, w23, #1                     // =1
	and	w23, w9, #0xffff
	sub	w8, w8, #16                     // =16
	cmp	w8, w23
	b.ge	.LBB26_6
.LBB26_4:                               // =>This Inner Loop Header: Depth=1
	lsl	w8, w23, #10
	mov	w1, #1
	mov	x0, x19
	str	w8, [x19, #4]
	bl	FlashReadPages
	ldr	w8, [x19]
	cmn	w8, #1                          // =1
	b.ne	.LBB26_2
// %bb.5:                               //   in Loop: Header=BB26_4 Depth=1
	ldr	w8, [x19, #4]
	mov	w1, #1
	mov	x0, x19
	add	w8, w8, #1                      // =1
	str	w8, [x19, #4]
	bl	FlashReadPages
	ldr	w8, [x19]
	cmn	w8, #1                          // =1
	b.ne	.LBB26_2
	b	.LBB26_3
.LBB26_6:
	adrp	x8, gBbtInfo
	ldrh	w23, [x8, :lo12:gBbtInfo]
	b	.LBB26_8
.LBB26_7:
	strh	w23, [x20]
	ldr	w8, [x22, #4]
	str	w8, [x20, #8]
	ldrh	w8, [x22, #8]
	strh	w8, [x20, #4]
.LBB26_8:
	mvn	w8, w23
	tst	w8, #0xffff
	b.eq	.LBB26_19
// %bb.9:
	adrp	x8, gBbtInfo+4
	ldrh	w8, [x8, :lo12:gBbtInfo+4]
	mov	w9, #65535
	cmp	w8, w9
	b.eq	.LBB26_14
// %bb.10:
	lsl	w8, w8, #10
	mov	w1, #1
	mov	x0, x19
	str	w8, [x19, #4]
	bl	FlashReadPages
	ldr	w8, [x19]
	cmn	w8, #1                          // =1
	b.eq	.LBB26_14
// %bb.11:
	ldrsh	w8, [x22]
	cmn	w8, #3887                       // =3887
	b.ne	.LBB26_14
// %bb.12:
	adrp	x9, gBbtInfo+8
	ldr	w8, [x22, #4]
	ldr	w9, [x9, :lo12:gBbtInfo+8]
	cmp	w8, w9
	b.ls	.LBB26_14
// %bb.13:
	ldrh	w9, [x20, #4]
	str	w8, [x20, #8]
	strh	w9, [x20]
	ldrh	w8, [x22, #8]
	strh	w8, [x20, #4]
.LBB26_14:
	ldrh	w0, [x20]
	mov	w1, #1
	bl	FtlGetLastWrittenPage
	add	w8, w0, #1                      // =1
	strh	w8, [x20, #2]
	tbnz	w0, #15, .LBB26_20
// %bb.15:
	and	w23, w0, #0xffff
	adrp	x24, gBbtInfo
	b	.LBB26_17
.LBB26_16:                              //   in Loop: Header=BB26_17 Depth=1
	cmp	w23, #0                         // =0
	sub	w23, w23, #1                    // =1
	b.le	.LBB26_20
.LBB26_17:                              // =>This Inner Loop Header: Depth=1
	ldrh	w8, [x24, :lo12:gBbtInfo]
	ldr	x9, [x21, :lo12:p_sys_data_buf]
	mov	w1, #1
	mov	x0, x19
	orr	w8, w23, w8, lsl #10
	str	w8, [x19, #4]
	str	x9, [x19, #8]
	bl	FlashReadPages
	ldr	w8, [x19]
	cmn	w8, #1                          // =1
	b.eq	.LBB26_16
// %bb.18:                              //   in Loop: Header=BB26_17 Depth=1
	ldrsh	w8, [x22]
	cmn	w8, #3887                       // =3887
	b.ne	.LBB26_16
	b	.LBB26_21
.LBB26_19:
	mov	w0, #-1
	b	.LBB26_30
.LBB26_20:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlLoadBbt
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlLoadBbt
	mov	w2, #251
	bl	sftl_printk
.LBB26_21:
	ldrh	w8, [x22, #10]
	adrp	x9, gBbtInfo+6
	strh	w8, [x9, :lo12:gBbtInfo+6]
	ldrh	w9, [x22, #12]
	mov	w8, #65535
	cmp	w9, w8
	b.eq	.LBB26_26
// %bb.22:
	adrp	x8, c_ftl_nand_sys_blks_per_plane
	ldr	w11, [x8, :lo12:c_ftl_nand_sys_blks_per_plane]
	cmp	w11, w9
	b.eq	.LBB26_26
// %bb.23:
	adrp	x10, c_ftl_nand_blk_pre_plane
	ldrh	w10, [x10, :lo12:c_ftl_nand_blk_pre_plane]
	lsr	w12, w10, #2
	cmp	w9, w12
	b.hs	.LBB26_26
// %bb.24:
	cmp	w11, w12
	b.hs	.LBB26_26
// %bb.25:
	cmp	w9, #24                         // =24
	mov	w11, #24
	csel	w9, w9, w11, hi
	adrp	x11, c_ftl_nand_data_blks_per_plane
	sub	w10, w10, w9
	strh	w10, [x11, :lo12:c_ftl_nand_data_blks_per_plane]
	adrp	x10, c_ftl_nand_planes_num
	adrp	x11, c_ftl_nand_totle_phy_blks
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_num]
	ldr	w11, [x11, :lo12:c_ftl_nand_totle_phy_blks]
	str	w9, [x8, :lo12:c_ftl_nand_sys_blks_per_plane]
	adrp	x8, c_ftl_nand_max_sys_blks
	mul	w9, w10, w9
	str	w9, [x8, :lo12:c_ftl_nand_max_sys_blks]
	sub	w8, w11, w9
	adrp	x9, c_ftl_nand_max_data_blks
	str	w8, [x9, :lo12:c_ftl_nand_max_data_blks]
.LBB26_26:
	adrp	x19, c_ftl_nand_die_num
	ldrh	w8, [x19, :lo12:c_ftl_nand_die_num]
	cbz	w8, .LBB26_29
// %bb.27:
	mov	x21, xzr
	adrp	x22, req_sys+8
	adrp	x23, c_ftl_nand_bbm_buf_size
.LBB26_28:                              // =>This Inner Loop Header: Depth=1
	ldrh	w8, [x23, :lo12:c_ftl_nand_bbm_buf_size]
	ldr	x9, [x22, :lo12:req_sys+8]
	add	x10, x20, x21, lsl #3
	ldr	x0, [x10, #32]
	mul	w10, w21, w8
	add	x1, x9, w10, uxtw #2
	lsl	x2, x8, #2
	bl	memcpy
	ldrh	w8, [x19, :lo12:c_ftl_nand_die_num]
	add	x21, x21, #1                    // =1
	cmp	x21, x8
	b.lo	.LBB26_28
.LBB26_29:
	mov	w0, wzr
.LBB26_30:
	ldp	x20, x19, [sp, #48]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #32]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #64             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end26:
	.size	FtlLoadBbt, .Lfunc_end26-FtlLoadBbt
                                        // -- End function
	.globl	FtlMakeBbt                      // -- Begin function FtlMakeBbt
	.p2align	2
	.type	FtlMakeBbt,@function
FtlMakeBbt:                             // @FtlMakeBbt
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-96]!           // 16-byte Folded Spill
	stp	x26, x25, [sp, #32]             // 16-byte Folded Spill
	adrp	x25, gBbtInfo
	stp	x28, x27, [sp, #16]             // 16-byte Folded Spill
	add	x25, x25, :lo12:gBbtInfo
	mov	x8, #-1
	adrp	x28, p_sys_data_buf
	adrp	x9, p_sys_spare_buf
	adrp	x27, c_ftl_nand_die_num
	stp	x22, x21, [sp, #64]             // 16-byte Folded Spill
	stur	x8, [x25, #12]
	stur	x8, [x25, #20]
	ldr	x8, [x28, :lo12:p_sys_data_buf]
	ldr	x21, [x9, :lo12:p_sys_spare_buf]
	ldrh	w9, [x27, :lo12:c_ftl_nand_die_num]
	adrp	x10, req_sys+8
	stp	x20, x19, [sp, #80]             // 16-byte Folded Spill
	mov	w20, #65535
	add	x10, x10, :lo12:req_sys+8
	adrp	x26, c_ftl_nand_blks_per_die
	stp	x24, x23, [sp, #48]             // 16-byte Folded Spill
	mov	x29, sp
	strh	w20, [x25]
	strh	wzr, [x25, #6]
	stp	x8, x21, [x10]
	cbz	w9, .LBB27_34
// %bb.1:
	adrp	x19, req_sys
	mov	x22, xzr
	add	x19, x19, :lo12:req_sys
	b	.LBB27_3
.LBB27_2:                               //   in Loop: Header=BB27_3 Depth=1
	ldrh	w8, [x27, :lo12:c_ftl_nand_die_num]
	add	x22, x22, #1                    // =1
	cmp	x22, x8
	b.hs	.LBB27_8
.LBB27_3:                               // =>This Loop Header: Depth=1
                                        //     Child Loop BB27_5 Depth 2
	ldrh	w8, [x26, :lo12:c_ftl_nand_blks_per_die]
	add	x23, x25, x22, lsl #1
	strh	w20, [x23, #12]!
	sub	w9, w8, #1                      // =1
	and	w24, w9, #0xffff
	sub	w9, w8, #16                     // =16
	cmp	w9, w24
	b.lt	.LBB27_5
	b	.LBB27_2
.LBB27_4:                               //   in Loop: Header=BB27_5 Depth=2
	ldrh	w8, [x26, :lo12:c_ftl_nand_blks_per_die]
	sub	w9, w24, #1                     // =1
	and	w24, w9, #0xffff
	sub	w9, w8, #16                     // =16
	cmp	w9, w24
	b.ge	.LBB27_2
.LBB27_5:                               //   Parent Loop BB27_3 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	madd	w8, w8, w22, w24
	lsl	w8, w8, #10
	mov	w1, #1
	mov	x0, x19
	str	w8, [x19, #4]
	bl	FlashReadPages
	ldr	w8, [x19]
	cmn	w8, #1                          // =1
	b.eq	.LBB27_4
// %bb.6:                               //   in Loop: Header=BB27_5 Depth=2
	ldrsh	w8, [x21]
	cmn	w8, #3872                       // =3872
	b.ne	.LBB27_4
// %bb.7:                               //   in Loop: Header=BB27_3 Depth=1
	strh	w24, [x23]
	b	.LBB27_2
.LBB27_8:
	cbz	w8, .LBB27_34
// %bb.9:
	mov	x20, xzr
	b	.LBB27_12
.LBB27_10:                              //   in Loop: Header=BB27_12 Depth=1
	ldrh	w9, [x26, :lo12:c_ftl_nand_blks_per_die]
	mov	w1, #1
	mov	x0, x19
	madd	w23, w20, w9, w8
	lsl	w8, w23, #10
	str	w8, [x19, #4]
	bl	FlashReadPages
	ldrh	w9, [x26, :lo12:c_ftl_nand_blks_per_die]
	add	x8, x25, x20, lsl #3
	ldr	x0, [x8, #32]
	ldr	x1, [x19, #8]
	add	x8, x9, #7                      // =7
	lsr	x2, x8, #3
	bl	memcpy
.LBB27_11:                              //   in Loop: Header=BB27_12 Depth=1
	ldrh	w8, [x26, :lo12:c_ftl_nand_blks_per_die]
	and	w1, w23, #0xffff
	mov	w12, #1
	adrp	x0, .L.str.82
	udiv	w2, w1, w8
	add	x9, x25, w2, uxtw #3
	ldr	x9, [x9, #32]
	msub	w8, w2, w8, w23
	ubfx	w10, w8, #3, #13
	and	x10, x10, #0x1ffc
	ldr	w11, [x9, x10]
	and	w3, w8, #0xffff
	lsl	w8, w12, w8
	add	x0, x0, :lo12:.L.str.82
	orr	w4, w8, w11
	adrp	x21, c_ftl_nand_die_num
	str	w4, [x9, x10]
	bl	sftl_printk
	ldrh	w8, [x25, #6]
	ldrh	w9, [x21, :lo12:c_ftl_nand_die_num]
	add	x20, x20, #1                    // =1
	add	w8, w8, #1                      // =1
	cmp	x20, x9
	strh	w8, [x25, #6]
	b.hs	.LBB27_34
.LBB27_12:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB27_20 Depth 2
                                        //     Child Loop BB27_23 Depth 2
                                        //     Child Loop BB27_26 Depth 2
                                        //     Child Loop BB27_30 Depth 2
                                        //       Child Loop BB27_31 Depth 3
	adrp	x8, p_sys_spare_buf
	ldr	x24, [x28, :lo12:p_sys_data_buf]
	ldr	x27, [x8, :lo12:p_sys_spare_buf]
	adrp	x8, req_sys+8
	add	x8, x8, :lo12:req_sys+8
	add	x22, x25, x20, lsl #1
	stp	x24, x27, [x8]
	ldrh	w8, [x22, #12]!
	mov	w9, #65535
	cmp	w8, w9
	b.ne	.LBB27_10
// %bb.13:                              //   in Loop: Header=BB27_12 Depth=1
	mov	x21, #-1
	stp	x21, x21, [x24, #240]
	stp	x21, x21, [x24, #224]
	stp	x21, x21, [x24, #208]
	stp	x21, x21, [x24, #192]
	stp	x21, x21, [x24, #176]
	stp	x21, x21, [x24, #160]
	stp	x21, x21, [x24, #144]
	stp	x21, x21, [x24, #128]
	stp	x21, x21, [x24, #112]
	stp	x21, x21, [x24, #96]
	stp	x21, x21, [x24, #80]
	stp	x21, x21, [x24, #64]
	stp	x21, x21, [x24, #48]
	stp	x21, x21, [x24, #32]
	stp	x21, x21, [x24, #16]
	stp	x21, x21, [x24]
	adrp	x8, g_nand_ops
	ldr	x8, [x8, :lo12:g_nand_ops]
	mov	x0, x24
	mov	w1, w20
	blr	x8
	and	w8, w0, #0xffff
	cmp	w8, #51                         // =51
	b.lo	.LBB27_15
// %bb.14:                              //   in Loop: Header=BB27_12 Depth=1
	stp	x21, x21, [x24, #240]
	stp	x21, x21, [x24, #224]
	stp	x21, x21, [x24, #208]
	stp	x21, x21, [x24, #192]
	stp	x21, x21, [x24, #176]
	stp	x21, x21, [x24, #160]
	stp	x21, x21, [x24, #144]
	stp	x21, x21, [x24, #128]
	stp	x21, x21, [x24, #112]
	stp	x21, x21, [x24, #96]
	stp	x21, x21, [x24, #80]
	stp	x21, x21, [x24, #64]
	stp	x21, x21, [x24, #48]
	stp	x21, x21, [x24, #32]
	stp	x21, x21, [x24, #16]
	stp	x21, x21, [x24]
	b	.LBB27_24
.LBB27_15:                              //   in Loop: Header=BB27_12 Depth=1
	tst	w0, #0xffff
	b.eq	.LBB27_24
// %bb.16:                              //   in Loop: Header=BB27_12 Depth=1
	adrp	x9, g_nand_phy_info+14
	ldrh	w9, [x9, :lo12:g_nand_phy_info+14]
	cmp	w9, #4                          // =4
	b.ne	.LBB27_24
// %bb.17:                              //   in Loop: Header=BB27_12 Depth=1
	cmp	w8, #2                          // =2
	mov	w8, w8
	b.hs	.LBB27_19
// %bb.18:                              //   in Loop: Header=BB27_12 Depth=1
	mov	x9, xzr
	b	.LBB27_22
.LBB27_19:                              //   in Loop: Header=BB27_12 Depth=1
	and	x9, x8, #0xfffe
	add	x10, x24, #2                    // =2
	mov	x11, x9
.LBB27_20:                              //   Parent Loop BB27_12 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldurh	w12, [x10, #-2]
	ldrh	w13, [x10]
	subs	x11, x11, #2                    // =2
	lsr	w12, w12, #1
	lsr	w13, w13, #1
	sturh	w12, [x10, #-2]
	strh	w13, [x10], #4
	b.ne	.LBB27_20
// %bb.21:                              //   in Loop: Header=BB27_12 Depth=1
	cmp	x9, x8
	b.eq	.LBB27_24
.LBB27_22:                              //   in Loop: Header=BB27_12 Depth=1
	sub	x8, x8, x9
	add	x9, x24, x9, lsl #1
.LBB27_23:                              //   Parent Loop BB27_12 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldrh	w10, [x9]
	subs	x8, x8, #1                      // =1
	lsr	w10, w10, #1
	strh	w10, [x9], #2
	b.ne	.LBB27_23
.LBB27_24:                              //   in Loop: Header=BB27_12 Depth=1
	adrp	x8, req_sys+8
	ldr	x23, [x8, :lo12:req_sys+8]
	add	x21, x25, x20, lsl #3
	adrp	x8, c_ftl_nand_bbm_buf_size
	ldr	x24, [x21, #32]!
	ldrh	w8, [x8, :lo12:c_ftl_nand_bbm_buf_size]
	mov	w1, wzr
	mov	x0, x24
	lsl	x2, x8, #2
	bl	memset
	mov	x28, xzr
	b	.LBB27_26
.LBB27_25:                              //   in Loop: Header=BB27_26 Depth=2
	lsr	w9, w8, #3
	and	x9, x9, #0x1ffc
	ldr	w10, [x24, x9]
	mov	w11, #1
	lsl	w8, w11, w8
	add	x28, x28, #2                    // =2
	orr	w8, w8, w10
	cmp	x28, #1024                      // =1024
	str	w8, [x24, x9]
	b.eq	.LBB27_29
.LBB27_26:                              //   Parent Loop BB27_12 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldrh	w8, [x23, x28]
	mov	w9, #65535
	cmp	w8, w9
	b.eq	.LBB27_29
// %bb.27:                              //   in Loop: Header=BB27_26 Depth=2
	ldrh	w9, [x26, :lo12:c_ftl_nand_blks_per_die]
	cmp	w8, w9
	b.lo	.LBB27_25
// %bb.28:                              //   in Loop: Header=BB27_26 Depth=2
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlBbt2Bitmap
	mov	w2, #74
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlBbt2Bitmap
	bl	sftl_printk
	ldrh	w8, [x23, x28]
	b	.LBB27_25
.LBB27_29:                              //   in Loop: Header=BB27_12 Depth=1
	ldrh	w8, [x26, :lo12:c_ftl_nand_blks_per_die]
	adrp	x28, p_sys_data_buf
	sub	w24, w8, #1                     // =1
.LBB27_30:                              //   Parent Loop BB27_12 Depth=1
                                        // =>  This Loop Header: Depth=2
                                        //       Child Loop BB27_31 Depth 3
	mul	w9, w8, w20
	mov	w10, w24
.LBB27_31:                              //   Parent Loop BB27_12 Depth=1
                                        //     Parent Loop BB27_30 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	mov	w24, w10
	add	w10, w9, w10
	and	w11, w10, #0xffff
	and	w12, w8, #0xffff
	udiv	w11, w11, w12
	add	x12, x25, w11, uxtw #3
	ldr	x12, [x12, #32]
	msub	w10, w11, w8, w10
	lsr	w11, w10, #3
	and	x11, x11, #0x1ffc
	ldr	w11, [x12, x11]
	lsr	w11, w11, w10
	sub	w10, w24, #1                    // =1
	tbnz	w11, #0, .LBB27_31
// %bb.32:                              //   in Loop: Header=BB27_30 Depth=2
	adrp	x8, p_sys_spare_buf
	ldr	x8, [x8, :lo12:p_sys_spare_buf]
	strh	w24, [x22]
	mov	w2, #4096
	mov	w1, wzr
	stp	xzr, xzr, [x8]
	ldr	x0, [x28, :lo12:p_sys_data_buf]
	bl	memset
	mov	w8, #61664
	strh	w8, [x27]
	str	wzr, [x27, #4]
	ldrh	w8, [x22]
	adrp	x10, c_ftl_nand_bbm_buf_size
	strh	w8, [x27, #2]
	ldrh	w8, [x26, :lo12:c_ftl_nand_blks_per_die]
	ldrh	w9, [x22]
	ldrh	w10, [x10, :lo12:c_ftl_nand_bbm_buf_size]
	ldr	x0, [x19, #8]
	ldr	x1, [x21]
	madd	w23, w20, w8, w9
	lsl	w8, w23, #10
	lsl	x2, x10, #2
	str	w8, [x19, #4]
	bl	memcpy
	mov	w2, #1
	mov	x0, x19
	bl	FlashEraseBlocks
	mov	w1, #1
	mov	w2, #1
	mov	x0, x19
	bl	FlashProgPages
	ldr	w8, [x19]
	cmn	w8, #1                          // =1
	b.ne	.LBB27_11
// %bb.33:                              //   in Loop: Header=BB27_30 Depth=2
	ldrh	w8, [x26, :lo12:c_ftl_nand_blks_per_die]
	and	w1, w23, #0xffff
	mov	w12, #1
	adrp	x0, .L.str.82
	udiv	w2, w1, w8
	add	x9, x25, w2, uxtw #3
	ldr	x9, [x9, #32]
	msub	w8, w2, w8, w23
	ubfx	w10, w8, #3, #13
	and	x10, x10, #0x1ffc
	ldr	w11, [x9, x10]
	and	w3, w8, #0xffff
	lsl	w8, w12, w8
	add	x0, x0, :lo12:.L.str.82
	orr	w4, w8, w11
	str	w4, [x9, x10]
	bl	sftl_printk
	ldrh	w9, [x25, #6]
	ldrh	w8, [x26, :lo12:c_ftl_nand_blks_per_die]
	add	w9, w9, #1                      // =1
	strh	w9, [x25, #6]
	b	.LBB27_30
.LBB27_34:
	adrp	x21, c_ftl_nand_reserved_blks
	ldrh	w8, [x21, :lo12:c_ftl_nand_reserved_blks]
	cbz	w8, .LBB27_37
// %bb.35:
	adrp	x20, .L.str.82
	mov	w19, wzr
	mov	w22, #1
	add	x20, x20, :lo12:.L.str.82
.LBB27_36:                              // =>This Inner Loop Header: Depth=1
	ldrh	w8, [x26, :lo12:c_ftl_nand_blks_per_die]
	and	w9, w19, #0xffff
	mov	x0, x20
	mov	w1, w19
	udiv	w2, w9, w8
	add	x9, x25, w2, uxtw #3
	mul	w8, w2, w8
	ldr	x9, [x9, #32]
	sub	w3, w19, w8, uxth
	lsr	w8, w3, #5
	lsl	x8, x8, #2
	ldr	w10, [x9, x8]
	lsl	w11, w22, w3
	orr	w4, w11, w10
	str	w4, [x9, x8]
	bl	sftl_printk
	ldrh	w8, [x25, #6]
	ldrh	w9, [x21, :lo12:c_ftl_nand_reserved_blks]
	add	w19, w19, #1                    // =1
	add	w8, w8, #1                      // =1
	cmp	w19, w9
	strh	w8, [x25, #6]
	b.lo	.LBB27_36
.LBB27_37:
	adrp	x22, gBbtInfo+12
	ldrh	w8, [x22, :lo12:gBbtInfo+12]
	sub	w9, w8, #1                      // =1
	and	w21, w9, #0xffff
	sub	w8, w8, #48                     // =48
	cmp	w8, w21
	b.ge	.LBB27_46
// %bb.38:
	adrp	x20, .L.str.82
	adrp	x23, gBbtInfo
	mov	w24, #1
	add	x20, x20, :lo12:.L.str.82
	mov	w19, w21
	b	.LBB27_41
.LBB27_39:                              //   in Loop: Header=BB27_41 Depth=1
	ldrh	w8, [x26, :lo12:c_ftl_nand_blks_per_die]
	and	w9, w19, #0xffff
	mov	x0, x20
	mov	w1, w21
	udiv	w2, w9, w8
	add	x9, x25, w2, uxtw #3
	ldr	x9, [x9, #32]
	msub	w8, w2, w8, w19
	ubfx	w10, w8, #3, #13
	and	x10, x10, #0x1ffc
	ldr	w11, [x9, x10]
	and	w3, w8, #0xffff
	lsl	w8, w24, w8
	orr	w4, w8, w11
	str	w4, [x9, x10]
	bl	sftl_printk
	ldrh	w8, [x25, #6]
	add	w8, w8, #1                      // =1
	strh	w8, [x25, #6]
.LBB27_40:                              //   in Loop: Header=BB27_41 Depth=1
	ldrh	w8, [x22, :lo12:gBbtInfo+12]
	sub	w19, w19, #1                    // =1
	and	w21, w19, #0xffff
	sub	w8, w8, #48                     // =48
	cmp	w8, w21
	b.ge	.LBB27_46
.LBB27_41:                              // =>This Inner Loop Header: Depth=1
	ldrh	w8, [x26, :lo12:c_ftl_nand_blks_per_die]
	and	w10, w19, #0xffff
	and	w9, w8, #0xffff
	udiv	w9, w10, w9
	add	x10, x25, w9, uxtw #3
	ldr	x10, [x10, #32]
	msub	w8, w9, w8, w19
	lsr	w9, w8, #3
	and	x9, x9, #0x1ffc
	ldr	w9, [x10, x9]
	lsr	w8, w9, w8
	tbnz	w8, #0, .LBB27_40
// %bb.42:                              //   in Loop: Header=BB27_41 Depth=1
	mov	w0, w19
	bl	FlashTestBlk
	cbnz	w0, .LBB27_39
// %bb.43:                              //   in Loop: Header=BB27_41 Depth=1
	ldrsh	w8, [x23, :lo12:gBbtInfo]
	cmn	w8, #1                          // =1
	b.ne	.LBB27_45
// %bb.44:                              //   in Loop: Header=BB27_41 Depth=1
	strh	w19, [x23, :lo12:gBbtInfo]
	b	.LBB27_40
.LBB27_45:
	adrp	x8, gBbtInfo+4
	strh	w19, [x8, :lo12:gBbtInfo+4]
.LBB27_46:
	ldrh	w8, [x25]
	adrp	x9, req_erase
	ldr	x10, [x9, :lo12:req_erase]
	strh	wzr, [x25, #2]
	lsl	w8, w8, #10
	str	wzr, [x25, #8]
	str	w8, [x10, #4]
	ldrh	w8, [x25, #4]
	ldr	x10, [x9, :lo12:req_erase]
	mov	w2, #2
	lsl	w8, w8, #10
	str	w8, [x10, #36]
	ldr	x0, [x9, :lo12:req_erase]
	bl	FlashEraseBlocks
	ldrh	w1, [x25]
	ldrh	w8, [x26, :lo12:c_ftl_nand_blks_per_die]
	add	x20, x25, #32                   // =32
	mov	w21, #1
	adrp	x19, .L.str.82
	udiv	w2, w1, w8
	ldr	x9, [x20, w2, uxtw #3]
	msub	w8, w2, w8, w1
	ubfx	w10, w8, #3, #13
	and	x10, x10, #0x1ffc
	ldr	w11, [x9, x10]
	and	w3, w8, #0xffff
	lsl	w8, w21, w8
	add	x19, x19, :lo12:.L.str.82
	orr	w4, w8, w11
	mov	x0, x19
	str	w4, [x9, x10]
	bl	sftl_printk
	ldrh	w8, [x25, #6]
	ldrh	w1, [x25, #4]
	ldrh	w9, [x26, :lo12:c_ftl_nand_blks_per_die]
	mov	x0, x19
	add	w8, w8, #1                      // =1
	strh	w8, [x25, #6]
	udiv	w2, w1, w9
	ldr	x8, [x20, w2, uxtw #3]
	msub	w9, w2, w9, w1
	ubfx	w10, w9, #3, #13
	and	x10, x10, #0x1ffc
	ldr	w11, [x8, x10]
	and	w3, w9, #0xffff
	lsl	w9, w21, w9
	orr	w4, w9, w11
	str	w4, [x8, x10]
	bl	sftl_printk
	ldrh	w8, [x25, #6]
	add	w8, w8, #1                      // =1
	strh	w8, [x25, #6]
	bl	FtlBbmTblFlush
	ldr	w8, [x25, #8]
	ldrh	w9, [x25, #4]
	ldrh	w10, [x25]
	strh	wzr, [x25, #2]
	add	w8, w8, #1                      // =1
	strh	w9, [x25]
	str	w8, [x25, #8]
	strh	w10, [x25, #4]
	bl	FtlBbmTblFlush
	ldp	x20, x19, [sp, #80]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #96             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end27:
	.size	FtlMakeBbt, .Lfunc_end27-FtlMakeBbt
                                        // -- End function
	.globl	FtlBbmTblFlush                  // -- Begin function FtlBbmTblFlush
	.p2align	2
	.type	FtlBbmTblFlush,@function
FtlBbmTblFlush:                         // @FtlBbmTblFlush
// %bb.0:
	hint	#25
	sub	sp, sp, #112                    // =112
	adrp	x9, p_sys_data_buf
	adrp	x10, p_sys_spare_buf
	adrp	x8, c_ftl_nand_byte_pre_page
	ldr	x0, [x9, :lo12:p_sys_data_buf]
	ldr	x9, [x10, :lo12:p_sys_spare_buf]
	ldrh	w2, [x8, :lo12:c_ftl_nand_byte_pre_page]
	adrp	x8, req_sys+8
	add	x8, x8, :lo12:req_sys+8
	mov	w1, wzr
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	stp	x28, x27, [sp, #32]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #48]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #64]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #80]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #96]             // 16-byte Folded Spill
	add	x29, sp, #16                    // =16
	stp	x0, x9, [x8]
	bl	memset
	adrp	x19, c_ftl_nand_die_num
	ldrh	w8, [x19, :lo12:c_ftl_nand_die_num]
	adrp	x24, gBbtInfo
	add	x24, x24, :lo12:gBbtInfo
	cbz	w8, .LBB28_3
// %bb.1:
	mov	x20, xzr
	adrp	x21, req_sys+8
	adrp	x22, c_ftl_nand_bbm_buf_size
.LBB28_2:                               // =>This Inner Loop Header: Depth=1
	ldrh	w8, [x22, :lo12:c_ftl_nand_bbm_buf_size]
	ldr	x9, [x21, :lo12:req_sys+8]
	add	x10, x24, x20, lsl #3
	ldr	x1, [x10, #32]
	mul	w10, w20, w8
	add	x0, x9, w10, sxtw #2
	lsl	x2, x8, #2
	bl	memcpy
	ldrh	w8, [x19, :lo12:c_ftl_nand_die_num]
	add	x20, x20, #1                    // =1
	cmp	x20, x8
	b.lo	.LBB28_2
.LBB28_3:
	adrp	x8, req_sys+16
	ldr	x27, [x8, :lo12:req_sys+16]
	mov	x8, #-1
	mov	w9, #61649
	adrp	x10, g_totle_avg_erase_count
	str	x8, [x27, #8]
	stur	x8, [x27, #2]
	strh	w9, [x27]
	ldr	w8, [x24, #8]
	adrp	x9, c_ftl_nand_sys_blks_per_plane
	adrp	x19, req_sys
	adrp	x20, .L.str.83
	str	w8, [x27, #4]
	ldrh	w8, [x24]
	adrp	x21, .L.str.84
	mov	w12, wzr
	mov	w11, wzr
	strh	w8, [x27, #2]
	ldrh	w8, [x24, #4]
	add	x19, x19, :lo12:req_sys
	add	x20, x20, :lo12:.L.str.83
	adrp	x26, c_ftl_nand_page_pre_slc_blk
	strh	w8, [x27, #8]
	ldrh	w8, [x24, #6]
	adrp	x25, gBbtInfo+2
	adrp	x28, req_sys+4
	add	x21, x21, :lo12:.L.str.84
	strh	w8, [x27, #10]
	ldr	w8, [x9, :lo12:c_ftl_nand_sys_blks_per_plane]
	adrp	x22, req_erase
	strh	w8, [x27, #12]
	ldr	w8, [x10, :lo12:g_totle_avg_erase_count]
	strh	w8, [x27, #14]
.LBB28_4:                               // =>This Loop Header: Depth=1
                                        //     Child Loop BB28_5 Depth 2
	mov	w23, w11
	stur	w12, [x29, #-4]                 // 4-byte Folded Spill
	str	w11, [sp, #8]                   // 4-byte Folded Spill
.LBB28_5:                               //   Parent Loop BB28_4 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	adrp	x8, p_sys_data_buf
	adrp	x9, p_sys_spare_buf
	ldr	x8, [x8, :lo12:p_sys_data_buf]
	ldr	x9, [x9, :lo12:p_sys_spare_buf]
	ldrh	w1, [x24]
	ldrh	w2, [x24, #2]
	ldrh	w3, [x24, #4]
	stp	x8, x9, [x19, #8]
	mov	x0, x20
	orr	w8, w2, w1, lsl #10
	stp	wzr, w8, [x19]
	ldrh	w4, [x27, #10]
	bl	sftl_printk
	ldrh	w8, [x26, :lo12:c_ftl_nand_page_pre_slc_blk]
	ldrh	w9, [x24, #2]
	sub	w8, w8, #1                      // =1
	cmp	w8, w9
	b.gt	.LBB28_7
// %bb.6:                               //   in Loop: Header=BB28_5 Depth=2
	ldr	w8, [x24, #8]
	mov	w2, #1
	add	w8, w8, #1                      // =1
	str	w8, [x24, #8]
	str	w8, [x27, #4]
	ldrh	w8, [x24]
	strh	w8, [x27, #8]
	ldrh	w9, [x24, #4]
	strh	w8, [x24, #4]
	ldr	x8, [x22, :lo12:req_erase]
	strh	wzr, [x24, #2]
	strh	w9, [x24]
	lsl	w9, w9, #10
	str	w9, [x28, :lo12:req_sys+4]
	str	w9, [x8, #4]
	ldr	x0, [x22, :lo12:req_erase]
	bl	FlashEraseBlocks
.LBB28_7:                               //   in Loop: Header=BB28_5 Depth=2
	mov	w1, #1
	mov	w2, #1
	mov	x0, x19
	bl	FlashProgPages
	ldrh	w9, [x25, :lo12:gBbtInfo+2]
	ldr	w8, [x19]
	add	w9, w9, #1                      // =1
	cmn	w8, #1                          // =1
	strh	w9, [x25, :lo12:gBbtInfo+2]
	b.ne	.LBB28_9
// %bb.8:                               //   in Loop: Header=BB28_5 Depth=2
	ldr	w1, [x28, :lo12:req_sys+4]
	mov	x0, x21
	bl	sftl_printk
	add	w23, w23, #1                    // =1
	and	w8, w23, #0xffff
	cmp	w8, #4                          // =4
	b.lo	.LBB28_5
	b	.LBB28_12
.LBB28_9:                               //   in Loop: Header=BB28_4 Depth=1
	ldur	w12, [x29, #-4]                 // 4-byte Folded Reload
	mov	w11, w23
	add	w12, w12, #1                    // =1
	cmp	w12, #2                         // =2
	b.lt	.LBB28_4
// %bb.10:                              //   in Loop: Header=BB28_4 Depth=1
	cmp	w8, #256                        // =256
	mov	w11, w23
	b.eq	.LBB28_4
// %bb.11:
	ldp	x20, x19, [sp, #96]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	add	sp, sp, #112                    // =112
	hint	#29
	ret
.LBB28_12:
	ldr	w9, [sp, #8]                    // 4-byte Folded Reload
	ldr	w1, [x28, :lo12:req_sys+4]
	adrp	x0, .L.str.85
	add	x0, x0, :lo12:.L.str.85
	add	w8, w9, #1                      // =1
	and	w8, w8, #0xffff
	cmp	w8, #4                          // =4
	mov	w8, #4
	csinc	w8, w8, w9, ls
	and	w2, w8, #0xffff
	bl	sftl_printk
.LBB28_13:                              // =>This Inner Loop Header: Depth=1
	b	.LBB28_13
.Lfunc_end28:
	.size	FtlBbmTblFlush, .Lfunc_end28-FtlBbmTblFlush
                                        // -- End function
	.globl	make_superblock                 // -- Begin function make_superblock
	.p2align	2
	.type	make_superblock,@function
make_superblock:                        // @make_superblock
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	adrp	x9, c_ftl_nand_data_blks_per_plane
	ldrh	w8, [x0]
	ldrh	w9, [x9, :lo12:c_ftl_nand_data_blks_per_plane]
	str	x19, [sp, #16]                  // 8-byte Folded Spill
	mov	x19, x0
	mov	x29, sp
	cmp	w8, w9
	b.lo	.LBB29_2
// %bb.1:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.make_superblock
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.make_superblock
	mov	w2, #2157
	bl	sftl_printk
.LBB29_2:
	strh	wzr, [x19, #4]
	strb	wzr, [x19, #7]
	adrp	x10, c_ftl_nand_planes_num
	ldrh	w9, [x10, :lo12:c_ftl_nand_planes_num]
	ldrh	w8, [x19]
	cbz	w9, .LBB29_7
// %bb.3:
	adrp	x13, p_plane_order_table
	adrp	x17, gBbtInfo
	mov	w9, wzr
	mov	x11, xzr
	add	x12, x19, #16                   // =16
	add	x13, x13, :lo12:p_plane_order_table
	adrp	x14, c_ftl_nand_planes_per_die
	adrp	x15, c_ftl_nand_blks_per_die
	mov	w16, #65535
	add	x17, x17, :lo12:gBbtInfo
	b	.LBB29_5
.LBB29_4:                               //   in Loop: Header=BB29_5 Depth=1
	ldrh	w18, [x10, :lo12:c_ftl_nand_planes_num]
	add	x11, x11, #1                    // =1
	cmp	x11, x18
	b.hs	.LBB29_7
.LBB29_5:                               // =>This Inner Loop Header: Depth=1
	ldrb	w18, [x13, x11]
	ldrh	w0, [x14, :lo12:c_ftl_nand_planes_per_die]
	ldrh	w1, [x15, :lo12:c_ftl_nand_blks_per_die]
	strh	w16, [x12, x11, lsl #1]
	and	w2, w18, #0xffff
	and	w3, w0, #0xffff
	udiv	w2, w2, w3
	mul	w3, w0, w8
	madd	w1, w1, w2, w3
	ldrh	w3, [x15, :lo12:c_ftl_nand_blks_per_die]
	msub	w18, w2, w0, w18
	add	w18, w1, w18
	and	w0, w18, #0xffff
	and	w1, w3, #0xffff
	udiv	w0, w0, w1
	add	x1, x17, w0, uxtw #3
	ldr	x1, [x1, #32]
	msub	w0, w0, w3, w18
	lsr	w2, w0, #3
	and	x2, x2, #0x1ffc
	ldr	w1, [x1, x2]
	lsr	w0, w1, w0
	tbnz	w0, #0, .LBB29_4
// %bb.6:                               //   in Loop: Header=BB29_5 Depth=1
	add	w9, w9, #1                      // =1
	strh	w18, [x12, x11, lsl #1]
	strb	w9, [x19, #7]
	b	.LBB29_4
.LBB29_7:
	adrp	x10, c_ftl_nand_page_pre_blk
	ldrh	w10, [x10, :lo12:c_ftl_nand_page_pre_blk]
	and	w9, w9, #0xff
	strb	wzr, [x19, #9]
	mov	w0, wzr
	mul	w9, w10, w9
	strh	w9, [x19, #4]
	adrp	x9, p_erase_count_table
	ldr	x9, [x9, :lo12:p_erase_count_table]
	ldrh	w8, [x9, x8, lsl #1]
	mov	w9, #10000
	cmp	w8, w9
	cset	w8, hi
	strb	w8, [x19, #9]
	ldr	x19, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end29:
	.size	make_superblock, .Lfunc_end29-make_superblock
                                        // -- End function
	.globl	FtlFreeSysBlkQueueOut           // -- Begin function FtlFreeSysBlkQueueOut
	.p2align	2
	.type	FtlFreeSysBlkQueueOut,@function
FtlFreeSysBlkQueueOut:                  // @FtlFreeSysBlkQueueOut
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-48]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #32]             // 16-byte Folded Spill
	adrp	x20, gSysFreeQueue+6
	ldrh	w8, [x20, :lo12:gSysFreeQueue+6]
	str	x21, [sp, #16]                  // 8-byte Folded Spill
	mov	w21, #65535
	mov	x29, sp
	cbz	w8, .LBB30_4
// %bb.1:
	adrp	x9, gSysFreeQueue
	add	x9, x9, :lo12:gSysFreeQueue
	ldrh	w10, [x9, #2]
	sub	w8, w8, #1                      // =1
	mov	w2, #1
	add	x11, x9, x10, lsl #1
	ldrh	w19, [x11, #8]
	strh	w8, [x9, #6]
	adrp	x8, req_erase
	ldr	x11, [x8, :lo12:req_erase]
	add	w10, w10, #1                    // =1
	and	w10, w10, #0x3ff
	strh	w10, [x9, #2]
	lsl	w9, w19, #10
	str	w9, [x11, #4]
	ldr	x0, [x8, :lo12:req_erase]
	bl	FlashEraseBlocks
	adrp	x8, g_totle_sys_slc_erase_count
	ldr	w9, [x8, :lo12:g_totle_sys_slc_erase_count]
	cmp	w19, w21
	add	w9, w9, #1                      // =1
	str	w9, [x8, :lo12:g_totle_sys_slc_erase_count]
	b.eq	.LBB30_5
// %bb.2:
	cbz	w19, .LBB30_5
// %bb.3:
	mov	w0, w19
	ldp	x20, x19, [sp, #32]             // 16-byte Folded Reload
	ldr	x21, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #48             // 16-byte Folded Reload
	hint	#29
	ret
.LBB30_4:
	mov	w19, #65535
.LBB30_5:
	ldrh	w2, [x20, :lo12:gSysFreeQueue+6]
	adrp	x0, .L.str.86
	add	x0, x0, :lo12:.L.str.86
	mov	w1, w19
	bl	sftl_printk
.LBB30_6:                               // =>This Inner Loop Header: Depth=1
	b	.LBB30_6
.Lfunc_end30:
	.size	FtlFreeSysBlkQueueOut, .Lfunc_end30-FtlFreeSysBlkQueueOut
                                        // -- End function
	.globl	FtlVpcTblFlush                  // -- Begin function FtlVpcTblFlush
	.p2align	2
	.type	FtlVpcTblFlush,@function
FtlVpcTblFlush:                         // @FtlVpcTblFlush
// %bb.0:
	hint	#25
	sub	sp, sp, #112                    // =112
	adrp	x15, gSysInfo
	stp	x22, x21, [sp, #80]             // 16-byte Folded Spill
	adrp	x21, p_sys_data_buf
	adrp	x22, p_sys_spare_buf
	add	x15, x15, :lo12:gSysInfo
	ldr	x12, [x21, :lo12:p_sys_data_buf]
	ldr	x17, [x22, :lo12:p_sys_spare_buf]
	ldrh	w13, [x15]
	stp	x20, x19, [sp, #96]             // 16-byte Folded Spill
	adrp	x19, req_sys+8
	add	x19, x19, :lo12:req_sys+8
	mov	w8, #61604
	stp	x12, x17, [x19]
	strh	w13, [x17, #2]
	strh	w8, [x17]
	ldr	w8, [x15, #8]
	mov	x9, #19539
	movk	x9, #18004, lsl #16
	adrp	x20, g_sys_save_data
	movk	x9, #89, lsl #32
	add	x20, x20, :lo12:g_sys_save_data
	movk	x9, #20480, lsl #48
	adrp	x10, c_ftl_nand_die_num
	str	xzr, [x17, #8]
	str	w8, [x17, #4]
	ldrh	w8, [x15, #6]
	str	x9, [x20]
	ldrb	w9, [x10, :lo12:c_ftl_nand_die_num]
	adrp	x11, g_active_superblock
	add	x11, x11, :lo12:g_active_superblock
	ldrh	w10, [x11]
	strh	w8, [x20, #8]
	ldrh	w8, [x11, #2]
	strb	w9, [x20, #10]
	ldrb	w9, [x11, #6]
	ldrb	w11, [x11, #8]
	adrp	x14, g_buffer_superblock
	add	x14, x14, :lo12:g_buffer_superblock
	strh	w10, [x20, #14]
	ldrh	w10, [x14]
	orr	w8, w9, w8, lsl #6
	ldrh	w9, [x14, #2]
	strb	w11, [x20, #11]
	ldrb	w11, [x14, #6]
	ldrb	w13, [x14, #8]
	adrp	x12, g_gc_temp_superblock
	add	x12, x12, :lo12:g_gc_temp_superblock
	strh	w10, [x20, #18]
	ldrh	w10, [x12]
	orr	w9, w11, w9, lsl #6
	ldrh	w11, [x12, #2]
	strb	w13, [x20, #12]
	ldrb	w13, [x12, #6]
	ldrb	w12, [x12, #8]
	stp	x24, x23, [sp, #64]             // 16-byte Folded Spill
	adrp	x16, g_GlobalSysVersion
	orr	w11, w13, w11, lsl #6
	adrp	x13, g_totle_mlc_erase_count
	strb	w12, [x20, #13]
	adrp	x12, g_GlobalDataVersion
	adrp	x23, c_ftl_nand_byte_pre_page
	strh	w10, [x20, #22]
	ldr	w14, [x16, :lo12:g_GlobalSysVersion]
	ldr	w10, [x13, :lo12:g_totle_mlc_erase_count]
	ldr	w12, [x12, :lo12:g_GlobalDataVersion]
	ldr	x0, [x19]
	ldrh	w2, [x23, :lo12:c_ftl_nand_byte_pre_page]
	mov	w1, #255
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	stp	x28, x27, [sp, #32]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #48]             // 16-byte Folded Spill
	add	x29, sp, #16                    // =16
	str	x17, [sp, #8]                   // 8-byte Folded Spill
	strh	w8, [x20, #16]
	strh	w9, [x20, #20]
	strh	w11, [x20, #24]
	str	w10, [x20, #32]
	stp	w12, w14, [x20, #36]
	bl	memset
	ldr	x8, [x19]
	ldp	x9, x10, [x20]
	adrp	x19, p_valid_page_count_table
	add	x0, x8, #48                     // =48
	stp	x9, x10, [x8]
	ldp	x9, x10, [x20, #32]
	ldp	x11, x12, [x20, #16]
	adrp	x20, c_ftl_nand_data_blks_per_plane
	stp	x9, x10, [x8, #32]
	stp	x11, x12, [x8, #16]
	ldrh	w9, [x20, :lo12:c_ftl_nand_data_blks_per_plane]
	ldr	x1, [x19, :lo12:p_valid_page_count_table]
	lsl	x2, x9, #1
	bl	memcpy
	adrp	x9, FtlUpdateVaildLpnCount
	ldrh	w8, [x9, :lo12:FtlUpdateVaildLpnCount]
	add	w10, w8, #1                     // =1
	cmp	w8, #5                          // =5
	strh	w10, [x9, :lo12:FtlUpdateVaildLpnCount]
	b.lo	.LBB31_6
// %bb.1:
	ldrh	w8, [x20, :lo12:c_ftl_nand_data_blks_per_plane]
	strh	wzr, [x9, :lo12:FtlUpdateVaildLpnCount]
	adrp	x9, g_VaildLpn
	str	wzr, [x9, :lo12:g_VaildLpn]
	cbz	x8, .LBB31_6
// %bb.2:
	ldr	x11, [x19, :lo12:p_valid_page_count_table]
	mov	w10, wzr
	mov	w12, #65535
	b	.LBB31_4
.LBB31_3:                               //   in Loop: Header=BB31_4 Depth=1
	subs	x8, x8, #1                      // =1
	add	x11, x11, #2                    // =2
	b.eq	.LBB31_6
.LBB31_4:                               // =>This Inner Loop Header: Depth=1
	ldrh	w13, [x11]
	cmp	w13, w12
	b.eq	.LBB31_3
// %bb.5:                               //   in Loop: Header=BB31_4 Depth=1
	add	w10, w10, w13
	str	w10, [x9, :lo12:g_VaildLpn]
	b	.LBB31_3
.LBB31_6:
	adrp	x25, gSysInfo+2
	ldrh	w8, [x25, :lo12:gSysInfo+2]
	adrp	x24, req_sys+4
	adrp	x26, req_sys
	mov	w10, wzr
	add	x24, x24, :lo12:req_sys+4
	adrp	x27, gSysInfo
	adrp	x19, c_ftl_nand_page_pre_slc_blk
	add	x26, x26, :lo12:req_sys
	mov	w28, #65535
.LBB31_7:                               // =>This Loop Header: Depth=1
                                        //     Child Loop BB31_8 Depth 2
                                        //       Child Loop BB31_15 Depth 3
	str	w10, [sp, #4]                   // 4-byte Folded Spill
.LBB31_8:                               //   Parent Loop BB31_7 Depth=1
                                        // =>  This Loop Header: Depth=2
                                        //       Child Loop BB31_15 Depth 3
	ldrh	w12, [x19, :lo12:c_ftl_nand_page_pre_slc_blk]
	ldr	x11, [x22, :lo12:p_sys_spare_buf]
	ldrh	w10, [x27, :lo12:gSysInfo]
	ldr	x9, [x21, :lo12:p_sys_data_buf]
	and	w8, w8, #0xffff
	sub	w12, w12, #1                    // =1
	stur	x11, [x24, #12]
	orr	w11, w8, w10, lsl #10
	cmp	w12, w8
	stur	x9, [x24, #4]
	str	w11, [x24]
	b.gt	.LBB31_13
// %bb.9:                               //   in Loop: Header=BB31_8 Depth=2
	adrp	x9, gSysInfo+2
	adrp	x8, gSysFreeQueue+6
	add	x9, x9, :lo12:gSysInfo+2
	ldrh	w8, [x8, :lo12:gSysFreeQueue+6]
	ldrh	w28, [x9, #2]
	strh	w10, [x9, #2]
	strh	wzr, [x9]
	cbz	w8, .LBB31_31
// %bb.10:                              //   in Loop: Header=BB31_8 Depth=2
	adrp	x11, gSysFreeQueue
	add	x11, x11, :lo12:gSysFreeQueue
	ldrh	w9, [x11, #2]
	mov	x24, x26
	mov	x26, x19
	mov	x19, x25
	add	x10, x11, x9, lsl #1
	mov	x25, x22
	sub	w8, w8, #1                      // =1
	ldrh	w22, [x10, #8]
	adrp	x10, req_erase
	strh	w8, [x11, #6]
	add	w8, w9, #1                      // =1
	ldr	x9, [x10, :lo12:req_erase]
	mov	x20, x23
	mov	x23, x21
	and	w8, w8, #0x3ff
	lsl	w21, w22, #10
	strh	w8, [x11, #2]
	str	w21, [x9, #4]
	ldr	x0, [x10, :lo12:req_erase]
	mov	w2, #1
	bl	FlashEraseBlocks
	adrp	x9, g_totle_sys_slc_erase_count
	ldr	w8, [x9, :lo12:g_totle_sys_slc_erase_count]
	mov	w10, #65535
	cmp	w22, w10
	add	w8, w8, #1                      // =1
	str	w8, [x9, :lo12:g_totle_sys_slc_erase_count]
	b.eq	.LBB31_32
// %bb.11:                              //   in Loop: Header=BB31_8 Depth=2
	cbz	w22, .LBB31_32
// %bb.12:                              //   in Loop: Header=BB31_8 Depth=2
	adrp	x10, g_GlobalSysVersion
	ldr	w8, [x10, :lo12:g_GlobalSysVersion]
	adrp	x9, gSysInfo
	add	x9, x9, :lo12:gSysInfo
	strh	w22, [x9]
	str	w8, [x9, #8]
	add	w9, w8, #1                      // =1
	str	w9, [x10, :lo12:g_GlobalSysVersion]
	ldr	x9, [sp, #8]                    // 8-byte Folded Reload
	adrp	x11, req_sys+4
	str	w21, [x11, :lo12:req_sys+4]
	mov	x21, x23
	str	w8, [x9, #4]
	strh	w22, [x9, #2]
	ldr	x9, [x23, :lo12:p_sys_data_buf]
	mov	x22, x25
	mov	x25, x19
	mov	x19, x26
	mov	x26, x24
	adrp	x24, req_sys+4
	mov	x23, x20
	add	x24, x24, :lo12:req_sys+4
.LBB31_13:                              //   in Loop: Header=BB31_8 Depth=2
	ldrh	w8, [x23, :lo12:c_ftl_nand_byte_pre_page]
	mov	w10, #42982
	movk	w10, #18374, lsl #16
	cbz	x8, .LBB31_16
// %bb.14:                              //   in Loop: Header=BB31_8 Depth=2
	mov	w10, #42982
	movk	w10, #18374, lsl #16
.LBB31_15:                              //   Parent Loop BB31_7 Depth=1
                                        //     Parent Loop BB31_8 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	ldrb	w11, [x9], #1
	lsr	w12, w10, #2
	add	w12, w12, w10, lsl #5
	subs	x8, x8, #1                      // =1
	add	w11, w12, w11
	eor	w10, w11, w10
	b.ne	.LBB31_15
.LBB31_16:                              //   in Loop: Header=BB31_8 Depth=2
	ldr	x8, [sp, #8]                    // 8-byte Folded Reload
	mov	w1, #1
	mov	w2, #1
	mov	x0, x26
	str	w10, [x8, #12]
	bl	FlashProgPages
	ldrh	w9, [x25, :lo12:gSysInfo+2]
	ldr	w10, [x26]
	add	w8, w9, #1                      // =1
	cmn	w10, #1                         // =1
	strh	w8, [x25, :lo12:gSysInfo+2]
	b.eq	.LBB31_19
// %bb.17:                              //   in Loop: Header=BB31_8 Depth=2
	cbz	w9, .LBB31_8
// %bb.18:                              //   in Loop: Header=BB31_8 Depth=2
	cmp	w10, #256                       // =256
	b.eq	.LBB31_8
	b	.LBB31_26
.LBB31_19:                              //   in Loop: Header=BB31_7 Depth=1
	cbnz	w9, .LBB31_21
// %bb.20:                              //   in Loop: Header=BB31_7 Depth=1
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlVpcTblFlush
	mov	w2, #1145
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlVpcTblFlush
	bl	sftl_printk
	ldrh	w8, [x25, :lo12:gSysInfo+2]
.LBB31_21:                              //   in Loop: Header=BB31_7 Depth=1
	and	w9, w8, #0xffff
	cmp	w9, #1                          // =1
	b.ne	.LBB31_23
// %bb.22:                              //   in Loop: Header=BB31_7 Depth=1
	ldrh	w8, [x19, :lo12:c_ftl_nand_page_pre_slc_blk]
	sub	w8, w8, #1                      // =1
	strh	w8, [x25, :lo12:gSysInfo+2]
.LBB31_23:                              //   in Loop: Header=BB31_7 Depth=1
	ldr	w10, [sp, #4]                   // 4-byte Folded Reload
	and	w9, w10, #0xffff
	add	w10, w10, #1                    // =1
	cmp	w9, #3                          // =3
	b.lo	.LBB31_7
// %bb.24:
	adrp	x8, req_sys+4
	ldr	w1, [x8, :lo12:req_sys+4]
	adrp	x0, .L.str.95
	add	x0, x0, :lo12:.L.str.95
	mov	w2, #4
	bl	sftl_printk
.LBB31_25:                              // =>This Inner Loop Header: Depth=1
	b	.LBB31_25
.LBB31_26:
	mvn	w8, w28
	tst	w8, #0xffff
	b.eq	.LBB31_30
// %bb.27:
	tst	w28, #0xffff
	b.eq	.LBB31_30
// %bb.28:
	adrp	x8, gSysFreeQueue+6
	ldrh	w8, [x8, :lo12:gSysFreeQueue+6]
	cmp	w8, #1024                       // =1024
	b.eq	.LBB31_30
// %bb.29:
	adrp	x13, req_erase
	ldr	x10, [x13, :lo12:req_erase]
	and	w8, w28, #0xffff
	adrp	x9, c_ftl_nand_blks_per_die
	ldrh	w9, [x9, :lo12:c_ftl_nand_blks_per_die]
	adrp	x11, c_ftl_nand_planes_per_die
	lsl	w12, w8, #10
	ldrh	w11, [x11, :lo12:c_ftl_nand_planes_per_die]
	str	w12, [x10, #4]
	ldr	x0, [x13, :lo12:req_erase]
	udiv	w10, w8, w9
	msub	w8, w10, w9, w8
	mov	w2, #1
	udiv	w19, w8, w11
	bl	FlashEraseBlocks
	adrp	x8, p_erase_count_table
	ldr	x8, [x8, :lo12:p_erase_count_table]
	lsl	x9, x19, #1
	adrp	x12, g_totle_sys_slc_erase_count
	adrp	x11, gSysFreeQueue
	ldrh	w10, [x8, x9]
	add	x11, x11, :lo12:gSysFreeQueue
	add	w10, w10, #1                    // =1
	strh	w10, [x8, x9]
	ldr	w8, [x12, :lo12:g_totle_sys_slc_erase_count]
	ldrh	w9, [x11, #6]
	ldrh	w10, [x11, #4]
	add	w8, w8, #1                      // =1
	add	w9, w9, #1                      // =1
	str	w8, [x12, :lo12:g_totle_sys_slc_erase_count]
	add	x8, x11, x10, lsl #1
	add	w10, w10, #1                    // =1
	strh	w9, [x11, #6]
	strh	w28, [x8, #8]
	and	w8, w10, #0x3ff
	strh	w8, [x11, #4]
.LBB31_30:
	ldp	x20, x19, [sp, #96]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	add	sp, sp, #112                    // =112
	hint	#29
	ret
.LBB31_31:
	mov	w22, #65535
.LBB31_32:
	adrp	x8, gSysFreeQueue+6
	ldrh	w2, [x8, :lo12:gSysFreeQueue+6]
	adrp	x0, .L.str.86
	add	x0, x0, :lo12:.L.str.86
	mov	w1, w22
	bl	sftl_printk
.LBB31_33:                              // =>This Inner Loop Header: Depth=1
	b	.LBB31_33
.Lfunc_end31:
	.size	FtlVpcTblFlush, .Lfunc_end31-FtlVpcTblFlush
                                        // -- End function
	.globl	FtlSysBlkInit                   // -- Begin function FtlSysBlkInit
	.p2align	2
	.type	FtlSysBlkInit,@function
FtlSysBlkInit:                          // @FtlSysBlkInit
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-64]!           // 16-byte Folded Spill
	adrp	x8, c_ftl_nand_max_sys_blks
	ldr	w8, [x8, :lo12:c_ftl_nand_max_sys_blks]
	adrp	x9, gSysFreeQueue
	add	x9, x9, :lo12:gSysFreeQueue
	stp	x20, x19, [sp, #48]             // 16-byte Folded Spill
	adrp	x20, g_power_lost_recovery_flag
	add	x0, x9, #8                      // =8
	mov	w2, #2048
	mov	w1, wzr
	stp	x24, x23, [sp, #16]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #32]             // 16-byte Folded Spill
	mov	x29, sp
	strh	wzr, [x20, :lo12:g_power_lost_recovery_flag]
	stur	wzr, [x9, #2]
	strh	wzr, [x9, #6]
	strh	w8, [x9]
	bl	memset
	bl	FtlScanSysBlk
	adrp	x8, gSysInfo
	ldrsh	w8, [x8, :lo12:gSysInfo]
	cmn	w8, #1                          // =1
	b.eq	.LBB32_2
// %bb.1:
	bl	FtlLoadSysInfo
	cbz	w0, .LBB32_3
.LBB32_2:
	mov	w0, #-1
	b	.LBB32_48
.LBB32_3:
	mov	w21, #19539
	movk	w21, #18004, lsl #16
	bl	FtlLoadMapInfo
	adrp	x8, c_ftl_nand_max_vendor_blks
	adrp	x10, g_totle_vendor_block
	adrp	x11, c_ftl_nand_vendor_region_num
	ldrh	w8, [x8, :lo12:c_ftl_nand_max_vendor_blks]
	ldrh	w10, [x10, :lo12:g_totle_vendor_block]
	ldrh	w11, [x11, :lo12:c_ftl_nand_vendor_region_num]
	adrp	x0, gVendorBlkInfo
	add	x0, x0, :lo12:gVendorBlkInfo
	mov	w9, #61574
	strh	w9, [x0, #4]
	adrp	x9, p_vendor_block_table
	strh	w8, [x0, #10]
	adrp	x8, p_vendor_block_ver_table
	strh	w10, [x0, #8]
	adrp	x10, p_vendor_block_valid_page_count
	strh	w11, [x0, #6]
	adrp	x11, p_vendor_region_ppn_table
	ldr	x9, [x9, :lo12:p_vendor_block_table]
	ldr	x8, [x8, :lo12:p_vendor_block_ver_table]
	ldr	x10, [x10, :lo12:p_vendor_block_valid_page_count]
	ldr	x11, [x11, :lo12:p_vendor_region_ppn_table]
	stp	x9, x8, [x0, #16]
	stp	x10, x11, [x0, #32]
	bl	FtlMapTblRecovery
	adrp	x19, g_sys_ext_data
	add	x19, x19, :lo12:g_sys_ext_data
	mov	w1, #1
	mov	w0, wzr
	mov	x2, x19
	bl	FtlVendorPartRead
	ldr	w8, [x19]
	cmp	w8, w21
	b.ne	.LBB32_5
// %bb.4:
	adrp	x11, g_sys_ext_data+8
	add	x11, x11, :lo12:g_sys_ext_data+8
	ldp	w0, w18, [x11, #80]
	ldp	w17, w16, [x11]
	ldp	w15, w14, [x11, #8]
	ldp	w8, w13, [x11, #20]
	ldp	w12, w9, [x11, #28]
	ldp	w10, w11, [x11, #36]
	b	.LBB32_6
.LBB32_5:
	add	x0, x19, #4                     // =4
	mov	w2, #508
	mov	w1, wzr
	bl	memset
	mov	w11, wzr
	mov	w10, wzr
	mov	w9, wzr
	mov	w12, wzr
	mov	w13, wzr
	mov	w8, wzr
	mov	w14, wzr
	mov	w15, wzr
	mov	w16, wzr
	mov	w17, wzr
	mov	w18, wzr
	mov	w0, wzr
	str	w21, [x19]
.LBB32_6:
	adrp	x1, g_totle_write_sector
	str	w0, [x1, :lo12:g_totle_write_sector]
	adrp	x0, g_totle_read_sector
	adrp	x1, g_totle_gc_page_count
	str	w18, [x0, :lo12:g_totle_read_sector]
	adrp	x18, g_totle_write_page_count
	adrp	x0, g_totle_read_page_count
	str	w17, [x1, :lo12:g_totle_gc_page_count]
	adrp	x17, g_totle_l2p_write_count
	str	w16, [x18, :lo12:g_totle_write_page_count]
	adrp	x16, g_totle_sys_slc_erase_count
	str	w15, [x0, :lo12:g_totle_read_page_count]
	adrp	x15, g_totle_cache_write_count
	adrp	x0, g_max_erase_count
	str	w14, [x17, :lo12:g_totle_l2p_write_count]
	adrp	x17, g_totle_mlc_erase_count
	str	w13, [x16, :lo12:g_totle_sys_slc_erase_count]
	adrp	x13, c_mlc_erase_count_value
	adrp	x14, g_min_erase_count
	adrp	x21, c_ftl_nand_data_blks_per_plane
	str	w9, [x15, :lo12:g_totle_cache_write_count]
	str	w10, [x0, :lo12:g_max_erase_count]
	ldr	w9, [x17, :lo12:g_totle_mlc_erase_count]
	ldrh	w10, [x13, :lo12:c_mlc_erase_count_value]
	adrp	x1, g_totle_slc_erase_count
	adrp	x19, g_ect_tbl_info_size
	adrp	x22, gp_ect_tbl_info
	str	w11, [x14, :lo12:g_min_erase_count]
	ldrh	w11, [x21, :lo12:c_ftl_nand_data_blks_per_plane]
	str	w8, [x1, :lo12:g_totle_slc_erase_count]
	ldrh	w1, [x19, :lo12:g_ect_tbl_info_size]
	ldr	x2, [x22, :lo12:gp_ect_tbl_info]
	madd	w8, w9, w10, w8
	adrp	x18, g_totle_discard_page_count
	udiv	w8, w8, w11
	adrp	x9, g_totle_avg_erase_count
	mov	w0, #64
	str	w12, [x18, :lo12:g_totle_discard_page_count]
	str	w8, [x9, :lo12:g_totle_avg_erase_count]
	bl	FtlVendorPartRead
	ldr	x8, [x22, :lo12:gp_ect_tbl_info]
	mov	w9, #17221
	movk	w9, #16980, lsl #16
	ldr	w8, [x8]
	cmp	w8, w9
	b.eq	.LBB32_8
// %bb.7:
	adrp	x0, .L.str.75
	adrp	x1, .L.str.96
	add	x0, x0, :lo12:.L.str.75
	add	x1, x1, :lo12:.L.str.96
	bl	sftl_printk
	ldrh	w8, [x19, :lo12:g_ect_tbl_info_size]
	ldr	x0, [x22, :lo12:gp_ect_tbl_info]
	mov	w1, wzr
	lsl	x2, x8, #9
	bl	memset
.LBB32_8:
	adrp	x8, gSysFreeQueue+6
	ldrh	w8, [x8, :lo12:gSysFreeQueue+6]
	adrp	x19, g_sys_save_data+28
	cbz	w8, .LBB32_13
// %bb.9:
	ldrh	w8, [x19, :lo12:g_sys_save_data+28]
	and	w8, w8, #0x1f
	cbz	w8, .LBB32_13
// %bb.10:
	adrp	x9, gSysFreeQueue+2
	add	x9, x9, :lo12:gSysFreeQueue+2
	ldrh	w13, [x9]
	ldrh	w11, [x9, #2]
	adrp	x12, gSysFreeQueue+8
	mov	w10, wzr
	add	x12, x12, :lo12:gSysFreeQueue+8
.LBB32_11:                              // =>This Inner Loop Header: Depth=1
	and	x14, x13, #0xffff
	ldrh	w14, [x12, x14, lsl #1]
	add	w13, w13, #1                    // =1
	and	x15, x11, #0xffff
	add	w11, w11, #1                    // =1
	add	w10, w10, #1                    // =1
	and	w13, w13, #0x3ff
	cmp	w8, w10, uxth
	and	w11, w11, #0x3ff
	strh	w14, [x12, x15, lsl #1]
	b.hi	.LBB32_11
// %bb.12:
	strh	w13, [x9]
	strh	w11, [x9, #2]
.LBB32_13:
	bl	SupperBlkListInit
	bl	FtlPowerLostRecovery
	ldrh	w8, [x21, :lo12:c_ftl_nand_data_blks_per_plane]
	adrp	x9, FtlUpdateVaildLpnCount
	strh	wzr, [x9, :lo12:FtlUpdateVaildLpnCount]
	adrp	x9, g_VaildLpn
	adrp	x22, p_valid_page_count_table
	str	wzr, [x9, :lo12:g_VaildLpn]
	cbz	x8, .LBB32_18
// %bb.14:
	ldr	x11, [x22, :lo12:p_valid_page_count_table]
	mov	w10, wzr
	mov	w12, #65535
	b	.LBB32_16
.LBB32_15:                              //   in Loop: Header=BB32_16 Depth=1
	subs	x8, x8, #1                      // =1
	add	x11, x11, #2                    // =2
	b.eq	.LBB32_18
.LBB32_16:                              // =>This Inner Loop Header: Depth=1
	ldrh	w13, [x11]
	cmp	w13, w12
	b.eq	.LBB32_15
// %bb.17:                              //   in Loop: Header=BB32_16 Depth=1
	add	w10, w10, w13
	str	w10, [x9, :lo12:g_VaildLpn]
	b	.LBB32_15
.LBB32_18:
	adrp	x21, c_ftl_nand_l2pmap_ram_region_num
	ldrh	w8, [x21, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	cbz	w8, .LBB32_22
// %bb.19:
	adrp	x9, p_l2p_ram_map
	ldr	x11, [x9, :lo12:p_l2p_ram_map]
	cmp	w8, #1                          // =1
	mov	x10, xzr
	csinc	w9, w8, wzr, hi
	add	x11, x11, #4                    // =4
.LBB32_20:                              // =>This Inner Loop Header: Depth=1
	ldr	w12, [x11]
	tbnz	w12, #31, .LBB32_23
// %bb.21:                              //   in Loop: Header=BB32_20 Depth=1
	add	x10, x10, #1                    // =1
	cmp	x9, x10
	add	x11, x11, #16                   // =16
	b.ne	.LBB32_20
	b	.LBB32_24
.LBB32_22:
	mov	w9, wzr
	b	.LBB32_24
.LBB32_23:
	mov	w9, w10
.LBB32_24:
	ldrh	w10, [x19, :lo12:g_sys_save_data+28]
	cmp	w9, w8
	add	w8, w10, #1                     // =1
	strh	w8, [x19, :lo12:g_sys_save_data+28]
	adrp	x19, g_active_superblock
	add	x19, x19, :lo12:g_active_superblock
	b.lo	.LBB32_26
// %bb.25:
	ldrh	w8, [x20, :lo12:g_power_lost_recovery_flag]
	cbz	w8, .LBB32_32
.LBB32_26:
	mov	x0, x19
	bl	FtlSuperblockPowerLostFix
	adrp	x20, g_buffer_superblock
	add	x20, x20, :lo12:g_buffer_superblock
	mov	x0, x20
	bl	FtlSuperblockPowerLostFix
	ldrh	w8, [x19]
	ldr	x9, [x22, :lo12:p_valid_page_count_table]
	ldrh	w10, [x19, #4]
	lsl	x8, x8, #1
	ldrh	w11, [x9, x8]
	sub	w10, w11, w10
	adrp	x11, c_ftl_nand_page_pre_blk
	strh	w10, [x9, x8]
	ldrh	w8, [x11, :lo12:c_ftl_nand_page_pre_blk]
	ldrh	w9, [x20]
	ldr	x10, [x22, :lo12:p_valid_page_count_table]
	strb	wzr, [x19, #6]
	strh	wzr, [x19, #4]
	strh	w8, [x19, #2]
	lsl	x8, x9, #1
	ldrh	w12, [x20, #4]
	ldrh	w9, [x10, x8]
	sub	w9, w9, w12
	adrp	x12, g_sys_save_data+30
	strh	w9, [x10, x8]
	ldrh	w8, [x11, :lo12:c_ftl_nand_page_pre_blk]
	ldrh	w9, [x12, :lo12:g_sys_save_data+30]
	strb	wzr, [x20, #6]
	strh	wzr, [x20, #4]
	strh	w8, [x20, #2]
	add	w8, w9, #1                      // =1
	strh	w8, [x12, :lo12:g_sys_save_data+30]
	bl	FtlWriteDump_data
	ldrh	w8, [x21, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	cbz	w8, .LBB32_31
// %bb.27:
	adrp	x20, gL2pMapInfo
	mov	x22, xzr
	mov	x23, xzr
	adrp	x24, p_l2p_ram_map
	add	x20, x20, :lo12:gL2pMapInfo
	b	.LBB32_29
.LBB32_28:                              //   in Loop: Header=BB32_29 Depth=1
	add	x23, x23, #1                    // =1
	cmp	x23, w8, uxth
	add	x22, x22, #16                   // =16
	b.hs	.LBB32_31
.LBB32_29:                              // =>This Inner Loop Header: Depth=1
	ldr	x9, [x24, :lo12:p_l2p_ram_map]
	add	x9, x9, x22
	ldr	w10, [x9, #4]
	tbz	w10, #31, .LBB32_28
// %bb.30:                              //   in Loop: Header=BB32_29 Depth=1
	ldrh	w1, [x9]
	ldr	x2, [x9, #8]
	mov	x0, x20
	bl	FtlMapWritePage
	ldr	x8, [x24, :lo12:p_l2p_ram_map]
	add	x8, x8, x22
	ldr	w9, [x8, #4]
	and	w9, w9, #0x7fffffff
	str	w9, [x8, #4]
	ldrh	w8, [x21, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	b	.LBB32_28
.LBB32_31:
	bl	FtlVpcTblFlush
	bl	FtlVpcTblFlush
.LBB32_32:
	ldrh	w20, [x19]
	mov	w8, #65535
	cmp	w20, w8
	b.eq	.LBB32_47
// %bb.33:
	adrp	x9, g_buffer_superblock+4
	ldrh	w8, [x19, #4]
	ldrh	w9, [x9, :lo12:g_buffer_superblock+4]
	orr	w8, w9, w8
	tst	w8, #0xffff
	b.ne	.LBB32_47
// %bb.34:
	adrp	x0, .L.str.112
	add	x0, x0, :lo12:.L.str.112
	mov	w1, w20
	bl	sftl_printk
	adrp	x22, g_gc_next_blk
	ldrh	w8, [x22, :lo12:g_gc_next_blk]
	adrp	x21, g_gc_next_blk_1
	cmp	w8, w20
	b.eq	.LBB32_40
// %bb.35:
	ldrh	w9, [x21, :lo12:g_gc_next_blk_1]
	cmp	w9, w20
	b.eq	.LBB32_40
// %bb.36:
	mov	w10, #65535
	cmp	w8, w10
	b.eq	.LBB32_39
// %bb.37:
	cmp	w9, w10
	b.ne	.LBB32_40
// %bb.38:
	strh	w20, [x21, :lo12:g_gc_next_blk_1]
	b	.LBB32_40
.LBB32_39:
	strh	w20, [x22, :lo12:g_gc_next_blk]
.LBB32_40:
	adrp	x8, g_buffer_superblock
	ldrh	w19, [x8, :lo12:g_buffer_superblock]
	adrp	x0, .L.str.112
	add	x0, x0, :lo12:.L.str.112
	mov	w1, w19
	bl	sftl_printk
	ldrh	w8, [x22, :lo12:g_gc_next_blk]
	cmp	w8, w19
	b.eq	.LBB32_46
// %bb.41:
	ldrh	w9, [x21, :lo12:g_gc_next_blk_1]
	cmp	w9, w19
	b.eq	.LBB32_46
// %bb.42:
	mov	w10, #65535
	cmp	w8, w10
	b.eq	.LBB32_45
// %bb.43:
	cmp	w9, w10
	b.ne	.LBB32_46
// %bb.44:
	strh	w19, [x21, :lo12:g_gc_next_blk_1]
	b	.LBB32_46
.LBB32_45:
	strh	w19, [x22, :lo12:g_gc_next_blk]
.LBB32_46:
	bl	FtlVpcTblFlush
	adrp	x0, g_active_superblock
	add	x0, x0, :lo12:g_active_superblock
	bl	allocate_new_data_superblock
	adrp	x0, g_buffer_superblock
	add	x0, x0, :lo12:g_buffer_superblock
	bl	allocate_new_data_superblock
.LBB32_47:
	bl	FtlVpcCheckAndModify
	mov	w0, wzr
.LBB32_48:
	ldp	x20, x19, [sp, #48]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #32]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #64             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end32:
	.size	FtlSysBlkInit, .Lfunc_end32-FtlSysBlkInit
                                        // -- End function
	.globl	sftl_init                       // -- Begin function sftl_init
	.p2align	2
	.type	sftl_init,@function
sftl_init:                              // @sftl_init
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	adrp	x0, .L.str.75
	adrp	x1, .L.str.1
	str	x19, [sp, #16]                  // 8-byte Folded Spill
	adrp	x19, gFtlInitStatus
	mov	w8, #-1
	add	x0, x0, :lo12:.L.str.75
	add	x1, x1, :lo12:.L.str.1
	mov	x29, sp
	str	w8, [x19, :lo12:gFtlInitStatus]
	bl	sftl_printk
	adrp	x0, g_nand_phy_info
	add	x0, x0, :lo12:g_nand_phy_info
	bl	FtlConstantsInit
	bl	FtlMemInit
	bl	FtlVariablesInit
	adrp	x8, c_ftl_nand_max_sys_blks
	ldr	w8, [x8, :lo12:c_ftl_nand_max_sys_blks]
	adrp	x9, gSysFreeQueue
	add	x9, x9, :lo12:gSysFreeQueue
	add	x0, x9, #8                      // =8
	mov	w2, #2048
	mov	w1, wzr
	stur	wzr, [x9, #2]
	strh	wzr, [x9, #6]
	strh	w8, [x9]
	bl	memset
	bl	FtlLoadBbt
	cbnz	w0, .LBB33_5
// %bb.1:
	bl	FtlSysBlkInit
	cbnz	w0, .LBB33_5
// %bb.2:
	adrp	x8, g_num_free_superblocks
	ldrh	w8, [x8, :lo12:g_num_free_superblocks]
	mov	w9, #1
	str	w9, [x19, :lo12:gFtlInitStatus]
	cmp	w8, #15                         // =15
	b.hi	.LBB33_5
// %bb.3:
	mov	w19, #8129
.LBB33_4:                               // =>This Inner Loop Header: Depth=1
	mov	w0, wzr
	bl	rk_ftl_garbage_collect
	subs	w19, w19, #1                    // =1
	b.ne	.LBB33_4
.LBB33_5:
	ldr	x19, [sp, #16]                  // 8-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end33:
	.size	sftl_init, .Lfunc_end33-sftl_init
                                        // -- End function
	.globl	rk_ftl_garbage_collect          // -- Begin function rk_ftl_garbage_collect
	.p2align	2
	.type	rk_ftl_garbage_collect,@function
rk_ftl_garbage_collect:                 // @rk_ftl_garbage_collect
// %bb.0:
	hint	#25
	sub	sp, sp, #144                    // =144
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	stp	x29, x30, [sp, #48]             // 16-byte Folded Spill
	add	x29, sp, #48                    // =48
	stp	x28, x27, [sp, #64]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #80]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #96]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #112]            // 16-byte Folded Spill
	stp	x20, x19, [sp, #128]            // 16-byte Folded Spill
	stur	x8, [x29, #-8]
	adrp	x24, g_in_gc_progress
	ldr	w8, [x24, :lo12:g_in_gc_progress]
	mov	w20, wzr
	cbnz	w8, .LBB34_187
// %bb.1:
	adrp	x8, g_num_data_superblocks
	ldrh	w8, [x8, :lo12:g_num_data_superblocks]
	cmp	w8, #48                         // =48
	b.lo	.LBB34_187
// %bb.2:
	adrp	x8, ftl_gc_temp_block_bops_scan_page_addr
	ldrsh	w8, [x8, :lo12:ftl_gc_temp_block_bops_scan_page_addr]
	mov	w22, w0
	cmn	w8, #1                          // =1
	b.eq	.LBB34_5
// %bb.3:
	adrp	x8, g_gc_temp_superblock
	ldrh	w8, [x8, :lo12:g_gc_temp_superblock]
	mov	w9, #65535
	cmp	w8, w9
	b.eq	.LBB34_5
// %bb.4:
	mov	w0, #1
	mov	w20, #1
	bl	FtlGcFreeTempBlock
	cbnz	w0, .LBB34_187
.LBB34_5:
	adrp	x20, g_gc_next_blk_1
	ldrh	w8, [x20, :lo12:g_gc_next_blk_1]
	mov	w28, #65535
	adrp	x19, g_gc_next_blk
	cmp	w8, w28
	b.eq	.LBB34_8
// %bb.6:
	ldrh	w9, [x19, :lo12:g_gc_next_blk]
	cmp	w9, w28
	b.ne	.LBB34_8
// %bb.7:
	strh	w8, [x19, :lo12:g_gc_next_blk]
	mov	w8, #65535
	strh	w8, [x20, :lo12:g_gc_next_blk_1]
.LBB34_8:
	bl	FtlReadRefresh
	adrp	x27, g_gc_superblock
	adrp	x10, g_gc_temp_superblock
	adrp	x8, g_gc_skip_write_count
	ldrh	w10, [x10, :lo12:g_gc_temp_superblock]
	ldrh	w12, [x27, :lo12:g_gc_superblock]
	ldr	w11, [x8, :lo12:g_gc_skip_write_count]
	ldrh	w21, [x19, :lo12:g_gc_next_blk]
	mov	w9, #1
	bfi	w9, w22, #7, #25
	and	w10, w10, w12
	add	w9, w11, w9
	cmp	w10, w28
	adrp	x25, g_num_free_superblocks
	str	w9, [x8, :lo12:g_gc_skip_write_count]
	b.ne	.LBB34_35
// %bb.9:
	mov	w10, #65535
	cmp	w21, w10
	b.ne	.LBB34_35
// %bb.10:
	ldrh	w10, [x25, :lo12:g_num_free_superblocks]
	mov	w11, #1024
	cmp	w10, #24                        // =24
	mov	w10, #5120
	csel	w10, w10, w11, lo
	cmp	w9, w10
	b.ls	.LBB34_13
// %bb.11:
	str	wzr, [x8, :lo12:g_gc_skip_write_count]
	adrp	x8, gc_ink_free_return_value
	strh	wzr, [x8, :lo12:gc_ink_free_return_value]
	bl	GetSwlReplaceBlock
	ldrh	w2, [x25, :lo12:g_num_free_superblocks]
	mvn	w8, w0
	mov	w28, w0
	tst	w8, #0xffff
	b.eq	.LBB34_14
.LBB34_12:
	adrp	x8, p_valid_page_count_table
	adrp	x10, p_erase_count_table
	ldr	x8, [x8, :lo12:p_valid_page_count_table]
	ldr	x10, [x10, :lo12:p_erase_count_table]
	and	x9, x28, #0xffff
	adrp	x11, g_gc_free_blk_threshold
	lsl	x9, x9, #1
	ldrh	w3, [x8, x9]
	ldrh	w4, [x10, x9]
	ldrh	w5, [x11, :lo12:g_gc_free_blk_threshold]
	adrp	x0, .L.str.115
	and	w1, w28, #0xffff
	add	x0, x0, :lo12:.L.str.115
	bl	sftl_printk
	b	.LBB34_24
.LBB34_13:
	mov	w21, #65535
	mov	w28, #65535
	b	.LBB34_35
.LBB34_14:
	adrp	x8, g_gc_merge_free_blk_threshold
	ldrh	w9, [x8, :lo12:g_gc_merge_free_blk_threshold]
	cmp	w2, w9
	b.hs	.LBB34_21
// %bb.15:
	adrp	x9, p_data_block_list_head
	ldr	x9, [x9, :lo12:p_data_block_list_head]
	cbz	x9, .LBB34_23
// %bb.16:
	adrp	x10, p_data_block_list_table
	ldr	x10, [x10, :lo12:p_data_block_list_table]
	mov	w11, #64
	mov	w12, #6
	mov	x14, x9
.LBB34_17:                              // =>This Inner Loop Header: Depth=1
	ldrh	w13, [x14]
	mov	w14, #65535
	cmp	x13, x14
	b.eq	.LBB34_199
// %bb.18:                              //   in Loop: Header=BB34_17 Depth=1
	sub	w11, w11, #1                    // =1
	tst	w11, #0xffff
	madd	x14, x13, x12, x10
	b.ne	.LBB34_17
// %bb.19:
	adrp	x11, p_valid_page_count_table
	ldr	x11, [x11, :lo12:p_valid_page_count_table]
	ldrh	w11, [x11, x13, lsl #1]
	cmp	w11, #8                         // =8
	b.hs	.LBB34_203
// %bb.20:
	sub	x9, x9, x10
	mov	w10, #43691
	movk	w10, #43690, lsl #16
	lsr	x9, x9, #1
	mul	w28, w9, w10
	mvn	w9, w28
	tst	w9, #0xffff
	mov	w9, #128
	strh	w9, [x8, :lo12:g_gc_merge_free_blk_threshold]
	b.ne	.LBB34_12
	b	.LBB34_23
.LBB34_21:
	mov	w9, #80
.LBB34_22:
	strh	w9, [x8, :lo12:g_gc_merge_free_blk_threshold]
.LBB34_23:
	mov	w28, #65535
.LBB34_24:
	adrp	x8, g_gc_bad_block_temp_num
	ldrh	w9, [x8, :lo12:g_gc_bad_block_temp_num]
	ldrh	w21, [x19, :lo12:g_gc_next_blk]
	cbz	w9, .LBB34_35
// %bb.25:
	mov	w8, #65535
	cmp	w21, w8
	b.ne	.LBB34_35
// %bb.26:
	mov	w23, w22
	adrp	x22, g_gc_bad_block_gc_index
	ldrh	w8, [x22, :lo12:g_gc_bad_block_gc_index]
	cmp	w8, w9
	b.lo	.LBB34_28
// %bb.27:
	mov	w8, wzr
	strh	wzr, [x22, :lo12:g_gc_bad_block_gc_index]
.LBB34_28:
	adrp	x9, g_gc_bad_block_temp_tbl
	add	x9, x9, :lo12:g_gc_bad_block_temp_tbl
	adrp	x10, c_ftl_nand_blks_per_die
	ldrh	w8, [x9, w8, uxtw #1]
	ldrh	w9, [x10, :lo12:c_ftl_nand_blks_per_die]
	adrp	x10, c_ftl_nand_planes_per_die
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_per_die]
	adrp	x0, .L.str.112
	udiv	w11, w8, w9
	msub	w8, w11, w9, w8
	udiv	w21, w8, w10
	add	x0, x0, :lo12:.L.str.112
	mov	w1, w21
	bl	sftl_printk
	ldrh	w8, [x19, :lo12:g_gc_next_blk]
	cmp	w8, w21
	b.eq	.LBB34_34
// %bb.29:
	ldrh	w9, [x20, :lo12:g_gc_next_blk_1]
	cmp	w9, w21, uxth
	b.eq	.LBB34_33
// %bb.30:
	mov	w10, #65535
	cmp	w8, w10
	b.eq	.LBB34_200
// %bb.31:
	cmp	w9, w10
	b.ne	.LBB34_33
// %bb.32:
	strh	w21, [x20, :lo12:g_gc_next_blk_1]
.LBB34_33:
	mov	w21, w8
.LBB34_34:
	ldrh	w8, [x22, :lo12:g_gc_bad_block_gc_index]
	add	w8, w8, #1                      // =1
	strh	w8, [x22, :lo12:g_gc_bad_block_gc_index]
	mov	w22, w23
.LBB34_35:
	adrp	x12, g_in_swl_replace
	cbnz	w22, .LBB34_39
// %bb.36:
	mvn	w8, w28
	tst	w8, #0xffff
	b.ne	.LBB34_39
// %bb.37:
	ldrh	w9, [x25, :lo12:g_num_free_superblocks]
	cmp	w9, #24                         // =24
	b.ls	.LBB34_47
// %bb.38:
	mov	w10, #1
	b	.LBB34_52
.LBB34_39:
	adrp	x8, g_gc_temp_superblock
	ldrh	w9, [x8, :lo12:g_gc_temp_superblock]
	ldrh	w8, [x27, :lo12:g_gc_superblock]
	mov	w26, #1
	and	w10, w21, w9
	mov	w9, #65535
	cmp	w10, w9
	b.ne	.LBB34_74
// %bb.40:
	and	w10, w8, w28
	cmp	w10, w9
	b.ne	.LBB34_74
// %bb.41:
	adrp	x21, g_gc_free_blk_threshold
	ldrh	w8, [x25, :lo12:g_num_free_superblocks]
	ldrh	w9, [x21, :lo12:g_gc_free_blk_threshold]
	mov	x23, x12
	adrp	x20, gc_ink_free_return_value
	str	wzr, [x12, :lo12:g_in_swl_replace]
	cmp	w8, w9
	b.ls	.LBB34_63
// %bb.42:
	ldrh	w8, [x20, :lo12:gc_ink_free_return_value]
	cbnz	w8, .LBB34_44
// %bb.43:
	adrp	x9, g_MaxLpn
	adrp	x8, g_VaildLpn
	ldr	w9, [x9, :lo12:g_MaxLpn]
	ldr	w8, [x8, :lo12:g_VaildLpn]
	add	w9, w9, w9, lsl #1
	cmp	w8, w9, lsr #2
	b.hs	.LBB34_189
.LBB34_44:
	adrp	x8, c_ftl_nand_data_op_blks_per_plane
	ldrh	w8, [x8, :lo12:c_ftl_nand_data_op_blks_per_plane]
	add	w8, w8, w8, lsl #1
	lsr	w8, w8, #2
.LBB34_45:
	strh	w8, [x21, :lo12:g_gc_free_blk_threshold]
	bl	FtlReadRefresh
	adrp	x8, p_data_block_list_head
	ldr	x8, [x8, :lo12:p_data_block_list_head]
	cbz	x8, .LBB34_60
// %bb.46:
	adrp	x9, p_data_block_list_table
	ldr	w9, [x9, :lo12:p_data_block_list_table]
	sub	w8, w8, w9
	mov	w9, #43691
	lsr	w8, w8, #1
	movk	w9, #43690, lsl #16
	mul	w8, w8, w9
	and	x8, x8, #0xffff
	b	.LBB34_61
.LBB34_47:
	adrp	x8, c_ftl_nand_page_pre_blk
	cmp	w9, #17                         // =17
	b.lo	.LBB34_49
// %bb.48:
	ldrh	w8, [x8, :lo12:c_ftl_nand_page_pre_blk]
	lsr	w10, w8, #5
	b	.LBB34_52
.LBB34_49:
	cmp	w9, #13                         // =13
	b.lo	.LBB34_51
// %bb.50:
	ldrh	w8, [x8, :lo12:c_ftl_nand_page_pre_blk]
	lsr	w10, w8, #4
	b	.LBB34_52
.LBB34_51:
	ldrh	w8, [x8, :lo12:c_ftl_nand_page_pre_blk]
	cmp	w9, #8                          // =8
	lsr	w10, w8, #2
	csel	w10, w10, w8, hi
.LBB34_52:
	adrp	x8, g_gc_free_blk_threshold
	ldrh	w11, [x8, :lo12:g_gc_free_blk_threshold]
	cmp	w9, w11
	b.ls	.LBB34_55
// %bb.53:
	adrp	x9, g_gc_temp_superblock
	ldrh	w9, [x9, :lo12:g_gc_temp_superblock]
	mov	w11, #65535
	and	w9, w21, w9
	cmp	w9, w11
	b.eq	.LBB34_56
// %bb.54:
	adrp	x9, c_ftl_nand_data_op_blks_per_plane
	ldrh	w9, [x9, :lo12:c_ftl_nand_data_op_blks_per_plane]
	add	w9, w9, w9, lsl #1
	lsr	w9, w9, #2
	strh	w9, [x8, :lo12:g_gc_free_blk_threshold]
.LBB34_55:
	adrp	x8, g_gc_bad_block_temp_num
	ldrh	w8, [x8, :lo12:g_gc_bad_block_temp_num]
	add	w9, w10, #32                    // =32
	cmp	w8, #0                          // =0
	csel	w26, w10, w9, eq
	b	.LBB34_73
.LBB34_56:
	adrp	x9, gc_ink_free_return_value
	ldrh	w20, [x9, :lo12:gc_ink_free_return_value]
	mov	x11, x12
	cbnz	w20, .LBB34_58
// %bb.57:
	adrp	x10, g_MaxLpn
	adrp	x9, g_VaildLpn
	ldr	w10, [x10, :lo12:g_MaxLpn]
	ldr	w9, [x9, :lo12:g_VaildLpn]
	add	w10, w10, w10, lsl #1
	cmp	w9, w10, lsr #2
	b.hs	.LBB34_195
.LBB34_58:
	adrp	x9, c_ftl_nand_data_op_blks_per_plane
	ldrh	w9, [x9, :lo12:c_ftl_nand_data_op_blks_per_plane]
	add	w9, w9, w9, lsl #1
	lsr	w9, w9, #2
.LBB34_59:
	strh	w9, [x8, :lo12:g_gc_free_blk_threshold]
	str	wzr, [x11, :lo12:g_in_swl_replace]
	b	.LBB34_187
.LBB34_60:
	mov	w8, #65535
.LBB34_61:
	adrp	x9, p_valid_page_count_table
	ldr	x9, [x9, :lo12:p_valid_page_count_table]
	ldrh	w8, [x9, x8, lsl #1]
	cmp	w8, #5                          // =5
	b.lo	.LBB34_63
// %bb.62:
	ldrh	w20, [x20, :lo12:gc_ink_free_return_value]
	b	.LBB34_187
.LBB34_63:
	ldrh	w8, [x20, :lo12:gc_ink_free_return_value]
	cbz	w8, .LBB34_65
// %bb.64:
	mov	w26, #1
	b	.LBB34_72
.LBB34_65:
	adrp	x8, c_ftl_nand_data_op_blks_per_plane
	ldrh	w8, [x8, :lo12:c_ftl_nand_data_op_blks_per_plane]
	mov	w13, w22
	adrp	x22, p_data_block_list_head
	ldr	x9, [x22, :lo12:p_data_block_list_head]
	add	w10, w8, w8, lsl #1
	lsr	w10, w10, #2
	strh	w10, [x21, :lo12:g_gc_free_blk_threshold]
	cbz	x9, .LBB34_67
// %bb.66:
	adrp	x10, p_data_block_list_table
	ldr	w10, [x10, :lo12:p_data_block_list_table]
	sub	w9, w9, w10
	mov	w10, #43691
	lsr	w9, w9, #1
	movk	w10, #43690, lsl #16
	mul	w9, w9, w10
	and	x9, x9, #0xffff
	b	.LBB34_68
.LBB34_67:
	mov	w9, #65535
.LBB34_68:
	adrp	x21, p_valid_page_count_table
	adrp	x10, c_ftl_nand_page_pre_slc_blk
	ldr	x11, [x21, :lo12:p_valid_page_count_table]
	adrp	x12, c_ftl_nand_planes_num
	ldrh	w10, [x10, :lo12:c_ftl_nand_page_pre_slc_blk]
	ldrh	w12, [x12, :lo12:c_ftl_nand_planes_num]
	ldrh	w9, [x11, x9, lsl #1]
	mul	w10, w12, w10
	cmp	w10, #0                         // =0
	cinc	w10, w10, lt
	cmp	w9, w10, asr #1
	b.le	.LBB34_70
// %bb.69:
	ldrh	w10, [x25, :lo12:g_num_free_superblocks]
	sub	w8, w8, #1                      // =1
	cmp	w8, w10
	b.le	.LBB34_196
.LBB34_70:
	cbz	w9, .LBB34_190
// %bb.71:
	mov	w26, #1
	mov	w22, w13
.LBB34_72:
	mov	x12, x23
.LBB34_73:
	ldrh	w8, [x27, :lo12:g_gc_superblock]
.LBB34_74:
	mov	w9, #65535
	adrp	x10, g_gc_superblock+8
	cmp	w8, w9
	adrp	x23, g_gc_cur_blk_max_valid_pages
	b.ne	.LBB34_90
// %bb.75:
	mvn	w8, w28
	tst	w8, #0xffff
	b.eq	.LBB34_83
// %bb.76:
	strh	w28, [x27, :lo12:g_gc_superblock]
	mov	w8, w28
.LBB34_77:
	adrp	x9, g_gc_blk_num
	ldrh	w9, [x9, :lo12:g_gc_blk_num]
	strb	wzr, [x10, :lo12:g_gc_superblock+8]
	cbz	x9, .LBB34_82
// %bb.78:
	adrp	x10, p_gc_blk_tbl
	ldr	x10, [x10, :lo12:p_gc_blk_tbl]
.LBB34_79:                              // =>This Inner Loop Header: Depth=1
	ldrh	w11, [x10]
	cmp	w11, w8, uxth
	b.eq	.LBB34_86
// %bb.80:                              //   in Loop: Header=BB34_79 Depth=1
	subs	x9, x9, #1                      // =1
	add	x10, x10, #2                    // =2
	b.ne	.LBB34_79
// %bb.81:
	mvn	w8, w8
	tst	w8, #0xffff
	b.eq	.LBB34_88
.LBB34_82:
	adrp	x19, g_gc_superblock
	add	x19, x19, :lo12:g_gc_superblock
	mov	x0, x19
	mov	x20, x12
	bl	make_superblock
	adrp	x8, p_valid_page_count_table
	ldr	x9, [x8, :lo12:p_valid_page_count_table]
	ldrh	w8, [x19]
	adrp	x10, g_gc_cur_blk_valid_pages
	strh	wzr, [x19, #2]
	strb	wzr, [x19, #6]
	strh	wzr, [x10, :lo12:g_gc_cur_blk_valid_pages]
	ldrh	w9, [x9, x8, lsl #1]
	mov	x12, x20
	strh	w9, [x23, :lo12:g_gc_cur_blk_max_valid_pages]
	b	.LBB34_90
.LBB34_83:
	ldrh	w8, [x19, :lo12:g_gc_next_blk]
	mov	w9, #65535
	cmp	x8, x9
	b.eq	.LBB34_87
// %bb.84:
	adrp	x9, p_valid_page_count_table
	ldr	x9, [x9, :lo12:p_valid_page_count_table]
	ldrh	w9, [x9, x8, lsl #1]
	cbz	w9, .LBB34_89
// %bb.85:
	mov	w9, #65535
	strh	w8, [x27, :lo12:g_gc_superblock]
	strh	w9, [x19, :lo12:g_gc_next_blk]
	b	.LBB34_77
.LBB34_86:
	mov	w8, #65535
	strh	w8, [x27, :lo12:g_gc_superblock]
	b	.LBB34_90
.LBB34_87:
	strb	wzr, [x10, :lo12:g_gc_superblock+8]
.LBB34_88:
	mov	w8, #65535
	b	.LBB34_90
.LBB34_89:
	adrp	x9, g_gc_superblock
	mov	w8, #65535
	add	x9, x9, :lo12:g_gc_superblock
	strh	w8, [x9]
	strh	w8, [x19, :lo12:g_gc_next_blk]
	strb	wzr, [x9, #8]
.LBB34_90:
	adrp	x9, g_active_superblock
	ldrh	w9, [x9, :lo12:g_active_superblock]
	str	x28, [sp, #16]                  // 8-byte Folded Spill
	cmp	w8, w9
	adrp	x9, g_buffer_superblock
	b.eq	.LBB34_93
// %bb.91:
	ldrh	w9, [x9, :lo12:g_buffer_superblock]
	cmp	w8, w9
	b.eq	.LBB34_93
// %bb.92:
	adrp	x9, g_gc_temp_superblock
	ldrh	w9, [x9, :lo12:g_gc_temp_superblock]
	cmp	w8, w9
	b.ne	.LBB34_94
.LBB34_93:
	mov	w8, #65535
	strh	w8, [x27, :lo12:g_gc_superblock]
.LBB34_94:
	mov	w18, #65535
	adrp	x17, c_ftl_nand_planes_num
	mov	w20, #6
	adrp	x13, g_gc_superblock+2
	adrp	x28, req_gc
	mov	w23, #24
                                        // kill: def $w8 killed $w8 killed $x8 def $x8
.LBB34_95:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB34_125 Depth 2
                                        //       Child Loop BB34_127 Depth 3
                                        //       Child Loop BB34_132 Depth 3
                                        //     Child Loop BB34_101 Depth 2
                                        //       Child Loop BB34_104 Depth 3
                                        //       Child Loop BB34_111 Depth 3
                                        //         Child Loop BB34_118 Depth 4
                                        //     Child Loop BB34_161 Depth 2
                                        //     Child Loop BB34_168 Depth 2
	mvn	w9, w8
	tst	w9, #0xffff
	b.eq	.LBB34_123
.LBB34_96:                              //   in Loop: Header=BB34_95 Depth=1
	adrp	x9, c_ftl_nand_page_pre_blk
	ldrh	w11, [x9, :lo12:c_ftl_nand_page_pre_blk]
	mov	w9, #1
	str	w9, [x24, :lo12:g_in_gc_progress]
	cbz	w22, .LBB34_98
// %bb.97:                              //   in Loop: Header=BB34_95 Depth=1
	adrp	x9, p_valid_page_count_table
	ldr	x9, [x9, :lo12:p_valid_page_count_table]
                                        // kill: def $w8 killed $w8 killed $x8 def $x8
	and	x8, x8, #0xffff
	ldrh	w8, [x9, x8, lsl #1]
	ldrh	w9, [x17, :lo12:c_ftl_nand_planes_num]
	neg	w8, w8
	madd	w8, w9, w11, w8
	add	w9, w8, #3                      // =3
	cmp	w8, #0                          // =0
	csel	w8, w9, w8, lt
	add	w26, w26, w8, lsr #2
.LBB34_98:                              //   in Loop: Header=BB34_95 Depth=1
	ldrh	w8, [x13, :lo12:g_gc_superblock+2]
	add	w9, w8, w26, uxth
	sub	w10, w11, w8
	cmp	w9, w11
	csel	w9, w10, w26, hi
	tst	w9, #0xffff
	b.eq	.LBB34_153
// %bb.99:                              //   in Loop: Header=BB34_95 Depth=1
	stp	w11, w22, [sp, #8]              // 8-byte Folded Spill
	mov	w22, wzr
	and	w8, w9, #0xffff
	str	w9, [sp, #4]                    // 4-byte Folded Spill
	stur	w8, [x29, #-20]                 // 4-byte Folded Spill
	b	.LBB34_101
.LBB34_100:                             //   in Loop: Header=BB34_101 Depth=2
	ldur	w8, [x29, #-20]                 // 4-byte Folded Reload
	add	w22, w22, #1                    // =1
	adrp	x17, c_ftl_nand_planes_num
	adrp	x13, g_gc_superblock+2
	cmp	w22, w8
	mov	w18, #65535
	b.eq	.LBB34_152
.LBB34_101:                             //   Parent Loop BB34_95 Depth=1
                                        // =>  This Loop Header: Depth=2
                                        //       Child Loop BB34_104 Depth 3
                                        //       Child Loop BB34_111 Depth 3
                                        //         Child Loop BB34_118 Depth 4
	ldrh	w9, [x17, :lo12:c_ftl_nand_planes_num]
	cbz	w9, .LBB34_106
// %bb.102:                             //   in Loop: Header=BB34_101 Depth=2
	adrp	x14, g_gc_superblock
	mov	x8, xzr
	mov	w20, wzr
	add	x14, x14, :lo12:g_gc_superblock
	b	.LBB34_104
.LBB34_103:                             //   in Loop: Header=BB34_104 Depth=3
	add	x8, x8, #1                      // =1
	cmp	x8, w9, uxth
	b.hs	.LBB34_107
.LBB34_104:                             //   Parent Loop BB34_95 Depth=1
                                        //     Parent Loop BB34_101 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	add	x10, x14, x8, lsl #1
	ldrh	w10, [x10, #16]
	cmp	w10, w18
	b.eq	.LBB34_103
// %bb.105:                             //   in Loop: Header=BB34_104 Depth=3
	ldrh	w9, [x13, :lo12:g_gc_superblock+2]
	ldr	x11, [x28, :lo12:req_gc]
	and	x12, x20, #0xffff
	add	w20, w20, #1                    // =1
	add	w9, w22, w9
	orr	w9, w9, w10, lsl #10
	add	x10, x11, x12, lsl #5
	str	w9, [x10, #4]
	ldrh	w9, [x17, :lo12:c_ftl_nand_planes_num]
	b	.LBB34_103
.LBB34_106:                             //   in Loop: Header=BB34_101 Depth=2
	mov	w20, wzr
.LBB34_107:                             //   in Loop: Header=BB34_101 Depth=2
	ldr	x0, [x28, :lo12:req_gc]
	and	w26, w20, #0xffff
	mov	w1, w26
	bl	FlashReadPages
	cbz	w26, .LBB34_100
// %bb.108:                             //   in Loop: Header=BB34_101 Depth=2
                                        // kill: def $w20 killed $w20 killed $x20 def $x20
	mov	x24, xzr
	and	x20, x20, #0xffff
	b	.LBB34_111
.LBB34_109:                             //   in Loop: Header=BB34_111 Depth=3
	bl	Ftl_gc_temp_data_write_back
	cbnz	w0, .LBB34_186
.LBB34_110:                             //   in Loop: Header=BB34_111 Depth=3
	add	x24, x24, #1                    // =1
	cmp	x24, x20
	b.eq	.LBB34_100
.LBB34_111:                             //   Parent Loop BB34_95 Depth=1
                                        //     Parent Loop BB34_101 Depth=2
                                        // =>    This Loop Header: Depth=3
                                        //         Child Loop BB34_118 Depth 4
	ldr	x8, [x28, :lo12:req_gc]
	add	x8, x8, x24, lsl #5
	ldr	w9, [x8]
	cmn	w9, #1                          // =1
	b.eq	.LBB34_110
// %bb.112:                             //   in Loop: Header=BB34_111 Depth=3
	ldr	x27, [x8, #16]
	ldrsh	w8, [x27]
	cmn	w8, #3947                       // =3947
	b.ne	.LBB34_110
// %bb.113:                             //   in Loop: Header=BB34_111 Depth=3
	ldr	w26, [x27, #8]
	cmn	w26, #1                         // =1
	b.ne	.LBB34_115
// %bb.114:                             //   in Loop: Header=BB34_111 Depth=3
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.rk_ftl_garbage_collect
	mov	w2, #753
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.rk_ftl_garbage_collect
	bl	sftl_printk
.LBB34_115:                             //   in Loop: Header=BB34_111 Depth=3
	sub	x1, x29, #12                    // =12
	mov	w0, w26
	mov	w2, wzr
	bl	log2phys
	ldr	x8, [x28, :lo12:req_gc]
	ldur	w26, [x29, #-12]
	add	x9, x8, x24, lsl #5
	ldr	w9, [x9, #4]
	cmp	w26, w9
	b.ne	.LBB34_110
// %bb.116:                             //   in Loop: Header=BB34_111 Depth=3
	adrp	x11, g_gc_cur_blk_valid_pages
	ldrh	w9, [x11, :lo12:g_gc_cur_blk_valid_pages]
	lsl	x19, x24, #5
	adrp	x25, req_gc_dst
	adrp	x21, g_gc_num_req
	add	w9, w9, #1                      // =1
	ldr	x10, [x25, :lo12:req_gc_dst]
	add	x8, x8, x19
	strh	w9, [x11, :lo12:g_gc_cur_blk_valid_pages]
	ldr	w9, [x21, :lo12:g_gc_num_req]
	ldr	w8, [x8, #24]
	add	x9, x10, x9, lsl #5
	str	w8, [x9, #24]
	bl	Ftl_get_new_temp_ppa
	ldr	x8, [x25, :lo12:req_gc_dst]
	ldr	w9, [x21, :lo12:g_gc_num_req]
	add	x8, x8, x9, lsl #5
	str	w0, [x8, #4]
	ldr	x8, [x28, :lo12:req_gc]
	ldr	w10, [x21, :lo12:g_gc_num_req]
	ldr	x9, [x25, :lo12:req_gc_dst]
	add	x8, x8, x19
	ldr	x8, [x8, #8]
	lsl	x10, x10, #5
	add	x9, x9, x10
	str	x8, [x9, #8]
	ldr	x8, [x28, :lo12:req_gc]
	ldr	x9, [x25, :lo12:req_gc_dst]
	add	x8, x8, x19
	ldr	x8, [x8, #16]
	add	x9, x9, x10
	str	x8, [x9, #16]
	str	w26, [x27, #12]
	adrp	x8, g_gc_temp_superblock
	ldrh	w8, [x8, :lo12:g_gc_temp_superblock]
	adrp	x9, c_gc_page_buf_num
	strh	w8, [x27, #2]
	adrp	x8, g_GlobalDataVersion
	ldr	w8, [x8, :lo12:g_GlobalDataVersion]
	str	w8, [x27, #4]
	ldr	w8, [x21, :lo12:g_gc_num_req]
	ldr	w10, [x9, :lo12:c_gc_page_buf_num]
	add	w8, w8, #1                      // =1
	str	w8, [x21, :lo12:g_gc_num_req]
	cbz	w10, .LBB34_121
// %bb.117:                             //   in Loop: Header=BB34_111 Depth=3
	adrp	x11, gp_gc_page_buf_info
	ldr	x9, [x28, :lo12:req_gc]
	ldr	x11, [x11, :lo12:gp_gc_page_buf_info]
	mov	w12, wzr
.LBB34_118:                             //   Parent Loop BB34_95 Depth=1
                                        //     Parent Loop BB34_101 Depth=2
                                        //       Parent Loop BB34_111 Depth=3
                                        // =>      This Inner Loop Header: Depth=4
	and	x13, x12, #0xffff
	madd	x13, x13, x23, x11
	ldr	w14, [x13, #16]!
	cbz	w14, .LBB34_120
// %bb.119:                             //   in Loop: Header=BB34_118 Depth=4
	add	w12, w12, #1                    // =1
	cmp	w10, w12, uxth
	b.hi	.LBB34_118
	b	.LBB34_121
.LBB34_120:                             //   in Loop: Header=BB34_111 Depth=3
	mov	w8, #1
	str	w8, [x13]
	adrp	x11, gp_gc_page_buf_info
	ldr	x8, [x11, :lo12:gp_gc_page_buf_info]
                                        // kill: def $w12 killed $w12 killed $x12 def $x12
	and	x10, x12, #0xffff
	add	x10, x10, w12, uxth #1
	lsl	x10, x10, #3
	ldr	x8, [x8, x10]
	add	x9, x9, x24, lsl #5
	str	x8, [x9, #8]
	ldr	x8, [x11, :lo12:gp_gc_page_buf_info]
	add	x8, x8, x10
	ldr	x8, [x8, #8]
	str	x8, [x9, #16]
	adrp	x8, g_gc_num_req
	ldr	w8, [x8, :lo12:g_gc_num_req]
.LBB34_121:                             //   in Loop: Header=BB34_111 Depth=3
	adrp	x9, g_gc_temp_superblock+4
	add	x9, x9, :lo12:g_gc_temp_superblock+4
	ldrb	w9, [x9, #3]
	cmp	w8, w9
	b.eq	.LBB34_109
// %bb.122:                             //   in Loop: Header=BB34_111 Depth=3
	adrp	x8, g_gc_temp_superblock+4
	add	x8, x8, :lo12:g_gc_temp_superblock+4
	ldrh	w8, [x8]
	cbnz	w8, .LBB34_110
	b	.LBB34_109
.LBB34_123:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x8, p_data_block_list_head
	ldr	x8, [x8, :lo12:p_data_block_list_head]
	str	wzr, [x12, :lo12:g_in_swl_replace]
	cbz	x8, .LBB34_184
// %bb.124:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x9, g_gc_blk_index
	ldrh	w10, [x9, :lo12:g_gc_blk_index]
	mov	x25, x12
.LBB34_125:                             //   Parent Loop BB34_95 Depth=1
                                        // =>  This Loop Header: Depth=2
                                        //       Child Loop BB34_127 Depth 3
                                        //       Child Loop BB34_132 Depth 3
	adrp	x9, p_data_block_list_table
	ldr	x9, [x9, :lo12:p_data_block_list_table]
	tst	w10, #0xffff
	mov	x12, x8
	b.eq	.LBB34_129
// %bb.126:                             //   in Loop: Header=BB34_125 Depth=2
	mov	x12, x8
	mov	w11, w10
.LBB34_127:                             //   Parent Loop BB34_95 Depth=1
                                        //     Parent Loop BB34_125 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	ldrh	w12, [x12]
	cmp	x12, x18
	b.eq	.LBB34_184
// %bb.128:                             //   in Loop: Header=BB34_127 Depth=3
	sub	w11, w11, #1                    // =1
	tst	w11, #0xffff
	madd	x12, x12, x20, x9
	b.ne	.LBB34_127
.LBB34_129:                             //   in Loop: Header=BB34_125 Depth=2
	sub	x9, x12, x9
	mov	x11, #-6148914691236517206
	asr	x9, x9, #1
	movk	x11, #43691
	mul	x9, x9, x11
	and	x11, x9, #0xffff
	cmp	x11, x18
	strh	w9, [x27, :lo12:g_gc_superblock]
	b.eq	.LBB34_185
// %bb.130:                             //   in Loop: Header=BB34_125 Depth=2
	adrp	x12, g_gc_blk_num
	ldrh	w13, [x12, :lo12:g_gc_blk_num]
	cbz	x13, .LBB34_134
// %bb.131:                             //   in Loop: Header=BB34_125 Depth=2
	adrp	x12, p_gc_blk_tbl
	ldr	x12, [x12, :lo12:p_gc_blk_tbl]
	mov	x14, x13
.LBB34_132:                             //   Parent Loop BB34_95 Depth=1
                                        //     Parent Loop BB34_125 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	ldrh	w15, [x12]
	cmp	w15, w9, uxth
	b.eq	.LBB34_147
// %bb.133:                             //   in Loop: Header=BB34_132 Depth=3
	subs	x14, x14, #1                    // =1
	add	x12, x12, #2                    // =2
	b.ne	.LBB34_132
.LBB34_134:                             //   in Loop: Header=BB34_125 Depth=2
	adrp	x12, p_valid_page_count_table
	ldr	x15, [x12, :lo12:p_valid_page_count_table]
	adrp	x12, c_ftl_nand_page_pre_blk
	ldrh	w12, [x12, :lo12:c_ftl_nand_page_pre_blk]
	ldrh	w16, [x17, :lo12:c_ftl_nand_planes_num]
	add	w14, w10, #1                    // =1
	adrp	x10, g_gc_blk_index
	strh	w14, [x10, :lo12:g_gc_blk_index]
	ldrh	w10, [x15, x11, lsl #1]
	mul	w12, w16, w12
	cmp	w12, #0                         // =0
	cinc	w16, w12, lt
	cmp	w10, w16, asr #1
	b.gt	.LBB34_138
// %bb.135:                             //   in Loop: Header=BB34_125 Depth=2
	cmp	w13, #35                        // =35
	b.hi	.LBB34_139
// %bb.136:                             //   in Loop: Header=BB34_125 Depth=2
	and	w13, w14, #0xffff
	cmp	w13, #49                        // =49
	b.lo	.LBB34_139
// %bb.137:                             //   in Loop: Header=BB34_125 Depth=2
	cmp	w10, #9                         // =9
	b.lo	.LBB34_139
.LBB34_138:                             //   in Loop: Header=BB34_125 Depth=2
	adrp	x10, g_gc_blk_index
	strh	wzr, [x10, :lo12:g_gc_blk_index]
	ldrh	w10, [x15, x11, lsl #1]
	mov	w14, wzr
.LBB34_139:                             //   in Loop: Header=BB34_125 Depth=2
	and	w11, w14, #0xffff
	cmp	w11, #3                         // =3
	b.hi	.LBB34_142
// %bb.140:                             //   in Loop: Header=BB34_125 Depth=2
	ldr	x11, [sp, #16]                  // 8-byte Folded Reload
	mvn	w11, w11
	tst	w11, #0xffff
	b.ne	.LBB34_142
// %bb.141:                             //   in Loop: Header=BB34_125 Depth=2
	cmp	w12, w10
	b.le	.LBB34_197
.LBB34_142:                             //   in Loop: Header=BB34_125 Depth=2
	cbnz	w10, .LBB34_175
// %bb.143:                             //   in Loop: Header=BB34_125 Depth=2
	adrp	x9, g_tmp_data_superblock_id
	ldrh	w0, [x9, :lo12:g_tmp_data_superblock_id]
	mov	x19, x17
	cmp	w0, w18
	b.eq	.LBB34_148
// %bb.144:                             //   in Loop: Header=BB34_125 Depth=2
	mov	x20, x9
	bl	update_vpc_list
	adrp	x8, p_data_block_list_head
	adrp	x9, p_data_block_list_table
	ldr	x8, [x8, :lo12:p_data_block_list_head]
	ldr	w9, [x9, :lo12:p_data_block_list_table]
	adrp	x10, p_valid_page_count_table
	ldr	x10, [x10, :lo12:p_valid_page_count_table]
	mov	w11, #43691
	sub	w9, w8, w9
	lsr	w9, w9, #1
	movk	w11, #43690, lsl #16
	mov	w18, #65535
	mul	w9, w9, w11
	strh	w18, [x20, :lo12:g_tmp_data_superblock_id]
	and	x9, x9, #0xffff
	ldrh	w10, [x10, x9, lsl #1]
	cbnz	w10, .LBB34_149
// %bb.145:                             //   in Loop: Header=BB34_125 Depth=2
	cmp	x9, x18
	mov	w20, #6
	b.eq	.LBB34_150
// %bb.146:                             //   in Loop: Header=BB34_125 Depth=2
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.decrement_vpc_count
	mov	w2, #2869
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.decrement_vpc_count
	bl	sftl_printk
	adrp	x8, p_data_block_list_head
	ldr	x8, [x8, :lo12:p_data_block_list_head]
	mov	w18, #65535
	b	.LBB34_150
.LBB34_147:                             //   in Loop: Header=BB34_125 Depth=2
	adrp	x9, g_gc_blk_index
	b	.LBB34_151
.LBB34_148:                             //   in Loop: Header=BB34_125 Depth=2
	strh	w18, [x9, :lo12:g_tmp_data_superblock_id]
	b	.LBB34_150
.LBB34_149:                             //   in Loop: Header=BB34_125 Depth=2
	mov	w20, #6
.LBB34_150:                             //   in Loop: Header=BB34_125 Depth=2
	adrp	x9, g_gc_blk_index
	ldrh	w10, [x9, :lo12:g_gc_blk_index]
	mov	x17, x19
.LBB34_151:                             //   in Loop: Header=BB34_125 Depth=2
	add	w10, w10, #1                    // =1
	strh	w10, [x9, :lo12:g_gc_blk_index]
	cbnz	x8, .LBB34_125
	b	.LBB34_184
.LBB34_152:                             //   in Loop: Header=BB34_95 Depth=1
	ldrh	w8, [x13, :lo12:g_gc_superblock+2]
	ldp	w11, w22, [sp, #8]              // 8-byte Folded Reload
	ldr	w9, [sp, #4]                    // 4-byte Folded Reload
	adrp	x24, g_in_gc_progress
	adrp	x12, g_in_swl_replace
	mov	w20, #6
.LBB34_153:                             //   in Loop: Header=BB34_95 Depth=1
	add	w8, w8, w9
	cmp	w11, w8, uxth
	adrp	x27, g_gc_superblock
	strh	w8, [x13, :lo12:g_gc_superblock+2]
	b.hi	.LBB34_173
// %bb.154:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x8, g_gc_num_req
	ldr	w8, [x8, :lo12:g_gc_num_req]
	mov	x19, x17
	cbz	w8, .LBB34_156
// %bb.155:                             //   in Loop: Header=BB34_95 Depth=1
	mov	x21, x12
	bl	Ftl_gc_temp_data_write_back
	mov	x12, x21
	mov	w18, #65535
	cbnz	w0, .LBB34_204
.LBB34_156:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x8, g_gc_cur_blk_valid_pages
	ldrh	w8, [x8, :lo12:g_gc_cur_blk_valid_pages]
	adrp	x13, g_gc_superblock+2
	cbnz	w8, .LBB34_172
// %bb.157:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x8, p_valid_page_count_table
	ldr	x8, [x8, :lo12:p_valid_page_count_table]
	ldrh	w9, [x27, :lo12:g_gc_superblock]
	ldrh	w8, [x8, x9, lsl #1]
	cbz	w8, .LBB34_172
// %bb.158:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x8, g_MaxLpn
	ldr	w8, [x8, :lo12:g_MaxLpn]
	cbz	w8, .LBB34_165
// %bb.159:                             //   in Loop: Header=BB34_95 Depth=1
	mov	x21, x12
	mov	w26, wzr
	b	.LBB34_161
.LBB34_160:                             //   in Loop: Header=BB34_161 Depth=2
	adrp	x8, g_MaxLpn
	ldr	w8, [x8, :lo12:g_MaxLpn]
	add	w26, w26, #1                    // =1
	cmp	w26, w8
	b.hs	.LBB34_164
.LBB34_161:                             //   Parent Loop BB34_95 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	sub	x1, x29, #16                    // =16
	mov	w0, w26
	mov	w2, wzr
	bl	log2phys
	ldur	w8, [x29, #-16]
	cmn	w8, #1                          // =1
	b.eq	.LBB34_160
// %bb.162:                             //   in Loop: Header=BB34_161 Depth=2
	adrp	x9, c_ftl_nand_blks_per_die
	ldrh	w9, [x9, :lo12:c_ftl_nand_blks_per_die]
	adrp	x10, c_ftl_nand_planes_per_die
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_per_die]
	ubfx	w8, w8, #10, #16
	ldrh	w11, [x27, :lo12:g_gc_superblock]
	udiv	w12, w8, w9
	msub	w8, w12, w9, w8
	udiv	w8, w8, w10
	cmp	w8, w11
	b.ne	.LBB34_160
// %bb.163:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x8, g_MaxLpn
	ldr	w8, [x8, :lo12:g_MaxLpn]
.LBB34_164:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x13, g_gc_superblock+2
	mov	x12, x21
	cmp	w26, w8
	b.lo	.LBB34_171
.LBB34_165:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x8, p_valid_page_count_table
	ldr	x8, [x8, :lo12:p_valid_page_count_table]
	ldrh	w9, [x27, :lo12:g_gc_superblock]
	mov	w26, w22
	strh	wzr, [x8, x9, lsl #1]
	ldrh	w0, [x27, :lo12:g_gc_superblock]
	bl	update_vpc_list
	bl	FtlWriteDump_data
	adrp	x8, c_ftl_nand_l2pmap_ram_region_num
	ldrh	w8, [x8, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	adrp	x11, p_l2p_ram_map
	cbz	w8, .LBB34_170
// %bb.166:                             //   in Loop: Header=BB34_95 Depth=1
	mov	x20, xzr
	mov	x22, xzr
	b	.LBB34_168
.LBB34_167:                             //   in Loop: Header=BB34_168 Depth=2
	add	x22, x22, #1                    // =1
	cmp	x22, w8, uxth
	add	x20, x20, #16                   // =16
	b.hs	.LBB34_170
.LBB34_168:                             //   Parent Loop BB34_95 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldr	x9, [x11, :lo12:p_l2p_ram_map]
	add	x9, x9, x20
	ldr	w10, [x9, #4]
	tbz	w10, #31, .LBB34_167
// %bb.169:                             //   in Loop: Header=BB34_168 Depth=2
	ldrh	w1, [x9]
	ldr	x2, [x9, #8]
	adrp	x0, gL2pMapInfo
	add	x0, x0, :lo12:gL2pMapInfo
	bl	FtlMapWritePage
	adrp	x11, p_l2p_ram_map
	ldr	x8, [x11, :lo12:p_l2p_ram_map]
	add	x8, x8, x20
	ldr	w9, [x8, #4]
	and	w9, w9, #0x7fffffff
	str	w9, [x8, #4]
	adrp	x8, c_ftl_nand_l2pmap_ram_region_num
	ldrh	w8, [x8, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	b	.LBB34_167
.LBB34_170:                             //   in Loop: Header=BB34_95 Depth=1
	bl	FtlVpcTblFlush
	mov	w22, w26
	adrp	x12, g_in_swl_replace
	mov	w20, #6
	adrp	x13, g_gc_superblock+2
.LBB34_171:                             //   in Loop: Header=BB34_95 Depth=1
	mov	w18, #65535
.LBB34_172:                             //   in Loop: Header=BB34_95 Depth=1
	mov	x17, x19
	strh	w18, [x27, :lo12:g_gc_superblock]
.LBB34_173:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x8, g_num_free_superblocks
	ldrh	w8, [x8, :lo12:g_num_free_superblocks]
	str	wzr, [x24, :lo12:g_in_gc_progress]
	cmp	w8, #2                          // =2
	b.hi	.LBB34_198
// %bb.174:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x8, c_ftl_nand_page_pre_blk
	ldrh	w26, [x8, :lo12:c_ftl_nand_page_pre_blk]
	ldrh	w8, [x27, :lo12:g_gc_superblock]
	b	.LBB34_95
.LBB34_175:                             //   in Loop: Header=BB34_95 Depth=1
	mvn	w8, w9
	tst	w8, #0xffff
	adrp	x8, g_gc_superblock+8
	strb	wzr, [x8, :lo12:g_gc_superblock+8]
	b.ne	.LBB34_177
// %bb.176:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.rk_ftl_garbage_collect
	mov	w2, #716
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.rk_ftl_garbage_collect
	mov	x19, x17
	bl	sftl_printk
	ldrh	w9, [x27, :lo12:g_gc_superblock]
	mov	x17, x19
.LBB34_177:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x8, g_active_superblock
	ldrh	w8, [x8, :lo12:g_active_superblock]
	mov	x19, x17
	cmp	w8, w9, uxth
	b.ne	.LBB34_179
// %bb.178:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.rk_ftl_garbage_collect
	mov	w2, #717
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.rk_ftl_garbage_collect
	bl	sftl_printk
	ldrh	w9, [x27, :lo12:g_gc_superblock]
.LBB34_179:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x8, g_buffer_superblock
	ldrh	w8, [x8, :lo12:g_buffer_superblock]
	cmp	w8, w9, uxth
	b.ne	.LBB34_181
// %bb.180:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.rk_ftl_garbage_collect
	mov	w2, #718
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.rk_ftl_garbage_collect
	bl	sftl_printk
	ldrh	w9, [x27, :lo12:g_gc_superblock]
.LBB34_181:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x8, g_gc_temp_superblock
	ldrh	w8, [x8, :lo12:g_gc_temp_superblock]
	cmp	w8, w9, uxth
	b.ne	.LBB34_183
// %bb.182:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.rk_ftl_garbage_collect
	mov	w2, #719
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.rk_ftl_garbage_collect
	bl	sftl_printk
.LBB34_183:                             //   in Loop: Header=BB34_95 Depth=1
	adrp	x21, g_gc_superblock
	add	x21, x21, :lo12:g_gc_superblock
	mov	x0, x21
	bl	make_superblock
	adrp	x8, p_valid_page_count_table
	ldr	x9, [x8, :lo12:p_valid_page_count_table]
	ldrh	w8, [x21]
	adrp	x10, g_gc_cur_blk_valid_pages
	strh	wzr, [x10, :lo12:g_gc_cur_blk_valid_pages]
	adrp	x10, g_gc_cur_blk_max_valid_pages
	ldrh	w9, [x9, x8, lsl #1]
	mov	x17, x19
	adrp	x13, g_gc_superblock+2
	mov	w18, #65535
	mov	x12, x25
	strh	wzr, [x21, #2]
	strh	w9, [x10, :lo12:g_gc_cur_blk_max_valid_pages]
	strb	wzr, [x21, #6]
	b	.LBB34_96
.LBB34_184:
	mov	w8, #65535
	strh	w8, [x27, :lo12:g_gc_superblock]
.LBB34_185:
	adrp	x8, g_gc_blk_index
	strh	wzr, [x8, :lo12:g_gc_blk_index]
	mov	w20, #8
	b	.LBB34_187
.LBB34_186:
	adrp	x8, gc_ink_free_return_value
	ldrh	w20, [x8, :lo12:gc_ink_free_return_value]
	adrp	x8, g_in_gc_progress
	str	wzr, [x8, :lo12:g_in_gc_progress]
	mov	w8, #65535
	adrp	x9, g_gc_superblock
	str	w8, [x9, :lo12:g_gc_superblock]
.LBB34_187:
	adrp	x9, __stack_chk_guard
	ldur	x8, [x29, #-8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB34_205
// %bb.188:
	mov	w0, w20
	ldp	x20, x19, [sp, #128]            // 16-byte Folded Reload
	ldp	x22, x21, [sp, #112]            // 16-byte Folded Reload
	ldp	x24, x23, [sp, #96]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #80]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #64]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #48]             // 16-byte Folded Reload
	add	sp, sp, #144                    // =144
	hint	#29
	ret
.LBB34_189:
	mov	w8, #18
	b	.LBB34_45
.LBB34_190:
	adrp	x19, g_tmp_data_superblock_id
	ldrh	w0, [x19, :lo12:g_tmp_data_superblock_id]
	mov	w20, #65535
	cmp	w0, w20
	b.eq	.LBB34_201
// %bb.191:
	bl	update_vpc_list
	adrp	x9, p_data_block_list_table
	ldr	w8, [x22, :lo12:p_data_block_list_head]
	ldr	w9, [x9, :lo12:p_data_block_list_table]
	ldr	x10, [x21, :lo12:p_valid_page_count_table]
	strh	w20, [x19, :lo12:g_tmp_data_superblock_id]
	sub	w8, w8, w9
	mov	w9, #43691
	lsr	w8, w8, #1
	movk	w9, #43690, lsl #16
	mul	w8, w8, w9
	and	x8, x8, #0xffff
	ldrh	w9, [x10, x8, lsl #1]
	cbnz	w9, .LBB34_194
// %bb.192:
	mov	w9, #65535
	cmp	x8, x9
	b.eq	.LBB34_194
// %bb.193:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.decrement_vpc_count
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.decrement_vpc_count
	mov	w2, #2869
	bl	sftl_printk
.LBB34_194:
	ldrh	w8, [x25, :lo12:g_num_free_superblocks]
	b	.LBB34_202
.LBB34_195:
	mov	w9, #18
	b	.LBB34_59
.LBB34_196:
	bl	FtlReadRefresh
	ldrh	w20, [x20, :lo12:gc_ink_free_return_value]
	b	.LBB34_187
.LBB34_197:
	adrp	x8, gc_ink_free_return_value
	ldrh	w20, [x8, :lo12:gc_ink_free_return_value]
	mov	w8, #65535
	strh	w8, [x27, :lo12:g_gc_superblock]
	adrp	x8, g_gc_blk_index
	strh	wzr, [x8, :lo12:g_gc_blk_index]
	b	.LBB34_187
.LBB34_198:
	adrp	x9, gc_ink_free_return_value
	ldrh	w20, [x9, :lo12:gc_ink_free_return_value]
	cbnz	w20, .LBB34_187
	b	.LBB34_202
.LBB34_199:
	mov	w28, w14
	b	.LBB34_24
.LBB34_200:
	strh	w21, [x19, :lo12:g_gc_next_blk]
	b	.LBB34_34
.LBB34_201:
	ldrh	w8, [x25, :lo12:g_num_free_superblocks]
	strh	w20, [x19, :lo12:g_tmp_data_superblock_id]
.LBB34_202:
	add	w20, w8, #1                     // =1
	b	.LBB34_187
.LBB34_203:
	mov	w9, #64
	b	.LBB34_22
.LBB34_204:
	adrp	x8, gc_ink_free_return_value
	ldrh	w20, [x8, :lo12:gc_ink_free_return_value]
	str	wzr, [x24, :lo12:g_in_gc_progress]
	b	.LBB34_187
.LBB34_205:
	bl	__stack_chk_fail
.Lfunc_end34:
	.size	rk_ftl_garbage_collect, .Lfunc_end34-rk_ftl_garbage_collect
                                        // -- End function
	.globl	FtlSysFlush                     // -- Begin function FtlSysFlush
	.p2align	2
	.type	FtlSysFlush,@function
FtlSysFlush:                            // @FtlSysFlush
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-64]!           // 16-byte Folded Spill
	str	x23, [sp, #16]                  // 8-byte Folded Spill
	stp	x22, x21, [sp, #32]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #48]             // 16-byte Folded Spill
	mov	x29, sp
	bl	FtlWriteDump_data
	adrp	x20, c_ftl_nand_l2pmap_ram_region_num
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	cbz	w8, .LBB35_5
// %bb.1:
	adrp	x19, gL2pMapInfo
	mov	x21, xzr
	mov	x22, xzr
	adrp	x23, p_l2p_ram_map
	add	x19, x19, :lo12:gL2pMapInfo
	b	.LBB35_3
.LBB35_2:                               //   in Loop: Header=BB35_3 Depth=1
	add	x22, x22, #1                    // =1
	cmp	x22, w8, uxth
	add	x21, x21, #16                   // =16
	b.hs	.LBB35_5
.LBB35_3:                               // =>This Inner Loop Header: Depth=1
	ldr	x9, [x23, :lo12:p_l2p_ram_map]
	add	x9, x9, x21
	ldr	w10, [x9, #4]
	tbz	w10, #31, .LBB35_2
// %bb.4:                               //   in Loop: Header=BB35_3 Depth=1
	ldrh	w1, [x9]
	ldr	x2, [x9, #8]
	mov	x0, x19
	bl	FtlMapWritePage
	ldr	x8, [x23, :lo12:p_l2p_ram_map]
	add	x8, x8, x21
	ldr	w9, [x8, #4]
	and	w9, w9, #0x7fffffff
	str	w9, [x8, #4]
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	b	.LBB35_2
.LBB35_5:
	mov	w0, #1
	bl	FtlEctTblFlush
	bl	FtlVpcTblFlush
	ldp	x20, x19, [sp, #48]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #32]             // 16-byte Folded Reload
	ldr	x23, [sp, #16]                  // 8-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #64             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end35:
	.size	FtlSysFlush, .Lfunc_end35-FtlSysFlush
                                        // -- End function
	.globl	FtlCacheWriteBack               // -- Begin function FtlCacheWriteBack
	.p2align	2
	.type	FtlCacheWriteBack,@function
FtlCacheWriteBack:                      // @FtlCacheWriteBack
// %bb.0:
	hint	#25
	mov	w0, wzr
	hint	#29
	ret
.Lfunc_end36:
	.size	FtlCacheWriteBack, .Lfunc_end36-FtlCacheWriteBack
                                        // -- End function
	.globl	l2p_flush                       // -- Begin function l2p_flush
	.p2align	2
	.type	l2p_flush,@function
l2p_flush:                              // @l2p_flush
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-64]!           // 16-byte Folded Spill
	str	x23, [sp, #16]                  // 8-byte Folded Spill
	stp	x22, x21, [sp, #32]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #48]             // 16-byte Folded Spill
	mov	x29, sp
	bl	FtlWriteDump_data
	adrp	x20, c_ftl_nand_l2pmap_ram_region_num
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	cbz	w8, .LBB37_5
// %bb.1:
	adrp	x19, gL2pMapInfo
	mov	x21, xzr
	mov	x22, xzr
	adrp	x23, p_l2p_ram_map
	add	x19, x19, :lo12:gL2pMapInfo
	b	.LBB37_3
.LBB37_2:                               //   in Loop: Header=BB37_3 Depth=1
	add	x22, x22, #1                    // =1
	cmp	x22, w8, uxth
	add	x21, x21, #16                   // =16
	b.hs	.LBB37_5
.LBB37_3:                               // =>This Inner Loop Header: Depth=1
	ldr	x9, [x23, :lo12:p_l2p_ram_map]
	add	x9, x9, x21
	ldr	w10, [x9, #4]
	tbz	w10, #31, .LBB37_2
// %bb.4:                               //   in Loop: Header=BB37_3 Depth=1
	ldrh	w1, [x9]
	ldr	x2, [x9, #8]
	mov	x0, x19
	bl	FtlMapWritePage
	ldr	x8, [x23, :lo12:p_l2p_ram_map]
	add	x8, x8, x21
	ldr	w9, [x8, #4]
	and	w9, w9, #0x7fffffff
	str	w9, [x8, #4]
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	b	.LBB37_2
.LBB37_5:
	ldp	x20, x19, [sp, #48]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #32]             // 16-byte Folded Reload
	ldr	x23, [sp, #16]                  // 8-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #64             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end37:
	.size	l2p_flush, .Lfunc_end37-l2p_flush
                                        // -- End function
	.globl	FtlEctTblFlush                  // -- Begin function FtlEctTblFlush
	.p2align	2
	.type	FtlEctTblFlush,@function
FtlEctTblFlush:                         // @FtlEctTblFlush
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
	adrp	x8, g_ect_tbl_power_up_flush
	ldrh	w9, [x8, :lo12:g_ect_tbl_power_up_flush]
	mov	x29, sp
	cmp	w9, #31                         // =31
	b.hi	.LBB38_2
// %bb.1:
	add	w9, w9, #1                      // =1
	strh	w9, [x8, :lo12:g_ect_tbl_power_up_flush]
	mov	w9, #1
	b	.LBB38_3
.LBB38_2:
	mov	w9, #32
.LBB38_3:
	adrp	x8, gp_ect_tbl_info
	ldr	x10, [x8, :lo12:gp_ect_tbl_info]
	ldr	w11, [x10, #16]
	cbnz	w0, .LBB38_5
// %bb.4:
	ldr	w12, [x10, #20]
	add	w9, w12, w9
	cmp	w11, w9
	b.lo	.LBB38_7
.LBB38_5:
	mov	w9, #17221
	movk	w9, #16980, lsl #16
	str	w11, [x10, #20]
	str	w9, [x10]
	ldr	x9, [x8, :lo12:gp_ect_tbl_info]
	adrp	x10, g_ect_tbl_info_size
	ldrh	w1, [x10, :lo12:g_ect_tbl_info_size]
	mov	w0, #64
	ldr	w10, [x9, #8]
	str	wzr, [x9, #4]
	lsl	w11, w1, #9
	add	w10, w10, #1                    // =1
	stp	w10, w11, [x9, #8]
	ldr	x2, [x8, :lo12:gp_ect_tbl_info]
	bl	FtlVendorPartWrite
	adrp	x8, g_sys_ext_data
	ldr	w8, [x8, :lo12:g_sys_ext_data]
	mov	w9, #19539
	movk	w9, #18004, lsl #16
	cmp	w8, w9
	b.ne	.LBB38_7
// %bb.6:
	adrp	x9, g_totle_write_sector
	adrp	x10, g_totle_read_sector
	ldr	w9, [x9, :lo12:g_totle_write_sector]
	ldr	w10, [x10, :lo12:g_totle_read_sector]
	adrp	x2, g_sys_ext_data
	add	x2, x2, :lo12:g_sys_ext_data
	adrp	x11, g_totle_gc_page_count
	adrp	x12, g_totle_write_page_count
	adrp	x13, g_totle_read_page_count
	stp	w9, w10, [x2, #88]
	ldr	w10, [x11, :lo12:g_totle_gc_page_count]
	ldr	w11, [x12, :lo12:g_totle_write_page_count]
	ldr	w12, [x13, :lo12:g_totle_read_page_count]
	mov	w8, #89
	movk	w8, #20480, lsl #16
	adrp	x14, g_totle_l2p_write_count
	adrp	x15, g_totle_slc_erase_count
	adrp	x9, g_totle_sys_slc_erase_count
	stp	w8, w10, [x2, #4]
	ldr	w10, [x14, :lo12:g_totle_l2p_write_count]
	stp	w11, w12, [x2, #12]
	ldr	w12, [x15, :lo12:g_totle_slc_erase_count]
	ldr	w9, [x9, :lo12:g_totle_sys_slc_erase_count]
	adrp	x8, g_totle_discard_page_count
	adrp	x11, g_totle_cache_write_count
	str	w10, [x2, #20]
	adrp	x10, g_max_erase_count
	stp	w12, w9, [x2, #28]
	adrp	x9, g_min_erase_count
	ldr	w8, [x8, :lo12:g_totle_discard_page_count]
	ldr	w11, [x11, :lo12:g_totle_cache_write_count]
	ldr	w10, [x10, :lo12:g_max_erase_count]
	ldr	w9, [x9, :lo12:g_min_erase_count]
	mov	w1, #1
	mov	w0, wzr
	stp	w8, w11, [x2, #36]
	stp	w10, w9, [x2, #44]
	bl	FtlVendorPartWrite
.LBB38_7:
	mov	w0, wzr
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end38:
	.size	FtlEctTblFlush, .Lfunc_end38-FtlEctTblFlush
                                        // -- End function
	.globl	sftl_deinit                     // -- Begin function sftl_deinit
	.p2align	2
	.type	sftl_deinit,@function
sftl_deinit:                            // @sftl_deinit
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-64]!           // 16-byte Folded Spill
	adrp	x8, gFtlInitStatus
	ldr	w8, [x8, :lo12:gFtlInitStatus]
	str	x23, [sp, #16]                  // 8-byte Folded Spill
	stp	x22, x21, [sp, #32]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #48]             // 16-byte Folded Spill
	cmp	w8, #1                          // =1
	mov	x29, sp
	b.ne	.LBB39_7
// %bb.1:
	bl	FtlWriteDump_data
	adrp	x20, c_ftl_nand_l2pmap_ram_region_num
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	cbz	w8, .LBB39_6
// %bb.2:
	adrp	x19, gL2pMapInfo
	mov	x21, xzr
	mov	x22, xzr
	adrp	x23, p_l2p_ram_map
	add	x19, x19, :lo12:gL2pMapInfo
	b	.LBB39_4
.LBB39_3:                               //   in Loop: Header=BB39_4 Depth=1
	add	x22, x22, #1                    // =1
	cmp	x22, w8, uxth
	add	x21, x21, #16                   // =16
	b.hs	.LBB39_6
.LBB39_4:                               // =>This Inner Loop Header: Depth=1
	ldr	x9, [x23, :lo12:p_l2p_ram_map]
	add	x9, x9, x21
	ldr	w10, [x9, #4]
	tbz	w10, #31, .LBB39_3
// %bb.5:                               //   in Loop: Header=BB39_4 Depth=1
	ldrh	w1, [x9]
	ldr	x2, [x9, #8]
	mov	x0, x19
	bl	FtlMapWritePage
	ldr	x8, [x23, :lo12:p_l2p_ram_map]
	add	x8, x8, x21
	ldr	w9, [x8, #4]
	and	w9, w9, #0x7fffffff
	str	w9, [x8, #4]
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	b	.LBB39_3
.LBB39_6:
	mov	w0, #1
	bl	FtlEctTblFlush
	bl	FtlVpcTblFlush
.LBB39_7:
	ldp	x20, x19, [sp, #48]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #32]             // 16-byte Folded Reload
	ldr	x23, [sp, #16]                  // 8-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #64             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end39:
	.size	sftl_deinit, .Lfunc_end39-sftl_deinit
                                        // -- End function
	.globl	FtlRead                         // -- Begin function FtlRead
	.p2align	2
	.type	FtlRead,@function
FtlRead:                                // @FtlRead
// %bb.0:
	hint	#25
	sub	sp, sp, #176                    // =176
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	and	w9, w0, #0xff
	stp	x29, x30, [sp, #80]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #144]            // 16-byte Folded Spill
	stp	x20, x19, [sp, #160]            // 16-byte Folded Spill
	add	x29, sp, #80                    // =80
	mov	x19, x3
	mov	w21, w1
	cmp	w9, #16                         // =16
	stp	x28, x27, [sp, #96]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #112]            // 16-byte Folded Spill
	stp	x24, x23, [sp, #128]            // 16-byte Folded Spill
	stur	x8, [x29, #-8]
	b.ne	.LBB40_2
// %bb.1:
	add	w0, w21, #256                   // =256
	mov	w1, w2
	mov	x2, x19
	bl	FtlVendorPartRead
	b	.LBB40_12
.LBB40_2:
	adrp	x8, g_MaxLbaSector
	ldr	w8, [x8, :lo12:g_MaxLbaSector]
	mov	w0, #-1
	cmp	w8, w21
	b.ls	.LBB40_12
// %bb.3:
	cmp	w8, w2
	b.lo	.LBB40_12
// %bb.4:
	add	w9, w2, w21
	cmp	w9, w8
	mov	w0, #-1
	stur	w9, [x29, #-16]                 // 4-byte Folded Spill
	b.hi	.LBB40_12
// %bb.5:
	adrp	x8, gFtlInitStatus
	ldr	w8, [x8, :lo12:gFtlInitStatus]
	cmn	w8, #1                          // =1
	b.eq	.LBB40_12
// %bb.6:
	adrp	x10, c_ftl_nand_sec_pre_page
	ldur	w8, [x29, #-16]                 // 4-byte Folded Reload
	ldrh	w10, [x10, :lo12:c_ftl_nand_sec_pre_page]
	adrp	x9, g_totle_read_sector
	adrp	x11, g_totle_read_page_count
	ldr	w12, [x9, :lo12:g_totle_read_sector]
	sub	w8, w8, #1                      // =1
	ldr	w13, [x11, :lo12:g_totle_read_page_count]
	udiv	w24, w21, w10
	udiv	w23, w8, w10
	sub	w10, w23, w24
	add	w8, w12, w2
	adds	w25, w10, #1                    // =1
	str	w8, [x9, :lo12:g_totle_read_sector]
	add	w8, w13, w25
	str	w8, [x11, :lo12:g_totle_read_page_count]
	b.lo	.LBB40_14
// %bb.7:
	stur	wzr, [x29, #-20]                // 4-byte Folded Spill
.LBB40_8:
	adrp	x8, g_gc_bad_block_temp_num
	ldrh	w8, [x8, :lo12:g_gc_bad_block_temp_num]
	cbnz	w8, .LBB40_10
// %bb.9:
	adrp	x8, g_num_free_superblocks
	ldrh	w8, [x8, :lo12:g_num_free_superblocks]
	cmp	w8, #31                         // =31
	b.hi	.LBB40_11
.LBB40_10:
	mov	w0, wzr
	bl	rk_ftl_garbage_collect
.LBB40_11:
	ldur	w0, [x29, #-20]                 // 4-byte Folded Reload
.LBB40_12:
	adrp	x9, __stack_chk_guard
	ldur	x8, [x29, #-8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB40_56
// %bb.13:
	ldp	x20, x19, [sp, #160]            // 16-byte Folded Reload
	ldp	x22, x21, [sp, #144]            // 16-byte Folded Reload
	ldp	x24, x23, [sp, #128]            // 16-byte Folded Reload
	ldp	x26, x25, [sp, #112]            // 16-byte Folded Reload
	ldp	x28, x27, [sp, #96]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #80]             // 16-byte Folded Reload
	add	sp, sp, #176                    // =176
	hint	#29
	ret
.LBB40_14:
	mov	w27, wzr
	adrp	x26, req_read
	adrp	x28, g_sys_ext_data+72
	mov	w20, w24
	str	w2, [sp, #12]                   // 4-byte Folded Spill
	str	xzr, [sp, #16]                  // 8-byte Folded Spill
	str	wzr, [sp, #24]                  // 4-byte Folded Spill
	stur	wzr, [x29, #-20]                // 4-byte Folded Spill
	b	.LBB40_17
.LBB40_15:                              //   in Loop: Header=BB40_17 Depth=1
	ldr	w25, [sp, #28]                  // 4-byte Folded Reload
	mov	w27, wzr
.LBB40_16:                              //   in Loop: Header=BB40_17 Depth=1
	add	w20, w20, #1                    // =1
	cbz	w25, .LBB40_8
.LBB40_17:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB40_24 Depth 2
                                        //     Child Loop BB40_39 Depth 2
	sub	x1, x29, #12                    // =12
	mov	w0, w20
	mov	w2, wzr
	bl	log2phys
	ldur	w9, [x29, #-12]
	cmn	w9, #1                          // =1
	b.eq	.LBB40_21
// %bb.18:                              //   in Loop: Header=BB40_17 Depth=1
	ldr	x10, [x26, :lo12:req_read]
	mov	w8, w27
	cmp	w20, w24
	add	x10, x10, x8, lsl #5
	str	w9, [x10, #4]
	b.ne	.LBB40_27
// %bb.19:                              //   in Loop: Header=BB40_17 Depth=1
	ldr	x9, [x26, :lo12:req_read]
	adrp	x10, p_io_data_buf_0
	ldr	x10, [x10, :lo12:p_io_data_buf_0]
	ldr	w11, [sp, #12]                  // 4-byte Folded Reload
	add	x9, x9, x8, lsl #5
	str	x10, [x9, #8]
	adrp	x9, c_ftl_nand_sec_pre_page
	ldrh	w9, [x9, :lo12:c_ftl_nand_sec_pre_page]
	udiv	w10, w21, w9
	msub	w10, w10, w9, w21
	str	w10, [sp, #20]                  // 4-byte Folded Spill
	sub	w10, w9, w10
	cmp	w10, w11
	csel	w10, w11, w10, hi
	cmp	w10, w9
	str	w10, [sp, #24]                  // 4-byte Folded Spill
	b.ne	.LBB40_33
// %bb.20:                              //   in Loop: Header=BB40_17 Depth=1
	ldr	x10, [x26, :lo12:req_read]
	str	w9, [sp, #24]                   // 4-byte Folded Spill
	add	x10, x10, x8, lsl #5
	str	x19, [x10, #8]
	b	.LBB40_33
.LBB40_21:                              //   in Loop: Header=BB40_17 Depth=1
	adrp	x8, c_ftl_nand_sec_pre_page
	ldrh	w22, [x8, :lo12:c_ftl_nand_sec_pre_page]
	cbz	w22, .LBB40_31
// %bb.22:                              //   in Loop: Header=BB40_17 Depth=1
	stur	w27, [x29, #-32]                // 4-byte Folded Spill
	str	w25, [sp, #28]                  // 4-byte Folded Spill
	mov	x25, x19
	mov	w27, wzr
	mul	w19, w20, w22
	b	.LBB40_24
.LBB40_23:                              //   in Loop: Header=BB40_24 Depth=2
	add	w27, w27, #1                    // =1
	cmp	w27, w22
	b.hs	.LBB40_30
.LBB40_24:                              //   Parent Loop BB40_17 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	add	w9, w19, w27
	subs	w8, w9, w21
	b.lo	.LBB40_23
// %bb.25:                              //   in Loop: Header=BB40_24 Depth=2
	ldur	w10, [x29, #-16]                // 4-byte Folded Reload
	cmp	w9, w10
	b.hs	.LBB40_23
// %bb.26:                              //   in Loop: Header=BB40_24 Depth=2
	lsl	w8, w8, #9
	add	x0, x25, x8
	mov	w2, #512
	mov	w1, wzr
	bl	memset
	b	.LBB40_23
.LBB40_27:                              //   in Loop: Header=BB40_17 Depth=1
	cmp	w20, w23
	b.ne	.LBB40_32
// %bb.28:                              //   in Loop: Header=BB40_17 Depth=1
	ldr	x9, [x26, :lo12:req_read]
	adrp	x10, p_io_data_buf_1
	ldr	x10, [x10, :lo12:p_io_data_buf_1]
	ldur	w11, [x29, #-16]                // 4-byte Folded Reload
	add	x9, x9, x8, lsl #5
	str	x10, [x9, #8]
	adrp	x9, c_ftl_nand_sec_pre_page
	ldrh	w9, [x9, :lo12:c_ftl_nand_sec_pre_page]
	mul	w10, w23, w9
	sub	w11, w11, w10
	cmp	w11, w9
	str	w11, [sp, #16]                  // 4-byte Folded Spill
	b.ne	.LBB40_33
// %bb.29:                              //   in Loop: Header=BB40_17 Depth=1
	ldr	x11, [x26, :lo12:req_read]
	sub	w10, w10, w21
	lsl	w10, w10, #9
	add	x10, x19, x10
	add	x11, x11, x8, lsl #5
	str	x10, [x11, #8]
	str	w9, [sp, #16]                   // 4-byte Folded Spill
	b	.LBB40_33
.LBB40_30:                              //   in Loop: Header=BB40_17 Depth=1
	mov	x19, x25
	ldr	w25, [sp, #28]                  // 4-byte Folded Reload
	ldur	w27, [x29, #-32]                // 4-byte Folded Reload
.LBB40_31:                              //   in Loop: Header=BB40_17 Depth=1
	subs	w25, w25, #1                    // =1
	b.ne	.LBB40_34
	b	.LBB40_35
.LBB40_32:                              //   in Loop: Header=BB40_17 Depth=1
	adrp	x9, c_ftl_nand_sec_pre_page
	ldrh	w9, [x9, :lo12:c_ftl_nand_sec_pre_page]
	ldr	x11, [x26, :lo12:req_read]
	neg	w10, w21
	madd	w9, w20, w9, w10
	lsl	w9, w9, #9
	add	x9, x19, x9
	add	x10, x11, x8, lsl #5
	str	x9, [x10, #8]
.LBB40_33:                              //   in Loop: Header=BB40_17 Depth=1
	adrp	x9, c_ftl_nand_byte_pre_oob
	ldrh	w9, [x9, :lo12:c_ftl_nand_byte_pre_oob]
	adrp	x11, p_io_spare_buf
	ldr	x10, [x26, :lo12:req_read]
	ldr	x11, [x11, :lo12:p_io_spare_buf]
	mul	w9, w27, w9
	lsl	x8, x8, #5
	and	w9, w9, #0xfffffffc
	add	x10, x10, x8
	add	x9, x11, x9
	str	x9, [x10, #16]
	ldr	x9, [x26, :lo12:req_read]
	add	w27, w27, #1                    // =1
	add	x8, x9, x8
	str	w20, [x8, #24]
	subs	w25, w25, #1                    // =1
	b.eq	.LBB40_35
.LBB40_34:                              //   in Loop: Header=BB40_17 Depth=1
	adrp	x8, c_ftl_nand_planes_num
	ldrh	w8, [x8, :lo12:c_ftl_nand_planes_num]
	cmp	w27, w8, lsl #2
	b.ne	.LBB40_16
.LBB40_35:                              //   in Loop: Header=BB40_17 Depth=1
	cbz	w27, .LBB40_16
// %bb.36:                              //   in Loop: Header=BB40_17 Depth=1
	ldr	x0, [x26, :lo12:req_read]
	mov	w1, w27
	str	w25, [sp, #28]                  // 4-byte Folded Spill
	bl	FlashReadPages
	ldr	w8, [sp, #16]                   // 4-byte Folded Reload
	mov	x22, xzr
	lsl	w8, w8, #9
	str	x8, [sp, #32]                   // 8-byte Folded Spill
	ldr	w8, [sp, #20]                   // 4-byte Folded Reload
	lsl	w8, w8, #9
	stur	x8, [x29, #-32]                 // 8-byte Folded Spill
	ldr	w8, [sp, #24]                   // 4-byte Folded Reload
	lsl	w8, w8, #9
	str	x8, [sp, #40]                   // 8-byte Folded Spill
	mov	w8, w27
	lsl	x27, x8, #5
	b	.LBB40_39
.LBB40_37:                              //   in Loop: Header=BB40_39 Depth=2
	adrp	x8, g_gc_next_blk
	strh	w25, [x8, :lo12:g_gc_next_blk]
.LBB40_38:                              //   in Loop: Header=BB40_39 Depth=2
	add	x22, x22, #32                   // =32
	cmp	x27, x22
	b.eq	.LBB40_15
.LBB40_39:                              //   Parent Loop BB40_17 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldr	x8, [x26, :lo12:req_read]
	add	x9, x8, x22
	ldr	w10, [x9, #24]
	cmp	w10, w24
	b.ne	.LBB40_42
// %bb.40:                              //   in Loop: Header=BB40_39 Depth=2
	ldr	x8, [x9, #8]
	adrp	x9, p_io_data_buf_0
	ldr	x9, [x9, :lo12:p_io_data_buf_0]
	cmp	x8, x9
	b.ne	.LBB40_46
// %bb.41:                              //   in Loop: Header=BB40_39 Depth=2
	ldur	x9, [x29, #-32]                 // 8-byte Folded Reload
	ldr	x2, [sp, #40]                   // 8-byte Folded Reload
	mov	x0, x19
	add	x1, x8, x9
	b	.LBB40_45
.LBB40_42:                              //   in Loop: Header=BB40_39 Depth=2
	cmp	w10, w23
	b.ne	.LBB40_46
// %bb.43:                              //   in Loop: Header=BB40_39 Depth=2
	add	x8, x8, x22
	ldr	x1, [x8, #8]
	adrp	x8, p_io_data_buf_1
	ldr	x8, [x8, :lo12:p_io_data_buf_1]
	cmp	x1, x8
	b.ne	.LBB40_46
// %bb.44:                              //   in Loop: Header=BB40_39 Depth=2
	adrp	x8, c_ftl_nand_sec_pre_page
	ldrh	w8, [x8, :lo12:c_ftl_nand_sec_pre_page]
	neg	w9, w21
	ldr	x2, [sp, #32]                   // 8-byte Folded Reload
	madd	w8, w23, w8, w9
	lsl	w8, w8, #9
	add	x0, x19, x8
.LBB40_45:                              //   in Loop: Header=BB40_39 Depth=2
	bl	memcpy
.LBB40_46:                              //   in Loop: Header=BB40_39 Depth=2
	ldr	x8, [x26, :lo12:req_read]
	add	x9, x8, x22
	ldr	x10, [x9, #16]
	ldr	w9, [x9, #24]
	ldr	w10, [x10, #8]
	cmp	w9, w10
	b.eq	.LBB40_48
// %bb.47:                              //   in Loop: Header=BB40_39 Depth=2
	ldr	w9, [x28, :lo12:g_sys_ext_data+72]
	add	w9, w9, #1                      // =1
	str	w9, [x28, :lo12:g_sys_ext_data+72]
.LBB40_48:                              //   in Loop: Header=BB40_39 Depth=2
	ldr	w9, [x8, x22]
	cmn	w9, #1                          // =1
	b.eq	.LBB40_50
// %bb.49:                              //   in Loop: Header=BB40_39 Depth=2
	cmp	w9, #256                        // =256
	b.ne	.LBB40_38
	b	.LBB40_51
.LBB40_50:                              //   in Loop: Header=BB40_39 Depth=2
	ldr	w9, [x28, :lo12:g_sys_ext_data+72]
	mov	w10, #-1
	stur	w10, [x29, #-20]                // 4-byte Folded Spill
	add	w9, w9, #1                      // =1
	str	w9, [x28, :lo12:g_sys_ext_data+72]
	ldr	w9, [x8, x22]
	cmp	w9, #256                        // =256
	b.ne	.LBB40_38
.LBB40_51:                              //   in Loop: Header=BB40_39 Depth=2
	add	x8, x8, x22
	ldr	w8, [x8, #4]
	adrp	x9, c_ftl_nand_blks_per_die
	ldrh	w9, [x9, :lo12:c_ftl_nand_blks_per_die]
	adrp	x10, c_ftl_nand_planes_per_die
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_per_die]
	ubfx	w8, w8, #10, #16
	udiv	w11, w8, w9
	msub	w8, w11, w9, w8
	udiv	w25, w8, w10
	adrp	x0, .L.str.112
	add	x0, x0, :lo12:.L.str.112
	mov	w1, w25
	bl	sftl_printk
	adrp	x8, g_gc_next_blk
	ldrh	w8, [x8, :lo12:g_gc_next_blk]
	cmp	w8, w25
	b.eq	.LBB40_38
// %bb.52:                              //   in Loop: Header=BB40_39 Depth=2
	adrp	x9, g_gc_next_blk_1
	ldrh	w9, [x9, :lo12:g_gc_next_blk_1]
	cmp	w9, w25, uxth
	b.eq	.LBB40_38
// %bb.53:                              //   in Loop: Header=BB40_39 Depth=2
	mov	w10, #65535
	cmp	w8, w10
	mov	w8, #65535
	b.eq	.LBB40_37
// %bb.54:                              //   in Loop: Header=BB40_39 Depth=2
	cmp	w9, w8
	b.ne	.LBB40_38
// %bb.55:                              //   in Loop: Header=BB40_39 Depth=2
	adrp	x8, g_gc_next_blk_1
	strh	w25, [x8, :lo12:g_gc_next_blk_1]
	b	.LBB40_38
.LBB40_56:
	bl	__stack_chk_fail
.Lfunc_end40:
	.size	FtlRead, .Lfunc_end40-FtlRead
                                        // -- End function
	.globl	FtlVendorPartRead               // -- Begin function FtlVendorPartRead
	.p2align	2
	.type	FtlVendorPartRead,@function
FtlVendorPartRead:                      // @FtlVendorPartRead
// %bb.0:
	hint	#25
	sub	sp, sp, #208                    // =208
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	stp	x29, x30, [sp, #112]            // 16-byte Folded Spill
	add	x29, sp, #112                   // =112
	stp	x28, x27, [sp, #128]            // 16-byte Folded Spill
	stp	x26, x25, [sp, #144]            // 16-byte Folded Spill
	stp	x24, x23, [sp, #160]            // 16-byte Folded Spill
	stp	x22, x21, [sp, #176]            // 16-byte Folded Spill
	stp	x20, x19, [sp, #192]            // 16-byte Folded Spill
	stur	x8, [x29, #-8]
	adrp	x8, c_ftl_vendor_part_size
	ldrh	w8, [x8, :lo12:c_ftl_vendor_part_size]
	add	w9, w1, w0
	cmp	w9, w8
	b.ls	.LBB41_2
// %bb.1:
	mov	w19, #-1
	b	.LBB41_11
.LBB41_2:
	mov	w20, w1
	cbz	w1, .LBB41_10
// %bb.3:
	adrp	x8, c_ftl_nand_sec_pre_page_shift
	ldrh	w8, [x8, :lo12:c_ftl_nand_sec_pre_page_shift]
	mov	w21, w0
	mov	x22, x2
	mov	w19, wzr
	adrp	x28, c_ftl_nand_sec_pre_page
	adrp	x23, p_vendor_data_buf
	lsr	w24, w0, w8
	b	.LBB41_6
.LBB41_4:                               //   in Loop: Header=BB41_6 Depth=1
	ldr	x8, [x23, :lo12:p_vendor_data_buf]
	mov	w10, w25
	lsl	w9, w27, #7
	and	x10, x10, #0xffff
	add	x1, x8, w9, uxtw #2
	lsl	x2, x10, #9
	mov	x0, x22
	bl	memcpy
.LBB41_5:                               //   in Loop: Header=BB41_6 Depth=1
	and	w8, w25, #0xffff
	subs	w20, w20, w8
	add	w21, w21, w8
	and	x8, x25, #0xffff
	add	w24, w24, #1                    // =1
	add	x22, x22, x8, lsl #9
	b.eq	.LBB41_11
.LBB41_6:                               // =>This Inner Loop Header: Depth=1
	adrp	x8, p_vendor_region_ppn_table
	ldr	x8, [x8, :lo12:p_vendor_region_ppn_table]
	ldrh	w9, [x28, :lo12:c_ftl_nand_sec_pre_page]
	ldr	w26, [x8, w24, uxtw #2]
	udiv	w8, w21, w9
	msub	w27, w8, w9, w21
	sub	w8, w9, w27
	cmp	w20, w8, uxth
	csel	w25, w20, w8, lo
	cbz	w26, .LBB41_9
// %bb.7:                               //   in Loop: Header=BB41_6 Depth=1
	ldr	x9, [x23, :lo12:p_vendor_data_buf]
	add	x8, sp, #40                     // =40
	add	x0, sp, #8                      // =8
	mov	w1, #1
	str	w26, [sp, #12]
	stp	x9, x8, [sp, #16]
	bl	FlashReadPages
	ldr	w8, [sp, #8]
	adrp	x9, req_sys
	ldr	w9, [x9, :lo12:req_sys]
	cmn	w8, #1                          // =1
	csinv	w19, w19, wzr, ne
	cmp	w9, #256                        // =256
	b.ne	.LBB41_4
// %bb.8:                               //   in Loop: Header=BB41_6 Depth=1
	adrp	x0, .L.str.94
	add	x0, x0, :lo12:.L.str.94
	mov	w1, w24
	mov	w2, w26
	bl	sftl_printk
	ldr	x2, [x23, :lo12:p_vendor_data_buf]
	adrp	x0, gVendorBlkInfo
	add	x0, x0, :lo12:gVendorBlkInfo
	mov	w1, w24
	bl	FtlMapWritePage
	b	.LBB41_4
.LBB41_9:                               //   in Loop: Header=BB41_6 Depth=1
	mov	w8, w25
	and	x8, x8, #0xffff
	lsl	x2, x8, #9
	mov	x0, x22
	mov	w1, wzr
	bl	memset
	b	.LBB41_5
.LBB41_10:
	mov	w19, wzr
.LBB41_11:
	adrp	x9, __stack_chk_guard
	ldur	x8, [x29, #-8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB41_13
// %bb.12:
	mov	w0, w19
	ldp	x20, x19, [sp, #192]            // 16-byte Folded Reload
	ldp	x22, x21, [sp, #176]            // 16-byte Folded Reload
	ldp	x24, x23, [sp, #160]            // 16-byte Folded Reload
	ldp	x26, x25, [sp, #144]            // 16-byte Folded Reload
	ldp	x28, x27, [sp, #128]            // 16-byte Folded Reload
	ldp	x29, x30, [sp, #112]            // 16-byte Folded Reload
	add	sp, sp, #208                    // =208
	hint	#29
	ret
.LBB41_13:
	bl	__stack_chk_fail
.Lfunc_end41:
	.size	FtlVendorPartRead, .Lfunc_end41-FtlVendorPartRead
                                        // -- End function
	.globl	log2phys                        // -- Begin function log2phys
	.p2align	2
	.type	log2phys,@function
log2phys:                               // @log2phys
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-80]!           // 16-byte Folded Spill
	stp	x24, x23, [sp, #32]             // 16-byte Folded Spill
	adrp	x23, g_MaxLpn
	ldr	w8, [x23, :lo12:g_MaxLpn]
	adrp	x9, c_ftl_nand_sec_pre_page_shift
	stp	x22, x21, [sp, #48]             // 16-byte Folded Spill
	ldrh	w22, [x9, :lo12:c_ftl_nand_sec_pre_page_shift]
	stp	x20, x19, [sp, #64]             // 16-byte Folded Spill
	mov	w20, w2
	mov	w21, w0
	cmp	w8, w0
	mov	x19, x1
	stp	x26, x25, [sp, #16]             // 16-byte Folded Spill
	mov	x29, sp
	b.hi	.LBB42_2
// %bb.1:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.log2phys
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.log2phys
	mov	w2, #820
	bl	sftl_printk
	ldr	w8, [x23, :lo12:g_MaxLpn]
.LBB42_2:
	cmp	w8, w21
	b.ls	.LBB42_17
// %bb.3:
	add	x8, x22, #7                     // =7
	mov	x9, #-1
	adrp	x10, c_ftl_nand_l2pmap_ram_region_num
	lsl	x11, x9, x8
	ldrh	w9, [x10, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	mov	w24, w21
	mvn	w25, w11
	lsr	w21, w21, w8
	adrp	x23, p_l2p_ram_map
	cbz	x9, .LBB42_19
// %bb.4:
	ldr	x8, [x23, :lo12:p_l2p_ram_map]
	mov	x22, xzr
.LBB42_5:                               // =>This Inner Loop Header: Depth=1
	ldrh	w10, [x8]
	cmp	w10, w21, uxth
	b.eq	.LBB42_21
// %bb.6:                               //   in Loop: Header=BB42_5 Depth=1
	add	x22, x22, #1                    // =1
	cmp	x9, x22
	add	x8, x8, #16                     // =16
	b.ne	.LBB42_5
// %bb.7:
	ldr	x8, [x23, :lo12:p_l2p_ram_map]
	mov	x22, xzr
	mov	x10, x8
.LBB42_8:                               // =>This Inner Loop Header: Depth=1
	ldrsh	w11, [x10]
	cmn	w11, #1                         // =1
	b.eq	.LBB42_23
// %bb.9:                               //   in Loop: Header=BB42_8 Depth=1
	add	x22, x22, #1                    // =1
	cmp	x9, x22
	add	x10, x10, #16                   // =16
	b.ne	.LBB42_8
// %bb.10:
	mov	x10, xzr
	mov	w11, #-2147483648
	mov	w12, #4
	mov	w22, w9
.LBB42_11:                              // =>This Inner Loop Header: Depth=1
	ldr	w13, [x8, x12]
	add	x12, x12, #16                   // =16
	cmp	w13, #0                         // =0
	cset	w14, ge
	cmp	w13, w11
	cset	w15, lo
	tst	w14, w15
	csel	w22, w10, w22, ne
	add	x10, x10, #1                    // =1
	csel	w11, w13, w11, ne
	cmp	x9, x10
	b.ne	.LBB42_11
// %bb.12:
	cmp	w9, w22, uxth
	b.hi	.LBB42_25
// %bb.13:
	adrp	x11, g_l2p_last_update_region_id
	ldrh	w11, [x11, :lo12:g_l2p_last_update_region_id]
	mov	x10, xzr
	add	x12, x8, #4                     // =4
	mov	w13, #-1
	mov	w22, w9
	b	.LBB42_15
.LBB42_14:                              //   in Loop: Header=BB42_15 Depth=1
	add	x10, x10, #1                    // =1
	cmp	x9, x10
	add	x12, x12, #16                   // =16
	b.eq	.LBB42_24
.LBB42_15:                              // =>This Inner Loop Header: Depth=1
	ldr	w14, [x12]
	cmp	w14, w13
	b.hs	.LBB42_14
// %bb.16:                              //   in Loop: Header=BB42_15 Depth=1
	ldurh	w15, [x12, #-4]
	cmp	w11, w15
	csel	w22, w22, w10, eq
	csel	w13, w13, w14, eq
	b	.LBB42_14
.LBB42_17:
	mov	w0, #-1
	cbnz	w20, .LBB42_33
// %bb.18:
	str	w0, [x19]
	b	.LBB42_33
.LBB42_19:
	mov	w22, wzr
.LBB42_20:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.select_l2p_ram_region
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.select_l2p_ram_region
	mov	w2, #796
	bl	sftl_printk
	ldr	x8, [x23, :lo12:p_l2p_ram_map]
	b	.LBB42_25
.LBB42_21:
                                        // kill: def $w22 killed $w22 killed $x22 def $x22
	and	x9, x25, x24
	cbnz	w20, .LBB42_29
.LBB42_22:
	ldr	x8, [x23, :lo12:p_l2p_ram_map]
                                        // kill: def $w22 killed $w22 killed $x22 def $x22
	and	x9, x9, #0xffff
	add	x8, x8, w22, uxth #4
	ldr	x8, [x8, #8]
	ldr	w9, [x8, x9, lsl #2]
	and	x8, x22, #0xffff
	str	w9, [x19]
	b	.LBB42_30
.LBB42_23:
                                        // kill: def $w22 killed $w22 killed $x22 def $x22
	b	.LBB42_25
.LBB42_24:
	cmp	w9, w22, uxth
	b.ls	.LBB42_20
.LBB42_25:
	and	x9, x22, #0xffff
	lsl	x26, x9, #4
	ldrh	w1, [x8, x26]
	mov	w10, #65535
	cmp	w1, w10
	b.eq	.LBB42_28
// %bb.26:
	add	x9, x8, x9, lsl #4
	ldr	w9, [x9, #4]
	tbz	w9, #31, .LBB42_28
// %bb.27:
	add	x8, x8, x26
	ldr	x2, [x8, #8]
	adrp	x0, gL2pMapInfo
	add	x0, x0, :lo12:gL2pMapInfo
	bl	FtlMapWritePage
	ldr	x8, [x23, :lo12:p_l2p_ram_map]
	add	x8, x8, x26
	ldr	w9, [x8, #4]
	and	w9, w9, #0x7fffffff
	str	w9, [x8, #4]
.LBB42_28:
	mov	w0, w21
	mov	w1, w22
	bl	load_l2p_region
	and	x9, x25, x24
	cbz	w20, .LBB42_22
.LBB42_29:
	ldr	x10, [x23, :lo12:p_l2p_ram_map]
                                        // kill: def $w22 killed $w22 killed $x22 def $x22
	and	x8, x22, #0xffff
	lsl	x12, x8, #4
	ldr	w11, [x19]
	add	x10, x10, x12
	ldr	x10, [x10, #8]
	and	x9, x9, #0xffff
	str	w11, [x10, x9, lsl #2]
	ldr	x9, [x23, :lo12:p_l2p_ram_map]
	adrp	x11, g_l2p_last_update_region_id
	add	x9, x9, x12
	ldr	w10, [x9, #4]
	orr	w10, w10, #0x80000000
	str	w10, [x9, #4]
	strh	w21, [x11, :lo12:g_l2p_last_update_region_id]
.LBB42_30:
	ldr	x9, [x23, :lo12:p_l2p_ram_map]
	add	x8, x9, x8, lsl #4
	ldr	w9, [x8, #4]!
	cmn	w9, #1                          // =1
	b.eq	.LBB42_32
// %bb.31:
	mov	w0, wzr
	add	w9, w9, #1                      // =1
	str	w9, [x8]
	b	.LBB42_33
.LBB42_32:
	mov	w0, wzr
.LBB42_33:
	ldp	x20, x19, [sp, #64]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #48]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #32]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #80             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end42:
	.size	log2phys, .Lfunc_end42-log2phys
                                        // -- End function
	.globl	FlashReadPages                  // -- Begin function FlashReadPages
	.p2align	2
	.type	FlashReadPages,@function
FlashReadPages:                         // @FlashReadPages
// %bb.0:
	hint	#25
	sub	sp, sp, #112                    // =112
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	stp	x28, x27, [sp, #32]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #48]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #64]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #80]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #96]             // 16-byte Folded Spill
	add	x29, sp, #16                    // =16
	cbz	w1, .LBB43_26
// %bb.1:
	adrp	x8, g_nand_phy_info+12
	ldrh	w8, [x8, :lo12:g_nand_phy_info+12]
	adrp	x20, .L__func__.FlashReadPages
	adrp	x22, g_nand_phy_info+8
	adrp	x24, .L.str.117
	mov	w26, w1
	add	x21, x0, #16                    // =16
	add	x20, x20, :lo12:.L__func__.FlashReadPages
	add	x22, x22, :lo12:g_nand_phy_info+8
	adrp	x25, sftl_nand_check_buf
	adrp	x19, g_nand_ops+24
	add	x24, x24, :lo12:.L.str.117
	stur	w8, [x29, #-4]                  // 4-byte Folded Spill
	b	.LBB43_4
.LBB43_2:                               //   in Loop: Header=BB43_4 Depth=1
	mov	w8, #-1
	stur	w8, [x21, #-16]
.LBB43_3:                               //   in Loop: Header=BB43_4 Depth=1
	subs	x26, x26, #1                    // =1
	add	x21, x21, #32                   // =32
	b.eq	.LBB43_26
.LBB43_4:                               // =>This Inner Loop Header: Depth=1
	ldur	x8, [x21, #-8]
	cbz	x8, .LBB43_6
// %bb.5:                               //   in Loop: Header=BB43_4 Depth=1
	ldr	x8, [x21]
	cbnz	x8, .LBB43_7
.LBB43_6:                               //   in Loop: Header=BB43_4 Depth=1
	adrp	x0, .L.str.78
	mov	w2, #96
	add	x0, x0, :lo12:.L.str.78
	mov	x1, x20
	bl	sftl_printk
.LBB43_7:                               //   in Loop: Header=BB43_4 Depth=1
	ldrh	w8, [x22, #6]
	ldrh	w10, [x22]
	ldur	w9, [x21, #-12]
	cmp	w8, #4                          // =4
	cset	w8, eq
	lsr	w10, w10, w8
	ubfx	w11, w9, #10, #16
	udiv	w23, w11, w10
	cmp	w23, #4                         // =4
	b.hs	.LBB43_2
// %bb.8:                               //   in Loop: Header=BB43_4 Depth=1
	ldrh	w12, [x22, #2]
	msub	w10, w10, w23, w11
	ldp	x11, x3, [x21, #-8]
	ldr	x13, [x25, :lo12:sftl_nand_check_buf]
	ldr	x14, [x19, :lo12:g_nand_ops+24]
	lsl	w8, w12, w8
	and	w9, w9, #0x3ff
	tst	x11, #0x3f
	and	w8, w8, #0xffff
	madd	w28, w10, w8, w9
	csel	x27, x11, x13, eq
	mov	w0, w23
	mov	w1, w28
	mov	x2, x27
	blr	x14
	stur	w0, [x21, #-16]
	adrp	x8, g_nand_phy_info+14
	ldrh	w8, [x8, :lo12:g_nand_phy_info+14]
	cmp	w8, #4                          // =4
	b.ne	.LBB43_23
// %bb.9:                               //   in Loop: Header=BB43_4 Depth=1
	ldr	x8, [x21]
	ldur	w10, [x29, #-4]                 // 4-byte Folded Reload
	ldr	x9, [x19, :lo12:g_nand_ops+24]
	add	x2, x27, #2048                  // =2048
	add	x3, x8, #8                      // =8
	add	w1, w28, w10
	mov	w0, w23
	blr	x9
	cmn	w0, #1                          // =1
	b.eq	.LBB43_13
// %bb.10:                              //   in Loop: Header=BB43_4 Depth=1
	ldr	x8, [x21]
	ldr	w9, [x8, #12]
	cmn	w9, #1                          // =1
	b.ne	.LBB43_14
// %bb.11:                              //   in Loop: Header=BB43_4 Depth=1
	ldr	w9, [x8, #8]
	cmn	w9, #1                          // =1
	b.ne	.LBB43_14
// %bb.12:                              //   in Loop: Header=BB43_4 Depth=1
	ldr	w8, [x8]
	cmn	w8, #1                          // =1
	b.eq	.LBB43_14
.LBB43_13:                              //   in Loop: Header=BB43_4 Depth=1
	mov	w3, #-1
	stur	w3, [x21, #-16]
	b	.LBB43_19
.LBB43_14:                              //   in Loop: Header=BB43_4 Depth=1
	ldur	w3, [x21, #-16]
	cmp	w0, #256                        // =256
	b.ne	.LBB43_17
// %bb.15:                              //   in Loop: Header=BB43_4 Depth=1
	cmn	w3, #1                          // =1
	b.eq	.LBB43_17
// %bb.16:                              //   in Loop: Header=BB43_4 Depth=1
	mov	w3, #256
	stur	w3, [x21, #-16]
	b	.LBB43_19
.LBB43_17:                              //   in Loop: Header=BB43_4 Depth=1
	cmp	w3, #256                        // =256
	b.eq	.LBB43_19
// %bb.18:                              //   in Loop: Header=BB43_4 Depth=1
	cmn	w3, #1                          // =1
	b.ne	.LBB43_23
.LBB43_19:                              //   in Loop: Header=BB43_4 Depth=1
	ldur	w1, [x21, #-12]
	adrp	x0, .L.str.121
	add	x0, x0, :lo12:.L.str.121
	mov	w2, w28
	bl	sftl_printk
	ldur	x23, [x21, #-8]
	cbz	x23, .LBB43_21
// %bb.20:                              //   in Loop: Header=BB43_4 Depth=1
	adrp	x0, .L.str.116
	adrp	x1, .L.str.122
	add	x0, x0, :lo12:.L.str.116
	add	x1, x1, :lo12:.L.str.122
	mov	x2, x23
	mov	w3, wzr
	bl	sftl_printk
	ldr	w1, [x23]
	mov	x0, x24
	bl	sftl_printk
	ldr	w1, [x23, #4]
	mov	x0, x24
	bl	sftl_printk
	ldr	w1, [x23, #8]
	mov	x0, x24
	bl	sftl_printk
	ldr	w1, [x23, #12]
	mov	x0, x24
	bl	sftl_printk
	adrp	x0, .L.str.120
	add	x0, x0, :lo12:.L.str.120
	bl	sftl_printk
.LBB43_21:                              //   in Loop: Header=BB43_4 Depth=1
	ldr	x23, [x21]
	cbz	x23, .LBB43_23
// %bb.22:                              //   in Loop: Header=BB43_4 Depth=1
	adrp	x0, .L.str.116
	adrp	x1, .L.str.88
	add	x0, x0, :lo12:.L.str.116
	add	x1, x1, :lo12:.L.str.88
	mov	x2, x23
	mov	w3, wzr
	bl	sftl_printk
	ldr	w1, [x23]
	mov	x0, x24
	bl	sftl_printk
	ldr	w1, [x23, #4]
	mov	x0, x24
	bl	sftl_printk
	ldr	w1, [x23, #8]
	mov	x0, x24
	bl	sftl_printk
	ldr	w1, [x23, #12]
	mov	x0, x24
	bl	sftl_printk
	adrp	x0, .L.str.120
	add	x0, x0, :lo12:.L.str.120
	bl	sftl_printk
.LBB43_23:                              //   in Loop: Header=BB43_4 Depth=1
	ldr	x8, [x25, :lo12:sftl_nand_check_buf]
	cmp	x27, x8
	b.ne	.LBB43_3
// %bb.24:                              //   in Loop: Header=BB43_4 Depth=1
	ldur	x0, [x21, #-8]
	cmp	x27, x0
	b.eq	.LBB43_3
// %bb.25:                              //   in Loop: Header=BB43_4 Depth=1
	adrp	x8, c_ftl_nand_sec_pre_page
	ldrh	w8, [x8, :lo12:c_ftl_nand_sec_pre_page]
	mov	x1, x27
	lsl	x2, x8, #9
	bl	memcpy
	b	.LBB43_3
.LBB43_26:
	ldp	x20, x19, [sp, #96]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	add	sp, sp, #112                    // =112
	hint	#29
	ret
.Lfunc_end43:
	.size	FlashReadPages, .Lfunc_end43-FlashReadPages
                                        // -- End function
	.globl	ftl_memcpy                      // -- Begin function ftl_memcpy
	.p2align	2
	.type	ftl_memcpy,@function
ftl_memcpy:                             // @ftl_memcpy
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	mov	w2, w2
	str	x19, [sp, #16]                  // 8-byte Folded Spill
	mov	x29, sp
	mov	x19, x0
	bl	memcpy
	mov	x0, x19
	ldr	x19, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end44:
	.size	ftl_memcpy, .Lfunc_end44-ftl_memcpy
                                        // -- End function
	.globl	P2V_block_in_plane              // -- Begin function P2V_block_in_plane
	.p2align	2
	.type	P2V_block_in_plane,@function
P2V_block_in_plane:                     // @P2V_block_in_plane
// %bb.0:
	hint	#25
	adrp	x8, c_ftl_nand_blks_per_die
	ldrh	w8, [x8, :lo12:c_ftl_nand_blks_per_die]
	adrp	x9, c_ftl_nand_planes_per_die
	ldrh	w9, [x9, :lo12:c_ftl_nand_planes_per_die]
	and	w10, w0, #0xffff
	udiv	w11, w10, w8
	msub	w8, w11, w8, w10
	udiv	w0, w8, w9
	hint	#29
	ret
.Lfunc_end45:
	.size	P2V_block_in_plane, .Lfunc_end45-P2V_block_in_plane
                                        // -- End function
	.globl	FtlGcRefreshBlock               // -- Begin function FtlGcRefreshBlock
	.p2align	2
	.type	FtlGcRefreshBlock,@function
FtlGcRefreshBlock:                      // @FtlGcRefreshBlock
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #16]             // 16-byte Folded Spill
	mov	w19, w0
	and	w20, w0, #0xffff
	adrp	x0, .L.str.112
	add	x0, x0, :lo12:.L.str.112
	mov	w1, w20
	mov	x29, sp
	bl	sftl_printk
	adrp	x8, g_gc_next_blk
	ldrh	w10, [x8, :lo12:g_gc_next_blk]
	cmp	w10, w20
	b.eq	.LBB46_6
// %bb.1:
	adrp	x9, g_gc_next_blk_1
	ldrh	w11, [x9, :lo12:g_gc_next_blk_1]
	cmp	w11, w19, uxth
	b.eq	.LBB46_6
// %bb.2:
	mov	w12, #65535
	cmp	w10, w12
	b.eq	.LBB46_5
// %bb.3:
	cmp	w11, w12
	b.ne	.LBB46_6
// %bb.4:
	strh	w19, [x9, :lo12:g_gc_next_blk_1]
	b	.LBB46_6
.LBB46_5:
	strh	w19, [x8, :lo12:g_gc_next_blk]
.LBB46_6:
	ldp	x20, x19, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end46:
	.size	FtlGcRefreshBlock, .Lfunc_end46-FtlGcRefreshBlock
                                        // -- End function
	.globl	FtlProgPages                    // -- Begin function FtlProgPages
	.p2align	2
	.type	FtlProgPages,@function
FtlProgPages:                           // @FtlProgPages
// %bb.0:
	hint	#25
	sub	sp, sp, #112                    // =112
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	mov	w2, wzr
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	stp	x28, x27, [sp, #32]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #48]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #64]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #80]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #96]             // 16-byte Folded Spill
	add	x29, sp, #16                    // =16
	mov	x19, x3
	mov	w21, w1
	mov	x20, x0
	str	x8, [sp, #8]
	bl	FlashProgPages
	cbz	w21, .LBB47_22
// %bb.1:
	mov	w28, w21
	adrp	x21, .L.str.77
	mov	x27, xzr
	mov	w24, wzr
	add	x21, x21, :lo12:.L.str.77
	adrp	x22, c_ftl_nand_blks_per_die
	adrp	x23, c_ftl_nand_planes_per_die
	b	.LBB47_4
.LBB47_2:                               //   in Loop: Header=BB47_4 Depth=1
	mov	w0, w25
	bl	decrement_vpc_count
.LBB47_3:                               //   in Loop: Header=BB47_4 Depth=1
	add	x27, x27, #1                    // =1
	cmp	x27, x28
	b.eq	.LBB47_15
.LBB47_4:                               // =>This Loop Header: Depth=1
                                        //     Child Loop BB47_7 Depth 2
	add	x25, x20, x27, lsl #5
	add	x26, x25, #4                    // =4
	b	.LBB47_7
.LBB47_5:                               //   in Loop: Header=BB47_7 Depth=2
	ldr	w1, [x26]
	mov	x0, x21
	bl	sftl_printk
	ldr	w8, [x26]
	ldrh	w9, [x22, :lo12:c_ftl_nand_blks_per_die]
	ldrh	w10, [x23, :lo12:c_ftl_nand_planes_per_die]
	ubfx	w8, w8, #10, #16
	udiv	w11, w8, w9
	msub	w8, w11, w9, w8
	udiv	w0, w8, w10
	bl	decrement_vpc_count
	ldrh	w8, [x19, #4]
	cbz	w8, .LBB47_9
.LBB47_6:                               //   in Loop: Header=BB47_7 Depth=2
	mov	x0, x19
	bl	get_new_active_ppa
	str	w0, [x26]
	mov	w1, #1
	mov	x0, x25
	mov	w2, wzr
	mov	w24, #1
	bl	FlashProgPages
.LBB47_7:                               //   Parent Loop BB47_4 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldr	w2, [x25]
	cmp	w2, #256                        // =256
	b.eq	.LBB47_5
// %bb.8:                               //   in Loop: Header=BB47_7 Depth=2
	cmn	w2, #1                          // =1
	b.eq	.LBB47_5
	b	.LBB47_10
.LBB47_9:                               //   in Loop: Header=BB47_7 Depth=2
	mov	x0, x19
	bl	allocate_new_data_superblock
	b	.LBB47_6
.LBB47_10:                              //   in Loop: Header=BB47_4 Depth=1
	adrp	x9, c_ftl_nand_planes_num
	ldrb	w8, [x19, #6]
	ldrh	w9, [x9, :lo12:c_ftl_nand_planes_num]
	cmp	w9, w8
	b.hi	.LBB47_12
// %bb.11:                              //   in Loop: Header=BB47_4 Depth=1
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlProgPages
	mov	w2, #986
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlProgPages
	bl	sftl_printk
.LBB47_12:                              //   in Loop: Header=BB47_4 Depth=1
	ldr	w8, [x26]
	add	x25, x20, x27, lsl #5
	add	x1, sp, #4                      // =4
	mov	w2, #1
	str	w8, [sp, #4]
	ldr	w0, [x25, #24]
	bl	log2phys
	ldr	x8, [x25, #16]
	ldr	w8, [x8, #12]
	cmn	w8, #1                          // =1
	b.eq	.LBB47_3
// %bb.13:                              //   in Loop: Header=BB47_4 Depth=1
	ldrh	w9, [x22, :lo12:c_ftl_nand_blks_per_die]
	ldrh	w10, [x23, :lo12:c_ftl_nand_planes_per_die]
	adrp	x11, p_valid_page_count_table
	ubfx	w8, w8, #10, #16
	ldr	x11, [x11, :lo12:p_valid_page_count_table]
	udiv	w12, w8, w9
	msub	w8, w12, w9, w8
	udiv	w25, w8, w10
	ldrh	w8, [x11, w25, uxtw #1]
	cbnz	w8, .LBB47_2
// %bb.14:                              //   in Loop: Header=BB47_4 Depth=1
	adrp	x0, .L.str.79
	and	w1, w25, #0xffff
	add	x0, x0, :lo12:.L.str.79
	mov	w2, wzr
	bl	sftl_printk
	b	.LBB47_2
.LBB47_15:
	cbz	w24, .LBB47_22
// %bb.16:
	bl	FtlWriteDump_data
	adrp	x21, c_ftl_nand_l2pmap_ram_region_num
	ldrh	w8, [x21, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	cbz	w8, .LBB47_21
// %bb.17:
	adrp	x20, gL2pMapInfo
	mov	x22, xzr
	mov	x23, xzr
	adrp	x24, p_l2p_ram_map
	add	x20, x20, :lo12:gL2pMapInfo
	b	.LBB47_19
.LBB47_18:                              //   in Loop: Header=BB47_19 Depth=1
	add	x23, x23, #1                    // =1
	cmp	x23, w8, uxth
	add	x22, x22, #16                   // =16
	b.hs	.LBB47_21
.LBB47_19:                              // =>This Inner Loop Header: Depth=1
	ldr	x9, [x24, :lo12:p_l2p_ram_map]
	add	x9, x9, x22
	ldr	w10, [x9, #4]
	tbz	w10, #31, .LBB47_18
// %bb.20:                              //   in Loop: Header=BB47_19 Depth=1
	ldrh	w1, [x9]
	ldr	x2, [x9, #8]
	mov	x0, x20
	bl	FtlMapWritePage
	ldr	x8, [x24, :lo12:p_l2p_ram_map]
	add	x8, x8, x22
	ldr	w9, [x8, #4]
	and	w9, w9, #0x7fffffff
	str	w9, [x8, #4]
	ldrh	w8, [x21, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	b	.LBB47_18
.LBB47_21:
	mov	w0, #1
	bl	FtlEctTblFlush
	bl	FtlVpcTblFlush
.LBB47_22:
	adrp	x9, c_ftl_nand_planes_num
	ldrb	w8, [x19, #6]
	ldrh	w9, [x9, :lo12:c_ftl_nand_planes_num]
	cmp	w9, w8
	b.hi	.LBB47_24
// %bb.23:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlProgPages
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlProgPages
	mov	w2, #1005
	bl	sftl_printk
.LBB47_24:
	adrp	x9, __stack_chk_guard
	ldr	x8, [sp, #8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB47_26
// %bb.25:
	ldp	x20, x19, [sp, #96]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	add	sp, sp, #112                    // =112
	hint	#29
	ret
.LBB47_26:
	bl	__stack_chk_fail
.Lfunc_end47:
	.size	FtlProgPages, .Lfunc_end47-FtlProgPages
                                        // -- End function
	.globl	decrement_vpc_count             // -- Begin function decrement_vpc_count
	.p2align	2
	.type	decrement_vpc_count,@function
decrement_vpc_count:                    // @decrement_vpc_count
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-48]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #32]             // 16-byte Folded Spill
	and	w19, w0, #0xffff
	mov	w8, #65535
	mov	w20, w0
	cmp	w19, w8
	stp	x22, x21, [sp, #16]             // 16-byte Folded Spill
	mov	x29, sp
	b.eq	.LBB48_3
// %bb.1:
	adrp	x22, p_valid_page_count_table
	ldr	x9, [x22, :lo12:p_valid_page_count_table]
	and	x21, x20, #0xffff
	ldrh	w10, [x9, x21, lsl #1]
	cbz	w10, .LBB48_9
// %bb.2:
	sub	w10, w10, #1                    // =1
	strh	w10, [x9, x21, lsl #1]
.LBB48_3:
	adrp	x22, g_tmp_data_superblock_id
	ldrh	w0, [x22, :lo12:g_tmp_data_superblock_id]
	cmp	w0, w8
	b.eq	.LBB48_8
// %bb.4:
	cmp	w0, w20, uxth
	b.eq	.LBB48_11
// %bb.5:
	bl	update_vpc_list
	adrp	x8, p_data_block_list_head
	adrp	x9, p_data_block_list_table
	ldr	x8, [x8, :lo12:p_data_block_list_head]
	ldr	x9, [x9, :lo12:p_data_block_list_table]
	adrp	x10, p_valid_page_count_table
	ldr	x10, [x10, :lo12:p_valid_page_count_table]
	strh	w20, [x22, :lo12:g_tmp_data_superblock_id]
	sub	x8, x8, x9
	mov	x9, #-6148914691236517206
	asr	x8, x8, #1
	movk	x9, #43691
	mul	x8, x8, x9
	and	x9, x8, #0xffff
	ldrh	w9, [x10, x9, lsl #1]
	cmp	w0, #0                          // =0
	cset	w21, ne
	cbnz	w9, .LBB48_12
// %bb.6:
	cmp	w19, w8, uxth
	b.eq	.LBB48_12
// %bb.7:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.decrement_vpc_count
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.decrement_vpc_count
	mov	w2, #2869
	bl	sftl_printk
	b	.LBB48_12
.LBB48_8:
	mov	w21, wzr
	strh	w20, [x22, :lo12:g_tmp_data_superblock_id]
	b	.LBB48_12
.LBB48_9:
	adrp	x0, .L.str.110
	add	x0, x0, :lo12:.L.str.110
	mov	w1, w19
	mov	w2, wzr
	bl	sftl_printk
	ldr	x8, [x22, :lo12:p_valid_page_count_table]
	ldrh	w8, [x8, x21, lsl #1]
	mov	w21, wzr
	cbnz	w8, .LBB48_12
// %bb.10:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.decrement_vpc_count
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.decrement_vpc_count
	mov	w2, #2853
	bl	sftl_printk
.LBB48_11:
	mov	w21, wzr
.LBB48_12:
	mov	w0, w21
	ldp	x20, x19, [sp, #32]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #48             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end48:
	.size	decrement_vpc_count, .Lfunc_end48-decrement_vpc_count
                                        // -- End function
	.globl	allocate_new_data_superblock    // -- Begin function allocate_new_data_superblock
	.p2align	2
	.type	allocate_new_data_superblock,@function
allocate_new_data_superblock:           // @allocate_new_data_superblock
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-64]!           // 16-byte Folded Spill
	stp	x22, x21, [sp, #32]             // 16-byte Folded Spill
	adrp	x22, c_ftl_nand_data_blks_per_plane
	stp	x20, x19, [sp, #48]             // 16-byte Folded Spill
	ldrh	w20, [x0]
	ldrh	w8, [x22, :lo12:c_ftl_nand_data_blks_per_plane]
	mov	x19, x0
	str	x23, [sp, #16]                  // 8-byte Folded Spill
	mov	x29, sp
	cmp	w20, w8
	b.ls	.LBB49_2
// %bb.1:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.allocate_new_data_superblock
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.allocate_new_data_superblock
	mov	w2, #2766
	bl	sftl_printk
.LBB49_2:
	mov	w21, #65535
	cmp	w20, w21
	b.eq	.LBB49_7
// %bb.3:
	adrp	x8, p_valid_page_count_table
	ldr	x8, [x8, :lo12:p_valid_page_count_table]
	ldrh	w8, [x8, x20, lsl #1]
	cbz	w8, .LBB49_6
// %bb.4:
	mov	w0, w20
	bl	insert_data_list
	adrp	x8, g_num_data_superblocks
	ldrh	w9, [x8, :lo12:g_num_data_superblocks]
	ldrh	w10, [x22, :lo12:c_ftl_nand_data_blks_per_plane]
	add	w9, w9, #1                      // =1
	cmp	w10, w9, uxth
	strh	w9, [x8, :lo12:g_num_data_superblocks]
	b.hs	.LBB49_7
// %bb.5:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.INSERT_DATA_LIST
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.INSERT_DATA_LIST
	mov	w2, #214
	bl	sftl_printk
	b	.LBB49_7
.LBB49_6:
	mov	w0, w20
	bl	INSERT_FREE_LIST
.LBB49_7:
	mov	w8, #1
	strb	w8, [x19, #8]
	adrp	x22, g_tmp_data_superblock_id
	ldrh	w0, [x22, :lo12:g_tmp_data_superblock_id]
	cmp	w0, w21
	b.eq	.LBB49_12
// %bb.8:
	cmp	w20, w0
	b.ne	.LBB49_10
// %bb.9:
	adrp	x8, p_valid_page_count_table
	ldr	x8, [x8, :lo12:p_valid_page_count_table]
	ldrh	w8, [x8, x20, lsl #1]
	cbz	w8, .LBB49_11
.LBB49_10:
	bl	update_vpc_list
.LBB49_11:
	mov	w8, #65535
	strh	w8, [x22, :lo12:g_tmp_data_superblock_id]
.LBB49_12:
	mov	x0, x19
	bl	allocate_data_superblock
	bl	FtlWriteDump_data
	adrp	x20, c_ftl_nand_l2pmap_ram_region_num
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	cbz	w8, .LBB49_17
// %bb.13:
	adrp	x19, gL2pMapInfo
	mov	x21, xzr
	mov	x22, xzr
	adrp	x23, p_l2p_ram_map
	add	x19, x19, :lo12:gL2pMapInfo
	b	.LBB49_15
.LBB49_14:                              //   in Loop: Header=BB49_15 Depth=1
	add	x22, x22, #1                    // =1
	cmp	x22, w8, uxth
	add	x21, x21, #16                   // =16
	b.hs	.LBB49_17
.LBB49_15:                              // =>This Inner Loop Header: Depth=1
	ldr	x9, [x23, :lo12:p_l2p_ram_map]
	add	x9, x9, x21
	ldr	w10, [x9, #4]
	tbz	w10, #31, .LBB49_14
// %bb.16:                              //   in Loop: Header=BB49_15 Depth=1
	ldrh	w1, [x9]
	ldr	x2, [x9, #8]
	mov	x0, x19
	bl	FtlMapWritePage
	ldr	x8, [x23, :lo12:p_l2p_ram_map]
	add	x8, x8, x21
	ldr	w9, [x8, #4]
	and	w9, w9, #0x7fffffff
	str	w9, [x8, #4]
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	b	.LBB49_14
.LBB49_17:
	mov	w0, wzr
	bl	FtlEctTblFlush
	bl	FtlVpcTblFlush
	ldp	x20, x19, [sp, #48]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #32]             // 16-byte Folded Reload
	ldr	x23, [sp, #16]                  // 8-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #64             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end49:
	.size	allocate_new_data_superblock, .Lfunc_end49-allocate_new_data_superblock
                                        // -- End function
	.globl	get_new_active_ppa              // -- Begin function get_new_active_ppa
	.p2align	2
	.type	get_new_active_ppa,@function
get_new_active_ppa:                     // @get_new_active_ppa
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	ldrsh	w8, [x0]
	stp	x20, x19, [sp, #16]             // 16-byte Folded Spill
	mov	x19, x0
	mov	x29, sp
	cmn	w8, #1                          // =1
	b.ne	.LBB50_2
// %bb.1:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.get_new_active_ppa
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.get_new_active_ppa
	mov	w2, #2792
	bl	sftl_printk
.LBB50_2:
	adrp	x20, c_ftl_nand_page_pre_blk
	ldrh	w8, [x19, #2]
	ldrh	w9, [x20, :lo12:c_ftl_nand_page_pre_blk]
	cmp	w8, w9
	b.ne	.LBB50_4
// %bb.3:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.get_new_active_ppa
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.get_new_active_ppa
	mov	w2, #2793
	bl	sftl_printk
.LBB50_4:
	ldrh	w8, [x19, #4]
	cbnz	w8, .LBB50_6
// %bb.5:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.get_new_active_ppa
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.get_new_active_ppa
	mov	w2, #2794
	bl	sftl_printk
.LBB50_6:
	ldrb	w8, [x19, #6]
	strb	wzr, [x19, #10]
	add	x9, x19, x8, lsl #1
	ldrh	w12, [x9, #16]
	mov	w9, #65535
                                        // kill: def $w8 killed $w8 killed $x8 def $x8
	cmp	w12, w9
	b.ne	.LBB50_12
// %bb.7:
	adrp	x10, c_ftl_nand_planes_num
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_num]
	b	.LBB50_9
.LBB50_8:                               //   in Loop: Header=BB50_9 Depth=1
	add	x11, x19, w8, uxtb #1
	ldrh	w12, [x11, #16]
	cmp	w12, w9
	b.ne	.LBB50_11
.LBB50_9:                               // =>This Inner Loop Header: Depth=1
	add	w8, w8, #1                      // =1
	cmp	w10, w8, uxtb
	b.ne	.LBB50_8
// %bb.10:                              //   in Loop: Header=BB50_9 Depth=1
	ldrh	w11, [x19, #2]
	mov	w8, wzr
	add	w11, w11, #1                    // =1
	strh	w11, [x19, #2]
	b	.LBB50_8
.LBB50_11:
	strb	w8, [x19, #6]
.LBB50_12:
	ldrh	w10, [x19, #2]
	ldrh	w9, [x20, :lo12:c_ftl_nand_page_pre_blk]
	cmp	w10, w9
	b.hs	.LBB50_17
// %bb.13:
	ldrh	w11, [x19, #4]
	adrp	x13, c_ftl_nand_planes_num
                                        // kill: def $w8 killed $w8 killed $x8 def $x8
	sub	w11, w11, #1                    // =1
	strh	w11, [x19, #4]
	ldrh	w14, [x13, :lo12:c_ftl_nand_planes_num]
	lsl	w13, w12, #10
	mov	w12, w10
	b	.LBB50_15
.LBB50_14:                              //   in Loop: Header=BB50_15 Depth=1
	add	x15, x19, w8, uxtb #1
	ldrsh	w15, [x15, #16]
	cmn	w15, #1                         // =1
	b.ne	.LBB50_18
.LBB50_15:                              // =>This Inner Loop Header: Depth=1
	add	w8, w8, #1                      // =1
	cmp	w14, w8, uxtb
	b.ne	.LBB50_14
// %bb.16:                              //   in Loop: Header=BB50_15 Depth=1
	mov	w8, wzr
	add	w12, w12, #1                    // =1
	strh	w12, [x19, #2]
	b	.LBB50_14
.LBB50_17:
	mov	w20, #65535
	b	.LBB50_21
.LBB50_18:
	orr	w20, w13, w10
	tst	w11, #0xffff
	strb	w8, [x19, #6]
	b.eq	.LBB50_21
// %bb.19:
	cmp	w9, w12, uxth
	b.ne	.LBB50_21
// %bb.20:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.get_new_active_ppa
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.get_new_active_ppa
	mov	w2, #2817
	bl	sftl_printk
.LBB50_21:
	mov	w0, w20
	ldp	x20, x19, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end50:
	.size	get_new_active_ppa, .Lfunc_end50-get_new_active_ppa
                                        // -- End function
	.globl	FtlWrite                        // -- Begin function FtlWrite
	.p2align	2
	.type	FtlWrite,@function
FtlWrite:                               // @FtlWrite
// %bb.0:
	hint	#25
	sub	sp, sp, #192                    // =192
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	and	w9, w0, #0xff
	stp	x29, x30, [sp, #96]             // 16-byte Folded Spill
	add	x29, sp, #96                    // =96
	cmp	w9, #16                         // =16
	stp	x28, x27, [sp, #112]            // 16-byte Folded Spill
	stp	x26, x25, [sp, #128]            // 16-byte Folded Spill
	stp	x24, x23, [sp, #144]            // 16-byte Folded Spill
	stp	x22, x21, [sp, #160]            // 16-byte Folded Spill
	stp	x20, x19, [sp, #176]            // 16-byte Folded Spill
	stur	x8, [x29, #-8]
	b.ne	.LBB51_2
// %bb.1:
	add	w0, w1, #256                    // =256
	mov	w1, w2
	mov	x2, x3
	bl	FtlVendorPartWrite
	b	.LBB51_21
.LBB51_2:
	adrp	x8, g_MaxLbaSector
	ldr	w8, [x8, :lo12:g_MaxLbaSector]
	mov	w0, #-1
	cmp	w8, w1
	b.ls	.LBB51_21
// %bb.3:
	cmp	w8, w2
	b.lo	.LBB51_21
// %bb.4:
	add	w9, w2, w1
	cmp	w9, w8
	mov	w0, #-1
	str	w9, [sp, #24]                   // 4-byte Folded Spill
	b.hi	.LBB51_21
// %bb.5:
	adrp	x8, gFtlInitStatus
	ldr	w8, [x8, :lo12:gFtlInitStatus]
	cmn	w8, #1                          // =1
	b.eq	.LBB51_21
// %bb.6:
	adrp	x11, g_totle_write_sector
	ldr	w12, [x11, :lo12:g_totle_write_sector]
	adrp	x8, g_ftl_nand_free_count
	mov	w9, #2048
	adrp	x13, c_ftl_nand_sec_pre_page
	ldr	w10, [sp, #24]                  // 4-byte Folded Reload
	str	w9, [x8, :lo12:g_ftl_nand_free_count]
	ldrh	w9, [x13, :lo12:c_ftl_nand_sec_pre_page]
	adrp	x8, g_totle_write_page_count
	add	w12, w12, w2
	sub	w10, w10, #1                    // =1
	str	w12, [x11, :lo12:g_totle_write_sector]
	ldr	w11, [x8, :lo12:g_totle_write_page_count]
	udiv	w24, w1, w9
	udiv	w9, w10, w9
	stp	w9, w1, [sp, #32]               // 8-byte Folded Spill
	sub	w9, w9, w24
	adds	w20, w9, #1                     // =1
	add	w9, w11, w20
	str	x3, [sp, #40]                   // 8-byte Folded Spill
	str	w2, [sp, #20]                   // 4-byte Folded Spill
	str	w9, [x8, :lo12:g_totle_write_page_count]
	b.lo	.LBB51_23
.LBB51_7:
	mov	w0, wzr
	bl	rk_ftl_garbage_collect
	adrp	x21, g_num_free_superblocks
	ldrh	w8, [x21, :lo12:g_num_free_superblocks]
	mov	w0, wzr
	cmp	w8, #5                          // =5
	b.hi	.LBB51_21
// %bb.8:
	mov	w8, #255
	adrp	x22, g_gc_superblock
	adrp	x23, g_gc_next_blk
	mov	w24, #65535
	adrp	x26, g_gc_merge_free_blk_threshold
	mov	w27, #128
	adrp	x28, g_gc_free_blk_threshold
.LBB51_9:                               // =>This Inner Loop Header: Depth=1
	ldrh	w9, [x22, :lo12:g_gc_superblock]
	ldrh	w10, [x23, :lo12:g_gc_next_blk]
	mov	w25, w8
	and	w9, w10, w9
	cmp	w9, w24
	b.ne	.LBB51_19
// %bb.10:                              //   in Loop: Header=BB51_9 Depth=1
	adrp	x8, p_data_block_list_head
	ldr	x8, [x8, :lo12:p_data_block_list_head]
	cbz	x8, .LBB51_12
// %bb.11:                              //   in Loop: Header=BB51_9 Depth=1
	adrp	x9, p_data_block_list_table
	ldr	x9, [x9, :lo12:p_data_block_list_table]
	sub	x8, x8, x9
	mov	w9, #43691
	lsr	x8, x8, #1
	movk	w9, #43690, lsl #16
	mul	w19, w8, w9
	b	.LBB51_13
.LBB51_12:                              //   in Loop: Header=BB51_9 Depth=1
	mov	w19, #65535
.LBB51_13:                              //   in Loop: Header=BB51_9 Depth=1
	and	w20, w19, #0xffff
	adrp	x0, .L.str.112
	add	x0, x0, :lo12:.L.str.112
	mov	w1, w20
	bl	sftl_printk
	ldrh	w8, [x23, :lo12:g_gc_next_blk]
	cmp	w8, w20
	b.eq	.LBB51_19
// %bb.14:                              //   in Loop: Header=BB51_9 Depth=1
	adrp	x9, g_gc_next_blk_1
	ldrh	w9, [x9, :lo12:g_gc_next_blk_1]
	cmp	w9, w19, uxth
	b.eq	.LBB51_19
// %bb.15:                              //   in Loop: Header=BB51_9 Depth=1
	cmp	w8, w24
	b.eq	.LBB51_18
// %bb.16:                              //   in Loop: Header=BB51_9 Depth=1
	cmp	w9, w24
	b.ne	.LBB51_19
// %bb.17:                              //   in Loop: Header=BB51_9 Depth=1
	adrp	x8, g_gc_next_blk_1
	strh	w19, [x8, :lo12:g_gc_next_blk_1]
	b	.LBB51_19
.LBB51_18:                              //   in Loop: Header=BB51_9 Depth=1
	strh	w19, [x23, :lo12:g_gc_next_blk]
.LBB51_19:                              //   in Loop: Header=BB51_9 Depth=1
	mov	w0, #1
	strh	w27, [x26, :lo12:g_gc_merge_free_blk_threshold]
	strh	w27, [x28, :lo12:g_gc_free_blk_threshold]
	bl	rk_ftl_garbage_collect
	mov	w0, wzr
	bl	rk_ftl_garbage_collect
	ldrh	w8, [x21, :lo12:g_num_free_superblocks]
	mov	w0, wzr
	cmp	w8, #2                          // =2
	b.hi	.LBB51_21
// %bb.20:                              //   in Loop: Header=BB51_9 Depth=1
	sub	w8, w25, #1                     // =1
	cbnz	w25, .LBB51_9
.LBB51_21:
	adrp	x9, __stack_chk_guard
	ldur	x8, [x29, #-8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB51_70
// %bb.22:
	ldp	x20, x19, [sp, #176]            // 16-byte Folded Reload
	ldp	x22, x21, [sp, #160]            // 16-byte Folded Reload
	ldp	x24, x23, [sp, #144]            // 16-byte Folded Reload
	ldp	x26, x25, [sp, #128]            // 16-byte Folded Reload
	ldp	x28, x27, [sp, #112]            // 16-byte Folded Reload
	ldp	x29, x30, [sp, #96]             // 16-byte Folded Reload
	add	sp, sp, #192                    // =192
	hint	#29
	ret
.LBB51_23:
	adrp	x10, g_active_superblock
	add	x10, x10, :lo12:g_active_superblock
	adrp	x9, power_up_flag
	ldrh	w8, [x10, #4]
	ldr	w9, [x9, :lo12:power_up_flag]
	adrp	x11, g_buffer_superblock
	add	x11, x11, :lo12:g_buffer_superblock
	cmp	w8, #0                          // =0
	ccmp	w9, #0, #4, eq
	mov	w19, wzr
	adrp	x22, req_prgm
	csel	x28, x11, x10, ne
	mov	w21, w24
	str	wzr, [sp, #28]                  // 4-byte Folded Spill
	b	.LBB51_25
.LBB51_24:                              //   in Loop: Header=BB51_25 Depth=1
	subs	w20, w20, w23
	b.eq	.LBB51_7
.LBB51_25:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB51_41 Depth 2
	adrp	x9, c_ftl_nand_planes_num
	ldrb	w8, [x28, #6]
	ldrh	w9, [x9, :lo12:c_ftl_nand_planes_num]
	cmp	w9, w8
	b.hi	.LBB51_27
// %bb.26:                              //   in Loop: Header=BB51_25 Depth=1
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlWrite
	mov	w2, #1046
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlWrite
	bl	sftl_printk
.LBB51_27:                              //   in Loop: Header=BB51_25 Depth=1
	ldrh	w8, [x28, #4]
	cbnz	w8, .LBB51_36
// %bb.28:                              //   in Loop: Header=BB51_25 Depth=1
	adrp	x8, g_active_superblock
	add	x8, x8, :lo12:g_active_superblock
	cmp	x28, x8
	b.ne	.LBB51_33
// %bb.29:                              //   in Loop: Header=BB51_25 Depth=1
	adrp	x8, g_buffer_superblock+4
	ldrh	w8, [x8, :lo12:g_buffer_superblock+4]
	mov	w25, w21
	cbnz	w8, .LBB51_31
// %bb.30:                              //   in Loop: Header=BB51_25 Depth=1
	adrp	x0, g_buffer_superblock
	add	x0, x0, :lo12:g_buffer_superblock
	bl	allocate_new_data_superblock
	adrp	x8, power_up_flag
	str	wzr, [x8, :lo12:power_up_flag]
.LBB51_31:                              //   in Loop: Header=BB51_25 Depth=1
	adrp	x21, g_active_superblock
	add	x21, x21, :lo12:g_active_superblock
	mov	x0, x21
	bl	allocate_new_data_superblock
	adrp	x8, power_up_flag
	ldr	w8, [x8, :lo12:power_up_flag]
	cmp	w8, #0                          // =0
	adrp	x8, g_buffer_superblock
	add	x8, x8, :lo12:g_buffer_superblock
	csel	x23, x21, x8, eq
	mov	w21, w25
	ldrh	w8, [x23, #4]
	cbnz	w8, .LBB51_35
.LBB51_32:                              //   in Loop: Header=BB51_25 Depth=1
	mov	x0, x23
	bl	allocate_new_data_superblock
	ldrh	w8, [x23, #4]
	b	.LBB51_35
.LBB51_33:                              //   in Loop: Header=BB51_25 Depth=1
	adrp	x23, g_active_superblock
	add	x23, x23, :lo12:g_active_superblock
	ldrh	w8, [x23, #4]
	adrp	x9, power_up_flag
	str	wzr, [x9, :lo12:power_up_flag]
	cbz	w8, .LBB51_69
// %bb.34:                              //   in Loop: Header=BB51_25 Depth=1
	ldrh	w8, [x23, #4]
	cbz	w8, .LBB51_32
.LBB51_35:                              //   in Loop: Header=BB51_25 Depth=1
	mov	x28, x23
.LBB51_36:                              //   in Loop: Header=BB51_25 Depth=1
	ldrb	w9, [x28, #7]
	adrp	x11, c_ftl_nand_planes_num
	ldrb	w10, [x28, #6]
	ldrh	w11, [x11, :lo12:c_ftl_nand_planes_num]
	lsl	w9, w9, #2
	cmp	w20, w9
	csel	w9, w9, w20, hi
	cmp	w9, w8
	csel	w23, w8, w9, hi
	cmp	w11, w10
	b.hi	.LBB51_38
// %bb.37:                              //   in Loop: Header=BB51_25 Depth=1
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlWrite
	mov	w2, #1079
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlWrite
	bl	sftl_printk
.LBB51_38:                              //   in Loop: Header=BB51_25 Depth=1
	cbz	w23, .LBB51_67
// %bb.39:                              //   in Loop: Header=BB51_25 Depth=1
	mov	w8, w23
	str	w8, [sp, #8]                    // 4-byte Folded Spill
	mov	w8, w8
	stp	w21, w20, [sp, #12]             // 8-byte Folded Spill
	mov	x25, xzr
	mov	x23, xzr
	lsl	x20, x8, #5
	mov	w21, w21
	b	.LBB51_41
.LBB51_40:                              //   in Loop: Header=BB51_41 Depth=2
	mov	w8, #61589
	strh	w8, [x26]
	adrp	x10, g_GlobalDataVersion
	ldr	w8, [x10, :lo12:g_GlobalDataVersion]
	add	x25, x25, #32                   // =32
	add	x23, x23, #1                    // =1
	add	w9, w8, #1                      // =1
	cmn	w9, #1                          // =1
	stp	w8, w27, [x26, #4]
	csinc	w8, wzr, w8, eq
	str	w8, [x10, :lo12:g_GlobalDataVersion]
	ldur	w8, [x29, #-12]
	cmp	x20, x25
	str	w8, [x26, #12]
	ldrh	w8, [x28]
	strh	w8, [x26, #2]
	b.eq	.LBB51_66
.LBB51_41:                              //   Parent Loop BB51_25 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldrh	w8, [x28, #4]
	cbz	w8, .LBB51_65
// %bb.42:                              //   in Loop: Header=BB51_41 Depth=2
	add	x27, x21, x23
	sub	x1, x29, #12                    // =12
	mov	w0, w27
	mov	w2, wzr
	bl	log2phys
	mov	x0, x28
	bl	get_new_active_ppa
	ldr	x8, [x22, :lo12:req_prgm]
	adrp	x11, c_ftl_nand_byte_pre_oob
	adrp	x9, p_io_spare_buf
	mov	w1, wzr
	add	x8, x8, x25
	str	w0, [x8, #4]
	ldrh	w8, [x11, :lo12:c_ftl_nand_byte_pre_oob]
	ldr	x9, [x9, :lo12:p_io_spare_buf]
	ldr	x10, [x22, :lo12:req_prgm]
	mul	w8, w23, w8
	and	w8, w8, #0xfffffffc
	add	x8, x9, x8
	add	x9, x10, x25
	str	x8, [x9, #16]
	ldr	x8, [x22, :lo12:req_prgm]
	add	x8, x8, x25
	str	w27, [x8, #24]
	ldr	x8, [x22, :lo12:req_prgm]
	ldrh	w2, [x11, :lo12:c_ftl_nand_byte_pre_oob]
	add	x8, x8, x25
	ldr	x26, [x8, #16]
	mov	x0, x26
	bl	memset
	adrp	x8, c_ftl_nand_sec_pre_page
	ldrh	w8, [x8, :lo12:c_ftl_nand_sec_pre_page]
	cmp	w27, w24
	b.eq	.LBB51_45
// %bb.43:                              //   in Loop: Header=BB51_41 Depth=2
	ldr	w9, [sp, #32]                   // 4-byte Folded Reload
	cmp	w27, w9
	b.eq	.LBB51_45
// %bb.44:                              //   in Loop: Header=BB51_41 Depth=2
	ldr	w9, [sp, #36]                   // 4-byte Folded Reload
	ldr	x10, [x22, :lo12:req_prgm]
	neg	w9, w9
	madd	w8, w27, w8, w9
	ldr	x9, [sp, #40]                   // 8-byte Folded Reload
	lsl	w8, w8, #9
	add	x8, x9, x8
	add	x9, x10, x25
	str	x8, [x9, #8]
	b	.LBB51_63
.LBB51_45:                              //   in Loop: Header=BB51_41 Depth=2
	cmp	w27, w24
	b.ne	.LBB51_48
// %bb.46:                              //   in Loop: Header=BB51_41 Depth=2
	ldr	w10, [sp, #36]                  // 4-byte Folded Reload
	udiv	w9, w10, w8
	msub	w9, w9, w8, w10
	ldr	w10, [sp, #20]                  // 4-byte Folded Reload
	str	w9, [sp, #28]                   // 4-byte Folded Spill
	sub	w9, w8, w9
	cmp	w9, w10
	csel	w19, w10, w9, hi
	cmp	w19, w8
	b.ne	.LBB51_50
// %bb.47:                              //   in Loop: Header=BB51_41 Depth=2
	ldr	x9, [x22, :lo12:req_prgm]
	ldr	x10, [sp, #40]                  // 8-byte Folded Reload
	mov	w19, w8
	add	x9, x9, x25
	str	x10, [x9, #8]
	b	.LBB51_63
.LBB51_48:                              //   in Loop: Header=BB51_41 Depth=2
	ldp	w11, w10, [sp, #28]             // 8-byte Folded Reload
	mul	w9, w27, w8
	cmp	w27, w10
	ldr	w10, [sp, #24]                  // 4-byte Folded Reload
	csel	w11, wzr, w11, eq
	str	w11, [sp, #28]                  // 4-byte Folded Spill
	sub	w10, w10, w9
	and	w10, w10, #0xffff
	csel	w19, w10, w19, eq
	cmp	w19, w8
	b.ne	.LBB51_51
// %bb.49:                              //   in Loop: Header=BB51_41 Depth=2
	ldr	w11, [sp, #36]                  // 4-byte Folded Reload
	ldr	x10, [x22, :lo12:req_prgm]
	mov	w19, w8
	sub	w9, w9, w11
	ldr	x11, [sp, #40]                  // 8-byte Folded Reload
	lsl	w9, w9, #9
	add	x10, x10, x25
	add	x9, x11, x9
	str	x9, [x10, #8]
	b	.LBB51_63
.LBB51_50:                              //   in Loop: Header=BB51_41 Depth=2
	adrp	x8, p_io_data_buf_0
	add	x8, x8, :lo12:p_io_data_buf_0
	b	.LBB51_52
.LBB51_51:                              //   in Loop: Header=BB51_41 Depth=2
	adrp	x8, p_io_data_buf_1
	add	x8, x8, :lo12:p_io_data_buf_1
.LBB51_52:                              //   in Loop: Header=BB51_41 Depth=2
	ldr	x9, [x22, :lo12:req_prgm]
	ldr	x8, [x8]
	add	x9, x9, x25
	str	x8, [x9, #8]
	ldur	w8, [x29, #-12]
	cmn	w8, #1                          // =1
	b.eq	.LBB51_57
// %bb.53:                              //   in Loop: Header=BB51_41 Depth=2
	ldr	x9, [x22, :lo12:req_prgm]
	str	w8, [sp, #52]
	str	w27, [sp, #72]
	add	x0, sp, #48                     // =48
	add	x8, x9, x25
	ldp	x9, x8, [x8, #8]
	mov	w1, #1
	stp	x9, x8, [sp, #56]
	bl	FlashReadPages
	ldr	w8, [sp, #48]
	cmn	w8, #1                          // =1
	b.eq	.LBB51_58
// %bb.54:                              //   in Loop: Header=BB51_41 Depth=2
	ldr	w8, [x26, #8]
	cmp	w27, w8
	b.eq	.LBB51_59
// %bb.55:                              //   in Loop: Header=BB51_41 Depth=2
	adrp	x9, g_sys_ext_data+72
	ldr	w8, [x9, :lo12:g_sys_ext_data+72]
	adrp	x0, .L.str.81
	add	x0, x0, :lo12:.L.str.81
	mov	w2, w27
	add	w8, w8, #1                      // =1
	str	w8, [x9, :lo12:g_sys_ext_data+72]
	ldr	w1, [x26, #8]
	bl	sftl_printk
	ldr	w8, [x26, #8]
	cmp	w27, w8
	b.eq	.LBB51_59
// %bb.56:                              //   in Loop: Header=BB51_41 Depth=2
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlWrite
	mov	w2, #1133
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlWrite
	bl	sftl_printk
	b	.LBB51_59
.LBB51_57:                              //   in Loop: Header=BB51_41 Depth=2
	ldr	x8, [x22, :lo12:req_prgm]
	mov	w1, wzr
	add	x8, x8, x25
	ldr	x0, [x8, #8]
	adrp	x8, c_ftl_nand_byte_pre_page
	ldrh	w2, [x8, :lo12:c_ftl_nand_byte_pre_page]
	bl	memset
	b	.LBB51_59
.LBB51_58:                              //   in Loop: Header=BB51_41 Depth=2
	adrp	x9, g_sys_ext_data+72
	ldr	w8, [x9, :lo12:g_sys_ext_data+72]
	adrp	x0, .L.str.80
	mov	w3, #-1
	add	x0, x0, :lo12:.L.str.80
	add	w8, w8, #1                      // =1
	str	w8, [x9, :lo12:g_sys_ext_data+72]
	ldr	w1, [x26, #8]
	mov	w2, w27
	bl	sftl_printk
.LBB51_59:                              //   in Loop: Header=BB51_41 Depth=2
	ldr	x8, [x22, :lo12:req_prgm]
	cmp	w27, w24
	add	x8, x8, x25
	ldr	x0, [x8, #8]
	b.ne	.LBB51_61
// %bb.60:                              //   in Loop: Header=BB51_41 Depth=2
	ldr	w8, [sp, #28]                   // 4-byte Folded Reload
	ldr	x1, [sp, #40]                   // 8-byte Folded Reload
	lsl	w2, w19, #9
	lsl	w8, w8, #9
	add	x0, x0, x8
	b	.LBB51_62
.LBB51_61:                              //   in Loop: Header=BB51_41 Depth=2
	adrp	x8, c_ftl_nand_sec_pre_page
	ldr	w9, [sp, #36]                   // 4-byte Folded Reload
	ldrh	w8, [x8, :lo12:c_ftl_nand_sec_pre_page]
	lsl	w2, w19, #9
	neg	w9, w9
	madd	w8, w27, w8, w9
	ldr	x9, [sp, #40]                   // 8-byte Folded Reload
	lsl	w8, w8, #9
	add	x1, x9, x8
.LBB51_62:                              //   in Loop: Header=BB51_41 Depth=2
	bl	memcpy
.LBB51_63:                              //   in Loop: Header=BB51_41 Depth=2
	adrp	x9, c_ftl_nand_planes_num
	ldrb	w8, [x28, #6]
	ldrh	w9, [x9, :lo12:c_ftl_nand_planes_num]
	cmp	w9, w8
	b.hi	.LBB51_40
// %bb.64:                              //   in Loop: Header=BB51_41 Depth=2
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlWrite
	mov	w2, #1148
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlWrite
	bl	sftl_printk
	b	.LBB51_40
.LBB51_65:                              //   in Loop: Header=BB51_25 Depth=1
	ldp	w21, w20, [sp, #12]             // 8-byte Folded Reload
	add	w21, w21, w23
                                        // kill: def $w23 killed $w23 killed $x23
	b	.LBB51_67
.LBB51_66:                              //   in Loop: Header=BB51_25 Depth=1
	ldp	w21, w20, [sp, #12]             // 8-byte Folded Reload
	add	w21, w21, w23
	ldr	w23, [sp, #8]                   // 4-byte Folded Reload
.LBB51_67:                              //   in Loop: Header=BB51_25 Depth=1
	ldr	x0, [x22, :lo12:req_prgm]
	mov	w1, w23
	mov	x3, x28
	bl	FtlProgPages
	cmp	w20, w23
	b.hs	.LBB51_24
// %bb.68:                              //   in Loop: Header=BB51_25 Depth=1
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlWrite
	mov	w2, #1157
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlWrite
	bl	sftl_printk
	b	.LBB51_24
.LBB51_69:                              //   in Loop: Header=BB51_25 Depth=1
	mov	x0, x28
	bl	allocate_new_data_superblock
	mov	x23, x28
	ldrh	w8, [x23, #4]
	cbnz	w8, .LBB51_35
	b	.LBB51_32
.LBB51_70:
	bl	__stack_chk_fail
.Lfunc_end51:
	.size	FtlWrite, .Lfunc_end51-FtlWrite
                                        // -- End function
	.globl	FtlVendorPartWrite              // -- Begin function FtlVendorPartWrite
	.p2align	2
	.type	FtlVendorPartWrite,@function
FtlVendorPartWrite:                     // @FtlVendorPartWrite
// %bb.0:
	hint	#25
	sub	sp, sp, #208                    // =208
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	stp	x29, x30, [sp, #112]            // 16-byte Folded Spill
	add	x29, sp, #112                   // =112
	stp	x28, x27, [sp, #128]            // 16-byte Folded Spill
	stp	x26, x25, [sp, #144]            // 16-byte Folded Spill
	stp	x24, x23, [sp, #160]            // 16-byte Folded Spill
	stp	x22, x21, [sp, #176]            // 16-byte Folded Spill
	stp	x20, x19, [sp, #192]            // 16-byte Folded Spill
	stur	x8, [x29, #-8]
	adrp	x8, c_ftl_vendor_part_size
	ldrh	w8, [x8, :lo12:c_ftl_vendor_part_size]
	add	w9, w1, w0
	cmp	w9, w8
	b.ls	.LBB52_2
// %bb.1:
	mov	w0, #-1
	b	.LBB52_10
.LBB52_2:
	mov	w19, w1
	cbz	w1, .LBB52_9
// %bb.3:
	adrp	x8, c_ftl_nand_sec_pre_page_shift
	ldrh	w8, [x8, :lo12:c_ftl_nand_sec_pre_page_shift]
	adrp	x22, gVendorBlkInfo
	mov	w20, w0
	mov	x21, x2
	adrp	x25, p_vendor_region_ppn_table
	adrp	x26, c_ftl_nand_sec_pre_page
	adrp	x27, p_vendor_data_buf
	add	x22, x22, :lo12:gVendorBlkInfo
	lsr	w23, w0, w8
	b	.LBB52_6
.LBB52_4:                               //   in Loop: Header=BB52_6 Depth=1
	adrp	x8, c_ftl_nand_byte_pre_page
	ldr	x0, [x27, :lo12:p_vendor_data_buf]
	ldrh	w2, [x8, :lo12:c_ftl_nand_byte_pre_page]
	mov	w1, wzr
	bl	memset
.LBB52_5:                               //   in Loop: Header=BB52_6 Depth=1
	ldr	x8, [x27, :lo12:p_vendor_data_buf]
	and	x10, x24, #0xffff
	lsl	w9, w28, #7
	and	w28, w24, #0xffff
	lsl	x24, x10, #9
	add	x0, x8, w9, uxtw #2
	mov	x1, x21
	mov	x2, x24
	bl	memcpy
	ldr	x2, [x27, :lo12:p_vendor_data_buf]
	mov	x0, x22
	mov	w1, w23
	bl	FtlMapWritePage
	add	w23, w23, #1                    // =1
	subs	w19, w19, w28
	add	w20, w20, w28
	add	x21, x21, x24
	b.eq	.LBB52_9
.LBB52_6:                               // =>This Inner Loop Header: Depth=1
	ldrh	w9, [x26, :lo12:c_ftl_nand_sec_pre_page]
	ldr	x8, [x25, :lo12:p_vendor_region_ppn_table]
	udiv	w10, w20, w9
	ldr	w8, [x8, w23, uxtw #2]
	msub	w28, w10, w9, w20
	sub	w10, w9, w28
	cmp	w19, w10, uxth
	csel	w24, w19, w10, lo
	cbz	w8, .LBB52_4
// %bb.7:                               //   in Loop: Header=BB52_6 Depth=1
	cmp	w9, w24, uxth
	b.eq	.LBB52_4
// %bb.8:                               //   in Loop: Header=BB52_6 Depth=1
	ldr	x9, [x27, :lo12:p_vendor_data_buf]
	str	w8, [sp, #12]
	add	x8, sp, #40                     // =40
	add	x0, sp, #8                      // =8
	mov	w1, #1
	stp	x9, x8, [sp, #16]
	bl	FlashReadPages
	b	.LBB52_5
.LBB52_9:
	mov	w0, wzr
.LBB52_10:
	adrp	x9, __stack_chk_guard
	ldur	x8, [x29, #-8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB52_12
// %bb.11:
	ldp	x20, x19, [sp, #192]            // 16-byte Folded Reload
	ldp	x22, x21, [sp, #176]            // 16-byte Folded Reload
	ldp	x24, x23, [sp, #160]            // 16-byte Folded Reload
	ldp	x26, x25, [sp, #144]            // 16-byte Folded Reload
	ldp	x28, x27, [sp, #128]            // 16-byte Folded Reload
	ldp	x29, x30, [sp, #112]            // 16-byte Folded Reload
	add	sp, sp, #208                    // =208
	hint	#29
	ret
.LBB52_12:
	bl	__stack_chk_fail
.Lfunc_end52:
	.size	FtlVendorPartWrite, .Lfunc_end52-FtlVendorPartWrite
                                        // -- End function
	.globl	sftl_discard                    // -- Begin function sftl_discard
	.p2align	2
	.type	sftl_discard,@function
sftl_discard:                           // @sftl_discard
// %bb.0:
	hint	#25
	sub	sp, sp, #96                     // =96
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #32]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #48]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #64]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #80]             // 16-byte Folded Spill
	str	x8, [sp, #8]
	adrp	x8, g_MaxLbaSector
	ldr	w9, [x8, :lo12:g_MaxLbaSector]
	add	w10, w1, w0
	mov	w8, w0
	mov	w0, #-1
	cmp	w10, w9
	add	x29, sp, #16                    // =16
	b.hi	.LBB53_19
// %bb.1:
	cmp	w9, w8
	b.ls	.LBB53_19
// %bb.2:
	mov	w19, w1
	cmp	w9, w1
	b.lo	.LBB53_19
// %bb.3:
	cmp	w19, #32                        // =32
	b.lo	.LBB53_18
// %bb.4:
	adrp	x21, c_ftl_nand_sec_pre_page
	ldrh	w9, [x21, :lo12:c_ftl_nand_sec_pre_page]
	udiv	w20, w8, w9
	msub	w8, w20, w9, w8
	ands	w8, w8, #0xffff
	b.eq	.LBB53_6
// %bb.5:
	sub	w8, w9, w8
	cmp	w8, w19
	csel	w8, w8, w19, lo
	add	w20, w20, #1                    // =1
	sub	w19, w19, w8, uxth
.LBB53_6:
	mov	w8, #-1
	cmp	w19, w9
	adrp	x22, gc_discard_updated
	str	w8, [sp]
	b.hs	.LBB53_13
.LBB53_7:
	ldr	w8, [x22, :lo12:gc_discard_updated]
	cmp	w8, #33                         // =33
	b.lo	.LBB53_18
// %bb.8:
	str	wzr, [x22, :lo12:gc_discard_updated]
	bl	FtlWriteDump_data
	adrp	x20, c_ftl_nand_l2pmap_ram_region_num
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	cbz	w8, .LBB53_17
// %bb.9:
	adrp	x19, gL2pMapInfo
	mov	x21, xzr
	mov	x22, xzr
	adrp	x23, p_l2p_ram_map
	add	x19, x19, :lo12:gL2pMapInfo
	b	.LBB53_11
.LBB53_10:                              //   in Loop: Header=BB53_11 Depth=1
	add	x22, x22, #1                    // =1
	cmp	x22, w8, uxth
	add	x21, x21, #16                   // =16
	b.hs	.LBB53_17
.LBB53_11:                              // =>This Inner Loop Header: Depth=1
	ldr	x9, [x23, :lo12:p_l2p_ram_map]
	add	x9, x9, x21
	ldr	w10, [x9, #4]
	tbz	w10, #31, .LBB53_10
// %bb.12:                              //   in Loop: Header=BB53_11 Depth=1
	ldrh	w1, [x9]
	ldr	x2, [x9, #8]
	mov	x0, x19
	bl	FtlMapWritePage
	ldr	x8, [x23, :lo12:p_l2p_ram_map]
	add	x8, x8, x21
	ldr	w9, [x8, #4]
	and	w9, w9, #0x7fffffff
	str	w9, [x8, #4]
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	b	.LBB53_10
.LBB53_13:
	adrp	x23, g_totle_discard_page_count
	adrp	x24, c_ftl_nand_blks_per_die
	adrp	x25, c_ftl_nand_planes_per_die
	b	.LBB53_15
.LBB53_14:                              //   in Loop: Header=BB53_15 Depth=1
	ldrh	w8, [x21, :lo12:c_ftl_nand_sec_pre_page]
	add	w20, w20, #1                    // =1
	sub	w19, w19, w8
	cmp	w19, w8
	b.lo	.LBB53_7
.LBB53_15:                              // =>This Inner Loop Header: Depth=1
	add	x1, sp, #4                      // =4
	mov	w0, w20
	mov	w2, wzr
	bl	log2phys
	ldr	w26, [sp, #4]
	cmn	w26, #1                         // =1
	b.eq	.LBB53_14
// %bb.16:                              //   in Loop: Header=BB53_15 Depth=1
	ldr	w8, [x22, :lo12:gc_discard_updated]
	ldr	w9, [x23, :lo12:g_totle_discard_page_count]
	mov	x1, sp
	mov	w2, #1
	add	w8, w8, #1                      // =1
	add	w9, w9, #1                      // =1
	mov	w0, w20
	str	w8, [x22, :lo12:gc_discard_updated]
	str	w9, [x23, :lo12:g_totle_discard_page_count]
	bl	log2phys
	ldrh	w8, [x24, :lo12:c_ftl_nand_blks_per_die]
	ldrh	w9, [x25, :lo12:c_ftl_nand_planes_per_die]
	ubfx	w10, w26, #10, #16
	udiv	w11, w10, w8
	msub	w8, w11, w8, w10
	udiv	w0, w8, w9
	bl	decrement_vpc_count
	b	.LBB53_14
.LBB53_17:
	bl	FtlVpcTblFlush
.LBB53_18:
	mov	w0, wzr
.LBB53_19:
	adrp	x9, __stack_chk_guard
	ldr	x8, [sp, #8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB53_21
// %bb.20:
	ldp	x20, x19, [sp, #80]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	add	sp, sp, #96                     // =96
	hint	#29
	ret
.LBB53_21:
	bl	__stack_chk_fail
.Lfunc_end53:
	.size	sftl_discard, .Lfunc_end53-sftl_discard
                                        // -- End function
	.globl	sftl_read                       // -- Begin function sftl_read
	.p2align	2
	.type	sftl_read,@function
sftl_read:                              // @sftl_read
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
	mov	x3, x2
	mov	w2, w1
	mov	w1, w0
	mov	w0, wzr
	mov	x29, sp
	bl	FtlRead
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end54:
	.size	sftl_read, .Lfunc_end54-sftl_read
                                        // -- End function
	.globl	sftl_write                      // -- Begin function sftl_write
	.p2align	2
	.type	sftl_write,@function
sftl_write:                             // @sftl_write
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-48]!           // 16-byte Folded Spill
	str	x21, [sp, #16]                  // 8-byte Folded Spill
	stp	x20, x19, [sp, #32]             // 16-byte Folded Spill
	mov	x29, sp
	mov	x19, x2
	mov	w20, w1
	mov	w21, w0
	bl	FtlWriteToIDB
	mov	w0, wzr
	mov	w1, w21
	mov	w2, w20
	mov	x3, x19
	bl	FtlWrite
	ldp	x20, x19, [sp, #32]             // 16-byte Folded Reload
	ldr	x21, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #48             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end55:
	.size	sftl_write, .Lfunc_end55-sftl_write
                                        // -- End function
	.globl	FtlWriteToIDB                   // -- Begin function FtlWriteToIDB
	.p2align	2
	.type	FtlWriteToIDB,@function
FtlWriteToIDB:                          // @FtlWriteToIDB
// %bb.0:
	hint	#25
	sub	sp, sp, #208                    // =208
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	stp	x29, x30, [sp, #112]            // 16-byte Folded Spill
	add	x29, sp, #112                   // =112
	cmp	w0, #575                        // =575
	stp	x28, x27, [sp, #128]            // 16-byte Folded Spill
	stp	x26, x25, [sp, #144]            // 16-byte Folded Spill
	stp	x24, x23, [sp, #160]            // 16-byte Folded Spill
	stp	x22, x21, [sp, #176]            // 16-byte Folded Spill
	stp	x20, x19, [sp, #192]            // 16-byte Folded Spill
	stur	x8, [x29, #-8]
	b.hi	.LBB56_6
// %bb.1:
	add	w23, w1, w0
	sub	w24, w23, #1                    // =1
	mov	w20, w1
	mov	w21, w0
	cmp	w24, #63                        // =63
	b.ls	.LBB56_6
// %bb.2:
	mov	x19, x2
	cmp	w21, #64                        // =64
	b.ne	.LBB56_12
// %bb.3:
	mov	w0, #262144
	mov	w1, #3265
	mov	w2, #6
	bl	kmalloc_order
	adrp	x25, idb_buf
	str	x0, [x25, :lo12:idb_buf]
	mov	w0, #262144
	mov	w1, #3265
	mov	w2, #6
	bl	kmalloc_order
	adrp	x8, gp_flash_check_buf
	str	x0, [x8, :lo12:gp_flash_check_buf]
	cbz	x0, .LBB56_15
// %bb.4:
	ldr	x22, [x25, :lo12:idb_buf]
	cbz	x22, .LBB56_15
// %bb.5:
	adrp	x8, idb_need_write_back
	mov	w9, #1
	mov	w2, #262144
	mov	x0, x22
	mov	w1, wzr
	strb	w9, [x8, :lo12:idb_need_write_back]
	bl	memset
	b	.LBB56_17
.LBB56_6:
	adrp	x19, idb_need_write_back
	ldrb	w8, [x19, :lo12:idb_need_write_back]
	cmp	w8, #1                          // =1
	b.ne	.LBB56_19
// %bb.7:
	adrp	x20, idb_buf
	ldr	x21, [x20, :lo12:idb_buf]
	mov	w9, #35899
	movk	w9, #64732, lsl #16
	ldr	w8, [x21]
	cmp	w8, w9
	b.ne	.LBB56_52
// %bb.8:
	adrp	x8, g_nand_phy_info+10
	ldrh	w8, [x8, :lo12:g_nand_phy_info+10]
	mov	w9, wzr
	mov	w11, #65150
	mov	w10, #262140
	lsl	w8, w8, #2
.LBB56_9:                               // =>This Inner Loop Header: Depth=1
	sub	w12, w11, #127                  // =127
	ldr	w12, [x21, w12, uxtw #2]
	cbnz	w12, .LBB56_20
// %bb.10:                              //   in Loop: Header=BB56_9 Depth=1
	ldr	w12, [x21, w9, uxtw #2]
	add	w13, w9, #1                     // =1
	sub	w14, w11, #128                  // =128
	cmp	w13, #1, lsl #12                // =4096
	sub	w11, w11, #1                    // =1
	csinc	w9, wzr, w9, hi
	cmp	w14, #1, lsl #12                // =4096
	str	w12, [x21, x10]
	sub	x10, x10, #4                    // =4
	b.hi	.LBB56_9
// %bb.11:
	mov	w22, #512
	b	.LBB56_21
.LBB56_12:
	adrp	x8, idb_need_write_back
	ldrb	w8, [x8, :lo12:idb_need_write_back]
	tbz	w8, #0, .LBB56_19
// %bb.13:
	adrp	x8, idb_buf
	ldr	x22, [x8, :lo12:idb_buf]
	cmp	w21, #63                        // =63
	b.hi	.LBB56_17
// %bb.14:
	mov	w8, #64
	sub	w8, w8, w21
	sub	w20, w20, w8
	lsl	w8, w8, #7
	add	x19, x19, w8, uxtw #2
	b	.LBB56_18
.LBB56_15:
	adrp	x0, .L.str.130
	adrp	x1, .L__func__.FtlWriteToIDB
	add	x0, x0, :lo12:.L.str.130
	add	x1, x1, :lo12:.L__func__.FtlWriteToIDB
	bl	sftl_printk
	adrp	x8, idb_need_write_back
	ldrb	w8, [x8, :lo12:idb_need_write_back]
	cmp	w8, #1                          // =1
	b.ne	.LBB56_19
// %bb.16:
	ldr	x22, [x25, :lo12:idb_buf]
.LBB56_17:
	lsl	w8, w21, #7
	sub	w8, w8, #2, lsl #12             // =8192
	add	x22, x22, w8, uxtw #2
.LBB56_18:
	add	w8, w23, #446                   // =446
	cmp	w24, #575                       // =575
	csel	w8, w8, wzr, hi
	sub	w8, w20, w8
	lsl	w2, w8, #9
	mov	x0, x22
	mov	x1, x19
	bl	memcpy
.LBB56_19:
	mov	w22, wzr
	b	.LBB56_54
.LBB56_20:
	lsr	w22, w11, #7
.LBB56_21:
	add	w9, w22, #4                     // =4
	and	w8, w8, #0xffff
	udiv	w27, w9, w8
	add	w26, w27, #1                    // =1
	adrp	x0, .L.str.132
	add	x0, x0, :lo12:.L.str.132
	mov	w1, w22
	mov	w2, w26
	bl	sftl_printk
	cmp	w27, #7                         // =7
	b.hi	.LBB56_52
// %bb.22:
	mov	w9, wzr
	lsl	w25, w22, #7
	adrp	x20, g_nand_ops+8
	mov	w8, w26
	stp	w22, wzr, [sp, #20]             // 8-byte Folded Spill
	str	w26, [sp, #36]                  // 4-byte Folded Spill
	str	x25, [sp, #8]                   // 8-byte Folded Spill
	b	.LBB56_25
.LBB56_23:                              //   in Loop: Header=BB56_25 Depth=1
	ldr	w8, [sp, #24]                   // 4-byte Folded Reload
	add	w8, w8, #1                      // =1
	cmp	w8, #5                          // =5
	str	w8, [sp, #24]                   // 4-byte Folded Spill
	b.hi	.LBB56_56
.LBB56_24:                              //   in Loop: Header=BB56_25 Depth=1
	ldp	w9, w26, [sp, #32]              // 8-byte Folded Reload
	add	w8, w9, w26
	cmp	w8, #9                          // =9
	b.hs	.LBB56_51
.LBB56_25:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB56_26 Depth 2
                                        //     Child Loop BB56_33 Depth 2
                                        //     Child Loop BB56_42 Depth 2
                                        //     Child Loop BB56_48 Depth 2
	adrp	x10, gp_flash_check_buf
	ldr	x0, [x10, :lo12:gp_flash_check_buf]
	mov	w2, #512
	mov	w1, wzr
	mov	w23, w9
	str	w8, [sp, #32]                   // 4-byte Folded Spill
	bl	memset
	adrp	x8, g_nand_phy_info+10
	ldrh	w19, [x8, :lo12:g_nand_phy_info+10]
	adrp	x8, g_nand_ops+32
	add	x8, x8, :lo12:g_nand_ops+32
	ldp	x28, x25, [x8]
	mov	w22, wzr
	str	w23, [sp, #28]                  // 4-byte Folded Spill
	mul	w23, w23, w19
	mov	w24, #-1
.LBB56_26:                              //   Parent Loop BB56_25 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldr	x8, [x20, :lo12:g_nand_ops+8]
	madd	w1, w22, w19, w23
	mov	w0, wzr
	blr	x8
	add	w24, w24, #1                    // =1
	cmp	w24, w27
	add	w22, w22, #1                    // =1
	b.ne	.LBB56_26
// %bb.27:                              //   in Loop: Header=BB56_25 Depth=1
	cmp	x25, #0                         // =0
	cset	w8, ne
	cmp	x28, #0                         // =0
	cset	w9, ne
	and	w22, w9, w8
	cmp	w22, #1                         // =1
	b.ne	.LBB56_29
// %bb.28:                              //   in Loop: Header=BB56_25 Depth=1
	adrp	x8, gp_flash_check_buf
	ldr	x24, [x8, :lo12:gp_flash_check_buf]
	mov	w2, #1016
	mov	w1, wzr
	add	x0, x24, #8                     // =8
	bl	memset
	mov	w8, #18766
	movk	w8, #17998, lsl #16
	str	w8, [x24]
	mov	w8, #12
	str	w8, [x24, #4]
	mov	w8, #1024
	str	wzr, [x24, #12]
	strh	w8, [x24, #16]
	adrp	x8, g_nand_phy_info+10
	ldrh	w8, [x8, :lo12:g_nand_phy_info+10]
	mov	w9, #4096
	str	w9, [x24, #20]
	mov	w9, #47602
	movk	w9, #65230, lsl #16
	mov	w10, #17225
	add	w9, w9, w8, uxtb
	movk	w10, #44697, lsl #16
	eor	w9, w9, w10
	lsl	w10, w9, #5
	strh	w8, [x24, #18]
	add	w8, w10, w8, lsr #8
	add	w8, w8, w9, lsr #2
	eor	w8, w8, w9
	lsr	w9, w8, #2
	add	w9, w9, w8, lsl #5
	eor	w8, w9, w8
	mov	w9, #16
	bfi	w9, w8, #5, #27
	add	w9, w9, w8, lsr #2
	eor	w8, w9, w8
	lsr	w9, w8, #2
	add	w9, w9, w8, lsl #5
	eor	w8, w9, w8
	lsr	w9, w8, #2
	add	w9, w9, w8, lsl #5
	eor	w8, w9, w8
	str	w8, [x24, #8]
	mul	w19, w26, w19
	cbnz	w19, .LBB56_30
	b	.LBB56_38
.LBB56_29:                              //   in Loop: Header=BB56_25 Depth=1
	mov	x24, xzr
	mul	w19, w26, w19
	cbz	w19, .LBB56_38
.LBB56_30:                              //   in Loop: Header=BB56_25 Depth=1
	cmp	x28, #0                         // =0
	cset	w8, eq
	cmp	x25, #0                         // =0
	cset	w9, eq
	mov	w26, wzr
	orr	w28, w8, w9
	mov	x25, x21
	b	.LBB56_33
.LBB56_31:                              //   in Loop: Header=BB56_33 Depth=2
	adrp	x26, g_nand_ops+16
	add	x26, x26, :lo12:g_nand_ops+16
	ldr	x8, [x26, #16]
	mov	w0, #70
	blr	x8
	ldr	x8, [x26]
	add	x3, sp, #40                     // =40
	mov	w0, wzr
	mov	w1, w23
	mov	x2, x24
	blr	x8
	adrp	x8, g_nand_phy_info+22
	ldrb	w8, [x8, :lo12:g_nand_phy_info+22]
	ldr	x9, [x26, #16]
	mov	w26, w0
	mov	w0, w8
	blr	x9
	cmn	w26, #1                         // =1
	b.eq	.LBB56_38
// %bb.32:                              //   in Loop: Header=BB56_33 Depth=2
	mov	w26, #1
	cmp	w26, w19
	b.eq	.LBB56_38
.LBB56_33:                              //   Parent Loop BB56_25 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	tbz	w22, #0, .LBB56_35
// %bb.34:                              //   in Loop: Header=BB56_33 Depth=2
	cmp	w26, #0                         // =0
	cset	w9, ne
	add	w10, w26, #1                    // =1
	orr	w9, w9, w28
	mov	w8, #61424
	stp	w10, w8, [sp, #40]
	tbz	w9, #0, .LBB56_31
	b	.LBB56_36
.LBB56_35:                              //   in Loop: Header=BB56_33 Depth=2
	lsl	w9, w26, #2
	mov	w8, #61424
	stp	w9, w8, [sp, #40]
.LBB56_36:                              //   in Loop: Header=BB56_33 Depth=2
	adrp	x8, g_nand_ops+16
	ldr	x8, [x8, :lo12:g_nand_ops+16]
	add	w1, w26, w23
	add	x3, sp, #40                     // =40
	mov	w0, wzr
	mov	x2, x25
	blr	x8
	cmn	w0, #1                          // =1
	b.eq	.LBB56_38
// %bb.37:                              //   in Loop: Header=BB56_33 Depth=2
	add	x25, x25, #2048                 // =2048
	add	w26, w26, #1                    // =1
	cmp	w26, w19
	b.ne	.LBB56_33
.LBB56_38:                              //   in Loop: Header=BB56_25 Depth=1
	adrp	x8, g_nand_phy_info+10
	add	x8, x8, :lo12:g_nand_phy_info+10
	ldrh	w8, [x8]
	ldr	w9, [sp, #36]                   // 4-byte Folded Reload
	mul	w22, w9, w8
	cbz	w22, .LBB56_46
// %bb.39:                              //   in Loop: Header=BB56_25 Depth=1
	adrp	x10, g_nand_ops+32
	adrp	x9, gp_flash_check_buf
	add	x10, x10, :lo12:g_nand_ops+32
	adrp	x11, g_nand_phy_info+10
	ldr	x23, [x9, :lo12:gp_flash_check_buf]
	ldp	x10, x9, [x10]
	add	x11, x11, :lo12:g_nand_phy_info+10
	ldrh	w24, [x11, #4]
	ldr	w11, [sp, #28]                  // 4-byte Folded Reload
	cmp	x9, #0                          // =0
	mov	w26, wzr
	mul	w25, w11, w8
	cset	w8, eq
	cmp	x10, #0                         // =0
	cset	w9, eq
	orr	w19, w8, w9
	b	.LBB56_42
.LBB56_40:                              //   in Loop: Header=BB56_42 Depth=2
	adrp	x28, g_nand_ops+24
	add	x28, x28, :lo12:g_nand_ops+24
	ldr	x8, [x28, #8]
	mov	w0, #70
	blr	x8
	ldr	x8, [x28, #16]
	mov	w0, #2
	blr	x8
	ldr	x8, [x28]
	add	x3, sp, #40                     // =40
	mov	w0, wzr
	mov	w1, w25
	mov	x2, x23
	blr	x8
	ldr	x8, [x28, #16]
	mov	w0, w24
	blr	x8
	adrp	x9, g_nand_phy_info+22
	ldr	x8, [x28, #8]
	ldrb	w0, [x9, :lo12:g_nand_phy_info+22]
	blr	x8
	ldr	w8, [x23]
	mov	w9, #18766
	movk	w9, #17998, lsl #16
	cmp	w8, w9
	b.ne	.LBB56_46
.LBB56_41:                              //   in Loop: Header=BB56_42 Depth=2
	add	w26, w26, #1                    // =1
	cmp	w26, w22
	b.eq	.LBB56_46
.LBB56_42:                              //   Parent Loop BB56_25 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	cmp	w26, #0                         // =0
	cset	w8, ne
	orr	w8, w19, w8
	tbz	w8, #0, .LBB56_40
// %bb.43:                              //   in Loop: Header=BB56_42 Depth=2
	adrp	x8, g_nand_ops+24
	ldr	x8, [x8, :lo12:g_nand_ops+24]
	add	w1, w26, w25
	add	x3, sp, #40                     // =40
	mov	w0, wzr
	mov	x2, x23
	blr	x8
	cmn	w0, #1                          // =1
	b.eq	.LBB56_46
// %bb.44:                              //   in Loop: Header=BB56_42 Depth=2
	ldr	w8, [sp, #44]
	mov	w9, #61424
	cmp	w8, w9
	b.ne	.LBB56_46
// %bb.45:                              //   in Loop: Header=BB56_42 Depth=2
	add	x23, x23, #2048                 // =2048
	b	.LBB56_41
.LBB56_46:                              //   in Loop: Header=BB56_25 Depth=1
	ldr	w22, [sp, #20]                  // 4-byte Folded Reload
	ldr	x25, [sp, #8]                   // 8-byte Folded Reload
	cbz	w22, .LBB56_23
// %bb.47:                              //   in Loop: Header=BB56_25 Depth=1
	adrp	x8, gp_flash_check_buf
	ldr	x24, [x8, :lo12:gp_flash_check_buf]
	mov	x23, xzr
.LBB56_48:                              //   Parent Loop BB56_25 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	lsl	x19, x23, #2
	ldr	w8, [x24, x19]
	ldr	w9, [x21, x19]
	cmp	w8, w9
	b.ne	.LBB56_50
// %bb.49:                              //   in Loop: Header=BB56_48 Depth=2
	add	x23, x23, #1                    // =1
	cmp	x25, x23
	b.ne	.LBB56_48
	b	.LBB56_23
.LBB56_50:                              //   in Loop: Header=BB56_25 Depth=1
	mov	w2, #512
	mov	x0, x24
	mov	w1, wzr
	bl	memset
	ldr	w2, [x24, x19]
	ldr	w3, [x21, x19]
	ldr	w19, [sp, #28]                  // 4-byte Folded Reload
	adrp	x0, .L.str.133
	add	x0, x0, :lo12:.L.str.133
	mov	w4, w23
	mov	w1, w19
	bl	sftl_printk
	adrp	x8, g_nand_phy_info+10
	ldrh	w8, [x8, :lo12:g_nand_phy_info+10]
	ldr	x9, [x20, :lo12:g_nand_ops+8]
	mov	w0, wzr
	mul	w1, w19, w8
	blr	x9
	b	.LBB56_24
.LBB56_51:
	ldr	w8, [sp, #24]                   // 4-byte Folded Reload
	adrp	x19, idb_need_write_back
	adrp	x20, idb_buf
	cbnz	w8, .LBB56_53
.LBB56_52:
	mov	w22, #-1
.LBB56_53:
	ldr	x0, [x20, :lo12:idb_buf]
	strb	wzr, [x19, :lo12:idb_need_write_back]
	bl	kfree
	adrp	x8, gp_flash_check_buf
	ldr	x0, [x8, :lo12:gp_flash_check_buf]
	bl	kfree
.LBB56_54:
	adrp	x9, __stack_chk_guard
	ldur	x8, [x29, #-8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB56_57
// %bb.55:
	mov	w0, w22
	ldp	x20, x19, [sp, #192]            // 16-byte Folded Reload
	ldp	x22, x21, [sp, #176]            // 16-byte Folded Reload
	ldp	x24, x23, [sp, #160]            // 16-byte Folded Reload
	ldp	x26, x25, [sp, #144]            // 16-byte Folded Reload
	ldp	x28, x27, [sp, #128]            // 16-byte Folded Reload
	ldp	x29, x30, [sp, #112]            // 16-byte Folded Reload
	add	sp, sp, #208                    // =208
	hint	#29
	ret
.LBB56_56:
	adrp	x19, idb_need_write_back
	adrp	x20, idb_buf
	b	.LBB56_53
.LBB56_57:
	bl	__stack_chk_fail
.Lfunc_end56:
	.size	FtlWriteToIDB, .Lfunc_end56-FtlWriteToIDB
                                        // -- End function
	.globl	sftl_vendor_read                // -- Begin function sftl_vendor_read
	.p2align	2
	.type	sftl_vendor_read,@function
sftl_vendor_read:                       // @sftl_vendor_read
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
	add	w0, w0, #256                    // =256
	mov	x29, sp
	bl	FtlVendorPartRead
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end57:
	.size	sftl_vendor_read, .Lfunc_end57-sftl_vendor_read
                                        // -- End function
	.globl	sftl_vendor_write               // -- Begin function sftl_vendor_write
	.p2align	2
	.type	sftl_vendor_write,@function
sftl_vendor_write:                      // @sftl_vendor_write
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
	add	w0, w0, #256                    // =256
	mov	x29, sp
	bl	FtlVendorPartWrite
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end58:
	.size	sftl_vendor_write, .Lfunc_end58-sftl_vendor_write
                                        // -- End function
	.globl	sftl_get_density                // -- Begin function sftl_get_density
	.p2align	2
	.type	sftl_get_density,@function
sftl_get_density:                       // @sftl_get_density
// %bb.0:
	hint	#25
	adrp	x8, g_MaxLbaSector
	ldr	w0, [x8, :lo12:g_MaxLbaSector]
	hint	#29
	ret
.Lfunc_end59:
	.size	sftl_get_density, .Lfunc_end59-sftl_get_density
                                        // -- End function
	.globl	FtlBbtInfoPrint                 // -- Begin function FtlBbtInfoPrint
	.p2align	2
	.type	FtlBbtInfoPrint,@function
FtlBbtInfoPrint:                        // @FtlBbtInfoPrint
// %bb.0:
	hint	#25
	hint	#29
	ret
.Lfunc_end60:
	.size	FtlBbtInfoPrint, .Lfunc_end60-FtlBbtInfoPrint
                                        // -- End function
	.globl	FtlBbt2Bitmap                   // -- Begin function FtlBbt2Bitmap
	.p2align	2
	.type	FtlBbt2Bitmap,@function
FtlBbt2Bitmap:                          // @FtlBbt2Bitmap
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-80]!           // 16-byte Folded Spill
	adrp	x8, c_ftl_nand_bbm_buf_size
	ldrh	w8, [x8, :lo12:c_ftl_nand_bbm_buf_size]
	stp	x20, x19, [sp, #64]             // 16-byte Folded Spill
	mov	x19, x1
	mov	x20, x0
	lsl	x2, x8, #2
	mov	x0, x1
	mov	w1, wzr
	stp	x26, x25, [sp, #16]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #32]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #48]             // 16-byte Folded Spill
	mov	x29, sp
	bl	memset
	adrp	x21, .L.str.78
	adrp	x22, .L__func__.FtlBbt2Bitmap
	mov	x23, xzr
	mov	w24, #65535
	adrp	x25, c_ftl_nand_blks_per_die
	mov	w26, #1
	add	x21, x21, :lo12:.L.str.78
	add	x22, x22, :lo12:.L__func__.FtlBbt2Bitmap
	b	.LBB61_2
.LBB61_1:                               //   in Loop: Header=BB61_2 Depth=1
	lsr	w9, w8, #3
	and	x9, x9, #0x1ffc
	ldr	w10, [x19, x9]
	lsl	w8, w26, w8
	add	x23, x23, #2                    // =2
	cmp	x23, #1024                      // =1024
	orr	w8, w8, w10
	str	w8, [x19, x9]
	b.eq	.LBB61_5
.LBB61_2:                               // =>This Inner Loop Header: Depth=1
	ldrh	w8, [x20, x23]
	cmp	w8, w24
	b.eq	.LBB61_5
// %bb.3:                               //   in Loop: Header=BB61_2 Depth=1
	ldrh	w9, [x25, :lo12:c_ftl_nand_blks_per_die]
	cmp	w8, w9
	b.lo	.LBB61_1
// %bb.4:                               //   in Loop: Header=BB61_2 Depth=1
	mov	w2, #74
	mov	x0, x21
	mov	x1, x22
	bl	sftl_printk
	ldrh	w8, [x20, x23]
	b	.LBB61_1
.LBB61_5:
	ldp	x20, x19, [sp, #64]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #48]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #32]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #80             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end61:
	.size	FtlBbt2Bitmap, .Lfunc_end61-FtlBbt2Bitmap
                                        // -- End function
	.globl	FtlBbtMemInit                   // -- Begin function FtlBbtMemInit
	.p2align	2
	.type	FtlBbtMemInit,@function
FtlBbtMemInit:                          // @FtlBbtMemInit
// %bb.0:
	hint	#25
	adrp	x8, gBbtInfo
	add	x8, x8, :lo12:gBbtInfo
	mov	w9, #65535
	mov	x10, #-1
	strh	w9, [x8]
	strh	wzr, [x8, #6]
	stur	x10, [x8, #12]
	stur	x10, [x8, #20]
	hint	#29
	ret
.Lfunc_end62:
	.size	FtlBbtMemInit, .Lfunc_end62-FtlBbtMemInit
                                        // -- End function
	.globl	FtlBbtCalcTotleCnt              // -- Begin function FtlBbtCalcTotleCnt
	.p2align	2
	.type	FtlBbtCalcTotleCnt,@function
FtlBbtCalcTotleCnt:                     // @FtlBbtCalcTotleCnt
// %bb.0:
	hint	#25
	adrp	x8, c_ftl_nand_blks_per_die
	adrp	x9, c_ftl_nand_die_num
	ldrh	w8, [x8, :lo12:c_ftl_nand_blks_per_die]
	ldrh	w11, [x9, :lo12:c_ftl_nand_die_num]
	mul	w9, w11, w8
	subs	w10, w9, #1                     // =1
	b.lt	.LBB63_3
// %bb.1:
	cmp	w9, #2                          // =2
	b.hs	.LBB63_4
// %bb.2:
	mov	w0, wzr
	mov	w10, wzr
	b	.LBB63_10
.LBB63_3:
	mov	w0, wzr
	hint	#29
	ret
.LBB63_4:
	mneg	w11, w11, w8
	tst	w11, #0xffff
	mov	w0, wzr
	b.eq	.LBB63_9
// %bb.5:
	lsr	w11, w10, #16
	mov	w10, w0
	cbnz	w11, .LBB63_10
// %bb.6:
	adrp	x14, gBbtInfo+32
	mov	w13, wzr
	mov	w12, wzr
	and	w10, w9, #0xfffffffe
	add	x14, x14, :lo12:gBbtInfo+32
.LBB63_7:                               // =>This Inner Loop Header: Depth=1
	orr	w15, w13, #0x1
	and	w16, w13, #0xffff
	and	w17, w8, #0xffff
	and	w18, w15, #0xffff
	udiv	w16, w16, w17
	udiv	w17, w18, w17
	msub	w18, w16, w8, w13
	ldr	x16, [x14, w16, uxtw #3]
	msub	w15, w17, w8, w15
	ldr	x17, [x14, w17, uxtw #3]
	lsr	w0, w18, #3
	lsr	w1, w15, #3
	and	x0, x0, #0x1ffc
	and	x1, x1, #0x1ffc
	ldr	w16, [x16, x0]
	ldr	w17, [x17, x1]
	add	w13, w13, #2                    // =2
	cmp	w10, w13
	lsr	w16, w16, w18
	lsr	w15, w17, w15
	and	w16, w16, #0x1
	and	w15, w15, #0x1
	add	w11, w11, w16
	add	w12, w12, w15
	b.ne	.LBB63_7
// %bb.8:
	cmp	w9, w10
	add	w0, w12, w11
	b.ne	.LBB63_10
	b	.LBB63_12
.LBB63_9:
	mov	w10, w0
.LBB63_10:
	adrp	x11, gBbtInfo
	add	x11, x11, :lo12:gBbtInfo
.LBB63_11:                              // =>This Inner Loop Header: Depth=1
	and	w12, w8, #0xffff
	and	w13, w10, #0xffff
	udiv	w12, w13, w12
	add	x13, x11, w12, uxtw #3
	ldr	x13, [x13, #32]
	msub	w12, w12, w8, w10
	lsr	w14, w12, #3
	and	x14, x14, #0x1ffc
	ldr	w13, [x13, x14]
	add	w10, w10, #1                    // =1
	cmp	w9, w10, uxth
	lsr	w12, w13, w12
	and	w12, w12, #0x1
	add	w0, w0, w12
	b.gt	.LBB63_11
.LBB63_12:
	hint	#29
	ret
.Lfunc_end63:
	.size	FtlBbtCalcTotleCnt, .Lfunc_end63-FtlBbtCalcTotleCnt
                                        // -- End function
	.globl	FtlGetLastWrittenPage           // -- Begin function FtlGetLastWrittenPage
	.p2align	2
	.type	FtlGetLastWrittenPage,@function
FtlGetLastWrittenPage:                  // @FtlGetLastWrittenPage
// %bb.0:
	hint	#25
	sub	sp, sp, #160                    // =160
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	adrp	x9, c_ftl_nand_page_pre_slc_blk
	adrp	x10, c_ftl_nand_page_pre_blk
	stp	x29, x30, [sp, #112]            // 16-byte Folded Spill
	add	x29, sp, #112                   // =112
	add	x9, x9, :lo12:c_ftl_nand_page_pre_slc_blk
	cmp	w1, #1                          // =1
	add	x10, x10, :lo12:c_ftl_nand_page_pre_blk
	stp	x22, x21, [sp, #128]            // 16-byte Folded Spill
	stp	x20, x19, [sp, #144]            // 16-byte Folded Spill
	stur	x8, [x29, #-8]
	adrp	x8, sftl_temp_buf
	csel	x9, x9, x10, eq
	ldr	x8, [x8, :lo12:sftl_temp_buf]
	ldrh	w9, [x9]
	add	x10, sp, #40                    // =40
	lsl	w20, w0, #10
	stp	x8, x10, [sp, #16]
	sub	w8, w9, #1                      // =1
	sxth	w19, w8
	orr	w8, w20, w19
	add	x0, sp, #8                      // =8
	mov	w1, #1
	str	w8, [sp, #12]
	bl	FlashReadPages
	ldr	w8, [sp, #40]
	cmn	w8, #1                          // =1
	b.ne	.LBB64_4
// %bb.1:
	tbnz	w19, #31, .LBB64_4
// %bb.2:
	mov	w21, wzr
.LBB64_3:                               // =>This Inner Loop Header: Depth=1
	sxth	w8, w21
	add	w8, w8, w19, sxth
	cmp	w8, #0                          // =0
	cinc	w8, w8, lt
	asr	w22, w8, #1
	orr	w8, w22, w20
	add	x0, sp, #8                      // =8
	mov	w1, #1
	str	w8, [sp, #12]
	bl	FlashReadPages
	ldp	w8, w9, [sp, #40]
	ldr	w10, [sp, #8]
	and	w8, w8, w9
	cmn	w8, #1                          // =1
	cset	w8, ne
	cmn	w10, #1                         // =1
	cset	w9, eq
	orr	w8, w8, w9
	sub	w9, w22, #1                     // =1
	cmp	w8, #0                          // =0
	csel	w8, w19, w9, ne
	csinc	w9, w21, w22, eq
	sxth	w19, w8
	sxth	w21, w9
	cmp	w21, w19
	b.le	.LBB64_3
.LBB64_4:
	adrp	x9, __stack_chk_guard
	ldur	x8, [x29, #-8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB64_6
// %bb.5:
	mov	w0, w19
	ldp	x20, x19, [sp, #144]            // 16-byte Folded Reload
	ldp	x22, x21, [sp, #128]            // 16-byte Folded Reload
	ldp	x29, x30, [sp, #112]            // 16-byte Folded Reload
	add	sp, sp, #160                    // =160
	hint	#29
	ret
.LBB64_6:
	bl	__stack_chk_fail
.Lfunc_end64:
	.size	FtlGetLastWrittenPage, .Lfunc_end64-FtlGetLastWrittenPage
                                        // -- End function
	.globl	FtlLoadFactoryBbt               // -- Begin function FtlLoadFactoryBbt
	.p2align	2
	.type	FtlLoadFactoryBbt,@function
FtlLoadFactoryBbt:                      // @FtlLoadFactoryBbt
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-96]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #80]             // 16-byte Folded Spill
	adrp	x8, p_sys_data_buf
	adrp	x9, p_sys_spare_buf
	adrp	x20, c_ftl_nand_die_num
	stp	x22, x21, [sp, #64]             // 16-byte Folded Spill
	ldr	x8, [x8, :lo12:p_sys_data_buf]
	ldr	x21, [x9, :lo12:p_sys_spare_buf]
	ldrh	w9, [x20, :lo12:c_ftl_nand_die_num]
	adrp	x10, req_sys+8
	add	x10, x10, :lo12:req_sys+8
	str	x27, [sp, #16]                  // 8-byte Folded Spill
	stp	x26, x25, [sp, #32]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #48]             // 16-byte Folded Spill
	mov	x29, sp
	stp	x8, x21, [x10]
	cbz	w9, .LBB65_8
// %bb.1:
	adrp	x23, gBbtInfo
	adrp	x19, req_sys
	mov	x22, xzr
	add	x23, x23, :lo12:gBbtInfo
	mov	w24, #65535
	adrp	x25, c_ftl_nand_blks_per_die
	add	x19, x19, :lo12:req_sys
	b	.LBB65_3
.LBB65_2:                               //   in Loop: Header=BB65_3 Depth=1
	ldrh	w8, [x20, :lo12:c_ftl_nand_die_num]
	add	x22, x22, #1                    // =1
	cmp	x22, x8
	b.hs	.LBB65_8
.LBB65_3:                               // =>This Loop Header: Depth=1
                                        //     Child Loop BB65_5 Depth 2
	ldrh	w8, [x25, :lo12:c_ftl_nand_blks_per_die]
	add	x26, x23, x22, lsl #1
	strh	w24, [x26, #12]!
	sub	w9, w8, #1                      // =1
	and	w27, w9, #0xffff
	sub	w9, w8, #16                     // =16
	cmp	w9, w27
	b.lt	.LBB65_5
	b	.LBB65_2
.LBB65_4:                               //   in Loop: Header=BB65_5 Depth=2
	ldrh	w8, [x25, :lo12:c_ftl_nand_blks_per_die]
	sub	w9, w27, #1                     // =1
	and	w27, w9, #0xffff
	sub	w9, w8, #16                     // =16
	cmp	w9, w27
	b.ge	.LBB65_2
.LBB65_5:                               //   Parent Loop BB65_3 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	madd	w8, w8, w22, w27
	lsl	w8, w8, #10
	mov	w1, #1
	mov	x0, x19
	str	w8, [x19, #4]
	bl	FlashReadPages
	ldr	w8, [x19]
	cmn	w8, #1                          // =1
	b.eq	.LBB65_4
// %bb.6:                               //   in Loop: Header=BB65_5 Depth=2
	ldrsh	w8, [x21]
	cmn	w8, #3872                       // =3872
	b.ne	.LBB65_4
// %bb.7:                               //   in Loop: Header=BB65_3 Depth=1
	strh	w27, [x26]
	b	.LBB65_2
.LBB65_8:
	ldp	x20, x19, [sp, #80]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             // 16-byte Folded Reload
	ldr	x27, [sp, #16]                  // 8-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #96             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end65:
	.size	FtlLoadFactoryBbt, .Lfunc_end65-FtlLoadFactoryBbt
                                        // -- End function
	.globl	FlashGetBadBlockList            // -- Begin function FlashGetBadBlockList
	.p2align	2
	.type	FlashGetBadBlockList,@function
FlashGetBadBlockList:                   // @FlashGetBadBlockList
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #16]             // 16-byte Folded Spill
	mov	x20, #-1
	stp	x20, x20, [x0, #240]
	stp	x20, x20, [x0, #224]
	stp	x20, x20, [x0, #208]
	stp	x20, x20, [x0, #192]
	stp	x20, x20, [x0, #176]
	stp	x20, x20, [x0, #160]
	stp	x20, x20, [x0, #144]
	stp	x20, x20, [x0, #128]
	stp	x20, x20, [x0, #112]
	stp	x20, x20, [x0, #96]
	stp	x20, x20, [x0, #80]
	stp	x20, x20, [x0, #64]
	stp	x20, x20, [x0, #48]
	stp	x20, x20, [x0, #32]
	stp	x20, x20, [x0, #16]
	stp	x20, x20, [x0]
	adrp	x8, g_nand_ops
	ldr	x8, [x8, :lo12:g_nand_ops]
	mov	x29, sp
	mov	x19, x0
	blr	x8
	and	w8, w0, #0xffff
	cmp	w8, #51                         // =51
	b.lo	.LBB66_2
// %bb.1:
	mov	w0, wzr
	stp	x20, x20, [x19, #240]
	stp	x20, x20, [x19, #224]
	stp	x20, x20, [x19, #208]
	stp	x20, x20, [x19, #192]
	stp	x20, x20, [x19, #176]
	stp	x20, x20, [x19, #160]
	stp	x20, x20, [x19, #144]
	stp	x20, x20, [x19, #128]
	stp	x20, x20, [x19, #112]
	stp	x20, x20, [x19, #96]
	stp	x20, x20, [x19, #80]
	stp	x20, x20, [x19, #64]
	stp	x20, x20, [x19, #48]
	stp	x20, x20, [x19, #32]
	stp	x20, x20, [x19, #16]
	stp	x20, x20, [x19]
	b	.LBB66_11
.LBB66_2:
	adrp	x8, g_nand_phy_info+14
	ldrh	w8, [x8, :lo12:g_nand_phy_info+14]
	cmp	w8, #4                          // =4
	b.ne	.LBB66_11
// %bb.3:
	tst	w0, #0xffff
	b.eq	.LBB66_11
// %bb.4:
	and	w8, w0, #0xffff
	cmp	w8, #2                          // =2
	b.hs	.LBB66_6
// %bb.5:
	mov	x9, xzr
	b	.LBB66_9
.LBB66_6:
	and	x9, x8, #0xfffe
	add	x10, x19, #2                    // =2
	mov	x11, x9
.LBB66_7:                               // =>This Inner Loop Header: Depth=1
	ldurh	w12, [x10, #-2]
	ldrh	w13, [x10]
	subs	x11, x11, #2                    // =2
	lsr	w12, w12, #1
	lsr	w13, w13, #1
	sturh	w12, [x10, #-2]
	strh	w13, [x10], #4
	b.ne	.LBB66_7
// %bb.8:
	cmp	x9, x8
	b.eq	.LBB66_11
.LBB66_9:
	add	x10, x19, x9, lsl #1
	sub	x8, x8, x9
.LBB66_10:                              // =>This Inner Loop Header: Depth=1
	ldrh	w9, [x10]
	subs	x8, x8, #1                      // =1
	lsr	w9, w9, #1
	strh	w9, [x10], #2
	b.ne	.LBB66_10
.LBB66_11:
	ldp	x20, x19, [sp, #16]             // 16-byte Folded Reload
	and	w0, w0, #0xffff
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end66:
	.size	FlashGetBadBlockList, .Lfunc_end66-FlashGetBadBlockList
                                        // -- End function
	.globl	FlashTestBlk                    // -- Begin function FlashTestBlk
	.p2align	2
	.type	FlashTestBlk,@function
FlashTestBlk:                           // @FlashTestBlk
// %bb.0:
	hint	#25
	sub	sp, sp, #144                    // =144
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	and	w9, w0, #0xffff
	stp	x29, x30, [sp, #112]            // 16-byte Folded Spill
	add	x29, sp, #112                   // =112
	cmp	w9, #12                         // =12
	stp	x20, x19, [sp, #128]            // 16-byte Folded Spill
	stur	x8, [x29, #-8]
	b.hs	.LBB67_2
// %bb.1:
	mov	w19, wzr
	b	.LBB67_6
.LBB67_2:
	adrp	x8, sftl_temp_buf
	mov	x10, #42405
	mov	x11, #23130
	ldr	x8, [x8, :lo12:sftl_temp_buf]
	movk	x10, #42405, lsl #16
	movk	x11, #23130, lsl #16
	movk	x10, #42405, lsl #32
	movk	x11, #23130, lsl #32
	add	x9, sp, #40                     // =40
	movk	x10, #42405, lsl #48
	movk	x11, #23130, lsl #48
	ubfiz	w20, w0, #10, #16
	add	x0, sp, #8                      // =8
	mov	w2, #1
	stp	x10, x10, [sp, #40]
	stp	x10, x10, [sp, #56]
	stp	x8, x9, [sp, #16]
	str	x11, [x8]
	str	w20, [sp, #12]
	bl	FlashEraseBlocks
	add	x0, sp, #8                      // =8
	mov	w1, #1
	mov	w2, #1
	bl	FlashProgPages
	ldr	w8, [sp, #8]
	cbz	w8, .LBB67_4
// %bb.3:
	mov	w19, #-1
	b	.LBB67_5
.LBB67_4:
	orr	w8, w20, #0x1
	add	x0, sp, #8                      // =8
	mov	w1, #1
	mov	w2, #1
	str	w8, [sp, #12]
	bl	FlashProgPages
	ldr	w8, [sp, #8]
	cmp	w8, #0                          // =0
	csetm	w19, ne
.LBB67_5:
	add	x0, sp, #8                      // =8
	mov	w2, #1
	str	w20, [sp, #12]
	bl	FlashEraseBlocks
.LBB67_6:
	adrp	x9, __stack_chk_guard
	ldur	x8, [x29, #-8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB67_8
// %bb.7:
	mov	w0, w19
	ldp	x20, x19, [sp, #128]            // 16-byte Folded Reload
	ldp	x29, x30, [sp, #112]            // 16-byte Folded Reload
	add	sp, sp, #144                    // =144
	hint	#29
	ret
.LBB67_8:
	bl	__stack_chk_fail
.Lfunc_end67:
	.size	FlashTestBlk, .Lfunc_end67-FlashTestBlk
                                        // -- End function
	.globl	P2V_plane                       // -- Begin function P2V_plane
	.p2align	2
	.type	P2V_plane,@function
P2V_plane:                              // @P2V_plane
// %bb.0:
	hint	#25
	adrp	x9, c_ftl_nand_planes_per_die
	adrp	x8, c_ftl_nand_blks_per_die
	ldrh	w9, [x9, :lo12:c_ftl_nand_planes_per_die]
	ldrh	w8, [x8, :lo12:c_ftl_nand_blks_per_die]
	and	w10, w0, #0xffff
	hint	#29
	udiv	w11, w10, w9
	udiv	w8, w10, w8
	msub	w10, w11, w9, w10
	madd	w0, w9, w8, w10
	ret
.Lfunc_end68:
	.size	P2V_plane, .Lfunc_end68-P2V_plane
                                        // -- End function
	.globl	ftl_cmp_data_ver                // -- Begin function ftl_cmp_data_ver
	.p2align	2
	.type	ftl_cmp_data_ver,@function
ftl_cmp_data_ver:                       // @ftl_cmp_data_ver
// %bb.0:
	hint	#25
	subs	w8, w0, w1
	mov	w9, #-2147483647
	sub	w10, w1, w0
	mov	w11, #-2147483648
	cmp	w8, w9
	cset	w8, lo
	cmp	w10, w11
	cset	w9, hi
	cmp	w0, w1
	csel	w0, w8, w9, hi
	hint	#29
	ret
.Lfunc_end69:
	.size	ftl_cmp_data_ver, .Lfunc_end69-ftl_cmp_data_ver
                                        // -- End function
	.globl	FtlFreeSysBlkQueueEmpty         // -- Begin function FtlFreeSysBlkQueueEmpty
	.p2align	2
	.type	FtlFreeSysBlkQueueEmpty,@function
FtlFreeSysBlkQueueEmpty:                // @FtlFreeSysBlkQueueEmpty
// %bb.0:
	hint	#25
	adrp	x8, gSysFreeQueue+6
	ldrh	w8, [x8, :lo12:gSysFreeQueue+6]
	hint	#29
	cmp	w8, #0                          // =0
	cset	w0, eq
	ret
.Lfunc_end70:
	.size	FtlFreeSysBlkQueueEmpty, .Lfunc_end70-FtlFreeSysBlkQueueEmpty
                                        // -- End function
	.globl	FtlFreeSysBlkQueueFull          // -- Begin function FtlFreeSysBlkQueueFull
	.p2align	2
	.type	FtlFreeSysBlkQueueFull,@function
FtlFreeSysBlkQueueFull:                 // @FtlFreeSysBlkQueueFull
// %bb.0:
	hint	#25
	adrp	x8, gSysFreeQueue+6
	ldrh	w8, [x8, :lo12:gSysFreeQueue+6]
	hint	#29
	cmp	w8, #1024                       // =1024
	cset	w0, eq
	ret
.Lfunc_end71:
	.size	FtlFreeSysBlkQueueFull, .Lfunc_end71-FtlFreeSysBlkQueueFull
                                        // -- End function
	.globl	FtlFreeSysBLkSort               // -- Begin function FtlFreeSysBLkSort
	.p2align	2
	.type	FtlFreeSysBLkSort,@function
FtlFreeSysBLkSort:                      // @FtlFreeSysBLkSort
// %bb.0:
	hint	#25
	adrp	x8, gSysFreeQueue+6
	ldrh	w8, [x8, :lo12:gSysFreeQueue+6]
	cbz	w8, .LBB72_5
// %bb.1:
	adrp	x8, g_sys_save_data+28
	ldrh	w8, [x8, :lo12:g_sys_save_data+28]
	and	w8, w8, #0x1f
	cbz	w8, .LBB72_5
// %bb.2:
	adrp	x9, gSysFreeQueue+2
	add	x9, x9, :lo12:gSysFreeQueue+2
	ldrh	w13, [x9]
	ldrh	w11, [x9, #2]
	adrp	x12, gSysFreeQueue+8
	mov	w10, wzr
	add	x12, x12, :lo12:gSysFreeQueue+8
.LBB72_3:                               // =>This Inner Loop Header: Depth=1
	and	x14, x13, #0xffff
	ldrh	w14, [x12, x14, lsl #1]
	add	w13, w13, #1                    // =1
	and	x15, x11, #0xffff
	add	w11, w11, #1                    // =1
	add	w10, w10, #1                    // =1
	and	w13, w13, #0x3ff
	cmp	w8, w10, uxth
	and	w11, w11, #0x3ff
	strh	w14, [x12, x15, lsl #1]
	b.hi	.LBB72_3
// %bb.4:
	strh	w13, [x9]
	strh	w11, [x9, #2]
.LBB72_5:
	hint	#29
	ret
.Lfunc_end72:
	.size	FtlFreeSysBLkSort, .Lfunc_end72-FtlFreeSysBLkSort
                                        // -- End function
	.globl	IsInFreeQueue                   // -- Begin function IsInFreeQueue
	.p2align	2
	.type	IsInFreeQueue,@function
IsInFreeQueue:                          // @IsInFreeQueue
// %bb.0:
	hint	#25
	adrp	x8, gSysFreeQueue+6
	ldrh	w8, [x8, :lo12:gSysFreeQueue+6]
	cmp	w8, #1024                       // =1024
	b.eq	.LBB73_5
// %bb.1:
	cbz	w8, .LBB73_5
// %bb.2:
	adrp	x9, gSysFreeQueue+2
	ldrh	w9, [x9, :lo12:gSysFreeQueue+2]
	adrp	x10, gSysFreeQueue
	add	x10, x10, :lo12:gSysFreeQueue
.LBB73_3:                               // =>This Inner Loop Header: Depth=1
	and	w11, w9, #0x3ff
	add	x11, x10, w11, uxtw #1
	ldrh	w11, [x11, #8]
	cmp	w11, w0, uxth
	b.eq	.LBB73_6
// %bb.4:                               //   in Loop: Header=BB73_3 Depth=1
	subs	w8, w8, #1                      // =1
	add	w9, w9, #1                      // =1
	b.ne	.LBB73_3
.LBB73_5:
	mov	w0, wzr
	hint	#29
	ret
.LBB73_6:
	mov	w0, #1
	hint	#29
	ret
.Lfunc_end73:
	.size	IsInFreeQueue, .Lfunc_end73-IsInFreeQueue
                                        // -- End function
	.globl	INSERT_FREE_LIST                // -- Begin function INSERT_FREE_LIST
	.p2align	2
	.type	INSERT_FREE_LIST,@function
INSERT_FREE_LIST:                       // @INSERT_FREE_LIST
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
                                        // kill: def $w0 killed $w0 def $x0
	mvn	w8, w0
	tst	w8, #0xffff
	mov	x29, sp
	b.eq	.LBB74_12
// %bb.1:
	adrp	x8, p_data_block_list_table
	ldr	x9, [x8, :lo12:p_data_block_list_table]
	and	x13, x0, #0xffff
	mov	w10, #6
	mov	w11, #-1
	madd	x9, x13, x10, x9
	mov	x10, x9
	str	w11, [x10], #2
	adrp	x12, p_free_data_block_list_head
	ldr	x11, [x12, :lo12:p_free_data_block_list_head]
	cbz	x11, .LBB74_11
// %bb.2:
	adrp	x15, p_erase_count_table
	ldr	x14, [x8, :lo12:p_data_block_list_table]
	ldr	x15, [x15, :lo12:p_erase_count_table]
	sub	x17, x11, x14
	ldrh	w16, [x15, x13, lsl #1]
	asr	x13, x17, #1
	mov	x17, #-6148914691236517206
	movk	x17, #43691
	mul	x13, x13, x17
	and	x17, x13, #0xffff
	ldrh	w17, [x15, x17, lsl #1]
                                        // kill: def $w13 killed $w13 killed $x13 def $x13
	cmp	w17, w16
	b.hs	.LBB74_8
// %bb.3:
	ldrh	w1, [x11]
	mov	w17, #65535
	cmp	w1, w17
	b.eq	.LBB74_7
// %bb.4:
	mov	w18, #6
.LBB74_5:                               // =>This Inner Loop Header: Depth=1
	mov	w13, w1
	and	x11, x13, #0xffff
	ldrh	w1, [x15, x11, lsl #1]
	madd	x11, x11, x18, x14
	cmp	w1, w16
	b.hs	.LBB74_8
// %bb.6:                               //   in Loop: Header=BB74_5 Depth=1
	ldrh	w1, [x11]
	cmp	w1, w17
	b.ne	.LBB74_5
.LBB74_7:
	strh	w13, [x10]
	strh	w0, [x11]
	b	.LBB74_12
.LBB74_8:
	ldrh	w14, [x11, #2]
	strh	w14, [x10]
	strh	w13, [x9]
	ldr	x10, [x12, :lo12:p_free_data_block_list_head]
	cmp	x11, x10
	b.eq	.LBB74_10
// %bb.9:
	ldrh	w9, [x11, #2]
	ldr	x8, [x8, :lo12:p_data_block_list_table]
	mov	w10, #6
	mul	x9, x9, x10
	strh	w0, [x8, x9]
	strh	w0, [x11, #2]
	b	.LBB74_12
.LBB74_10:
	strh	w0, [x11, #2]
.LBB74_11:
	str	x9, [x12, :lo12:p_free_data_block_list_head]
.LBB74_12:
	adrp	x8, g_num_free_superblocks
	ldrh	w9, [x8, :lo12:g_num_free_superblocks]
	adrp	x10, c_ftl_nand_data_blks_per_plane
	ldrh	w10, [x10, :lo12:c_ftl_nand_data_blks_per_plane]
	add	w9, w9, #1                      // =1
	strh	w9, [x8, :lo12:g_num_free_superblocks]
	cmp	w10, w9, uxth
	b.hs	.LBB74_14
// %bb.13:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.INSERT_FREE_LIST
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.INSERT_FREE_LIST
	mov	w2, #207
	bl	sftl_printk
.LBB74_14:
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end74:
	.size	INSERT_FREE_LIST, .Lfunc_end74-INSERT_FREE_LIST
                                        // -- End function
	.globl	insert_free_list                // -- Begin function insert_free_list
	.p2align	2
	.type	insert_free_list,@function
insert_free_list:                       // @insert_free_list
// %bb.0:
	hint	#25
                                        // kill: def $w0 killed $w0 def $x0
	mvn	w8, w0
	tst	w8, #0xffff
	b.eq	.LBB75_13
// %bb.1:
	adrp	x8, p_data_block_list_table
	ldr	x9, [x8, :lo12:p_data_block_list_table]
	and	x15, x0, #0xffff
	mov	w10, #6
	madd	x9, x15, x10, x9
	mov	w10, #-1
	mov	x11, x9
	str	w10, [x11], #2
	adrp	x10, p_free_data_block_list_head
	ldr	x12, [x10, :lo12:p_free_data_block_list_head]
	cbz	x12, .LBB75_12
// %bb.2:
	ldr	x13, [x8, :lo12:p_data_block_list_table]
	adrp	x14, p_erase_count_table
	ldr	x14, [x14, :lo12:p_erase_count_table]
	mov	x17, #-6148914691236517206
	sub	x16, x12, x13
	asr	x16, x16, #1
	movk	x17, #43691
	mul	x17, x16, x17
	and	x16, x17, #0xffff
	ldrh	w15, [x14, x15, lsl #1]
	ldrh	w16, [x14, x16, lsl #1]
	cmp	w16, w15
	b.hs	.LBB75_9
// %bb.3:
	ldrh	w16, [x12]
	mov	w18, #65535
	cmp	w16, w18
	b.eq	.LBB75_7
// %bb.4:
	mov	w1, #6
.LBB75_5:                               // =>This Inner Loop Header: Depth=1
	and	x12, x16, #0xffff
	ldrh	w17, [x14, x12, lsl #1]
	madd	x12, x12, x1, x13
	cmp	w17, w15
	b.hs	.LBB75_8
// %bb.6:                               //   in Loop: Header=BB75_5 Depth=1
	ldrh	w2, [x12]
	mov	w17, w16
	cmp	w2, w18
	mov	w16, w2
	b.ne	.LBB75_5
.LBB75_7:
	strh	w17, [x11]
	strh	w0, [x12]
	b	.LBB75_13
.LBB75_8:
	mov	w17, w16
.LBB75_9:
	ldrh	w13, [x12, #2]
	strh	w13, [x11]
	strh	w17, [x9]
	ldr	x11, [x10, :lo12:p_free_data_block_list_head]
	cmp	x12, x11
	b.eq	.LBB75_11
// %bb.10:
	ldrh	w9, [x12, #2]
	ldr	x8, [x8, :lo12:p_data_block_list_table]
	mov	w10, #6
	mul	x9, x9, x10
	strh	w0, [x8, x9]
	strh	w0, [x12, #2]
	b	.LBB75_13
.LBB75_11:
	strh	w0, [x12, #2]
.LBB75_12:
	str	x9, [x10, :lo12:p_free_data_block_list_head]
.LBB75_13:
	mov	w0, wzr
	hint	#29
	ret
.Lfunc_end75:
	.size	insert_free_list, .Lfunc_end75-insert_free_list
                                        // -- End function
	.globl	INSERT_DATA_LIST                // -- Begin function INSERT_DATA_LIST
	.p2align	2
	.type	INSERT_DATA_LIST,@function
INSERT_DATA_LIST:                       // @INSERT_DATA_LIST
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
	mov	x29, sp
	bl	insert_data_list
	adrp	x8, g_num_data_superblocks
	ldrh	w9, [x8, :lo12:g_num_data_superblocks]
	adrp	x10, c_ftl_nand_data_blks_per_plane
	ldrh	w10, [x10, :lo12:c_ftl_nand_data_blks_per_plane]
	add	w9, w9, #1                      // =1
	strh	w9, [x8, :lo12:g_num_data_superblocks]
	cmp	w10, w9, uxth
	b.hs	.LBB76_2
// %bb.1:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.INSERT_DATA_LIST
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.INSERT_DATA_LIST
	mov	w2, #214
	bl	sftl_printk
.LBB76_2:
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end76:
	.size	INSERT_DATA_LIST, .Lfunc_end76-INSERT_DATA_LIST
                                        // -- End function
	.globl	insert_data_list                // -- Begin function insert_data_list
	.p2align	2
	.type	insert_data_list,@function
insert_data_list:                       // @insert_data_list
// %bb.0:
	hint	#25
	adrp	x16, c_ftl_nand_data_blks_per_plane
	ldrh	w8, [x16, :lo12:c_ftl_nand_data_blks_per_plane]
                                        // kill: def $w0 killed $w0 def $x0
	cmp	w8, w0, uxth
	b.ls	.LBB77_14
// %bb.1:
	adrp	x8, p_data_block_list_table
	ldr	x15, [x8, :lo12:p_data_block_list_table]
	and	x17, x0, #0xffff
	mov	w9, #6
	mov	w10, #-1
	madd	x9, x17, x9, x15
	mov	x12, x9
	str	w10, [x12], #2
	adrp	x10, p_data_block_list_head
	ldr	x11, [x10, :lo12:p_data_block_list_head]
	cbz	x11, .LBB77_13
// %bb.2:
	adrp	x14, p_valid_page_count_table
	ldr	x14, [x14, :lo12:p_valid_page_count_table]
	ldr	x13, [x8, :lo12:p_data_block_list_table]
	mov	w18, #6
	madd	x15, x17, x18, x15
	ldrh	w15, [x15, #4]
	ldrh	w2, [x14, x17, lsl #1]
	mov	w1, #43691
	sub	x18, x11, x13
	movk	w1, #43690, lsl #16
	lsr	x17, x18, #1
	mul	w17, w17, w1
	cmp	w15, #0                         // =0
	mul	w15, w15, w2
	and	w18, w17, #0xffff
	csinv	w15, w15, wzr, ne
	cmp	w18, w0, uxth
	b.eq	.LBB77_14
// %bb.3:
	ldrh	w16, [x16, :lo12:c_ftl_nand_data_blks_per_plane]
	cbz	w16, .LBB77_14
// %bb.4:
	mov	w18, #1
	mov	w1, #65535
	mov	w2, #6
.LBB77_5:                               // =>This Inner Loop Header: Depth=1
	and	x3, x17, #0xffff
	ldrh	w4, [x11, #4]
	ldrh	w3, [x14, x3, lsl #1]
	cmp	w4, #0                          // =0
	mul	w3, w4, w3
	csinv	w3, w3, wzr, ne
	cmp	w3, w15
	b.hs	.LBB77_9
// %bb.6:                               //   in Loop: Header=BB77_5 Depth=1
	ldrh	w3, [x11]
	cmp	x3, x1
	b.eq	.LBB77_11
// %bb.7:                               //   in Loop: Header=BB77_5 Depth=1
	cmp	w3, w0, uxth
	b.eq	.LBB77_14
// %bb.8:                               //   in Loop: Header=BB77_5 Depth=1
	add	w18, w18, #1                    // =1
	cmp	w16, w18, uxth
	madd	x11, x3, x2, x13
	mov	w17, w3
	b.hs	.LBB77_5
	b	.LBB77_14
.LBB77_9:
	strh	w17, [x9]
	ldrh	w13, [x11, #2]
	strh	w13, [x12]
	ldr	x12, [x10, :lo12:p_data_block_list_head]
	cmp	x11, x12
	b.eq	.LBB77_12
// %bb.10:
	ldrh	w9, [x11, #2]
	ldr	x8, [x8, :lo12:p_data_block_list_table]
	mov	w10, #6
	mul	x9, x9, x10
	strh	w0, [x8, x9]
	strh	w0, [x11, #2]
	b	.LBB77_14
.LBB77_11:
	adrp	x8, p_data_block_list_tail
	strh	w17, [x12]
	strh	w0, [x11]
	str	x9, [x8, :lo12:p_data_block_list_tail]
	b	.LBB77_14
.LBB77_12:
	strh	w0, [x11, #2]
.LBB77_13:
	str	x9, [x10, :lo12:p_data_block_list_head]
.LBB77_14:
	mov	w0, wzr
	hint	#29
	ret
.Lfunc_end77:
	.size	insert_data_list, .Lfunc_end77-insert_data_list
                                        // -- End function
	.globl	List_remove_node                // -- Begin function List_remove_node
	.p2align	2
	.type	List_remove_node,@function
List_remove_node:                       // @List_remove_node
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-48]!           // 16-byte Folded Spill
	stp	x22, x21, [sp, #16]             // 16-byte Folded Spill
	adrp	x22, p_data_block_list_table
	ldr	x8, [x22, :lo12:p_data_block_list_table]
                                        // kill: def $w1 killed $w1 def $x1
	and	x9, x1, #0xffff
	mov	w10, #6
	stp	x20, x19, [sp, #32]             // 16-byte Folded Spill
	madd	x20, x9, x10, x8
	mov	x21, x20
	ldrsh	w8, [x21, #2]!
	mov	x19, x0
	mov	x29, sp
	cmn	w8, #1                          // =1
	b.ne	.LBB78_3
// %bb.1:
	ldr	x8, [x19]
	cmp	x20, x8
	b.eq	.LBB78_3
// %bb.2:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.List_remove_node
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.List_remove_node
	mov	w2, #372
	bl	sftl_printk
.LBB78_3:
	ldr	x9, [x19]
	ldrh	w8, [x20]
	cmp	x20, x9
	b.eq	.LBB78_6
// %bb.4:
	mov	w9, #65535
	cmp	w8, w9
	b.eq	.LBB78_8
// %bb.5:
	ldr	x9, [x22, :lo12:p_data_block_list_table]
	ldrh	w10, [x21]
	mov	w11, #6
	madd	x8, x8, x11, x9
	strh	w10, [x8, #2]
	ldrh	w9, [x21]
	ldr	x8, [x22, :lo12:p_data_block_list_table]
	ldrh	w10, [x20]
	mul	x9, x9, x11
	strh	w10, [x8, x9]
	b	.LBB78_11
.LBB78_6:
	mov	w9, #65535
	cmp	w8, w9
	b.eq	.LBB78_10
// %bb.7:
	ldr	x10, [x22, :lo12:p_data_block_list_table]
	mov	w11, #6
	madd	x8, x8, x11, x10
	str	x8, [x19]
	strh	w9, [x8, #2]
	b	.LBB78_11
.LBB78_8:
	ldrh	w8, [x21]
	mov	w9, #65535
	cmp	x8, x9
	b.eq	.LBB78_11
// %bb.9:
	ldr	x10, [x22, :lo12:p_data_block_list_table]
	mov	w11, #6
	mul	x8, x8, x11
	strh	w9, [x10, x8]
	b	.LBB78_11
.LBB78_10:
	str	xzr, [x19]
.LBB78_11:
	mov	w8, #65535
	strh	w8, [x20]
	strh	w8, [x21]
	ldp	x20, x19, [sp, #32]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #48             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end78:
	.size	List_remove_node, .Lfunc_end78-List_remove_node
                                        // -- End function
	.globl	List_pop_index_node             // -- Begin function List_pop_index_node
	.p2align	2
	.type	List_pop_index_node,@function
List_pop_index_node:                    // @List_pop_index_node
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-64]!           // 16-byte Folded Spill
	ldr	x8, [x0]
	str	x23, [sp, #16]                  // 8-byte Folded Spill
	stp	x22, x21, [sp, #32]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #48]             // 16-byte Folded Spill
	mov	x29, sp
	cbz	x8, .LBB79_11
// %bb.1:
	adrp	x20, p_data_block_list_table
	ldr	x9, [x20, :lo12:p_data_block_list_table]
	mov	x19, x0
	tst	w1, #0xffff
	mov	x12, x8
	b.eq	.LBB79_5
// %bb.2:
	mov	w10, #65535
	mov	w11, #6
	mov	x12, x8
.LBB79_3:                               // =>This Inner Loop Header: Depth=1
	ldrh	w13, [x12]
	cmp	x13, x10
	b.eq	.LBB79_5
// %bb.4:                               //   in Loop: Header=BB79_3 Depth=1
	sub	w1, w1, #1                      // =1
	tst	w1, #0xffff
	madd	x12, x13, x11, x9
	b.ne	.LBB79_3
.LBB79_5:
	sub	x10, x12, x9
	mov	x11, #-6148914691236517206
	movk	x11, #43691
	asr	x10, x10, #1
	mul	x21, x10, x11
	and	x10, x21, #0xffff
	mov	w11, #6
	madd	x22, x10, x11, x9
	mov	x23, x22
	ldrsh	w9, [x23, #2]!
	cmn	w9, #1                          // =1
	b.ne	.LBB79_8
// %bb.6:
	cmp	x22, x8
	b.eq	.LBB79_8
// %bb.7:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.List_remove_node
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.List_remove_node
	mov	w2, #372
	bl	sftl_printk
	ldr	x8, [x19]
.LBB79_8:
	ldrh	w9, [x22]
	cmp	x22, x8
	b.eq	.LBB79_12
// %bb.9:
	mov	w8, #65535
	cmp	w9, w8
	b.eq	.LBB79_14
// %bb.10:
	ldr	x8, [x20, :lo12:p_data_block_list_table]
	ldrh	w10, [x23]
	mov	w11, #6
	madd	x8, x9, x11, x8
	strh	w10, [x8, #2]
	ldrh	w9, [x23]
	ldr	x8, [x20, :lo12:p_data_block_list_table]
	ldrh	w10, [x22]
	mul	x9, x9, x11
	strh	w10, [x8, x9]
	b	.LBB79_17
.LBB79_11:
	mov	w0, #65535
	b	.LBB79_18
.LBB79_12:
	mov	w8, #65535
	cmp	w9, w8
	b.eq	.LBB79_16
// %bb.13:
	ldr	x10, [x20, :lo12:p_data_block_list_table]
	mov	w11, #6
	madd	x9, x9, x11, x10
	str	x9, [x19]
	strh	w8, [x9, #2]
	b	.LBB79_17
.LBB79_14:
	ldrh	w8, [x23]
	mov	w9, #65535
	cmp	x8, x9
	b.eq	.LBB79_17
// %bb.15:
	ldr	x10, [x20, :lo12:p_data_block_list_table]
	mov	w11, #6
	mul	x8, x8, x11
	strh	w9, [x10, x8]
	b	.LBB79_17
.LBB79_16:
	str	xzr, [x19]
.LBB79_17:
	mov	w8, #65535
	and	w0, w21, #0xffff
	strh	w8, [x22]
	strh	w8, [x23]
.LBB79_18:
	ldp	x20, x19, [sp, #48]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #32]             // 16-byte Folded Reload
	ldr	x23, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #64             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end79:
	.size	List_pop_index_node, .Lfunc_end79-List_pop_index_node
                                        // -- End function
	.globl	List_pop_head_node              // -- Begin function List_pop_head_node
	.p2align	2
	.type	List_pop_head_node,@function
List_pop_head_node:                     // @List_pop_head_node
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
	mov	w1, wzr
	mov	x29, sp
	bl	List_pop_index_node
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end80:
	.size	List_pop_head_node, .Lfunc_end80-List_pop_head_node
                                        // -- End function
	.globl	List_update_data_list           // -- Begin function List_update_data_list
	.p2align	2
	.type	List_update_data_list,@function
List_update_data_list:                  // @List_update_data_list
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-96]!           // 16-byte Folded Spill
	adrp	x8, g_active_superblock
	ldrh	w8, [x8, :lo12:g_active_superblock]
	stp	x28, x27, [sp, #16]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #32]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #48]             // 16-byte Folded Spill
	cmp	w8, w0, uxth
	stp	x22, x21, [sp, #64]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #80]             // 16-byte Folded Spill
	mov	x29, sp
	b.eq	.LBB81_25
// %bb.1:
	adrp	x8, g_buffer_superblock
	ldrh	w8, [x8, :lo12:g_buffer_superblock]
	mov	w19, w0
	cmp	w8, w0, uxth
	b.eq	.LBB81_25
// %bb.2:
	adrp	x8, g_gc_temp_superblock
	ldrh	w8, [x8, :lo12:g_gc_temp_superblock]
	cmp	w8, w19, uxth
	b.eq	.LBB81_25
// %bb.3:
	adrp	x20, p_data_block_list_table
	ldr	x8, [x20, :lo12:p_data_block_list_table]
	adrp	x21, p_data_block_list_head
	ldr	x9, [x21, :lo12:p_data_block_list_head]
	and	x22, x19, #0xffff
	mov	w10, #6
	madd	x25, x22, x10, x8
	cmp	x25, x9
	b.eq	.LBB81_25
// %bb.4:
	adrp	x23, p_valid_page_count_table
	ldr	x9, [x23, :lo12:p_valid_page_count_table]
	mov	w24, #6
	madd	x28, x22, x24, x8
	mov	w10, #65535
	ldrh	w8, [x9, x22, lsl #1]
	ldrh	w27, [x28, #2]!
	ldrh	w9, [x28, #2]
	mul	w8, w9, w8
	cmp	w9, #0                          // =0
	csinv	w26, w8, wzr, ne
	cmp	w27, w10
	b.ne	.LBB81_9
// %bb.5:
	ldrsh	w8, [x25]
	mov	w27, #65535
	cmn	w8, #1                          // =1
	b.ne	.LBB81_9
// %bb.6:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.List_update_data_list
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.List_update_data_list
	mov	w2, #463
	bl	sftl_printk
	ldrh	w8, [x28]
	cmp	w8, w27
	mov	w27, w8
	b.ne	.LBB81_9
// %bb.7:
	ldrsh	w8, [x25]
	cmn	w8, #1                          // =1
	b.eq	.LBB81_25
// %bb.8:
	mov	w27, #65535
.LBB81_9:
	ldr	x8, [x20, :lo12:p_data_block_list_table]
	ldr	x9, [x23, :lo12:p_valid_page_count_table]
	umaddl	x10, w27, w24, x8
	ldrh	w9, [x9, w27, uxtw #1]
	ldrh	w10, [x10, #4]
	mul	w9, w10, w9
	cmp	w10, #0                         // =0
	csinv	w9, w9, wzr, ne
	cmp	w26, w9
	b.hs	.LBB81_25
// %bb.10:
	mov	w9, #6
	madd	x22, x22, x9, x8
	mov	x23, x22
	ldrsh	w8, [x23, #2]!
	ldr	x9, [x21, :lo12:p_data_block_list_head]
	cmn	w8, #1                          // =1
	b.ne	.LBB81_13
// %bb.11:
	cmp	x22, x9
	b.eq	.LBB81_13
// %bb.12:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.List_remove_node
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.List_remove_node
	mov	w2, #372
	bl	sftl_printk
	ldr	x9, [x21, :lo12:p_data_block_list_head]
.LBB81_13:
	ldrh	w8, [x22]
	cmp	x22, x9
	b.eq	.LBB81_16
// %bb.14:
	mov	w9, #65535
	cmp	w8, w9
	b.eq	.LBB81_18
// %bb.15:
	ldr	x9, [x20, :lo12:p_data_block_list_table]
	ldrh	w10, [x23]
	mov	w11, #6
	madd	x8, x8, x11, x9
	strh	w10, [x8, #2]
	ldrh	w9, [x23]
	ldr	x8, [x20, :lo12:p_data_block_list_table]
	ldrh	w10, [x22]
	mul	x9, x9, x11
	strh	w10, [x8, x9]
	b	.LBB81_21
.LBB81_16:
	mov	w9, #65535
	cmp	w8, w9
	b.eq	.LBB81_20
// %bb.17:
	ldr	x10, [x20, :lo12:p_data_block_list_table]
	mov	w11, #6
	madd	x8, x8, x11, x10
	str	x8, [x21, :lo12:p_data_block_list_head]
	strh	w9, [x8, #2]
	b	.LBB81_21
.LBB81_18:
	ldrh	w8, [x23]
	mov	w9, #65535
	cmp	x8, x9
	b.eq	.LBB81_21
// %bb.19:
	ldr	x10, [x20, :lo12:p_data_block_list_table]
	mov	w11, #6
	mul	x8, x8, x11
	strh	w9, [x10, x8]
	b	.LBB81_21
.LBB81_20:
	str	xzr, [x21, :lo12:p_data_block_list_head]
.LBB81_21:
	mov	w8, #65535
	strh	w8, [x22]
	strh	w8, [x23]
	adrp	x20, g_num_data_superblocks
	ldrh	w8, [x20, :lo12:g_num_data_superblocks]
	cbnz	w8, .LBB81_23
// %bb.22:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.List_update_data_list
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.List_update_data_list
	mov	w2, #474
	bl	sftl_printk
	ldrh	w8, [x20, :lo12:g_num_data_superblocks]
.LBB81_23:
	sub	w8, w8, #1                      // =1
	mov	w0, w19
	strh	w8, [x20, :lo12:g_num_data_superblocks]
	bl	insert_data_list
	ldrh	w8, [x20, :lo12:g_num_data_superblocks]
	adrp	x9, c_ftl_nand_data_blks_per_plane
	ldrh	w9, [x9, :lo12:c_ftl_nand_data_blks_per_plane]
	add	w8, w8, #1                      // =1
	strh	w8, [x20, :lo12:g_num_data_superblocks]
	cmp	w9, w8, uxth
	b.hs	.LBB81_25
// %bb.24:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.INSERT_DATA_LIST
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.INSERT_DATA_LIST
	mov	w2, #214
	bl	sftl_printk
.LBB81_25:
	ldp	x20, x19, [sp, #80]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #96             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end81:
	.size	List_update_data_list, .Lfunc_end81-List_update_data_list
                                        // -- End function
	.globl	load_l2p_region                 // -- Begin function load_l2p_region
	.p2align	2
	.type	load_l2p_region,@function
load_l2p_region:                        // @load_l2p_region
// %bb.0:
	hint	#25
	sub	sp, sp, #112                    // =112
	stp	x24, x23, [sp, #64]             // 16-byte Folded Spill
	adrp	x24, c_ftl_nand_map_region_num
	ldrh	w8, [x24, :lo12:c_ftl_nand_map_region_num]
	stp	x20, x19, [sp, #96]             // 16-byte Folded Spill
	and	w20, w0, #0xffff
	stp	x22, x21, [sp, #80]             // 16-byte Folded Spill
	mov	w19, w0
	cmp	w8, w20
	mov	w22, w1
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	stp	x28, x27, [sp, #32]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #48]             // 16-byte Folded Spill
	add	x29, sp, #16                    // =16
	b.hs	.LBB82_2
// %bb.1:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.load_l2p_region
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.load_l2p_region
	mov	w2, #485
	bl	sftl_printk
.LBB82_2:
	adrp	x25, p_map_region_ppn_table
	ldr	x8, [x25, :lo12:p_map_region_ppn_table]
	and	x9, x19, #0xffff
	ldr	w21, [x8, x9, lsl #2]
	cbz	w21, .LBB82_6
// %bb.3:
	adrp	x26, p_l2p_ram_map
	ldr	x8, [x26, :lo12:p_l2p_ram_map]
	adrp	x23, req_sys
	add	x23, x23, :lo12:req_sys
	adrp	x9, p_sys_spare_buf
	str	w21, [x23, #4]
	add	x8, x8, w22, uxth #4
	ldr	x8, [x8, #8]
	ldr	x9, [x9, :lo12:p_sys_spare_buf]
	mov	w1, #1
	mov	x0, x23
	and	x22, x22, #0xffff
	stp	x8, x9, [x23, #8]
	bl	FlashReadPages
	ldr	x28, [x23, #16]
	ldrh	w8, [x28, #8]
	cmp	w8, w19, uxth
	b.ne	.LBB82_7
// %bb.4:
	adrp	x8, req_sys
	ldr	w8, [x8, :lo12:req_sys]
	cmp	w8, #256                        // =256
	b.ne	.LBB82_15
// %bb.5:
	adrp	x0, .L.str.90
	add	x0, x0, :lo12:.L.str.90
	mov	w1, w20
	mov	w2, w21
	bl	sftl_printk
	ldr	x8, [x26, :lo12:p_l2p_ram_map]
	adrp	x0, gL2pMapInfo
	add	x0, x0, :lo12:gL2pMapInfo
	mov	w1, w20
	add	x8, x8, x22, lsl #4
	ldr	x2, [x8, #8]
	bl	FtlMapWritePage
	b	.LBB82_15
.LBB82_6:
	adrp	x20, p_l2p_ram_map
	ldr	x8, [x20, :lo12:p_l2p_ram_map]
                                        // kill: def $w22 killed $w22 killed $x22 def $x22
	and	x9, x22, #0xffff
	lsl	x21, x9, #4
	adrp	x10, c_ftl_nand_byte_pre_page
	add	x8, x8, x21
	ldr	x0, [x8, #8]
	ldrh	w2, [x10, :lo12:c_ftl_nand_byte_pre_page]
	mov	w1, #255
	bl	memset
	ldr	x8, [x20, :lo12:p_l2p_ram_map]
	strh	w19, [x8, x21]
	ldr	x8, [x20, :lo12:p_l2p_ram_map]
	add	x8, x8, x21
	str	wzr, [x8, #4]
	b	.LBB82_18
.LBB82_7:
	adrp	x0, .L.str.87
	add	x0, x0, :lo12:.L.str.87
	mov	w1, w20
	mov	w2, w21
	str	x22, [sp, #8]                   // 8-byte Folded Spill
	bl	sftl_printk
	adrp	x8, req_sys+16
	ldr	x20, [x8, :lo12:req_sys+16]
	adrp	x0, .L.str.116
	adrp	x1, .L.str.88
	add	x0, x0, :lo12:.L.str.116
	add	x1, x1, :lo12:.L.str.88
	mov	x2, x20
	mov	w3, wzr
	bl	sftl_printk
	ldr	w1, [x20]
	adrp	x21, .L.str.117
	add	x21, x21, :lo12:.L.str.117
	mov	x0, x21
	bl	sftl_printk
	ldr	w1, [x20, #4]
	mov	x0, x21
	bl	sftl_printk
	ldr	w1, [x20, #8]
	mov	x0, x21
	bl	sftl_printk
	ldr	w1, [x20, #12]
	mov	x0, x21
	bl	sftl_printk
	adrp	x0, .L.str.120
	add	x0, x0, :lo12:.L.str.120
	bl	sftl_printk
	ldrh	w8, [x24, :lo12:c_ftl_nand_map_region_num]
	cbz	x8, .LBB82_14
// %bb.8:
	ldr	x21, [x25, :lo12:p_map_region_ppn_table]
	adrp	x22, .L.str.116
	adrp	x23, .L.str.89
	adrp	x24, .L.str.117
	adrp	x25, .L.str.120
	mov	x20, xzr
	mov	w27, wzr
	lsl	x26, x8, #2
	add	x22, x22, :lo12:.L.str.116
	add	x23, x23, :lo12:.L.str.89
	add	x24, x24, :lo12:.L.str.117
	add	x25, x25, :lo12:.L.str.120
	b	.LBB82_11
.LBB82_9:                               //   in Loop: Header=BB82_11 Depth=1
	ldr	w1, [x21, x20]
	mov	x0, x24
	bl	sftl_printk
	add	w27, w27, #1                    // =1
	cmp	w27, #16                        // =16
	b.hs	.LBB82_13
.LBB82_10:                              //   in Loop: Header=BB82_11 Depth=1
	add	x20, x20, #4                    // =4
	cmp	x26, x20
	b.eq	.LBB82_14
.LBB82_11:                              // =>This Inner Loop Header: Depth=1
	cbnz	w27, .LBB82_9
// %bb.12:                              //   in Loop: Header=BB82_11 Depth=1
	mov	x0, x22
	mov	x1, x23
	mov	x2, x21
	mov	w3, w20
	bl	sftl_printk
	b	.LBB82_9
.LBB82_13:                              //   in Loop: Header=BB82_11 Depth=1
	mov	x0, x25
	bl	sftl_printk
	mov	w27, wzr
	b	.LBB82_10
.LBB82_14:
	adrp	x0, .L.str.120
	add	x0, x0, :lo12:.L.str.120
	bl	sftl_printk
	ldr	x22, [sp, #8]                   // 8-byte Folded Reload
	adrp	x26, p_l2p_ram_map
.LBB82_15:
	ldrh	w8, [x28, #8]
	cmp	w8, w19, uxth
	b.eq	.LBB82_17
// %bb.16:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.load_l2p_region
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.load_l2p_region
	mov	w2, #508
	bl	sftl_printk
.LBB82_17:
	ldr	x8, [x26, :lo12:p_l2p_ram_map]
	lsl	x9, x22, #4
	add	x8, x8, x9
	str	wzr, [x8, #4]
	ldr	x8, [x26, :lo12:p_l2p_ram_map]
	strh	w19, [x8, x9]
.LBB82_18:
	ldp	x20, x19, [sp, #96]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	add	sp, sp, #112                    // =112
	hint	#29
	ret
.Lfunc_end82:
	.size	load_l2p_region, .Lfunc_end82-load_l2p_region
                                        // -- End function
	.globl	rknand_print_hex                // -- Begin function rknand_print_hex
	.p2align	2
	.type	rknand_print_hex,@function
rknand_print_hex:                       // @rknand_print_hex
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-96]!           // 16-byte Folded Spill
	stp	x28, x27, [sp, #16]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #32]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #48]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #64]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #80]             // 16-byte Folded Spill
	mov	x29, sp
	cbz	w3, .LBB83_12
// %bb.1:
	adrp	x23, .L.str.116
	adrp	x26, .L.str.117
	adrp	x27, .L.str.119
	mov	w19, w2
	mov	x20, x1
	mov	x21, x0
	mov	w22, wzr
	mov	x28, xzr
	mov	w25, wzr
	mov	w24, w3
	add	x23, x23, :lo12:.L.str.116
	add	x26, x26, :lo12:.L.str.117
	add	x27, x27, :lo12:.L.str.119
	b	.LBB83_5
.LBB83_2:                               //   in Loop: Header=BB83_5 Depth=1
	ldrb	w1, [x20, x28]
	mov	x0, x27
.LBB83_3:                               //   in Loop: Header=BB83_5 Depth=1
	bl	sftl_printk
	add	w25, w25, #1                    // =1
	cmp	w25, #16                        // =16
	b.hs	.LBB83_11
.LBB83_4:                               //   in Loop: Header=BB83_5 Depth=1
	add	x28, x28, #1                    // =1
	cmp	x24, x28
	add	w22, w22, w19
	b.eq	.LBB83_12
.LBB83_5:                               // =>This Inner Loop Header: Depth=1
	cbz	w25, .LBB83_9
// %bb.6:                               //   in Loop: Header=BB83_5 Depth=1
	cmp	w19, #2                         // =2
	b.eq	.LBB83_10
.LBB83_7:                               //   in Loop: Header=BB83_5 Depth=1
	cmp	w19, #4                         // =4
	b.ne	.LBB83_2
// %bb.8:                               //   in Loop: Header=BB83_5 Depth=1
	ldr	w1, [x20, x28, lsl #2]
	mov	x0, x26
	b	.LBB83_3
.LBB83_9:                               //   in Loop: Header=BB83_5 Depth=1
	mov	x0, x23
	mov	x1, x21
	mov	x2, x20
	mov	w3, w22
	bl	sftl_printk
	cmp	w19, #2                         // =2
	b.ne	.LBB83_7
.LBB83_10:                              //   in Loop: Header=BB83_5 Depth=1
	ldrh	w1, [x20, x28, lsl #1]
	adrp	x0, .L.str.118
	add	x0, x0, :lo12:.L.str.118
	b	.LBB83_3
.LBB83_11:                              //   in Loop: Header=BB83_5 Depth=1
	adrp	x0, .L.str.120
	add	x0, x0, :lo12:.L.str.120
	bl	sftl_printk
	mov	w25, wzr
	b	.LBB83_4
.LBB83_12:
	adrp	x0, .L.str.120
	add	x0, x0, :lo12:.L.str.120
	bl	sftl_printk
	ldp	x20, x19, [sp, #80]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #96             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end83:
	.size	rknand_print_hex, .Lfunc_end83-rknand_print_hex
                                        // -- End function
	.globl	FtlMapWritePage                 // -- Begin function FtlMapWritePage
	.p2align	2
	.type	FtlMapWritePage,@function
FtlMapWritePage:                        // @FtlMapWritePage
// %bb.0:
	hint	#25
	sub	sp, sp, #112                    // =112
	stp	x26, x25, [sp, #48]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #64]             // 16-byte Folded Spill
	adrp	x26, req_sys+4
	adrp	x24, req_sys
	stp	x28, x27, [sp, #32]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #80]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #96]             // 16-byte Folded Spill
	mov	x19, x2
	mov	w20, w1
	mov	x21, x0
	mov	w9, wzr
	mov	w27, w1
	adrp	x28, g_totle_l2p_write_count
	adrp	x25, c_ftl_nand_page_pre_slc_blk
	add	x26, x26, :lo12:req_sys+4
	adrp	x22, p_sys_spare_buf
	adrp	x23, c_ftl_nand_byte_pre_page
	add	x24, x24, :lo12:req_sys
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	add	x29, sp, #16                    // =16
.LBB84_1:                               // =>This Loop Header: Depth=1
                                        //     Child Loop BB84_3 Depth 2
                                        //       Child Loop BB84_12 Depth 3
	stur	w9, [x29, #-4]                  // 4-byte Folded Spill
	b	.LBB84_3
.LBB84_2:                               //   in Loop: Header=BB84_3 Depth=2
	str	wzr, [x21, #56]
.LBB84_3:                               //   Parent Loop BB84_1 Depth=1
                                        // =>  This Loop Header: Depth=2
                                        //       Child Loop BB84_12 Depth 3
	ldr	w8, [x28, :lo12:g_totle_l2p_write_count]
	add	w8, w8, #1                      // =1
	str	w8, [x28, :lo12:g_totle_l2p_write_count]
	ldrh	w8, [x25, :lo12:c_ftl_nand_page_pre_slc_blk]
	ldrh	w9, [x21, #2]
	sub	w8, w8, #1                      // =1
	cmp	w8, w9
	b.le	.LBB84_5
// %bb.4:                               //   in Loop: Header=BB84_3 Depth=2
	ldrh	w8, [x21]
	mov	w9, #65535
	cmp	w8, w9
	b.ne	.LBB84_6
.LBB84_5:                               //   in Loop: Header=BB84_3 Depth=2
	mov	x0, x21
	bl	Ftl_write_map_blk_to_last_page
	ldrh	w8, [x21]
.LBB84_6:                               //   in Loop: Header=BB84_3 Depth=2
	ldr	x9, [x21, #16]
	ldrh	w9, [x9, w8, uxtw #1]
	cbnz	w9, .LBB84_8
// %bb.7:                               //   in Loop: Header=BB84_3 Depth=2
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlMapWritePage
	mov	w2, #700
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlMapWritePage
	bl	sftl_printk
	ldrh	w8, [x21]
.LBB84_8:                               //   in Loop: Header=BB84_3 Depth=2
	ldrh	w9, [x21, #10]
	cmp	w8, w9
	b.lo	.LBB84_10
// %bb.9:                               //   in Loop: Header=BB84_3 Depth=2
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlMapWritePage
	mov	w2, #701
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlMapWritePage
	bl	sftl_printk
	ldrh	w8, [x21]
.LBB84_10:                              //   in Loop: Header=BB84_3 Depth=2
	ldr	x9, [x21, #16]
	ldr	x10, [x22, :lo12:p_sys_spare_buf]
	ldrh	w9, [x9, w8, uxtw #1]
	ldrh	w8, [x21, #2]
	stur	x19, [x26, #4]
	stur	x10, [x26, #12]
	orr	w8, w8, w9, lsl #10
	str	w8, [x26]
	stp	xzr, xzr, [x10]
	ldur	x8, [x26, #12]
	ldr	w10, [x21, #48]
	strh	w20, [x8, #8]
	str	w10, [x8, #4]
	ldrh	w10, [x21, #4]
	strh	w9, [x8, #2]
	strh	w10, [x8]
	ldrh	w9, [x23, :lo12:c_ftl_nand_byte_pre_page]
	mov	w10, #42982
	movk	w10, #18374, lsl #16
	cbz	x9, .LBB84_13
// %bb.11:                              //   in Loop: Header=BB84_3 Depth=2
	ldur	x11, [x26, #4]
	mov	w10, #42982
	movk	w10, #18374, lsl #16
.LBB84_12:                              //   Parent Loop BB84_1 Depth=1
                                        //     Parent Loop BB84_3 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	ldrb	w12, [x11], #1
	lsr	w13, w10, #2
	add	w13, w13, w10, lsl #5
	subs	x9, x9, #1                      // =1
	add	w12, w13, w12
	eor	w10, w12, w10
	b.ne	.LBB84_12
.LBB84_13:                              //   in Loop: Header=BB84_3 Depth=2
	mov	w1, #1
	mov	w2, #1
	mov	x0, x24
	str	w10, [x8, #12]
	bl	FlashProgPages
	ldrh	w8, [x21, #2]
	add	w8, w8, #1                      // =1
	strh	w8, [x21, #2]
	ldp	w8, w1, [x24]
	cmn	w8, #1                          // =1
	b.eq	.LBB84_17
// %bb.14:                              //   in Loop: Header=BB84_3 Depth=2
	ldr	x8, [x21, #40]
	str	w1, [x8, x27, lsl #2]
	ldrh	w8, [x21, #2]
	cmp	w8, #1                          // =1
	b.eq	.LBB84_2
// %bb.15:                              //   in Loop: Header=BB84_3 Depth=2
	adrp	x8, req_sys
	ldr	w8, [x8, :lo12:req_sys]
	cmp	w8, #256                        // =256
	b.eq	.LBB84_2
// %bb.16:                              //   in Loop: Header=BB84_3 Depth=2
	ldr	w9, [x21, #56]
	cbnz	w9, .LBB84_2
	b	.LBB84_22
.LBB84_17:                              //   in Loop: Header=BB84_1 Depth=1
	adrp	x0, .L.str.92
	add	x0, x0, :lo12:.L.str.92
	bl	sftl_printk
	ldrh	w8, [x21, #2]
	cmp	w8, #2                          // =2
	b.hi	.LBB84_19
// %bb.18:                              //   in Loop: Header=BB84_1 Depth=1
	ldrh	w8, [x25, :lo12:c_ftl_nand_page_pre_slc_blk]
	sub	w8, w8, #1                      // =1
	strh	w8, [x21, #2]
.LBB84_19:                              //   in Loop: Header=BB84_1 Depth=1
	ldur	w9, [x29, #-4]                  // 4-byte Folded Reload
	and	w8, w9, #0xffff
	cmp	w8, #3                          // =3
	b.hs	.LBB84_25
// %bb.20:                              //   in Loop: Header=BB84_1 Depth=1
	ldr	w8, [x21, #52]
	add	w9, w9, #1                      // =1
	cbz	w8, .LBB84_1
.LBB84_21:                              // =>This Inner Loop Header: Depth=1
	b	.LBB84_21
.LBB84_22:
	cmn	w8, #1                          // =1
	b.ne	.LBB84_24
// %bb.23:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlMapWritePage
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlMapWritePage
	mov	w2, #745
	bl	sftl_printk
.LBB84_24:
	ldp	x20, x19, [sp, #96]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	add	sp, sp, #112                    // =112
	hint	#29
	ret
.LBB84_25:
	adrp	x8, req_sys+4
	ldr	w1, [x8, :lo12:req_sys+4]
	adrp	x0, .L.str.93
	add	x0, x0, :lo12:.L.str.93
	mov	w2, #4
	bl	sftl_printk
.LBB84_26:                              // =>This Inner Loop Header: Depth=1
	b	.LBB84_26
.Lfunc_end84:
	.size	FtlMapWritePage, .Lfunc_end84-FtlMapWritePage
                                        // -- End function
	.globl	ftl_free_no_use_map_blk         // -- Begin function ftl_free_no_use_map_blk
	.p2align	2
	.type	ftl_free_no_use_map_blk,@function
ftl_free_no_use_map_blk:                // @ftl_free_no_use_map_blk
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-96]!           // 16-byte Folded Spill
	stp	x22, x21, [sp, #64]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #80]             // 16-byte Folded Spill
	ldrh	w8, [x0, #10]
	ldp	x20, x22, [x0, #32]
	ldr	x21, [x0, #16]
	mov	x19, x0
	lsl	x2, x8, #1
	mov	x0, x20
	mov	w1, wzr
	stp	x28, x27, [sp, #16]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #32]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #48]             // 16-byte Folded Spill
	mov	x29, sp
	bl	memset
	ldrh	w10, [x19, #6]
	cbz	w10, .LBB85_11
// %bb.1:
	ldrh	w9, [x19, #10]
	mov	x8, xzr
	mov	w11, w9
	b	.LBB85_4
.LBB85_2:                               //   in Loop: Header=BB85_4 Depth=1
	ldrh	w10, [x19, #6]
	mov	w11, w9
.LBB85_3:                               //   in Loop: Header=BB85_4 Depth=1
	add	x8, x8, #1                      // =1
	cmp	x8, w10, uxth
	b.hs	.LBB85_11
.LBB85_4:                               // =>This Loop Header: Depth=1
                                        //     Child Loop BB85_7 Depth 2
	tst	w11, #0xffff
	b.eq	.LBB85_10
// %bb.5:                               //   in Loop: Header=BB85_4 Depth=1
	ldr	w10, [x22, x8, lsl #2]
	mov	x11, xzr
	b	.LBB85_7
.LBB85_6:                               //   in Loop: Header=BB85_7 Depth=2
	add	x11, x11, #1                    // =1
	cmp	x11, w9, uxth
	b.hs	.LBB85_2
.LBB85_7:                               //   Parent Loop BB85_4 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldrh	w12, [x21, x11, lsl #1]
	lsr	w13, w10, #10
	cmp	w12, w13, uxth
	b.ne	.LBB85_6
// %bb.8:                               //   in Loop: Header=BB85_7 Depth=2
	cbz	w12, .LBB85_6
// %bb.9:                               //   in Loop: Header=BB85_7 Depth=2
	lsl	x9, x11, #1
	ldrh	w12, [x20, x9]
	add	w12, w12, #1                    // =1
	strh	w12, [x20, x9]
	ldrh	w9, [x19, #10]
	b	.LBB85_6
.LBB85_10:                              //   in Loop: Header=BB85_4 Depth=1
	mov	w11, wzr
	b	.LBB85_3
.LBB85_11:
	adrp	x8, c_ftl_nand_page_pre_slc_blk
	ldrh	w8, [x8, :lo12:c_ftl_nand_page_pre_slc_blk]
	ldrh	w9, [x19]
	strh	w8, [x20, x9, lsl #1]
	ldrh	w8, [x19, #10]
	cbz	w8, .LBB85_23
// %bb.12:
	ldrh	w9, [x20], #2
	adrp	x26, gSysFreeQueue
	mov	x23, xzr
	mov	w22, wzr
	mov	w11, #65535
	adrp	x27, g_totle_sys_slc_erase_count
	add	x26, x26, :lo12:gSysFreeQueue
	mov	w24, w9
.LBB85_13:                              // =>This Inner Loop Header: Depth=1
	and	w10, w24, #0xffff
	cmp	w10, w9, uxth
	b.ls	.LBB85_15
// %bb.14:                              //   in Loop: Header=BB85_13 Depth=1
	ldrh	w10, [x21, x23, lsl #1]
	cmp	w10, #0                         // =0
	csel	w24, w24, w9, eq
	csel	w22, w22, w23, eq
.LBB85_15:                              //   in Loop: Header=BB85_13 Depth=1
	tst	w9, #0xffff
	b.ne	.LBB85_21
// %bb.16:                              //   in Loop: Header=BB85_13 Depth=1
	ldrh	w25, [x21, x23, lsl #1]
	cbz	w25, .LBB85_21
// %bb.17:                              //   in Loop: Header=BB85_13 Depth=1
	cmp	w25, w11
	b.eq	.LBB85_20
// %bb.18:                              //   in Loop: Header=BB85_13 Depth=1
	adrp	x8, gSysFreeQueue+6
	ldrh	w8, [x8, :lo12:gSysFreeQueue+6]
	cmp	w8, #1024                       // =1024
	b.eq	.LBB85_20
// %bb.19:                              //   in Loop: Header=BB85_13 Depth=1
	adrp	x12, req_erase
	ldr	x8, [x12, :lo12:req_erase]
	adrp	x9, c_ftl_nand_blks_per_die
	ldrh	w9, [x9, :lo12:c_ftl_nand_blks_per_die]
	adrp	x10, c_ftl_nand_planes_per_die
	lsl	w11, w25, #10
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_per_die]
	str	w11, [x8, #4]
	ldr	x0, [x12, :lo12:req_erase]
	udiv	w8, w25, w9
	msub	w8, w8, w9, w25
	mov	w2, #1
	udiv	w28, w8, w10
	bl	FlashEraseBlocks
	adrp	x8, p_erase_count_table
	ldr	x8, [x8, :lo12:p_erase_count_table]
	lsl	x9, x28, #1
	mov	w11, #65535
	ldrh	w10, [x8, x9]
	add	w10, w10, #1                    // =1
	strh	w10, [x8, x9]
	ldr	w8, [x27, :lo12:g_totle_sys_slc_erase_count]
	ldrh	w9, [x26, #6]
	ldrh	w10, [x26, #4]
	add	w8, w8, #1                      // =1
	add	w9, w9, #1                      // =1
	str	w8, [x27, :lo12:g_totle_sys_slc_erase_count]
	add	x8, x26, x10, lsl #1
	add	w10, w10, #1                    // =1
	strh	w9, [x26, #6]
	strh	w25, [x8, #8]
	and	w8, w10, #0x3ff
	strh	w8, [x26, #4]
.LBB85_20:                              //   in Loop: Header=BB85_13 Depth=1
	strh	wzr, [x21, x23, lsl #1]
	ldrh	w9, [x19, #8]
	ldrh	w8, [x19, #10]
	sub	w9, w9, #1                      // =1
	strh	w9, [x19, #8]
.LBB85_21:                              //   in Loop: Header=BB85_13 Depth=1
	add	x10, x23, #1                    // =1
	cmp	x10, w8, uxth
	b.hs	.LBB85_24
// %bb.22:                              //   in Loop: Header=BB85_13 Depth=1
	ldrh	w9, [x20, x23, lsl #1]
	mov	x23, x10
	b	.LBB85_13
.LBB85_23:
	mov	w22, wzr
.LBB85_24:
	and	w0, w22, #0xffff
	ldp	x20, x19, [sp, #80]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #96             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end85:
	.size	ftl_free_no_use_map_blk, .Lfunc_end85-ftl_free_no_use_map_blk
                                        // -- End function
	.globl	ftl_map_blk_alloc_new_blk       // -- Begin function ftl_map_blk_alloc_new_blk
	.p2align	2
	.type	ftl_map_blk_alloc_new_blk,@function
ftl_map_blk_alloc_new_blk:              // @ftl_map_blk_alloc_new_blk
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-64]!           // 16-byte Folded Spill
	ldrh	w8, [x0, #10]
	stp	x24, x23, [sp, #16]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #32]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #48]             // 16-byte Folded Spill
	mov	x29, sp
	cbz	x8, .LBB86_5
// %bb.1:
	ldr	x22, [x0, #16]
	mov	x19, x0
	mov	x21, xzr
.LBB86_2:                               // =>This Inner Loop Header: Depth=1
	ldrh	w9, [x22, x21, lsl #1]
	cbz	w9, .LBB86_7
// %bb.3:                               //   in Loop: Header=BB86_2 Depth=1
	add	x21, x21, #1                    // =1
	cmp	x21, x8
	b.lo	.LBB86_2
// %bb.4:
	cmp	w8, w21, uxth
	b.hi	.LBB86_6
.LBB86_5:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.ftl_map_blk_alloc_new_blk
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.ftl_map_blk_alloc_new_blk
	mov	w2, #578
	bl	sftl_printk
.LBB86_6:
	ldp	x20, x19, [sp, #48]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #32]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #64             // 16-byte Folded Reload
	hint	#29
	ret
.LBB86_7:
	adrp	x23, gSysFreeQueue+6
	ldrh	w8, [x23, :lo12:gSysFreeQueue+6]
	mov	w24, #65535
	cbz	w8, .LBB86_11
// %bb.8:
	adrp	x9, gSysFreeQueue
	add	x9, x9, :lo12:gSysFreeQueue
	ldrh	w10, [x9, #2]
	sub	w8, w8, #1                      // =1
	mov	w2, #1
	add	x11, x9, x10, lsl #1
	ldrh	w20, [x11, #8]
	strh	w8, [x9, #6]
	adrp	x8, req_erase
	ldr	x11, [x8, :lo12:req_erase]
	add	w10, w10, #1                    // =1
	and	w10, w10, #0x3ff
	strh	w10, [x9, #2]
	lsl	w9, w20, #10
	str	w9, [x11, #4]
	ldr	x0, [x8, :lo12:req_erase]
	bl	FlashEraseBlocks
	adrp	x8, g_totle_sys_slc_erase_count
	ldr	w9, [x8, :lo12:g_totle_sys_slc_erase_count]
	cmp	w20, w24
	add	w9, w9, #1                      // =1
	str	w9, [x8, :lo12:g_totle_sys_slc_erase_count]
	b.eq	.LBB86_12
// %bb.9:
	cbz	w20, .LBB86_12
// %bb.10:
	strh	w20, [x22, x21, lsl #1]
	ldr	w9, [x19, #48]
	ldrh	w10, [x19, #8]
	ldrh	w8, [x19, #10]
	strh	wzr, [x19, #2]
	add	w9, w9, #1                      // =1
	add	w10, w10, #1                    // =1
	strh	w21, [x19]
	str	w9, [x19, #48]
	strh	w10, [x19, #8]
	cmp	w8, w21, uxth
	b.ls	.LBB86_5
	b	.LBB86_6
.LBB86_11:
	mov	w20, #65535
.LBB86_12:
	ldrh	w2, [x23, :lo12:gSysFreeQueue+6]
	adrp	x0, .L.str.86
	add	x0, x0, :lo12:.L.str.86
	mov	w1, w20
	bl	sftl_printk
.LBB86_13:                              // =>This Inner Loop Header: Depth=1
	b	.LBB86_13
.Lfunc_end86:
	.size	ftl_map_blk_alloc_new_blk, .Lfunc_end86-ftl_map_blk_alloc_new_blk
                                        // -- End function
	.globl	ftl_map_blk_gc                  // -- Begin function ftl_map_blk_gc
	.p2align	2
	.type	ftl_map_blk_gc,@function
ftl_map_blk_gc:                         // @ftl_map_blk_gc
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-96]!           // 16-byte Folded Spill
	stp	x26, x25, [sp, #32]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #80]             // 16-byte Folded Spill
	ldr	x20, [x0, #16]
	ldr	x26, [x0, #40]
	stp	x28, x27, [sp, #16]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #48]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #64]             // 16-byte Folded Spill
	mov	x29, sp
	mov	x19, x0
	bl	ftl_free_no_use_map_blk
	ldrh	w8, [x19, #10]
	ldrh	w9, [x19, #8]
	adrp	x24, c_ftl_nand_page_pre_slc_blk
	sub	w8, w8, #5                      // =5
	cmp	w8, w9
	b.gt	.LBB87_20
// %bb.1:
	and	w8, w0, #0xffff
	ldrh	w25, [x20, w8, uxtw #1]
	cbz	w25, .LBB87_20
// %bb.2:
	ldr	w9, [x19, #52]
	cbnz	w9, .LBB87_20
// %bb.3:
	mov	w9, #1
	str	w9, [x19, #52]
	strh	wzr, [x20, x8, lsl #1]
	ldrh	w8, [x19, #8]
	sub	w8, w8, #1                      // =1
	strh	w8, [x19, #8]
	ldrh	w8, [x19, #2]
	ldrh	w9, [x24, :lo12:c_ftl_nand_page_pre_slc_blk]
	cmp	w8, w9
	b.lo	.LBB87_5
// %bb.4:
	mov	x0, x19
	bl	ftl_map_blk_alloc_new_blk
.LBB87_5:
	ldrh	w8, [x19, #6]
	cbz	w8, .LBB87_15
// %bb.6:
	adrp	x21, req_sys
	mov	x20, xzr
	adrp	x27, p_sys_data_buf_1
	add	x21, x21, :lo12:req_sys
	adrp	x28, p_sys_spare_buf
	adrp	x22, req_sys
	b	.LBB87_8
.LBB87_7:                               //   in Loop: Header=BB87_8 Depth=1
	add	x20, x20, #1                    // =1
	cmp	x20, w8, uxth
	b.hs	.LBB87_15
.LBB87_8:                               // =>This Inner Loop Header: Depth=1
	ldr	w9, [x26, x20, lsl #2]
	cmp	w25, w9, lsr #10
	b.ne	.LBB87_7
// %bb.9:                               //   in Loop: Header=BB87_8 Depth=1
	ldr	x8, [x27, :lo12:p_sys_data_buf_1]
	ldr	x23, [x28, :lo12:p_sys_spare_buf]
	mov	w1, #1
	mov	x0, x21
	stp	x8, x23, [x21, #8]
	ldr	w8, [x26, x20, lsl #2]
	str	w8, [x21, #4]
	bl	FlashReadPages
	ldrh	w8, [x23, #8]
	cmp	x20, x8
	b.eq	.LBB87_11
// %bb.10:                              //   in Loop: Header=BB87_8 Depth=1
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.ftl_map_blk_gc
	mov	w2, #611
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.ftl_map_blk_gc
	bl	sftl_printk
.LBB87_11:                              //   in Loop: Header=BB87_8 Depth=1
	ldr	w8, [x22, :lo12:req_sys]
	cmn	w8, #1                          // =1
	b.eq	.LBB87_23
// %bb.12:                              //   in Loop: Header=BB87_8 Depth=1
	ldrh	w8, [x23, #8]
	cmp	x20, x8
	b.ne	.LBB87_23
// %bb.13:                              //   in Loop: Header=BB87_8 Depth=1
	ldrh	w8, [x23]
	ldrh	w9, [x19, #4]
	cmp	w8, w9
	b.ne	.LBB87_23
// %bb.14:                              //   in Loop: Header=BB87_8 Depth=1
	adrp	x8, req_sys+8
	ldr	x2, [x8, :lo12:req_sys+8]
	mov	x0, x19
	mov	w1, w20
	bl	FtlMapWritePage
	ldrh	w8, [x19, #6]
	b	.LBB87_7
.LBB87_15:
	cbz	w25, .LBB87_19
// %bb.16:
	mov	w8, #65535
	cmp	w25, w8
	b.eq	.LBB87_19
// %bb.17:
	adrp	x8, gSysFreeQueue+6
	ldrh	w8, [x8, :lo12:gSysFreeQueue+6]
	cmp	w8, #1024                       // =1024
	b.eq	.LBB87_19
// %bb.18:
	adrp	x9, req_erase
	ldr	x10, [x9, :lo12:req_erase]
	adrp	x8, c_ftl_nand_blks_per_die
	ldrh	w8, [x8, :lo12:c_ftl_nand_blks_per_die]
	adrp	x11, c_ftl_nand_planes_per_die
	lsl	w12, w25, #10
	ldrh	w11, [x11, :lo12:c_ftl_nand_planes_per_die]
	str	w12, [x10, #4]
	ldr	x0, [x9, :lo12:req_erase]
	udiv	w9, w25, w8
	msub	w8, w9, w8, w25
	mov	w2, #1
	udiv	w20, w8, w11
	bl	FlashEraseBlocks
	adrp	x8, p_erase_count_table
	ldr	x8, [x8, :lo12:p_erase_count_table]
	lsl	x9, x20, #1
	adrp	x11, g_totle_sys_slc_erase_count
	ldrh	w10, [x8, x9]
	add	w10, w10, #1                    // =1
	strh	w10, [x8, x9]
	adrp	x9, gSysFreeQueue
	ldr	w8, [x11, :lo12:g_totle_sys_slc_erase_count]
	add	x9, x9, :lo12:gSysFreeQueue
	ldrh	w10, [x9, #6]
	ldrh	w12, [x9, #4]
	add	w8, w8, #1                      // =1
	str	w8, [x11, :lo12:g_totle_sys_slc_erase_count]
	add	w8, w10, #1                     // =1
	strh	w8, [x9, #6]
	add	x8, x9, x12, lsl #1
	add	w10, w12, #1                    // =1
	strh	w25, [x8, #8]
	and	w8, w10, #0x3ff
	strh	w8, [x9, #4]
.LBB87_19:
	str	wzr, [x19, #52]
.LBB87_20:
	ldrh	w8, [x19, #2]
	ldrh	w9, [x24, :lo12:c_ftl_nand_page_pre_slc_blk]
	cmp	w8, w9
	b.lo	.LBB87_22
// %bb.21:
	mov	x0, x19
	bl	ftl_map_blk_alloc_new_blk
.LBB87_22:
	ldp	x20, x19, [sp, #80]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #96             // 16-byte Folded Reload
	hint	#29
	ret
.LBB87_23:
	str	wzr, [x26, x20, lsl #2]
.LBB87_24:                              // =>This Inner Loop Header: Depth=1
	b	.LBB87_24
.Lfunc_end87:
	.size	ftl_map_blk_gc, .Lfunc_end87-ftl_map_blk_gc
                                        // -- End function
	.globl	Ftl_write_map_blk_to_last_page  // -- Begin function Ftl_write_map_blk_to_last_page
	.p2align	2
	.type	Ftl_write_map_blk_to_last_page,@function
Ftl_write_map_blk_to_last_page:         // @Ftl_write_map_blk_to_last_page
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-64]!           // 16-byte Folded Spill
	ldrh	w8, [x0]
	stp	x22, x21, [sp, #32]             // 16-byte Folded Spill
	ldr	x22, [x0, #16]
	mov	w9, #65535
	stp	x20, x19, [sp, #48]             // 16-byte Folded Spill
	mov	x19, x0
	cmp	x8, x9
	str	x23, [sp, #16]                  // 8-byte Folded Spill
	mov	x29, sp
	b.eq	.LBB88_11
// %bb.1:
	ldrh	w22, [x22, x8, lsl #1]
	ldrh	w8, [x19, #2]
	adrp	x23, p_sys_data_buf
	adrp	x10, p_sys_spare_buf
	ldr	x11, [x23, :lo12:p_sys_data_buf]
	ldr	x20, [x10, :lo12:p_sys_spare_buf]
	adrp	x9, req_sys+4
	add	x9, x9, :lo12:req_sys+4
	orr	w8, w8, w22, lsl #10
	ldr	x21, [x19, #40]
	str	w8, [x9]
	stur	x11, [x9, #4]
	stur	x20, [x9, #12]
	ldr	w8, [x19, #48]
	mov	w9, #64245
	strh	w9, [x20, #8]
	mov	w1, #255
	str	w8, [x20, #4]
	ldrh	w8, [x19, #4]
	strh	w22, [x20, #2]
	strh	w8, [x20]
	adrp	x8, c_ftl_nand_page_pre_slc_blk
	ldrh	w8, [x8, :lo12:c_ftl_nand_page_pre_slc_blk]
	ldr	x0, [x23, :lo12:p_sys_data_buf]
	lsl	x2, x8, #3
	bl	memset
	ldrh	w10, [x19, #6]
	cbz	w10, .LBB88_6
// %bb.2:
	mov	x8, xzr
	mov	w9, wzr
	b	.LBB88_4
.LBB88_3:                               //   in Loop: Header=BB88_4 Depth=1
	add	x8, x8, #1                      // =1
	cmp	x8, w10, uxth
	b.hs	.LBB88_6
.LBB88_4:                               // =>This Inner Loop Header: Depth=1
	ldr	w11, [x21, x8, lsl #2]
	cmp	w22, w11, lsr #10
	b.ne	.LBB88_3
// %bb.5:                               //   in Loop: Header=BB88_4 Depth=1
	ldr	x10, [x23, :lo12:p_sys_data_buf]
	add	w9, w9, #1                      // =1
	and	w11, w9, #0xffff
	lsl	w12, w11, #1
	str	w8, [x10, w12, uxtw #2]
	ldr	w10, [x21, x8, lsl #2]
	ldr	x12, [x23, :lo12:p_sys_data_buf]
	mov	w13, #1
	bfi	w13, w11, #1, #16
	str	w10, [x12, w13, uxtw #2]
	ldrh	w10, [x19, #6]
	b	.LBB88_3
.LBB88_6:
	adrp	x8, c_ftl_nand_byte_pre_page
	ldrh	w9, [x8, :lo12:c_ftl_nand_byte_pre_page]
	mov	w8, #42982
	movk	w8, #18374, lsl #16
	cbz	x9, .LBB88_9
// %bb.7:
	adrp	x10, req_sys+8
	ldr	x10, [x10, :lo12:req_sys+8]
.LBB88_8:                               // =>This Inner Loop Header: Depth=1
	ldrb	w11, [x10], #1
	lsr	w12, w8, #2
	add	w12, w12, w8, lsl #5
	subs	x9, x9, #1                      // =1
	add	w11, w12, w11
	eor	w8, w11, w8
	b.ne	.LBB88_8
.LBB88_9:
	adrp	x0, req_sys
	add	x0, x0, :lo12:req_sys
	mov	w1, #1
	mov	w2, #1
	str	w8, [x20, #12]
	bl	FlashProgPages
	ldrh	w8, [x19, #2]
	mov	x0, x19
	add	w8, w8, #1                      // =1
	strh	w8, [x19, #2]
	bl	ftl_map_blk_gc
.LBB88_10:
	ldp	x20, x19, [sp, #48]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #32]             // 16-byte Folded Reload
	ldr	x23, [sp, #16]                  // 8-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #64             // 16-byte Folded Reload
	hint	#29
	ret
.LBB88_11:
	ldrh	w8, [x19, #8]
	cbz	w8, .LBB88_13
// %bb.12:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.Ftl_write_map_blk_to_last_page
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.Ftl_write_map_blk_to_last_page
	mov	w2, #641
	bl	sftl_printk
	ldrh	w8, [x19, #8]
	add	w8, w8, #1                      // =1
	b	.LBB88_14
.LBB88_13:
	mov	w8, #1
.LBB88_14:
	strh	w8, [x19, #8]
	adrp	x21, gSysFreeQueue+6
	ldrh	w8, [x21, :lo12:gSysFreeQueue+6]
	mov	w23, #65535
	cbz	w8, .LBB88_18
// %bb.15:
	adrp	x9, gSysFreeQueue
	add	x9, x9, :lo12:gSysFreeQueue
	ldrh	w10, [x9, #2]
	sub	w8, w8, #1                      // =1
	mov	w2, #1
	add	x11, x9, x10, lsl #1
	ldrh	w20, [x11, #8]
	strh	w8, [x9, #6]
	adrp	x8, req_erase
	ldr	x11, [x8, :lo12:req_erase]
	add	w10, w10, #1                    // =1
	and	w10, w10, #0x3ff
	strh	w10, [x9, #2]
	lsl	w9, w20, #10
	str	w9, [x11, #4]
	ldr	x0, [x8, :lo12:req_erase]
	bl	FlashEraseBlocks
	adrp	x8, g_totle_sys_slc_erase_count
	ldr	w9, [x8, :lo12:g_totle_sys_slc_erase_count]
	cmp	w20, w23
	add	w9, w9, #1                      // =1
	str	w9, [x8, :lo12:g_totle_sys_slc_erase_count]
	b.eq	.LBB88_19
// %bb.16:
	cbz	w20, .LBB88_19
// %bb.17:
	strh	w20, [x22]
	ldr	w8, [x19, #48]
	str	wzr, [x19]
	add	w8, w8, #1                      // =1
	str	w8, [x19, #48]
	b	.LBB88_10
.LBB88_18:
	mov	w20, #65535
.LBB88_19:
	ldrh	w2, [x21, :lo12:gSysFreeQueue+6]
	adrp	x0, .L.str.86
	add	x0, x0, :lo12:.L.str.86
	mov	w1, w20
	bl	sftl_printk
.LBB88_20:                              // =>This Inner Loop Header: Depth=1
	b	.LBB88_20
.Lfunc_end88:
	.size	Ftl_write_map_blk_to_last_page, .Lfunc_end88-Ftl_write_map_blk_to_last_page
                                        // -- End function
	.globl	js_hash                         // -- Begin function js_hash
	.p2align	2
	.type	js_hash,@function
js_hash:                                // @js_hash
// %bb.0:
	hint	#25
	mov	x8, x0
	mov	w0, #42982
	movk	w0, #18374, lsl #16
	cbz	w1, .LBB89_3
// %bb.1:
	mov	w9, w1
.LBB89_2:                               // =>This Inner Loop Header: Depth=1
	ldrb	w10, [x8], #1
	lsr	w11, w0, #2
	add	w11, w11, w0, lsl #5
	subs	x9, x9, #1                      // =1
	add	w10, w11, w10
	eor	w0, w10, w0
	b.ne	.LBB89_2
.LBB89_3:
	hint	#29
	ret
.Lfunc_end89:
	.size	js_hash, .Lfunc_end89-js_hash
                                        // -- End function
	.globl	flush_l2p_region                // -- Begin function flush_l2p_region
	.p2align	2
	.type	flush_l2p_region,@function
flush_l2p_region:                       // @flush_l2p_region
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #16]             // 16-byte Folded Spill
	adrp	x19, p_l2p_ram_map
	ldr	x8, [x19, :lo12:p_l2p_ram_map]
                                        // kill: def $w0 killed $w0 def $x0
	and	x9, x0, #0xffff
	lsl	x20, x9, #4
	adrp	x0, gL2pMapInfo
	add	x8, x8, x20
	ldrh	w1, [x8]
	ldr	x2, [x8, #8]
	add	x0, x0, :lo12:gL2pMapInfo
	mov	x29, sp
	bl	FtlMapWritePage
	ldr	x8, [x19, :lo12:p_l2p_ram_map]
	mov	w0, wzr
	add	x8, x8, x20
	ldr	w9, [x8, #4]
	ldp	x20, x19, [sp, #16]             // 16-byte Folded Reload
	and	w9, w9, #0x7fffffff
	str	w9, [x8, #4]
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end90:
	.size	flush_l2p_region, .Lfunc_end90-flush_l2p_region
                                        // -- End function
	.globl	select_l2p_ram_region           // -- Begin function select_l2p_ram_region
	.p2align	2
	.type	select_l2p_ram_region,@function
select_l2p_ram_region:                  // @select_l2p_ram_region
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	adrp	x8, c_ftl_nand_l2pmap_ram_region_num
	ldrh	w8, [x8, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	str	x19, [sp, #16]                  // 8-byte Folded Spill
	mov	x29, sp
	cbz	x8, .LBB91_11
// %bb.1:
	adrp	x9, p_l2p_ram_map
	ldr	x10, [x9, :lo12:p_l2p_ram_map]
	mov	x19, xzr
.LBB91_2:                               // =>This Inner Loop Header: Depth=1
	ldrsh	w11, [x10]
	cmn	w11, #1                         // =1
	b.eq	.LBB91_14
// %bb.3:                               //   in Loop: Header=BB91_2 Depth=1
	add	x19, x19, #1                    // =1
	cmp	x8, x19
	add	x10, x10, #16                   // =16
	b.ne	.LBB91_2
// %bb.4:
	ldr	x11, [x9, :lo12:p_l2p_ram_map]
	mov	x10, xzr
	mov	w12, #-2147483648
	mov	w19, w8
	add	x11, x11, #4                    // =4
.LBB91_5:                               // =>This Inner Loop Header: Depth=1
	ldr	w13, [x11], #16
	cmp	w13, #0                         // =0
	cset	w14, ge
	cmp	w13, w12
	cset	w15, lo
	tst	w14, w15
	csel	w19, w10, w19, ne
	add	x10, x10, #1                    // =1
	csel	w12, w13, w12, ne
	cmp	x8, x10
	b.ne	.LBB91_5
// %bb.6:
	cmp	w8, w19, uxth
	b.hi	.LBB91_14
// %bb.7:
	ldr	x11, [x9, :lo12:p_l2p_ram_map]
	adrp	x9, g_l2p_last_update_region_id
	ldrh	w9, [x9, :lo12:g_l2p_last_update_region_id]
	mov	x10, xzr
	add	x11, x11, #4                    // =4
	mov	w12, #-1
	mov	w19, w8
	b	.LBB91_9
.LBB91_8:                               //   in Loop: Header=BB91_9 Depth=1
	add	x10, x10, #1                    // =1
	cmp	x8, x10
	add	x11, x11, #16                   // =16
	b.eq	.LBB91_12
.LBB91_9:                               // =>This Inner Loop Header: Depth=1
	ldr	w13, [x11]
	cmp	w13, w12
	b.hs	.LBB91_8
// %bb.10:                              //   in Loop: Header=BB91_9 Depth=1
	ldurh	w14, [x11, #-4]
	cmp	w9, w14
	csel	w19, w19, w10, eq
	csel	w12, w12, w13, eq
	b	.LBB91_8
.LBB91_11:
	mov	w19, wzr
	b	.LBB91_13
.LBB91_12:
	cmp	w8, w19, uxth
	b.hi	.LBB91_14
.LBB91_13:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.select_l2p_ram_region
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.select_l2p_ram_region
	mov	w2, #796
	bl	sftl_printk
.LBB91_14:
	mov	w0, w19
	ldr	x19, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end91:
	.size	select_l2p_ram_region, .Lfunc_end91-select_l2p_ram_region
                                        // -- End function
	.globl	FtlWriteDump_data               // -- Begin function FtlWriteDump_data
	.p2align	2
	.type	FtlWriteDump_data,@function
FtlWriteDump_data:                      // @FtlWriteDump_data
// %bb.0:
	hint	#25
	sub	sp, sp, #112                    // =112
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	stp	x29, x30, [sp, #48]             // 16-byte Folded Spill
	add	x29, sp, #48                    // =48
	adrp	x9, g_active_superblock+4
	stp	x24, x23, [sp, #64]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #80]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #96]             // 16-byte Folded Spill
	stur	x8, [x29, #-8]
	add	x9, x9, :lo12:g_active_superblock+4
	ldrh	w8, [x9]
	cbz	w8, .LBB92_3
// %bb.1:
	ldrb	w9, [x9, #4]
	cbnz	w9, .LBB92_3
// %bb.2:
	adrp	x9, g_active_superblock+7
	adrp	x10, c_ftl_nand_page_pre_blk
	ldrb	w9, [x9, :lo12:g_active_superblock+7]
	ldrh	w10, [x10, :lo12:c_ftl_nand_page_pre_blk]
	mul	w9, w10, w9
	cmp	w9, w8
	b.ne	.LBB92_6
.LBB92_3:
	adrp	x8, g_active_superblock+10
	strb	wzr, [x8, :lo12:g_active_superblock+10]
.LBB92_4:
	adrp	x9, __stack_chk_guard
	ldur	x8, [x29, #-8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB92_16
// %bb.5:
	ldp	x20, x19, [sp, #96]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #48]             // 16-byte Folded Reload
	add	sp, sp, #112                    // =112
	hint	#29
	ret
.LBB92_6:
	adrp	x21, g_active_superblock+10
	ldrb	w8, [x21, :lo12:g_active_superblock+10]
	cbnz	w8, .LBB92_4
// %bb.7:
	adrp	x8, g_MaxLpn
	ldr	w8, [x8, :lo12:g_MaxLpn]
	adrp	x9, c_ftl_nand_planes_num
	ldrh	w20, [x9, :lo12:c_ftl_nand_planes_num]
	sub	x1, x29, #12                    // =12
	sub	w19, w8, #1                     // =1
	mov	w0, w19
	mov	w2, wzr
	bl	log2phys
	ldur	w9, [x29, #-12]
	adrp	x8, p_sys_data_buf
	adrp	x10, p_sys_spare_buf
	ldr	x11, [x8, :lo12:p_sys_data_buf]
	ldr	x22, [x10, :lo12:p_sys_spare_buf]
	cmn	w9, #1                          // =1
	str	w19, [sp, #24]
	str	w9, [sp, #4]
	stp	x11, x22, [sp, #8]
	str	wzr, [x22, #4]
	b.eq	.LBB92_9
// %bb.8:
	mov	x0, sp
	mov	w1, #1
	bl	FlashReadPages
	b	.LBB92_10
.LBB92_9:
	ldr	x0, [x8, :lo12:p_sys_data_buf]
	adrp	x8, c_ftl_nand_byte_pre_page
	ldrh	w2, [x8, :lo12:c_ftl_nand_byte_pre_page]
	mov	w1, #255
	bl	memset
.LBB92_10:
	mov	w8, #61589
	strh	w8, [x22]
	cbz	w20, .LBB92_15
// %bb.11:
	adrp	x8, g_active_superblock+4
	ldrh	w8, [x8, :lo12:g_active_superblock+4]
	cbz	w8, .LBB92_15
// %bb.12:
	lsl	w8, w20, #2
	mov	w9, #1
	adrp	x20, g_active_superblock
	add	x20, x20, :lo12:g_active_superblock
	sub	w23, w9, w8
	adrp	x24, g_GlobalDataVersion
.LBB92_13:                              // =>This Inner Loop Header: Depth=1
	ldr	w8, [sp, #4]
	mov	x0, x20
	stp	w19, w8, [x22, #8]
	ldrh	w8, [x20]
	strh	w8, [x22, #2]
	bl	get_new_active_ppa
	ldr	w8, [x24, :lo12:g_GlobalDataVersion]
	str	w0, [sp, #4]
	mov	x0, sp
	mov	w1, #1
	add	w9, w8, #1                      // =1
	cmn	w9, #1                          // =1
	str	w8, [x22, #4]
	csinc	w8, wzr, w8, eq
	mov	w2, wzr
	str	w8, [x24, :lo12:g_GlobalDataVersion]
	bl	FlashProgPages
	ldrh	w0, [x20]
	bl	decrement_vpc_count
	cbz	w23, .LBB92_15
// %bb.14:                              //   in Loop: Header=BB92_13 Depth=1
	ldrh	w8, [x20, #4]
	add	w23, w23, #1                    // =1
	cbnz	w8, .LBB92_13
.LBB92_15:
	mov	w8, #1
	strb	w8, [x21, :lo12:g_active_superblock+10]
	b	.LBB92_4
.LBB92_16:
	bl	__stack_chk_fail
.Lfunc_end92:
	.size	FtlWriteDump_data, .Lfunc_end92-FtlWriteDump_data
                                        // -- End function
	.globl	Ftl_save_ext_data               // -- Begin function Ftl_save_ext_data
	.p2align	2
	.type	Ftl_save_ext_data,@function
Ftl_save_ext_data:                      // @Ftl_save_ext_data
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
	adrp	x8, g_sys_ext_data
	ldr	w8, [x8, :lo12:g_sys_ext_data]
	mov	w9, #19539
	movk	w9, #18004, lsl #16
	mov	x29, sp
	cmp	w8, w9
	b.ne	.LBB93_2
// %bb.1:
	adrp	x9, g_totle_write_sector
	adrp	x10, g_totle_read_sector
	ldr	w9, [x9, :lo12:g_totle_write_sector]
	ldr	w10, [x10, :lo12:g_totle_read_sector]
	adrp	x2, g_sys_ext_data
	add	x2, x2, :lo12:g_sys_ext_data
	adrp	x11, g_totle_gc_page_count
	adrp	x12, g_totle_write_page_count
	adrp	x13, g_totle_read_page_count
	stp	w9, w10, [x2, #88]
	ldr	w10, [x11, :lo12:g_totle_gc_page_count]
	ldr	w11, [x12, :lo12:g_totle_write_page_count]
	ldr	w12, [x13, :lo12:g_totle_read_page_count]
	mov	w8, #89
	movk	w8, #20480, lsl #16
	adrp	x14, g_totle_l2p_write_count
	adrp	x15, g_totle_slc_erase_count
	adrp	x9, g_totle_sys_slc_erase_count
	stp	w8, w10, [x2, #4]
	ldr	w10, [x14, :lo12:g_totle_l2p_write_count]
	stp	w11, w12, [x2, #12]
	ldr	w12, [x15, :lo12:g_totle_slc_erase_count]
	ldr	w9, [x9, :lo12:g_totle_sys_slc_erase_count]
	adrp	x8, g_totle_discard_page_count
	adrp	x11, g_totle_cache_write_count
	str	w10, [x2, #20]
	adrp	x10, g_max_erase_count
	stp	w12, w9, [x2, #28]
	adrp	x9, g_min_erase_count
	ldr	w8, [x8, :lo12:g_totle_discard_page_count]
	ldr	w11, [x11, :lo12:g_totle_cache_write_count]
	ldr	w10, [x10, :lo12:g_max_erase_count]
	ldr	w9, [x9, :lo12:g_min_erase_count]
	mov	w1, #1
	mov	w0, wzr
	stp	w8, w11, [x2, #36]
	stp	w10, w9, [x2, #44]
	bl	FtlVendorPartWrite
.LBB93_2:
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end93:
	.size	Ftl_save_ext_data, .Lfunc_end93-Ftl_save_ext_data
                                        // -- End function
	.globl	FtlUpdateVaildLpn               // -- Begin function FtlUpdateVaildLpn
	.p2align	2
	.type	FtlUpdateVaildLpn,@function
FtlUpdateVaildLpn:                      // @FtlUpdateVaildLpn
// %bb.0:
	hint	#25
	adrp	x9, FtlUpdateVaildLpnCount
	ldrh	w8, [x9, :lo12:FtlUpdateVaildLpnCount]
	add	w10, w8, #1                     // =1
	strh	w10, [x9, :lo12:FtlUpdateVaildLpnCount]
	cbnz	w0, .LBB94_2
// %bb.1:
	cmp	w8, #5                          // =5
	b.lo	.LBB94_7
.LBB94_2:
	adrp	x8, c_ftl_nand_data_blks_per_plane
	ldrh	w8, [x8, :lo12:c_ftl_nand_data_blks_per_plane]
	strh	wzr, [x9, :lo12:FtlUpdateVaildLpnCount]
	adrp	x9, g_VaildLpn
	str	wzr, [x9, :lo12:g_VaildLpn]
	cbz	x8, .LBB94_7
// %bb.3:
	adrp	x11, p_valid_page_count_table
	ldr	x11, [x11, :lo12:p_valid_page_count_table]
	mov	w10, wzr
	mov	w12, #65535
	b	.LBB94_5
.LBB94_4:                               //   in Loop: Header=BB94_5 Depth=1
	subs	x8, x8, #1                      // =1
	add	x11, x11, #2                    // =2
	b.eq	.LBB94_7
.LBB94_5:                               // =>This Inner Loop Header: Depth=1
	ldrh	w13, [x11]
	cmp	w13, w12
	b.eq	.LBB94_4
// %bb.6:                               //   in Loop: Header=BB94_5 Depth=1
	add	w10, w10, w13
	str	w10, [x9, :lo12:g_VaildLpn]
	b	.LBB94_4
.LBB94_7:
	hint	#29
	ret
.Lfunc_end94:
	.size	FtlUpdateVaildLpn, .Lfunc_end94-FtlUpdateVaildLpn
                                        // -- End function
	.globl	FtlMapBlkWriteDump_data         // -- Begin function FtlMapBlkWriteDump_data
	.p2align	2
	.type	FtlMapBlkWriteDump_data,@function
FtlMapBlkWriteDump_data:                // @FtlMapBlkWriteDump_data
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	ldr	w8, [x0, #56]
	stp	x20, x19, [sp, #16]             // 16-byte Folded Spill
	mov	x29, sp
	cbz	w8, .LBB95_5
// %bb.1:
	ldrh	w8, [x0, #6]
	str	wzr, [x0, #56]
	adrp	x10, p_sys_data_buf_1
	adrp	x11, p_sys_spare_buf
	mov	x19, x0
	ldr	x9, [x0, #40]
	ldr	x0, [x10, :lo12:p_sys_data_buf_1]
	ldr	x10, [x11, :lo12:p_sys_spare_buf]
	adrp	x11, req_sys+4
	add	x11, x11, :lo12:req_sys+4
	sub	w20, w8, #1                     // =1
	stur	x0, [x11, #4]
	stur	x10, [x11, #12]
	and	x8, x20, #0xffff
	ldr	w8, [x9, x8, lsl #2]
	str	w8, [x11]
	cbz	w8, .LBB95_3
// %bb.2:
	adrp	x0, req_sys
	add	x0, x0, :lo12:req_sys
	mov	w1, #1
	bl	FlashReadPages
	b	.LBB95_4
.LBB95_3:
	adrp	x8, c_ftl_nand_byte_pre_page
	ldrh	w2, [x8, :lo12:c_ftl_nand_byte_pre_page]
	mov	w1, #255
	bl	memset
.LBB95_4:
	adrp	x8, req_sys+8
	ldr	x2, [x8, :lo12:req_sys+8]
	and	w1, w20, #0xffff
	mov	x0, x19
	bl	FtlMapWritePage
.LBB95_5:
	ldp	x20, x19, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end95:
	.size	FtlMapBlkWriteDump_data, .Lfunc_end95-FtlMapBlkWriteDump_data
                                        // -- End function
	.globl	FtlScanSysBlk                   // -- Begin function FtlScanSysBlk
	.p2align	2
	.type	FtlScanSysBlk,@function
FtlScanSysBlk:                          // @FtlScanSysBlk
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-96]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #80]             // 16-byte Folded Spill
	adrp	x8, g_totle_map_block
	adrp	x19, c_ftl_nand_max_map_blks
	adrp	x9, p_map_block_ver_table
	strh	wzr, [x8, :lo12:g_totle_map_block]
	ldr	w8, [x19, :lo12:c_ftl_nand_max_map_blks]
	ldr	x0, [x9, :lo12:p_map_block_ver_table]
	adrp	x9, g_totle_vendor_block
	mov	w1, wzr
	lsl	w2, w8, #2
	stp	x28, x27, [sp, #16]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #32]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #48]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #64]             // 16-byte Folded Spill
	mov	x29, sp
	strh	wzr, [x9, :lo12:g_totle_vendor_block]
	bl	memset
	adrp	x9, p_map_block_table
	ldr	w8, [x19, :lo12:c_ftl_nand_max_map_blks]
	ldr	x0, [x9, :lo12:p_map_block_table]
	mov	w1, wzr
	lsl	w2, w8, #1
	bl	memset
	adrp	x19, c_ftl_nand_max_vendor_blks
	adrp	x9, p_vendor_block_ver_table
	ldrh	w8, [x19, :lo12:c_ftl_nand_max_vendor_blks]
	ldr	x0, [x9, :lo12:p_vendor_block_ver_table]
	mov	w1, wzr
	lsl	x2, x8, #2
	bl	memset
	adrp	x9, p_vendor_block_table
	ldrh	w8, [x19, :lo12:c_ftl_nand_max_vendor_blks]
	ldr	x0, [x9, :lo12:p_vendor_block_table]
	mov	w1, wzr
	lsl	x2, x8, #1
	bl	memset
	adrp	x8, c_ftl_nand_data_blks_per_plane
	adrp	x9, c_ftl_nand_blk_pre_plane
	ldrh	w19, [x8, :lo12:c_ftl_nand_data_blks_per_plane]
	ldrh	w8, [x9, :lo12:c_ftl_nand_blk_pre_plane]
	adrp	x10, gSysInfo
	add	x10, x10, :lo12:gSysInfo
	mov	x9, #-1
	cmp	w19, w8
	stp	x9, x9, [x10]
	b.hs	.LBB96_80
// %bb.1:
	adrp	x8, c_ftl_nand_planes_num
	adrp	x21, c_ftl_nand_planes_per_die
	adrp	x20, c_ftl_nand_blks_per_die
	adrp	x22, req_read
	b	.LBB96_3
.LBB96_2:                               //   in Loop: Header=BB96_3 Depth=1
	adrp	x8, c_ftl_nand_blk_pre_plane
	ldrh	w8, [x8, :lo12:c_ftl_nand_blk_pre_plane]
	add	w19, w19, #1                    // =1
	cmp	w8, w19, uxth
	adrp	x8, c_ftl_nand_planes_num
	b.ls	.LBB96_80
.LBB96_3:                               // =>This Loop Header: Depth=1
                                        //     Child Loop BB96_6 Depth 2
                                        //     Child Loop BB96_12 Depth 2
                                        //       Child Loop BB96_48 Depth 3
                                        //       Child Loop BB96_32 Depth 3
                                        //       Child Loop BB96_40 Depth 3
                                        //       Child Loop BB96_59 Depth 3
                                        //       Child Loop BB96_67 Depth 3
	ldrh	w9, [x8, :lo12:c_ftl_nand_planes_num]
	cbz	w9, .LBB96_2
// %bb.4:                               //   in Loop: Header=BB96_3 Depth=1
	adrp	x16, p_plane_order_table
	adrp	x17, gBbtInfo
	mov	x8, xzr
	mov	w25, wzr
	adrp	x15, c_ftl_nand_planes_num
	add	x16, x16, :lo12:p_plane_order_table
	add	x17, x17, :lo12:gBbtInfo
	adrp	x18, p_gc_data_buf
	adrp	x0, p_gc_spare_buf
	adrp	x1, c_ftl_nand_byte_pre_oob
	b	.LBB96_6
.LBB96_5:                               //   in Loop: Header=BB96_6 Depth=2
	add	x8, x8, #1                      // =1
	cmp	x8, w9, uxth
	b.hs	.LBB96_8
.LBB96_6:                               //   Parent Loop BB96_3 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldrb	w10, [x16, x8]
	ldrh	w11, [x21, :lo12:c_ftl_nand_planes_per_die]
	ldrh	w12, [x20, :lo12:c_ftl_nand_blks_per_die]
	and	w13, w10, #0xffff
	and	w14, w11, #0xffff
	udiv	w13, w13, w14
	mul	w14, w11, w19
	madd	w14, w12, w13, w14
	msub	w10, w13, w11, w10
	add	w11, w14, w10
	and	w10, w11, #0xffff
	and	w13, w12, #0xffff
	udiv	w13, w10, w13
	add	x14, x17, w13, uxtw #3
	ldr	x14, [x14, #32]
	msub	w11, w13, w12, w11
	lsr	w12, w11, #3
	and	x12, x12, #0x1ffc
	ldr	w12, [x14, x12]
	lsr	w11, w12, w11
	tbnz	w11, #0, .LBB96_5
// %bb.7:                               //   in Loop: Header=BB96_6 Depth=2
	ldr	x9, [x22, :lo12:req_read]
	and	x11, x25, #0xffff
	lsl	x11, x11, #5
	lsl	w10, w10, #10
	add	x9, x9, x11
	str	w10, [x9, #4]
	ldr	x9, [x22, :lo12:req_read]
	ldr	x10, [x18, :lo12:p_gc_data_buf]
	add	x9, x9, x11
	str	x10, [x9, #8]
	ldrh	w9, [x1, :lo12:c_ftl_nand_byte_pre_oob]
	and	w10, w25, #0xffff
	ldr	x12, [x0, :lo12:p_gc_spare_buf]
	ldr	x13, [x22, :lo12:req_read]
	mul	w9, w9, w10
	add	w10, w9, #3                     // =3
	cmp	w9, #0                          // =0
	csel	w9, w10, w9, lt
	asr	w9, w9, #2
	add	x9, x12, w9, sxtw #2
	add	x10, x13, x11
	str	x9, [x10, #16]
	ldrh	w9, [x15, :lo12:c_ftl_nand_planes_num]
	add	w25, w25, #1                    // =1
	b	.LBB96_5
.LBB96_8:                               //   in Loop: Header=BB96_3 Depth=1
	tst	w25, #0xffff
	b.eq	.LBB96_2
// %bb.9:                               //   in Loop: Header=BB96_3 Depth=1
	ldr	x0, [x22, :lo12:req_read]
	and	w1, w25, #0xffff
	bl	FlashReadPages
	mov	x23, xzr
                                        // kill: def $w25 killed $w25 killed $x25 def $x25
	and	x28, x25, #0xffff
	b	.LBB96_12
.LBB96_10:                              //   in Loop: Header=BB96_12 Depth=2
	lsr	w10, w27, #10
	strh	w10, [x9, x8, lsl #1]
.LBB96_11:                              //   in Loop: Header=BB96_12 Depth=2
	add	x23, x23, #1                    // =1
	cmp	x23, x28
	b.eq	.LBB96_2
.LBB96_12:                              //   Parent Loop BB96_3 Depth=1
                                        // =>  This Loop Header: Depth=2
                                        //       Child Loop BB96_48 Depth 3
                                        //       Child Loop BB96_32 Depth 3
                                        //       Child Loop BB96_40 Depth 3
                                        //       Child Loop BB96_59 Depth 3
                                        //       Child Loop BB96_67 Depth 3
	ldr	x8, [x22, :lo12:req_read]
	add	x9, x8, x23, lsl #5
	ldp	w10, w27, [x9]
	ldr	x25, [x9, #16]
	cmn	w10, #1                         // =1
	b.eq	.LBB96_46
.LBB96_13:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x8, g_GlobalSysVersion
	ldr	w9, [x8, :lo12:g_GlobalSysVersion]
	ldr	w8, [x25, #4]
	cmn	w9, #1                          // =1
	b.eq	.LBB96_15
// %bb.14:                              //   in Loop: Header=BB96_12 Depth=2
	cmp	w9, w8
	b.hi	.LBB96_17
.LBB96_15:                              //   in Loop: Header=BB96_12 Depth=2
	cmn	w8, #1                          // =1
	b.eq	.LBB96_17
// %bb.16:                              //   in Loop: Header=BB96_12 Depth=2
	add	w9, w8, #1                      // =1
	adrp	x10, g_GlobalSysVersion
	str	w9, [x10, :lo12:g_GlobalSysVersion]
.LBB96_17:                              //   in Loop: Header=BB96_12 Depth=2
	ldrh	w9, [x25]
	mov	w10, #61633
	cmp	w9, w10
	b.gt	.LBB96_27
// %bb.18:                              //   in Loop: Header=BB96_12 Depth=2
	mov	w10, #61574
	cmp	w9, w10
	b.eq	.LBB96_56
// %bb.19:                              //   in Loop: Header=BB96_12 Depth=2
	mov	w10, #61604
	cmp	w9, w10
	b.ne	.LBB96_11
// %bb.20:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x9, gSysInfo
	ldrsh	w9, [x9, :lo12:gSysInfo]
	cmn	w9, #1                          // =1
	b.eq	.LBB96_77
// %bb.21:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x9, gSysInfo+4
	ldrh	w24, [x9, :lo12:gSysInfo+4]
	mov	w9, #65535
	cmp	w24, w9
	b.eq	.LBB96_25
// %bb.22:                              //   in Loop: Header=BB96_12 Depth=2
	cbz	w24, .LBB96_25
// %bb.23:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x9, gSysFreeQueue+6
	ldrh	w9, [x9, :lo12:gSysFreeQueue+6]
	cmp	w9, #1024                       // =1024
	b.eq	.LBB96_25
// %bb.24:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x12, req_erase
	ldr	x8, [x12, :lo12:req_erase]
	ldrh	w9, [x20, :lo12:c_ftl_nand_blks_per_die]
	lsl	w11, w24, #10
	ldrh	w10, [x21, :lo12:c_ftl_nand_planes_per_die]
	str	w11, [x8, #4]
	ldr	x0, [x12, :lo12:req_erase]
	udiv	w8, w24, w9
	msub	w8, w8, w9, w24
	mov	w2, #1
	udiv	w26, w8, w10
	bl	FlashEraseBlocks
	adrp	x8, p_erase_count_table
	ldr	x8, [x8, :lo12:p_erase_count_table]
	lsl	x9, x26, #1
	adrp	x11, g_totle_sys_slc_erase_count
	adrp	x12, gSysFreeQueue
	ldrh	w10, [x8, x9]
	add	x12, x12, :lo12:gSysFreeQueue
	add	w10, w10, #1                    // =1
	strh	w10, [x8, x9]
	ldr	w8, [x11, :lo12:g_totle_sys_slc_erase_count]
	ldrh	w9, [x12, #6]
	ldrh	w10, [x12, #4]
	add	w8, w8, #1                      // =1
	add	w9, w9, #1                      // =1
	str	w8, [x11, :lo12:g_totle_sys_slc_erase_count]
	add	x8, x12, x10, lsl #1
	add	w10, w10, #1                    // =1
	strh	w9, [x12, #6]
	strh	w24, [x8, #8]
	and	w8, w10, #0x3ff
	strh	w8, [x12, #4]
	ldr	w8, [x25, #4]
.LBB96_25:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x9, gSysInfo+8
	ldr	w9, [x9, :lo12:gSysInfo+8]
	cmp	w9, w8
	b.hs	.LBB96_79
// %bb.26:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x10, gSysInfo
	add	x10, x10, :lo12:gSysInfo
	ldrh	w8, [x10]
	lsr	w9, w27, #10
	strh	w9, [x10]
	strh	w8, [x10, #4]
	ldr	w8, [x25, #4]
	b	.LBB96_78
.LBB96_27:                              //   in Loop: Header=BB96_12 Depth=2
	mov	w8, #65535
	cmp	w9, w8
	b.eq	.LBB96_73
// %bb.28:                              //   in Loop: Header=BB96_12 Depth=2
	mov	w8, #61634
	cmp	w9, w8
	b.ne	.LBB96_11
// %bb.29:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x24, g_totle_map_block
	adrp	x26, c_ftl_nand_max_map_blks
	ldrh	w9, [x24, :lo12:g_totle_map_block]
	ldr	w11, [x26, :lo12:c_ftl_nand_max_map_blks]
	cmp	w11, w9
	b.hs	.LBB96_31
// %bb.30:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlScanSysBlk
	mov	w2, #1232
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlScanSysBlk
	bl	sftl_printk
	ldr	w11, [x26, :lo12:c_ftl_nand_max_map_blks]
	ldrh	w9, [x24, :lo12:g_totle_map_block]
.LBB96_31:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x8, p_map_block_ver_table
	ldr	x10, [x8, :lo12:p_map_block_ver_table]
	mvn	w8, w9
	add	w8, w11, w8
	sxth	w13, w8
	mov	w14, w11
.LBB96_32:                              //   Parent Loop BB96_3 Depth=1
                                        //     Parent Loop BB96_12 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	sub	w14, w14, #1                    // =1
	sxth	w8, w14
	cmp	w13, w8
	b.ge	.LBB96_43
// %bb.33:                              //   in Loop: Header=BB96_32 Depth=3
	ldr	w12, [x25, #4]
	ldr	w15, [x10, w8, sxtw #2]
	cmp	w12, w15
	b.ls	.LBB96_32
// %bb.34:                              //   in Loop: Header=BB96_12 Depth=2
	cmp	w11, w9
	b.eq	.LBB96_37
// %bb.35:                              //   in Loop: Header=BB96_12 Depth=2
	ldr	w11, [x10]
	cbnz	w11, .LBB96_37
// %bb.36:                              //   in Loop: Header=BB96_12 Depth=2
	add	w9, w9, #1                      // =1
	adrp	x11, g_totle_map_block
	strh	w9, [x11, :lo12:g_totle_map_block]
.LBB96_37:                              //   in Loop: Header=BB96_12 Depth=2
	cbz	w8, .LBB96_42
// %bb.38:                              //   in Loop: Header=BB96_12 Depth=2
	ldr	w9, [x10, #4]
	adrp	x15, p_map_block_table
	cmp	w8, #1                          // =1
	adrp	x14, p_map_block_ver_table
	str	w9, [x10]
	ldr	x9, [x15, :lo12:p_map_block_table]
	ldrh	w10, [x9, #2]
	strh	w10, [x9]
	b.eq	.LBB96_41
// %bb.39:                              //   in Loop: Header=BB96_12 Depth=2
	mov	w9, #1
.LBB96_40:                              //   Parent Loop BB96_3 Depth=1
                                        //     Parent Loop BB96_12 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	ldr	x10, [x14, :lo12:p_map_block_ver_table]
	sxth	x11, w9
	add	x12, x11, #1                    // =1
	add	w9, w9, #1                      // =1
	ldr	w13, [x10, x12, lsl #2]
	str	w13, [x10, x11, lsl #2]
	ldr	x10, [x15, :lo12:p_map_block_table]
	and	w13, w9, #0xffff
	cmp	w13, w8, uxth
	ldrh	w12, [x10, x12, lsl #1]
	strh	w12, [x10, x11, lsl #1]
	b.lo	.LBB96_40
.LBB96_41:                              //   in Loop: Header=BB96_12 Depth=2
	ldr	w12, [x25, #4]
	ldr	x10, [x14, :lo12:p_map_block_ver_table]
.LBB96_42:                              //   in Loop: Header=BB96_12 Depth=2
	sxtw	x9, w8
	str	w12, [x10, x9, lsl #2]
	adrp	x10, p_map_block_table
	ldr	x10, [x10, :lo12:p_map_block_table]
	lsr	w11, w27, #10
	strh	w11, [x10, x9, lsl #1]
.LBB96_43:                              //   in Loop: Header=BB96_12 Depth=2
	tbnz	w8, #31, .LBB96_11
// %bb.44:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x9, g_totle_map_block
	ldrh	w9, [x9, :lo12:g_totle_map_block]
	adrp	x10, c_ftl_nand_max_map_blks
	ldr	w10, [x10, :lo12:c_ftl_nand_max_map_blks]
	mvn	w11, w9
	add	w10, w10, w11
	cmp	w8, w10, sxth
	b.gt	.LBB96_11
// %bb.45:                              //   in Loop: Header=BB96_12 Depth=2
	add	w9, w9, #1                      // =1
	adrp	x10, g_totle_map_block
	strh	w9, [x10, :lo12:g_totle_map_block]
	adrp	x10, p_map_block_ver_table
	ldr	w9, [x25, #4]
	ldr	x10, [x10, :lo12:p_map_block_ver_table]
                                        // kill: def $w8 killed $w8 killed $x8 def $x8
	and	x8, x8, #0xffff
	str	w9, [x10, x8, lsl #2]
	adrp	x9, p_map_block_table
	ldr	x9, [x9, :lo12:p_map_block_table]
	b	.LBB96_10
.LBB96_46:                              //   in Loop: Header=BB96_12 Depth=2
	lsl	x24, x23, #5
	add	x8, x8, x24
	add	w9, w27, #1                     // =1
	str	w9, [x8, #4]
	ldr	x8, [x22, :lo12:req_read]
	mov	w1, #1
	add	x0, x8, x24
	bl	FlashReadPages
	ldrsh	w8, [x25]
	cmn	w8, #1                          // =1
	b.eq	.LBB96_51
// %bb.47:                              //   in Loop: Header=BB96_12 Depth=2
	mov	w26, wzr
.LBB96_48:                              //   Parent Loop BB96_3 Depth=1
                                        //     Parent Loop BB96_12 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	ldr	x8, [x22, :lo12:req_read]
	ldr	w9, [x8, x24]
	cmn	w9, #1                          // =1
	b.ne	.LBB96_13
// %bb.49:                              //   in Loop: Header=BB96_48 Depth=3
	and	w9, w26, #0xffff
	cmp	w9, #14                         // =14
	b.hi	.LBB96_52
// %bb.50:                              //   in Loop: Header=BB96_48 Depth=3
	add	x8, x8, x24
	ldr	w9, [x8, #4]
	mov	w1, #1
	add	w26, w26, #1                    // =1
	add	w9, w9, #1                      // =1
	str	w9, [x8, #4]
	ldr	x8, [x22, :lo12:req_read]
	add	x0, x8, x24
	bl	FlashReadPages
	ldrsh	w8, [x25]
	cmn	w8, #1                          // =1
	b.ne	.LBB96_48
.LBB96_51:                              //   in Loop: Header=BB96_12 Depth=2
	ldr	x8, [x22, :lo12:req_read]
	mov	w9, #-1
	str	w9, [x8, x24]
	ldr	x8, [x22, :lo12:req_read]
	ldr	w8, [x8, x24]
	cmn	w8, #1                          // =1
	b.ne	.LBB96_13
.LBB96_52:                              //   in Loop: Header=BB96_12 Depth=2
	ubfx	w8, w27, #10, #16
	cbz	w8, .LBB96_11
// %bb.53:                              //   in Loop: Header=BB96_12 Depth=2
	mov	w9, #65535
	cmp	w8, w9
	b.eq	.LBB96_11
// %bb.54:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x9, gSysFreeQueue+6
	ldrh	w9, [x9, :lo12:gSysFreeQueue+6]
	cmp	w9, #1024                       // =1024
	b.eq	.LBB96_11
// %bb.55:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x13, req_erase
	ldr	x9, [x13, :lo12:req_erase]
	ldrh	w10, [x20, :lo12:c_ftl_nand_blks_per_die]
	and	w12, w27, #0x3fffc00
	ldrh	w11, [x21, :lo12:c_ftl_nand_planes_per_die]
	str	w12, [x9, #4]
	ldr	x0, [x13, :lo12:req_erase]
	udiv	w9, w8, w10
	msub	w8, w9, w10, w8
	mov	w2, #1
	lsr	w24, w27, #10
	udiv	w25, w8, w11
	bl	FlashEraseBlocks
	adrp	x8, p_erase_count_table
	ldr	x8, [x8, :lo12:p_erase_count_table]
	lsl	x9, x25, #1
	adrp	x11, g_totle_sys_slc_erase_count
	adrp	x12, gSysFreeQueue
	ldrh	w10, [x8, x9]
	add	x12, x12, :lo12:gSysFreeQueue
	add	w10, w10, #1                    // =1
	strh	w10, [x8, x9]
	ldr	w8, [x11, :lo12:g_totle_sys_slc_erase_count]
	ldrh	w9, [x12, #6]
	ldrh	w10, [x12, #4]
	add	w8, w8, #1                      // =1
	add	w9, w9, #1                      // =1
	str	w8, [x11, :lo12:g_totle_sys_slc_erase_count]
	add	x8, x12, x10, lsl #1
	add	w10, w10, #1                    // =1
	strh	w9, [x12, #6]
	strh	w24, [x8, #8]
	and	w8, w10, #0x3ff
	strh	w8, [x12, #4]
	b	.LBB96_11
.LBB96_56:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x8, g_totle_vendor_block
	adrp	x24, c_ftl_nand_max_vendor_blks
	ldrh	w10, [x8, :lo12:g_totle_vendor_block]
	ldrh	w11, [x24, :lo12:c_ftl_nand_max_vendor_blks]
	cmp	w10, w11
	b.ls	.LBB96_58
// %bb.57:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlScanSysBlk
	mov	w2, #1273
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlScanSysBlk
	mov	x26, x8
	bl	sftl_printk
	ldrh	w11, [x24, :lo12:c_ftl_nand_max_vendor_blks]
	ldrh	w10, [x26, :lo12:g_totle_vendor_block]
.LBB96_58:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x8, p_vendor_block_ver_table
	ldr	x9, [x8, :lo12:p_vendor_block_ver_table]
	mvn	w8, w10
	add	w13, w8, w11
	mov	w8, w11
.LBB96_59:                              //   Parent Loop BB96_3 Depth=1
                                        //     Parent Loop BB96_12 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	sub	w8, w8, #1                      // =1
	sxth	w8, w8
	cmp	w13, w8
	b.ge	.LBB96_70
// %bb.60:                              //   in Loop: Header=BB96_59 Depth=3
	ldr	w12, [x25, #4]
	ldr	w14, [x9, w8, sxtw #2]
	cmp	w12, w14
	b.ls	.LBB96_59
// %bb.61:                              //   in Loop: Header=BB96_12 Depth=2
	cmp	w10, w11
	b.eq	.LBB96_64
// %bb.62:                              //   in Loop: Header=BB96_12 Depth=2
	ldr	w11, [x9]
	cbnz	w11, .LBB96_64
// %bb.63:                              //   in Loop: Header=BB96_12 Depth=2
	add	w10, w10, #1                    // =1
	adrp	x11, g_totle_vendor_block
	strh	w10, [x11, :lo12:g_totle_vendor_block]
.LBB96_64:                              //   in Loop: Header=BB96_12 Depth=2
	cbz	w8, .LBB96_69
// %bb.65:                              //   in Loop: Header=BB96_12 Depth=2
	ldr	w10, [x9, #4]
	adrp	x15, p_vendor_block_table
	cmp	w8, #1                          // =1
	adrp	x14, p_vendor_block_ver_table
	str	w10, [x9]
	ldr	x9, [x15, :lo12:p_vendor_block_table]
	ldrh	w10, [x9, #2]
	strh	w10, [x9]
	b.eq	.LBB96_68
// %bb.66:                              //   in Loop: Header=BB96_12 Depth=2
	mov	w9, #1
.LBB96_67:                              //   Parent Loop BB96_3 Depth=1
                                        //     Parent Loop BB96_12 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	ldr	x10, [x14, :lo12:p_vendor_block_ver_table]
	sxth	x11, w9
	add	x12, x11, #1                    // =1
	add	w9, w9, #1                      // =1
	ldr	w13, [x10, x12, lsl #2]
	str	w13, [x10, x11, lsl #2]
	ldr	x10, [x15, :lo12:p_vendor_block_table]
	and	w13, w9, #0xffff
	cmp	w13, w8, uxth
	ldrh	w12, [x10, x12, lsl #1]
	strh	w12, [x10, x11, lsl #1]
	b.lo	.LBB96_67
.LBB96_68:                              //   in Loop: Header=BB96_12 Depth=2
	ldr	w12, [x25, #4]
	ldr	x9, [x14, :lo12:p_vendor_block_ver_table]
.LBB96_69:                              //   in Loop: Header=BB96_12 Depth=2
	sxtw	x10, w8
	str	w12, [x9, x10, lsl #2]
	adrp	x9, p_vendor_block_table
	ldr	x9, [x9, :lo12:p_vendor_block_table]
	lsr	w11, w27, #10
	strh	w11, [x9, x10, lsl #1]
.LBB96_70:                              //   in Loop: Header=BB96_12 Depth=2
	tbnz	w8, #31, .LBB96_11
// %bb.71:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x9, g_totle_vendor_block
	ldrh	w9, [x9, :lo12:g_totle_vendor_block]
	adrp	x10, c_ftl_nand_max_vendor_blks
	ldrh	w10, [x10, :lo12:c_ftl_nand_max_vendor_blks]
	mvn	w11, w9
	add	w10, w10, w11
	cmp	w8, w10, sxth
	b.gt	.LBB96_11
// %bb.72:                              //   in Loop: Header=BB96_12 Depth=2
	add	w9, w9, #1                      // =1
	adrp	x10, g_totle_vendor_block
	strh	w9, [x10, :lo12:g_totle_vendor_block]
	adrp	x10, p_vendor_block_ver_table
	ldr	w9, [x25, #4]
	ldr	x10, [x10, :lo12:p_vendor_block_ver_table]
                                        // kill: def $w8 killed $w8 killed $x8 def $x8
	and	x8, x8, #0xffff
	str	w9, [x10, x8, lsl #2]
	adrp	x9, p_vendor_block_table
	ldr	x9, [x9, :lo12:p_vendor_block_table]
	b	.LBB96_10
.LBB96_73:                              //   in Loop: Header=BB96_12 Depth=2
	ubfx	w8, w27, #10, #16
	cbz	w8, .LBB96_11
// %bb.74:                              //   in Loop: Header=BB96_12 Depth=2
	mov	w9, #65535
	cmp	w8, w9
	b.eq	.LBB96_11
// %bb.75:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x8, gSysFreeQueue+6
	ldrh	w8, [x8, :lo12:gSysFreeQueue+6]
	cmp	w8, #1024                       // =1024
	b.eq	.LBB96_11
// %bb.76:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x11, gSysFreeQueue
	add	x11, x11, :lo12:gSysFreeQueue
	ldrh	w9, [x11, #4]
	add	w8, w8, #1                      // =1
	lsr	w10, w27, #10
	strh	w8, [x11, #6]
	add	x8, x11, x9, lsl #1
	add	w9, w9, #1                      // =1
	strh	w10, [x8, #8]
	and	w8, w9, #0x3ff
	strh	w8, [x11, #4]
	b	.LBB96_11
.LBB96_77:                              //   in Loop: Header=BB96_12 Depth=2
	adrp	x10, gSysInfo
	lsr	w9, w27, #10
	add	x10, x10, :lo12:gSysInfo
	strh	w9, [x10]
.LBB96_78:                              //   in Loop: Header=BB96_12 Depth=2
	str	w8, [x10, #8]
	b	.LBB96_11
.LBB96_79:                              //   in Loop: Header=BB96_12 Depth=2
	lsr	w8, w27, #10
	adrp	x9, gSysInfo+4
	strh	w8, [x9, :lo12:gSysInfo+4]
	b	.LBB96_11
.LBB96_80:
	adrp	x17, p_map_block_table
	ldr	x10, [x17, :lo12:p_map_block_table]
	adrp	x16, c_ftl_nand_max_map_blks
	ldr	w8, [x16, :lo12:c_ftl_nand_max_map_blks]
	adrp	x15, g_totle_map_block
	ldrh	w9, [x10]
	cbnz	w9, .LBB96_90
// %bb.81:
	ldrh	w9, [x15, :lo12:g_totle_map_block]
	adrp	x18, c_ftl_nand_max_vendor_blks
	adrp	x0, p_vendor_block_table
	cbz	w9, .LBB96_91
// %bb.82:
	cbz	w8, .LBB96_91
// %bb.83:
	mov	w13, wzr
	adrp	x14, p_map_block_ver_table
.LBB96_84:                              // =>This Inner Loop Header: Depth=1
	mov	w11, w13
	add	w13, w13, #1                    // =1
	sxth	w9, w13
	cmp	w8, w9
	b.ls	.LBB96_91
// %bb.85:                              //   in Loop: Header=BB96_84 Depth=1
	ldrh	w12, [x10, w9, sxtw #1]
	cbz	w12, .LBB96_84
// %bb.86:
	cmp	w8, w9
	b.ls	.LBB96_91
// %bb.87:
	sub	w8, w9, w9
	strh	w12, [x10, w8, sxtw #1]
	ldr	x10, [x14, :lo12:p_map_block_ver_table]
	sxtw	x12, w9
	ldr	w13, [x10, x12, lsl #2]
	str	w13, [x10, w8, sxtw #2]
	ldr	x8, [x17, :lo12:p_map_block_table]
	add	w10, w11, #2                    // =2
	strh	wzr, [x8, x12, lsl #1]
	ldr	w8, [x16, :lo12:c_ftl_nand_max_map_blks]
.LBB96_88:                              // =>This Inner Loop Header: Depth=1
	sxth	w10, w10
	cmp	w8, w10
	b.ls	.LBB96_91
// %bb.89:                              //   in Loop: Header=BB96_88 Depth=1
	ldr	x8, [x17, :lo12:p_map_block_table]
	sbfiz	x11, x10, #1, #16
	sub	w13, w10, w9
	ldrh	w12, [x8, x11]
	strh	w12, [x8, w13, sxtw #1]
	ldr	x8, [x14, :lo12:p_map_block_ver_table]
	sxth	x12, w10
	add	w10, w10, #1                    // =1
	ldr	w12, [x8, x12, lsl #2]
	str	w12, [x8, w13, sxtw #2]
	ldr	x8, [x17, :lo12:p_map_block_table]
	strh	wzr, [x8, x11]
	ldr	w8, [x16, :lo12:c_ftl_nand_max_map_blks]
	b	.LBB96_88
.LBB96_90:
	adrp	x18, c_ftl_nand_max_vendor_blks
	adrp	x0, p_vendor_block_table
.LBB96_91:
	ldr	x10, [x0, :lo12:p_vendor_block_table]
	ldrh	w9, [x10]
	cbnz	w9, .LBB96_102
// %bb.92:
	adrp	x9, g_totle_vendor_block
	ldrh	w9, [x9, :lo12:g_totle_vendor_block]
	cbz	w9, .LBB96_102
// %bb.93:
	ldrh	w12, [x18, :lo12:c_ftl_nand_max_vendor_blks]
	cbz	w12, .LBB96_102
// %bb.94:
	mov	w14, wzr
	adrp	x17, p_vendor_block_ver_table
.LBB96_95:                              // =>This Inner Loop Header: Depth=1
	mov	w11, w14
	add	w14, w14, #1                    // =1
	sxth	w9, w14
	cmp	w9, w12
	b.ge	.LBB96_102
// %bb.96:                              //   in Loop: Header=BB96_95 Depth=1
	ldrh	w13, [x10, w9, sxtw #1]
	cbz	w13, .LBB96_95
// %bb.97:
	cmp	w9, w12
	b.ge	.LBB96_102
// %bb.98:
	sub	w8, w9, w9
	strh	w13, [x10, w8, sxtw #1]
	ldr	x10, [x17, :lo12:p_vendor_block_ver_table]
	sxtw	x12, w9
	ldr	w13, [x10, x12, lsl #2]
	str	w13, [x10, w8, sxtw #2]
	ldr	x8, [x0, :lo12:p_vendor_block_table]
	strh	wzr, [x8, x12, lsl #1]
	ldrh	w10, [x18, :lo12:c_ftl_nand_max_vendor_blks]
	add	w8, w11, #2                     // =2
.LBB96_99:                              // =>This Inner Loop Header: Depth=1
	sxth	w8, w8
	cmp	w8, w10
	b.ge	.LBB96_101
// %bb.100:                             //   in Loop: Header=BB96_99 Depth=1
	ldr	x10, [x0, :lo12:p_vendor_block_table]
	sbfiz	x11, x8, #1, #16
	sub	w13, w8, w9
	ldrh	w12, [x10, x11]
	strh	w12, [x10, w13, sxtw #1]
	ldr	x10, [x17, :lo12:p_vendor_block_ver_table]
	sxth	x12, w8
	add	w8, w8, #1                      // =1
	ldr	w12, [x10, x12, lsl #2]
	str	w12, [x10, w13, sxtw #2]
	ldr	x10, [x0, :lo12:p_vendor_block_table]
	strh	wzr, [x10, x11]
	ldrh	w10, [x18, :lo12:c_ftl_nand_max_vendor_blks]
	b	.LBB96_99
.LBB96_101:
	ldr	w8, [x16, :lo12:c_ftl_nand_max_map_blks]
.LBB96_102:
	ldrh	w9, [x15, :lo12:g_totle_map_block]
	cmp	w8, w9
	b.hs	.LBB96_104
// %bb.103:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlScanSysBlk
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlScanSysBlk
	mov	w2, #1398
	bl	sftl_printk
.LBB96_104:
	ldp	x20, x19, [sp, #80]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #96             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end96:
	.size	FtlScanSysBlk, .Lfunc_end96-FtlScanSysBlk
                                        // -- End function
	.globl	FtlLoadEctTbl                   // -- Begin function FtlLoadEctTbl
	.p2align	2
	.type	FtlLoadEctTbl,@function
FtlLoadEctTbl:                          // @FtlLoadEctTbl
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #16]             // 16-byte Folded Spill
	adrp	x19, g_ect_tbl_info_size
	adrp	x20, gp_ect_tbl_info
	ldrh	w1, [x19, :lo12:g_ect_tbl_info_size]
	ldr	x2, [x20, :lo12:gp_ect_tbl_info]
	mov	w0, #64
	mov	x29, sp
	bl	FtlVendorPartRead
	ldr	x8, [x20, :lo12:gp_ect_tbl_info]
	mov	w9, #17221
	movk	w9, #16980, lsl #16
	ldr	w8, [x8]
	cmp	w8, w9
	b.eq	.LBB97_2
// %bb.1:
	adrp	x0, .L.str.75
	adrp	x1, .L.str.96
	add	x0, x0, :lo12:.L.str.75
	add	x1, x1, :lo12:.L.str.96
	bl	sftl_printk
	ldrh	w8, [x19, :lo12:g_ect_tbl_info_size]
	ldr	x0, [x20, :lo12:gp_ect_tbl_info]
	mov	w1, wzr
	lsl	x2, x8, #9
	bl	memset
.LBB97_2:
	ldp	x20, x19, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end97:
	.size	FtlLoadEctTbl, .Lfunc_end97-FtlLoadEctTbl
                                        // -- End function
	.globl	FtlLoadSysInfo                  // -- Begin function FtlLoadSysInfo
	.p2align	2
	.type	FtlLoadSysInfo,@function
FtlLoadSysInfo:                         // @FtlLoadSysInfo
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-96]!           // 16-byte Folded Spill
	adrp	x11, c_ftl_nand_data_blks_per_plane
	stp	x28, x27, [sp, #16]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #32]             // 16-byte Folded Spill
	adrp	x25, p_sys_data_buf
	adrp	x27, p_sys_spare_buf
	adrp	x12, p_valid_page_count_table
	ldrh	w11, [x11, :lo12:c_ftl_nand_data_blks_per_plane]
	ldr	x9, [x25, :lo12:p_sys_data_buf]
	ldr	x10, [x27, :lo12:p_sys_spare_buf]
	ldr	x0, [x12, :lo12:p_valid_page_count_table]
	adrp	x8, req_sys+8
	add	x8, x8, :lo12:req_sys+8
	lsl	x2, x11, #1
	mov	w1, wzr
	stp	x24, x23, [sp, #48]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #64]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #80]             // 16-byte Folded Spill
	mov	x29, sp
	stp	x9, x10, [x8]
	bl	memset
	adrp	x20, gSysInfo
	ldrh	w0, [x20, :lo12:gSysInfo]
	mov	w8, #65535
	cmp	w0, w8
	b.eq	.LBB98_39
// %bb.1:
	mov	w26, #19539
	mov	w1, #1
	movk	w26, #18004, lsl #16
	bl	FtlGetLastWrittenPage
	add	w8, w0, #1                      // =1
	adrp	x9, gSysInfo+2
	adrp	x21, c_ftl_nand_byte_pre_page
	strh	w8, [x9, :lo12:gSysInfo+2]
	tbnz	w0, #15, .LBB98_19
// %bb.2:
	ldrh	w8, [x20, :lo12:gSysInfo]
	adrp	x20, req_sys
	mov	w19, w0
	sxth	w24, w0
	add	x20, x20, :lo12:req_sys
	adrp	x22, gSysInfo+4
.LBB98_3:                               // =>This Loop Header: Depth=1
                                        //     Child Loop BB98_7 Depth 2
                                        //       Child Loop BB98_11 Depth 3
	sxth	w23, w8
	sbfiz	w28, w8, #10, #16
	b	.LBB98_7
.LBB98_4:                               //   in Loop: Header=BB98_7 Depth=2
	ldrh	w4, [x22, :lo12:gSysInfo+4]
	adrp	x0, .L.str.97
	adrp	x1, .L__func__.FtlLoadSysInfo
	add	x0, x0, :lo12:.L.str.97
	add	x1, x1, :lo12:.L__func__.FtlLoadSysInfo
	mov	w2, w23
	mov	w3, w24
	bl	sftl_printk
	tst	w19, #0xffff
	b.eq	.LBB98_16
.LBB98_5:                               //   in Loop: Header=BB98_7 Depth=2
	adrp	x8, req_sys
	mov	w9, #-1
	str	w9, [x8, :lo12:req_sys]
.LBB98_6:                               //   in Loop: Header=BB98_7 Depth=2
	sub	w8, w19, #1                     // =1
	sxth	w24, w8
	mov	w19, w24
	tbnz	w8, #15, .LBB98_19
.LBB98_7:                               //   Parent Loop BB98_3 Depth=1
                                        // =>  This Loop Header: Depth=2
                                        //       Child Loop BB98_11 Depth 3
	ldr	x8, [x25, :lo12:p_sys_data_buf]
	orr	w9, w28, w24
	mov	w1, #1
	mov	x0, x20
	str	w9, [x20, #4]
	str	x8, [x20, #8]
	bl	FlashReadPages
	ldr	x8, [x20, #16]
	ldr	w5, [x8, #12]
	ldr	w8, [x20]
	cbz	w5, .LBB98_13
// %bb.8:                               //   in Loop: Header=BB98_7 Depth=2
	cmn	w8, #1                          // =1
	b.eq	.LBB98_13
// %bb.9:                               //   in Loop: Header=BB98_7 Depth=2
	ldrh	w9, [x21, :lo12:c_ftl_nand_byte_pre_page]
	mov	w6, #42982
	movk	w6, #18374, lsl #16
	cbz	x9, .LBB98_12
// %bb.10:                              //   in Loop: Header=BB98_7 Depth=2
	adrp	x10, req_sys+8
	ldr	x10, [x10, :lo12:req_sys+8]
	mov	w6, #42982
	movk	w6, #18374, lsl #16
.LBB98_11:                              //   Parent Loop BB98_3 Depth=1
                                        //     Parent Loop BB98_7 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	ldrb	w11, [x10], #1
	lsr	w12, w6, #2
	add	w12, w12, w6, lsl #5
	subs	x9, x9, #1                      // =1
	add	w11, w12, w11
	eor	w6, w11, w6
	b.ne	.LBB98_11
.LBB98_12:                              //   in Loop: Header=BB98_7 Depth=2
	cmp	w5, w6
	b.ne	.LBB98_4
.LBB98_13:                              //   in Loop: Header=BB98_7 Depth=2
	cmn	w8, #1                          // =1
	b.eq	.LBB98_6
// %bb.14:                              //   in Loop: Header=BB98_7 Depth=2
	ldr	x8, [x25, :lo12:p_sys_data_buf]
	ldr	w8, [x8]
	cmp	w8, w26
	b.ne	.LBB98_6
// %bb.15:                              //   in Loop: Header=BB98_7 Depth=2
	ldr	x8, [x27, :lo12:p_sys_spare_buf]
	ldrsh	w8, [x8]
	cmn	w8, #3932                       // =3932
	b.ne	.LBB98_6
	b	.LBB98_18
.LBB98_16:                              //   in Loop: Header=BB98_7 Depth=2
	ldrh	w8, [x22, :lo12:gSysInfo+4]
	cmp	w23, w8
	b.eq	.LBB98_5
// %bb.17:                              //   in Loop: Header=BB98_3 Depth=1
	adrp	x9, c_ftl_nand_page_pre_slc_blk
	ldrh	w9, [x9, :lo12:c_ftl_nand_page_pre_slc_blk]
	sub	w9, w9, #1                      // =1
	sxth	w24, w9
	mov	w19, w24
	tbz	w9, #15, .LBB98_3
	b	.LBB98_19
.LBB98_18:
	tbz	w19, #15, .LBB98_20
.LBB98_19:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlLoadSysInfo
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlLoadSysInfo
	mov	w2, #1474
	bl	sftl_printk
.LBB98_20:
	adrp	x19, c_ftl_nand_data_blks_per_plane
	ldrh	w8, [x19, :lo12:c_ftl_nand_data_blks_per_plane]
	ldrh	w9, [x21, :lo12:c_ftl_nand_byte_pre_page]
	lsl	x2, x8, #1
	add	x8, x2, #48                     // =48
	cmp	x8, x9
	b.ls	.LBB98_22
// %bb.21:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlLoadSysInfo
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlLoadSysInfo
	mov	w2, #1476
	bl	sftl_printk
	ldrh	w8, [x19, :lo12:c_ftl_nand_data_blks_per_plane]
	lsl	x2, x8, #1
.LBB98_22:
	adrp	x8, req_sys+8
	ldr	x8, [x8, :lo12:req_sys+8]
	adrp	x19, g_sys_save_data
	add	x19, x19, :lo12:g_sys_save_data
	adrp	x13, p_valid_page_count_table
	ldp	x9, x10, [x8]
	ldr	x0, [x13, :lo12:p_valid_page_count_table]
	add	x1, x8, #48                     // =48
	stp	x9, x10, [x19]
	ldp	x9, x10, [x8, #32]
	ldp	x12, x11, [x8, #16]
	stp	x9, x10, [x19, #32]
	stp	x12, x11, [x19, #16]
	bl	memcpy
	ldr	w8, [x19]
	cmp	w8, w26
	b.ne	.LBB98_39
// %bb.23:
	adrp	x8, g_sys_save_data+8
	add	x8, x8, :lo12:g_sys_save_data+8
	adrp	x9, c_ftl_nand_die_num
	ldrb	w10, [x8, #2]
	ldrh	w9, [x9, :lo12:c_ftl_nand_die_num]
	ldrh	w8, [x8]
	adrp	x11, gSysInfo+6
	cmp	w9, w10
	strh	w8, [x11, :lo12:gSysInfo+6]
	b.ne	.LBB98_39
// %bb.24:
	adrp	x9, c_ftl_nand_max_data_blks
	adrp	x10, gBbtInfo+6
	adrp	x12, c_ftl_nand_page_pre_blk
	ldr	w9, [x9, :lo12:c_ftl_nand_max_data_blks]
	ldrh	w10, [x10, :lo12:gBbtInfo+6]
	ldrh	w12, [x12, :lo12:c_ftl_nand_page_pre_blk]
	adrp	x11, g_MaxLbn
	str	w8, [x11, :lo12:g_MaxLbn]
	subs	w11, w9, w8
	cmp	w9, w8
	mul	w8, w12, w8
	adrp	x9, g_MaxLpn
	sub	w10, w11, w10
	adrp	x11, c_ftl_nand_sec_pre_page
	ldrh	w11, [x11, :lo12:c_ftl_nand_sec_pre_page]
	str	w8, [x9, :lo12:g_MaxLpn]
	adrp	x9, c_ftl_nand_planes_num
	ldrh	w9, [x9, :lo12:c_ftl_nand_planes_num]
	mul	w8, w8, w11
	adrp	x11, g_MaxLbaSector
	str	w8, [x11, :lo12:g_MaxLbaSector]
	udiv	w8, w10, w9
	adrp	x9, c_ftl_nand_data_op_blks_per_plane
	strh	w8, [x9, :lo12:c_ftl_nand_data_op_blks_per_plane]
	b.hs	.LBB98_26
// %bb.25:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlLoadSysInfo
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlLoadSysInfo
	mov	w2, #1498
	bl	sftl_printk
.LBB98_26:
	adrp	x8, g_sys_save_data+11
	add	x8, x8, :lo12:g_sys_save_data+11
	ldur	w11, [x8, #21]
	adrp	x13, g_totle_mlc_erase_count
	ldurh	w14, [x8, #11]
	adrp	x12, g_gc_temp_superblock
	str	w11, [x13, :lo12:g_totle_mlc_erase_count]
	ldrb	w11, [x8, #2]
	ldurh	w13, [x8, #13]
	adrp	x10, g_gc_superblock
	add	x12, x12, :lo12:g_gc_temp_superblock
	add	x10, x10, :lo12:g_gc_superblock
	strh	w14, [x12]
	mov	w14, #65535
	strb	w11, [x12, #8]
	lsr	w11, w13, #6
	strh	w11, [x12, #2]
	and	w11, w13, #0x3f
	str	w14, [x10]
	adrp	x13, g_totle_read_page_count
	adrp	x14, g_totle_slc_erase_count
	str	wzr, [x13, :lo12:g_totle_read_page_count]
	ldrb	w13, [x8]
	str	wzr, [x14, :lo12:g_totle_slc_erase_count]
	ldurh	w14, [x8, #5]
	adrp	x9, g_active_superblock
	strb	w11, [x12, #6]
	adrp	x12, g_totle_write_page_count
	add	x9, x9, :lo12:g_active_superblock
	str	wzr, [x12, :lo12:g_totle_write_page_count]
	adrp	x12, g_max_erase_count
	str	wzr, [x12, :lo12:g_max_erase_count]
	strb	w13, [x9, #8]
	lsr	w12, w14, #6
	and	w13, w14, #0x3f
	strb	wzr, [x10, #6]
	strb	wzr, [x10, #8]
	adrp	x10, g_totle_l2p_write_count
	strh	w12, [x9, #2]
	ldurh	w12, [x8, #9]
	strb	w13, [x9, #6]
	ldrb	w13, [x8, #1]
	str	wzr, [x10, :lo12:g_totle_l2p_write_count]
	ldurh	w10, [x8, #3]
	adrp	x15, g_buffer_superblock
	add	x15, x15, :lo12:g_buffer_superblock
	adrp	x11, g_totle_gc_page_count
	str	wzr, [x11, :lo12:g_totle_gc_page_count]
	adrp	x11, g_GlobalSysVersion
	strb	w13, [x15, #8]
	lsr	w13, w12, #6
	strh	w10, [x9]
	ldurh	w9, [x8, #7]
	ldur	w8, [x8, #29]
	strh	w13, [x15, #2]
	ldr	w13, [x11, :lo12:g_GlobalSysVersion]
	and	w12, w12, #0x3f
	strb	w12, [x15, #6]
	adrp	x12, g_totle_cache_write_count
	cmp	w8, w13
	strh	w9, [x15]
	str	wzr, [x12, :lo12:g_totle_cache_write_count]
	b.ls	.LBB98_28
// %bb.27:
	str	w8, [x11, :lo12:g_GlobalSysVersion]
.LBB98_28:
	adrp	x11, g_sys_save_data+36
	adrp	x8, g_GlobalDataVersion
	ldr	w11, [x11, :lo12:g_sys_save_data+36]
	ldr	w12, [x8, :lo12:g_GlobalDataVersion]
	cmp	w11, w12
	b.ls	.LBB98_30
// %bb.29:
	str	w11, [x8, :lo12:g_GlobalDataVersion]
.LBB98_30:
	mov	w19, #65535
	cmp	w10, w19
	b.eq	.LBB98_32
// %bb.31:
	adrp	x0, g_active_superblock
	add	x0, x0, :lo12:g_active_superblock
	bl	make_superblock
	adrp	x8, g_buffer_superblock
	ldrh	w9, [x8, :lo12:g_buffer_superblock]
.LBB98_32:
	cmp	w9, w19
	b.eq	.LBB98_34
// %bb.33:
	adrp	x0, g_buffer_superblock
	add	x0, x0, :lo12:g_buffer_superblock
	bl	make_superblock
.LBB98_34:
	adrp	x8, g_gc_temp_superblock
	ldrsh	w8, [x8, :lo12:g_gc_temp_superblock]
	cmn	w8, #1                          // =1
	b.eq	.LBB98_36
// %bb.35:
	adrp	x0, g_gc_temp_superblock
	add	x0, x0, :lo12:g_gc_temp_superblock
	bl	make_superblock
.LBB98_36:
	adrp	x8, g_gc_superblock
	ldrsh	w8, [x8, :lo12:g_gc_superblock]
	cmn	w8, #1                          // =1
	b.eq	.LBB98_38
// %bb.37:
	adrp	x0, g_gc_superblock
	add	x0, x0, :lo12:g_gc_superblock
	bl	make_superblock
.LBB98_38:
	mov	w0, wzr
	b	.LBB98_40
.LBB98_39:
	mov	w0, #-1
.LBB98_40:
	ldp	x20, x19, [sp, #80]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #96             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end98:
	.size	FtlLoadSysInfo, .Lfunc_end98-FtlLoadSysInfo
                                        // -- End function
	.globl	FtlMapTblRecovery               // -- Begin function FtlMapTblRecovery
	.p2align	2
	.type	FtlMapTblRecovery,@function
FtlMapTblRecovery:                      // @FtlMapTblRecovery
// %bb.0:
	hint	#25
	sub	sp, sp, #128                    // =128
	stp	x20, x19, [sp, #112]            // 16-byte Folded Spill
	mov	x19, x0
	stp	x28, x27, [sp, #48]             // 16-byte Folded Spill
	ldrh	w28, [x19, #6]
	ldr	x0, [x0, #40]
	ldp	x27, x8, [x19, #16]
	stp	x22, x21, [sp, #96]             // 16-byte Folded Spill
	ldrh	w22, [x19, #8]
	stp	x29, x30, [sp, #32]             // 16-byte Folded Spill
	add	x29, sp, #32                    // =32
	lsl	x2, x28, #2
	mov	w1, wzr
	stp	x26, x25, [sp, #64]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #80]             // 16-byte Folded Spill
	str	x8, [sp, #8]                    // 8-byte Folded Spill
	stur	x0, [x29, #-8]                  // 8-byte Folded Spill
	bl	memset
	adrp	x10, p_sys_data_buf
	adrp	x9, p_sys_spare_buf
	ldr	x10, [x10, :lo12:p_sys_data_buf]
	ldr	x21, [x9, :lo12:p_sys_spare_buf]
	adrp	x8, req_sys+8
	add	x8, x8, :lo12:req_sys+8
	mov	w11, #-1
	mov	w9, #1
	adrp	x20, c_ftl_nand_page_pre_slc_blk
	stp	x10, x21, [x8]
	str	w11, [x19]
	str	xzr, [x19, #48]
	str	w9, [x19, #56]
	str	w22, [sp, #16]                  // 4-byte Folded Spill
	cbz	w22, .LBB99_40
// %bb.1:
	ldr	w8, [sp, #16]                   // 4-byte Folded Reload
	adrp	x22, req_sys
	mov	w23, wzr
	add	x22, x22, :lo12:req_sys
	sub	w8, w8, #1                      // =1
	adrp	x24, c_ftl_nand_byte_pre_page
	stur	w8, [x29, #-12]                 // 4-byte Folded Spill
	b	.LBB99_3
.LBB99_2:                               //   in Loop: Header=BB99_3 Depth=1
	add	w8, w23, #1                     // =1
	sxth	w23, w8
	ldr	w8, [sp, #16]                   // 4-byte Folded Reload
	cmp	w23, w8
	b.ge	.LBB99_40
.LBB99_3:                               // =>This Loop Header: Depth=1
                                        //     Child Loop BB99_10 Depth 2
                                        //     Child Loop BB99_16 Depth 2
                                        //       Child Loop BB99_20 Depth 3
	ldur	w8, [x29, #-12]                 // 4-byte Folded Reload
	cmp	w8, w23
	b.eq	.LBB99_26
// %bb.4:                               //   in Loop: Header=BB99_3 Depth=1
	adrp	x8, p_sys_data_buf
	ldr	x8, [x8, :lo12:p_sys_data_buf]
	sxth	x25, w23
	mov	w1, #1
	mov	x0, x22
	str	x8, [x22, #8]
	ldrh	w8, [x20, :lo12:c_ftl_nand_page_pre_slc_blk]
	ldrh	w9, [x27, x25, lsl #1]
	sub	w8, w8, #1                      // =1
	orr	w8, w8, w9, lsl #10
	str	w8, [x22, #4]
	bl	FlashReadPages
	ldr	w8, [x22]
	cmn	w8, #1                          // =1
	b.eq	.LBB99_12
// %bb.5:                               //   in Loop: Header=BB99_3 Depth=1
	ldrh	w8, [x21]
	ldrh	w9, [x19, #4]
	cmp	w8, w9
	b.ne	.LBB99_12
// %bb.6:                               //   in Loop: Header=BB99_3 Depth=1
	ldrsh	w8, [x21, #8]
	cmn	w8, #1291                       // =1291
	b.ne	.LBB99_12
// %bb.7:                               //   in Loop: Header=BB99_3 Depth=1
	ldrh	w8, [x20, :lo12:c_ftl_nand_page_pre_slc_blk]
	cmp	w8, #2                          // =2
	b.lo	.LBB99_2
// %bb.8:                               //   in Loop: Header=BB99_3 Depth=1
	mov	w9, wzr
	b	.LBB99_10
.LBB99_9:                               //   in Loop: Header=BB99_10 Depth=2
	add	w9, w9, #1                      // =1
	and	w10, w8, #0xffff
	sxth	w9, w9
	sub	w10, w10, #1                    // =1
	cmp	w10, w9
	b.le	.LBB99_2
.LBB99_10:                              //   Parent Loop BB99_3 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	adrp	x10, p_sys_data_buf
	ldr	x10, [x10, :lo12:p_sys_data_buf]
	sbfiz	x12, x9, #1, #32
	sxtw	x11, w12
	lsl	x11, x11, #2
	ldrh	w11, [x10, x11]
	cmp	w11, w28
	b.hs	.LBB99_9
// %bb.11:                              //   in Loop: Header=BB99_10 Depth=2
	lsl	x8, x12, #2
	orr	x8, x8, #0x4
	ldr	w8, [x10, x8]
	ldur	x10, [x29, #-8]                 // 8-byte Folded Reload
	str	w8, [x10, x11, lsl #2]
	ldrh	w8, [x20, :lo12:c_ftl_nand_page_pre_slc_blk]
	b	.LBB99_9
.LBB99_12:                              //   in Loop: Header=BB99_3 Depth=1
	ldrh	w8, [x20, :lo12:c_ftl_nand_page_pre_slc_blk]
	cbz	w8, .LBB99_2
// %bb.13:                              //   in Loop: Header=BB99_3 Depth=1
	mov	w26, wzr
	b	.LBB99_16
.LBB99_14:                              //   in Loop: Header=BB99_16 Depth=2
	adrp	x0, .L.str.99
	adrp	x1, .L__func__.FtlMapTblRecovery
	add	x0, x0, :lo12:.L.str.99
	add	x1, x1, :lo12:.L__func__.FtlMapTblRecovery
	mov	w2, w23
	mov	w3, w26
	bl	sftl_printk
	adrp	x8, req_sys
	mov	w9, #-1
	str	w9, [x8, :lo12:req_sys]
.LBB99_15:                              //   in Loop: Header=BB99_16 Depth=2
	ldrh	w8, [x20, :lo12:c_ftl_nand_page_pre_slc_blk]
	add	w9, w26, #1                     // =1
	sxth	w26, w9
	cmp	w26, w8
	b.ge	.LBB99_2
.LBB99_16:                              //   Parent Loop BB99_3 Depth=1
                                        // =>  This Loop Header: Depth=2
                                        //       Child Loop BB99_20 Depth 3
	ldrh	w8, [x27, x25, lsl #1]
	mov	w1, #1
	mov	x0, x22
	orr	w8, w26, w8, lsl #10
	str	w8, [x22, #4]
	bl	FlashReadPages
	ldr	x8, [x22, #16]
	ldr	w4, [x8, #12]
	ldr	w8, [x22]
	cbz	w4, .LBB99_22
// %bb.17:                              //   in Loop: Header=BB99_16 Depth=2
	cmn	w8, #1                          // =1
	b.eq	.LBB99_22
// %bb.18:                              //   in Loop: Header=BB99_16 Depth=2
	ldrh	w9, [x24, :lo12:c_ftl_nand_byte_pre_page]
	mov	w5, #42982
	movk	w5, #18374, lsl #16
	cbz	x9, .LBB99_21
// %bb.19:                              //   in Loop: Header=BB99_16 Depth=2
	adrp	x10, req_sys+8
	ldr	x10, [x10, :lo12:req_sys+8]
	mov	w5, #42982
	movk	w5, #18374, lsl #16
.LBB99_20:                              //   Parent Loop BB99_3 Depth=1
                                        //     Parent Loop BB99_16 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	ldrb	w11, [x10], #1
	lsr	w12, w5, #2
	add	w12, w12, w5, lsl #5
	subs	x9, x9, #1                      // =1
	add	w11, w12, w11
	eor	w5, w11, w5
	b.ne	.LBB99_20
.LBB99_21:                              //   in Loop: Header=BB99_16 Depth=2
	cmp	w4, w5
	b.ne	.LBB99_14
.LBB99_22:                              //   in Loop: Header=BB99_16 Depth=2
	cmn	w8, #1                          // =1
	b.eq	.LBB99_15
// %bb.23:                              //   in Loop: Header=BB99_16 Depth=2
	ldrh	w8, [x21, #8]
	cmp	w8, w28
	b.hs	.LBB99_15
// %bb.24:                              //   in Loop: Header=BB99_16 Depth=2
	ldrh	w9, [x21]
	ldrh	w10, [x19, #4]
	cmp	w9, w10
	b.ne	.LBB99_15
// %bb.25:                              //   in Loop: Header=BB99_16 Depth=2
	adrp	x9, req_sys+4
	ldr	w9, [x9, :lo12:req_sys+4]
	ldur	x10, [x29, #-8]                 // 8-byte Folded Reload
	str	w9, [x10, x8, lsl #2]
	b	.LBB99_15
.LBB99_26:
	mov	w8, w23
	sxth	x26, w8
	ldrh	w0, [x27, x26, lsl #1]
	mov	w1, #1
	bl	FtlGetLastWrittenPage
	add	w8, w0, #1                      // =1
	strh	w8, [x19, #2]
	ldr	x8, [sp, #8]                    // 8-byte Folded Reload
	strh	w23, [x19]
	ldr	w8, [x8, x26, lsl #2]
	str	w8, [x19, #48]
	tbnz	w0, #15, .LBB99_40
// %bb.27:
	mov	w23, wzr
	sxth	w25, w0
	b	.LBB99_30
.LBB99_28:                              //   in Loop: Header=BB99_30 Depth=1
	ldur	w2, [x29, #-12]                 // 4-byte Folded Reload
	adrp	x0, .L.str.98
	adrp	x1, .L__func__.FtlMapTblRecovery
	add	x0, x0, :lo12:.L.str.98
	add	x1, x1, :lo12:.L__func__.FtlMapTblRecovery
	mov	w3, w23
	bl	sftl_printk
	adrp	x8, req_sys
	mov	w9, #-1
	str	w9, [x8, :lo12:req_sys]
.LBB99_29:                              //   in Loop: Header=BB99_30 Depth=1
	add	w8, w23, #1                     // =1
	sxth	w23, w8
	cmp	w25, w23
	b.lt	.LBB99_40
.LBB99_30:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB99_34 Depth 2
	ldrh	w8, [x27, x26, lsl #1]
	mov	w1, #1
	mov	x0, x22
	orr	w8, w23, w8, lsl #10
	str	w8, [x22, #4]
	bl	FlashReadPages
	ldr	x8, [x22, #16]
	ldr	w4, [x8, #12]
	ldr	w8, [x22]
	cbz	w4, .LBB99_36
// %bb.31:                              //   in Loop: Header=BB99_30 Depth=1
	cmn	w8, #1                          // =1
	b.eq	.LBB99_36
// %bb.32:                              //   in Loop: Header=BB99_30 Depth=1
	ldrh	w9, [x24, :lo12:c_ftl_nand_byte_pre_page]
	mov	w5, #42982
	movk	w5, #18374, lsl #16
	cbz	x9, .LBB99_35
// %bb.33:                              //   in Loop: Header=BB99_30 Depth=1
	adrp	x10, req_sys+8
	ldr	x10, [x10, :lo12:req_sys+8]
	mov	w5, #42982
	movk	w5, #18374, lsl #16
.LBB99_34:                              //   Parent Loop BB99_30 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldrb	w11, [x10], #1
	lsr	w12, w5, #2
	add	w12, w12, w5, lsl #5
	subs	x9, x9, #1                      // =1
	add	w11, w12, w11
	eor	w5, w11, w5
	b.ne	.LBB99_34
.LBB99_35:                              //   in Loop: Header=BB99_30 Depth=1
	cmp	w4, w5
	b.ne	.LBB99_28
.LBB99_36:                              //   in Loop: Header=BB99_30 Depth=1
	cmn	w8, #1                          // =1
	b.eq	.LBB99_29
// %bb.37:                              //   in Loop: Header=BB99_30 Depth=1
	ldrh	w8, [x21, #8]
	cmp	w8, w28
	b.hs	.LBB99_29
// %bb.38:                              //   in Loop: Header=BB99_30 Depth=1
	ldrh	w9, [x21]
	ldrh	w10, [x19, #4]
	cmp	w9, w10
	b.ne	.LBB99_29
// %bb.39:                              //   in Loop: Header=BB99_30 Depth=1
	adrp	x9, req_sys+4
	ldr	w9, [x9, :lo12:req_sys+4]
	ldur	x10, [x29, #-8]                 // 8-byte Folded Reload
	str	w9, [x10, x8, lsl #2]
	b	.LBB99_29
.LBB99_40:
	mov	x0, x19
	bl	ftl_free_no_use_map_blk
	ldrh	w8, [x19, #2]
	ldrh	w9, [x20, :lo12:c_ftl_nand_page_pre_slc_blk]
	cmp	w8, w9
	b.ne	.LBB99_42
// %bb.41:
	mov	x0, x19
	bl	ftl_map_blk_alloc_new_blk
.LBB99_42:
	mov	x0, x19
	bl	ftl_map_blk_gc
	mov	x0, x19
	bl	ftl_map_blk_gc
	ldp	x20, x19, [sp, #112]            // 16-byte Folded Reload
	ldp	x22, x21, [sp, #96]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #80]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #64]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #48]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #32]             // 16-byte Folded Reload
	mov	w0, wzr
	add	sp, sp, #128                    // =128
	hint	#29
	ret
.Lfunc_end99:
	.size	FtlMapTblRecovery, .Lfunc_end99-FtlMapTblRecovery
                                        // -- End function
	.globl	FtlLoadVonderInfo               // -- Begin function FtlLoadVonderInfo
	.p2align	2
	.type	FtlLoadVonderInfo,@function
FtlLoadVonderInfo:                      // @FtlLoadVonderInfo
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
	adrp	x8, c_ftl_nand_max_vendor_blks
	adrp	x10, g_totle_vendor_block
	adrp	x11, c_ftl_nand_vendor_region_num
	ldrh	w8, [x8, :lo12:c_ftl_nand_max_vendor_blks]
	ldrh	w10, [x10, :lo12:g_totle_vendor_block]
	ldrh	w11, [x11, :lo12:c_ftl_nand_vendor_region_num]
	adrp	x0, gVendorBlkInfo
	add	x0, x0, :lo12:gVendorBlkInfo
	mov	w9, #61574
	strh	w9, [x0, #4]
	adrp	x9, p_vendor_block_table
	strh	w8, [x0, #10]
	adrp	x8, p_vendor_block_ver_table
	strh	w10, [x0, #8]
	adrp	x10, p_vendor_block_valid_page_count
	strh	w11, [x0, #6]
	adrp	x11, p_vendor_region_ppn_table
	ldr	x9, [x9, :lo12:p_vendor_block_table]
	ldr	x8, [x8, :lo12:p_vendor_block_ver_table]
	ldr	x10, [x10, :lo12:p_vendor_block_valid_page_count]
	ldr	x11, [x11, :lo12:p_vendor_region_ppn_table]
	mov	x29, sp
	stp	x9, x8, [x0, #16]
	stp	x10, x11, [x0, #32]
	bl	FtlMapTblRecovery
	mov	w0, wzr
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end100:
	.size	FtlLoadVonderInfo, .Lfunc_end100-FtlLoadVonderInfo
                                        // -- End function
	.globl	FtlLoadMapInfo                  // -- Begin function FtlLoadMapInfo
	.p2align	2
	.type	FtlLoadMapInfo,@function
FtlLoadMapInfo:                         // @FtlLoadMapInfo
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-64]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #48]             // 16-byte Folded Spill
	adrp	x20, c_ftl_nand_max_map_blks
	adrp	x19, p_map_block_valid_page_count
	ldr	w8, [x20, :lo12:c_ftl_nand_max_map_blks]
	ldr	x0, [x19, :lo12:p_map_block_valid_page_count]
	mov	w1, wzr
	str	x23, [sp, #16]                  // 8-byte Folded Spill
	lsl	w2, w8, #1
	stp	x22, x21, [sp, #32]             // 16-byte Folded Spill
	mov	x29, sp
	bl	memset
	adrp	x22, c_ftl_nand_byte_pre_page
	adrp	x23, c_ftl_nand_l2pmap_ram_region_num
	adrp	x21, p_l2p_map_buf
	ldrh	w8, [x22, :lo12:c_ftl_nand_byte_pre_page]
	ldrh	w9, [x23, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	ldr	x0, [x21, :lo12:p_l2p_map_buf]
	mov	w1, #255
	mul	x2, x9, x8
	bl	memset
	ldrh	w8, [x23, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	cbz	w8, .LBB101_3
// %bb.1:
	mov	x8, xzr
	mov	x9, xzr
	mov	x10, xzr
	adrp	x11, p_l2p_ram_map
	mov	w12, #65535
	mov	x13, #4294967296
.LBB101_2:                              // =>This Inner Loop Header: Depth=1
	ldr	x14, [x11, :lo12:p_l2p_ram_map]
	add	x10, x10, #1                    // =1
	add	x14, x14, x8
	str	wzr, [x14, #4]
	ldr	x14, [x11, :lo12:p_l2p_ram_map]
	strh	w12, [x14, x8]
	ldrh	w14, [x22, :lo12:c_ftl_nand_byte_pre_page]
	ldr	x15, [x21, :lo12:p_l2p_map_buf]
	ldr	x16, [x11, :lo12:p_l2p_ram_map]
	mul	x14, x9, x14
	asr	x14, x14, #32
	and	x14, x14, #0xfffffffffffffffc
	add	x14, x15, x14
	add	x15, x16, x8
	str	x14, [x15, #8]
	ldrh	w14, [x23, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	add	x9, x9, x13
	add	x8, x8, #16                     // =16
	cmp	x10, x14
	b.lo	.LBB101_2
.LBB101_3:
	adrp	x0, gL2pMapInfo
	add	x0, x0, :lo12:gL2pMapInfo
	mov	w8, #-255655937
	mov	w9, #65535
	stur	w8, [x0, #2]
	adrp	x8, g_totle_map_block
	strh	w9, [x0]
	adrp	x9, c_ftl_nand_map_region_num
	ldr	w10, [x20, :lo12:c_ftl_nand_max_map_blks]
	ldrh	w8, [x8, :lo12:g_totle_map_block]
	ldrh	w9, [x9, :lo12:c_ftl_nand_map_region_num]
	ldr	x11, [x19, :lo12:p_map_block_valid_page_count]
	strh	w10, [x0, #10]
	adrp	x10, p_map_block_table
	strh	w8, [x0, #8]
	adrp	x8, p_map_block_ver_table
	strh	w9, [x0, #6]
	adrp	x9, p_map_region_ppn_table
	ldr	x10, [x10, :lo12:p_map_block_table]
	ldr	x8, [x8, :lo12:p_map_block_ver_table]
	ldr	x9, [x9, :lo12:p_map_region_ppn_table]
	stp	x10, x8, [x0, #16]
	stp	x11, x9, [x0, #32]
	bl	FtlMapTblRecovery
	ldp	x20, x19, [sp, #48]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #32]             // 16-byte Folded Reload
	ldr	x23, [sp, #16]                  // 8-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #64             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end101:
	.size	FtlLoadMapInfo, .Lfunc_end101-FtlLoadMapInfo
                                        // -- End function
	.globl	ftl_sb_update_avl_pages         // -- Begin function ftl_sb_update_avl_pages
	.p2align	2
	.type	ftl_sb_update_avl_pages,@function
ftl_sb_update_avl_pages:                // @ftl_sb_update_avl_pages
// %bb.0:
	hint	#25
	strh	wzr, [x0, #4]
	adrp	x8, c_ftl_nand_planes_num
	ldrh	w8, [x8, :lo12:c_ftl_nand_planes_num]
                                        // kill: def $w2 killed $w2 def $x2
	mov	w9, wzr
	cmp	w8, w2, uxth
	b.ls	.LBB102_5
// %bb.1:
	mov	w9, wzr
	and	x10, x2, #0xffff
	add	x11, x0, #16                    // =16
	b	.LBB102_3
.LBB102_2:                              //   in Loop: Header=BB102_3 Depth=1
	add	x10, x10, #1                    // =1
	cmp	x10, x8
	b.hs	.LBB102_5
.LBB102_3:                              // =>This Inner Loop Header: Depth=1
	ldrsh	w12, [x11, x10, lsl #1]
	cmn	w12, #1                         // =1
	b.eq	.LBB102_2
// %bb.4:                               //   in Loop: Header=BB102_3 Depth=1
	add	w9, w9, #1                      // =1
	strh	w9, [x0, #4]
	b	.LBB102_2
.LBB102_5:
	cbz	w8, .LBB102_10
// %bb.6:
	adrp	x10, c_ftl_nand_page_pre_blk
	ldrh	w10, [x10, :lo12:c_ftl_nand_page_pre_blk]
	mvn	w11, w1
	add	w10, w10, w11
	add	x11, x0, #16                    // =16
	b	.LBB102_8
.LBB102_7:                              //   in Loop: Header=BB102_8 Depth=1
	subs	x8, x8, #1                      // =1
	add	x11, x11, #2                    // =2
	b.eq	.LBB102_10
.LBB102_8:                              // =>This Inner Loop Header: Depth=1
	ldrsh	w12, [x11]
	cmn	w12, #1                         // =1
	b.eq	.LBB102_7
// %bb.9:                               //   in Loop: Header=BB102_8 Depth=1
	add	w9, w10, w9
	strh	w9, [x0, #4]
	b	.LBB102_7
.LBB102_10:
	hint	#29
	ret
.Lfunc_end102:
	.size	ftl_sb_update_avl_pages, .Lfunc_end102-ftl_sb_update_avl_pages
                                        // -- End function
	.globl	FtlReUsePrevPpa                 // -- Begin function FtlReUsePrevPpa
	.p2align	2
	.type	FtlReUsePrevPpa,@function
FtlReUsePrevPpa:                        // @FtlReUsePrevPpa
// %bb.0:
	hint	#25
	sub	sp, sp, #96                     // =96
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #32]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #48]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #64]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #80]             // 16-byte Folded Spill
	adrp	x10, c_ftl_nand_blks_per_die
	str	x8, [sp, #8]
	ldrh	w10, [x10, :lo12:c_ftl_nand_blks_per_die]
	adrp	x11, c_ftl_nand_planes_per_die
	adrp	x21, p_valid_page_count_table
	ldrh	w11, [x11, :lo12:c_ftl_nand_planes_per_die]
	ubfx	w9, w1, #10, #16
	ldr	x8, [x21, :lo12:p_valid_page_count_table]
	udiv	w12, w9, w10
	msub	w9, w12, w10, w9
	str	w1, [sp, #4]
	udiv	w20, w9, w11
	ldrh	w9, [x8, w20, uxtw #1]
	mov	w19, w0
	add	x29, sp, #16                    // =16
	cbz	w9, .LBB103_4
// %bb.1:
	add	w9, w9, #1                      // =1
	strh	w9, [x8, x20, lsl #1]
.LBB103_2:
	add	x1, sp, #4                      // =4
	mov	w2, #1
	mov	w0, w19
	bl	log2phys
	adrp	x9, __stack_chk_guard
	ldr	x8, [sp, #8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB103_26
// %bb.3:
	ldp	x20, x19, [sp, #80]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	add	sp, sp, #96                     // =96
	hint	#29
	ret
.LBB103_4:
	adrp	x24, p_free_data_block_list_head
	ldr	x8, [x24, :lo12:p_free_data_block_list_head]
	cbz	x8, .LBB103_2
// %bb.5:
	adrp	x22, g_num_free_superblocks
	ldrh	w9, [x22, :lo12:g_num_free_superblocks]
	cbz	w9, .LBB103_2
// %bb.6:
	adrp	x23, p_data_block_list_table
	ldr	x10, [x23, :lo12:p_data_block_list_table]
	mov	w13, #43691
	movk	w13, #43690, lsl #16
	mov	w11, wzr
	sub	x14, x8, x10
	lsr	x14, x14, #1
	mov	w12, #6
	mul	w14, w14, w13
	mov	w13, #65535
.LBB103_7:                              // =>This Inner Loop Header: Depth=1
	and	w15, w14, #0xffff
	cmp	w15, w20, uxth
	b.eq	.LBB103_10
// %bb.8:                               //   in Loop: Header=BB103_7 Depth=1
	and	x14, x14, #0xffff
	mul	x14, x14, x12
	ldrh	w14, [x10, x14]
	cmp	w14, w13
	b.eq	.LBB103_2
// %bb.9:                               //   in Loop: Header=BB103_7 Depth=1
	add	w11, w11, #1                    // =1
	cmp	w9, w11, uxth
	b.hi	.LBB103_7
	b	.LBB103_2
.LBB103_10:
	mov	w9, #6
	madd	x25, x20, x9, x10
	mov	x26, x25
	ldrh	w9, [x26, #2]!
	cmp	x25, x8
	b.eq	.LBB103_13
// %bb.11:
	mov	w10, #65535
	cmp	w9, w10
	b.ne	.LBB103_13
// %bb.12:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.List_remove_node
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.List_remove_node
	mov	w2, #372
	bl	sftl_printk
	ldr	x8, [x24, :lo12:p_free_data_block_list_head]
.LBB103_13:
	ldrh	w9, [x25]
	cmp	x25, x8
	b.eq	.LBB103_16
// %bb.14:
	mov	w8, #65535
	cmp	w9, w8
	b.eq	.LBB103_18
// %bb.15:
	ldr	x8, [x23, :lo12:p_data_block_list_table]
	ldrh	w10, [x26]
	mov	w11, #6
	madd	x8, x9, x11, x8
	strh	w10, [x8, #2]
	ldrh	w9, [x26]
	ldr	x8, [x23, :lo12:p_data_block_list_table]
	ldrh	w10, [x25]
	mul	x9, x9, x11
	strh	w10, [x8, x9]
	b	.LBB103_21
.LBB103_16:
	mov	w8, #65535
	cmp	w9, w8
	b.eq	.LBB103_20
// %bb.17:
	ldr	x10, [x23, :lo12:p_data_block_list_table]
	mov	w11, #6
	madd	x9, x9, x11, x10
	str	x9, [x24, :lo12:p_free_data_block_list_head]
	strh	w8, [x9, #2]
	b	.LBB103_21
.LBB103_18:
	ldrh	w8, [x26]
	mov	w9, #65535
	cmp	x8, x9
	b.eq	.LBB103_21
// %bb.19:
	ldr	x10, [x23, :lo12:p_data_block_list_table]
	mov	w11, #6
	mul	x8, x8, x11
	strh	w9, [x10, x8]
	b	.LBB103_21
.LBB103_20:
	str	xzr, [x24, :lo12:p_free_data_block_list_head]
.LBB103_21:
	mov	w8, #65535
	strh	w8, [x25]
	strh	w8, [x26]
	ldrh	w8, [x22, :lo12:g_num_free_superblocks]
	cbnz	w8, .LBB103_23
// %bb.22:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlReUsePrevPpa
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlReUsePrevPpa
	mov	w2, #1742
	bl	sftl_printk
	ldrh	w8, [x22, :lo12:g_num_free_superblocks]
.LBB103_23:
	sub	w8, w8, #1                      // =1
	mov	w0, w20
	strh	w8, [x22, :lo12:g_num_free_superblocks]
	bl	insert_data_list
	adrp	x8, g_num_data_superblocks
	ldrh	w9, [x8, :lo12:g_num_data_superblocks]
	adrp	x10, c_ftl_nand_data_blks_per_plane
	ldrh	w10, [x10, :lo12:c_ftl_nand_data_blks_per_plane]
	add	w9, w9, #1                      // =1
	strh	w9, [x8, :lo12:g_num_data_superblocks]
	cmp	w10, w9, uxth
	b.hs	.LBB103_25
// %bb.24:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.INSERT_DATA_LIST
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.INSERT_DATA_LIST
	mov	w2, #214
	bl	sftl_printk
.LBB103_25:
	ldr	x8, [x21, :lo12:p_valid_page_count_table]
	lsl	x9, x20, #1
	ldrh	w10, [x8, x9]
	add	w10, w10, #1                    // =1
	strh	w10, [x8, x9]
	b	.LBB103_2
.LBB103_26:
	bl	__stack_chk_fail
.Lfunc_end103:
	.size	FtlReUsePrevPpa, .Lfunc_end103-FtlReUsePrevPpa
                                        // -- End function
	.globl	FtlRecoverySuperblock           // -- Begin function FtlRecoverySuperblock
	.p2align	2
	.type	FtlRecoverySuperblock,@function
FtlRecoverySuperblock:                  // @FtlRecoverySuperblock
// %bb.0:
	hint	#25
	sub	sp, sp, #160                    // =160
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	stp	x29, x30, [sp, #64]             // 16-byte Folded Spill
	add	x29, sp, #64                    // =64
	stp	x28, x27, [sp, #80]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #96]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #112]            // 16-byte Folded Spill
	stp	x22, x21, [sp, #128]            // 16-byte Folded Spill
	stp	x20, x19, [sp, #144]            // 16-byte Folded Spill
	stur	x8, [x29, #-8]
	ldrsh	w8, [x0]
	cmn	w8, #1                          // =1
	b.eq	.LBB104_148
// %bb.1:
	adrp	x24, c_ftl_nand_page_pre_blk
	ldrh	w25, [x0, #2]
	ldrh	w8, [x24, :lo12:c_ftl_nand_page_pre_blk]
	mov	x19, x0
	cmp	w25, w8
	b.ne	.LBB104_3
// %bb.2:
	strh	wzr, [x19, #4]
	strb	wzr, [x19, #6]
	b	.LBB104_148
.LBB104_3:
	ldrb	w8, [x19, #6]
	ldrh	w0, [x19, #16]
	str	w8, [sp, #32]                   // 4-byte Folded Spill
	mov	w8, #65535
	cmp	w0, w8
	b.eq	.LBB104_5
// %bb.4:
	mov	w21, wzr
	b	.LBB104_7
.LBB104_5:
	mov	w21, wzr
.LBB104_6:                              // =>This Inner Loop Header: Depth=1
	add	w21, w21, #1                    // =1
	add	x9, x19, w21, uxth #1
	ldrh	w0, [x9, #16]
	cmp	w0, w8
	b.eq	.LBB104_6
.LBB104_7:
	mov	w1, #1
	bl	FtlGetLastWrittenPage
	cmn	w0, #1                          // =1
	b.eq	.LBB104_13
// %bb.8:
	adrp	x26, c_ftl_nand_planes_num
	ldrh	w15, [x26, :lo12:c_ftl_nand_planes_num]
	mov	w20, w0
	adrp	x22, req_read
	cbz	w15, .LBB104_19
// %bb.9:
	mov	x8, xzr
	mov	w23, wzr
	add	x9, x19, #16                    // =16
	mov	w10, #65535
	adrp	x11, p_gc_data_buf
	adrp	x12, c_ftl_nand_byte_pre_page
	adrp	x13, p_gc_spare_buf
	adrp	x14, c_ftl_nand_byte_pre_oob
	b	.LBB104_11
.LBB104_10:                             //   in Loop: Header=BB104_11 Depth=1
	add	x8, x8, #1                      // =1
	cmp	x8, w15, uxth
	b.hs	.LBB104_20
.LBB104_11:                             // =>This Inner Loop Header: Depth=1
	ldrh	w16, [x9, x8, lsl #1]
	cmp	w16, w10
	b.eq	.LBB104_10
// %bb.12:                              //   in Loop: Header=BB104_11 Depth=1
	ldr	x15, [x22, :lo12:req_read]
	and	x17, x23, #0xffff
	lsl	x17, x17, #5
	orr	w16, w20, w16, lsl #10
	add	x15, x15, x17
	str	w16, [x15, #4]
	ldrh	w15, [x12, :lo12:c_ftl_nand_byte_pre_page]
	and	w16, w23, #0xffff
	ldr	x18, [x11, :lo12:p_gc_data_buf]
	ldr	x0, [x22, :lo12:req_read]
	mul	w15, w15, w16
	add	w1, w15, #3                     // =3
	cmp	w15, #0                         // =0
	csel	w15, w1, w15, lt
	asr	w15, w15, #2
	add	x0, x0, x17
	add	x15, x18, w15, sxtw #2
	str	x15, [x0, #8]
	ldrh	w15, [x14, :lo12:c_ftl_nand_byte_pre_oob]
	ldr	x18, [x13, :lo12:p_gc_spare_buf]
	ldr	x0, [x22, :lo12:req_read]
	add	w23, w23, #1                    // =1
	mul	w15, w15, w16
	add	w16, w15, #3                    // =3
	cmp	w15, #0                         // =0
	csel	w15, w16, w15, lt
	asr	w15, w15, #2
	add	x15, x18, w15, sxtw #2
	add	x16, x0, x17
	str	x15, [x16, #16]
	ldrh	w15, [x26, :lo12:c_ftl_nand_planes_num]
	b	.LBB104_10
.LBB104_13:
	cbz	w25, .LBB104_15
// %bb.14:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlRecoverySuperblock
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlRecoverySuperblock
	mov	w2, #1809
	bl	sftl_printk
.LBB104_15:
	ldr	w8, [sp, #32]                   // 4-byte Folded Reload
	cbz	w8, .LBB104_18
// %bb.16:
	cmp	w8, w21, uxth
	b.eq	.LBB104_18
// %bb.17:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlRecoverySuperblock
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlRecoverySuperblock
	mov	w2, #1810
	bl	sftl_printk
.LBB104_18:
	strh	wzr, [x19, #2]
	strb	wzr, [x19, #6]
	b	.LBB104_148
.LBB104_19:
	mov	w23, wzr
.LBB104_20:
	ldr	x0, [x22, :lo12:req_read]
	and	w21, w23, #0xffff
	mov	w1, w21
	bl	FlashReadPages
	adrp	x8, g_GlobalDataVersion
	ldr	w8, [x8, :lo12:g_GlobalDataVersion]
	cbz	w21, .LBB104_29
// %bb.21:
	ldr	x13, [x22, :lo12:req_read]
	mov	w9, w23
	mov	x10, xzr
	and	x11, x9, #0xffff
	mov	w9, #65535
	mov	w12, #-2147483648
	add	x13, x13, #16                   // =16
	mov	w14, #-2147483647
	mov	w15, w8
	b	.LBB104_24
.LBB104_22:                             //   in Loop: Header=BB104_24 Depth=1
	mov	w9, w20
.LBB104_23:                             //   in Loop: Header=BB104_24 Depth=1
	add	x10, x10, #1                    // =1
	cmp	x11, x10
	add	x13, x13, #32                   // =32
	b.eq	.LBB104_31
.LBB104_24:                             // =>This Inner Loop Header: Depth=1
	ldur	w16, [x13, #-16]
	cbnz	w16, .LBB104_22
// %bb.25:                              //   in Loop: Header=BB104_24 Depth=1
	ldr	x16, [x13]
	ldr	w17, [x16, #4]
	cmn	w17, #1                         // =1
	b.eq	.LBB104_28
// %bb.26:                              //   in Loop: Header=BB104_24 Depth=1
	subs	w18, w17, w15
	sub	w0, w15, w17
	cmp	w18, w12
	cset	w18, hi
	cmp	w0, w14
	cset	w0, lo
	cmp	w17, w15
	csel	w18, w18, w0, hi
	tbnz	w18, #0, .LBB104_28
// %bb.27:                              //   in Loop: Header=BB104_24 Depth=1
	add	w15, w17, #1                    // =1
	adrp	x17, g_GlobalDataVersion
	str	w15, [x17, :lo12:g_GlobalDataVersion]
.LBB104_28:                             //   in Loop: Header=BB104_24 Depth=1
	ldr	w16, [x16]
	cmn	w16, #1                         // =1
	b.ne	.LBB104_23
	b	.LBB104_30
.LBB104_29:
	mov	w10, wzr
	mov	w9, #65535
.LBB104_30:
	and	w11, w10, #0xffff
	cmp	w11, w23, uxth
	b.ne	.LBB104_32
.LBB104_31:
	ldr	x10, [x22, :lo12:req_read]
	adrp	x11, c_ftl_nand_blks_per_die
	adrp	x12, c_ftl_nand_planes_per_die
	ldrh	w11, [x11, :lo12:c_ftl_nand_blks_per_die]
	ldr	w10, [x10, #4]
	ldrh	w12, [x12, :lo12:c_ftl_nand_planes_per_die]
	add	w14, w20, #1                    // =1
	ubfx	w10, w10, #10, #16
	udiv	w11, w10, w11
	udiv	w13, w10, w12
	b	.LBB104_33
.LBB104_32:
	ldr	x11, [x22, :lo12:req_read]
                                        // kill: def $w10 killed $w10 killed $x10 def $x10
	adrp	x12, c_ftl_nand_planes_per_die
	and	x10, x10, #0xffff
	ldrh	w12, [x12, :lo12:c_ftl_nand_planes_per_die]
	add	x10, x11, x10, lsl #5
	ldr	w10, [x10, #4]
	adrp	x11, c_ftl_nand_blks_per_die
	ldrh	w11, [x11, :lo12:c_ftl_nand_blks_per_die]
	mov	w14, w20
	ubfx	w10, w10, #10, #16
	udiv	w13, w10, w12
	udiv	w11, w10, w11
.LBB104_33:
	mul	w11, w12, w11
	msub	w12, w13, w12, w10
	ldrh	w10, [x24, :lo12:c_ftl_nand_page_pre_blk]
	and	w13, w14, #0xffff
	cmp	w10, w13
	b.ne	.LBB104_35
// %bb.34:
	strh	w14, [x19, #2]
	strb	wzr, [x19, #6]
	strh	wzr, [x19, #4]
.LBB104_35:
	add	w12, w11, w12
	ldr	w11, [sp, #32]                  // 4-byte Folded Reload
	cmp	w13, w25
	b.ne	.LBB104_42
// %bb.36:
	cmp	w11, w12, uxth
	b.ne	.LBB104_42
// %bb.37:
	strh	wzr, [x19, #4]
	ldrh	w8, [x26, :lo12:c_ftl_nand_planes_num]
	mov	w9, wzr
	cmp	w8, w12, uxth
	b.ls	.LBB104_47
// %bb.38:
	sub	x11, x8, w12, uxth
	add	x12, x19, w12, uxth #1
	mov	w9, wzr
	add	x12, x12, #16                   // =16
	b	.LBB104_40
.LBB104_39:                             //   in Loop: Header=BB104_40 Depth=1
	subs	x11, x11, #1                    // =1
	add	x12, x12, #2                    // =2
	b.eq	.LBB104_47
.LBB104_40:                             // =>This Inner Loop Header: Depth=1
	ldrsh	w13, [x12]
	cmn	w13, #1                         // =1
	b.eq	.LBB104_39
// %bb.41:                              //   in Loop: Header=BB104_40 Depth=1
	add	w9, w9, #1                      // =1
	strh	w9, [x19, #4]
	b	.LBB104_39
.LBB104_42:
	sub	w26, w8, #1                     // =1
	mvn	w8, w9
	tst	w8, #0xffff
	str	x12, [sp, #24]                  // 8-byte Folded Spill
	stp	w25, w14, [x29, #-28]           // 8-byte Folded Spill
	b.eq	.LBB104_67
.LBB104_43:
	adrp	x9, g_recovery_page_min_ver
	ldr	w8, [x9, :lo12:g_recovery_page_min_ver]
	cmn	w8, #1                          // =1
	b.ne	.LBB104_45
// %bb.44:
	str	w26, [x9, :lo12:g_recovery_page_min_ver]
.LBB104_45:
	ldur	w10, [x29, #-28]                // 4-byte Folded Reload
	and	w21, w20, #0xffff
	sub	w9, w20, #7                     // =7
	add	w8, w10, #7                     // =7
	cmp	w21, w8
	csel	w8, w9, w10, hi
	and	w23, w8, #0xffff
	cmp	w21, w23
	b.hs	.LBB104_52
.LBB104_46:
	mov	w8, #-1
	adrp	x9, g_recovery_page_min_ver
	str	w8, [x9, :lo12:g_recovery_page_min_ver]
	b	.LBB104_68
.LBB104_47:
	cbz	w8, .LBB104_148
// %bb.48:
	mvn	w11, w14
	add	w10, w10, w11
	add	x11, x19, #16                   // =16
	b	.LBB104_50
.LBB104_49:                             //   in Loop: Header=BB104_50 Depth=1
	subs	x8, x8, #1                      // =1
	add	x11, x11, #2                    // =2
	b.eq	.LBB104_148
.LBB104_50:                             // =>This Inner Loop Header: Depth=1
	ldrsh	w12, [x11]
	cmn	w12, #1                         // =1
	b.eq	.LBB104_49
// %bb.51:                              //   in Loop: Header=BB104_50 Depth=1
	add	w9, w10, w9
	strh	w9, [x19, #4]
	b	.LBB104_49
.LBB104_52:
	add	x24, x19, #16                   // =16
	mov	w25, #65535
	b	.LBB104_54
.LBB104_53:                             //   in Loop: Header=BB104_54 Depth=1
	add	w8, w23, #1                     // =1
	and	w23, w8, #0xffff
	cmp	w21, w23
	b.lo	.LBB104_46
.LBB104_54:                             // =>This Loop Header: Depth=1
                                        //     Child Loop BB104_57 Depth 2
                                        //     Child Loop BB104_63 Depth 2
	adrp	x8, c_ftl_nand_planes_num
	ldrh	w9, [x8, :lo12:c_ftl_nand_planes_num]
	cbz	w9, .LBB104_59
// %bb.55:                              //   in Loop: Header=BB104_54 Depth=1
	mov	x8, xzr
	mov	w27, wzr
	b	.LBB104_57
.LBB104_56:                             //   in Loop: Header=BB104_57 Depth=2
	add	x8, x8, #1                      // =1
	cmp	x8, w9, uxth
	b.hs	.LBB104_60
.LBB104_57:                             //   Parent Loop BB104_54 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldrh	w10, [x24, x8, lsl #1]
	cmp	w10, w25
	b.eq	.LBB104_56
// %bb.58:                              //   in Loop: Header=BB104_57 Depth=2
	ldr	x9, [x22, :lo12:req_read]
	and	x11, x27, #0xffff
	orr	w10, w23, w10, lsl #10
	add	w27, w27, #1                    // =1
	add	x9, x9, x11, lsl #5
	str	w10, [x9, #4]
	adrp	x9, c_ftl_nand_planes_num
	ldrh	w9, [x9, :lo12:c_ftl_nand_planes_num]
	b	.LBB104_56
.LBB104_59:                             //   in Loop: Header=BB104_54 Depth=1
	mov	w27, wzr
.LBB104_60:                             //   in Loop: Header=BB104_54 Depth=1
	ldr	x0, [x22, :lo12:req_read]
	and	w20, w27, #0xffff
	mov	w1, w20
	bl	FlashReadPages
	cbz	w20, .LBB104_53
// %bb.61:                              //   in Loop: Header=BB104_54 Depth=1
	ldr	x9, [x22, :lo12:req_read]
                                        // kill: def $w27 killed $w27 killed $x27 def $x27
	and	x8, x27, #0xffff
	add	x9, x9, #16                     // =16
	b	.LBB104_63
.LBB104_62:                             //   in Loop: Header=BB104_63 Depth=2
	subs	x8, x8, #1                      // =1
	add	x9, x9, #32                     // =32
	b.eq	.LBB104_53
.LBB104_63:                             //   Parent Loop BB104_54 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldur	w10, [x9, #-16]
	cbnz	w10, .LBB104_68
// %bb.64:                              //   in Loop: Header=BB104_63 Depth=2
	ldr	x10, [x9]
	ldrsh	w11, [x10]
	cmn	w11, #1                         // =1
	b.eq	.LBB104_62
// %bb.65:                              //   in Loop: Header=BB104_63 Depth=2
	ldr	w10, [x10, #4]
	cmn	w10, #1                         // =1
	b.eq	.LBB104_62
// %bb.66:                              //   in Loop: Header=BB104_63 Depth=2
	adrp	x11, g_recovery_page_min_ver
	str	w10, [x11, :lo12:g_recovery_page_min_ver]
	b	.LBB104_62
.LBB104_67:
	ldrb	w8, [x19, #8]
	cbz	w8, .LBB104_43
.LBB104_68:
	ldur	w25, [x29, #-28]                // 4-byte Folded Reload
	adrp	x8, g_power_lost_recovery_flag
	mov	w9, #1
	add	x20, x19, #16                   // =16
	mov	w14, #65535
	mov	w28, w25
	strh	w9, [x8, :lo12:g_power_lost_recovery_flag]
	b	.LBB104_70
.LBB104_69:                             //   in Loop: Header=BB104_70 Depth=1
	adrp	x8, c_ftl_nand_page_pre_blk
	ldrh	w8, [x8, :lo12:c_ftl_nand_page_pre_blk]
	add	w28, w28, #1                    // =1
	mov	w14, #65535
	cmp	w8, w28, uxth
	b.eq	.LBB104_143
.LBB104_70:                             // =>This Loop Header: Depth=1
                                        //     Child Loop BB104_73 Depth 2
                                        //     Child Loop BB104_80 Depth 2
	adrp	x13, c_ftl_nand_planes_num
	ldrh	w10, [x13, :lo12:c_ftl_nand_planes_num]
	cbz	w10, .LBB104_75
// %bb.71:                              //   in Loop: Header=BB104_70 Depth=1
	mov	x8, xzr
	mov	w21, wzr
	and	w9, w28, #0xffff
	b	.LBB104_73
.LBB104_72:                             //   in Loop: Header=BB104_73 Depth=2
	add	x8, x8, #1                      // =1
	cmp	x8, w10, uxth
	b.hs	.LBB104_76
.LBB104_73:                             //   Parent Loop BB104_70 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldrh	w11, [x20, x8, lsl #1]
	cmp	w11, w14
	b.eq	.LBB104_72
// %bb.74:                              //   in Loop: Header=BB104_73 Depth=2
	ldr	x10, [x22, :lo12:req_read]
	and	x12, x21, #0xffff
	orr	w11, w9, w11, lsl #10
	add	w21, w21, #1                    // =1
	add	x10, x10, x12, lsl #5
	str	w11, [x10, #4]
	ldrh	w10, [x13, :lo12:c_ftl_nand_planes_num]
	b	.LBB104_72
.LBB104_75:                             //   in Loop: Header=BB104_70 Depth=1
	mov	w21, wzr
.LBB104_76:                             //   in Loop: Header=BB104_70 Depth=1
	ldr	x0, [x22, :lo12:req_read]
	and	w24, w21, #0xffff
	mov	w1, w24
	bl	FlashReadPages
	cbz	w24, .LBB104_69
// %bb.77:                              //   in Loop: Header=BB104_70 Depth=1
	ldr	w24, [sp, #32]                  // 4-byte Folded Reload
                                        // kill: def $w21 killed $w21 killed $x21 def $x21
	and	x8, x21, #0xffff
	mov	x27, xzr
	lsl	x23, x8, #5
	b	.LBB104_80
.LBB104_78:                             //   in Loop: Header=BB104_80 Depth=2
	str	w26, [x9, :lo12:g_recovery_page_min_ver]
.LBB104_79:                             //   in Loop: Header=BB104_80 Depth=2
	add	x27, x27, #32                   // =32
	cmp	x23, x27
	b.eq	.LBB104_69
.LBB104_80:                             //   Parent Loop BB104_70 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldr	x8, [x22, :lo12:req_read]
	adrp	x10, c_ftl_nand_planes_per_die
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_per_die]
	and	w11, w28, #0xffff
	add	x9, x8, x27
	ldr	w21, [x9, #4]
	adrp	x9, c_ftl_nand_blks_per_die
	ldrh	w9, [x9, :lo12:c_ftl_nand_blks_per_die]
	ubfx	w12, w21, #10, #16
	udiv	w13, w12, w10
	udiv	w9, w12, w9
	msub	w12, w13, w10, w12
	madd	w9, w10, w9, w12
	cmp	w24, w9, uxth
	cset	w10, hi
	cmp	w11, w25
	cset	w11, eq
	stur	w21, [x29, #-20]
	b.lo	.LBB104_79
// %bb.81:                              //   in Loop: Header=BB104_80 Depth=2
	and	w10, w11, w10
	tbnz	w10, #0, .LBB104_79
// %bb.82:                              //   in Loop: Header=BB104_80 Depth=2
	ldur	w11, [x29, #-24]                // 4-byte Folded Reload
	and	w10, w28, #0xffff
	cmp	w10, w11, uxth
	b.ne	.LBB104_84
// %bb.83:                              //   in Loop: Header=BB104_80 Depth=2
	ldr	x10, [sp, #24]                  // 8-byte Folded Reload
	and	w9, w9, #0xffff
	cmp	w9, w10, uxth
	b.eq	.LBB104_133
.LBB104_84:                             //   in Loop: Header=BB104_80 Depth=2
	ldr	w9, [x8, x27]
	cmn	w9, #1                          // =1
	b.eq	.LBB104_98
// %bb.85:                              //   in Loop: Header=BB104_80 Depth=2
	add	x8, x8, x27
	ldr	x25, [x8, #16]
	ldrsh	w8, [x25]
	cmn	w8, #3947                       // =3947
	b.ne	.LBB104_102
// %bb.86:                              //   in Loop: Header=BB104_80 Depth=2
	ldr	w26, [x25, #4]
	cmn	w26, #1                         // =1
	b.eq	.LBB104_90
// %bb.87:                              //   in Loop: Header=BB104_80 Depth=2
	adrp	x8, g_GlobalDataVersion
	ldr	w8, [x8, :lo12:g_GlobalDataVersion]
	mov	w11, #-2147483648
	subs	w9, w26, w8
	sub	w10, w8, w26
	cmp	w9, w11
	mov	w11, #-2147483647
	cset	w9, hi
	cmp	w10, w11
	cset	w10, lo
	cmp	w26, w8
	csel	w8, w9, w10, hi
	tbnz	w8, #0, .LBB104_90
// %bb.88:                              //   in Loop: Header=BB104_80 Depth=2
	add	w8, w26, #1                     // =1
	adrp	x9, g_GlobalDataVersion
	str	w8, [x9, :lo12:g_GlobalDataVersion]
	ldrsh	w8, [x25]
	cmn	w8, #3947                       // =3947
	b.eq	.LBB104_90
// %bb.89:                              //   in Loop: Header=BB104_80 Depth=2
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlRecoverySuperblock
	mov	w2, #1961
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlRecoverySuperblock
	bl	sftl_printk
.LBB104_90:                             //   in Loop: Header=BB104_80 Depth=2
	ldp	w0, w24, [x25, #8]
	sub	x1, x29, #16                    // =16
	mov	w2, wzr
	stur	w24, [x29, #-12]
	str	w0, [sp, #20]                   // 4-byte Folded Spill
	bl	log2phys
	adrp	x8, g_recovery_page_min_ver
	ldr	w8, [x8, :lo12:g_recovery_page_min_ver]
	cmn	w8, #1                          // =1
	b.eq	.LBB104_92
// %bb.91:                              //   in Loop: Header=BB104_80 Depth=2
	subs	w9, w26, w8
	mov	w11, #-2147483648
	sub	w10, w8, w26
	cmp	w9, w11
	mov	w11, #-2147483647
	cset	w9, hi
	cmp	w10, w11
	cset	w10, lo
	cmp	w26, w8
	csel	w8, w9, w10, hi
	tbz	w8, #0, .LBB104_114
.LBB104_92:                             //   in Loop: Header=BB104_80 Depth=2
	ldur	w25, [x29, #-16]
	cmp	w25, w21
	b.ne	.LBB104_104
.LBB104_93:                             //   in Loop: Header=BB104_80 Depth=2
	ldur	w25, [x29, #-28]                // 4-byte Folded Reload
	cmn	w24, #1                         // =1
	b.eq	.LBB104_120
// %bb.94:                              //   in Loop: Header=BB104_80 Depth=2
	adrp	x8, c_ftl_nand_blks_per_die
	ldrh	w8, [x8, :lo12:c_ftl_nand_blks_per_die]
	adrp	x10, c_ftl_nand_planes_per_die
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_per_die]
	adrp	x11, c_ftl_nand_data_blks_per_plane
	ubfx	w9, w24, #10, #16
	ldrh	w11, [x11, :lo12:c_ftl_nand_data_blks_per_plane]
	udiv	w12, w9, w8
	msub	w8, w12, w8, w9
	udiv	w24, w8, w10
	cmp	w24, w11
	b.lo	.LBB104_96
// %bb.95:                              //   in Loop: Header=BB104_80 Depth=2
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlRecoverySuperblock
	mov	w2, #2066
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlRecoverySuperblock
	bl	sftl_printk
.LBB104_96:                             //   in Loop: Header=BB104_80 Depth=2
	adrp	x8, p_valid_page_count_table
	ldr	x8, [x8, :lo12:p_valid_page_count_table]
	and	x9, x24, #0xffff
	ldrh	w8, [x8, x9, lsl #1]
	cbz	w8, .LBB104_121
// %bb.97:                              //   in Loop: Header=BB104_80 Depth=2
	mov	w0, w24
	bl	decrement_vpc_count
	ldr	w24, [sp, #32]                  // 4-byte Folded Reload
	b	.LBB104_79
.LBB104_98:                             //   in Loop: Header=BB104_80 Depth=2
	adrp	x8, g_recovery_page_num
	ldr	w8, [x8, :lo12:g_recovery_page_num]
	cmp	w8, #31                         // =31
	b.hi	.LBB104_100
// %bb.99:                              //   in Loop: Header=BB104_80 Depth=2
	adrp	x9, g_recovery_ppa_tbl
	add	x9, x9, :lo12:g_recovery_ppa_tbl
	str	w21, [x9, x8, lsl #2]
	add	w8, w8, #1                      // =1
	adrp	x9, g_recovery_page_num
	str	w8, [x9, :lo12:g_recovery_page_num]
.LBB104_100:                            //   in Loop: Header=BB104_80 Depth=2
	ldrh	w0, [x19]
	bl	decrement_vpc_count
	adrp	x9, g_recovery_page_min_ver
	ldr	w8, [x9, :lo12:g_recovery_page_min_ver]
	cmn	w8, #1                          // =1
	b.eq	.LBB104_78
// %bb.101:                             //   in Loop: Header=BB104_80 Depth=2
	cmp	w8, w26
	b.ls	.LBB104_79
	b	.LBB104_78
.LBB104_102:                            //   in Loop: Header=BB104_80 Depth=2
	ldrh	w0, [x19]
	bl	decrement_vpc_count
.LBB104_103:                            //   in Loop: Header=BB104_80 Depth=2
	ldur	w25, [x29, #-28]                // 4-byte Folded Reload
	b	.LBB104_79
.LBB104_104:                            //   in Loop: Header=BB104_80 Depth=2
	cmn	w24, #1                         // =1
	b.eq	.LBB104_106
// %bb.105:                             //   in Loop: Header=BB104_80 Depth=2
	adrp	x8, c_ftl_nand_totle_phy_blks
	ldr	w8, [x8, :lo12:c_ftl_nand_totle_phy_blks]
	cmp	w8, w24, lsr #10
	b.ls	.LBB104_124
.LBB104_106:                            //   in Loop: Header=BB104_80 Depth=2
	ldr	w0, [sp, #20]                   // 4-byte Folded Reload
	sub	x1, x29, #20                    // =20
	mov	w2, #1
	bl	log2phys
	cmn	w25, #1                         // =1
	b.eq	.LBB104_93
// %bb.107:                             //   in Loop: Header=BB104_80 Depth=2
	cmp	w25, w24
	b.eq	.LBB104_93
// %bb.108:                             //   in Loop: Header=BB104_80 Depth=2
	adrp	x8, c_ftl_nand_blks_per_die
	ldrh	w8, [x8, :lo12:c_ftl_nand_blks_per_die]
	adrp	x10, c_ftl_nand_planes_per_die
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_per_die]
	adrp	x11, g_active_superblock
	ubfx	w9, w25, #10, #16
	ldrh	w11, [x11, :lo12:g_active_superblock]
	udiv	w12, w9, w8
	msub	w8, w12, w8, w9
	udiv	w8, w8, w10
	cmp	w8, w11
	b.eq	.LBB104_111
// %bb.109:                             //   in Loop: Header=BB104_80 Depth=2
	adrp	x9, g_buffer_superblock
	ldrh	w9, [x9, :lo12:g_buffer_superblock]
	cmp	w9, w8, uxth
	b.eq	.LBB104_111
// %bb.110:                             //   in Loop: Header=BB104_80 Depth=2
	adrp	x9, g_gc_temp_superblock
	ldrh	w9, [x9, :lo12:g_gc_temp_superblock]
	cmp	w9, w8, uxth
	b.ne	.LBB104_93
.LBB104_111:                            //   in Loop: Header=BB104_80 Depth=2
	ldr	x8, [x22, :lo12:req_read]
	mov	w1, #1
	str	w25, [x8, #4]
	ldr	x0, [x22, :lo12:req_read]
	ldr	x21, [x8, #16]
	bl	FlashReadPages
	ldr	x8, [x22, :lo12:req_read]
	ldr	w8, [x8]
	cmn	w8, #1                          // =1
	b.eq	.LBB104_93
// %bb.112:                             //   in Loop: Header=BB104_80 Depth=2
	ldr	w8, [x21, #4]
	mov	w11, #-2147483648
	subs	w9, w26, w8
	sub	w10, w8, w26
	cmp	w9, w11
	mov	w11, #-2147483647
	cset	w9, hi
	cmp	w10, w11
	cset	w10, lo
	cmp	w26, w8
	csel	w8, w9, w10, hi
	cmp	w8, #1                          // =1
	b.ne	.LBB104_93
// %bb.113:                             //   in Loop: Header=BB104_80 Depth=2
	ldr	w0, [sp, #20]                   // 4-byte Folded Reload
	sub	x1, x29, #16                    // =16
	mov	w2, #1
	bl	log2phys
	b	.LBB104_93
.LBB104_114:                            //   in Loop: Header=BB104_80 Depth=2
	cmn	w24, #1                         // =1
	b.eq	.LBB104_122
// %bb.115:                             //   in Loop: Header=BB104_80 Depth=2
	ldr	x8, [x22, :lo12:req_read]
	mov	w1, #1
	add	x8, x8, x27
	str	w24, [x8, #4]
	ldr	x9, [x22, :lo12:req_read]
	ldr	x25, [x8, #16]
	add	x0, x9, x27
	bl	FlashReadPages
	ldr	x8, [x22, :lo12:req_read]
	mov	x13, x25
	ldur	w25, [x29, #-28]                // 4-byte Folded Reload
	ldr	w9, [x8, x27]
	cmn	w9, #1                          // =1
	b.eq	.LBB104_126
// %bb.116:                             //   in Loop: Header=BB104_80 Depth=2
	ldr	w9, [x13, #8]
	ldr	w10, [sp, #20]                  // 4-byte Folded Reload
	cmp	w9, w10
	b.ne	.LBB104_126
// %bb.117:                             //   in Loop: Header=BB104_80 Depth=2
	adrp	x9, g_recovery_page_min_ver
	ldr	w14, [x13, #4]
	ldr	w9, [x9, :lo12:g_recovery_page_min_ver]
	mov	w12, #-2147483648
	subs	w10, w9, w14
	sub	w11, w14, w9
	cmp	w10, w12
	mov	w12, #-2147483647
	cset	w10, hi
	cmp	w11, w12
	cset	w11, lo
	cmp	w9, w14
	csel	w9, w10, w11, hi
	tbnz	w9, #0, .LBB104_126
// %bb.118:                             //   in Loop: Header=BB104_80 Depth=2
	ldur	w9, [x29, #-16]
	cmp	w9, w21
	b.ne	.LBB104_125
.LBB104_119:                            //   in Loop: Header=BB104_80 Depth=2
	ldr	w0, [sp, #20]                   // 4-byte Folded Reload
	mov	w1, w24
	bl	FtlReUsePrevPpa
	b	.LBB104_126
.LBB104_120:                            //   in Loop: Header=BB104_80 Depth=2
	ldr	w24, [sp, #32]                  // 4-byte Folded Reload
	b	.LBB104_79
.LBB104_121:                            //   in Loop: Header=BB104_80 Depth=2
	adrp	x0, .L.str.101
	add	x0, x0, :lo12:.L.str.101
	mov	w1, w24
	bl	sftl_printk
	ldr	w24, [sp, #32]                  // 4-byte Folded Reload
	b	.LBB104_79
.LBB104_122:                            //   in Loop: Header=BB104_80 Depth=2
	ldur	w8, [x29, #-16]
	ldr	w24, [sp, #32]                  // 4-byte Folded Reload
	ldur	w25, [x29, #-28]                // 4-byte Folded Reload
	cmp	w8, w21
	b.ne	.LBB104_79
// %bb.123:                             //   in Loop: Header=BB104_80 Depth=2
	ldr	w0, [sp, #20]                   // 4-byte Folded Reload
	sub	x1, x29, #12                    // =12
	mov	w2, #1
	bl	log2phys
	b	.LBB104_79
.LBB104_124:                            //   in Loop: Header=BB104_80 Depth=2
	adrp	x0, .L.str.100
	add	x0, x0, :lo12:.L.str.100
	mov	w1, w24
	bl	sftl_printk
	ldr	w24, [sp, #32]                  // 4-byte Folded Reload
	b	.LBB104_103
.LBB104_125:                            //   in Loop: Header=BB104_80 Depth=2
	cmp	w9, w24
	b.ne	.LBB104_127
.LBB104_126:                            //   in Loop: Header=BB104_80 Depth=2
	ldr	w24, [sp, #32]                  // 4-byte Folded Reload
	mov	w8, #-1
	stur	w8, [x29, #-12]
	b	.LBB104_79
.LBB104_127:                            //   in Loop: Header=BB104_80 Depth=2
	cmn	w9, #1                          // =1
	b.eq	.LBB104_129
// %bb.128:                             //   in Loop: Header=BB104_80 Depth=2
	add	x8, x8, x27
	str	w9, [x8, #4]
	ldr	x9, [x22, :lo12:req_read]
	ldr	x8, [x8, #16]
	mov	w1, #1
	mov	w21, w14
	add	x0, x9, x27
	str	x8, [sp, #8]                    // 8-byte Folded Spill
	bl	FlashReadPages
	mov	w14, w21
	b	.LBB104_130
.LBB104_129:                            //   in Loop: Header=BB104_80 Depth=2
	str	x13, [sp, #8]                   // 8-byte Folded Spill
	str	w9, [x8, x27]
.LBB104_130:                            //   in Loop: Header=BB104_80 Depth=2
	ldr	x8, [x22, :lo12:req_read]
	adrp	x9, g_recovery_page_min_ver
	mov	w12, #-2147483648
	mov	w13, #-2147483647
	ldr	w8, [x8, x27]
	cmn	w8, #1                          // =1
	b.eq	.LBB104_119
// %bb.131:                             //   in Loop: Header=BB104_80 Depth=2
	ldr	x8, [sp, #8]                    // 8-byte Folded Reload
	ldr	w9, [x9, :lo12:g_recovery_page_min_ver]
	ldr	w8, [x8, #4]
	subs	w10, w9, w8
	sub	w11, w8, w9
	cmp	w10, w12
	cset	w10, hi
	cmp	w11, w13
	cset	w11, lo
	cmp	w9, w8
	csel	w9, w10, w11, hi
	tbnz	w9, #0, .LBB104_119
// %bb.132:                             //   in Loop: Header=BB104_80 Depth=2
	subs	w9, w14, w8
	sub	w10, w8, w14
	cmp	w9, w12
	cset	w9, hi
	cmp	w10, w13
	cset	w10, lo
	cmp	w14, w8
	csel	w8, w9, w10, hi
	tbz	w8, #0, .LBB104_119
	b	.LBB104_126
.LBB104_133:
	ldr	x11, [sp, #24]                  // 8-byte Folded Reload
	ldur	w14, [x29, #-24]                // 4-byte Folded Reload
	strh	wzr, [x19, #4]
	adrp	x8, c_ftl_nand_planes_num
	strb	w11, [x19, #6]
	strh	w14, [x19, #2]
	ldrh	w8, [x8, :lo12:c_ftl_nand_planes_num]
	mov	w9, wzr
	adrp	x13, c_ftl_nand_page_pre_blk
	cmp	w8, w11, uxth
	b.ls	.LBB104_138
// %bb.134:
	sub	x10, x8, w11, uxth
	add	x11, x19, w11, uxth #1
	mov	w9, wzr
	add	x11, x11, #16                   // =16
	b	.LBB104_136
.LBB104_135:                            //   in Loop: Header=BB104_136 Depth=1
	subs	x10, x10, #1                    // =1
	add	x11, x11, #2                    // =2
	b.eq	.LBB104_138
.LBB104_136:                            // =>This Inner Loop Header: Depth=1
	ldrsh	w12, [x11]
	cmn	w12, #1                         // =1
	b.eq	.LBB104_135
// %bb.137:                             //   in Loop: Header=BB104_136 Depth=1
	add	w9, w9, #1                      // =1
	strh	w9, [x19, #4]
	b	.LBB104_135
.LBB104_138:
	cbz	w8, .LBB104_148
// %bb.139:
	ldrh	w10, [x13, :lo12:c_ftl_nand_page_pre_blk]
	mvn	w11, w14
	add	w10, w10, w11
	add	x11, x19, #16                   // =16
	b	.LBB104_141
.LBB104_140:                            //   in Loop: Header=BB104_141 Depth=1
	subs	x8, x8, #1                      // =1
	add	x11, x11, #2                    // =2
	b.eq	.LBB104_148
.LBB104_141:                            // =>This Inner Loop Header: Depth=1
	ldrsh	w12, [x11]
	cmn	w12, #1                         // =1
	b.eq	.LBB104_140
// %bb.142:                             //   in Loop: Header=BB104_141 Depth=1
	add	w9, w10, w9
	strh	w9, [x19, #4]
	b	.LBB104_140
.LBB104_143:
	strh	w28, [x19, #2]
	strh	wzr, [x19, #4]
	adrp	x8, c_ftl_nand_planes_num
	ldrh	w8, [x8, :lo12:c_ftl_nand_planes_num]
	cbz	x8, .LBB104_148
// %bb.144:
	mov	x9, xzr
	add	x10, x19, #16                   // =16
.LBB104_145:                            // =>This Inner Loop Header: Depth=1
	ldrsh	w11, [x10, x9, lsl #1]
	cmn	w11, #1                         // =1
	b.ne	.LBB104_147
// %bb.146:                             //   in Loop: Header=BB104_145 Depth=1
	add	x9, x9, #1                      // =1
	cmp	x8, x9
	b.ne	.LBB104_145
	b	.LBB104_148
.LBB104_147:
	strb	w9, [x19, #6]
.LBB104_148:
	adrp	x9, __stack_chk_guard
	ldur	x8, [x29, #-8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB104_150
// %bb.149:
	ldp	x20, x19, [sp, #144]            // 16-byte Folded Reload
	ldp	x22, x21, [sp, #128]            // 16-byte Folded Reload
	ldp	x24, x23, [sp, #112]            // 16-byte Folded Reload
	ldp	x26, x25, [sp, #96]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #80]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #64]             // 16-byte Folded Reload
	mov	w0, wzr
	add	sp, sp, #160                    // =160
	hint	#29
	ret
.LBB104_150:
	bl	__stack_chk_fail
.Lfunc_end104:
	.size	FtlRecoverySuperblock, .Lfunc_end104-FtlRecoverySuperblock
                                        // -- End function
	.globl	FtlSlcSuperblockCheck           // -- Begin function FtlSlcSuperblockCheck
	.p2align	2
	.type	FtlSlcSuperblockCheck,@function
FtlSlcSuperblockCheck:                  // @FtlSlcSuperblockCheck
// %bb.0:
	hint	#25
	ldrh	w8, [x0, #4]
	cbz	w8, .LBB105_3
// %bb.1:
	ldrsh	w8, [x0]
	cmn	w8, #1                          // =1
	b.eq	.LBB105_3
// %bb.2:
	ldrb	w9, [x0, #6]
	add	x8, x0, x9, lsl #1
	ldrsh	w8, [x8, #16]
	cmn	w8, #1                          // =1
	b.eq	.LBB105_4
.LBB105_3:
	hint	#29
	ret
.LBB105_4:
	adrp	x8, c_ftl_nand_planes_num
	ldrh	w8, [x8, :lo12:c_ftl_nand_planes_num]
                                        // kill: def $w9 killed $w9 killed $x9 def $x9
	b	.LBB105_6
.LBB105_5:                              //   in Loop: Header=BB105_6 Depth=1
	add	x10, x0, w9, uxtb #1
	ldrsh	w10, [x10, #16]
	cmn	w10, #1                         // =1
	b.ne	.LBB105_8
.LBB105_6:                              // =>This Inner Loop Header: Depth=1
	add	w9, w9, #1                      // =1
	cmp	w8, w9, uxtb
	b.ne	.LBB105_5
// %bb.7:                               //   in Loop: Header=BB105_6 Depth=1
	ldrh	w10, [x0, #2]
	mov	w9, wzr
	add	w10, w10, #1                    // =1
	strh	w10, [x0, #2]
	b	.LBB105_5
.LBB105_8:
	strb	w9, [x0, #6]
	hint	#29
	ret
.Lfunc_end105:
	.size	FtlSlcSuperblockCheck, .Lfunc_end105-FtlSlcSuperblockCheck
                                        // -- End function
	.globl	FtlPowerLostRecovery            // -- Begin function FtlPowerLostRecovery
	.p2align	2
	.type	FtlPowerLostRecovery,@function
FtlPowerLostRecovery:                   // @FtlPowerLostRecovery
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #16]             // 16-byte Folded Spill
	adrp	x19, g_active_superblock
	add	x19, x19, :lo12:g_active_superblock
	adrp	x8, g_recovery_page_num
	mov	x0, x19
	mov	x29, sp
	str	wzr, [x8, :lo12:g_recovery_page_num]
	bl	FtlRecoverySuperblock
	ldrh	w8, [x19, #4]
	cbz	w8, .LBB106_8
// %bb.1:
	ldrh	w8, [x19]
	mov	w9, #65535
	cmp	w8, w9
	b.eq	.LBB106_8
// %bb.2:
	ldrb	w9, [x19, #6]
	add	x8, x19, x9, lsl #1
	ldrsh	w8, [x8, #16]
	cmn	w8, #1                          // =1
	b.ne	.LBB106_8
// %bb.3:
	adrp	x8, c_ftl_nand_planes_num
	ldrh	w8, [x8, :lo12:c_ftl_nand_planes_num]
	adrp	x10, g_active_superblock+2
                                        // kill: def $w9 killed $w9 killed $x9 def $x9
	b	.LBB106_5
.LBB106_4:                              //   in Loop: Header=BB106_5 Depth=1
	add	x11, x19, w9, uxtb #1
	ldrsh	w11, [x11, #16]
	cmn	w11, #1                         // =1
	b.ne	.LBB106_7
.LBB106_5:                              // =>This Inner Loop Header: Depth=1
	add	w9, w9, #1                      // =1
	cmp	w8, w9, uxtb
	b.ne	.LBB106_4
// %bb.6:                               //   in Loop: Header=BB106_5 Depth=1
	ldrh	w11, [x10, :lo12:g_active_superblock+2]
	mov	w9, wzr
	add	w11, w11, #1                    // =1
	strh	w11, [x10, :lo12:g_active_superblock+2]
	b	.LBB106_4
.LBB106_7:
	adrp	x8, g_active_superblock+6
	strb	w9, [x8, :lo12:g_active_superblock+6]
.LBB106_8:
	adrp	x19, g_buffer_superblock
	add	x19, x19, :lo12:g_buffer_superblock
	mov	x0, x19
	bl	FtlRecoverySuperblock
	ldrh	w8, [x19, #4]
	cbz	w8, .LBB106_16
// %bb.9:
	ldrh	w8, [x19]
	mov	w9, #65535
	cmp	w8, w9
	b.eq	.LBB106_16
// %bb.10:
	ldrb	w9, [x19, #6]
	add	x8, x19, x9, lsl #1
	ldrsh	w8, [x8, #16]
	cmn	w8, #1                          // =1
	b.ne	.LBB106_16
// %bb.11:
	adrp	x8, c_ftl_nand_planes_num
	ldrh	w8, [x8, :lo12:c_ftl_nand_planes_num]
	adrp	x10, g_buffer_superblock+2
                                        // kill: def $w9 killed $w9 killed $x9 def $x9
	b	.LBB106_13
.LBB106_12:                             //   in Loop: Header=BB106_13 Depth=1
	add	x11, x19, w9, uxtb #1
	ldrsh	w11, [x11, #16]
	cmn	w11, #1                         // =1
	b.ne	.LBB106_15
.LBB106_13:                             // =>This Inner Loop Header: Depth=1
	add	w9, w9, #1                      // =1
	cmp	w8, w9, uxtb
	b.ne	.LBB106_12
// %bb.14:                              //   in Loop: Header=BB106_13 Depth=1
	ldrh	w11, [x10, :lo12:g_buffer_superblock+2]
	mov	w9, wzr
	add	w11, w11, #1                    // =1
	strh	w11, [x10, :lo12:g_buffer_superblock+2]
	b	.LBB106_12
.LBB106_15:
	adrp	x8, g_buffer_superblock+6
	strb	w9, [x8, :lo12:g_buffer_superblock+6]
.LBB106_16:
	bl	FtlGcPageRecovery
	adrp	x19, g_tmp_data_superblock_id
	ldrh	w0, [x19, :lo12:g_tmp_data_superblock_id]
	mov	w20, #65535
	cmp	w0, w20
	b.eq	.LBB106_20
// %bb.17:
	bl	update_vpc_list
	adrp	x8, p_data_block_list_head
	adrp	x9, p_data_block_list_table
	ldr	w8, [x8, :lo12:p_data_block_list_head]
	ldr	w9, [x9, :lo12:p_data_block_list_table]
	adrp	x10, p_valid_page_count_table
	ldr	x10, [x10, :lo12:p_valid_page_count_table]
	strh	w20, [x19, :lo12:g_tmp_data_superblock_id]
	sub	w8, w8, w9
	mov	w9, #43691
	lsr	w8, w8, #1
	movk	w9, #43690, lsl #16
	mul	w8, w8, w9
	and	x8, x8, #0xffff
	ldrh	w9, [x10, x8, lsl #1]
	cbnz	w9, .LBB106_21
// %bb.18:
	mov	w9, #65535
	cmp	x8, x9
	b.eq	.LBB106_21
// %bb.19:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.decrement_vpc_count
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.decrement_vpc_count
	mov	w2, #2869
	bl	sftl_printk
	b	.LBB106_21
.LBB106_20:
	strh	w20, [x19, :lo12:g_tmp_data_superblock_id]
.LBB106_21:
	ldp	x20, x19, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end106:
	.size	FtlPowerLostRecovery, .Lfunc_end106-FtlPowerLostRecovery
                                        // -- End function
	.globl	FtlGcPageRecovery               // -- Begin function FtlGcPageRecovery
	.p2align	2
	.type	FtlGcPageRecovery,@function
FtlGcPageRecovery:                      // @FtlGcPageRecovery
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #16]             // 16-byte Folded Spill
	adrp	x20, c_ftl_nand_page_pre_blk
	ldrh	w1, [x20, :lo12:c_ftl_nand_page_pre_blk]
	adrp	x19, g_gc_temp_superblock
	add	x19, x19, :lo12:g_gc_temp_superblock
	mov	x0, x19
	mov	x29, sp
	bl	FtlGcScanTempBlk
	ldrh	w8, [x19, #2]
	ldrh	w9, [x20, :lo12:c_ftl_nand_page_pre_blk]
	cmp	w8, w9
	b.lo	.LBB107_7
// %bb.1:
	adrp	x8, gL2pMapInfo+6
	add	x8, x8, :lo12:gL2pMapInfo+6
	ldur	w9, [x8, #50]
	cbz	w9, .LBB107_6
// %bb.2:
	ldrh	w8, [x8]
	adrp	x9, gL2pMapInfo+40
	adrp	x10, p_sys_data_buf_1
	adrp	x12, p_sys_spare_buf
	add	x9, x9, :lo12:gL2pMapInfo+40
	ldr	x0, [x10, :lo12:p_sys_data_buf_1]
	ldr	x10, [x12, :lo12:p_sys_spare_buf]
	ldr	x13, [x9]
	adrp	x11, req_sys+4
	add	x11, x11, :lo12:req_sys+4
	sub	w19, w8, #1                     // =1
	str	wzr, [x9, #16]
	stur	x0, [x11, #4]
	stur	x10, [x11, #12]
	and	x8, x19, #0xffff
	ldr	w8, [x13, x8, lsl #2]
	str	w8, [x11]
	cbz	w8, .LBB107_4
// %bb.3:
	adrp	x0, req_sys
	add	x0, x0, :lo12:req_sys
	mov	w1, #1
	bl	FlashReadPages
	b	.LBB107_5
.LBB107_4:
	adrp	x8, c_ftl_nand_byte_pre_page
	ldrh	w2, [x8, :lo12:c_ftl_nand_byte_pre_page]
	mov	w1, #255
	bl	memset
.LBB107_5:
	adrp	x8, req_sys+8
	ldr	x2, [x8, :lo12:req_sys+8]
	adrp	x0, gL2pMapInfo
	and	w1, w19, #0xffff
	add	x0, x0, :lo12:gL2pMapInfo
	bl	FtlMapWritePage
.LBB107_6:
	mov	w0, wzr
	bl	FtlGcFreeTempBlock
	adrp	x8, ftl_gc_temp_power_lost_recovery_flag
	str	wzr, [x8, :lo12:ftl_gc_temp_power_lost_recovery_flag]
.LBB107_7:
	ldp	x20, x19, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end107:
	.size	FtlGcPageRecovery, .Lfunc_end107-FtlGcPageRecovery
                                        // -- End function
	.globl	SupperBlkListInit               // -- Begin function SupperBlkListInit
	.p2align	2
	.type	SupperBlkListInit,@function
SupperBlkListInit:                      // @SupperBlkListInit
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-96]!           // 16-byte Folded Spill
	adrp	x8, c_ftl_nand_blk_pre_plane
	ldrh	w8, [x8, :lo12:c_ftl_nand_blk_pre_plane]
	stp	x22, x21, [sp, #64]             // 16-byte Folded Spill
	adrp	x22, p_data_block_list_table
	ldr	x0, [x22, :lo12:p_data_block_list_table]
	add	x8, x8, x8, lsl #1
	lsl	x2, x8, #1
	mov	w1, wzr
	stp	x28, x27, [sp, #16]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #32]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #48]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #80]             // 16-byte Folded Spill
	mov	x29, sp
	bl	memset
	adrp	x8, p_free_data_block_list_head
	adrp	x27, c_ftl_nand_data_blks_per_plane
	str	xzr, [x8, :lo12:p_free_data_block_list_head]
	ldrh	w8, [x27, :lo12:c_ftl_nand_data_blks_per_plane]
	adrp	x9, p_data_block_list_head
	adrp	x10, p_data_block_list_tail
	str	xzr, [x9, :lo12:p_data_block_list_head]
	str	xzr, [x10, :lo12:p_data_block_list_tail]
	adrp	x9, g_num_data_superblocks
	adrp	x10, g_num_free_superblocks
	strh	wzr, [x9, :lo12:g_num_data_superblocks]
	strh	wzr, [x10, :lo12:g_num_free_superblocks]
	cbz	w8, .LBB108_17
// %bb.1:
	adrp	x24, gBbtInfo
	mov	x19, xzr
	mov	w25, wzr
	mov	w26, wzr
	adrp	x28, c_ftl_nand_planes_num
	adrp	x23, p_valid_page_count_table
	mov	w21, #6
	adrp	x20, g_active_superblock
	add	x24, x24, :lo12:gBbtInfo
	b	.LBB108_4
.LBB108_2:                              //   in Loop: Header=BB108_4 Depth=1
	mov	w0, w19
	add	w25, w25, #1                    // =1
	bl	INSERT_FREE_LIST
.LBB108_3:                              //   in Loop: Header=BB108_4 Depth=1
	ldrh	w8, [x27, :lo12:c_ftl_nand_data_blks_per_plane]
	add	x19, x19, #1                    // =1
	cmp	x19, x8
	b.hs	.LBB108_16
.LBB108_4:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB108_6 Depth 2
	ldrh	w9, [x28, :lo12:c_ftl_nand_planes_num]
	cbz	x9, .LBB108_9
// %bb.5:                               //   in Loop: Header=BB108_4 Depth=1
	adrp	x10, c_ftl_nand_planes_per_die
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_per_die]
	adrp	x11, c_ftl_nand_blks_per_die
	adrp	x12, c_ftl_nand_page_pre_blk
	ldrh	w11, [x11, :lo12:c_ftl_nand_blks_per_die]
	ldrh	w12, [x12, :lo12:c_ftl_nand_page_pre_blk]
	adrp	x14, p_plane_order_table
	mov	w8, wzr
	mul	w13, w10, w19
	add	x14, x14, :lo12:p_plane_order_table
.LBB108_6:                              //   Parent Loop BB108_4 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldrb	w15, [x14], #1
	and	w16, w10, #0xffff
	and	w17, w15, #0xffff
	udiv	w16, w17, w16
	msub	w15, w16, w10, w15
	madd	w16, w11, w16, w13
	add	w15, w16, w15
	and	w17, w11, #0xffff
	and	w16, w15, #0xffff
	udiv	w16, w16, w17
	add	x17, x24, w16, uxtw #3
	ldr	x17, [x17, #32]
	msub	w15, w16, w11, w15
	lsr	w16, w15, #3
	and	x16, x16, #0x1ffc
	ldr	w16, [x17, x16]
	lsr	w15, w16, w15
	tst	w15, #0x1
	csel	w15, w12, wzr, eq
	subs	x9, x9, #1                      // =1
	add	w8, w15, w8
	b.ne	.LBB108_6
// %bb.7:                               //   in Loop: Header=BB108_4 Depth=1
	tst	w8, #0xffff
	b.eq	.LBB108_9
// %bb.8:                               //   in Loop: Header=BB108_4 Depth=1
	and	w8, w8, #0xffff
	mov	w9, #32768
	udiv	w8, w9, w8
	b	.LBB108_10
.LBB108_9:                              //   in Loop: Header=BB108_4 Depth=1
	ldr	x9, [x23, :lo12:p_valid_page_count_table]
	mov	w8, wzr
	mov	w10, #65535
	strh	w10, [x9, x19, lsl #1]
.LBB108_10:                             //   in Loop: Header=BB108_4 Depth=1
	ldr	x9, [x22, :lo12:p_data_block_list_table]
	madd	x9, x19, x21, x9
	strh	w8, [x9, #4]
	ldrh	w8, [x20, :lo12:g_active_superblock]
	cmp	x19, x8
	b.eq	.LBB108_3
// %bb.11:                              //   in Loop: Header=BB108_4 Depth=1
	adrp	x8, g_buffer_superblock
	ldrh	w8, [x8, :lo12:g_buffer_superblock]
	cmp	x19, x8
	b.eq	.LBB108_3
// %bb.12:                              //   in Loop: Header=BB108_4 Depth=1
	adrp	x8, g_gc_temp_superblock
	ldrh	w8, [x8, :lo12:g_gc_temp_superblock]
	cmp	x19, x8
	b.eq	.LBB108_3
// %bb.13:                              //   in Loop: Header=BB108_4 Depth=1
	ldr	x8, [x23, :lo12:p_valid_page_count_table]
	ldrh	w8, [x8, x19, lsl #1]
	cbz	w8, .LBB108_2
// %bb.14:                              //   in Loop: Header=BB108_4 Depth=1
	mov	w0, w19
	add	w26, w26, #1                    // =1
	bl	insert_data_list
	adrp	x10, g_num_data_superblocks
	ldrh	w8, [x10, :lo12:g_num_data_superblocks]
	ldrh	w9, [x27, :lo12:c_ftl_nand_data_blks_per_plane]
	add	w8, w8, #1                      // =1
	cmp	w9, w8, uxth
	strh	w8, [x10, :lo12:g_num_data_superblocks]
	b.hs	.LBB108_3
// %bb.15:                              //   in Loop: Header=BB108_4 Depth=1
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.INSERT_DATA_LIST
	mov	w2, #214
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.INSERT_DATA_LIST
	bl	sftl_printk
	b	.LBB108_3
.LBB108_16:
	adrp	x10, g_num_free_superblocks
	b	.LBB108_18
.LBB108_17:
	mov	w26, wzr
	mov	w25, wzr
.LBB108_18:
	adrp	x9, g_num_data_superblocks
	strh	w26, [x9, :lo12:g_num_data_superblocks]
	and	w9, w25, #0xffff
	add	w9, w9, w26, uxth
	cmp	w9, w8
	strh	w25, [x10, :lo12:g_num_free_superblocks]
	b.ls	.LBB108_20
// %bb.19:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.SupperBlkListInit
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.SupperBlkListInit
	mov	w2, #2219
	bl	sftl_printk
.LBB108_20:
	ldp	x20, x19, [sp, #80]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #48]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #32]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #96             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end108:
	.size	SupperBlkListInit, .Lfunc_end108-SupperBlkListInit
                                        // -- End function
	.globl	Ftl_load_ext_data               // -- Begin function Ftl_load_ext_data
	.p2align	2
	.type	Ftl_load_ext_data,@function
Ftl_load_ext_data:                      // @Ftl_load_ext_data
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #16]             // 16-byte Folded Spill
	adrp	x19, g_sys_ext_data
	add	x19, x19, :lo12:g_sys_ext_data
	mov	w20, #19539
	mov	w1, #1
	mov	w0, wzr
	mov	x2, x19
	mov	x29, sp
	movk	w20, #18004, lsl #16
	bl	FtlVendorPartRead
	ldr	w8, [x19]
	cmp	w8, w20
	b.ne	.LBB109_2
// %bb.1:
	adrp	x12, g_sys_ext_data+8
	add	x12, x12, :lo12:g_sys_ext_data+8
	ldp	w0, w18, [x12, #80]
	ldp	w17, w16, [x12]
	ldp	w15, w14, [x12, #8]
	ldp	w8, w13, [x12, #20]
	ldp	w9, w11, [x12, #28]
	ldp	w10, w12, [x12, #36]
	b	.LBB109_3
.LBB109_2:
	add	x0, x19, #4                     // =4
	mov	w2, #508
	mov	w1, wzr
	bl	memset
	mov	w12, wzr
	mov	w10, wzr
	mov	w11, wzr
	mov	w9, wzr
	mov	w13, wzr
	mov	w8, wzr
	mov	w14, wzr
	mov	w15, wzr
	mov	w16, wzr
	mov	w17, wzr
	mov	w18, wzr
	mov	w0, wzr
	str	w20, [x19]
.LBB109_3:
	adrp	x1, g_totle_write_sector
	str	w0, [x1, :lo12:g_totle_write_sector]
	adrp	x0, g_totle_read_sector
	adrp	x1, g_totle_gc_page_count
	str	w18, [x0, :lo12:g_totle_read_sector]
	adrp	x18, g_totle_write_page_count
	adrp	x0, g_totle_read_page_count
	str	w17, [x1, :lo12:g_totle_gc_page_count]
	adrp	x17, g_totle_l2p_write_count
	str	w16, [x18, :lo12:g_totle_write_page_count]
	adrp	x16, g_totle_sys_slc_erase_count
	adrp	x18, g_totle_discard_page_count
	str	w15, [x0, :lo12:g_totle_read_page_count]
	adrp	x15, g_totle_cache_write_count
	str	w14, [x17, :lo12:g_totle_l2p_write_count]
	adrp	x17, g_totle_mlc_erase_count
	str	w13, [x16, :lo12:g_totle_sys_slc_erase_count]
	adrp	x13, c_mlc_erase_count_value
	adrp	x16, c_ftl_nand_data_blks_per_plane
	str	w9, [x18, :lo12:g_totle_discard_page_count]
	str	w11, [x15, :lo12:g_totle_cache_write_count]
	ldr	w9, [x17, :lo12:g_totle_mlc_erase_count]
	ldrh	w11, [x13, :lo12:c_mlc_erase_count_value]
	ldrh	w13, [x16, :lo12:c_ftl_nand_data_blks_per_plane]
	adrp	x1, g_totle_slc_erase_count
	ldp	x20, x19, [sp, #16]             // 16-byte Folded Reload
	str	w8, [x1, :lo12:g_totle_slc_erase_count]
	madd	w8, w9, w11, w8
	adrp	x0, g_max_erase_count
	adrp	x14, g_min_erase_count
	udiv	w8, w8, w13
	adrp	x9, g_totle_avg_erase_count
	str	w10, [x0, :lo12:g_max_erase_count]
	str	w12, [x14, :lo12:g_min_erase_count]
	str	w8, [x9, :lo12:g_totle_avg_erase_count]
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end109:
	.size	Ftl_load_ext_data, .Lfunc_end109-Ftl_load_ext_data
                                        // -- End function
	.globl	FtlSuperblockPowerLostFix       // -- Begin function FtlSuperblockPowerLostFix
	.p2align	2
	.type	FtlSuperblockPowerLostFix,@function
FtlSuperblockPowerLostFix:              // @FtlSuperblockPowerLostFix
// %bb.0:
	hint	#25
	sub	sp, sp, #96                     // =96
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	stp	x29, x30, [sp, #48]             // 16-byte Folded Spill
	add	x29, sp, #48                    // =48
	stp	x22, x21, [sp, #64]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #80]             // 16-byte Folded Spill
	adrp	x10, p_sys_data_buf
	adrp	x11, p_sys_spare_buf
	stur	x8, [x29, #-8]
	ldr	x8, [x10, :lo12:p_sys_data_buf]
	ldr	x20, [x11, :lo12:p_sys_spare_buf]
	mov	w9, #-1
	str	w9, [sp, #32]
	mov	x9, #-3
	movk	x9, #65534, lsl #32
	stp	x8, x20, [sp, #16]
	str	x9, [x20, #8]
	ldrh	w8, [x0]
	strh	wzr, [x20]
	mov	w9, #61589
	mov	x19, x0
	strh	w8, [x20, #2]
	ldr	x8, [x10, :lo12:p_sys_data_buf]
	str	w9, [x8]
	ldr	x8, [x10, :lo12:p_sys_data_buf]
	mov	w9, #22136
	movk	w9, #4660, lsl #16
	str	w9, [x8, #4]
	ldrh	w8, [x0, #4]
	cbz	w8, .LBB110_5
// %bb.1:
	tst	w8, #0x1
	mov	w8, #6
	cinc	w21, w8, ne
	adrp	x22, g_GlobalDataVersion
.LBB110_2:                              // =>This Inner Loop Header: Depth=1
	mov	x0, x19
	bl	get_new_active_ppa
	cmn	w0, #1                          // =1
	str	w0, [sp, #12]
	b.eq	.LBB110_5
// %bb.3:                               //   in Loop: Header=BB110_2 Depth=1
	ldr	w8, [x22, :lo12:g_GlobalDataVersion]
	add	x0, sp, #8                      // =8
	mov	w1, #1
	mov	w2, wzr
	add	w9, w8, #1                      // =1
	cmn	w9, #1                          // =1
	str	w8, [x20, #4]
	csinc	w8, wzr, w8, eq
	str	w8, [x22, :lo12:g_GlobalDataVersion]
	bl	FlashProgPages
	ldrh	w0, [x19]
	bl	decrement_vpc_count
	subs	w21, w21, #1                    // =1
	b.eq	.LBB110_5
// %bb.4:                               //   in Loop: Header=BB110_2 Depth=1
	ldrh	w8, [x19, #4]
	cbnz	w8, .LBB110_2
.LBB110_5:
	adrp	x8, p_valid_page_count_table
	ldrh	w9, [x19]
	ldr	x8, [x8, :lo12:p_valid_page_count_table]
	ldrh	w10, [x19, #4]
	lsl	x9, x9, #1
	ldrh	w11, [x8, x9]
	sub	w10, w11, w10
	adrp	x11, c_ftl_nand_page_pre_blk
	strh	w10, [x8, x9]
	ldrh	w8, [x11, :lo12:c_ftl_nand_page_pre_blk]
	strb	wzr, [x19, #6]
	strh	wzr, [x19, #4]
	adrp	x9, __stack_chk_guard
	strh	w8, [x19, #2]
	ldur	x8, [x29, #-8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB110_7
// %bb.6:
	ldp	x20, x19, [sp, #80]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #64]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #48]             // 16-byte Folded Reload
	add	sp, sp, #96                     // =96
	hint	#29
	ret
.LBB110_7:
	bl	__stack_chk_fail
.Lfunc_end110:
	.size	FtlSuperblockPowerLostFix, .Lfunc_end110-FtlSuperblockPowerLostFix
                                        // -- End function
	.globl	FtlVpcCheckAndModify            // -- Begin function FtlVpcCheckAndModify
	.p2align	2
	.type	FtlVpcCheckAndModify,@function
FtlVpcCheckAndModify:                   // @FtlVpcCheckAndModify
// %bb.0:
	hint	#25
	sub	sp, sp, #112                    // =112
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	adrp	x0, .L.str.102
	adrp	x1, .L__func__.FtlVpcCheckAndModify
	add	x0, x0, :lo12:.L.str.102
	add	x1, x1, :lo12:.L__func__.FtlVpcCheckAndModify
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	stp	x28, x27, [sp, #32]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #48]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #64]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #80]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #96]             // 16-byte Folded Spill
	add	x29, sp, #16                    // =16
	str	x8, [sp, #8]
	bl	sftl_printk
	adrp	x8, c_ftl_nand_blk_pre_plane
	adrp	x25, p_valid_page_count_check_table
	ldrh	w8, [x8, :lo12:c_ftl_nand_blk_pre_plane]
	ldr	x0, [x25, :lo12:p_valid_page_count_check_table]
	mov	w1, wzr
	lsl	x2, x8, #1
	bl	memset
	adrp	x20, g_MaxLpn
	ldr	w8, [x20, :lo12:g_MaxLpn]
	cbz	w8, .LBB111_5
// %bb.1:
	mov	w19, wzr
	adrp	x21, c_ftl_nand_blks_per_die
	adrp	x22, c_ftl_nand_planes_per_die
	b	.LBB111_3
.LBB111_2:                              //   in Loop: Header=BB111_3 Depth=1
	ldr	w8, [x20, :lo12:g_MaxLpn]
	add	w19, w19, #1                    // =1
	cmp	w19, w8
	b.hs	.LBB111_5
.LBB111_3:                              // =>This Inner Loop Header: Depth=1
	add	x1, sp, #4                      // =4
	mov	w0, w19
	mov	w2, wzr
	bl	log2phys
	ldr	w8, [sp, #4]
	cmn	w8, #1                          // =1
	b.eq	.LBB111_2
// %bb.4:                               //   in Loop: Header=BB111_3 Depth=1
	ldrh	w9, [x21, :lo12:c_ftl_nand_blks_per_die]
	ldrh	w10, [x22, :lo12:c_ftl_nand_planes_per_die]
	ubfx	w8, w8, #10, #16
	ldr	x12, [x25, :lo12:p_valid_page_count_check_table]
	udiv	w11, w8, w9
	msub	w8, w11, w9, w8
	udiv	w8, w8, w10
	lsl	x8, x8, #1
	ldrh	w9, [x12, x8]
	add	w9, w9, #1                      // =1
	strh	w9, [x12, x8]
	b	.LBB111_2
.LBB111_5:
	adrp	x26, c_ftl_nand_data_blks_per_plane
	ldrh	w8, [x26, :lo12:c_ftl_nand_data_blks_per_plane]
	cbz	w8, .LBB111_30
// %bb.6:
	adrp	x24, .L.str.103
	mov	x27, xzr
	mov	x19, xzr
	adrp	x28, p_valid_page_count_table
	mov	w22, #65535
	add	x24, x24, :lo12:.L.str.103
	adrp	x20, g_active_superblock
	adrp	x23, g_gc_temp_superblock
	b	.LBB111_9
.LBB111_7:                              //   in Loop: Header=BB111_9 Depth=1
	mov	w0, w19
	bl	update_vpc_list
.LBB111_8:                              //   in Loop: Header=BB111_9 Depth=1
	ldrh	w8, [x26, :lo12:c_ftl_nand_data_blks_per_plane]
	add	x19, x19, #1                    // =1
	add	x27, x27, #6                    // =6
	cmp	x19, x8
	b.hs	.LBB111_30
.LBB111_9:                              // =>This Inner Loop Header: Depth=1
	ldr	x8, [x28, :lo12:p_valid_page_count_table]
	lsl	x21, x19, #1
	ldrh	w2, [x8, x21]
	cmp	w2, w22
	b.eq	.LBB111_8
// %bb.10:                              //   in Loop: Header=BB111_9 Depth=1
	ldr	x8, [x25, :lo12:p_valid_page_count_check_table]
	ldrh	w3, [x8, x21]
	cmp	w2, w3
	b.eq	.LBB111_8
// %bb.11:                              //   in Loop: Header=BB111_9 Depth=1
	mov	x0, x24
	mov	w1, w19
	bl	sftl_printk
	ldrh	w8, [x20, :lo12:g_active_superblock]
	cmp	x19, x8
	b.eq	.LBB111_8
// %bb.12:                              //   in Loop: Header=BB111_9 Depth=1
	ldrh	w8, [x23, :lo12:g_gc_temp_superblock]
	cmp	x19, x8
	b.eq	.LBB111_8
// %bb.13:                              //   in Loop: Header=BB111_9 Depth=1
	adrp	x8, g_buffer_superblock
	ldrh	w8, [x8, :lo12:g_buffer_superblock]
	cmp	x19, x8
	b.eq	.LBB111_8
// %bb.14:                              //   in Loop: Header=BB111_9 Depth=1
	ldr	x8, [x28, :lo12:p_valid_page_count_table]
	ldr	x9, [x25, :lo12:p_valid_page_count_check_table]
	ldrh	w10, [x8, x21]
	ldrh	w9, [x9, x21]
	strh	w9, [x8, x21]
	cbnz	w10, .LBB111_7
// %bb.15:                              //   in Loop: Header=BB111_9 Depth=1
	adrp	x8, p_data_block_list_table
	ldr	x21, [x8, :lo12:p_data_block_list_table]
	adrp	x9, p_free_data_block_list_head
	ldr	x9, [x9, :lo12:p_free_data_block_list_head]
	add	x24, x21, x27
	ldrsh	w8, [x24, #2]
	cmn	w8, #1                          // =1
	b.ne	.LBB111_18
// %bb.16:                              //   in Loop: Header=BB111_9 Depth=1
	cmp	x24, x9
	b.eq	.LBB111_18
// %bb.17:                              //   in Loop: Header=BB111_9 Depth=1
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.List_remove_node
	mov	w2, #372
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.List_remove_node
	bl	sftl_printk
	adrp	x8, p_free_data_block_list_head
	ldr	x9, [x8, :lo12:p_free_data_block_list_head]
.LBB111_18:                             //   in Loop: Header=BB111_9 Depth=1
	ldrh	w8, [x21, x27]
	cmp	x24, x9
	b.eq	.LBB111_21
// %bb.19:                              //   in Loop: Header=BB111_9 Depth=1
	cmp	w8, w22
	b.eq	.LBB111_23
// %bb.20:                              //   in Loop: Header=BB111_9 Depth=1
	adrp	x11, p_data_block_list_table
	ldr	x9, [x11, :lo12:p_data_block_list_table]
	ldrh	w10, [x24, #2]
	mov	w12, #6
	madd	x8, x8, x12, x9
	strh	w10, [x8, #2]
	ldrh	w9, [x24, #2]
	ldr	x8, [x11, :lo12:p_data_block_list_table]
	ldrh	w10, [x21, x27]
	mul	x9, x9, x12
	strh	w10, [x8, x9]
	b	.LBB111_26
.LBB111_21:                             //   in Loop: Header=BB111_9 Depth=1
	cmp	w8, w22
	b.eq	.LBB111_25
// %bb.22:                              //   in Loop: Header=BB111_9 Depth=1
	adrp	x9, p_data_block_list_table
	ldr	x9, [x9, :lo12:p_data_block_list_table]
	mov	w10, #6
	madd	x8, x8, x10, x9
	adrp	x9, p_free_data_block_list_head
	str	x8, [x9, :lo12:p_free_data_block_list_head]
	strh	w22, [x8, #2]
	b	.LBB111_26
.LBB111_23:                             //   in Loop: Header=BB111_9 Depth=1
	ldrh	w8, [x24, #2]
	cmp	x8, x22
	b.eq	.LBB111_26
// %bb.24:                              //   in Loop: Header=BB111_9 Depth=1
	adrp	x9, p_data_block_list_table
	ldr	x9, [x9, :lo12:p_data_block_list_table]
	mov	w10, #6
	mul	x8, x8, x10
	strh	w22, [x9, x8]
	b	.LBB111_26
.LBB111_25:                             //   in Loop: Header=BB111_9 Depth=1
	adrp	x8, p_free_data_block_list_head
	str	xzr, [x8, :lo12:p_free_data_block_list_head]
.LBB111_26:                             //   in Loop: Header=BB111_9 Depth=1
	strh	w22, [x21, x27]
	strh	w22, [x24, #2]
	adrp	x21, g_num_free_superblocks
	ldrh	w8, [x21, :lo12:g_num_free_superblocks]
	cbnz	w8, .LBB111_28
// %bb.27:                              //   in Loop: Header=BB111_9 Depth=1
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlVpcCheckAndModify
	mov	w2, #2330
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlVpcCheckAndModify
	bl	sftl_printk
	ldrh	w8, [x21, :lo12:g_num_free_superblocks]
.LBB111_28:                             //   in Loop: Header=BB111_9 Depth=1
	sub	w8, w8, #1                      // =1
	mov	w0, w19
	strh	w8, [x21, :lo12:g_num_free_superblocks]
	bl	insert_data_list
	adrp	x10, g_num_data_superblocks
	ldrh	w8, [x10, :lo12:g_num_data_superblocks]
	ldrh	w9, [x26, :lo12:c_ftl_nand_data_blks_per_plane]
	adrp	x24, .L.str.103
	add	x24, x24, :lo12:.L.str.103
	add	w8, w8, #1                      // =1
	cmp	w9, w8, uxth
	strh	w8, [x10, :lo12:g_num_data_superblocks]
	b.hs	.LBB111_8
// %bb.29:                              //   in Loop: Header=BB111_9 Depth=1
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.INSERT_DATA_LIST
	mov	w2, #214
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.INSERT_DATA_LIST
	bl	sftl_printk
	b	.LBB111_8
.LBB111_30:
	bl	FtlWriteDump_data
	adrp	x20, c_ftl_nand_l2pmap_ram_region_num
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	cbz	w8, .LBB111_35
// %bb.31:
	adrp	x19, gL2pMapInfo
	mov	x21, xzr
	mov	x22, xzr
	adrp	x23, p_l2p_ram_map
	add	x19, x19, :lo12:gL2pMapInfo
	b	.LBB111_33
.LBB111_32:                             //   in Loop: Header=BB111_33 Depth=1
	add	x22, x22, #1                    // =1
	cmp	x22, w8, uxth
	add	x21, x21, #16                   // =16
	b.hs	.LBB111_35
.LBB111_33:                             // =>This Inner Loop Header: Depth=1
	ldr	x9, [x23, :lo12:p_l2p_ram_map]
	add	x9, x9, x21
	ldr	w10, [x9, #4]
	tbz	w10, #31, .LBB111_32
// %bb.34:                              //   in Loop: Header=BB111_33 Depth=1
	ldrh	w1, [x9]
	ldr	x2, [x9, #8]
	mov	x0, x19
	bl	FtlMapWritePage
	ldr	x8, [x23, :lo12:p_l2p_ram_map]
	add	x8, x8, x21
	ldr	w9, [x8, #4]
	and	w9, w9, #0x7fffffff
	str	w9, [x8, #4]
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	b	.LBB111_32
.LBB111_35:
	bl	FtlVpcTblFlush
	adrp	x9, __stack_chk_guard
	ldr	x8, [sp, #8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB111_37
// %bb.36:
	ldp	x20, x19, [sp, #96]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	add	sp, sp, #112                    // =112
	hint	#29
	ret
.LBB111_37:
	bl	__stack_chk_fail
.Lfunc_end111:
	.size	FtlVpcCheckAndModify, .Lfunc_end111-FtlVpcCheckAndModify
                                        // -- End function
	.globl	update_vpc_list                 // -- Begin function update_vpc_list
	.p2align	2
	.type	update_vpc_list,@function
update_vpc_list:                        // @update_vpc_list
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-80]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #64]             // 16-byte Folded Spill
	adrp	x20, p_valid_page_count_table
	ldr	x8, [x20, :lo12:p_valid_page_count_table]
	mov	w19, w0
	stp	x22, x21, [sp, #48]             // 16-byte Folded Spill
	and	x21, x19, #0xffff
	ldrh	w8, [x8, x21, lsl #1]
	str	x25, [sp, #16]                  // 8-byte Folded Spill
	stp	x24, x23, [sp, #32]             // 16-byte Folded Spill
	mov	x29, sp
	cbz	w8, .LBB112_2
// %bb.1:
	mov	w0, w19
	bl	List_update_data_list
	mov	w0, wzr
	b	.LBB112_29
.LBB112_2:
	adrp	x8, g_gc_next_blk
	ldrh	w9, [x8, :lo12:g_gc_next_blk]
	cmp	w9, w19, uxth
	b.ne	.LBB112_4
// %bb.3:
	mov	w9, #65535
	strh	w9, [x8, :lo12:g_gc_next_blk]
.LBB112_4:
	adrp	x8, g_gc_next_blk_1
	ldrh	w9, [x8, :lo12:g_gc_next_blk_1]
	cmp	w9, w19, uxth
	b.ne	.LBB112_6
// %bb.5:
	mov	w9, #65535
	strh	w9, [x8, :lo12:g_gc_next_blk_1]
.LBB112_6:
	adrp	x8, g_gc_superblock
	ldrh	w9, [x8, :lo12:g_gc_superblock]
	cmp	w9, w19, uxth
	b.ne	.LBB112_8
// %bb.7:
	mov	w9, #65535
	strh	w9, [x8, :lo12:g_gc_superblock]
	b	.LBB112_11
.LBB112_8:
	adrp	x8, g_active_superblock
	ldrh	w8, [x8, :lo12:g_active_superblock]
	mov	w0, wzr
	cmp	w8, w19, uxth
	b.eq	.LBB112_29
// %bb.9:
	adrp	x8, g_buffer_superblock
	ldrh	w8, [x8, :lo12:g_buffer_superblock]
	cmp	w8, w19, uxth
	b.eq	.LBB112_29
// %bb.10:
	adrp	x8, g_gc_temp_superblock
	ldrh	w8, [x8, :lo12:g_gc_temp_superblock]
	cmp	w8, w19, uxth
	b.eq	.LBB112_29
.LBB112_11:
	adrp	x24, p_data_block_list_table
	ldr	x8, [x24, :lo12:p_data_block_list_table]
	mov	w9, #6
	adrp	x25, p_data_block_list_head
	madd	x22, x21, x9, x8
	mov	x23, x22
	ldrsh	w8, [x23, #2]!
	ldr	x9, [x25, :lo12:p_data_block_list_head]
	cmn	w8, #1                          // =1
	b.ne	.LBB112_14
// %bb.12:
	cmp	x22, x9
	b.eq	.LBB112_14
// %bb.13:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.List_remove_node
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.List_remove_node
	mov	w2, #372
	bl	sftl_printk
	ldr	x9, [x25, :lo12:p_data_block_list_head]
.LBB112_14:
	ldrh	w8, [x22]
	cmp	x22, x9
	b.eq	.LBB112_17
// %bb.15:
	mov	w9, #65535
	cmp	w8, w9
	b.eq	.LBB112_19
// %bb.16:
	ldr	x9, [x24, :lo12:p_data_block_list_table]
	ldrh	w10, [x23]
	mov	w11, #6
	madd	x8, x8, x11, x9
	strh	w10, [x8, #2]
	ldrh	w9, [x23]
	ldr	x8, [x24, :lo12:p_data_block_list_table]
	ldrh	w10, [x22]
	mul	x9, x9, x11
	strh	w10, [x8, x9]
	b	.LBB112_22
.LBB112_17:
	mov	w9, #65535
	cmp	w8, w9
	b.eq	.LBB112_21
// %bb.18:
	ldr	x10, [x24, :lo12:p_data_block_list_table]
	mov	w11, #6
	madd	x8, x8, x11, x10
	str	x8, [x25, :lo12:p_data_block_list_head]
	strh	w9, [x8, #2]
	b	.LBB112_22
.LBB112_19:
	ldrh	w8, [x23]
	mov	w9, #65535
	cmp	x8, x9
	b.eq	.LBB112_22
// %bb.20:
	ldr	x10, [x24, :lo12:p_data_block_list_table]
	mov	w11, #6
	mul	x8, x8, x11
	strh	w9, [x10, x8]
	b	.LBB112_22
.LBB112_21:
	str	xzr, [x25, :lo12:p_data_block_list_head]
.LBB112_22:
	mov	w8, #65535
	strh	w8, [x22]
	strh	w8, [x23]
	adrp	x22, g_num_data_superblocks
	ldrh	w8, [x22, :lo12:g_num_data_superblocks]
	cbnz	w8, .LBB112_24
// %bb.23:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.update_vpc_list
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.update_vpc_list
	mov	w2, #2835
	bl	sftl_printk
	ldrh	w8, [x22, :lo12:g_num_data_superblocks]
.LBB112_24:
	mvn	w9, w19
	sub	w8, w8, #1                      // =1
	tst	w9, #0xffff
	strh	w8, [x22, :lo12:g_num_data_superblocks]
	b.eq	.LBB112_26
// %bb.25:
	ldr	x8, [x20, :lo12:p_valid_page_count_table]
	mov	w0, w19
	strh	wzr, [x8, x21, lsl #1]
	bl	INSERT_FREE_LIST
.LBB112_26:
	mov	w0, w19
	bl	FtlGcFreeBadSuperBlk
	adrp	x8, g_num_free_superblocks
	ldrh	w9, [x22, :lo12:g_num_data_superblocks]
	ldrh	w8, [x8, :lo12:g_num_free_superblocks]
	adrp	x10, c_ftl_nand_data_blks_per_plane
	ldrh	w10, [x10, :lo12:c_ftl_nand_data_blks_per_plane]
	add	w8, w9, w8
	cmp	w8, w10
	b.ls	.LBB112_28
// %bb.27:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.update_vpc_list
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.update_vpc_list
	mov	w2, #2838
	bl	sftl_printk
.LBB112_28:
	mov	w0, #1
.LBB112_29:
	ldp	x20, x19, [sp, #64]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #48]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #32]             // 16-byte Folded Reload
	ldr	x25, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #80             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end112:
	.size	update_vpc_list, .Lfunc_end112-update_vpc_list
                                        // -- End function
	.globl	ftl_check_vpc                   // -- Begin function ftl_check_vpc
	.p2align	2
	.type	ftl_check_vpc,@function
ftl_check_vpc:                          // @ftl_check_vpc
// %bb.0:
	hint	#25
	sub	sp, sp, #112                    // =112
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	adrp	x0, .L.str.102
	adrp	x1, .L__func__.ftl_check_vpc
	add	x0, x0, :lo12:.L.str.102
	add	x1, x1, :lo12:.L__func__.ftl_check_vpc
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	stp	x28, x27, [sp, #32]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #48]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #64]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #80]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #96]             // 16-byte Folded Spill
	add	x29, sp, #16                    // =16
	str	x8, [sp, #8]
	bl	sftl_printk
	adrp	x19, check_vpc_table
	add	x19, x19, :lo12:check_vpc_table
	mov	w2, #8192
	mov	x0, x19
	mov	w1, wzr
	bl	memset
	adrp	x21, g_MaxLpn
	ldr	w8, [x21, :lo12:g_MaxLpn]
	cbz	w8, .LBB113_5
// %bb.1:
	mov	w20, wzr
	adrp	x22, c_ftl_nand_blks_per_die
	adrp	x23, c_ftl_nand_planes_per_die
	b	.LBB113_3
.LBB113_2:                              //   in Loop: Header=BB113_3 Depth=1
	ldr	w8, [x21, :lo12:g_MaxLpn]
	add	w20, w20, #1                    // =1
	cmp	w20, w8
	b.hs	.LBB113_5
.LBB113_3:                              // =>This Inner Loop Header: Depth=1
	add	x1, sp, #4                      // =4
	mov	w0, w20
	mov	w2, wzr
	bl	log2phys
	ldr	w8, [sp, #4]
	cmn	w8, #1                          // =1
	b.eq	.LBB113_2
// %bb.4:                               //   in Loop: Header=BB113_3 Depth=1
	ldrh	w9, [x22, :lo12:c_ftl_nand_blks_per_die]
	ldrh	w10, [x23, :lo12:c_ftl_nand_planes_per_die]
	ubfx	w8, w8, #10, #16
	udiv	w11, w8, w9
	msub	w8, w11, w9, w8
	udiv	w8, w8, w10
	lsl	x8, x8, #1
	ldrh	w9, [x19, x8]
	add	w9, w9, #1                      // =1
	strh	w9, [x19, x8]
	b	.LBB113_2
.LBB113_5:
	adrp	x24, c_ftl_nand_data_blks_per_plane
	ldrh	w8, [x24, :lo12:c_ftl_nand_data_blks_per_plane]
	adrp	x22, p_valid_page_count_table
	cbz	w8, .LBB113_11
// %bb.6:
	ldr	x8, [x22, :lo12:p_valid_page_count_table]
	adrp	x21, .L.str.104
	mov	x20, xzr
	mov	w23, wzr
	add	x21, x21, :lo12:.L.str.104
	mov	w25, #65535
	b	.LBB113_8
.LBB113_7:                              //   in Loop: Header=BB113_8 Depth=1
	ldrh	w9, [x24, :lo12:c_ftl_nand_data_blks_per_plane]
	add	x20, x20, #1                    // =1
	cmp	x20, x9
	b.hs	.LBB113_12
.LBB113_8:                              // =>This Inner Loop Header: Depth=1
	lsl	x9, x20, #1
	ldrh	w2, [x8, x9]
	ldrh	w3, [x19, x9]
	cmp	w2, w3
	b.eq	.LBB113_7
// %bb.9:                               //   in Loop: Header=BB113_8 Depth=1
	mov	x0, x21
	mov	w1, w20
	bl	sftl_printk
	ldr	x8, [x22, :lo12:p_valid_page_count_table]
	ldrh	w9, [x8, x20, lsl #1]
	cmp	w9, w25
	b.eq	.LBB113_7
// %bb.10:                              //   in Loop: Header=BB113_8 Depth=1
	ldrh	w10, [x19, x20, lsl #1]
	cmp	w9, w10
	csinc	w23, w23, wzr, hs
	b	.LBB113_7
.LBB113_11:
	mov	w23, wzr
.LBB113_12:
	adrp	x8, p_free_data_block_list_head
	ldr	x9, [x8, :lo12:p_free_data_block_list_head]
	cbz	x9, .LBB113_19
// %bb.13:
	adrp	x8, g_num_free_superblocks
	ldrh	w24, [x8, :lo12:g_num_free_superblocks]
	cbz	w24, .LBB113_19
// %bb.14:
	adrp	x26, p_data_block_list_table
	ldr	x8, [x26, :lo12:p_data_block_list_table]
	mov	w10, #43691
	movk	w10, #43690, lsl #16
	adrp	x20, .L.str.105
	sub	x9, x9, x8
	lsr	x9, x9, #1
	mov	w25, wzr
	mov	w27, #6
	mov	w28, #65535
	mul	w9, w9, w10
	add	x20, x20, :lo12:.L.str.105
.LBB113_15:                             // =>This Inner Loop Header: Depth=1
	ldr	x10, [x22, :lo12:p_valid_page_count_table]
	and	x21, x9, #0xffff
	ldrh	w2, [x10, x21, lsl #1]
	cbz	w2, .LBB113_17
// %bb.16:                              //   in Loop: Header=BB113_15 Depth=1
	ldrh	w3, [x19, x21, lsl #1]
	mov	x0, x20
	mov	w1, w21
	bl	sftl_printk
	ldr	x8, [x26, :lo12:p_data_block_list_table]
	mov	w23, #1
.LBB113_17:                             //   in Loop: Header=BB113_15 Depth=1
	mul	x9, x21, x27
	ldrh	w9, [x8, x9]
	cmp	w9, w28
	b.eq	.LBB113_19
// %bb.18:                              //   in Loop: Header=BB113_15 Depth=1
	add	w25, w25, #1                    // =1
	cmp	w24, w25, uxth
	b.hi	.LBB113_15
.LBB113_19:
	tst	w23, #0xffff
	b.eq	.LBB113_21
// %bb.20:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.ftl_check_vpc
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.ftl_check_vpc
	mov	w2, #2394
	bl	sftl_printk
.LBB113_21:
	adrp	x9, __stack_chk_guard
	ldr	x8, [sp, #8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB113_23
// %bb.22:
	ldp	x20, x19, [sp, #96]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	add	sp, sp, #112                    // =112
	hint	#29
	ret
.LBB113_23:
	bl	__stack_chk_fail
.Lfunc_end113:
	.size	ftl_check_vpc, .Lfunc_end113-ftl_check_vpc
                                        // -- End function
	.globl	ftl_scan_all_data               // -- Begin function ftl_scan_all_data
	.p2align	2
	.type	ftl_scan_all_data,@function
ftl_scan_all_data:                      // @ftl_scan_all_data
// %bb.0:
	hint	#25
	sub	sp, sp, #128                    // =128
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	adrp	x0, .L.str.106
	stp	x29, x30, [sp, #32]             // 16-byte Folded Spill
	add	x29, sp, #32                    // =32
	add	x0, x0, :lo12:.L.str.106
	mov	w1, wzr
	stp	x28, x27, [sp, #48]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #64]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #80]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #96]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #112]            // 16-byte Folded Spill
	stur	x8, [x29, #-8]
	bl	sftl_printk
	adrp	x24, g_MaxLpn
	ldr	w8, [x24, :lo12:g_MaxLpn]
	cbz	w8, .LBB114_10
// %bb.1:
	adrp	x20, .L.str.107
	adrp	x21, req_sys
	adrp	x27, req_sys+4
	adrp	x22, .L.str.108
	mov	w19, wzr
	add	x20, x20, :lo12:.L.str.107
	add	x21, x21, :lo12:req_sys
	adrp	x25, p_sys_data_buf
	adrp	x26, p_sys_spare_buf
	add	x27, x27, :lo12:req_sys+4
	add	x22, x22, :lo12:.L.str.108
	b	.LBB114_4
.LBB114_2:                              //   in Loop: Header=BB114_4 Depth=1
	ldur	x8, [x27, #12]
	ldur	x9, [x27, #4]
	ldr	w2, [x27]
	mov	x0, x22
	ldp	w3, w4, [x8]
	ldp	w5, w6, [x8, #8]
	ldp	w7, w8, [x9]
	mov	w1, w19
	str	w8, [sp]
	bl	sftl_printk
.LBB114_3:                              //   in Loop: Header=BB114_4 Depth=1
	ldr	w8, [x24, :lo12:g_MaxLpn]
	add	w19, w19, #1                    // =1
	cmp	w19, w8
	b.hs	.LBB114_10
.LBB114_4:                              // =>This Inner Loop Header: Depth=1
	sub	x1, x29, #12                    // =12
	mov	w0, w19
	mov	w2, wzr
	bl	log2phys
	ldur	w23, [x29, #-12]
	tst	w19, #0x7ff
	b.eq	.LBB114_6
// %bb.5:                               //   in Loop: Header=BB114_4 Depth=1
	cmn	w23, #1                         // =1
	b.ne	.LBB114_7
	b	.LBB114_3
.LBB114_6:                              //   in Loop: Header=BB114_4 Depth=1
	mov	x0, x20
	mov	w1, w19
	mov	w2, w23
	bl	sftl_printk
	cmn	w23, #1                         // =1
	b.eq	.LBB114_3
.LBB114_7:                              //   in Loop: Header=BB114_4 Depth=1
	ldr	x8, [x25, :lo12:p_sys_data_buf]
	ldr	x28, [x26, :lo12:p_sys_spare_buf]
	mov	w1, #1
	mov	x0, x21
	str	w19, [x21, #24]
	stp	x8, x28, [x21, #8]
	stp	wzr, w23, [x21]
	bl	FlashReadPages
	ldr	w8, [x21]
	cmn	w8, #1                          // =1
	b.eq	.LBB114_2
// %bb.8:                               //   in Loop: Header=BB114_4 Depth=1
	cmp	w8, #256                        // =256
	b.eq	.LBB114_2
// %bb.9:                               //   in Loop: Header=BB114_4 Depth=1
	ldr	w8, [x28, #8]
	cmp	w19, w8
	b.ne	.LBB114_2
	b	.LBB114_3
.LBB114_10:
	adrp	x9, __stack_chk_guard
	ldur	x8, [x29, #-8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB114_12
// %bb.11:
	ldp	x20, x19, [sp, #112]            // 16-byte Folded Reload
	ldp	x22, x21, [sp, #96]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #80]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #64]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #48]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #32]             // 16-byte Folded Reload
	add	sp, sp, #128                    // =128
	hint	#29
	ret
.LBB114_12:
	bl	__stack_chk_fail
.Lfunc_end114:
	.size	ftl_scan_all_data, .Lfunc_end114-ftl_scan_all_data
                                        // -- End function
	.globl	update_multiplier_value         // -- Begin function update_multiplier_value
	.p2align	2
	.type	update_multiplier_value,@function
update_multiplier_value:                // @update_multiplier_value
// %bb.0:
	hint	#25
	adrp	x8, c_ftl_nand_planes_num
	ldrh	w9, [x8, :lo12:c_ftl_nand_planes_num]
	mov	w8, wzr
                                        // kill: def $w0 killed $w0 def $x0
	cbz	x9, .LBB115_6
// %bb.1:
	adrp	x10, c_ftl_nand_planes_per_die
	adrp	x11, c_ftl_nand_blks_per_die
	adrp	x12, c_ftl_nand_page_pre_blk
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_per_die]
	ldrh	w11, [x11, :lo12:c_ftl_nand_blks_per_die]
	ldrh	w12, [x12, :lo12:c_ftl_nand_page_pre_blk]
	adrp	x13, p_plane_order_table
	adrp	x15, gBbtInfo
	add	x13, x13, :lo12:p_plane_order_table
	mul	w14, w10, w0
	add	x15, x15, :lo12:gBbtInfo
.LBB115_2:                              // =>This Inner Loop Header: Depth=1
	ldrb	w16, [x13], #1
	and	w17, w10, #0xffff
	and	w18, w16, #0xffff
	udiv	w17, w18, w17
	msub	w16, w17, w10, w16
	madd	w17, w11, w17, w14
	add	w16, w17, w16
	and	w18, w11, #0xffff
	and	w17, w16, #0xffff
	udiv	w17, w17, w18
	add	x18, x15, w17, uxtw #3
	ldr	x18, [x18, #32]
	msub	w16, w17, w11, w16
	lsr	w17, w16, #3
	and	x17, x17, #0x1ffc
	ldr	w17, [x18, x17]
	lsr	w16, w17, w16
	tst	w16, #0x1
	csel	w16, w12, wzr, eq
	subs	x9, x9, #1                      // =1
	add	w8, w16, w8
	b.ne	.LBB115_2
// %bb.3:
	tst	w8, #0xffff
	b.eq	.LBB115_5
// %bb.4:
	and	w8, w8, #0xffff
	mov	w9, #32768
	udiv	w8, w9, w8
	b	.LBB115_6
.LBB115_5:
	mov	w8, wzr
.LBB115_6:
	adrp	x9, p_data_block_list_table
	ldr	x9, [x9, :lo12:p_data_block_list_table]
	and	x10, x0, #0xffff
	mov	w11, #6
	mov	w0, wzr
	madd	x9, x10, x11, x9
	strh	w8, [x9, #4]
	hint	#29
	ret
.Lfunc_end115:
	.size	update_multiplier_value, .Lfunc_end115-update_multiplier_value
                                        // -- End function
	.globl	GetSwlReplaceBlock              // -- Begin function GetSwlReplaceBlock
	.p2align	2
	.type	GetSwlReplaceBlock,@function
GetSwlReplaceBlock:                     // @GetSwlReplaceBlock
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	adrp	x11, g_totle_avg_erase_count
	adrp	x9, g_min_erase_count
	ldr	w2, [x11, :lo12:g_totle_avg_erase_count]
	ldr	w10, [x9, :lo12:g_min_erase_count]
	adrp	x8, g_max_erase_count
	str	x19, [sp, #16]                  // 8-byte Folded Spill
	mov	x29, sp
	cmp	w2, w10
	b.hs	.LBB116_5
// %bb.1:
	adrp	x12, c_ftl_nand_data_blks_per_plane
	ldrh	w13, [x12, :lo12:c_ftl_nand_data_blks_per_plane]
	adrp	x12, g_totle_mlc_erase_count
	mov	w14, wzr
	str	wzr, [x12, :lo12:g_totle_mlc_erase_count]
	cbz	w13, .LBB116_4
// %bb.2:
	adrp	x15, p_erase_count_table
	ldr	x15, [x15, :lo12:p_erase_count_table]
	cmp	w13, #1                         // =1
	csinc	w16, w13, wzr, hi
.LBB116_3:                              // =>This Inner Loop Header: Depth=1
	ldrh	w17, [x15], #2
	subs	x16, x16, #1                    // =1
	add	w14, w14, w17
	str	w14, [x12, :lo12:g_totle_mlc_erase_count]
	b.ne	.LBB116_3
.LBB116_4:
	adrp	x15, g_totle_slc_erase_count
	ldr	w15, [x15, :lo12:g_totle_slc_erase_count]
	adrp	x16, c_mlc_erase_count_value
	ldrh	w16, [x16, :lo12:c_mlc_erase_count_value]
	udiv	w2, w14, w13
	str	w2, [x11, :lo12:g_totle_avg_erase_count]
	sub	w11, w14, w15
	udiv	w11, w11, w16
	str	w11, [x12, :lo12:g_totle_mlc_erase_count]
	b	.LBB116_10
.LBB116_5:
	ldr	w13, [x8, :lo12:g_max_erase_count]
	cmp	w2, w13
	b.ls	.LBB116_10
// %bb.6:
	adrp	x12, c_ftl_nand_data_blks_per_plane
	ldrh	w14, [x12, :lo12:c_ftl_nand_data_blks_per_plane]
	add	w13, w13, #1                    // =1
	str	w13, [x8, :lo12:g_max_erase_count]
	cbz	w14, .LBB116_10
// %bb.7:
	mov	x10, xzr
	adrp	x13, p_erase_count_table
.LBB116_8:                              // =>This Inner Loop Header: Depth=1
	ldr	x14, [x13, :lo12:p_erase_count_table]
	lsl	x15, x10, #1
	add	x10, x10, #1                    // =1
	ldrh	w16, [x14, x15]
	add	w16, w16, #1                    // =1
	strh	w16, [x14, x15]
	ldrh	w14, [x12, :lo12:c_ftl_nand_data_blks_per_plane]
	cmp	x10, x14
	b.lo	.LBB116_8
// %bb.9:
	ldr	w10, [x9, :lo12:g_min_erase_count]
	ldr	w2, [x11, :lo12:g_totle_avg_erase_count]
.LBB116_10:
	add	w11, w10, #256                  // =256
	cmp	w11, w2
	b.ls	.LBB116_13
// %bb.11:
	ldr	w11, [x8, :lo12:g_max_erase_count]
	add	w12, w10, #768                  // =768
	cmp	w12, w11
	b.ls	.LBB116_13
.LBB116_12:
	mov	w0, #65535
	b	.LBB116_43
.LBB116_13:
	adrp	x11, p_free_data_block_list_head
	ldr	x11, [x11, :lo12:p_free_data_block_list_head]
	cbz	x11, .LBB116_18
// %bb.14:
	adrp	x12, g_num_free_superblocks
	ldrh	w13, [x12, :lo12:g_num_free_superblocks]
	adrp	x12, p_data_block_list_table
	ldr	x12, [x12, :lo12:p_data_block_list_table]
	lsl	w15, w13, #3
	add	w14, w13, w13, lsl #1
	sub	w13, w15, w13
	lsr	w14, w14, #2
	lsr	w13, w13, #3
	cmp	w13, w14
	sub	x16, x11, x12
	csel	w13, w13, w14, lo
	mov	w14, #43691
	lsr	x15, x16, #1
	movk	w14, #43690, lsl #16
	mul	w16, w15, w14
	cbz	w13, .LBB116_19
// %bb.15:
	mov	w14, wzr
	mov	w15, #6
	mov	w17, #65535
.LBB116_16:                             // =>This Inner Loop Header: Depth=1
	and	x18, x16, #0xffff
	mul	x18, x18, x15
	ldrh	w18, [x12, x18]
	mov	w0, w16
	cmp	w18, w17
	b.eq	.LBB116_20
// %bb.17:                              //   in Loop: Header=BB116_16 Depth=1
	add	w14, w14, #1                    // =1
	and	w16, w14, #0xffff
	cmp	w16, w13, uxth
	mov	w16, w18
	mov	w0, w18
	b.lo	.LBB116_16
	b	.LBB116_20
.LBB116_18:
	mov	w6, wzr
	b	.LBB116_21
.LBB116_19:
	mov	w0, w16
.LBB116_20:
	adrp	x12, p_erase_count_table
	ldr	x12, [x12, :lo12:p_erase_count_table]
	and	x13, x0, #0xffff
	ldrh	w6, [x12, x13, lsl #1]
.LBB116_21:
	add	w12, w10, #64                   // =64
	cmp	w12, w6
	mov	w0, #65535
	b.hi	.LBB116_43
// %bb.22:
	adrp	x12, p_data_block_list_head
	ldr	x5, [x12, :lo12:p_data_block_list_head]
	cbz	x5, .LBB116_43
// %bb.23:
	ldrh	w15, [x5]
	mov	w0, #65535
	cmp	w15, w0
	b.eq	.LBB116_43
// %bb.24:
	adrp	x12, c_ftl_nand_data_blks_per_plane
	adrp	x13, p_data_block_list_table
	adrp	x14, p_erase_count_table
	ldrh	w17, [x12, :lo12:c_ftl_nand_data_blks_per_plane]
	ldr	x18, [x13, :lo12:p_data_block_list_table]
	ldr	x1, [x14, :lo12:p_erase_count_table]
	mov	x4, #-6148914691236517206
	mov	w16, wzr
	mov	w3, #6
	movk	x4, #43691
	mov	w12, #65535
	mov	w19, #65535
	b	.LBB116_26
.LBB116_25:                             //   in Loop: Header=BB116_26 Depth=1
	and	x15, x15, #0xffff
	madd	x5, x15, x3, x18
	ldrh	w15, [x5]
	cmp	w15, w0
	b.eq	.LBB116_31
.LBB116_26:                             // =>This Inner Loop Header: Depth=1
	add	w16, w16, #1                    // =1
	cmp	w17, w16, uxth
	b.lo	.LBB116_12
// %bb.27:                              //   in Loop: Header=BB116_26 Depth=1
	ldrh	w7, [x5, #4]
	cbz	w7, .LBB116_25
// %bb.28:                              //   in Loop: Header=BB116_26 Depth=1
	sub	x5, x5, x18
	asr	x5, x5, #1
	mul	x5, x5, x4
	and	x7, x5, #0xffff
	ldrh	w7, [x1, x7, lsl #1]
	cmp	w10, w7
	b.hs	.LBB116_30
// %bb.29:                              //   in Loop: Header=BB116_26 Depth=1
	cmp	w7, w12, uxth
	csel	w19, w5, w19, lo
	csel	w12, w7, w12, lo
	b	.LBB116_25
.LBB116_30:
	mov	w19, w5
.LBB116_31:
	and	w1, w19, #0xffff
	mov	w0, #65535
	cmp	w1, w0
	b.eq	.LBB116_43
// %bb.32:
	ldr	x14, [x14, :lo12:p_erase_count_table]
	and	x15, x19, #0xffff
	ldrh	w16, [x14, x15, lsl #1]
	cmp	w10, w16
	b.hs	.LBB116_37
// %bb.33:
	cbz	x11, .LBB116_35
// %bb.34:
	ldr	w13, [x13, :lo12:p_data_block_list_table]
	sub	w11, w11, w13
	mov	w13, #43691
	lsr	w11, w11, #1
	movk	w13, #43690, lsl #16
	mul	w11, w11, w13
	and	x11, x11, #0xffff
	ldrh	w11, [x14, x11, lsl #1]
.LBB116_35:
	cmp	w10, w11
	b.hs	.LBB116_37
// %bb.36:
	and	w10, w12, #0xffff
	str	w10, [x9, :lo12:g_min_erase_count]
.LBB116_37:
	cmp	w2, w16
	mov	w0, #65535
	b.ls	.LBB116_43
// %bb.38:
	add	w9, w16, #128                   // =128
	cmp	w9, w6
	b.hs	.LBB116_43
// %bb.39:
	add	w9, w16, #256                   // =256
	cmp	w9, w2
	b.hs	.LBB116_41
// %bb.40:
	ldr	w3, [x8, :lo12:g_max_erase_count]
	b	.LBB116_42
.LBB116_41:
	ldr	w3, [x8, :lo12:g_max_erase_count]
	add	w8, w16, #768                   // =768
	cmp	w8, w3
	b.hs	.LBB116_12
.LBB116_42:
	adrp	x8, p_valid_page_count_table
	ldr	x8, [x8, :lo12:p_valid_page_count_table]
	lsl	x9, x15, #1
	ldrh	w5, [x14, x9]
	adrp	x0, .L.str.109
	ldrh	w4, [x8, x9]
	add	x0, x0, :lo12:.L.str.109
	bl	sftl_printk
	adrp	x8, g_in_swl_replace
	mov	w9, #1
	str	w9, [x8, :lo12:g_in_swl_replace]
	mov	w0, w19
.LBB116_43:
	ldr	x19, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end116:
	.size	GetSwlReplaceBlock, .Lfunc_end116-GetSwlReplaceBlock
                                        // -- End function
	.globl	free_data_superblock            // -- Begin function free_data_superblock
	.p2align	2
	.type	free_data_superblock,@function
free_data_superblock:                   // @free_data_superblock
// %bb.0:
	hint	#34
                                        // kill: def $w0 killed $w0 def $x0
	mvn	w8, w0
	tst	w8, #0xffff
	b.eq	.LBB117_2
// %bb.1:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
	adrp	x8, p_valid_page_count_table
	ldr	x8, [x8, :lo12:p_valid_page_count_table]
	and	x9, x0, #0xffff
	mov	x29, sp
                                        // kill: def $w0 killed $w0 killed $x0
	strh	wzr, [x8, x9, lsl #1]
	bl	INSERT_FREE_LIST
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
.LBB117_2:
	mov	w0, wzr
	ret
.Lfunc_end117:
	.size	free_data_superblock, .Lfunc_end117-free_data_superblock
                                        // -- End function
	.globl	allocate_data_superblock        // -- Begin function allocate_data_superblock
	.p2align	2
	.type	allocate_data_superblock,@function
allocate_data_superblock:               // @allocate_data_superblock
// %bb.0:
	hint	#25
	sub	sp, sp, #112                    // =112
	stp	x26, x25, [sp, #48]             // 16-byte Folded Spill
	adrp	x26, .L.str.78
	stp	x28, x27, [sp, #32]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #64]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #80]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #96]             // 16-byte Folded Spill
	mov	x19, x0
	add	x24, x0, #16                    // =16
	adrp	x23, g_num_free_superblocks
	adrp	x28, g_num_data_superblocks
	adrp	x21, c_ftl_nand_data_blks_per_plane
	add	x26, x26, :lo12:.L.str.78
	adrp	x27, p_valid_page_count_table
	mov	w22, #65535
	adrp	x20, req_erase
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	add	x29, sp, #16                    // =16
.LBB118_1:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB118_16 Depth 2
                                        //     Child Loop BB118_35 Depth 2
                                        //     Child Loop BB118_39 Depth 2
                                        //     Child Loop BB118_44 Depth 2
	ldrh	w8, [x23, :lo12:g_num_free_superblocks]
	ldrh	w9, [x28, :lo12:g_num_data_superblocks]
	ldrh	w10, [x21, :lo12:c_ftl_nand_data_blks_per_plane]
	add	w8, w9, w8
	cmp	w8, w10
	b.ls	.LBB118_3
// %bb.2:                               //   in Loop: Header=BB118_1 Depth=1
	adrp	x1, .L__func__.allocate_data_superblock
	mov	w2, #2667
	mov	x0, x26
	add	x1, x1, :lo12:.L__func__.allocate_data_superblock
	bl	sftl_printk
.LBB118_3:                              //   in Loop: Header=BB118_1 Depth=1
	adrp	x8, g_gc_temp_superblock
	add	x8, x8, :lo12:g_gc_temp_superblock
	cmp	x19, x8
	b.eq	.LBB118_5
.LBB118_4:                              //   in Loop: Header=BB118_1 Depth=1
	mov	w1, wzr
	b	.LBB118_6
.LBB118_5:                              //   in Loop: Header=BB118_1 Depth=1
	adrp	x9, g_in_swl_replace
	ldrh	w8, [x23, :lo12:g_num_free_superblocks]
	ldr	w9, [x9, :lo12:g_in_swl_replace]
	mul	w9, w9, w8
	lsr	w9, w9, #2
	add	w1, w9, w8, lsr #1
	mvn	w8, w1
	tst	w8, #0xffff
	b.eq	.LBB118_4
.LBB118_6:                              //   in Loop: Header=BB118_1 Depth=1
	adrp	x0, p_free_data_block_list_head
	add	x0, x0, :lo12:p_free_data_block_list_head
	bl	List_pop_index_node
	ldrh	w8, [x23, :lo12:g_num_free_superblocks]
	mov	w25, w0
	cbnz	w8, .LBB118_8
// %bb.7:                               //   in Loop: Header=BB118_1 Depth=1
	adrp	x1, .L__func__.allocate_data_superblock
	mov	w2, #2676
	mov	x0, x26
	add	x1, x1, :lo12:.L__func__.allocate_data_superblock
	bl	sftl_printk
	ldrh	w8, [x23, :lo12:g_num_free_superblocks]
.LBB118_8:                              //   in Loop: Header=BB118_1 Depth=1
	ldrh	w9, [x21, :lo12:c_ftl_nand_data_blks_per_plane]
	sub	w10, w8, #1                     // =1
	and	w8, w25, #0xffff
	strh	w10, [x23, :lo12:g_num_free_superblocks]
	cmp	w8, w9
	b.hs	.LBB118_1
// %bb.9:                               //   in Loop: Header=BB118_1 Depth=1
	ldr	x9, [x27, :lo12:p_valid_page_count_table]
	ldrh	w9, [x9, w8, uxtw #1]
	mov	w8, w8
	cbnz	w9, .LBB118_1
// %bb.10:                              //   in Loop: Header=BB118_1 Depth=1
	mov	x0, x19
	str	x8, [sp, #8]                    // 8-byte Folded Spill
	strh	w25, [x19]
	bl	make_superblock
	ldrb	w8, [x19, #7]
	cbz	w8, .LBB118_25
// %bb.11:                              //   in Loop: Header=BB118_1 Depth=1
	ldrh	w8, [x23, :lo12:g_num_free_superblocks]
	ldrh	w9, [x28, :lo12:g_num_data_superblocks]
	ldrh	w10, [x21, :lo12:c_ftl_nand_data_blks_per_plane]
	add	w8, w9, w8
	cmp	w8, w10
	b.ls	.LBB118_13
// %bb.12:                              //   in Loop: Header=BB118_1 Depth=1
	adrp	x1, .L__func__.allocate_data_superblock
	mov	w2, #2693
	mov	x0, x26
	add	x1, x1, :lo12:.L__func__.allocate_data_superblock
	bl	sftl_printk
.LBB118_13:                             //   in Loop: Header=BB118_1 Depth=1
	adrp	x13, c_ftl_nand_planes_num
	ldrh	w9, [x13, :lo12:c_ftl_nand_planes_num]
	cbz	w9, .LBB118_20
// %bb.14:                              //   in Loop: Header=BB118_1 Depth=1
	mov	x8, xzr
	mov	x10, xzr
	mov	w21, wzr
	b	.LBB118_16
.LBB118_15:                             //   in Loop: Header=BB118_16 Depth=2
	add	x10, x10, #1                    // =1
	cmp	x10, w9, uxth
	add	x8, x8, #32                     // =32
	b.hs	.LBB118_18
.LBB118_16:                             //   Parent Loop BB118_1 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldr	x11, [x20, :lo12:req_erase]
	add	x11, x11, x8
	str	xzr, [x11, #8]
	ldr	x11, [x20, :lo12:req_erase]
	add	x11, x11, x8
	str	xzr, [x11, #16]
	ldrh	w11, [x24, x10, lsl #1]
	cmp	w11, w22
	b.eq	.LBB118_15
// %bb.17:                              //   in Loop: Header=BB118_16 Depth=2
	ldr	x9, [x20, :lo12:req_erase]
	and	x12, x21, #0xffff
	lsl	w11, w11, #10
	add	w21, w21, #1                    // =1
	add	x9, x9, x12, lsl #5
	str	w11, [x9, #4]
	ldrh	w9, [x13, :lo12:c_ftl_nand_planes_num]
	b	.LBB118_15
.LBB118_18:                             //   in Loop: Header=BB118_1 Depth=1
	ands	w2, w21, #0xffff
	b.eq	.LBB118_20
// %bb.19:                              //   in Loop: Header=BB118_1 Depth=1
	mov	w26, wzr
	b	.LBB118_21
.LBB118_20:                             //   in Loop: Header=BB118_1 Depth=1
	adrp	x1, .L__func__.allocate_data_superblock
	mov	w2, #2704
	mov	x0, x26
	add	x1, x1, :lo12:.L__func__.allocate_data_superblock
	bl	sftl_printk
	mov	w2, wzr
	mov	w21, wzr
	mov	w26, #1
.LBB118_21:                             //   in Loop: Header=BB118_1 Depth=1
	adrp	x8, g_gc_superblock
	ldrh	w8, [x8, :lo12:g_gc_superblock]
	ldr	x11, [sp, #8]                   // 8-byte Folded Reload
	cmp	w8, w25, uxth
	b.ne	.LBB118_23
// %bb.22:                              //   in Loop: Header=BB118_1 Depth=1
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.allocate_data_superblock
	mov	x23, x28
	mov	w28, w26
	mov	x26, x27
	mov	w27, w2
	mov	w2, #2706
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.allocate_data_superblock
	bl	sftl_printk
	ldr	x11, [sp, #8]                   // 8-byte Folded Reload
	mov	w2, w27
	mov	x27, x26
	mov	w26, w28
	mov	x28, x23
	adrp	x23, g_num_free_superblocks
.LBB118_23:                             //   in Loop: Header=BB118_1 Depth=1
	adrp	x8, p_erase_count_table
	ldr	x8, [x8, :lo12:p_erase_count_table]
	ldrb	w10, [x19, #8]
	ldrh	w9, [x8, x11, lsl #1]
	cbz	w10, .LBB118_29
// %bb.24:                              //   in Loop: Header=BB118_1 Depth=1
	adrp	x10, g_totle_slc_erase_count
	add	w9, w9, #1                      // =1
	add	x10, x10, :lo12:g_totle_slc_erase_count
	b	.LBB118_30
.LBB118_25:                             //   in Loop: Header=BB118_1 Depth=1
	ldr	x8, [x27, :lo12:p_valid_page_count_table]
	ldr	x9, [sp, #8]                    // 8-byte Folded Reload
	mov	w0, w25
	strh	w22, [x8, x9, lsl #1]
	bl	insert_data_list
	ldrh	w8, [x28, :lo12:g_num_data_superblocks]
	ldrh	w9, [x21, :lo12:c_ftl_nand_data_blks_per_plane]
	add	w8, w8, #1                      // =1
	cmp	w9, w8, uxth
	strh	w8, [x28, :lo12:g_num_data_superblocks]
	b.hs	.LBB118_27
// %bb.26:                              //   in Loop: Header=BB118_1 Depth=1
	adrp	x1, .L__func__.INSERT_DATA_LIST
	mov	w2, #214
	mov	x0, x26
	add	x1, x1, :lo12:.L__func__.INSERT_DATA_LIST
	bl	sftl_printk
	ldrh	w8, [x28, :lo12:g_num_data_superblocks]
	ldrh	w9, [x21, :lo12:c_ftl_nand_data_blks_per_plane]
.LBB118_27:                             //   in Loop: Header=BB118_1 Depth=1
	ldrh	w10, [x23, :lo12:g_num_free_superblocks]
	add	w8, w10, w8, uxth
	cmp	w8, w9
	b.ls	.LBB118_1
// %bb.28:                              //   in Loop: Header=BB118_1 Depth=1
	adrp	x1, .L__func__.allocate_data_superblock
	mov	w2, #2690
	mov	x0, x26
	add	x1, x1, :lo12:.L__func__.allocate_data_superblock
	bl	sftl_printk
	b	.LBB118_1
.LBB118_29:                             //   in Loop: Header=BB118_1 Depth=1
	adrp	x10, c_mlc_erase_count_value
	ldrh	w10, [x10, :lo12:c_mlc_erase_count_value]
	cmp	w9, #0                          // =0
	add	w10, w10, w9
	mov	w9, #2
	csel	w9, w9, w10, eq
	adrp	x10, g_totle_mlc_erase_count
	add	x10, x10, :lo12:g_totle_mlc_erase_count
.LBB118_30:                             //   in Loop: Header=BB118_1 Depth=1
	lsl	x11, x11, #1
	strh	w9, [x8, x11]
	ldr	w8, [x10]
	adrp	x9, p_erase_count_table
	ldr	x9, [x9, :lo12:p_erase_count_table]
	add	w8, w8, #1                      // =1
	str	w8, [x10]
	ldrh	w8, [x9, x11]
	adrp	x9, g_max_erase_count
	ldr	w9, [x9, :lo12:g_max_erase_count]
	cmp	w9, w8
	b.hs	.LBB118_32
// %bb.31:                              //   in Loop: Header=BB118_1 Depth=1
	adrp	x9, g_max_erase_count
	str	w8, [x9, :lo12:g_max_erase_count]
.LBB118_32:                             //   in Loop: Header=BB118_1 Depth=1
	adrp	x8, g_totle_mlc_erase_count
	adrp	x9, c_mlc_erase_count_value
	adrp	x10, g_totle_slc_erase_count
	ldr	w8, [x8, :lo12:g_totle_mlc_erase_count]
	ldrh	w9, [x9, :lo12:c_mlc_erase_count_value]
	ldr	w10, [x10, :lo12:g_totle_slc_erase_count]
	adrp	x11, c_ftl_nand_data_blks_per_plane
	ldrh	w11, [x11, :lo12:c_ftl_nand_data_blks_per_plane]
	adrp	x12, gp_ect_tbl_info
	ldr	x12, [x12, :lo12:gp_ect_tbl_info]
	madd	w8, w8, w9, w10
	udiv	w8, w8, w11
	adrp	x9, g_totle_avg_erase_count
	str	w8, [x9, :lo12:g_totle_avg_erase_count]
	ldr	w8, [x12, #16]
	add	w8, w8, #1                      // =1
	str	w8, [x12, #16]
	cbz	w26, .LBB118_34
// %bb.33:                              //   in Loop: Header=BB118_1 Depth=1
	ldr	x0, [x20, :lo12:req_erase]
	bl	FlashEraseBlocks
	b	.LBB118_50
.LBB118_34:                             //   in Loop: Header=BB118_1 Depth=1
                                        // kill: def $w21 killed $w21 killed $x21 def $x21
	mov	w9, #4
	and	x21, x21, #0xffff
	mov	x8, x21
.LBB118_35:                             //   Parent Loop BB118_1 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldr	x10, [x20, :lo12:req_erase]
	subs	x8, x8, #1                      // =1
	ldr	w11, [x10, x9]
	and	w11, w11, #0xfffffc00
	str	w11, [x10, x9]
	add	x9, x9, #32                     // =32
	b.ne	.LBB118_35
// %bb.36:                              //   in Loop: Header=BB118_1 Depth=1
	ldr	x0, [x20, :lo12:req_erase]
	bl	FlashEraseBlocks
	adrp	x10, c_ftl_nand_planes_num
	tbnz	w26, #0, .LBB118_50
// %bb.37:                              //   in Loop: Header=BB118_1 Depth=1
	mov	x27, xzr
	mov	w26, wzr
	mov	x28, x24
	b	.LBB118_39
.LBB118_38:                             //   in Loop: Header=BB118_39 Depth=2
	add	x27, x27, #32                   // =32
	subs	x21, x21, #1                    // =1
	add	x28, x28, #2                    // =2
	b.eq	.LBB118_41
.LBB118_39:                             //   Parent Loop BB118_1 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldr	x8, [x20, :lo12:req_erase]
	ldr	w9, [x8, x27]
	cmn	w9, #1                          // =1
	b.ne	.LBB118_38
// %bb.40:                              //   in Loop: Header=BB118_39 Depth=2
	add	x8, x8, x27
	ldr	w8, [x8, #4]
	adrp	x9, c_ftl_nand_blks_per_die
	ldrh	w9, [x9, :lo12:c_ftl_nand_blks_per_die]
	adrp	x22, gBbtInfo
	ubfx	w1, w8, #10, #16
	add	x22, x22, :lo12:gBbtInfo
	udiv	w2, w1, w9
	lsr	w10, w8, #10
	add	x8, x22, w2, uxtw #3
	ldr	x8, [x8, #32]
	msub	w9, w2, w9, w10
	ubfx	w10, w9, #3, #13
	and	x10, x10, #0x1ffc
	ldr	w11, [x8, x10]
	mov	w12, #1
	and	w3, w9, #0xffff
	lsl	w9, w12, w9
	adrp	x0, .L.str.82
	orr	w4, w9, w11
	add	x0, x0, :lo12:.L.str.82
	add	w26, w26, #1                    // =1
	str	w4, [x8, x10]
	bl	sftl_printk
	ldrh	w8, [x22, #6]
	adrp	x10, c_ftl_nand_planes_num
	add	w8, w8, #1                      // =1
	strh	w8, [x22, #6]
	mov	w22, #65535
	strh	w22, [x28]
	ldrb	w8, [x19, #7]
	sub	w8, w8, #1                      // =1
	strb	w8, [x19, #7]
	b	.LBB118_38
.LBB118_41:                             //   in Loop: Header=BB118_1 Depth=1
	cmp	w26, #1                         // =1
	adrp	x27, p_valid_page_count_table
	adrp	x28, g_num_data_superblocks
	b.lt	.LBB118_50
// %bb.42:                              //   in Loop: Header=BB118_1 Depth=1
	ldrh	w9, [x10, :lo12:c_ftl_nand_planes_num]
	cbz	x9, .LBB118_47
// %bb.43:                              //   in Loop: Header=BB118_1 Depth=1
	adrp	x10, c_ftl_nand_planes_per_die
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_per_die]
	adrp	x11, c_ftl_nand_blks_per_die
	adrp	x12, c_ftl_nand_page_pre_blk
	ldrh	w11, [x11, :lo12:c_ftl_nand_blks_per_die]
	ldrh	w12, [x12, :lo12:c_ftl_nand_page_pre_blk]
	adrp	x14, p_plane_order_table
	adrp	x18, gBbtInfo
	mov	w8, wzr
	mul	w13, w10, w25
	add	x14, x14, :lo12:p_plane_order_table
	add	x18, x18, :lo12:gBbtInfo
.LBB118_44:                             //   Parent Loop BB118_1 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldrb	w15, [x14], #1
	and	w16, w10, #0xffff
	and	w17, w15, #0xffff
	udiv	w16, w17, w16
	msub	w15, w16, w10, w15
	madd	w16, w16, w11, w13
	add	w15, w16, w15
	and	w17, w11, #0xffff
	and	w16, w15, #0xffff
	udiv	w16, w16, w17
	add	x17, x18, w16, uxtw #3
	ldr	x17, [x17, #32]
	msub	w15, w16, w11, w15
	lsr	w16, w15, #3
	and	x16, x16, #0x1ffc
	ldr	w16, [x17, x16]
	lsr	w15, w16, w15
	tst	w15, #0x1
	csel	w15, w12, wzr, eq
	subs	x9, x9, #1                      // =1
	add	w8, w15, w8
	b.ne	.LBB118_44
// %bb.45:                              //   in Loop: Header=BB118_1 Depth=1
	ldr	x11, [sp, #8]                   // 8-byte Folded Reload
	tst	w8, #0xffff
	b.eq	.LBB118_48
// %bb.46:                              //   in Loop: Header=BB118_1 Depth=1
	and	w8, w8, #0xffff
	mov	w9, #32768
	udiv	w8, w9, w8
	b	.LBB118_49
.LBB118_47:                             //   in Loop: Header=BB118_1 Depth=1
	ldr	x11, [sp, #8]                   // 8-byte Folded Reload
.LBB118_48:                             //   in Loop: Header=BB118_1 Depth=1
	mov	w8, wzr
.LBB118_49:                             //   in Loop: Header=BB118_1 Depth=1
	adrp	x9, p_data_block_list_table
	ldr	x9, [x9, :lo12:p_data_block_list_table]
	mov	w10, #6
	madd	x9, x11, x10, x9
	strh	w8, [x9, #4]
	bl	FtlBbmTblFlush
.LBB118_50:                             //   in Loop: Header=BB118_1 Depth=1
	ldrb	w8, [x19, #7]
	cbnz	w8, .LBB118_52
// %bb.51:                              //   in Loop: Header=BB118_1 Depth=1
	ldr	x8, [x27, :lo12:p_valid_page_count_table]
	ldr	x9, [sp, #8]                    // 8-byte Folded Reload
	adrp	x26, .L.str.78
	adrp	x21, c_ftl_nand_data_blks_per_plane
	add	x26, x26, :lo12:.L.str.78
	strh	w22, [x8, x9, lsl #1]
	b	.LBB118_1
.LBB118_52:
	adrp	x9, c_ftl_nand_page_pre_blk
	ldrh	w9, [x9, :lo12:c_ftl_nand_page_pre_blk]
	strh	w25, [x19]
	strh	wzr, [x19, #2]
	strb	wzr, [x19, #6]
	mul	w8, w9, w8
	adrp	x10, g_GlobalSysVersion
	strh	w8, [x19, #4]
	ldr	w9, [x10, :lo12:g_GlobalSysVersion]
	str	w9, [x19, #12]
	add	w9, w9, #1                      // =1
	str	w9, [x10, :lo12:g_GlobalSysVersion]
	ldr	x9, [x27, :lo12:p_valid_page_count_table]
	ldrh	w10, [x19]
	strh	w8, [x9, x10, lsl #1]
	ldrh	w8, [x19, #4]
	cbz	w8, .LBB118_54
// %bb.53:
	ldrb	w8, [x19, #7]
	cbnz	w8, .LBB118_55
.LBB118_54:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.allocate_data_superblock
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.allocate_data_superblock
	mov	w2, #2759
	bl	sftl_printk
.LBB118_55:
	ldp	x20, x19, [sp, #96]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	add	sp, sp, #112                    // =112
	hint	#29
	ret
.Lfunc_end118:
	.size	allocate_data_superblock, .Lfunc_end118-allocate_data_superblock
                                        // -- End function
	.globl	FtlGcFreeBadSuperBlk            // -- Begin function FtlGcFreeBadSuperBlk
	.p2align	2
	.type	FtlGcFreeBadSuperBlk,@function
FtlGcFreeBadSuperBlk:                   // @FtlGcFreeBadSuperBlk
// %bb.0:
	hint	#25
	sub	sp, sp, #112                    // =112
	stp	x26, x25, [sp, #48]             // 16-byte Folded Spill
	adrp	x26, g_gc_bad_block_temp_num
	ldrh	w8, [x26, :lo12:g_gc_bad_block_temp_num]
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	add	x29, sp, #16                    // =16
	stp	x28, x27, [sp, #32]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #64]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #80]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #96]             // 16-byte Folded Spill
	stur	w0, [x29, #-4]                  // 4-byte Folded Spill
	cbz	w8, .LBB119_28
// %bb.1:
	adrp	x9, c_ftl_nand_planes_num
	ldrh	w9, [x9, :lo12:c_ftl_nand_planes_num]
	adrp	x24, g_gc_bad_block_temp_tbl
	add	x24, x24, :lo12:g_gc_bad_block_temp_tbl
	cbz	w9, .LBB119_17
// %bb.2:
	adrp	x27, gBbtInfo
	adrp	x21, .L.str.82
	mov	x28, xzr
	add	x27, x27, :lo12:gBbtInfo
	add	x21, x21, :lo12:.L.str.82
	mov	w10, #1
	b	.LBB119_5
.LBB119_3:                              //   in Loop: Header=BB119_5 Depth=1
	adrp	x9, c_ftl_nand_planes_num
	ldrh	w9, [x9, :lo12:c_ftl_nand_planes_num]
	mov	w10, w8
.LBB119_4:                              //   in Loop: Header=BB119_5 Depth=1
	add	x28, x28, #1                    // =1
	cmp	x28, w9, uxth
	b.hs	.LBB119_17
.LBB119_5:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB119_9 Depth 2
                                        //       Child Loop BB119_13 Depth 3
                                        //       Child Loop BB119_15 Depth 3
	tst	w10, #0xffff
	b.eq	.LBB119_16
// %bb.6:                               //   in Loop: Header=BB119_5 Depth=1
	adrp	x9, p_plane_order_table
	add	x9, x9, :lo12:p_plane_order_table
	adrp	x10, c_ftl_nand_planes_per_die
	ldrb	w9, [x9, x28]
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_per_die]
	adrp	x11, c_ftl_nand_blks_per_die
	ldur	w14, [x29, #-4]                 // 4-byte Folded Reload
	ldrh	w11, [x11, :lo12:c_ftl_nand_blks_per_die]
	and	w12, w9, #0xffff
	and	w13, w10, #0xffff
	mul	w14, w10, w14
	udiv	w12, w12, w13
	madd	w11, w11, w12, w14
	msub	w9, w12, w10, w9
	add	w23, w11, w9
	adrp	x20, g_gc_bad_block_temp_tbl+2
	mov	x19, xzr
	mov	x25, xzr
	and	w22, w23, #0xffff
	add	x20, x20, :lo12:g_gc_bad_block_temp_tbl+2
	b	.LBB119_9
.LBB119_7:                              //   in Loop: Header=BB119_9 Depth=2
	sub	w8, w8, #1                      // =1
	strh	w8, [x26, :lo12:g_gc_bad_block_temp_num]
.LBB119_8:                              //   in Loop: Header=BB119_9 Depth=2
	add	x25, x25, #1                    // =1
	add	x20, x20, #2                    // =2
	cmp	x25, w8, uxth
	sub	x19, x19, #1                    // =1
	b.hs	.LBB119_3
.LBB119_9:                              //   Parent Loop BB119_5 Depth=1
                                        // =>  This Loop Header: Depth=2
                                        //       Child Loop BB119_13 Depth 3
                                        //       Child Loop BB119_15 Depth 3
	ldrh	w9, [x24, x25, lsl #1]
	cmp	w9, w23, uxth
	b.ne	.LBB119_8
// %bb.10:                              //   in Loop: Header=BB119_9 Depth=2
	adrp	x0, .L.str.114
	add	x0, x0, :lo12:.L.str.114
	mov	w1, w22
	bl	sftl_printk
	adrp	x8, c_ftl_nand_blks_per_die
	ldrh	w8, [x8, :lo12:c_ftl_nand_blks_per_die]
	and	w9, w23, #0xffff
	mov	w12, #1
	mov	x0, x21
	udiv	w2, w9, w8
	add	x9, x27, w2, uxtw #3
	ldr	x9, [x9, #32]
	msub	w8, w2, w8, w23
	ubfx	w10, w8, #3, #13
	and	x10, x10, #0x1ffc
	ldr	w11, [x9, x10]
	and	w3, w8, #0xffff
	lsl	w8, w12, w8
	mov	w1, w22
	orr	w4, w8, w11
	str	w4, [x9, x10]
	bl	sftl_printk
	ldrh	w8, [x27, #6]
	add	w8, w8, #1                      // =1
	strh	w8, [x27, #6]
	bl	FtlBbmTblFlush
	ldrh	w8, [x26, :lo12:g_gc_bad_block_temp_num]
	cmp	x25, x8
	b.hs	.LBB119_7
// %bb.11:                              //   in Loop: Header=BB119_9 Depth=2
	sub	x10, x8, x25
	cmp	x10, #2                         // =2
	mov	x9, x25
	b.lo	.LBB119_15
// %bb.12:                              //   in Loop: Header=BB119_9 Depth=2
	and	x11, x10, #0xfffffffffffffffe
	add	x12, x19, x8
	add	x9, x25, x11
	and	x12, x12, #0xfffffffffffffffe
	mov	x13, x20
.LBB119_13:                             //   Parent Loop BB119_5 Depth=1
                                        //     Parent Loop BB119_9 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	ldrh	w14, [x13]
	ldrh	w15, [x13, #2]
	subs	x12, x12, #2                    // =2
	sturh	w14, [x13, #-2]
	strh	w15, [x13], #4
	b.ne	.LBB119_13
// %bb.14:                              //   in Loop: Header=BB119_9 Depth=2
	cmp	x10, x11
	b.eq	.LBB119_7
.LBB119_15:                             //   Parent Loop BB119_5 Depth=1
                                        //     Parent Loop BB119_9 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	add	x10, x24, x9, lsl #1
	ldrh	w11, [x10, #2]
	add	x9, x9, #1                      // =1
	cmp	x9, x8
	strh	w11, [x10]
	b.lo	.LBB119_15
	b	.LBB119_7
.LBB119_16:                             //   in Loop: Header=BB119_5 Depth=1
	mov	w10, wzr
	b	.LBB119_4
.LBB119_17:
	tst	w8, #0xffff
	b.eq	.LBB119_28
// %bb.18:
	adrp	x21, g_gc_next_blk
	ldrh	w9, [x21, :lo12:g_gc_next_blk]
	mov	w10, #65535
	cmp	w9, w10
	b.ne	.LBB119_28
// %bb.19:
	adrp	x20, g_gc_bad_block_gc_index
	ldrh	w9, [x20, :lo12:g_gc_bad_block_gc_index]
	cmp	w9, w8, uxth
	b.lo	.LBB119_21
// %bb.20:
	mov	w9, wzr
	strh	wzr, [x20, :lo12:g_gc_bad_block_gc_index]
.LBB119_21:
	ldrh	w8, [x24, w9, uxtw #1]
	adrp	x9, c_ftl_nand_blks_per_die
	ldrh	w9, [x9, :lo12:c_ftl_nand_blks_per_die]
	adrp	x10, c_ftl_nand_planes_per_die
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_per_die]
	adrp	x0, .L.str.112
	udiv	w11, w8, w9
	msub	w8, w11, w9, w8
	udiv	w19, w8, w10
	add	x0, x0, :lo12:.L.str.112
	mov	w1, w19
	bl	sftl_printk
	ldrh	w9, [x21, :lo12:g_gc_next_blk]
	cmp	w9, w19
	b.eq	.LBB119_27
// %bb.22:
	adrp	x8, g_gc_next_blk_1
	ldrh	w10, [x8, :lo12:g_gc_next_blk_1]
	cmp	w10, w19, uxth
	b.eq	.LBB119_27
// %bb.23:
	mov	w11, #65535
	cmp	w9, w11
	b.eq	.LBB119_26
// %bb.24:
	cmp	w10, w11
	b.ne	.LBB119_27
// %bb.25:
	strh	w19, [x8, :lo12:g_gc_next_blk_1]
	b	.LBB119_27
.LBB119_26:
	strh	w19, [x21, :lo12:g_gc_next_blk]
.LBB119_27:
	ldrh	w8, [x20, :lo12:g_gc_bad_block_gc_index]
	add	w8, w8, #1                      // =1
	strh	w8, [x20, :lo12:g_gc_bad_block_gc_index]
.LBB119_28:
	ldp	x20, x19, [sp, #96]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	mov	w0, wzr
	add	sp, sp, #112                    // =112
	hint	#29
	ret
.Lfunc_end119:
	.size	FtlGcFreeBadSuperBlk, .Lfunc_end119-FtlGcFreeBadSuperBlk
                                        // -- End function
	.globl	FtlGcBufFree                    // -- Begin function FtlGcBufFree
	.p2align	2
	.type	FtlGcBufFree,@function
FtlGcBufFree:                           // @FtlGcBufFree
// %bb.0:
	hint	#25
	cbz	w1, .LBB120_8
// %bb.1:
	mov	w8, wzr
	adrp	x9, c_gc_page_buf_num
	adrp	x10, gp_gc_page_buf_info
	mov	w11, #24
	b	.LBB120_4
.LBB120_2:                              //   in Loop: Header=BB120_4 Depth=1
                                        // kill: def $w15 killed $w15 killed $x15 def $x15
	and	x13, x15, #0xffff
	madd	x12, x13, x11, x12
	str	wzr, [x12, #16]
.LBB120_3:                              //   in Loop: Header=BB120_4 Depth=1
	add	w8, w8, #1                      // =1
	cmp	w1, w8, uxth
	b.ls	.LBB120_8
.LBB120_4:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB120_6 Depth 2
	ldr	w13, [x9, :lo12:c_gc_page_buf_num]
	cbz	w13, .LBB120_3
// %bb.5:                               //   in Loop: Header=BB120_4 Depth=1
	and	x14, x8, #0xffff
	add	x14, x0, x14, lsl #5
	ldr	x12, [x10, :lo12:gp_gc_page_buf_info]
	ldr	x14, [x14, #8]
	mov	w15, wzr
.LBB120_6:                              //   Parent Loop BB120_4 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	and	x16, x15, #0xffff
	mul	x16, x16, x11
	ldr	x16, [x12, x16]
	cmp	x16, x14
	b.eq	.LBB120_2
// %bb.7:                               //   in Loop: Header=BB120_6 Depth=2
	add	w15, w15, #1                    // =1
	cmp	w13, w15, uxth
	b.hi	.LBB120_6
	b	.LBB120_3
.LBB120_8:
	hint	#29
	ret
.Lfunc_end120:
	.size	FtlGcBufFree, .Lfunc_end120-FtlGcBufFree
                                        // -- End function
	.globl	FtlGcBufAlloc                   // -- Begin function FtlGcBufAlloc
	.p2align	2
	.type	FtlGcBufAlloc,@function
FtlGcBufAlloc:                          // @FtlGcBufAlloc
// %bb.0:
	hint	#25
	cbz	w1, .LBB121_8
// %bb.1:
	mov	w8, wzr
	adrp	x9, c_gc_page_buf_num
	adrp	x10, gp_gc_page_buf_info
	mov	w11, #24
	mov	w12, #1
	b	.LBB121_4
.LBB121_2:                              //   in Loop: Header=BB121_4 Depth=1
	str	w12, [x16]
	ldr	x13, [x10, :lo12:gp_gc_page_buf_info]
                                        // kill: def $w15 killed $w15 killed $x15 def $x15
	and	x14, x15, #0xffff
	add	x14, x14, w15, uxth #1
	lsl	x14, x14, #3
	ldr	x13, [x13, x14]
	and	x15, x8, #0xffff
	add	x15, x0, x15, lsl #5
	str	x13, [x15, #8]
	ldr	x13, [x10, :lo12:gp_gc_page_buf_info]
	add	x13, x13, x14
	ldr	x13, [x13, #8]
	str	x13, [x15, #16]
.LBB121_3:                              //   in Loop: Header=BB121_4 Depth=1
	add	w8, w8, #1                      // =1
	cmp	w1, w8, uxth
	b.ls	.LBB121_8
.LBB121_4:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB121_6 Depth 2
	ldr	w13, [x9, :lo12:c_gc_page_buf_num]
	cbz	w13, .LBB121_3
// %bb.5:                               //   in Loop: Header=BB121_4 Depth=1
	ldr	x14, [x10, :lo12:gp_gc_page_buf_info]
	mov	w15, wzr
.LBB121_6:                              //   Parent Loop BB121_4 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	and	x16, x15, #0xffff
	madd	x16, x16, x11, x14
	ldr	w17, [x16, #16]!
	cbz	w17, .LBB121_2
// %bb.7:                               //   in Loop: Header=BB121_6 Depth=2
	add	w15, w15, #1                    // =1
	cmp	w13, w15, uxth
	b.hi	.LBB121_6
	b	.LBB121_3
.LBB121_8:
	hint	#29
	ret
.Lfunc_end121:
	.size	FtlGcBufAlloc, .Lfunc_end121-FtlGcBufAlloc
                                        // -- End function
	.globl	IsBlkInGcList                   // -- Begin function IsBlkInGcList
	.p2align	2
	.type	IsBlkInGcList,@function
IsBlkInGcList:                          // @IsBlkInGcList
// %bb.0:
	hint	#25
	adrp	x8, g_gc_blk_num
	ldrh	w8, [x8, :lo12:g_gc_blk_num]
	cbz	x8, .LBB122_4
// %bb.1:
	adrp	x9, p_gc_blk_tbl
	ldr	x9, [x9, :lo12:p_gc_blk_tbl]
.LBB122_2:                              // =>This Inner Loop Header: Depth=1
	ldrh	w10, [x9]
	cmp	w10, w0, uxth
	b.eq	.LBB122_5
// %bb.3:                               //   in Loop: Header=BB122_2 Depth=1
	subs	x8, x8, #1                      // =1
	add	x9, x9, #2                      // =2
	b.ne	.LBB122_2
.LBB122_4:
	mov	w0, wzr
	hint	#29
	ret
.LBB122_5:
	mov	w0, #1
	hint	#29
	ret
.Lfunc_end122:
	.size	IsBlkInGcList, .Lfunc_end122-IsBlkInGcList
                                        // -- End function
	.globl	FtlGcUpdatePage                 // -- Begin function FtlGcUpdatePage
	.p2align	2
	.type	FtlGcUpdatePage,@function
FtlGcUpdatePage:                        // @FtlGcUpdatePage
// %bb.0:
	hint	#25
	adrp	x8, c_ftl_nand_blks_per_die
	ldrh	w12, [x8, :lo12:c_ftl_nand_blks_per_die]
	adrp	x10, c_ftl_nand_planes_per_die
	adrp	x8, g_gc_blk_num
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_per_die]
	ubfx	w9, w0, #10, #16
	ldrh	w11, [x8, :lo12:g_gc_blk_num]
	udiv	w13, w9, w12
	msub	w9, w13, w12, w9
	udiv	w9, w9, w10
	adrp	x10, p_gc_blk_tbl
	cbz	x11, .LBB123_5
// %bb.1:
	ldr	x12, [x10, :lo12:p_gc_blk_tbl]
	mov	x13, xzr
.LBB123_2:                              // =>This Inner Loop Header: Depth=1
	ldrh	w14, [x12, x13, lsl #1]
	cmp	w14, w9, uxth
	b.eq	.LBB123_4
// %bb.3:                               //   in Loop: Header=BB123_2 Depth=1
	add	x13, x13, #1                    // =1
	cmp	x11, x13
	b.ne	.LBB123_2
	b	.LBB123_5
.LBB123_4:
	cmp	w11, w13, uxth
	mov	w11, w13
	b.ne	.LBB123_6
.LBB123_5:
	ldr	x10, [x10, :lo12:p_gc_blk_tbl]
                                        // kill: def $w11 killed $w11 killed $x11 def $x11
	and	x11, x11, #0xffff
	strh	w9, [x10, x11, lsl #1]
	ldrh	w9, [x8, :lo12:g_gc_blk_num]
	add	w9, w9, #1                      // =1
	strh	w9, [x8, :lo12:g_gc_blk_num]
.LBB123_6:
	adrp	x8, p_gc_page_info
	adrp	x9, g_gc_page_offset
	ldr	x10, [x8, :lo12:p_gc_page_info]
	ldrh	w11, [x9, :lo12:g_gc_page_offset]
	mov	w12, #12
	madd	x10, x11, x12, x10
	str	w1, [x10, #4]
	ldr	x10, [x8, :lo12:p_gc_page_info]
	ldrh	w11, [x9, :lo12:g_gc_page_offset]
	madd	x10, x11, x12, x10
	str	w2, [x10, #8]
	ldrh	w10, [x9, :lo12:g_gc_page_offset]
	ldr	x8, [x8, :lo12:p_gc_page_info]
	mul	x10, x10, x12
	str	w0, [x8, x10]
	ldrh	w8, [x9, :lo12:g_gc_page_offset]
	add	w8, w8, #1                      // =1
	strh	w8, [x9, :lo12:g_gc_page_offset]
	hint	#29
	ret
.Lfunc_end123:
	.size	FtlGcUpdatePage, .Lfunc_end123-FtlGcUpdatePage
                                        // -- End function
	.globl	FtlGcFreeTempBlock              // -- Begin function FtlGcFreeTempBlock
	.p2align	2
	.type	FtlGcFreeTempBlock,@function
FtlGcFreeTempBlock:                     // @FtlGcFreeTempBlock
// %bb.0:
	hint	#25
	sub	sp, sp, #112                    // =112
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	stp	x28, x27, [sp, #32]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #48]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #64]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #80]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #96]             // 16-byte Folded Spill
	str	x8, [sp, #8]
	adrp	x20, g_gc_temp_superblock
	ldrsh	w8, [x20, :lo12:g_gc_temp_superblock]
	add	x29, sp, #16                    // =16
	cmn	w8, #1                          // =1
	b.eq	.LBB124_4
// %bb.1:
	adrp	x22, c_ftl_nand_page_pre_blk
	ldrh	w8, [x22, :lo12:c_ftl_nand_page_pre_blk]
	adrp	x21, ftl_gc_temp_block_bops_scan_page_addr
	cbz	w0, .LBB124_5
// %bb.2:
	ldrsh	w9, [x21, :lo12:ftl_gc_temp_block_bops_scan_page_addr]
	mov	w1, #2
	cmn	w9, #1                          // =1
	b.ne	.LBB124_6
// %bb.3:
	adrp	x9, g_num_free_superblocks
	ldrh	w9, [x9, :lo12:g_num_free_superblocks]
	strh	wzr, [x21, :lo12:ftl_gc_temp_block_bops_scan_page_addr]
	cmp	w9, #18                         // =18
	csel	w1, w8, w1, lo
	b	.LBB124_6
.LBB124_4:
	adrp	x8, ftl_gc_temp_power_lost_recovery_flag
	mov	w0, wzr
	str	wzr, [x8, :lo12:ftl_gc_temp_power_lost_recovery_flag]
	b	.LBB124_8
.LBB124_5:
	mov	w1, w8
.LBB124_6:
	adrp	x19, g_gc_temp_superblock
	add	x19, x19, :lo12:g_gc_temp_superblock
	mov	x0, x19
	bl	FtlGcScanTempBlk
	ldrsh	w8, [x21, :lo12:ftl_gc_temp_block_bops_scan_page_addr]
	mov	w9, #-1
	str	w9, [sp, #4]
	cmn	w8, #1                          // =1
	b.eq	.LBB124_10
// %bb.7:
	mov	w0, #1
.LBB124_8:
	adrp	x9, __stack_chk_guard
	ldr	x8, [sp, #8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB124_39
// %bb.9:
	ldp	x20, x19, [sp, #96]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	add	sp, sp, #112                    // =112
	hint	#29
	ret
.LBB124_10:
	ldrh	w8, [x20, :lo12:g_gc_temp_superblock]
	mov	w10, #65535
	adrp	x9, ftl_gc_temp_power_lost_recovery_flag
	str	wzr, [x9, :lo12:ftl_gc_temp_power_lost_recovery_flag]
	cmp	w8, w10
	b.eq	.LBB124_26
// %bb.11:
	adrp	x9, g_gc_temp_superblock+7
	adrp	x21, g_gc_page_offset
	ldrb	w9, [x9, :lo12:g_gc_temp_superblock+7]
	ldrh	w10, [x22, :lo12:c_ftl_nand_page_pre_blk]
	ldrh	w11, [x21, :lo12:g_gc_page_offset]
	mul	w12, w10, w9
	cmp	w12, w11
	b.eq	.LBB124_13
// %bb.12:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.FtlGcFreeTempBlock
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.FtlGcFreeTempBlock
	mov	w2, #164
	bl	sftl_printk
	ldrb	w9, [x19, #7]
	ldrh	w10, [x22, :lo12:c_ftl_nand_page_pre_blk]
	ldrh	w8, [x19]
.LBB124_13:
	adrp	x11, p_valid_page_count_table
	ldr	x11, [x11, :lo12:p_valid_page_count_table]
	mul	w9, w10, w9
	adrp	x10, g_totle_gc_page_count
	strh	w9, [x11, w8, uxtw #1]
	ldrh	w8, [x21, :lo12:g_gc_page_offset]
	ldr	w9, [x10, :lo12:g_totle_gc_page_count]
	add	w9, w9, w8
	str	w9, [x10, :lo12:g_totle_gc_page_count]
	cbz	w8, .LBB124_22
// %bb.14:
	mov	x23, xzr
	mov	x24, xzr
	adrp	x25, p_gc_page_info
	adrp	x26, g_MaxLpn
	adrp	x27, c_ftl_nand_blks_per_die
	adrp	x28, c_ftl_nand_planes_per_die
	b	.LBB124_18
.LBB124_15:                             //   in Loop: Header=BB124_18 Depth=1
	ldrh	w19, [x20, :lo12:g_gc_temp_superblock]
.LBB124_16:                             //   in Loop: Header=BB124_18 Depth=1
	mov	w0, w19
	bl	decrement_vpc_count
.LBB124_17:                             //   in Loop: Header=BB124_18 Depth=1
	ldrh	w8, [x21, :lo12:g_gc_page_offset]
	add	x24, x24, #1                    // =1
	add	x23, x23, #12                   // =12
	cmp	x24, x8
	b.hs	.LBB124_22
.LBB124_18:                             // =>This Inner Loop Header: Depth=1
	ldr	x19, [x25, :lo12:p_gc_page_info]
	ldr	w8, [x26, :lo12:g_MaxLpn]
	add	x22, x19, x23
	ldr	w0, [x22, #8]
	cmp	w0, w8
	b.hs	.LBB124_15
// %bb.19:                              //   in Loop: Header=BB124_18 Depth=1
	add	x1, sp, #4                      // =4
	mov	w2, wzr
	bl	log2phys
	ldr	w8, [sp, #4]
	ldr	w9, [x19, x23]
	cmp	w8, w9
	b.ne	.LBB124_21
// %bb.20:                              //   in Loop: Header=BB124_18 Depth=1
	ldrh	w9, [x27, :lo12:c_ftl_nand_blks_per_die]
	ldrh	w10, [x28, :lo12:c_ftl_nand_planes_per_die]
	ldr	w0, [x22, #8]
	ubfx	w8, w8, #10, #16
	add	x11, x19, x23
	udiv	w12, w8, w9
	msub	w8, w12, w9, w8
	add	x1, x11, #4                     // =4
	mov	w2, #1
	udiv	w19, w8, w10
	bl	log2phys
	b	.LBB124_16
.LBB124_21:                             //   in Loop: Header=BB124_18 Depth=1
	add	x9, x19, x23
	ldr	w9, [x9, #4]
	cmp	w8, w9
	b.ne	.LBB124_15
	b	.LBB124_17
.LBB124_22:
	adrp	x19, g_tmp_data_superblock_id
	ldrh	w0, [x19, :lo12:g_tmp_data_superblock_id]
	mov	w22, #65535
	cmp	w0, w22
	b.eq	.LBB124_27
// %bb.23:
	bl	update_vpc_list
	adrp	x8, p_data_block_list_head
	adrp	x9, p_data_block_list_table
	ldr	w8, [x8, :lo12:p_data_block_list_head]
	ldr	w9, [x9, :lo12:p_data_block_list_table]
	strh	w22, [x19, :lo12:g_tmp_data_superblock_id]
	adrp	x19, p_valid_page_count_table
	ldr	x10, [x19, :lo12:p_valid_page_count_table]
	sub	w8, w8, w9
	mov	w9, #43691
	lsr	w8, w8, #1
	movk	w9, #43690, lsl #16
	mul	w8, w8, w9
	and	x8, x8, #0xffff
	ldrh	w9, [x10, x8, lsl #1]
	cbnz	w9, .LBB124_28
// %bb.24:
	mov	w9, #65535
	cmp	x8, x9
	b.eq	.LBB124_28
// %bb.25:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.decrement_vpc_count
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.decrement_vpc_count
	mov	w2, #2869
	bl	sftl_printk
	b	.LBB124_28
.LBB124_26:
	mov	w0, wzr
	b	.LBB124_8
.LBB124_27:
	strh	w22, [x19, :lo12:g_tmp_data_superblock_id]
	adrp	x19, p_valid_page_count_table
.LBB124_28:
	ldr	x8, [x19, :lo12:p_valid_page_count_table]
	ldrh	w0, [x20, :lo12:g_gc_temp_superblock]
	ldrh	w8, [x8, x0, lsl #1]
	cbz	w8, .LBB124_31
// %bb.29:
                                        // kill: def $w0 killed $w0 killed $x0
	bl	insert_data_list
	adrp	x8, g_num_data_superblocks
	ldrh	w9, [x8, :lo12:g_num_data_superblocks]
	adrp	x10, c_ftl_nand_data_blks_per_plane
	ldrh	w10, [x10, :lo12:c_ftl_nand_data_blks_per_plane]
	add	w9, w9, #1                      // =1
	strh	w9, [x8, :lo12:g_num_data_superblocks]
	cmp	w10, w9, uxth
	b.hs	.LBB124_32
// %bb.30:
	adrp	x0, .L.str.78
	adrp	x1, .L__func__.INSERT_DATA_LIST
	add	x0, x0, :lo12:.L.str.78
	add	x1, x1, :lo12:.L__func__.INSERT_DATA_LIST
	mov	w2, #214
	bl	sftl_printk
	b	.LBB124_32
.LBB124_31:
                                        // kill: def $w0 killed $w0 killed $x0
	bl	INSERT_FREE_LIST
.LBB124_32:
	mov	w22, #65535
	adrp	x8, g_gc_blk_num
	strh	wzr, [x21, :lo12:g_gc_page_offset]
	strh	w22, [x20, :lo12:g_gc_temp_superblock]
	strh	wzr, [x8, :lo12:g_gc_blk_num]
	bl	FtlWriteDump_data
	adrp	x20, c_ftl_nand_l2pmap_ram_region_num
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	cbz	w8, .LBB124_37
// %bb.33:
	adrp	x19, gL2pMapInfo
	mov	x21, xzr
	mov	x23, xzr
	adrp	x24, p_l2p_ram_map
	add	x19, x19, :lo12:gL2pMapInfo
	b	.LBB124_35
.LBB124_34:                             //   in Loop: Header=BB124_35 Depth=1
	add	x23, x23, #1                    // =1
	cmp	x23, w8, uxth
	add	x21, x21, #16                   // =16
	b.hs	.LBB124_37
.LBB124_35:                             // =>This Inner Loop Header: Depth=1
	ldr	x9, [x24, :lo12:p_l2p_ram_map]
	add	x9, x9, x21
	ldr	w10, [x9, #4]
	tbz	w10, #31, .LBB124_34
// %bb.36:                              //   in Loop: Header=BB124_35 Depth=1
	ldrh	w1, [x9]
	ldr	x2, [x9, #8]
	mov	x0, x19
	bl	FtlMapWritePage
	ldr	x8, [x24, :lo12:p_l2p_ram_map]
	add	x8, x8, x21
	ldr	w9, [x8, #4]
	and	w9, w9, #0x7fffffff
	str	w9, [x8, #4]
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	b	.LBB124_34
.LBB124_37:
	bl	FtlVpcTblFlush
	adrp	x9, c_ftl_nand_data_op_blks_per_plane
	adrp	x8, g_num_free_superblocks
	ldrh	w9, [x9, :lo12:c_ftl_nand_data_op_blks_per_plane]
	ldrh	w8, [x8, :lo12:g_num_free_superblocks]
	adrp	x10, g_gc_superblock
	mov	w0, wzr
	add	w9, w9, w9, lsl #1
	cmp	w8, w9, lsr #2
	strh	w22, [x10, :lo12:g_gc_superblock]
	b.ls	.LBB124_8
// %bb.38:
	adrp	x8, g_gc_free_blk_threshold
	mov	w9, #20
	strh	w9, [x8, :lo12:g_gc_free_blk_threshold]
	b	.LBB124_8
.LBB124_39:
	bl	__stack_chk_fail
.Lfunc_end124:
	.size	FtlGcFreeTempBlock, .Lfunc_end124-FtlGcFreeTempBlock
                                        // -- End function
	.globl	FtlGcScanTempBlk                // -- Begin function FtlGcScanTempBlk
	.p2align	2
	.type	FtlGcScanTempBlk,@function
FtlGcScanTempBlk:                       // @FtlGcScanTempBlk
// %bb.0:
	hint	#25
	sub	sp, sp, #176                    // =176
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	stp	x29, x30, [sp, #80]             // 16-byte Folded Spill
	add	x29, sp, #80                    // =80
	stp	x28, x27, [sp, #96]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #112]            // 16-byte Folded Spill
	stp	x24, x23, [sp, #128]            // 16-byte Folded Spill
	stp	x22, x21, [sp, #144]            // 16-byte Folded Spill
	stp	x20, x19, [sp, #160]            // 16-byte Folded Spill
	str	w1, [sp, #12]                   // 4-byte Folded Spill
	adrp	x10, ftl_gc_temp_block_bops_scan_page_addr
	stur	x8, [x29, #-8]
	ldrh	w8, [x10, :lo12:ftl_gc_temp_block_bops_scan_page_addr]
	mov	w9, #65535
	mov	x22, x0
	adrp	x11, g_gc_blk_num
	cmp	w8, w9
	adrp	x26, g_gc_page_offset
	csel	w19, wzr, w8, eq
	adrp	x24, p_gc_page_info
	cbz	w8, .LBB125_2
// %bb.1:
	adrp	x8, c_ftl_nand_page_pre_blk
	ldrh	w8, [x8, :lo12:c_ftl_nand_page_pre_blk]
	ldr	w9, [sp, #12]                   // 4-byte Folded Reload
	cmp	w8, w9
	b.ne	.LBB125_3
.LBB125_2:
	adrp	x20, c_ftl_nand_page_pre_super_blk
	ldrh	w8, [x20, :lo12:c_ftl_nand_page_pre_super_blk]
	adrp	x9, p_gc_blk_tbl
	ldr	x0, [x9, :lo12:p_gc_blk_tbl]
	mov	w1, #255
	lsl	x2, x8, #1
	strh	wzr, [x11, :lo12:g_gc_blk_num]
	strh	wzr, [x26, :lo12:g_gc_page_offset]
	bl	memset
	ldrh	w8, [x20, :lo12:c_ftl_nand_page_pre_super_blk]
	ldr	x0, [x24, :lo12:p_gc_page_info]
	mov	w1, #255
	add	x8, x8, x8, lsl #1
	lsl	x2, x8, #2
	bl	memset
	bl	FtlGcBufInit
.LBB125_3:
	ldrsh	w8, [x22]
	adrp	x16, c_ftl_nand_planes_num
	strb	wzr, [x22, #8]
	cmn	w8, #1                          // =1
	b.eq	.LBB125_44
// %bb.4:
	add	x20, x22, #16                   // =16
	adrp	x28, req_read
	mov	w21, #65535
	mov	w27, #12
	adrp	x17, p_gc_data_buf
	adrp	x18, c_ftl_nand_byte_pre_page
	adrp	x0, p_gc_spare_buf
	adrp	x1, c_ftl_nand_byte_pre_oob
	str	wzr, [sp, #16]                  // 4-byte Folded Spill
	str	x22, [sp, #24]                  // 8-byte Folded Spill
	b	.LBB125_6
.LBB125_5:                              //   in Loop: Header=BB125_6 Depth=1
	adrp	x8, c_ftl_nand_page_pre_blk
	ldrh	w8, [x8, :lo12:c_ftl_nand_page_pre_blk]
	adrp	x16, c_ftl_nand_planes_num
	adrp	x17, p_gc_data_buf
	adrp	x18, c_ftl_nand_byte_pre_page
	cmp	w8, w19, uxth
	adrp	x0, p_gc_spare_buf
	adrp	x1, c_ftl_nand_byte_pre_oob
	str	w10, [sp, #16]                  // 4-byte Folded Spill
	b.ls	.LBB125_44
.LBB125_6:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB125_7 Depth 2
                                        //       Child Loop BB125_10 Depth 3
                                        //       Child Loop BB125_18 Depth 3
                                        //         Child Loop BB125_21 Depth 4
                                        //         Child Loop BB125_29 Depth 4
                                        //         Child Loop BB125_33 Depth 4
	mov	w9, w19
.LBB125_7:                              //   Parent Loop BB125_6 Depth=1
                                        // =>  This Loop Header: Depth=2
                                        //       Child Loop BB125_10 Depth 3
                                        //       Child Loop BB125_18 Depth 3
                                        //         Child Loop BB125_21 Depth 4
                                        //         Child Loop BB125_29 Depth 4
                                        //         Child Loop BB125_33 Depth 4
	ldrh	w10, [x16, :lo12:c_ftl_nand_planes_num]
	str	w9, [sp, #20]                   // 4-byte Folded Spill
	cbz	w10, .LBB125_12
// %bb.8:                               //   in Loop: Header=BB125_7 Depth=2
	mov	x8, xzr
	mov	w19, wzr
	and	w9, w9, #0xffff
	b	.LBB125_10
.LBB125_9:                              //   in Loop: Header=BB125_10 Depth=3
	add	x8, x8, #1                      // =1
	cmp	x8, w10, uxth
	b.hs	.LBB125_13
.LBB125_10:                             //   Parent Loop BB125_6 Depth=1
                                        //     Parent Loop BB125_7 Depth=2
                                        // =>    This Inner Loop Header: Depth=3
	ldrh	w11, [x20, x8, lsl #1]
	cmp	w11, w21
	b.eq	.LBB125_9
// %bb.11:                              //   in Loop: Header=BB125_10 Depth=3
	ldr	x10, [x28, :lo12:req_read]
	and	x12, x19, #0xffff
	lsl	x12, x12, #5
	orr	w11, w9, w11, lsl #10
	add	x10, x10, x12
	str	w11, [x10, #4]
	ldrh	w10, [x18, :lo12:c_ftl_nand_byte_pre_page]
	and	w11, w19, #0xffff
	ldr	x13, [x17, :lo12:p_gc_data_buf]
	ldr	x14, [x28, :lo12:req_read]
	mul	w10, w10, w11
	add	w15, w10, #3                    // =3
	cmp	w10, #0                         // =0
	csel	w10, w15, w10, lt
	asr	w10, w10, #2
	add	x14, x14, x12
	add	x10, x13, w10, sxtw #2
	str	x10, [x14, #8]
	ldrh	w10, [x1, :lo12:c_ftl_nand_byte_pre_oob]
	ldr	x13, [x0, :lo12:p_gc_spare_buf]
	ldr	x14, [x28, :lo12:req_read]
	add	w19, w19, #1                    // =1
	mul	w10, w10, w11
	add	w11, w10, #3                    // =3
	cmp	w10, #0                         // =0
	csel	w10, w11, w10, lt
	asr	w10, w10, #2
	add	x10, x13, w10, sxtw #2
	add	x11, x14, x12
	str	x10, [x11, #16]
	ldrh	w10, [x16, :lo12:c_ftl_nand_planes_num]
	b	.LBB125_9
.LBB125_12:                             //   in Loop: Header=BB125_7 Depth=2
	mov	w19, wzr
.LBB125_13:                             //   in Loop: Header=BB125_7 Depth=2
	ldr	x0, [x28, :lo12:req_read]
	and	w22, w19, #0xffff
	mov	w1, w22
	bl	FlashReadPages
	adrp	x16, g_gc_blk_num
	cbz	w22, .LBB125_41
// %bb.14:                              //   in Loop: Header=BB125_7 Depth=2
                                        // kill: def $w19 killed $w19 killed $x19 def $x19
	mov	x22, xzr
	and	x19, x19, #0xffff
	b	.LBB125_18
.LBB125_15:                             //   in Loop: Header=BB125_18 Depth=3
	strh	w11, [x10, x9, lsl #1]
	ldrh	w9, [x16, :lo12:g_gc_blk_num]
	add	w9, w9, #1                      // =1
	strh	w9, [x16, :lo12:g_gc_blk_num]
.LBB125_16:                             //   in Loop: Header=BB125_18 Depth=3
	ldr	x9, [x24, :lo12:p_gc_page_info]
	ldrh	w10, [x26, :lo12:g_gc_page_offset]
	madd	x9, x10, x27, x9
	str	w23, [x9, #4]
	ldr	x9, [x24, :lo12:p_gc_page_info]
	ldrh	w10, [x26, :lo12:g_gc_page_offset]
	madd	x9, x10, x27, x9
	mov	w10, #-1
	str	w10, [x9, #8]
.LBB125_17:                             //   in Loop: Header=BB125_18 Depth=3
	ldrh	w9, [x26, :lo12:g_gc_page_offset]
	ldr	x10, [x24, :lo12:p_gc_page_info]
	add	x22, x22, #1                    // =1
	cmp	x22, x19
	mul	x9, x9, x27
	str	w8, [x10, x9]
	ldrh	w8, [x26, :lo12:g_gc_page_offset]
	add	w8, w8, #1                      // =1
	strh	w8, [x26, :lo12:g_gc_page_offset]
	b.eq	.LBB125_41
.LBB125_18:                             //   Parent Loop BB125_6 Depth=1
                                        //     Parent Loop BB125_7 Depth=2
                                        // =>    This Loop Header: Depth=3
                                        //         Child Loop BB125_21 Depth 4
                                        //         Child Loop BB125_29 Depth 4
                                        //         Child Loop BB125_33 Depth 4
	ldr	x8, [x28, :lo12:req_read]
	add	x8, x8, x22, lsl #5
	ldp	w9, w23, [x8]
	ldr	x25, [x8, #16]
	cbz	w9, .LBB125_23
// %bb.19:                              //   in Loop: Header=BB125_18 Depth=3
	ldr	w8, [x25, #12]
	adrp	x9, c_ftl_nand_blks_per_die
	ldrh	w11, [x9, :lo12:c_ftl_nand_blks_per_die]
	adrp	x9, c_ftl_nand_planes_per_die
	ldrh	w12, [x9, :lo12:c_ftl_nand_planes_per_die]
	adrp	x10, p_gc_blk_tbl
	ldrh	w9, [x16, :lo12:g_gc_blk_num]
	ubfx	w13, w8, #10, #16
	ldr	x10, [x10, :lo12:p_gc_blk_tbl]
	udiv	w14, w13, w11
	msub	w11, w14, w11, w13
	udiv	w11, w11, w12
	cbz	x9, .LBB125_15
// %bb.20:                              //   in Loop: Header=BB125_18 Depth=3
	mov	x12, xzr
.LBB125_21:                             //   Parent Loop BB125_6 Depth=1
                                        //     Parent Loop BB125_7 Depth=2
                                        //       Parent Loop BB125_18 Depth=3
                                        // =>      This Inner Loop Header: Depth=4
	ldrh	w13, [x10, x12, lsl #1]
	cmp	w13, w11, uxth
	b.eq	.LBB125_35
// %bb.22:                              //   in Loop: Header=BB125_21 Depth=4
	add	x12, x12, #1                    // =1
	cmp	x9, x12
	b.ne	.LBB125_21
	b	.LBB125_15
.LBB125_23:                             //   in Loop: Header=BB125_18 Depth=3
	ldrsh	w8, [x25]
	cmn	w8, #1                          // =1
	b.eq	.LBB125_40
// %bb.24:                              //   in Loop: Header=BB125_18 Depth=3
	adrp	x8, g_MaxLpn
	ldr	w0, [x25, #8]
	ldr	w8, [x8, :lo12:g_MaxLpn]
	cmp	w0, w8
	b.hi	.LBB125_40
// %bb.25:                              //   in Loop: Header=BB125_18 Depth=3
	add	x1, sp, #36                     // =36
	mov	w2, wzr
	bl	log2phys
	ldr	w8, [sp, #36]
	adrp	x16, g_gc_blk_num
	cmn	w8, #1                          // =1
	b.eq	.LBB125_31
// %bb.26:                              //   in Loop: Header=BB125_18 Depth=3
	ldr	w9, [x25, #12]
	cmp	w8, w9
	b.ne	.LBB125_31
// %bb.27:                              //   in Loop: Header=BB125_18 Depth=3
	adrp	x9, p_io_data_buf_1
	adrp	x10, p_io_spare_buf
	ldr	x9, [x9, :lo12:p_io_data_buf_1]
	ldr	x10, [x10, :lo12:p_io_spare_buf]
	add	x0, sp, #40                     // =40
	mov	w1, #1
	str	w8, [sp, #44]
	stp	x9, x10, [sp, #48]
	bl	FlashReadPages
	adrp	x8, c_ftl_nand_sec_pre_page
	ldrh	w10, [x8, :lo12:c_ftl_nand_sec_pre_page]
	adrp	x16, g_gc_blk_num
	cbz	x10, .LBB125_31
// %bb.28:                              //   in Loop: Header=BB125_18 Depth=3
	ldr	x8, [x28, :lo12:req_read]
	ldr	x9, [sp, #48]
	lsl	x10, x10, #7
	add	x8, x8, x22, lsl #5
	ldr	x8, [x8, #8]
.LBB125_29:                             //   Parent Loop BB125_6 Depth=1
                                        //     Parent Loop BB125_7 Depth=2
                                        //       Parent Loop BB125_18 Depth=3
                                        // =>      This Inner Loop Header: Depth=4
	ldr	w11, [x8]
	ldr	w12, [x9]
	cmp	w11, w12
	b.ne	.LBB125_39
// %bb.30:                              //   in Loop: Header=BB125_29 Depth=4
	add	x8, x8, #4                      // =4
	subs	x10, x10, #1                    // =1
	add	x9, x9, #4                      // =4
	b.ne	.LBB125_29
.LBB125_31:                             //   in Loop: Header=BB125_18 Depth=3
	ldp	w9, w8, [x25, #8]
	adrp	x10, c_ftl_nand_blks_per_die
	ldrh	w12, [x10, :lo12:c_ftl_nand_blks_per_die]
	adrp	x10, c_ftl_nand_planes_per_die
	ldrh	w13, [x10, :lo12:c_ftl_nand_planes_per_die]
	adrp	x11, p_gc_blk_tbl
	ldrh	w10, [x16, :lo12:g_gc_blk_num]
	ubfx	w14, w8, #10, #16
	ldr	x11, [x11, :lo12:p_gc_blk_tbl]
	udiv	w15, w14, w12
	msub	w12, w15, w12, w14
	udiv	w12, w12, w13
	cbz	x10, .LBB125_37
// %bb.32:                              //   in Loop: Header=BB125_18 Depth=3
	mov	x13, xzr
.LBB125_33:                             //   Parent Loop BB125_6 Depth=1
                                        //     Parent Loop BB125_7 Depth=2
                                        //       Parent Loop BB125_18 Depth=3
                                        // =>      This Inner Loop Header: Depth=4
	ldrh	w14, [x11, x13, lsl #1]
	cmp	w14, w12, uxth
	b.eq	.LBB125_36
// %bb.34:                              //   in Loop: Header=BB125_33 Depth=4
	add	x13, x13, #1                    // =1
	cmp	x10, x13
	b.ne	.LBB125_33
	b	.LBB125_37
.LBB125_35:                             //   in Loop: Header=BB125_18 Depth=3
	cmp	w9, w12, uxth
	b.eq	.LBB125_15
	b	.LBB125_16
.LBB125_36:                             //   in Loop: Header=BB125_18 Depth=3
	cmp	w10, w13, uxth
	b.ne	.LBB125_38
.LBB125_37:                             //   in Loop: Header=BB125_18 Depth=3
	strh	w12, [x11, x10, lsl #1]
	ldrh	w10, [x16, :lo12:g_gc_blk_num]
	add	w10, w10, #1                    // =1
	strh	w10, [x16, :lo12:g_gc_blk_num]
.LBB125_38:                             //   in Loop: Header=BB125_18 Depth=3
	ldr	x10, [x24, :lo12:p_gc_page_info]
	ldrh	w11, [x26, :lo12:g_gc_page_offset]
	madd	x10, x11, x27, x10
	str	w23, [x10, #4]
	ldr	x10, [x24, :lo12:p_gc_page_info]
	ldrh	w11, [x26, :lo12:g_gc_page_offset]
	madd	x10, x11, x27, x10
	str	w9, [x10, #8]
	b	.LBB125_17
.LBB125_39:                             //   in Loop: Header=BB125_7 Depth=2
	ldr	x8, [sp, #24]                   // 8-byte Folded Reload
	ldr	w2, [sp, #44]
	adrp	x0, .L.str.111
	add	x0, x0, :lo12:.L.str.111
	ldrh	w1, [x8]
	bl	sftl_printk
.LBB125_40:                             //   in Loop: Header=BB125_7 Depth=2
	ldr	x22, [sp, #24]                  // 8-byte Folded Reload
	adrp	x8, p_valid_page_count_table
	ldr	x8, [x8, :lo12:p_valid_page_count_table]
	ldrh	w9, [x22]
	strh	wzr, [x8, x9, lsl #1]
	ldrh	w0, [x22]
	bl	INSERT_FREE_LIST
	strh	w21, [x22]
	adrp	x8, g_gc_superblock
	adrp	x19, c_ftl_nand_page_pre_super_blk
	strh	w21, [x8, :lo12:g_gc_superblock]
	ldrh	w8, [x19, :lo12:c_ftl_nand_page_pre_super_blk]
	adrp	x9, p_gc_blk_tbl
	ldr	x0, [x9, :lo12:p_gc_blk_tbl]
	adrp	x9, g_gc_blk_num
	lsl	x2, x8, #1
	mov	w1, #255
	strh	wzr, [x9, :lo12:g_gc_blk_num]
	strh	wzr, [x26, :lo12:g_gc_page_offset]
	bl	memset
	ldrh	w8, [x19, :lo12:c_ftl_nand_page_pre_super_blk]
	ldr	x0, [x24, :lo12:p_gc_page_info]
	mov	w1, #255
	add	x8, x8, x8, lsl #1
	lsl	x2, x8, #2
	bl	memset
	bl	FtlGcBufInit
	ldrsh	w8, [x22]
	mov	w9, wzr
	mov	w19, wzr
	adrp	x16, c_ftl_nand_planes_num
	cmn	w8, #1                          // =1
	adrp	x17, p_gc_data_buf
	adrp	x18, c_ftl_nand_byte_pre_page
	adrp	x0, p_gc_spare_buf
	adrp	x1, c_ftl_nand_byte_pre_oob
	strb	wzr, [x22, #8]
	b.ne	.LBB125_7
	b	.LBB125_44
.LBB125_41:                             //   in Loop: Header=BB125_6 Depth=1
	ldp	w8, w10, [sp, #12]              // 8-byte Folded Reload
	ldr	x22, [sp, #24]                  // 8-byte Folded Reload
	add	w10, w10, #1                    // =1
	cmp	w10, w8
	ldr	w8, [sp, #20]                   // 4-byte Folded Reload
	add	w19, w8, #1                     // =1
	b.lo	.LBB125_5
// %bb.42:                              //   in Loop: Header=BB125_6 Depth=1
	adrp	x8, ftl_gc_temp_block_bops_scan_page_addr
	ldrh	w8, [x8, :lo12:ftl_gc_temp_block_bops_scan_page_addr]
	cmp	w8, w21
	b.eq	.LBB125_5
// %bb.43:                              //   in Loop: Header=BB125_6 Depth=1
	adrp	x9, c_ftl_nand_page_pre_blk
	ldrh	w9, [x9, :lo12:c_ftl_nand_page_pre_blk]
	add	w8, w8, w10
	cmp	w9, w19, uxth
	adrp	x9, ftl_gc_temp_block_bops_scan_page_addr
	strh	w8, [x9, :lo12:ftl_gc_temp_block_bops_scan_page_addr]
	b.ls	.LBB125_5
	b	.LBB125_53
.LBB125_44:
	mov	w8, #65535
	adrp	x9, ftl_gc_temp_block_bops_scan_page_addr
	strh	w8, [x9, :lo12:ftl_gc_temp_block_bops_scan_page_addr]
	strh	w19, [x22, #2]
	strb	wzr, [x22, #6]
	strh	wzr, [x22, #4]
	ldrh	w8, [x16, :lo12:c_ftl_nand_planes_num]
	cbz	x8, .LBB125_53
// %bb.45:
	mov	w9, wzr
	add	x10, x22, #16                   // =16
	mov	x11, x8
	b	.LBB125_47
.LBB125_46:                             //   in Loop: Header=BB125_47 Depth=1
	subs	x11, x11, #1                    // =1
	add	x10, x10, #2                    // =2
	b.eq	.LBB125_49
.LBB125_47:                             // =>This Inner Loop Header: Depth=1
	ldrsh	w12, [x10]
	cmn	w12, #1                         // =1
	b.eq	.LBB125_46
// %bb.48:                              //   in Loop: Header=BB125_47 Depth=1
	add	w9, w9, #1                      // =1
	strh	w9, [x22, #4]
	b	.LBB125_46
.LBB125_49:
	adrp	x10, c_ftl_nand_page_pre_blk
	ldrh	w10, [x10, :lo12:c_ftl_nand_page_pre_blk]
	mvn	w11, w19
	add	w10, w10, w11
	add	x11, x22, #16                   // =16
	b	.LBB125_51
.LBB125_50:                             //   in Loop: Header=BB125_51 Depth=1
	subs	x8, x8, #1                      // =1
	add	x11, x11, #2                    // =2
	b.eq	.LBB125_53
.LBB125_51:                             // =>This Inner Loop Header: Depth=1
	ldrsh	w12, [x11]
	cmn	w12, #1                         // =1
	b.eq	.LBB125_50
// %bb.52:                              //   in Loop: Header=BB125_51 Depth=1
	add	w9, w10, w9
	strh	w9, [x22, #4]
	b	.LBB125_50
.LBB125_53:
	adrp	x9, __stack_chk_guard
	ldur	x8, [x29, #-8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB125_55
// %bb.54:
	ldp	x20, x19, [sp, #160]            // 16-byte Folded Reload
	ldp	x22, x21, [sp, #144]            // 16-byte Folded Reload
	ldp	x24, x23, [sp, #128]            // 16-byte Folded Reload
	ldp	x26, x25, [sp, #112]            // 16-byte Folded Reload
	ldp	x28, x27, [sp, #96]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #80]             // 16-byte Folded Reload
	mov	w0, #-1
	add	sp, sp, #176                    // =176
	hint	#29
	ret
.LBB125_55:
	bl	__stack_chk_fail
.Lfunc_end125:
	.size	FtlGcScanTempBlk, .Lfunc_end125-FtlGcScanTempBlk
                                        // -- End function
	.globl	FtlGcPageVarInit                // -- Begin function FtlGcPageVarInit
	.p2align	2
	.type	FtlGcPageVarInit,@function
FtlGcPageVarInit:                       // @FtlGcPageVarInit
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	str	x19, [sp, #16]                  // 8-byte Folded Spill
	adrp	x8, g_gc_blk_num
	adrp	x19, c_ftl_nand_page_pre_super_blk
	adrp	x9, p_gc_blk_tbl
	strh	wzr, [x8, :lo12:g_gc_blk_num]
	ldrh	w8, [x19, :lo12:c_ftl_nand_page_pre_super_blk]
	ldr	x0, [x9, :lo12:p_gc_blk_tbl]
	adrp	x9, g_gc_page_offset
	mov	w1, #255
	lsl	x2, x8, #1
	mov	x29, sp
	strh	wzr, [x9, :lo12:g_gc_page_offset]
	bl	memset
	ldrh	w8, [x19, :lo12:c_ftl_nand_page_pre_super_blk]
	adrp	x9, p_gc_page_info
	ldr	x0, [x9, :lo12:p_gc_page_info]
	mov	w1, #255
	add	x8, x8, x8, lsl #1
	lsl	x2, x8, #2
	bl	memset
	bl	FtlGcBufInit
	ldr	x19, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end126:
	.size	FtlGcPageVarInit, .Lfunc_end126-FtlGcPageVarInit
                                        // -- End function
	.globl	Ftl_get_new_temp_ppa            // -- Begin function Ftl_get_new_temp_ppa
	.p2align	2
	.type	Ftl_get_new_temp_ppa,@function
Ftl_get_new_temp_ppa:                   // @Ftl_get_new_temp_ppa
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-64]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #48]             // 16-byte Folded Spill
	adrp	x19, g_gc_temp_superblock
	add	x19, x19, :lo12:g_gc_temp_superblock
	ldrsh	w8, [x19]
	str	x23, [sp, #16]                  // 8-byte Folded Spill
	stp	x22, x21, [sp, #32]             // 16-byte Folded Spill
	mov	x29, sp
	cmn	w8, #1                          // =1
	b.eq	.LBB127_2
// %bb.1:
	ldrh	w8, [x19, #4]
	cbnz	w8, .LBB127_8
.LBB127_2:
	mov	w0, wzr
	bl	FtlGcFreeTempBlock
	mov	x0, x19
	strb	wzr, [x19, #8]
	bl	allocate_data_superblock
	adrp	x8, g_gc_blk_num
	adrp	x9, g_gc_page_offset
	strh	wzr, [x8, :lo12:g_gc_blk_num]
	strh	wzr, [x9, :lo12:g_gc_page_offset]
	bl	FtlWriteDump_data
	adrp	x20, c_ftl_nand_l2pmap_ram_region_num
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	cbz	w8, .LBB127_7
// %bb.3:
	adrp	x19, gL2pMapInfo
	mov	x21, xzr
	mov	x22, xzr
	adrp	x23, p_l2p_ram_map
	add	x19, x19, :lo12:gL2pMapInfo
	b	.LBB127_5
.LBB127_4:                              //   in Loop: Header=BB127_5 Depth=1
	add	x22, x22, #1                    // =1
	cmp	x22, w8, uxth
	add	x21, x21, #16                   // =16
	b.hs	.LBB127_7
.LBB127_5:                              // =>This Inner Loop Header: Depth=1
	ldr	x9, [x23, :lo12:p_l2p_ram_map]
	add	x9, x9, x21
	ldr	w10, [x9, #4]
	tbz	w10, #31, .LBB127_4
// %bb.6:                               //   in Loop: Header=BB127_5 Depth=1
	ldrh	w1, [x9]
	ldr	x2, [x9, #8]
	mov	x0, x19
	bl	FtlMapWritePage
	ldr	x8, [x23, :lo12:p_l2p_ram_map]
	add	x8, x8, x21
	ldr	w9, [x8, #4]
	and	w9, w9, #0x7fffffff
	str	w9, [x8, #4]
	ldrh	w8, [x20, :lo12:c_ftl_nand_l2pmap_ram_region_num]
	b	.LBB127_4
.LBB127_7:
	mov	w0, wzr
	bl	FtlEctTblFlush
	bl	FtlVpcTblFlush
.LBB127_8:
	adrp	x0, g_gc_temp_superblock
	add	x0, x0, :lo12:g_gc_temp_superblock
	bl	get_new_active_ppa
	ldp	x20, x19, [sp, #48]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #32]             // 16-byte Folded Reload
	ldr	x23, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #64             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end127:
	.size	Ftl_get_new_temp_ppa, .Lfunc_end127-Ftl_get_new_temp_ppa
                                        // -- End function
	.globl	Ftl_gc_temp_data_write_back     // -- Begin function Ftl_gc_temp_data_write_back
	.p2align	2
	.type	Ftl_gc_temp_data_write_back,@function
Ftl_gc_temp_data_write_back:            // @Ftl_gc_temp_data_write_back
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	stp	x20, x19, [sp, #16]             // 16-byte Folded Spill
	adrp	x19, req_gc_dst
	adrp	x20, g_gc_num_req
	ldr	x0, [x19, :lo12:req_gc_dst]
	ldr	w1, [x20, :lo12:g_gc_num_req]
	mov	w2, wzr
	mov	x29, sp
	bl	FlashProgPages
	ldr	w8, [x20, :lo12:g_gc_num_req]
	cbz	w8, .LBB128_25
// %bb.1:
	mov	w8, wzr
	adrp	x9, c_ftl_nand_blks_per_die
	adrp	x10, c_ftl_nand_planes_per_die
	adrp	x11, g_gc_blk_num
	adrp	x12, p_gc_blk_tbl
	adrp	x13, p_gc_page_info
	adrp	x14, g_gc_page_offset
	mov	w15, #12
	b	.LBB128_4
.LBB128_2:                              //   in Loop: Header=BB128_4 Depth=1
	strh	w2, [x1, x0, lsl #1]
	ldrh	w0, [x11, :lo12:g_gc_blk_num]
	add	w0, w0, #1                      // =1
	strh	w0, [x11, :lo12:g_gc_blk_num]
.LBB128_3:                              //   in Loop: Header=BB128_4 Depth=1
	ldr	x0, [x13, :lo12:p_gc_page_info]
	ldrh	w1, [x14, :lo12:g_gc_page_offset]
	add	w8, w8, #1                      // =1
	madd	x0, x1, x15, x0
	str	w17, [x0, #4]
	ldr	x17, [x13, :lo12:p_gc_page_info]
	ldrh	w0, [x14, :lo12:g_gc_page_offset]
	madd	x17, x0, x15, x17
	str	w18, [x17, #8]
	ldrh	w17, [x14, :lo12:g_gc_page_offset]
	ldr	x18, [x13, :lo12:p_gc_page_info]
	mul	x17, x17, x15
	str	w16, [x18, x17]
	ldrh	w17, [x14, :lo12:g_gc_page_offset]
	ldr	w16, [x20, :lo12:g_gc_num_req]
	add	w17, w17, #1                    // =1
	cmp	w16, w8, uxth
	strh	w17, [x14, :lo12:g_gc_page_offset]
	b.ls	.LBB128_17
.LBB128_4:                              // =>This Loop Header: Depth=1
                                        //     Child Loop BB128_7 Depth 2
                                        //     Child Loop BB128_11 Depth 2
	ldr	x16, [x19, :lo12:req_gc_dst]
	and	x17, x8, #0xffff
	add	x17, x16, x17, lsl #5
	ldr	x18, [x17, #16]
	ldp	w0, w17, [x17]
	ldr	w16, [x18, #12]
	cmn	w0, #1                          // =1
	b.eq	.LBB128_9
// %bb.5:                               //   in Loop: Header=BB128_4 Depth=1
	ldrh	w3, [x9, :lo12:c_ftl_nand_blks_per_die]
	ldrh	w4, [x10, :lo12:c_ftl_nand_planes_per_die]
	ldr	w18, [x18, #8]
	ubfx	w2, w16, #10, #16
	ldrh	w0, [x11, :lo12:g_gc_blk_num]
	ldr	x1, [x12, :lo12:p_gc_blk_tbl]
	udiv	w5, w2, w3
	msub	w2, w5, w3, w2
	udiv	w2, w2, w4
	cbz	x0, .LBB128_2
// %bb.6:                               //   in Loop: Header=BB128_4 Depth=1
	mov	x3, xzr
.LBB128_7:                              //   Parent Loop BB128_4 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldrh	w4, [x1, x3, lsl #1]
	cmp	w4, w2, uxth
	b.eq	.LBB128_13
// %bb.8:                               //   in Loop: Header=BB128_7 Depth=2
	add	x3, x3, #1                      // =1
	cmp	x0, x3
	b.ne	.LBB128_7
	b	.LBB128_2
.LBB128_9:                              //   in Loop: Header=BB128_4 Depth=1
	ldrh	w2, [x9, :lo12:c_ftl_nand_blks_per_die]
	ldrh	w3, [x10, :lo12:c_ftl_nand_planes_per_die]
	ubfx	w1, w16, #10, #16
	ldrh	w18, [x11, :lo12:g_gc_blk_num]
	ldr	x0, [x12, :lo12:p_gc_blk_tbl]
	udiv	w4, w1, w2
	msub	w1, w4, w2, w1
	udiv	w1, w1, w3
	cbz	x18, .LBB128_15
// %bb.10:                              //   in Loop: Header=BB128_4 Depth=1
	mov	x2, xzr
.LBB128_11:                             //   Parent Loop BB128_4 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	ldrh	w3, [x0, x2, lsl #1]
	cmp	w3, w1, uxth
	b.eq	.LBB128_14
// %bb.12:                              //   in Loop: Header=BB128_11 Depth=2
	add	x2, x2, #1                      // =1
	cmp	x18, x2
	b.ne	.LBB128_11
	b	.LBB128_15
.LBB128_13:                             //   in Loop: Header=BB128_4 Depth=1
	cmp	w0, w3, uxth
	b.ne	.LBB128_3
	b	.LBB128_2
.LBB128_14:                             //   in Loop: Header=BB128_4 Depth=1
	cmp	w18, w2, uxth
	b.ne	.LBB128_16
.LBB128_15:                             //   in Loop: Header=BB128_4 Depth=1
	strh	w1, [x0, x18, lsl #1]
	ldrh	w18, [x11, :lo12:g_gc_blk_num]
	add	w18, w18, #1                    // =1
	strh	w18, [x11, :lo12:g_gc_blk_num]
.LBB128_16:                             //   in Loop: Header=BB128_4 Depth=1
	mov	w18, #-1
	b	.LBB128_3
.LBB128_17:
	cbz	w16, .LBB128_25
// %bb.18:
	ldr	x9, [x19, :lo12:req_gc_dst]
	mov	w8, wzr
	adrp	x10, c_gc_page_buf_num
	adrp	x11, gp_gc_page_buf_info
	mov	w12, #24
	b	.LBB128_21
.LBB128_19:                             //   in Loop: Header=BB128_21 Depth=1
                                        // kill: def $w17 killed $w17 killed $x17 def $x17
	and	x14, x17, #0xffff
	madd	x13, x14, x12, x13
	str	wzr, [x13, #16]
.LBB128_20:                             //   in Loop: Header=BB128_21 Depth=1
	add	w8, w8, #1                      // =1
	cmp	w16, w8, uxth
	b.ls	.LBB128_25
.LBB128_21:                             // =>This Loop Header: Depth=1
                                        //     Child Loop BB128_23 Depth 2
	ldr	w14, [x10, :lo12:c_gc_page_buf_num]
	cbz	w14, .LBB128_20
// %bb.22:                              //   in Loop: Header=BB128_21 Depth=1
	and	x15, x8, #0xffff
	add	x15, x9, x15, lsl #5
	ldr	x13, [x11, :lo12:gp_gc_page_buf_info]
	ldr	x15, [x15, #8]
	mov	w17, wzr
.LBB128_23:                             //   Parent Loop BB128_21 Depth=1
                                        // =>  This Inner Loop Header: Depth=2
	and	x18, x17, #0xffff
	mul	x18, x18, x12
	ldr	x18, [x13, x18]
	cmp	x18, x15
	b.eq	.LBB128_19
// %bb.24:                              //   in Loop: Header=BB128_23 Depth=2
	add	w17, w17, #1                    // =1
	cmp	w14, w17, uxth
	b.hi	.LBB128_23
	b	.LBB128_20
.LBB128_25:
	adrp	x8, g_gc_temp_superblock+4
	ldrh	w8, [x8, :lo12:g_gc_temp_superblock+4]
	mov	w19, wzr
	str	wzr, [x20, :lo12:g_gc_num_req]
	cbnz	w8, .LBB128_27
// %bb.26:
	mov	w0, #1
	mov	w19, #1
	bl	FtlGcFreeTempBlock
.LBB128_27:
	mov	w0, w19
	ldp	x20, x19, [sp, #16]             // 16-byte Folded Reload
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end128:
	.size	Ftl_gc_temp_data_write_back, .Lfunc_end128-Ftl_gc_temp_data_write_back
                                        // -- End function
	.globl	FtlGcMarkBadPhyBlk              // -- Begin function FtlGcMarkBadPhyBlk
	.p2align	2
	.type	FtlGcMarkBadPhyBlk,@function
FtlGcMarkBadPhyBlk:                     // @FtlGcMarkBadPhyBlk
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-48]!           // 16-byte Folded Spill
	adrp	x8, c_ftl_nand_blks_per_die
	ldrh	w8, [x8, :lo12:c_ftl_nand_blks_per_die]
	str	x21, [sp, #16]                  // 8-byte Folded Spill
	adrp	x9, c_ftl_nand_planes_per_die
	adrp	x21, g_gc_bad_block_temp_num
	ldrh	w9, [x9, :lo12:c_ftl_nand_planes_per_die]
	ldrh	w1, [x21, :lo12:g_gc_bad_block_temp_num]
	and	w2, w0, #0xffff
	stp	x20, x19, [sp, #32]             // 16-byte Folded Spill
	mov	w19, w0
	udiv	w10, w2, w8
	adrp	x0, .L.str.113
	msub	w8, w10, w8, w2
	add	x0, x0, :lo12:.L.str.113
	mov	x29, sp
	udiv	w20, w8, w9
	bl	sftl_printk
	adrp	x0, .L.str.112
	add	x0, x0, :lo12:.L.str.112
	mov	w1, w20
	bl	sftl_printk
	adrp	x8, g_gc_next_blk
	ldrh	w10, [x8, :lo12:g_gc_next_blk]
	cmp	w10, w20
	b.eq	.LBB129_5
// %bb.1:
	adrp	x9, g_gc_next_blk_1
	ldrh	w11, [x9, :lo12:g_gc_next_blk_1]
	cmp	w11, w20, uxth
	b.eq	.LBB129_5
// %bb.2:
	mov	w12, #65535
	cmp	w10, w12
	b.eq	.LBB129_12
// %bb.3:
	cmp	w11, w12
	b.ne	.LBB129_5
// %bb.4:
	strh	w20, [x9, :lo12:g_gc_next_blk_1]
.LBB129_5:
	ldrh	w8, [x21, :lo12:g_gc_bad_block_temp_num]
	cbz	x8, .LBB129_10
.LBB129_6:
	adrp	x9, g_gc_bad_block_temp_tbl
	add	x9, x9, :lo12:g_gc_bad_block_temp_tbl
	mov	x10, x8
.LBB129_7:                              // =>This Inner Loop Header: Depth=1
	ldrh	w11, [x9]
	cmp	w11, w19, uxth
	b.eq	.LBB129_11
// %bb.8:                               //   in Loop: Header=BB129_7 Depth=1
	subs	x10, x10, #1                    // =1
	add	x9, x9, #2                      // =2
	b.ne	.LBB129_7
// %bb.9:
	cmp	w8, #15                         // =15
	b.hi	.LBB129_11
.LBB129_10:
	adrp	x9, g_gc_bad_block_temp_tbl
	add	x9, x9, :lo12:g_gc_bad_block_temp_tbl
	add	w10, w8, #1                     // =1
	strh	w10, [x21, :lo12:g_gc_bad_block_temp_num]
	strh	w19, [x9, w8, uxtw #1]
.LBB129_11:
	ldp	x20, x19, [sp, #32]             // 16-byte Folded Reload
	ldr	x21, [sp, #16]                  // 8-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #48             // 16-byte Folded Reload
	hint	#29
	ret
.LBB129_12:
	strh	w20, [x8, :lo12:g_gc_next_blk]
	ldrh	w8, [x21, :lo12:g_gc_bad_block_temp_num]
	cbnz	x8, .LBB129_6
	b	.LBB129_10
.Lfunc_end129:
	.size	FtlGcMarkBadPhyBlk, .Lfunc_end129-FtlGcMarkBadPhyBlk
                                        // -- End function
	.globl	FtlGcReFreshBadBlk              // -- Begin function FtlGcReFreshBadBlk
	.p2align	2
	.type	FtlGcReFreshBadBlk,@function
FtlGcReFreshBadBlk:                     // @FtlGcReFreshBadBlk
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-48]!           // 16-byte Folded Spill
	adrp	x8, g_gc_bad_block_temp_num
	ldrh	w9, [x8, :lo12:g_gc_bad_block_temp_num]
	str	x21, [sp, #16]                  // 8-byte Folded Spill
	stp	x20, x19, [sp, #32]             // 16-byte Folded Spill
	mov	x29, sp
	cbz	w9, .LBB130_11
// %bb.1:
	adrp	x21, g_gc_next_blk
	ldrh	w8, [x21, :lo12:g_gc_next_blk]
	mov	w10, #65535
	cmp	w8, w10
	b.ne	.LBB130_11
// %bb.2:
	adrp	x20, g_gc_bad_block_gc_index
	ldrh	w8, [x20, :lo12:g_gc_bad_block_gc_index]
	cmp	w8, w9
	b.lo	.LBB130_4
// %bb.3:
	mov	w8, wzr
	strh	wzr, [x20, :lo12:g_gc_bad_block_gc_index]
.LBB130_4:
	adrp	x9, g_gc_bad_block_temp_tbl
	add	x9, x9, :lo12:g_gc_bad_block_temp_tbl
	adrp	x10, c_ftl_nand_blks_per_die
	ldrh	w8, [x9, w8, uxtw #1]
	ldrh	w9, [x10, :lo12:c_ftl_nand_blks_per_die]
	adrp	x10, c_ftl_nand_planes_per_die
	ldrh	w10, [x10, :lo12:c_ftl_nand_planes_per_die]
	adrp	x0, .L.str.112
	udiv	w11, w8, w9
	msub	w8, w11, w9, w8
	udiv	w19, w8, w10
	add	x0, x0, :lo12:.L.str.112
	mov	w1, w19
	bl	sftl_printk
	ldrh	w9, [x21, :lo12:g_gc_next_blk]
	cmp	w9, w19
	b.eq	.LBB130_10
// %bb.5:
	adrp	x8, g_gc_next_blk_1
	ldrh	w10, [x8, :lo12:g_gc_next_blk_1]
	cmp	w10, w19, uxth
	b.eq	.LBB130_10
// %bb.6:
	mov	w11, #65535
	cmp	w9, w11
	b.eq	.LBB130_9
// %bb.7:
	cmp	w10, w11
	b.ne	.LBB130_10
// %bb.8:
	strh	w19, [x8, :lo12:g_gc_next_blk_1]
	b	.LBB130_10
.LBB130_9:
	strh	w19, [x21, :lo12:g_gc_next_blk]
.LBB130_10:
	ldrh	w8, [x20, :lo12:g_gc_bad_block_gc_index]
	add	w8, w8, #1                      // =1
	strh	w8, [x20, :lo12:g_gc_bad_block_gc_index]
.LBB130_11:
	ldp	x20, x19, [sp, #32]             // 16-byte Folded Reload
	ldr	x21, [sp, #16]                  // 8-byte Folded Reload
	mov	w0, wzr
	ldp	x29, x30, [sp], #48             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end130:
	.size	FtlGcReFreshBadBlk, .Lfunc_end130-FtlGcReFreshBadBlk
                                        // -- End function
	.globl	FtlReadRefresh                  // -- Begin function FtlReadRefresh
	.p2align	2
	.type	FtlReadRefresh,@function
FtlReadRefresh:                         // @FtlReadRefresh
// %bb.0:
	hint	#25
	sub	sp, sp, #160                    // =160
	adrp	x8, __stack_chk_guard
	ldr	x8, [x8, :lo12:__stack_chk_guard]
	stp	x29, x30, [sp, #112]            // 16-byte Folded Spill
	add	x29, sp, #112                   // =112
	stp	x22, x21, [sp, #128]            // 16-byte Folded Spill
	stp	x20, x19, [sp, #144]            // 16-byte Folded Spill
	stur	x8, [x29, #-8]
	adrp	x8, g_sys_ext_data+80
	ldr	w8, [x8, :lo12:g_sys_ext_data+80]
	cbz	w8, .LBB131_6
// %bb.1:
	adrp	x19, g_sys_ext_data+84
	adrp	x20, g_MaxLpn
	ldr	w8, [x19, :lo12:g_sys_ext_data+84]
	ldr	w9, [x20, :lo12:g_MaxLpn]
	cmp	w8, w9
	b.hs	.LBB131_11
// %bb.2:
	mov	w21, #2047
.LBB131_3:                              // =>This Inner Loop Header: Depth=1
	add	x1, sp, #36                     // =36
	mov	w0, w8
	mov	w2, wzr
	bl	log2phys
	ldr	w8, [x19, :lo12:g_sys_ext_data+84]
	ldr	w22, [sp, #36]
	add	w8, w8, #1                      // =1
	cmn	w22, #1                         // =1
	str	w8, [x19, :lo12:g_sys_ext_data+84]
	b.ne	.LBB131_12
// %bb.4:                               //   in Loop: Header=BB131_3 Depth=1
	subs	w21, w21, #1                    // =1
	mov	w0, #-1
	b.lo	.LBB131_20
// %bb.5:                               //   in Loop: Header=BB131_3 Depth=1
	ldr	w9, [x20, :lo12:g_MaxLpn]
	cmp	w8, w9
	b.lo	.LBB131_3
	b	.LBB131_20
.LBB131_6:
	adrp	x8, g_max_erase_count
	adrp	x11, g_totle_read_page_count
	ldr	w12, [x8, :lo12:g_max_erase_count]
	ldr	w8, [x11, :lo12:g_totle_read_page_count]
	adrp	x11, g_sys_ext_data+76
	ldr	w11, [x11, :lo12:g_sys_ext_data+76]
	mov	w9, #10000
	mov	w10, #63
	mov	w13, #31
	cmp	w12, w9
	add	w9, w8, #256, lsl #12           // =1048576
	csel	w10, w13, w10, hi
	cmp	w11, w9
	adrp	x9, g_sys_save_data+28
	b.hi	.LBB131_10
// %bb.7:
	adrp	x13, g_MaxLpn
	ldr	w13, [x13, :lo12:g_MaxLpn]
	mov	w14, #1000
	lsr	w12, w12, #10
	add	w12, w12, #1                    // =1
	mul	w13, w13, w14
	udiv	w12, w13, w12
	add	w11, w12, w11
	cmp	w11, w8
	b.lo	.LBB131_10
// %bb.8:
	adrp	x12, g_sys_ext_data+100
	ldrh	w11, [x9, :lo12:g_sys_save_data+28]
	ldr	w12, [x12, :lo12:g_sys_ext_data+100]
	mov	w0, wzr
	cmp	w12, w11
	b.eq	.LBB131_20
// %bb.9:
	and	w10, w10, w11
	cbnz	w10, .LBB131_20
.LBB131_10:
	ldrh	w9, [x9, :lo12:g_sys_save_data+28]
	adrp	x10, g_sys_ext_data+76
	mov	w0, wzr
	add	x10, x10, :lo12:g_sys_ext_data+76
	mov	w11, #1
	stur	x11, [x10, #4]
	str	w9, [x10, #24]
	str	w8, [x10]
	b	.LBB131_20
.LBB131_11:
	adrp	x8, g_totle_read_page_count
	ldr	w8, [x8, :lo12:g_totle_read_page_count]
	adrp	x9, g_sys_ext_data+76
	add	x9, x9, :lo12:g_sys_ext_data+76
	mov	w0, wzr
	stur	xzr, [x9, #4]
	str	w8, [x9]
	b	.LBB131_20
.LBB131_12:
	adrp	x9, sftl_temp_buf
	ldr	x9, [x9, :lo12:sftl_temp_buf]
	str	w8, [sp, #24]
	add	x8, sp, #40                     // =40
	mov	x0, sp
	mov	w1, #1
	stp	x9, x8, [sp, #8]
	stp	wzr, w22, [sp]
	bl	FlashReadPages
	ldr	w8, [sp]
	cmp	w8, #256                        // =256
	b.ne	.LBB131_19
// %bb.13:
	adrp	x8, c_ftl_nand_blks_per_die
	ldrh	w8, [x8, :lo12:c_ftl_nand_blks_per_die]
	adrp	x9, c_ftl_nand_planes_per_die
	ldrh	w9, [x9, :lo12:c_ftl_nand_planes_per_die]
	ubfx	w10, w22, #10, #16
	udiv	w11, w10, w8
	msub	w8, w11, w8, w10
	udiv	w19, w8, w9
	adrp	x0, .L.str.112
	add	x0, x0, :lo12:.L.str.112
	mov	w1, w19
	bl	sftl_printk
	adrp	x8, g_gc_next_blk
	ldrh	w10, [x8, :lo12:g_gc_next_blk]
	cmp	w10, w19
	b.eq	.LBB131_19
// %bb.14:
	adrp	x9, g_gc_next_blk_1
	ldrh	w11, [x9, :lo12:g_gc_next_blk_1]
	cmp	w11, w19, uxth
	b.eq	.LBB131_19
// %bb.15:
	mov	w12, #65535
	cmp	w10, w12
	b.eq	.LBB131_18
// %bb.16:
	cmp	w11, w12
	b.ne	.LBB131_19
// %bb.17:
	strh	w19, [x9, :lo12:g_gc_next_blk_1]
	b	.LBB131_19
.LBB131_18:
	strh	w19, [x8, :lo12:g_gc_next_blk]
.LBB131_19:
	mov	w0, #-1
.LBB131_20:
	adrp	x9, __stack_chk_guard
	ldur	x8, [x29, #-8]
	ldr	x9, [x9, :lo12:__stack_chk_guard]
	cmp	x9, x8
	b.ne	.LBB131_22
// %bb.21:
	ldp	x20, x19, [sp, #144]            // 16-byte Folded Reload
	ldp	x22, x21, [sp, #128]            // 16-byte Folded Reload
	ldp	x29, x30, [sp, #112]            // 16-byte Folded Reload
	add	sp, sp, #160                    // =160
	hint	#29
	ret
.LBB131_22:
	bl	__stack_chk_fail
.Lfunc_end131:
	.size	FtlReadRefresh, .Lfunc_end131-FtlReadRefresh
                                        // -- End function
	.globl	sftl_gc                         // -- Begin function sftl_gc
	.p2align	2
	.type	sftl_gc,@function
sftl_gc:                                // @sftl_gc
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
	mov	w0, #1
	mov	x29, sp
	bl	rk_ftl_garbage_collect
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end132:
	.size	sftl_gc, .Lfunc_end132-sftl_gc
                                        // -- End function
	.globl	ftl_free                        // -- Begin function ftl_free
	.p2align	2
	.type	ftl_free,@function
ftl_free:                               // @ftl_free
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
	mov	x29, sp
	bl	kfree
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end133:
	.size	ftl_free, .Lfunc_end133-ftl_free
                                        // -- End function
	.globl	ftl_memcmp                      // -- Begin function ftl_memcmp
	.p2align	2
	.type	ftl_memcmp,@function
ftl_memcmp:                             // @ftl_memcmp
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
	mov	w2, w2
	mov	x29, sp
	bl	memcmp
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end134:
	.size	ftl_memcmp, .Lfunc_end134-ftl_memcmp
                                        // -- End function
	.globl	rk_sftl_vendor_dev_ops_register // -- Begin function rk_sftl_vendor_dev_ops_register
	.p2align	2
	.type	rk_sftl_vendor_dev_ops_register,@function
rk_sftl_vendor_dev_ops_register:        // @rk_sftl_vendor_dev_ops_register
// %bb.0:
	hint	#25
	adrp	x9, _flash_read
	ldr	x10, [x9, :lo12:_flash_read]
	cbz	x10, .LBB135_2
// %bb.1:
	mov	w0, #-1
	hint	#29
	ret
.LBB135_2:
	mov	x8, x0
	str	x8, [x9, :lo12:_flash_read]
	adrp	x8, _flash_write
	mov	w0, wzr
	str	x1, [x8, :lo12:_flash_write]
	hint	#29
	ret
.Lfunc_end135:
	.size	rk_sftl_vendor_dev_ops_register, .Lfunc_end135-rk_sftl_vendor_dev_ops_register
                                        // -- End function
	.globl	rk_sftl_vendor_storage_init     // -- Begin function rk_sftl_vendor_storage_init
	.p2align	2
	.type	rk_sftl_vendor_storage_init,@function
rk_sftl_vendor_storage_init:            // @rk_sftl_vendor_storage_init
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-64]!           // 16-byte Folded Spill
	mov	w0, #65536
	mov	w1, #3265
	mov	w2, #4
	str	x23, [sp, #16]                  // 8-byte Folded Spill
	stp	x22, x21, [sp, #32]             // 16-byte Folded Spill
	stp	x20, x19, [sp, #48]             // 16-byte Folded Spill
	mov	x29, sp
	bl	kmalloc_order
	adrp	x20, g_vendor
	str	x0, [x20, :lo12:g_vendor]
	cbz	x0, .LBB136_4
// %bb.1:
	adrp	x22, _flash_read
	ldr	x8, [x22, :lo12:_flash_read]
	mov	x2, x0
	mov	w1, #128
	mov	w0, wzr
	blr	x8
	cbnz	w0, .LBB136_7
// %bb.2:
	ldr	x2, [x20, :lo12:g_vendor]
	mov	w21, #22084
	movk	w21, #21067, lsl #16
	ldr	w8, [x2]
	cmp	w8, w21
	b.ne	.LBB136_5
// %bb.3:
	mov	w8, #65532
	ldr	w9, [x2, #4]
	ldr	w8, [x2, x8]
	cmp	w9, #0                          // =0
	ccmp	w8, w9, #0, ne
	csel	w23, w9, wzr, eq
	b	.LBB136_6
.LBB136_4:
	mov	w0, #-12
	b	.LBB136_8
.LBB136_5:
	mov	w23, wzr
.LBB136_6:
	ldr	x8, [x22, :lo12:_flash_read]
	mov	w0, #128
	mov	w1, #128
	blr	x8
	cbz	w0, .LBB136_9
.LBB136_7:
	ldr	x0, [x20, :lo12:g_vendor]
	bl	kfree
	mov	w0, #-1
	str	xzr, [x20, :lo12:g_vendor]
.LBB136_8:
	ldp	x20, x19, [sp, #48]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #32]             // 16-byte Folded Reload
	ldr	x23, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #64             // 16-byte Folded Reload
	hint	#29
	ret
.LBB136_9:
	ldr	x19, [x20, :lo12:g_vendor]
	ldr	w8, [x19]
	cmp	w8, w21
	b.ne	.LBB136_12
// %bb.10:
	mov	w8, #65532
	ldr	w9, [x19, #4]
	ldr	w8, [x19, x8]
	mov	w10, #128
	cmp	w8, w9
	cset	w8, eq
	cmp	w23, w9
	cset	w11, lo
	tst	w8, w11
	csel	w23, w9, w23, ne
	csel	w0, w10, wzr, ne
	cbz	w23, .LBB136_13
.LBB136_11:
	ldr	x8, [x22, :lo12:_flash_read]
	mov	w1, #128
	mov	x2, x19
	blr	x8
	cbnz	w0, .LBB136_7
	b	.LBB136_8
.LBB136_12:
	mov	w0, wzr
	cbnz	w23, .LBB136_11
.LBB136_13:
	add	x0, x19, #8                     // =8
	mov	w2, #65524
	mov	w1, wzr
	bl	memset
	mov	w8, #1
	mov	w9, #65532
	mov	w10, #-67633152
	mov	w0, wzr
	stp	w21, w8, [x19]
	str	w8, [x19, x9]
	str	w10, [x19, #12]
	b	.LBB136_8
.Lfunc_end136:
	.size	rk_sftl_vendor_storage_init, .Lfunc_end136-rk_sftl_vendor_storage_init
                                        // -- End function
	.globl	rk_sftl_vendor_read             // -- Begin function rk_sftl_vendor_read
	.p2align	2
	.type	rk_sftl_vendor_read,@function
rk_sftl_vendor_read:                    // @rk_sftl_vendor_read
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-32]!           // 16-byte Folded Spill
	adrp	x8, g_vendor
	ldr	x8, [x8, :lo12:g_vendor]
	str	x19, [sp, #16]                  // 8-byte Folded Spill
	mov	x29, sp
	cbz	x8, .LBB137_5
// %bb.1:
	ldrh	w10, [x8, #10]
	cbz	x10, .LBB137_5
// %bb.2:
	mov	x11, xzr
	add	x9, x8, #20                     // =20
.LBB137_3:                              // =>This Inner Loop Header: Depth=1
	ldurh	w12, [x9, #-4]
	cmp	w12, w0
	b.eq	.LBB137_6
// %bb.4:                               //   in Loop: Header=BB137_3 Depth=1
	add	x11, x11, #1                    // =1
	cmp	x11, x10
	add	x9, x9, #8                      // =8
	b.lo	.LBB137_3
.LBB137_5:
	mov	w19, #-1
	b	.LBB137_7
.LBB137_6:
	ldrh	w10, [x9]
	ldurh	w9, [x9, #-2]
	mov	x0, x1
	cmp	w10, w2
	add	x8, x8, x9
	csel	w19, w10, w2, lo
	add	x8, x8, #1024                   // =1024
	mov	x1, x8
	mov	x2, x19
	bl	memcpy
.LBB137_7:
	mov	w0, w19
	ldr	x19, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #32             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end137:
	.size	rk_sftl_vendor_read, .Lfunc_end137-rk_sftl_vendor_read
                                        // -- End function
	.globl	rk_sftl_vendor_write            // -- Begin function rk_sftl_vendor_write
	.p2align	2
	.type	rk_sftl_vendor_write,@function
rk_sftl_vendor_write:                   // @rk_sftl_vendor_write
// %bb.0:
	hint	#25
	sub	sp, sp, #112                    // =112
	adrp	x8, g_vendor
	stp	x20, x19, [sp, #96]             // 16-byte Folded Spill
	ldr	x19, [x8, :lo12:g_vendor]
	stp	x29, x30, [sp, #16]             // 16-byte Folded Spill
	stp	x28, x27, [sp, #32]             // 16-byte Folded Spill
	stp	x26, x25, [sp, #48]             // 16-byte Folded Spill
	stp	x24, x23, [sp, #64]             // 16-byte Folded Spill
	stp	x22, x21, [sp, #80]             // 16-byte Folded Spill
	add	x29, sp, #16                    // =16
	cbz	x19, .LBB138_6
// %bb.1:
	ldrh	w23, [x19, #10]
	ldrh	w24, [x19, #8]
	add	w8, w2, #63                     // =63
	mov	w21, w2
	mov	w22, w0
	and	w25, w8, #0xffffffc0
	cbz	w23, .LBB138_5
// %bb.2:
	mov	x27, xzr
	mov	w9, w23
	sub	w8, w23, #1                     // =1
	add	x26, x19, #28                   // =28
.LBB138_3:                              // =>This Inner Loop Header: Depth=1
	ldurh	w10, [x26, #-12]
	cmp	w10, w22
	b.eq	.LBB138_8
// %bb.4:                               //   in Loop: Header=BB138_3 Depth=1
	add	x27, x27, #1                    // =1
	cmp	x9, x27
	add	x26, x26, #8                    // =8
	b.ne	.LBB138_3
.LBB138_5:
	ldrh	w8, [x19, #14]
	cmp	w25, w8
	b.ls	.LBB138_7
.LBB138_6:
	mov	w0, #-1
	b	.LBB138_18
.LBB138_7:
	add	x9, x19, x23, lsl #3
	strh	w22, [x9, #16]
	ldrh	w10, [x19, #12]
	sub	w8, w8, w25
	strh	w21, [x9, #20]
	mov	w2, w21
	strh	w10, [x9, #18]
	strh	w8, [x19, #14]
	add	x8, x19, x10
	add	w9, w10, w25
	add	x0, x8, #1024                   // =1024
	strh	w9, [x19, #12]
	bl	memcpy
	ldr	w9, [x19, #4]
	add	w8, w23, #1                     // =1
	add	w11, w24, #1                    // =1
	strh	w8, [x19, #10]
	and	w8, w11, #0xffff
	cmp	w8, #1                          // =1
	mov	w10, #65532
	csinc	w8, wzr, w24, hi
	add	w9, w9, #1                      // =1
	str	w9, [x19, #4]
	str	w9, [x19, x10]
	strh	w8, [x19, #8]
	b	.LBB138_17
.LBB138_8:
	ldurh	w9, [x26, #-8]
	add	w9, w9, #63                     // =63
	and	w20, w9, #0x1ffc0
	cmp	w20, w21
	b.hs	.LBB138_15
// %bb.9:
	ldrh	w23, [x19, #14]
	cmp	w25, w23
	b.hi	.LBB138_6
// %bb.10:
	ldurh	w28, [x26, #-10]
	cmp	w8, w27
	b.ls	.LBB138_14
// %bb.11:
	stp	w23, w20, [sp]                  // 8-byte Folded Spill
	sub	x20, x8, x27
	mov	w27, w8
	str	x1, [sp, #8]                    // 8-byte Folded Spill
.LBB138_12:                             // =>This Inner Loop Header: Depth=1
	ldurh	w8, [x26, #-4]
	ldrh	w9, [x26]
	ldurh	w11, [x26, #-2]
	add	x10, x19, #1024                 // =1024
	sturh	w8, [x26, #-12]
	add	w8, w9, #63                     // =63
	and	x23, x8, #0x1ffc0
	add	x0, x10, w28, uxtw
	add	x1, x10, x11
	mov	x2, x23
	sturh	w28, [x26, #-10]
	sturh	w9, [x26, #-8]
	bl	memcpy
	add	w28, w23, w28
	subs	x20, x20, #1                    // =1
	add	x26, x26, #8                    // =8
	b.ne	.LBB138_12
// %bb.13:
	ldr	x1, [sp, #8]                    // 8-byte Folded Reload
	ldp	w23, w20, [sp]                  // 8-byte Folded Reload
.LBB138_14:
	add	x8, x19, x27, lsl #3
	and	w9, w28, #0xffff
	strh	w22, [x8, #16]
	strh	w28, [x8, #18]
	strh	w21, [x8, #20]
	add	x8, x19, x9
	add	x0, x8, #1024                   // =1024
	mov	w2, w21
	bl	memcpy
	add	w8, w28, w25
	sub	w9, w20, w25
	strh	w8, [x19, #12]
	add	w8, w23, w9
	strh	w8, [x19, #14]
	b	.LBB138_16
.LBB138_15:
	ldurh	w8, [x26, #-10]
	mov	w2, w21
	add	x8, x19, x8
	add	x0, x8, #1024                   // =1024
	bl	memcpy
	sturh	w21, [x26, #-8]
.LBB138_16:
	ldr	w8, [x19, #4]
	add	w10, w24, #1                    // =1
	and	w10, w10, #0xffff
	cmp	w10, #1                         // =1
	mov	w9, #65532
	csinc	w10, wzr, w24, hi
	add	w8, w8, #1                      // =1
	str	w8, [x19, #4]
	str	w8, [x19, x9]
	strh	w10, [x19, #8]
.LBB138_17:
	adrp	x8, _flash_write
	ldr	x8, [x8, :lo12:_flash_write]
	lsl	w0, w24, #7
	mov	w1, #128
	mov	x2, x19
	blr	x8
	mov	w0, wzr
.LBB138_18:
	ldp	x20, x19, [sp, #96]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #80]             // 16-byte Folded Reload
	ldp	x24, x23, [sp, #64]             // 16-byte Folded Reload
	ldp	x26, x25, [sp, #48]             // 16-byte Folded Reload
	ldp	x28, x27, [sp, #32]             // 16-byte Folded Reload
	ldp	x29, x30, [sp, #16]             // 16-byte Folded Reload
	add	sp, sp, #112                    // =112
	hint	#29
	ret
.Lfunc_end138:
	.size	rk_sftl_vendor_write, .Lfunc_end138-rk_sftl_vendor_write
                                        // -- End function
	.globl	rk_sftl_vendor_storage_ioctl    // -- Begin function rk_sftl_vendor_storage_ioctl
	.p2align	2
	.type	rk_sftl_vendor_storage_ioctl,@function
rk_sftl_vendor_storage_ioctl:           // @rk_sftl_vendor_storage_ioctl
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-64]!           // 16-byte Folded Spill
	adrp	x8, kmalloc_caches+320
	ldr	x0, [x8, :lo12:kmalloc_caches+320]
	stp	x22, x21, [sp, #32]             // 16-byte Folded Spill
	mov	w21, w1
	mov	w1, #3265
	str	x23, [sp, #16]                  // 8-byte Folded Spill
	stp	x20, x19, [sp, #48]             // 16-byte Folded Spill
	mov	x29, sp
	mov	x20, x2
	bl	kmem_cache_alloc
	cbz	x0, .LBB139_14
// %bb.1:
	mov	w8, #30210
	movk	w8, #16388, lsl #16
	mov	x19, x0
	cmp	w21, w8
	b.eq	.LBB139_15
// %bb.2:
	mov	w8, #30209
	movk	w8, #16388, lsl #16
	cmp	w21, w8
	b.ne	.LBB139_29
// %bb.3:
	//APP
	mrs	x22, SP_EL0
	//NO_APP
	ldrb	w10, [x22, #46]
	ldr	x9, [x22, #8]
	lsl	x8, x20, #8
	tbnz	w10, #5, .LBB139_5
// %bb.4:
	ldr	x11, [x22]
	mov	x10, x20
	tbz	w11, #26, .LBB139_6
.LBB139_5:
	and	x10, x20, x8, asr #8
.LBB139_6:
	//APP
	adds	x10, x10, #8                    // =8
	csel	x9, xzr, x9, hi
	csinv	x10, x10, xzr, lo
	sbcs	xzr, x10, x9
	cset	x10, ls

	//NO_APP
	cbz	x10, .LBB139_37
// %bb.7:
	//APP


	//NO_APP
	ldr	x9, [x22, #8]
	and	x23, x20, x8, asr #8
	//APP
	bics	xzr, x23, x9
	csel	x1, x20, xzr, eq

	//NO_APP
	//APP
	csdb
	//NO_APP
	mov	w2, #8
	mov	x0, x19
	bl	__arch_copy_from_user
	//APP


	//NO_APP
	cbnz	x0, .LBB139_38
// %bb.8:
	ldr	w8, [x19]
	mov	w9, #17745
	movk	w9, #22098, lsl #16
	cmp	w8, w9
	b.ne	.LBB139_28
// %bb.9:
	adrp	x8, g_vendor
	ldr	x8, [x8, :lo12:g_vendor]
	cbz	x8, .LBB139_28
// %bb.10:
	ldrh	w9, [x8, #10]
	cbz	x9, .LBB139_28
// %bb.11:
	ldrh	w12, [x19, #4]
	ldrh	w10, [x19, #6]
	add	x0, x19, #8                     // =8
	add	x11, x8, #20                    // =20
.LBB139_12:                             // =>This Inner Loop Header: Depth=1
	ldurh	w13, [x11, #-4]
	cmp	w13, w12
	b.eq	.LBB139_32
// %bb.13:                              //   in Loop: Header=BB139_12 Depth=1
	subs	x9, x9, #1                      // =1
	add	x11, x11, #8                    // =8
	b.ne	.LBB139_12
	b	.LBB139_28
.LBB139_14:
	mov	x21, #-1
	b	.LBB139_31
.LBB139_15:
	//APP
	mrs	x22, SP_EL0
	//NO_APP
	ldrb	w9, [x22, #46]
	ldr	x8, [x22, #8]
	tbnz	w9, #5, .LBB139_17
// %bb.16:
	ldr	x10, [x22]
	mov	x9, x20
	tbz	w10, #26, .LBB139_18
.LBB139_17:
	lsl	x9, x20, #8
	and	x9, x20, x9, asr #8
.LBB139_18:
	//APP
	adds	x9, x9, #8                      // =8
	csel	x8, xzr, x8, hi
	csinv	x9, x9, xzr, lo
	sbcs	xzr, x9, x8
	cset	x9, ls

	//NO_APP
	cbz	x9, .LBB139_40
// %bb.19:
	lsl	x9, x20, #8
	//APP


	//NO_APP
	ldr	x8, [x22, #8]
	and	x23, x20, x9, asr #8
	//APP
	bics	xzr, x23, x8
	csel	x1, x20, xzr, eq

	//NO_APP
	//APP
	csdb
	//NO_APP
	mov	w2, #8
	mov	x0, x19
	bl	__arch_copy_from_user
	//APP


	//NO_APP
	cbnz	x0, .LBB139_41
// %bb.20:
	ldr	w8, [x19]
	mov	w9, #17745
	movk	w9, #22098, lsl #16
	cmp	w8, w9
	b.ne	.LBB139_28
// %bb.21:
	ldrh	w9, [x19, #6]
	cmp	x9, #4087                       // =4087
	b.hi	.LBB139_28
// %bb.22:
	ldrb	w10, [x22, #46]
	ldr	x8, [x22, #8]
	add	x21, x9, #8                     // =8
	tbnz	w10, #5, .LBB139_24
// %bb.23:
	ldr	x10, [x22]
	mov	x9, x20
	tbz	w10, #26, .LBB139_25
.LBB139_24:
	mov	x9, x23
.LBB139_25:
	//APP
	adds	x9, x9, x21
	csel	x8, xzr, x8, hi
	csinv	x9, x9, xzr, lo
	sbcs	xzr, x9, x8
	cset	x9, ls

	//NO_APP
	cbz	x9, .LBB139_43
// %bb.26:
	//APP


	//NO_APP
	ldr	x8, [x22, #8]
	//APP
	bics	xzr, x23, x8
	csel	x1, x20, xzr, eq

	//NO_APP
	//APP
	csdb
	//NO_APP
	mov	x0, x19
	mov	x2, x21
	bl	__arch_copy_from_user
	//APP


	//NO_APP
	cbnz	x0, .LBB139_44
// %bb.27:
	ldrh	w0, [x19, #4]
	ldrh	w2, [x19, #6]
	add	x1, x19, #8                     // =8
	bl	rk_sftl_vendor_write
                                        // kill: def $w0 killed $w0 def $x0
	sxtw	x21, w0
	b	.LBB139_30
.LBB139_28:
	mov	x21, #-1
	b	.LBB139_30
.LBB139_29:
	mov	x21, #-14
.LBB139_30:
	mov	x0, x19
	bl	kfree
.LBB139_31:
	mov	x0, x21
	ldp	x20, x19, [sp, #48]             // 16-byte Folded Reload
	ldp	x22, x21, [sp, #32]             // 16-byte Folded Reload
	ldr	x23, [sp, #16]                  // 8-byte Folded Reload
	ldp	x29, x30, [sp], #64             // 16-byte Folded Reload
	hint	#29
	ret
.LBB139_32:
	ldrh	w9, [x11]
	ldurh	w11, [x11, #-2]
	cmp	w9, w10
	add	x8, x8, x11
	csel	w21, w9, w10, lo
	add	x1, x8, #1024                   // =1024
	mov	x2, x21
	bl	memcpy
	strh	w21, [x19, #6]
	ldrb	w9, [x22, #46]
	ldr	x8, [x22, #8]
	add	w2, w21, #8                     // =8
	tbnz	w9, #5, .LBB139_34
// %bb.33:
	ldr	x10, [x22]
	mov	x9, x20
	tbz	w10, #26, .LBB139_35
.LBB139_34:
	mov	x9, x23
.LBB139_35:
	mov	x21, #-14
	//APP
	adds	x9, x9, x2
	csel	x8, xzr, x8, hi
	csinv	x9, x9, xzr, lo
	sbcs	xzr, x9, x8
	cset	x9, ls

	//NO_APP
	cbz	x9, .LBB139_30
// %bb.36:
	//APP


	//NO_APP
	ldr	x8, [x22, #8]
	//APP
	bics	xzr, x23, x8
	csel	x0, x20, xzr, eq

	//NO_APP
	//APP
	csdb
	//NO_APP
	mov	x1, x19
	bl	__arch_copy_to_user
	cmp	x0, #0                          // =0
	//APP


	//NO_APP
	csel	x21, xzr, x21, eq
	b	.LBB139_30
.LBB139_37:
	mov	w2, #8
	b	.LBB139_39
.LBB139_38:
	mov	x2, x0
.LBB139_39:
	sub	x8, x19, x2
	add	x0, x8, #8                      // =8
	mov	w1, wzr
	bl	memset
	adrp	x0, .L.str.131
	add	x0, x0, :lo12:.L.str.131
	mov	w1, #256
	b	.LBB139_46
.LBB139_40:
	mov	w2, #8
	b	.LBB139_42
.LBB139_41:
	mov	x2, x0
.LBB139_42:
	sub	x8, x19, x2
	add	x0, x8, #8                      // =8
	mov	w1, wzr
	bl	memset
	adrp	x0, .L.str.131
	add	x0, x0, :lo12:.L.str.131
	mov	w1, #276
	b	.LBB139_46
.LBB139_43:
	mov	x2, x21
	b	.LBB139_45
.LBB139_44:
	mov	x2, x0
.LBB139_45:
	sub	x8, x21, x2
	add	x0, x19, x8
	mov	w1, wzr
	bl	memset
	adrp	x0, .L.str.131
	add	x0, x0, :lo12:.L.str.131
	mov	w1, #283
.LBB139_46:
	mov	x2, x20
	bl	sftl_printk
	mov	x21, #-14
	b	.LBB139_30
.Lfunc_end139:
	.size	rk_sftl_vendor_storage_ioctl, .Lfunc_end139-rk_sftl_vendor_storage_ioctl
                                        // -- End function
	.globl	rk_sftl_vendor_register         // -- Begin function rk_sftl_vendor_register
	.p2align	2
	.type	rk_sftl_vendor_register,@function
rk_sftl_vendor_register:                // @rk_sftl_vendor_register
// %bb.0:
	hint	#25
	stp	x29, x30, [sp, #-16]!           // 16-byte Folded Spill
	adrp	x0, rkflash_vender_storage_dev
	add	x0, x0, :lo12:rkflash_vender_storage_dev
	mov	x29, sp
	bl	misc_register
	ldp	x29, x30, [sp], #16             // 16-byte Folded Reload
	hint	#29
	ret
.Lfunc_end140:
	.size	rk_sftl_vendor_register, .Lfunc_end140-rk_sftl_vendor_register
                                        // -- End function
	.type	gFtlInitStatus,@object          // @gFtlInitStatus
	.data
	.globl	gFtlInitStatus
	.p2align	2
gFtlInitStatus:
	.word	4294967295                      // 0xffffffff
	.size	gFtlInitStatus, 4

	.type	.L.str,@object                  // @.str
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str:
	.asciz	"\n%s\n"
	.size	.L.str, 5

	.type	.L.str.1,@object                // @.str.1
.L.str.1:
	.asciz	"SFTL version: 5.0.59 20221121"
	.size	.L.str.1, 30

	.type	.L.str.2,@object                // @.str.2
.L.str.2:
	.asciz	"act blk: %x %x %x %x %x %x\n"
	.size	.L.str.2, 28

	.type	g_active_superblock,@object     // @g_active_superblock
	.bss
	.globl	g_active_superblock
	.p2align	2
g_active_superblock:
	.zero	48
	.size	g_active_superblock, 48

	.type	p_valid_page_count_table,@object // @p_valid_page_count_table
	.globl	p_valid_page_count_table
	.p2align	3
p_valid_page_count_table:
	.xword	0
	.size	p_valid_page_count_table, 8

	.type	.L.str.3,@object                // @.str.3
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.3:
	.asciz	"buf blk: %x %x %x %x %x %x\n"
	.size	.L.str.3, 28

	.type	g_buffer_superblock,@object     // @g_buffer_superblock
	.bss
	.globl	g_buffer_superblock
	.p2align	2
g_buffer_superblock:
	.zero	48
	.size	g_buffer_superblock, 48

	.type	.L.str.4,@object                // @.str.4
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.4:
	.asciz	"tmp blk: %x %x %x %x %x %x\n"
	.size	.L.str.4, 28

	.type	g_gc_temp_superblock,@object    // @g_gc_temp_superblock
	.bss
	.globl	g_gc_temp_superblock
	.p2align	2
g_gc_temp_superblock:
	.zero	48
	.size	g_gc_temp_superblock, 48

	.type	.L.str.5,@object                // @.str.5
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.5:
	.asciz	"gc blk: %x %x %x %x %x %x\n"
	.size	.L.str.5, 27

	.type	g_gc_superblock,@object         // @g_gc_superblock
	.bss
	.globl	g_gc_superblock
	.p2align	2
g_gc_superblock:
	.zero	48
	.size	g_gc_superblock, 48

	.type	.L.str.6,@object                // @.str.6
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.6:
	.asciz	"free blk: %x %x %x\n"
	.size	.L.str.6, 20

	.type	g_num_free_superblocks,@object  // @g_num_free_superblocks
	.bss
	.globl	g_num_free_superblocks
	.p2align	2
g_num_free_superblocks:
	.hword	0                               // 0x0
	.size	g_num_free_superblocks, 2

	.type	g_gc_next_blk,@object           // @g_gc_next_blk
	.globl	g_gc_next_blk
	.p2align	2
g_gc_next_blk:
	.hword	0                               // 0x0
	.size	g_gc_next_blk, 2

	.type	g_gc_next_blk_1,@object         // @g_gc_next_blk_1
	.globl	g_gc_next_blk_1
	.p2align	2
g_gc_next_blk_1:
	.hword	0                               // 0x0
	.size	g_gc_next_blk_1, 2

	.type	.L.str.7,@object                // @.str.7
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.7:
	.asciz	"FLASH INFO:\n"
	.size	.L.str.7, 13

	.type	.L.str.8,@object                // @.str.8
.L.str.8:
	.asciz	"Device Capacity: %d MB\n"
	.size	.L.str.8, 24

	.type	DeviceCapacity,@object          // @DeviceCapacity
	.bss
	.globl	DeviceCapacity
	.p2align	2
DeviceCapacity:
	.word	0                               // 0x0
	.size	DeviceCapacity, 4

	.type	.L.str.9,@object                // @.str.9
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.9:
	.asciz	"FTL INFO:\n"
	.size	.L.str.9, 11

	.type	.L.str.10,@object               // @.str.10
.L.str.10:
	.asciz	"g_MaxLpn = 0x%x\n"
	.size	.L.str.10, 17

	.type	g_MaxLpn,@object                // @g_MaxLpn
	.bss
	.globl	g_MaxLpn
	.p2align	2
g_MaxLpn:
	.word	0                               // 0x0
	.size	g_MaxLpn, 4

	.type	.L.str.11,@object               // @.str.11
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.11:
	.asciz	"g_VaildLpn = 0x%x\n"
	.size	.L.str.11, 19

	.type	g_VaildLpn,@object              // @g_VaildLpn
	.bss
	.globl	g_VaildLpn
	.p2align	2
g_VaildLpn:
	.word	0                               // 0x0
	.size	g_VaildLpn, 4

	.type	.L.str.12,@object               // @.str.12
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.12:
	.asciz	"read_page_count = 0x%x\n"
	.size	.L.str.12, 24

	.type	g_totle_read_page_count,@object // @g_totle_read_page_count
	.bss
	.globl	g_totle_read_page_count
	.p2align	2
g_totle_read_page_count:
	.word	0                               // 0x0
	.size	g_totle_read_page_count, 4

	.type	.L.str.13,@object               // @.str.13
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.13:
	.asciz	"discard_page_count = 0x%x\n"
	.size	.L.str.13, 27

	.type	g_totle_discard_page_count,@object // @g_totle_discard_page_count
	.bss
	.globl	g_totle_discard_page_count
	.p2align	2
g_totle_discard_page_count:
	.word	0                               // 0x0
	.size	g_totle_discard_page_count, 4

	.type	.L.str.14,@object               // @.str.14
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.14:
	.asciz	"write_page_count = 0x%x\n"
	.size	.L.str.14, 25

	.type	g_totle_write_page_count,@object // @g_totle_write_page_count
	.bss
	.globl	g_totle_write_page_count
	.p2align	2
g_totle_write_page_count:
	.word	0                               // 0x0
	.size	g_totle_write_page_count, 4

	.type	.L.str.15,@object               // @.str.15
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.15:
	.asciz	"cache_write_count = 0x%x\n"
	.size	.L.str.15, 26

	.type	g_totle_cache_write_count,@object // @g_totle_cache_write_count
	.bss
	.globl	g_totle_cache_write_count
	.p2align	2
g_totle_cache_write_count:
	.word	0                               // 0x0
	.size	g_totle_cache_write_count, 4

	.type	.L.str.16,@object               // @.str.16
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.16:
	.asciz	"l2p_write_count = 0x%x\n"
	.size	.L.str.16, 24

	.type	g_totle_l2p_write_count,@object // @g_totle_l2p_write_count
	.bss
	.globl	g_totle_l2p_write_count
	.p2align	2
g_totle_l2p_write_count:
	.word	0                               // 0x0
	.size	g_totle_l2p_write_count, 4

	.type	.L.str.17,@object               // @.str.17
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.17:
	.asciz	"gc_page_count = 0x%x\n"
	.size	.L.str.17, 22

	.type	g_totle_gc_page_count,@object   // @g_totle_gc_page_count
	.bss
	.globl	g_totle_gc_page_count
	.p2align	2
g_totle_gc_page_count:
	.word	0                               // 0x0
	.size	g_totle_gc_page_count, 4

	.type	.L.str.18,@object               // @.str.18
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.18:
	.asciz	"totle_write = %d MB\n"
	.size	.L.str.18, 21

	.type	g_totle_write_sector,@object    // @g_totle_write_sector
	.bss
	.globl	g_totle_write_sector
	.p2align	2
g_totle_write_sector:
	.word	0                               // 0x0
	.size	g_totle_write_sector, 4

	.type	.L.str.19,@object               // @.str.19
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.19:
	.asciz	"totle_read = %d MB\n"
	.size	.L.str.19, 20

	.type	g_totle_read_sector,@object     // @g_totle_read_sector
	.bss
	.globl	g_totle_read_sector
	.p2align	2
g_totle_read_sector:
	.word	0                               // 0x0
	.size	g_totle_read_sector, 4

	.type	.L.str.20,@object               // @.str.20
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.20:
	.asciz	"GSV = 0x%x\n"
	.size	.L.str.20, 12

	.type	g_GlobalSysVersion,@object      // @g_GlobalSysVersion
	.bss
	.globl	g_GlobalSysVersion
	.p2align	2
g_GlobalSysVersion:
	.word	0                               // 0x0
	.size	g_GlobalSysVersion, 4

	.type	.L.str.21,@object               // @.str.21
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.21:
	.asciz	"GDV = 0x%x\n"
	.size	.L.str.21, 12

	.type	g_GlobalDataVersion,@object     // @g_GlobalDataVersion
	.bss
	.globl	g_GlobalDataVersion
	.p2align	2
g_GlobalDataVersion:
	.word	0                               // 0x0
	.size	g_GlobalDataVersion, 4

	.type	.L.str.22,@object               // @.str.22
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.22:
	.asciz	"bad blk num = %d\n"
	.size	.L.str.22, 18

	.type	gBbtInfo,@object                // @gBbtInfo
	.bss
	.globl	gBbtInfo
	.p2align	3
gBbtInfo:
	.zero	96
	.size	gBbtInfo, 96

	.type	.L.str.23,@object               // @.str.23
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.23:
	.asciz	"free_superblocks = 0x%x\n"
	.size	.L.str.23, 25

	.type	.L.str.24,@object               // @.str.24
.L.str.24:
	.asciz	"mlc_EC = 0x%x\n"
	.size	.L.str.24, 15

	.type	g_totle_mlc_erase_count,@object // @g_totle_mlc_erase_count
	.bss
	.globl	g_totle_mlc_erase_count
	.p2align	2
g_totle_mlc_erase_count:
	.word	0                               // 0x0
	.size	g_totle_mlc_erase_count, 4

	.type	.L.str.25,@object               // @.str.25
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.25:
	.asciz	"slc_EC = 0x%x\n"
	.size	.L.str.25, 15

	.type	g_totle_slc_erase_count,@object // @g_totle_slc_erase_count
	.bss
	.globl	g_totle_slc_erase_count
	.p2align	2
g_totle_slc_erase_count:
	.word	0                               // 0x0
	.size	g_totle_slc_erase_count, 4

	.type	.L.str.26,@object               // @.str.26
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.26:
	.asciz	"avg_EC = 0x%x\n"
	.size	.L.str.26, 15

	.type	g_totle_avg_erase_count,@object // @g_totle_avg_erase_count
	.bss
	.globl	g_totle_avg_erase_count
	.p2align	2
g_totle_avg_erase_count:
	.word	0                               // 0x0
	.size	g_totle_avg_erase_count, 4

	.type	.L.str.27,@object               // @.str.27
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.27:
	.asciz	"sys_EC = 0x%x\n"
	.size	.L.str.27, 15

	.type	g_totle_sys_slc_erase_count,@object // @g_totle_sys_slc_erase_count
	.bss
	.globl	g_totle_sys_slc_erase_count
	.p2align	2
g_totle_sys_slc_erase_count:
	.word	0                               // 0x0
	.size	g_totle_sys_slc_erase_count, 4

	.type	.L.str.28,@object               // @.str.28
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.28:
	.asciz	"max_EC = 0x%x\n"
	.size	.L.str.28, 15

	.type	g_max_erase_count,@object       // @g_max_erase_count
	.bss
	.globl	g_max_erase_count
	.p2align	2
g_max_erase_count:
	.word	0                               // 0x0
	.size	g_max_erase_count, 4

	.type	.L.str.29,@object               // @.str.29
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.29:
	.asciz	"min_EC = 0x%x\n"
	.size	.L.str.29, 15

	.type	g_min_erase_count,@object       // @g_min_erase_count
	.bss
	.globl	g_min_erase_count
	.p2align	2
g_min_erase_count:
	.word	0                               // 0x0
	.size	g_min_erase_count, 4

	.type	.L.str.30,@object               // @.str.30
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.30:
	.asciz	"PLT = 0x%x\n"
	.size	.L.str.30, 12

	.type	g_sys_save_data,@object         // @g_sys_save_data
	.bss
	.globl	g_sys_save_data
	.p2align	2
g_sys_save_data:
	.zero	48
	.size	g_sys_save_data, 48

	.type	.L.str.31,@object               // @.str.31
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.31:
	.asciz	"POT = 0x%x\n"
	.size	.L.str.31, 12

	.type	.L.str.32,@object               // @.str.32
.L.str.32:
	.asciz	"MaxSector = 0x%x\n"
	.size	.L.str.32, 18

	.type	g_MaxLbaSector,@object          // @g_MaxLbaSector
	.bss
	.globl	g_MaxLbaSector
	.p2align	2
g_MaxLbaSector:
	.word	0                               // 0x0
	.size	g_MaxLbaSector, 4

	.type	.L.str.33,@object               // @.str.33
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.33:
	.asciz	"init_sys_blks_pp = 0x%x\n"
	.size	.L.str.33, 25

	.type	c_ftl_nand_init_sys_blks_per_plane,@object // @c_ftl_nand_init_sys_blks_per_plane
	.bss
	.globl	c_ftl_nand_init_sys_blks_per_plane
	.p2align	2
c_ftl_nand_init_sys_blks_per_plane:
	.word	0                               // 0x0
	.size	c_ftl_nand_init_sys_blks_per_plane, 4

	.type	.L.str.34,@object               // @.str.34
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.34:
	.asciz	"sys_blks_pp = 0x%x\n"
	.size	.L.str.34, 20

	.type	c_ftl_nand_sys_blks_per_plane,@object // @c_ftl_nand_sys_blks_per_plane
	.bss
	.globl	c_ftl_nand_sys_blks_per_plane
	.p2align	2
c_ftl_nand_sys_blks_per_plane:
	.word	0                               // 0x0
	.size	c_ftl_nand_sys_blks_per_plane, 4

	.type	.L.str.35,@object               // @.str.35
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.35:
	.asciz	"free sysblock = 0x%x\n"
	.size	.L.str.35, 22

	.type	gSysFreeQueue,@object           // @gSysFreeQueue
	.bss
	.globl	gSysFreeQueue
	.p2align	2
gSysFreeQueue:
	.zero	2056
	.size	gSysFreeQueue, 2056

	.type	.L.str.36,@object               // @.str.36
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.36:
	.asciz	"data_blks_pp = 0x%x\n"
	.size	.L.str.36, 21

	.type	c_ftl_nand_data_blks_per_plane,@object // @c_ftl_nand_data_blks_per_plane
	.bss
	.globl	c_ftl_nand_data_blks_per_plane
	.p2align	2
c_ftl_nand_data_blks_per_plane:
	.hword	0                               // 0x0
	.size	c_ftl_nand_data_blks_per_plane, 2

	.type	.L.str.37,@object               // @.str.37
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.37:
	.asciz	"data_op_blks_pp = 0x%x\n"
	.size	.L.str.37, 24

	.type	c_ftl_nand_data_op_blks_per_plane,@object // @c_ftl_nand_data_op_blks_per_plane
	.bss
	.globl	c_ftl_nand_data_op_blks_per_plane
	.p2align	2
c_ftl_nand_data_op_blks_per_plane:
	.hword	0                               // 0x0
	.size	c_ftl_nand_data_op_blks_per_plane, 2

	.type	.L.str.38,@object               // @.str.38
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.38:
	.asciz	"max_data_blks = 0x%x\n"
	.size	.L.str.38, 22

	.type	c_ftl_nand_max_data_blks,@object // @c_ftl_nand_max_data_blks
	.bss
	.globl	c_ftl_nand_max_data_blks
	.p2align	2
c_ftl_nand_max_data_blks:
	.word	0                               // 0x0
	.size	c_ftl_nand_max_data_blks, 4

	.type	.L.str.39,@object               // @.str.39
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.39:
	.asciz	"Sys.id = 0x%x\n"
	.size	.L.str.39, 15

	.type	gSysInfo,@object                // @gSysInfo
	.bss
	.globl	gSysInfo
	.p2align	2
gSysInfo:
	.zero	16
	.size	gSysInfo, 16

	.type	.L.str.40,@object               // @.str.40
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.40:
	.asciz	"Bbt.id = 0x%x\n"
	.size	.L.str.40, 15

	.type	.L.str.41,@object               // @.str.41
.L.str.41:
	.asciz	"ACT.page = 0x%x\n"
	.size	.L.str.41, 17

	.type	.L.str.42,@object               // @.str.42
.L.str.42:
	.asciz	"ACT.plane = 0x%x\n"
	.size	.L.str.42, 18

	.type	.L.str.43,@object               // @.str.43
.L.str.43:
	.asciz	"ACT.id = 0x%x\n"
	.size	.L.str.43, 15

	.type	.L.str.44,@object               // @.str.44
.L.str.44:
	.asciz	"ACT.mode = 0x%x\n"
	.size	.L.str.44, 17

	.type	.L.str.45,@object               // @.str.45
.L.str.45:
	.asciz	"ACT.a_pages = 0x%x\n"
	.size	.L.str.45, 20

	.type	.L.str.46,@object               // @.str.46
.L.str.46:
	.asciz	"ACT VPC = 0x%x\n"
	.size	.L.str.46, 16

	.type	.L.str.47,@object               // @.str.47
.L.str.47:
	.asciz	"BUF.page = 0x%x\n"
	.size	.L.str.47, 17

	.type	.L.str.48,@object               // @.str.48
.L.str.48:
	.asciz	"BUF.plane = 0x%x\n"
	.size	.L.str.48, 18

	.type	.L.str.49,@object               // @.str.49
.L.str.49:
	.asciz	"BUF.id = 0x%x\n"
	.size	.L.str.49, 15

	.type	.L.str.50,@object               // @.str.50
.L.str.50:
	.asciz	"BUF.mode = 0x%x\n"
	.size	.L.str.50, 17

	.type	.L.str.51,@object               // @.str.51
.L.str.51:
	.asciz	"BUF.a_pages = 0x%x\n"
	.size	.L.str.51, 20

	.type	.L.str.52,@object               // @.str.52
.L.str.52:
	.asciz	"BUF VPC = 0x%x\n"
	.size	.L.str.52, 16

	.type	.L.str.53,@object               // @.str.53
.L.str.53:
	.asciz	"TMP.page = 0x%x\n"
	.size	.L.str.53, 17

	.type	.L.str.54,@object               // @.str.54
.L.str.54:
	.asciz	"TMP.plane = 0x%x\n"
	.size	.L.str.54, 18

	.type	.L.str.55,@object               // @.str.55
.L.str.55:
	.asciz	"TMP.id = 0x%x\n"
	.size	.L.str.55, 15

	.type	.L.str.56,@object               // @.str.56
.L.str.56:
	.asciz	"TMP.mode = 0x%x\n"
	.size	.L.str.56, 17

	.type	.L.str.57,@object               // @.str.57
.L.str.57:
	.asciz	"TMP.a_pages = 0x%x\n"
	.size	.L.str.57, 20

	.type	.L.str.58,@object               // @.str.58
.L.str.58:
	.asciz	"GC.page = 0x%x\n"
	.size	.L.str.58, 16

	.type	.L.str.59,@object               // @.str.59
.L.str.59:
	.asciz	"GC.plane = 0x%x\n"
	.size	.L.str.59, 17

	.type	.L.str.60,@object               // @.str.60
.L.str.60:
	.asciz	"GC.id = 0x%x\n"
	.size	.L.str.60, 14

	.type	.L.str.61,@object               // @.str.61
.L.str.61:
	.asciz	"GC.mode = 0x%x\n"
	.size	.L.str.61, 16

	.type	.L.str.62,@object               // @.str.62
.L.str.62:
	.asciz	"GC.a_pages = 0x%x\n"
	.size	.L.str.62, 19

	.type	.L.str.63,@object               // @.str.63
.L.str.63:
	.asciz	"WR_CHK = %x %x %x\n"
	.size	.L.str.63, 19

	.type	g_sys_ext_data,@object          // @g_sys_ext_data
	.bss
	.globl	g_sys_ext_data
	.p2align	2
g_sys_ext_data:
	.zero	512
	.size	g_sys_ext_data, 512

	.type	.L.str.64,@object               // @.str.64
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.64:
	.asciz	"Read Err Cnt = 0x%x\n"
	.size	.L.str.64, 21

	.type	.L.str.65,@object               // @.str.65
.L.str.65:
	.asciz	"Prog Err Cnt = 0x%x\n"
	.size	.L.str.65, 21

	.type	.L.str.66,@object               // @.str.66
.L.str.66:
	.asciz	"gc_free_blk_th= 0x%x\n"
	.size	.L.str.66, 22

	.type	g_gc_free_blk_threshold,@object // @g_gc_free_blk_threshold
	.bss
	.globl	g_gc_free_blk_threshold
	.p2align	2
g_gc_free_blk_threshold:
	.hword	0                               // 0x0
	.size	g_gc_free_blk_threshold, 2

	.type	.L.str.67,@object               // @.str.67
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.67:
	.asciz	"gc_merge_free_blk_th= 0x%x\n"
	.size	.L.str.67, 28

	.type	g_gc_merge_free_blk_threshold,@object // @g_gc_merge_free_blk_threshold
	.bss
	.globl	g_gc_merge_free_blk_threshold
	.p2align	2
g_gc_merge_free_blk_threshold:
	.hword	0                               // 0x0
	.size	g_gc_merge_free_blk_threshold, 2

	.type	.L.str.68,@object               // @.str.68
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.68:
	.asciz	"gc_skip_write_count= 0x%x\n"
	.size	.L.str.68, 27

	.type	g_gc_skip_write_count,@object   // @g_gc_skip_write_count
	.bss
	.globl	g_gc_skip_write_count
	.p2align	2
g_gc_skip_write_count:
	.word	0                               // 0x0
	.size	g_gc_skip_write_count, 4

	.type	.L.str.69,@object               // @.str.69
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.69:
	.asciz	"gc_blk_index= 0x%x\n"
	.size	.L.str.69, 20

	.type	g_gc_blk_index,@object          // @g_gc_blk_index
	.bss
	.globl	g_gc_blk_index
	.p2align	2
g_gc_blk_index:
	.hword	0                               // 0x0
	.size	g_gc_blk_index, 2

	.type	.L.str.70,@object               // @.str.70
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.70:
	.asciz	"free min EC= 0x%x\n"
	.size	.L.str.70, 19

	.type	.L.str.71,@object               // @.str.71
.L.str.71:
	.asciz	"free max EC= 0x%x\n"
	.size	.L.str.71, 19

	.type	.L.str.72,@object               // @.str.72
.L.str.72:
	.asciz	"GC__SB VPC = 0x%x\n"
	.size	.L.str.72, 19

	.type	.L.str.73,@object               // @.str.73
.L.str.73:
	.asciz	"%d. [0x%x]=0x%x 0x%x  0x%x\n"
	.size	.L.str.73, 28

	.type	p_data_block_list_table,@object // @p_data_block_list_table
	.bss
	.globl	p_data_block_list_table
	.p2align	3
p_data_block_list_table:
	.xword	0
	.size	p_data_block_list_table, 8

	.type	p_erase_count_table,@object     // @p_erase_count_table
	.globl	p_erase_count_table
	.p2align	3
p_erase_count_table:
	.xword	0
	.size	p_erase_count_table, 8

	.type	p_free_data_block_list_head,@object // @p_free_data_block_list_head
	.globl	p_free_data_block_list_head
	.p2align	3
p_free_data_block_list_head:
	.xword	0
	.size	p_free_data_block_list_head, 8

	.type	.L.str.74,@object               // @.str.74
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.74:
	.asciz	"free %d. [0x%x] 0x%x  0x%x\n"
	.size	.L.str.74, 28

	.type	.L.str.75,@object               // @.str.75
.L.str.75:
	.asciz	"%s\n"
	.size	.L.str.75, 4

	.type	c_ftl_nand_planes_num,@object   // @c_ftl_nand_planes_num
	.bss
	.globl	c_ftl_nand_planes_num
	.p2align	2
c_ftl_nand_planes_num:
	.hword	0                               // 0x0
	.size	c_ftl_nand_planes_num, 2

	.type	c_ftl_nand_max_sys_blks,@object // @c_ftl_nand_max_sys_blks
	.globl	c_ftl_nand_max_sys_blks
	.p2align	2
c_ftl_nand_max_sys_blks:
	.word	0                               // 0x0
	.size	c_ftl_nand_max_sys_blks, 4

	.type	c_ftl_nand_blk_pre_plane,@object // @c_ftl_nand_blk_pre_plane
	.globl	c_ftl_nand_blk_pre_plane
	.p2align	2
c_ftl_nand_blk_pre_plane:
	.hword	0                               // 0x0
	.size	c_ftl_nand_blk_pre_plane, 2

	.type	c_ftl_nand_totle_phy_blks,@object // @c_ftl_nand_totle_phy_blks
	.globl	c_ftl_nand_totle_phy_blks
	.p2align	2
c_ftl_nand_totle_phy_blks:
	.word	0                               // 0x0
	.size	c_ftl_nand_totle_phy_blks, 4

	.type	c_ftl_nand_type,@object         // @c_ftl_nand_type
	.globl	c_ftl_nand_type
	.p2align	2
c_ftl_nand_type:
	.hword	0                               // 0x0
	.size	c_ftl_nand_type, 2

	.type	c_ftl_nand_die_num,@object      // @c_ftl_nand_die_num
	.globl	c_ftl_nand_die_num
	.p2align	2
c_ftl_nand_die_num:
	.hword	0                               // 0x0
	.size	c_ftl_nand_die_num, 2

	.type	c_ftl_nand_planes_per_die,@object // @c_ftl_nand_planes_per_die
	.globl	c_ftl_nand_planes_per_die
	.p2align	2
c_ftl_nand_planes_per_die:
	.hword	0                               // 0x0
	.size	c_ftl_nand_planes_per_die, 2

	.type	c_ftl_nand_sec_pre_page,@object // @c_ftl_nand_sec_pre_page
	.globl	c_ftl_nand_sec_pre_page
	.p2align	2
c_ftl_nand_sec_pre_page:
	.hword	0                               // 0x0
	.size	c_ftl_nand_sec_pre_page, 2

	.type	p_plane_order_table,@object     // @p_plane_order_table
	.globl	p_plane_order_table
	.p2align	2
p_plane_order_table:
	.zero	32
	.size	p_plane_order_table, 32

	.type	c_mlc_erase_count_value,@object // @c_mlc_erase_count_value
	.globl	c_mlc_erase_count_value
	.p2align	2
c_mlc_erase_count_value:
	.hword	0                               // 0x0
	.size	c_mlc_erase_count_value, 2

	.type	c_ftl_nand_ext_blk_pre_plane,@object // @c_ftl_nand_ext_blk_pre_plane
	.globl	c_ftl_nand_ext_blk_pre_plane
	.p2align	2
c_ftl_nand_ext_blk_pre_plane:
	.hword	0                               // 0x0
	.size	c_ftl_nand_ext_blk_pre_plane, 2

	.type	c_ftl_vendor_part_size,@object  // @c_ftl_vendor_part_size
	.globl	c_ftl_vendor_part_size
	.p2align	2
c_ftl_vendor_part_size:
	.hword	0                               // 0x0
	.size	c_ftl_vendor_part_size, 2

	.type	c_ftl_nand_blks_per_die,@object // @c_ftl_nand_blks_per_die
	.globl	c_ftl_nand_blks_per_die
	.p2align	2
c_ftl_nand_blks_per_die:
	.hword	0                               // 0x0
	.size	c_ftl_nand_blks_per_die, 2

	.type	c_ftl_nand_blks_per_die_shift,@object // @c_ftl_nand_blks_per_die_shift
	.globl	c_ftl_nand_blks_per_die_shift
	.p2align	2
c_ftl_nand_blks_per_die_shift:
	.hword	0                               // 0x0
	.size	c_ftl_nand_blks_per_die_shift, 2

	.type	c_ftl_nand_page_pre_blk,@object // @c_ftl_nand_page_pre_blk
	.globl	c_ftl_nand_page_pre_blk
	.p2align	2
c_ftl_nand_page_pre_blk:
	.hword	0                               // 0x0
	.size	c_ftl_nand_page_pre_blk, 2

	.type	c_ftl_nand_page_pre_slc_blk,@object // @c_ftl_nand_page_pre_slc_blk
	.globl	c_ftl_nand_page_pre_slc_blk
	.p2align	2
c_ftl_nand_page_pre_slc_blk:
	.hword	0                               // 0x0
	.size	c_ftl_nand_page_pre_slc_blk, 2

	.type	c_ftl_nand_page_pre_super_blk,@object // @c_ftl_nand_page_pre_super_blk
	.globl	c_ftl_nand_page_pre_super_blk
	.p2align	2
c_ftl_nand_page_pre_super_blk:
	.hword	0                               // 0x0
	.size	c_ftl_nand_page_pre_super_blk, 2

	.type	c_ftl_nand_sec_pre_page_shift,@object // @c_ftl_nand_sec_pre_page_shift
	.globl	c_ftl_nand_sec_pre_page_shift
	.p2align	2
c_ftl_nand_sec_pre_page_shift:
	.hword	0                               // 0x0
	.size	c_ftl_nand_sec_pre_page_shift, 2

	.type	c_ftl_nand_byte_pre_page,@object // @c_ftl_nand_byte_pre_page
	.globl	c_ftl_nand_byte_pre_page
	.p2align	2
c_ftl_nand_byte_pre_page:
	.hword	0                               // 0x0
	.size	c_ftl_nand_byte_pre_page, 2

	.type	c_ftl_nand_byte_pre_oob,@object // @c_ftl_nand_byte_pre_oob
	.globl	c_ftl_nand_byte_pre_oob
	.p2align	2
c_ftl_nand_byte_pre_oob:
	.hword	0                               // 0x0
	.size	c_ftl_nand_byte_pre_oob, 2

	.type	c_ftl_nand_reserved_blks,@object // @c_ftl_nand_reserved_blks
	.globl	c_ftl_nand_reserved_blks
	.p2align	2
c_ftl_nand_reserved_blks:
	.hword	0                               // 0x0
	.size	c_ftl_nand_reserved_blks, 2

	.type	c_ftl_nand_max_vendor_blks,@object // @c_ftl_nand_max_vendor_blks
	.globl	c_ftl_nand_max_vendor_blks
	.p2align	2
c_ftl_nand_max_vendor_blks:
	.hword	0                               // 0x0
	.size	c_ftl_nand_max_vendor_blks, 2

	.type	c_ftl_nand_vendor_region_num,@object // @c_ftl_nand_vendor_region_num
	.globl	c_ftl_nand_vendor_region_num
	.p2align	2
c_ftl_nand_vendor_region_num:
	.hword	0                               // 0x0
	.size	c_ftl_nand_vendor_region_num, 2

	.type	c_ftl_nand_map_blks_per_plane,@object // @c_ftl_nand_map_blks_per_plane
	.globl	c_ftl_nand_map_blks_per_plane
	.p2align	2
c_ftl_nand_map_blks_per_plane:
	.hword	0                               // 0x0
	.size	c_ftl_nand_map_blks_per_plane, 2

	.type	c_ftl_nand_max_map_blks,@object // @c_ftl_nand_max_map_blks
	.globl	c_ftl_nand_max_map_blks
	.p2align	2
c_ftl_nand_max_map_blks:
	.word	0                               // 0x0
	.size	c_ftl_nand_max_map_blks, 4

	.type	c_ftl_nand_map_region_num,@object // @c_ftl_nand_map_region_num
	.globl	c_ftl_nand_map_region_num
	.p2align	2
c_ftl_nand_map_region_num:
	.hword	0                               // 0x0
	.size	c_ftl_nand_map_region_num, 2

	.type	c_ftl_nand_l2pmap_ram_region_num,@object // @c_ftl_nand_l2pmap_ram_region_num
	.globl	c_ftl_nand_l2pmap_ram_region_num
	.p2align	2
c_ftl_nand_l2pmap_ram_region_num:
	.hword	0                               // 0x0
	.size	c_ftl_nand_l2pmap_ram_region_num, 2

	.type	g_in_gc_progress,@object        // @g_in_gc_progress
	.globl	g_in_gc_progress
	.p2align	2
g_in_gc_progress:
	.word	0                               // 0x0
	.size	g_in_gc_progress, 4

	.type	g_in_swl_replace,@object        // @g_in_swl_replace
	.globl	g_in_swl_replace
	.p2align	2
g_in_swl_replace:
	.word	0                               // 0x0
	.size	g_in_swl_replace, 4

	.type	g_gc_head_data_block,@object    // @g_gc_head_data_block
	.globl	g_gc_head_data_block
	.p2align	2
g_gc_head_data_block:
	.word	0                               // 0x0
	.size	g_gc_head_data_block, 4

	.type	g_gc_head_data_block_count,@object // @g_gc_head_data_block_count
	.globl	g_gc_head_data_block_count
	.p2align	2
g_gc_head_data_block_count:
	.word	0                               // 0x0
	.size	g_gc_head_data_block_count, 4

	.type	g_cur_erase_blk,@object         // @g_cur_erase_blk
	.globl	g_cur_erase_blk
	.p2align	2
g_cur_erase_blk:
	.word	0                               // 0x0
	.size	g_cur_erase_blk, 4

	.type	g_gc_bad_block_temp_num,@object // @g_gc_bad_block_temp_num
	.globl	g_gc_bad_block_temp_num
	.p2align	2
g_gc_bad_block_temp_num:
	.hword	0                               // 0x0
	.size	g_gc_bad_block_temp_num, 2

	.type	g_gc_bad_block_gc_index,@object // @g_gc_bad_block_gc_index
	.globl	g_gc_bad_block_gc_index
	.p2align	2
g_gc_bad_block_gc_index:
	.hword	0                               // 0x0
	.size	g_gc_bad_block_gc_index, 2

	.type	p_gc_blk_tbl,@object            // @p_gc_blk_tbl
	.globl	p_gc_blk_tbl
	.p2align	3
p_gc_blk_tbl:
	.xword	0
	.size	p_gc_blk_tbl, 8

	.type	p_gc_page_info,@object          // @p_gc_page_info
	.globl	p_gc_page_info
	.p2align	3
p_gc_page_info:
	.xword	0
	.size	p_gc_page_info, 8

	.type	req_read,@object                // @req_read
	.globl	req_read
	.p2align	3
req_read:
	.xword	0
	.size	req_read, 8

	.type	req_gc_dst,@object              // @req_gc_dst
	.globl	req_gc_dst
	.p2align	3
req_gc_dst:
	.xword	0
	.size	req_gc_dst, 8

	.type	req_prgm,@object                // @req_prgm
	.globl	req_prgm
	.p2align	3
req_prgm:
	.xword	0
	.size	req_prgm, 8

	.type	req_erase,@object               // @req_erase
	.globl	req_erase
	.p2align	3
req_erase:
	.xword	0
	.size	req_erase, 8

	.type	req_gc,@object                  // @req_gc
	.globl	req_gc
	.p2align	3
req_gc:
	.xword	0
	.size	req_gc, 8

	.type	c_gc_page_buf_num,@object       // @c_gc_page_buf_num
	.globl	c_gc_page_buf_num
	.p2align	2
c_gc_page_buf_num:
	.word	0                               // 0x0
	.size	c_gc_page_buf_num, 4

	.type	p_sys_data_buf,@object          // @p_sys_data_buf
	.globl	p_sys_data_buf
	.p2align	3
p_sys_data_buf:
	.xword	0
	.size	p_sys_data_buf, 8

	.type	p_sys_data_buf_1,@object        // @p_sys_data_buf_1
	.globl	p_sys_data_buf_1
	.p2align	3
p_sys_data_buf_1:
	.xword	0
	.size	p_sys_data_buf_1, 8

	.type	p_vendor_data_buf,@object       // @p_vendor_data_buf
	.globl	p_vendor_data_buf
	.p2align	3
p_vendor_data_buf:
	.xword	0
	.size	p_vendor_data_buf, 8

	.type	p_gc_data_buf,@object           // @p_gc_data_buf
	.globl	p_gc_data_buf
	.p2align	3
p_gc_data_buf:
	.xword	0
	.size	p_gc_data_buf, 8

	.type	p_io_data_buf_0,@object         // @p_io_data_buf_0
	.globl	p_io_data_buf_0
	.p2align	3
p_io_data_buf_0:
	.xword	0
	.size	p_io_data_buf_0, 8

	.type	p_io_data_buf_1,@object         // @p_io_data_buf_1
	.globl	p_io_data_buf_1
	.p2align	3
p_io_data_buf_1:
	.xword	0
	.size	p_io_data_buf_1, 8

	.type	gp_gc_page_buf_info,@object     // @gp_gc_page_buf_info
	.globl	gp_gc_page_buf_info
	.p2align	3
gp_gc_page_buf_info:
	.xword	0
	.size	gp_gc_page_buf_info, 8

	.type	sftl_nand_check_buf,@object     // @sftl_nand_check_buf
	.globl	sftl_nand_check_buf
	.p2align	3
sftl_nand_check_buf:
	.xword	0
	.size	sftl_nand_check_buf, 8

	.type	sftl_temp_buf,@object           // @sftl_temp_buf
	.globl	sftl_temp_buf
	.p2align	3
sftl_temp_buf:
	.xword	0
	.size	sftl_temp_buf, 8

	.type	sftl_nand_check_spare_buf,@object // @sftl_nand_check_spare_buf
	.globl	sftl_nand_check_spare_buf
	.p2align	3
sftl_nand_check_spare_buf:
	.xword	0
	.size	sftl_nand_check_spare_buf, 8

	.type	p_sys_spare_buf,@object         // @p_sys_spare_buf
	.globl	p_sys_spare_buf
	.p2align	3
p_sys_spare_buf:
	.xword	0
	.size	p_sys_spare_buf, 8

	.type	p_io_spare_buf,@object          // @p_io_spare_buf
	.globl	p_io_spare_buf
	.p2align	3
p_io_spare_buf:
	.xword	0
	.size	p_io_spare_buf, 8

	.type	p_gc_spare_buf,@object          // @p_gc_spare_buf
	.globl	p_gc_spare_buf
	.p2align	3
p_gc_spare_buf:
	.xword	0
	.size	p_gc_spare_buf, 8

	.type	g_ect_tbl_info_size,@object     // @g_ect_tbl_info_size
	.globl	g_ect_tbl_info_size
	.p2align	2
g_ect_tbl_info_size:
	.hword	0                               // 0x0
	.size	g_ect_tbl_info_size, 2

	.type	p_swl_mul_table,@object         // @p_swl_mul_table
	.globl	p_swl_mul_table
	.p2align	3
p_swl_mul_table:
	.xword	0
	.size	p_swl_mul_table, 8

	.type	gp_ect_tbl_info,@object         // @gp_ect_tbl_info
	.globl	gp_ect_tbl_info
	.p2align	3
gp_ect_tbl_info:
	.xword	0
	.size	gp_ect_tbl_info, 8

	.type	p_valid_page_count_check_table,@object // @p_valid_page_count_check_table
	.globl	p_valid_page_count_check_table
	.p2align	3
p_valid_page_count_check_table:
	.xword	0
	.size	p_valid_page_count_check_table, 8

	.type	p_map_block_table,@object       // @p_map_block_table
	.globl	p_map_block_table
	.p2align	3
p_map_block_table:
	.xword	0
	.size	p_map_block_table, 8

	.type	p_map_block_valid_page_count,@object // @p_map_block_valid_page_count
	.globl	p_map_block_valid_page_count
	.p2align	3
p_map_block_valid_page_count:
	.xword	0
	.size	p_map_block_valid_page_count, 8

	.type	p_vendor_block_table,@object    // @p_vendor_block_table
	.globl	p_vendor_block_table
	.p2align	3
p_vendor_block_table:
	.xword	0
	.size	p_vendor_block_table, 8

	.type	p_vendor_block_valid_page_count,@object // @p_vendor_block_valid_page_count
	.globl	p_vendor_block_valid_page_count
	.p2align	3
p_vendor_block_valid_page_count:
	.xword	0
	.size	p_vendor_block_valid_page_count, 8

	.type	p_vendor_block_ver_table,@object // @p_vendor_block_ver_table
	.globl	p_vendor_block_ver_table
	.p2align	3
p_vendor_block_ver_table:
	.xword	0
	.size	p_vendor_block_ver_table, 8

	.type	p_vendor_region_ppn_table,@object // @p_vendor_region_ppn_table
	.globl	p_vendor_region_ppn_table
	.p2align	3
p_vendor_region_ppn_table:
	.xword	0
	.size	p_vendor_region_ppn_table, 8

	.type	p_map_region_ppn_table,@object  // @p_map_region_ppn_table
	.globl	p_map_region_ppn_table
	.p2align	3
p_map_region_ppn_table:
	.xword	0
	.size	p_map_region_ppn_table, 8

	.type	p_map_block_ver_table,@object   // @p_map_block_ver_table
	.globl	p_map_block_ver_table
	.p2align	3
p_map_block_ver_table:
	.xword	0
	.size	p_map_block_ver_table, 8

	.type	p_l2p_ram_map,@object           // @p_l2p_ram_map
	.globl	p_l2p_ram_map
	.p2align	3
p_l2p_ram_map:
	.xword	0
	.size	p_l2p_ram_map, 8

	.type	p_l2p_map_buf,@object           // @p_l2p_map_buf
	.globl	p_l2p_map_buf
	.p2align	3
p_l2p_map_buf:
	.xword	0
	.size	p_l2p_map_buf, 8

	.type	c_ftl_nand_bbm_buf_size,@object // @c_ftl_nand_bbm_buf_size
	.globl	c_ftl_nand_bbm_buf_size
	.p2align	2
c_ftl_nand_bbm_buf_size:
	.hword	0                               // 0x0
	.size	c_ftl_nand_bbm_buf_size, 2

	.type	.L.str.76,@object               // @.str.76
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.76:
	.asciz	"%s error allocating memory. return -1\n"
	.size	.L.str.76, 39

	.type	.L__func__.FtlMemInit,@object   // @__func__.FtlMemInit
.L__func__.FtlMemInit:
	.asciz	"FtlMemInit"
	.size	.L__func__.FtlMemInit, 11

	.type	g_tmp_data_superblock_id,@object // @g_tmp_data_superblock_id
	.bss
	.globl	g_tmp_data_superblock_id
	.p2align	2
g_tmp_data_superblock_id:
	.hword	0                               // 0x0
	.size	g_tmp_data_superblock_id, 2

	.type	g_totle_swl_count,@object       // @g_totle_swl_count
	.globl	g_totle_swl_count
	.p2align	2
g_totle_swl_count:
	.word	0                               // 0x0
	.size	g_totle_swl_count, 4

	.type	ftl_gc_temp_power_lost_recovery_flag,@object // @ftl_gc_temp_power_lost_recovery_flag
	.globl	ftl_gc_temp_power_lost_recovery_flag
	.p2align	2
ftl_gc_temp_power_lost_recovery_flag:
	.word	0                               // 0x0
	.size	ftl_gc_temp_power_lost_recovery_flag, 4

	.type	g_recovery_page_min_ver,@object // @g_recovery_page_min_ver
	.globl	g_recovery_page_min_ver
	.p2align	2
g_recovery_page_min_ver:
	.word	0                               // 0x0
	.size	g_recovery_page_min_ver, 4

	.type	g_totle_vendor_block,@object    // @g_totle_vendor_block
	.globl	g_totle_vendor_block
	.p2align	2
g_totle_vendor_block:
	.hword	0                               // 0x0
	.size	g_totle_vendor_block, 2

	.type	g_MaxLbn,@object                // @g_MaxLbn
	.globl	g_MaxLbn
	.p2align	2
g_MaxLbn:
	.word	0                               // 0x0
	.size	g_MaxLbn, 4

	.type	g_nand_phy_info,@object         // @g_nand_phy_info
	.globl	g_nand_phy_info
	.p2align	1
g_nand_phy_info:
	.zero	24
	.size	g_nand_phy_info, 24

	.type	.L.str.77,@object               // @.str.77
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.77:
	.asciz	"FtlProgPages error %x = %d\n"
	.size	.L.str.77, 28

	.type	.L.str.78,@object               // @.str.78
.L.str.78:
	.asciz	"\n!!!!! error @ func:%s - line:%d\n"
	.size	.L.str.78, 34

	.type	.L__func__.FtlProgPages,@object // @__func__.FtlProgPages
.L__func__.FtlProgPages:
	.asciz	"FtlProgPages"
	.size	.L__func__.FtlProgPages, 13

	.type	.L.str.79,@object               // @.str.79
.L.str.79:
	.asciz	"Ftlwrite decrement_vpc_count %x = %d\n"
	.size	.L.str.79, 38

	.type	power_up_flag,@object           // @power_up_flag
	.data
	.globl	power_up_flag
	.p2align	2
power_up_flag:
	.word	1                               // 0x1
	.size	power_up_flag, 4

	.type	g_ftl_nand_free_count,@object   // @g_ftl_nand_free_count
	.bss
	.globl	g_ftl_nand_free_count
	.p2align	2
g_ftl_nand_free_count:
	.word	0                               // 0x0
	.size	g_ftl_nand_free_count, 4

	.type	.L__func__.FtlWrite,@object     // @__func__.FtlWrite
	.section	.rodata.str1.1,"aMS",@progbits,1
.L__func__.FtlWrite:
	.asciz	"FtlWrite"
	.size	.L__func__.FtlWrite, 9

	.type	.L.str.80,@object               // @.str.80
.L.str.80:
	.asciz	"FtlWrite: ecc error:%x %x %x\n"
	.size	.L.str.80, 30

	.type	.L.str.81,@object               // @.str.81
.L.str.81:
	.asciz	"FtlWrite: lpa error:%x %x\n"
	.size	.L.str.81, 27

	.type	gc_discard_updated,@object      // @gc_discard_updated
	.local	gc_discard_updated
	.comm	gc_discard_updated,4,4
	.type	.L.str.82,@object               // @.str.82
.L.str.82:
	.asciz	"phyBlk = 0x%x die = %d block_in_die = 0x%x 0x%8x\n"
	.size	.L.str.82, 50

	.type	.L__func__.FtlBbt2Bitmap,@object // @__func__.FtlBbt2Bitmap
.L__func__.FtlBbt2Bitmap:
	.asciz	"FtlBbt2Bitmap"
	.size	.L__func__.FtlBbt2Bitmap, 14

	.type	req_sys,@object                 // @req_sys
	.bss
	.globl	req_sys
	.p2align	3
req_sys:
	.zero	32
	.size	req_sys, 32

	.type	.L.str.83,@object               // @.str.83
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.83:
	.asciz	"FtlBbmTblFlush id=%x,page=%x,previd=%x cnt=%d\n"
	.size	.L.str.83, 47

	.type	.L.str.84,@object               // @.str.84
.L.str.84:
	.asciz	"FtlBbmTblFlush error:%x\n"
	.size	.L.str.84, 25

	.type	.L.str.85,@object               // @.str.85
.L.str.85:
	.asciz	"FtlBbmTblFlush error = %x error count = %d\n"
	.size	.L.str.85, 44

	.type	.L__func__.FtlLoadBbt,@object   // @__func__.FtlLoadBbt
.L__func__.FtlLoadBbt:
	.asciz	"FtlLoadBbt"
	.size	.L__func__.FtlLoadBbt, 11

	.type	.L.str.86,@object               // @.str.86
.L.str.86:
	.asciz	"FtlFreeSysBlkQueueOut = %x, free count = %d, error\n"
	.size	.L.str.86, 52

	.type	.L__func__.INSERT_FREE_LIST,@object // @__func__.INSERT_FREE_LIST
.L__func__.INSERT_FREE_LIST:
	.asciz	"INSERT_FREE_LIST"
	.size	.L__func__.INSERT_FREE_LIST, 17

	.type	g_num_data_superblocks,@object  // @g_num_data_superblocks
	.bss
	.globl	g_num_data_superblocks
	.p2align	2
g_num_data_superblocks:
	.hword	0                               // 0x0
	.size	g_num_data_superblocks, 2

	.type	.L__func__.INSERT_DATA_LIST,@object // @__func__.INSERT_DATA_LIST
	.section	.rodata.str1.1,"aMS",@progbits,1
.L__func__.INSERT_DATA_LIST:
	.asciz	"INSERT_DATA_LIST"
	.size	.L__func__.INSERT_DATA_LIST, 17

	.type	p_data_block_list_head,@object  // @p_data_block_list_head
	.bss
	.globl	p_data_block_list_head
	.p2align	3
p_data_block_list_head:
	.xword	0
	.size	p_data_block_list_head, 8

	.type	p_data_block_list_tail,@object  // @p_data_block_list_tail
	.globl	p_data_block_list_tail
	.p2align	3
p_data_block_list_tail:
	.xword	0
	.size	p_data_block_list_tail, 8

	.type	.L__func__.List_remove_node,@object // @__func__.List_remove_node
	.section	.rodata.str1.1,"aMS",@progbits,1
.L__func__.List_remove_node:
	.asciz	"List_remove_node"
	.size	.L__func__.List_remove_node, 17

	.type	.L__func__.List_update_data_list,@object // @__func__.List_update_data_list
.L__func__.List_update_data_list:
	.asciz	"List_update_data_list"
	.size	.L__func__.List_update_data_list, 22

	.type	.L__func__.load_l2p_region,@object // @__func__.load_l2p_region
.L__func__.load_l2p_region:
	.asciz	"load_l2p_region"
	.size	.L__func__.load_l2p_region, 16

	.type	.L.str.87,@object               // @.str.87
.L.str.87:
	.asciz	"region_id = %x phyAddr = %x\n"
	.size	.L.str.87, 29

	.type	.L.str.88,@object               // @.str.88
.L.str.88:
	.asciz	"spare:"
	.size	.L.str.88, 7

	.type	.L.str.89,@object               // @.str.89
.L.str.89:
	.asciz	"map_ppn:"
	.size	.L.str.89, 9

	.type	.L.str.90,@object               // @.str.90
.L.str.90:
	.asciz	"load_l2p_region refresh = %x phyAddr = %x\n"
	.size	.L.str.90, 43

	.type	gL2pMapInfo,@object             // @gL2pMapInfo
	.bss
	.globl	gL2pMapInfo
	.p2align	3
gL2pMapInfo:
	.zero	64
	.size	gL2pMapInfo, 64

	.type	.L__func__.ftl_map_blk_alloc_new_blk,@object // @__func__.ftl_map_blk_alloc_new_blk
	.section	.rodata.str1.1,"aMS",@progbits,1
.L__func__.ftl_map_blk_alloc_new_blk:
	.asciz	"ftl_map_blk_alloc_new_blk"
	.size	.L__func__.ftl_map_blk_alloc_new_blk, 26

	.type	.L__func__.ftl_map_blk_gc,@object // @__func__.ftl_map_blk_gc
.L__func__.ftl_map_blk_gc:
	.asciz	"ftl_map_blk_gc"
	.size	.L__func__.ftl_map_blk_gc, 15

	.type	.L__func__.Ftl_write_map_blk_to_last_page,@object // @__func__.Ftl_write_map_blk_to_last_page
.L__func__.Ftl_write_map_blk_to_last_page:
	.asciz	"Ftl_write_map_blk_to_last_page"
	.size	.L__func__.Ftl_write_map_blk_to_last_page, 31

	.type	.L__func__.FtlMapWritePage,@object // @__func__.FtlMapWritePage
.L__func__.FtlMapWritePage:
	.asciz	"FtlMapWritePage"
	.size	.L__func__.FtlMapWritePage, 16

	.type	.L.str.92,@object               // @.str.92
.L.str.92:
	.asciz	"FtlMapWritePage error = %x \n"
	.size	.L.str.92, 29

	.type	.L.str.93,@object               // @.str.93
.L.str.93:
	.asciz	"FtlMapWritePage error = %x error count = %d\n"
	.size	.L.str.93, 45

	.type	g_l2p_last_update_region_id,@object // @g_l2p_last_update_region_id
	.bss
	.globl	g_l2p_last_update_region_id
	.p2align	2
g_l2p_last_update_region_id:
	.hword	0                               // 0x0
	.size	g_l2p_last_update_region_id, 2

	.type	.L__func__.select_l2p_ram_region,@object // @__func__.select_l2p_ram_region
	.section	.rodata.str1.1,"aMS",@progbits,1
.L__func__.select_l2p_ram_region:
	.asciz	"select_l2p_ram_region"
	.size	.L__func__.select_l2p_ram_region, 22

	.type	.L__func__.log2phys,@object     // @__func__.log2phys
.L__func__.log2phys:
	.asciz	"log2phys"
	.size	.L__func__.log2phys, 9

	.type	gVendorBlkInfo,@object          // @gVendorBlkInfo
	.bss
	.globl	gVendorBlkInfo
	.p2align	3
gVendorBlkInfo:
	.zero	64
	.size	gVendorBlkInfo, 64

	.type	.L.str.94,@object               // @.str.94
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.94:
	.asciz	"FtlVendorPartRead refresh = %x phyAddr = %x\n"
	.size	.L.str.94, 45

	.type	g_ect_tbl_power_up_flush,@object // @g_ect_tbl_power_up_flush
	.bss
	.globl	g_ect_tbl_power_up_flush
	.p2align	2
g_ect_tbl_power_up_flush:
	.hword	0                               // 0x0
	.size	g_ect_tbl_power_up_flush, 2

	.type	FtlUpdateVaildLpnCount,@object  // @FtlUpdateVaildLpnCount
	.globl	FtlUpdateVaildLpnCount
	.p2align	2
FtlUpdateVaildLpnCount:
	.hword	0                               // 0x0
	.size	FtlUpdateVaildLpnCount, 2

	.type	.L__func__.FtlVpcTblFlush,@object // @__func__.FtlVpcTblFlush
	.section	.rodata.str1.1,"aMS",@progbits,1
.L__func__.FtlVpcTblFlush:
	.asciz	"FtlVpcTblFlush"
	.size	.L__func__.FtlVpcTblFlush, 15

	.type	.L.str.95,@object               // @.str.95
.L.str.95:
	.asciz	"FtlVpcTblFlush error = %x error count = %d\n"
	.size	.L.str.95, 44

	.type	g_totle_map_block,@object       // @g_totle_map_block
	.bss
	.globl	g_totle_map_block
	.p2align	2
g_totle_map_block:
	.hword	0                               // 0x0
	.size	g_totle_map_block, 2

	.type	.L__func__.FtlScanSysBlk,@object // @__func__.FtlScanSysBlk
	.section	.rodata.str1.1,"aMS",@progbits,1
.L__func__.FtlScanSysBlk:
	.asciz	"FtlScanSysBlk"
	.size	.L__func__.FtlScanSysBlk, 14

	.type	.L.str.96,@object               // @.str.96
.L.str.96:
	.asciz	"no ect"
	.size	.L.str.96, 7

	.type	.L.str.97,@object               // @.str.97
.L.str.97:
	.asciz	"%s hash error this.id =%x page =%x pre_id =%x hash =%x hash_r =%x\n"
	.size	.L.str.97, 67

	.type	.L__func__.FtlLoadSysInfo,@object // @__func__.FtlLoadSysInfo
.L__func__.FtlLoadSysInfo:
	.asciz	"FtlLoadSysInfo"
	.size	.L__func__.FtlLoadSysInfo, 15

	.type	.L.str.98,@object               // @.str.98
.L.str.98:
	.asciz	"%s last blk_id =%x page =%x hash error hash =%x hash_r =%x\n"
	.size	.L.str.98, 60

	.type	.L__func__.FtlMapTblRecovery,@object // @__func__.FtlMapTblRecovery
.L__func__.FtlMapTblRecovery:
	.asciz	"FtlMapTblRecovery"
	.size	.L__func__.FtlMapTblRecovery, 18

	.type	.L.str.99,@object               // @.str.99
.L.str.99:
	.asciz	"%s scan blk_id =%x page =%x hash error hash =%x hash_r =%x\n"
	.size	.L.str.99, 60

	.type	.L__func__.FtlReUsePrevPpa,@object // @__func__.FtlReUsePrevPpa
.L__func__.FtlReUsePrevPpa:
	.asciz	"FtlReUsePrevPpa"
	.size	.L__func__.FtlReUsePrevPpa, 16

	.type	.L__func__.FtlRecoverySuperblock,@object // @__func__.FtlRecoverySuperblock
.L__func__.FtlRecoverySuperblock:
	.asciz	"FtlRecoverySuperblock"
	.size	.L__func__.FtlRecoverySuperblock, 22

	.type	g_power_lost_recovery_flag,@object // @g_power_lost_recovery_flag
	.bss
	.globl	g_power_lost_recovery_flag
	.p2align	2
g_power_lost_recovery_flag:
	.hword	0                               // 0x0
	.size	g_power_lost_recovery_flag, 2

	.type	.L.str.100,@object              // @.str.100
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.100:
	.asciz	"data prev_ppa = %x error...................\n"
	.size	.L.str.100, 45

	.type	.L.str.101,@object              // @.str.101
.L.str.101:
	.asciz	"spuer block %x vpn is 0\n "
	.size	.L.str.101, 26

	.type	g_recovery_page_num,@object     // @g_recovery_page_num
	.bss
	.globl	g_recovery_page_num
	.p2align	2
g_recovery_page_num:
	.word	0                               // 0x0
	.size	g_recovery_page_num, 4

	.type	g_recovery_ppa_tbl,@object      // @g_recovery_ppa_tbl
	.globl	g_recovery_ppa_tbl
	.p2align	2
g_recovery_ppa_tbl:
	.zero	128
	.size	g_recovery_ppa_tbl, 128

	.type	.L__func__.make_superblock,@object // @__func__.make_superblock
	.section	.rodata.str1.1,"aMS",@progbits,1
.L__func__.make_superblock:
	.asciz	"make_superblock"
	.size	.L__func__.make_superblock, 16

	.type	.L__func__.SupperBlkListInit,@object // @__func__.SupperBlkListInit
.L__func__.SupperBlkListInit:
	.asciz	"SupperBlkListInit"
	.size	.L__func__.SupperBlkListInit, 18

	.type	.L.str.102,@object              // @.str.102
.L.str.102:
	.asciz	"...%s enter...\n"
	.size	.L.str.102, 16

	.type	.L__func__.FtlVpcCheckAndModify,@object // @__func__.FtlVpcCheckAndModify
.L__func__.FtlVpcCheckAndModify:
	.asciz	"FtlVpcCheckAndModify"
	.size	.L__func__.FtlVpcCheckAndModify, 21

	.type	.L.str.103,@object              // @.str.103
.L.str.103:
	.asciz	"FtlCheckVpc %x = %x  %x\n"
	.size	.L.str.103, 25

	.type	.L__func__.ftl_check_vpc,@object // @__func__.ftl_check_vpc
.L__func__.ftl_check_vpc:
	.asciz	"ftl_check_vpc"
	.size	.L__func__.ftl_check_vpc, 14

	.type	check_vpc_table,@object         // @check_vpc_table
	.bss
	.globl	check_vpc_table
	.p2align	1
check_vpc_table:
	.zero	16384
	.size	check_vpc_table, 16384

	.type	.L.str.104,@object              // @.str.104
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.104:
	.asciz	"FtlCheckVpc2 %x = %x  %x\n"
	.size	.L.str.104, 26

	.type	.L.str.105,@object              // @.str.105
.L.str.105:
	.asciz	"free blk vpc error %x = %x  %x\n"
	.size	.L.str.105, 32

	.type	.L.str.106,@object              // @.str.106
.L.str.106:
	.asciz	"ftl_scan_all_data = %x\n"
	.size	.L.str.106, 24

	.type	.L.str.107,@object              // @.str.107
.L.str.107:
	.asciz	"scan lpa = %x ppa= %x\n"
	.size	.L.str.107, 23

	.type	.L.str.108,@object              // @.str.108
.L.str.108:
	.asciz	"lpa = %x,addr= %x,spare= %x %x %x %x data=%x %x\n"
	.size	.L.str.108, 49

	.type	.L.str.109,@object              // @.str.109
.L.str.109:
	.asciz	"swblk %x ,avg = %x max= %x vpc= %x,ec=%x ,max ec=%x\n"
	.size	.L.str.109, 53

	.type	.L__func__.allocate_data_superblock,@object // @__func__.allocate_data_superblock
.L__func__.allocate_data_superblock:
	.asciz	"allocate_data_superblock"
	.size	.L__func__.allocate_data_superblock, 25

	.type	.L__func__.allocate_new_data_superblock,@object // @__func__.allocate_new_data_superblock
.L__func__.allocate_new_data_superblock:
	.asciz	"allocate_new_data_superblock"
	.size	.L__func__.allocate_new_data_superblock, 29

	.type	.L__func__.get_new_active_ppa,@object // @__func__.get_new_active_ppa
.L__func__.get_new_active_ppa:
	.asciz	"get_new_active_ppa"
	.size	.L__func__.get_new_active_ppa, 19

	.type	.L__func__.update_vpc_list,@object // @__func__.update_vpc_list
.L__func__.update_vpc_list:
	.asciz	"update_vpc_list"
	.size	.L__func__.update_vpc_list, 16

	.type	.L.str.110,@object              // @.str.110
.L.str.110:
	.asciz	"decrement_vpc_count %x = %d\n"
	.size	.L.str.110, 29

	.type	.L__func__.decrement_vpc_count,@object // @__func__.decrement_vpc_count
.L__func__.decrement_vpc_count:
	.asciz	"decrement_vpc_count"
	.size	.L__func__.decrement_vpc_count, 20

	.type	g_gc_num_req,@object            // @g_gc_num_req
	.bss
	.globl	g_gc_num_req
	.p2align	2
g_gc_num_req:
	.word	0                               // 0x0
	.size	g_gc_num_req, 4

	.type	g_gc_blk_num,@object            // @g_gc_blk_num
	.globl	g_gc_blk_num
	.p2align	2
g_gc_blk_num:
	.hword	0                               // 0x0
	.size	g_gc_blk_num, 2

	.type	g_gc_page_offset,@object        // @g_gc_page_offset
	.globl	g_gc_page_offset
	.p2align	2
g_gc_page_offset:
	.hword	0                               // 0x0
	.size	g_gc_page_offset, 2

	.type	ftl_gc_temp_block_bops_scan_page_addr,@object // @ftl_gc_temp_block_bops_scan_page_addr
	.data
	.p2align	2
ftl_gc_temp_block_bops_scan_page_addr:
	.hword	65535                           // 0xffff
	.size	ftl_gc_temp_block_bops_scan_page_addr, 2

	.type	.L__func__.FtlGcFreeTempBlock,@object // @__func__.FtlGcFreeTempBlock
	.section	.rodata.str1.1,"aMS",@progbits,1
.L__func__.FtlGcFreeTempBlock:
	.asciz	"FtlGcFreeTempBlock"
	.size	.L__func__.FtlGcFreeTempBlock, 19

	.type	.L.str.111,@object              // @.str.111
.L.str.111:
	.asciz	"FtlGcScanTempBlk Error ID %x %x!!!!!!! \n"
	.size	.L.str.111, 41

	.type	.L.str.112,@object              // @.str.112
.L.str.112:
	.asciz	"FtlGcRefreshBlock  0x%x\n"
	.size	.L.str.112, 25

	.type	.L.str.113,@object              // @.str.113
.L.str.113:
	.asciz	"FtlGcMarkBadPhyBlk %d 0x%x\n"
	.size	.L.str.113, 28

	.type	g_gc_bad_block_temp_tbl,@object // @g_gc_bad_block_temp_tbl
	.bss
	.globl	g_gc_bad_block_temp_tbl
	.p2align	1
g_gc_bad_block_temp_tbl:
	.zero	34
	.size	g_gc_bad_block_temp_tbl, 34

	.type	.L.str.114,@object              // @.str.114
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.114:
	.asciz	"FtlGcFreeBadSuperBlk 0x%x\n"
	.size	.L.str.114, 27

	.type	gc_ink_free_return_value,@object // @gc_ink_free_return_value
	.bss
	.globl	gc_ink_free_return_value
	.p2align	2
gc_ink_free_return_value:
	.hword	0                               // 0x0
	.size	gc_ink_free_return_value, 2

	.type	.L.str.115,@object              // @.str.115
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.115:
	.asciz	"SWL %x, FSB = %x vpc= %x,ec=%x th=%x\n"
	.size	.L.str.115, 38

	.type	g_gc_cur_blk_valid_pages,@object // @g_gc_cur_blk_valid_pages
	.bss
	.globl	g_gc_cur_blk_valid_pages
	.p2align	2
g_gc_cur_blk_valid_pages:
	.hword	0                               // 0x0
	.size	g_gc_cur_blk_valid_pages, 2

	.type	g_gc_cur_blk_max_valid_pages,@object // @g_gc_cur_blk_max_valid_pages
	.globl	g_gc_cur_blk_max_valid_pages
	.p2align	2
g_gc_cur_blk_max_valid_pages:
	.hword	0                               // 0x0
	.size	g_gc_cur_blk_max_valid_pages, 2

	.type	.L__func__.rk_ftl_garbage_collect,@object // @__func__.rk_ftl_garbage_collect
	.section	.rodata.str1.1,"aMS",@progbits,1
.L__func__.rk_ftl_garbage_collect:
	.asciz	"rk_ftl_garbage_collect"
	.size	.L__func__.rk_ftl_garbage_collect, 23

	.type	.L.str.116,@object              // @.str.116
.L.str.116:
	.asciz	"%s %p + 0x%x:"
	.size	.L.str.116, 14

	.type	.L.str.117,@object              // @.str.117
.L.str.117:
	.asciz	"0x%08x,"
	.size	.L.str.117, 8

	.type	.L.str.118,@object              // @.str.118
.L.str.118:
	.asciz	"0x%04x,"
	.size	.L.str.118, 8

	.type	.L.str.119,@object              // @.str.119
.L.str.119:
	.asciz	"0x%02x,"
	.size	.L.str.119, 8

	.type	.L.str.120,@object              // @.str.120
.L.str.120:
	.asciz	"\n"
	.size	.L.str.120, 2

	.type	.L__func__.FlashReadPages,@object // @__func__.FlashReadPages
.L__func__.FlashReadPages:
	.asciz	"FlashReadPages"
	.size	.L__func__.FlashReadPages, 15

	.type	g_nand_ops,@object              // @g_nand_ops
	.bss
	.globl	g_nand_ops
	.p2align	3
g_nand_ops:
	.zero	48
	.size	g_nand_ops, 48

	.type	.L.str.121,@object              // @.str.121
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.121:
	.asciz	"FlashReadPages %x %x error_ecc_bits %d\n"
	.size	.L.str.121, 40

	.type	.L.str.122,@object              // @.str.122
.L.str.122:
	.asciz	"data:"
	.size	.L.str.122, 6

	.type	.L__func__.FlashProgPages,@object // @__func__.FlashProgPages
.L__func__.FlashProgPages:
	.asciz	"FlashProgPages"
	.size	.L__func__.FlashProgPages, 15

	.type	.L.str.123,@object              // @.str.123
.L.str.123:
	.asciz	"%s: addr: %x is in id block!!!!!!!!!!\n"
	.size	.L.str.123, 39

	.type	.L.str.124,@object              // @.str.124
.L.str.124:
	.asciz	"not free: w: d:"
	.size	.L.str.124, 16

	.type	.L.str.125,@object              // @.str.125
.L.str.125:
	.asciz	"not free: w: s:"
	.size	.L.str.125, 16

	.type	.L.str.126,@object              // @.str.126
.L.str.126:
	.asciz	"prog read error: = %x\n"
	.size	.L.str.126, 23

	.type	.L.str.127,@object              // @.str.127
.L.str.127:
	.asciz	"prog read REFRESH: = %x\n"
	.size	.L.str.127, 25

	.type	.L.str.128,@object              // @.str.128
.L.str.128:
	.asciz	"prog read s error: = %x %x %x %x %x\n"
	.size	.L.str.128, 37

	.type	.L.str.129,@object              // @.str.129
.L.str.129:
	.asciz	"prog read d error: = %x %x %x %x %x\n"
	.size	.L.str.129, 37

	.type	.L__func__.FlashEraseBlocks,@object // @__func__.FlashEraseBlocks
.L__func__.FlashEraseBlocks:
	.asciz	"FlashEraseBlocks"
	.size	.L__func__.FlashEraseBlocks, 17

	.type	idb_need_write_back,@object     // @idb_need_write_back
	.local	idb_need_write_back
	.comm	idb_need_write_back,1,4
	.type	idb_buf,@object                 // @idb_buf
	.local	idb_buf
	.comm	idb_buf,8,8
	.type	gp_flash_check_buf,@object      // @gp_flash_check_buf
	.local	gp_flash_check_buf
	.comm	gp_flash_check_buf,8,8
	.type	.L.str.130,@object              // @.str.130
.L.str.130:
	.asciz	"%s idb buffer alloc fail\n"
	.size	.L.str.130, 26

	.type	.L__func__.FtlWriteToIDB,@object // @__func__.FtlWriteToIDB
.L__func__.FtlWriteToIDB:
	.asciz	"FtlWriteToIDB"
	.size	.L__func__.FtlWriteToIDB, 14

	.type	_flash_read,@object             // @_flash_read
	.local	_flash_read
	.comm	_flash_read,8,8
	.type	_flash_write,@object            // @_flash_write
	.local	_flash_write
	.comm	_flash_write,8,8
	.type	g_vendor,@object                // @g_vendor
	.local	g_vendor
	.comm	g_vendor,8,8
	.type	.L.str.131,@object              // @.str.131
.L.str.131:
	.asciz	"copy_from_user error %d %p %p\n"
	.size	.L.str.131, 31

	.type	rkflash_vender_storage_dev,@object // @rkflash_vender_storage_dev
	.data
	.p2align	3
rkflash_vender_storage_dev:
	.word	255                             // 0xff
	.zero	4
	.xword	.L.str.135
	.xword	rk_sftl_vendor_storage_fops
	.zero	16
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.hword	0                               // 0x0
	.zero	6
	.size	rkflash_vender_storage_dev, 80

	.type	gp_last_act_superblock,@object  // @gp_last_act_superblock
	.bss
	.globl	gp_last_act_superblock
	.p2align	3
gp_last_act_superblock:
	.xword	0
	.size	gp_last_act_superblock, 8

	.type	.L.str.132,@object              // @.str.132
	.section	.rodata.str1.1,"aMS",@progbits,1
.L.str.132:
	.asciz	"write_idblock %x %x\n"
	.size	.L.str.132, 21

	.type	.L.str.133,@object              // @.str.133
.L.str.133:
	.asciz	"write_idblock fail! %x %x %x %x\n"
	.size	.L.str.133, 33

	.type	.L.str.135,@object              // @.str.135
.L.str.135:
	.asciz	"vendor_storage"
	.size	.L.str.135, 15

	.type	rk_sftl_vendor_storage_fops,@object // @rk_sftl_vendor_storage_fops
	.section	.rodata,"a",@progbits
	.p2align	3
rk_sftl_vendor_storage_fops:
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	rk_sftl_vendor_storage_ioctl
	.xword	rk_sftl_vendor_storage_ioctl
	.xword	0
	.xword	0                               // 0x0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.xword	0
	.size	rk_sftl_vendor_storage_fops, 256

	.ident	"Android (7284624, based on r416183b) clang version 12.0.5 (https://android.googlesource.com/toolchain/llvm-project c935d99d7cf2016289302412d708641d52d2f7ee)"
	.section	".note.GNU-stack","",@progbits
	.addrsig
	.addrsig_sym rk_sftl_vendor_storage_ioctl
	.addrsig_sym g_active_superblock
	.addrsig_sym g_buffer_superblock
	.addrsig_sym g_gc_temp_superblock
	.addrsig_sym g_gc_superblock
	.addrsig_sym g_sys_ext_data
	.addrsig_sym p_free_data_block_list_head
	.addrsig_sym g_nand_phy_info
	.addrsig_sym req_sys
	.addrsig_sym gL2pMapInfo
	.addrsig_sym gVendorBlkInfo
	.addrsig_sym rkflash_vender_storage_dev
	.addrsig_sym rk_sftl_vendor_storage_fops
