Created
August 12, 2019 01:42
-
-
Save shuffle2/0be391dc80e30343ffa154d6dc43ecec to your computer and use it in GitHub Desktop.
lzra decompile
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| void LZRA_decompress(u8 *dest, u32 out_size, u8 *compress_data, u8 **next_ptr) { | |
| u8 *input; // r11@1 | |
| int v7; // r3@1 | |
| u8 v8; // r6@1 | |
| int v9; // r4@1 | |
| s32 v10; // lr@7 | |
| u8 *v11; // r12@7 | |
| u32 v12; // r9@7 | |
| s32 v13; // r3@7 | |
| u8 *v14; // r1@8 | |
| u32 v15; // r0@8 | |
| int v16; // r8@8 | |
| int v17; // r5@9 | |
| u32 v18; // r5@9 | |
| u32 v19; // r6@10 | |
| int v20; // r2@11 | |
| u32 v21; // r6@11 | |
| u8 *v22; // r2@16 | |
| int v23; // r0@17 | |
| u32 v24; // r2@17 | |
| s32 v25; // r8@19 | |
| u32 v26; // r10@19 | |
| int v27; // r2@19 | |
| u8 *v28; // r2@22 | |
| int v29; // r0@22 | |
| int v30; // r6@18 | |
| int v31; // r3@23 | |
| u32 v32; // r3@23 | |
| u32 v33; // r6@24 | |
| int v34; // r6@26 | |
| int v35; // r9@30 | |
| int v36; // lr@31 | |
| int v37; // r2@31 | |
| u32 v38; // r0@31 | |
| int v39; // r1@33 | |
| u32 v40; // r6@33 | |
| u32 v41; // r3@33 | |
| u32 v42; // r0@37 | |
| u32 v43; // r3@39 | |
| u32 v44; // r0@39 | |
| int v45; // r0@43 | |
| int v46; // r0@44 | |
| int v47; // r1@45 | |
| u32 v48; // r0@50 | |
| u32 v49; // r0@52 | |
| u32 v50; // r0@57 | |
| u32 v51; // r1@59 | |
| u32 v52; // r0@59 | |
| u32 v53; // r0@63 | |
| u32 v54; // r0@65 | |
| int v55; // r0@69 | |
| s32 v56; // r1@71 | |
| int v57; // lr@71 | |
| s32 v58; // r3@73 | |
| int v59; // r0@74 | |
| u32 v60; // r5@74 | |
| u32 v61; // r0@75 | |
| int v62; // r6@78 | |
| u32 v63; // r0@78 | |
| s32 v64; // r6@80 | |
| s32 v65; // r0@82 | |
| int v66; // r3@84 | |
| int v67; // r2@84 | |
| u32 v68; // r0@84 | |
| u32 v69; // lr@86 | |
| int v70; // r5@86 | |
| s32 v71; // r9@86 | |
| u32 v72; // r6@86 | |
| s32 v73; // r0@87 | |
| u32 v74; // r1@90 | |
| u32 v75; // r6@92 | |
| u32 v76; // r1@92 | |
| int v77; // r1@99 | |
| int v78; // r2@100 | |
| u32 v79; // r1@104 | |
| u32 v80; // r1@106 | |
| u32 v81; // r1@110 | |
| u32 v82; // r2@112 | |
| u32 v83; // r1@112 | |
| int v84; // r1@116 | |
| u32 v85; // r3@116 | |
| u32 v86; // r3@118 | |
| int v87; // r1@85 | |
| int v88; // r1@32 | |
| int v89; // r5@105 | |
| int v90; // r2@111 | |
| int v91; // r2@51 | |
| int v92; // r1@58 | |
| int v93; // r6@91 | |
| int v94; // r6@117 | |
| int v95; // r3@38 | |
| int v96; // r3@64 | |
| int v97; // r1@98 | |
| char v99; // [sp+20h] [bp-CD0h]@7 | |
| u8 *v100; // [sp+24h] [bp-CCCh]@7 | |
| u32 v101; // [sp+28h] [bp-CC8h]@7 | |
| u8 *v102; // [sp+2Ch] [bp-CC4h]@17 | |
| int v103; // [sp+34h] [bp-CBCh]@82 | |
| u8 dst[3240]; // [sp+38h] [bp-CB8h]@6 | |
| int v105; // [sp+CE0h] [bp-10h]@1 | |
| input = compress_data; | |
| v105 = dword_C2190000; | |
| v7 = compress_data[2]; | |
| v8 = *compress_data; | |
| v9 = _byteswap_ulong(*(u32 *)(compress_data + 1)); | |
| if (*compress_data & 0x80) { | |
| if (v9 <= out_size) { | |
| memcpy(dest, compress_data + 5, v9); | |
| if (next_ptr) | |
| *next_ptr = &input[v9 + 5]; | |
| } | |
| } else { | |
| memset(dst, -128 - (2 * v8 & 0x30), 0xCA8); | |
| if (out_size) { | |
| v10 = 0; | |
| v101 = (u32)&dest[out_size]; | |
| v99 = v8 & 7; | |
| v11 = dest; | |
| v12 = -1; | |
| v13 = 0; | |
| v100 = dest; | |
| do { | |
| v14 = dst; | |
| v15 = (v13 & 0xFFFFF8FF | (((u8)v11 & 7) << 8)) >> v99; | |
| v13 = 1; | |
| v16 = 255 * (v15 & 7) - 1; | |
| do { | |
| v20 = v16 + v13; | |
| v21 = *(&dst[v16] + v13); | |
| if (v12 >> 24) { | |
| v18 = v12; | |
| } else { | |
| v17 = (input++)[5]; | |
| v9 = v17 | (v9 << 8); | |
| v18 = v12 << 8; | |
| } | |
| v13 *= 2; | |
| v12 = (v18 >> 8) * v21; | |
| v19 = v21 - (v21 >> 3); | |
| if (v9 < v12) { | |
| v19 = v19 + 31; | |
| v13 |= 1u; | |
| } else { | |
| v9 -= v12; | |
| v12 = v18 - v12; | |
| } | |
| dst[v20] = v19; | |
| } while (v13 < 256); | |
| v22 = v11; | |
| while (1) { | |
| v23 = v10 + 2920; | |
| *v22 = v13; | |
| v11 = v22 + 1; | |
| v102 = v22; | |
| v24 = v14[v10 + 2920]; | |
| if (!(v12 >> 24)) { | |
| v30 = input[5]; | |
| v12 <<= 8; | |
| ++input; | |
| v9 = v30 | (v9 << 8); | |
| } | |
| v25 = 0; | |
| v26 = (v12 >> 8) * v24; | |
| v27 = v24 - (v24 >> 4); | |
| if (v9 < v26) | |
| v25 = 1; | |
| if (v9 >= v26) | |
| break; | |
| dst[v23] = v27 + 15; | |
| v28 = &dst[v10 + 2928]; | |
| v29 = 0; | |
| while (1) { | |
| v33 = v28[8 * v29]; | |
| if (v26 >> 24) { | |
| v32 = v26; | |
| } else { | |
| v31 = (input++)[5]; | |
| v9 = v31 | (v9 << 8); | |
| v32 = v26 << 8; | |
| } | |
| v26 = (v32 >> 8) * v33; | |
| v34 = v33 - (v33 >> 4); | |
| if (v9 >= v26) | |
| break; | |
| v28[8 * v29++] = v34 + 15; | |
| if (v29 == 7) | |
| goto LABEL_30; | |
| } | |
| v9 -= v26; | |
| v26 = v32 - v26; | |
| *(&dst[8 * v29 + 0xB70] + v10) = v34; | |
| LABEL_30: | |
| v35 = v29 - 1; | |
| if (v29 - 1 >= 0) { | |
| v36 = v10 & 7 | 32 * v35 | 8 * ((u32)v11 << v35) & 0x18; | |
| v37 = v36 + 2984; | |
| v38 = dst[v36 + 2984]; | |
| if (!(v26 >> 24)) { | |
| v88 = input[5]; | |
| v26 <<= 8; | |
| ++input; | |
| v9 = v88 | (v9 << 8); | |
| } | |
| v39 = v35 - 3; | |
| v40 = (v26 >> 8) * v38; | |
| v41 = v38 - (v38 >> 4); | |
| if (v9 >= v40) { | |
| v9 -= v40; | |
| v40 = v26 - v40; | |
| v25 = 2; | |
| } else { | |
| v41 = v41 + 15; | |
| v25 = 3; | |
| } | |
| dst[v37] = v41; | |
| if (v39 < 0) { | |
| v26 = v40; | |
| } else { | |
| if (v39 >= 1) { | |
| v42 = (u8)v41; | |
| if (!(v40 >> 24)) { | |
| v95 = input[5]; | |
| v40 <<= 8; | |
| ++input; | |
| v9 = v95 | (v9 << 8); | |
| } | |
| v25 *= 2; | |
| v43 = (v40 >> 8) * v42; | |
| v44 = v42 - (v42 >> 4); | |
| if (v9 >= v43) { | |
| v9 -= v43; | |
| v43 = v40 - v43; | |
| } else { | |
| v44 = v44 + 15; | |
| v25 |= 1u; | |
| } | |
| dst[v37] = v44; | |
| if (v39 != 1) { | |
| if (!(v43 >> 24)) { | |
| v45 = input[5]; | |
| v43 <<= 8; | |
| ++input; | |
| v9 = v45 | (v9 << 8); | |
| } | |
| v46 = 4 - v35; | |
| do { | |
| v47 = 2 * v25 | 1; | |
| if (v9 >= v43 >> 1) { | |
| v47 = 2 * v25; | |
| v9 -= v43 >> 1; | |
| } | |
| ++v46; | |
| v43 >>= 1; | |
| v25 = v47; | |
| } while (v46); | |
| v25 = v47; | |
| } | |
| v40 = v43; | |
| } | |
| v48 = dst[v36 + 3008]; | |
| if (!(v40 >> 24)) { | |
| v91 = input[5]; | |
| v40 <<= 8; | |
| ++input; | |
| v9 = v91 | (v9 << 8); | |
| } | |
| v25 *= 2; | |
| v26 = (v40 >> 8) * v48; | |
| v49 = v48 - (v48 >> 4); | |
| if (v9 >= v26) { | |
| v9 -= v26; | |
| v26 = v40 - v26; | |
| } else { | |
| v49 = v49 + 15; | |
| v25 |= 1u; | |
| } | |
| dst[v36 + 3008] = v49; | |
| } | |
| if (v35 >= 1) { | |
| v50 = dst[v36 + 2992]; | |
| if (!(v26 >> 24)) { | |
| v92 = input[5]; | |
| v26 <<= 8; | |
| ++input; | |
| v9 = v92 | (v9 << 8); | |
| } | |
| v25 *= 2; | |
| v51 = (v26 >> 8) * v50; | |
| v52 = v50 - (v50 >> 4); | |
| if (v9 >= v51) { | |
| v9 -= v51; | |
| v51 = v26 - v51; | |
| } else { | |
| v52 = v52 + 15; | |
| v25 |= 1u; | |
| } | |
| dst[v36 + 2992] = v52; | |
| if (v35 == 1) { | |
| v26 = v51; | |
| } else { | |
| v53 = dst[v36 + 3000]; | |
| if (!(v51 >> 24)) { | |
| v96 = input[5]; | |
| v51 <<= 8; | |
| ++input; | |
| v9 = v96 | (v9 << 8); | |
| } | |
| v25 *= 2; | |
| v26 = (v51 >> 8) * v53; | |
| v54 = v53 - (v53 >> 4); | |
| if (v9 >= v26) { | |
| v9 -= v26; | |
| v26 = v51 - v26; | |
| } else { | |
| v54 = v54 + 15; | |
| v25 |= 1u; | |
| } | |
| dst[v36 + 3000] = v54; | |
| } | |
| } | |
| if (v25 == 0xFF) { | |
| if (next_ptr) | |
| *next_ptr = input + 5; | |
| goto LABEL_144; | |
| } | |
| } | |
| v55 = v35; | |
| if (v25 < 3) | |
| v55 = v35 + 248; | |
| v56 = 256; | |
| v57 = v55 + 2033; | |
| if (v25 < 3) | |
| v56 = 64; | |
| v58 = 8; | |
| do { | |
| if (v26 >> 24) { | |
| v60 = v26; | |
| } else { | |
| v59 = input[5]; | |
| v60 = v26 << 8; | |
| ++input; | |
| v9 = v59 | (v9 << 8); | |
| } | |
| v62 = v57 + v58; | |
| v63 = *(&dst[v57] + v58); | |
| v58 *= 2; | |
| v26 = v63 * (v60 >> 8); | |
| v61 = v63 - (v63 >> 3); | |
| if (v9 < v26) { | |
| v58 += 8; | |
| v61 = v61 + 31; | |
| } else { | |
| v9 -= v26; | |
| v26 = v60 - v26; | |
| } | |
| dst[v62] = v61; | |
| v64 = v58 - v56; | |
| } while (v58 - v56 < 0); | |
| if (v58 == v56) { | |
| v12 = v26; | |
| } else { | |
| v65 = 0; | |
| v103 = (v64 >> 3) - 1; | |
| if (v25 > 2) | |
| v65 = 1; | |
| v66 = v35 & 7 | 32 * ((v64 >> 3) - 1) | 8 * (v65 << ((v64 >> 3) - 1)) & 0x18; | |
| v67 = v66 + 2344; | |
| v68 = dst[v66 + 2344]; | |
| if (!(v26 >> 24)) { | |
| v87 = input[5]; | |
| v26 <<= 8; | |
| ++input; | |
| v9 = v87 | (v9 << 8); | |
| } | |
| v69 = (v26 >> 8) * v68; | |
| v70 = (v64 >> 3) - 4; | |
| v71 = v64 >> 3; | |
| v72 = v68 - (v68 >> 4); | |
| if (v9 >= v69) { | |
| v9 -= v69; | |
| v69 = v26 - v69; | |
| v73 = 2; | |
| } else { | |
| v72 = v72 + 15; | |
| v73 = 3; | |
| } | |
| dst[v67] = v72; | |
| if (v70 < 0) { | |
| v12 = v69; | |
| } else { | |
| if (v70 >= 1) { | |
| v74 = (u8)v72; | |
| if (!(v69 >> 24)) { | |
| v93 = input[5]; | |
| v69 <<= 8; | |
| ++input; | |
| v9 = v93 | (v9 << 8); | |
| } | |
| v73 *= 2; | |
| v75 = v74 * (v69 >> 8); | |
| v76 = v74 - (v74 >> 4); | |
| if (v9 >= v75) { | |
| v9 -= v75; | |
| v75 = v69 - v75; | |
| } else { | |
| v76 = v76 + 15; | |
| v73 |= 1u; | |
| } | |
| dst[v67] = v76; | |
| if (v70 == 1) { | |
| v69 = v75; | |
| } else { | |
| if (!(v75 >> 24)) { | |
| v97 = input[5]; | |
| v75 <<= 8; | |
| ++input; | |
| v9 = v97 | (v9 << 8); | |
| } | |
| v77 = 5 - v71; | |
| do { | |
| v78 = 2 * v73 | 1; | |
| if (v9 >= v75 >> 1) { | |
| v78 = 2 * v73; | |
| v9 -= v75 >> 1; | |
| } | |
| ++v77; | |
| v75 >>= 1; | |
| v73 = v78; | |
| } while (v77); | |
| v69 = v75; | |
| v73 = v78; | |
| } | |
| } | |
| v79 = dst[v66 + 2368]; | |
| if (!(v69 >> 24)) { | |
| v89 = input[5]; | |
| v69 <<= 8; | |
| ++input; | |
| v9 = v89 | (v9 << 8); | |
| } | |
| v73 *= 2; | |
| v12 = (v69 >> 8) * v79; | |
| v80 = v79 - (v79 >> 4); | |
| if (v9 >= v12) { | |
| v9 -= v12; | |
| v12 = v69 - v12; | |
| } else { | |
| v80 = v80 + 15; | |
| v73 |= 1u; | |
| } | |
| dst[v66 + 2368] = v80; | |
| } | |
| if (v103 >= 1) { | |
| v81 = dst[v66 + 2352]; | |
| if (!(v12 >> 24)) { | |
| v90 = input[5]; | |
| v12 <<= 8; | |
| ++input; | |
| v9 = v90 | (v9 << 8); | |
| } | |
| v73 *= 2; | |
| v82 = v81 * (v12 >> 8); | |
| v83 = v81 - (v81 >> 4); | |
| if (v9 >= v82) { | |
| v9 -= v82; | |
| v82 = v12 - v82; | |
| } else { | |
| v83 = v83 + 15; | |
| v73 |= 1u; | |
| } | |
| dst[v66 + 2352] = v83; | |
| if (v103 == 1) { | |
| v12 = v82; | |
| } else { | |
| v84 = v66 + 2360; | |
| v85 = dst[v66 + 2360]; | |
| if (!(v82 >> 24)) { | |
| v94 = input[5]; | |
| v82 <<= 8; | |
| ++input; | |
| v9 = v94 | (v9 << 8); | |
| } | |
| v73 *= 2; | |
| v12 = (v82 >> 8) * v85; | |
| v86 = v85 - (v85 >> 4); | |
| if (v9 >= v12) { | |
| v9 -= v12; | |
| v12 = v82 - v12; | |
| } else { | |
| v86 = v86 + 15; | |
| v73 |= 1u; | |
| } | |
| dst[v84] = v86; | |
| } | |
| } | |
| v64 = v73 - 1; | |
| } | |
| if (v11 - v100 <= (u32)v64) | |
| goto LABEL_144; | |
| v22 = &v102[v25 + 1]; | |
| if ((u32)v22 >= v101) | |
| goto LABEL_144; | |
| v13 = v102[-v64]; | |
| do { | |
| *v11 = v13; | |
| --v25; | |
| v13 = (v11++)[-v64]; | |
| } while (v25); | |
| v10 = 7; | |
| v14 = dst; | |
| } | |
| --v10; | |
| dst[v23] = v27; | |
| if (v10 < 0) | |
| v10 = 0; | |
| v9 -= v26; | |
| v12 -= v26; | |
| } while (v11 != (u8 *)v101); | |
| } | |
| } | |
| LABEL_144: | |
| //JUMPOUT(dword_C2190000, v105, sub_C20006DE); | |
| return; | |
| } | |
| int main() { | |
| //... | |
| LZRA_decompress( | |
| (u8 *)decompress_dest, | |
| decompressed_size, | |
| &compress_data[4], | |
| &next); | |
| //... | |
| return 0; | |
| } |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment