├── requirements.txt ├── report-tiktok.py ├── ByteBuf.py ├── pkcs7_padding.py ├── TikTokAg.py ├── Simon.py ├── tiktok.py ├── Gorgon.py ├── Ladon.py ├── Argus.py ├── dictionary.py ├── Sm3.py ├── protobuf.py └── ttencrypt.py /requirements.txt: -------------------------------------------------------------------------------- 1 | requests 2 | ms4 3 | rich 4 | time 5 | random -------------------------------------------------------------------------------- /report-tiktok.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlmunharifHamoudi/report-tiktok/HEAD/report-tiktok.py -------------------------------------------------------------------------------- /ByteBuf.py: -------------------------------------------------------------------------------- 1 | from pkcs7_padding import pkcs7_padding_data_length 2 | import ctypes 3 | 4 | class ByteBuf: 5 | def __init__(self, data, size=None): 6 | if data: 7 | self.mem = data 8 | 9 | if size is not None: 10 | self.data_size = size 11 | elif data is not None: 12 | self.data_size = len(data) 13 | else: 14 | raise ValueError("Either size or data must be provided") 15 | 16 | self.pos = 0 17 | 18 | def data(self): 19 | return self.mem 20 | 21 | def size(self): 22 | return self.data_size 23 | 24 | def remove_padding(self): 25 | padding_size = pkcs7_padding_data_length(self.mem, self.data_size, 16) 26 | if padding_size == 0: 27 | return self.data_size 28 | self.data_size = padding_size 29 | dst = (ctypes.c_uint8 * self.data_size)() 30 | dst = self.mem[:self.data_size] 31 | self.mem = dst 32 | return self.mem -------------------------------------------------------------------------------- /pkcs7_padding.py: -------------------------------------------------------------------------------- 1 | def pkcs7_padding_data_length(buffer, buffer_size, modulus): 2 | if buffer_size % modulus != 0 or buffer_size < modulus: 3 | return 0 4 | padding_value = buffer[buffer_size-1] 5 | if padding_value < 1 or padding_value > modulus: 6 | return 0 7 | if buffer_size < padding_value + 1: 8 | return 0 9 | count = 1 10 | buffer_size -= 1 11 | for i in range(count, padding_value): 12 | buffer_size -= 1 13 | if buffer[buffer_size] != padding_value: 14 | return 0 15 | return buffer_size 16 | 17 | def pkcs7_padding_pad_buffer(buffer: bytearray, data_length: int, buffer_size: int, modulus: int) -> int: 18 | pad_byte = modulus - (data_length % modulus) 19 | if data_length + pad_byte > buffer_size: 20 | return -pad_byte 21 | for i in range(pad_byte): 22 | buffer[data_length+i] = pad_byte 23 | return pad_byte 24 | 25 | def padding_size(size: int) -> int: 26 | mod = size % 16 27 | if mod > 0: 28 | return size + (16 - mod) 29 | return size -------------------------------------------------------------------------------- /TikTokAg.py: -------------------------------------------------------------------------------- 1 | import random 2 | def UserAgent(): 3 | device_types = { 4 | "Samsung": ["Galaxy S23 Ultra", "Galaxy Z Fold 4", "Galaxy Note 20 Ultra"], 5 | "Google": ["Pixel 7 Pro", "Pixel 6a", "Pixel 5"], 6 | "OnePlus": ["10 Pro", "9", "8T"], 7 | "Xiaomi": ["12 Pro", "Mi 11", "Redmi Note 11 Pro"], 8 | "Huawei": ["P50 Pro", "Mate 50", "P40 Pro"], 9 | "Sony": ["Xperia 1 IV", "Xperia 10 IV", "Xperia 5 III"], 10 | "Oppo": ["Find X5 Pro", "Reno 7 Pro", "A96"], 11 | "Realme": ["GT 2 Pro", "9 Pro", "X7 Max"], 12 | "Nokia": ["X20", "G50", "8.3"] 13 | } 14 | 15 | brand = random.choice(list(device_types.keys())) 16 | device_type = random.choice(device_types[brand]) 17 | 18 | agent = ( 19 | f"com.zhiliaoapp.musically/2023105030 (Linux; U; Android 12; ar_YE;{device_type}; Build/{brand}{device_type}; Cronet/TTNetVersion:2fdb62f9 2023-09-06 QuicVersion:bb24d47c 2023-07-19)" 20 | ) 21 | 22 | return { 23 | 'type': device_type, 24 | 'brand': brand, 25 | 'User-Agent': agent 26 | } 27 | 28 | 29 | 30 | -------------------------------------------------------------------------------- /Simon.py: -------------------------------------------------------------------------------- 1 | from ctypes import c_ulonglong 2 | 3 | def get_bit(val, pos): 4 | return 1 if val & (1 << pos) else 0 5 | 6 | def rotate_left(v, n): 7 | r = (v << n) | (v >> (64 - n)) 8 | return r & 0xffffffffffffffff 9 | 10 | def rotate_right(v, n): 11 | r = (v << (64 - n)) | (v >> n) 12 | return r & 0xffffffffffffffff 13 | 14 | def key_expansion(key): 15 | tmp = 0 16 | for i in range(4, 72): 17 | tmp = rotate_right(key[i-1], 3) 18 | tmp = tmp ^ key[i-3] 19 | tmp = tmp ^ rotate_right(tmp, 1) 20 | key[i] = c_ulonglong(~key[i-4]).value ^ tmp ^ get_bit(0x3DC94C3A046D678B, (i - 4) % 62) ^ 3 21 | return key 22 | 23 | def simon_dec(ct, k, c=0): 24 | tmp = 0 25 | f = 0 26 | key = [0] * 72 27 | 28 | key[0] = k[0] 29 | key[1] = k[1] 30 | key[2] = k[2] 31 | key[3] = k[3] 32 | 33 | key = key_expansion(key) 34 | 35 | x_i = ct[0] 36 | x_i1 = ct[1] 37 | 38 | for i in range(72-1, -1, -1): 39 | tmp = x_i 40 | f = rotate_left(x_i, 1) if c == 1 else rotate_left(x_i, 1) & rotate_left(x_i, 8) 41 | x_i = x_i1 ^ f ^ rotate_left(x_i, 2) ^ key[i] 42 | x_i1 = tmp 43 | 44 | pt = [x_i, x_i1] 45 | return pt 46 | 47 | def simon_enc(pt, k, c=0): 48 | tmp = 0 49 | f = 0 50 | key = [0] * 72 51 | key[0] = k[0] 52 | key[1] = k[1] 53 | key[2] = k[2] 54 | key[3] = k[3] 55 | 56 | key = key_expansion(key) 57 | 58 | x_i = pt[0] 59 | x_i1 = pt[1] 60 | 61 | for i in range(72): 62 | tmp = x_i1 63 | f = rotate_left(x_i1, 1) if c == 1 else rotate_left(x_i1, 1) & rotate_left(x_i1, 8) 64 | x_i1 = x_i ^ f ^ rotate_left(x_i1, 2) ^ key[i] 65 | x_i = tmp 66 | 67 | ct = [x_i, x_i1] 68 | return ct 69 | 70 | -------------------------------------------------------------------------------- /tiktok.py: -------------------------------------------------------------------------------- 1 | from binascii import hexlify 2 | from random import randbytes 3 | from uuid import uuid4 4 | from ttencrypt import ttencrypt 5 | from json import dumps 6 | from requests import request 7 | def tt_encrypt(data) -> str: 8 | return ttencrypt().encrypt(dumps(data).replace(" ", "")) 9 | def device_register() -> dict: 10 | openudid = hexlify(randbytes(8)).decode() 11 | cdid = str(uuid4()) 12 | google_aid = str(uuid4()) 13 | clientudid = str(uuid4()) 14 | req_id = str(uuid4()) 15 | url = "https://log-va.tiktokv.com/service/2/device_register/?ac=wifi&channel=googleplay&aid=1233&app_name=musical_ly&version_code=170404&version_name=17.4.4&device_platform=android&ab_version=17.4.4&ssmix=a&device_type=SM-G611M&device_brand=samsung&language=en&os_api=28&os_version=9&openudid=" + openudid + "&manifest_version_code=2021704040&resolution=720*1280&dpi=320&update_version_code=2021704040&_rticket=1653464286478&_rticket=1653464286894&storage_type=2&app_type=normal&sys_region=US&appTheme=light&pass-route=1&pass-region=1&timezone_name=Europe%252FBerlin&cpu_support64=false&host_abi=armeabi-v7a&app_language=en&ac2=wifi&uoo=1&op_region=US&timezone_offset=3600&build_number=17.4.4&locale=en®ion=US&ts=1653464286&cdid=" + cdid 16 | 17 | payload = {"magic_tag":"ss_app_log","header":{"display_name":"TikTok","update_version_code":2021704040,"manifest_version_code":2021704040,"app_version_minor":"","aid":1233,"channel":"googleplay","package":"com.zhiliaoapp.musically","app_version":"17.4.4","version_code":170404,"sdk_version":"2.12.1-rc.5","sdk_target_version":29,"git_hash":"050d489d","os":"Android","os_version":"9","os_api":28,"device_model":"SM-G611M","device_brand":"samsung","device_manufacturer":"samsung","cpu_abi":"armeabi-v7a","release_build":"e1611c6_20200824","density_dpi":320,"display_density":"xhdpi","resolution":"1280x720","language":"en","timezone":1,"access":"wifi","not_request_sender":0,"mcc_mnc":"26203","rom":"G611MUBS6CTD1","rom_version":"PPR1.180610.011","cdid":cdid,"sig_hash":"e89b158e4bcf988ebd09eb83f5378e87","gaid_limited":0,"google_aid":google_aid,"openudid":openudid,"clientudid":clientudid,"region":"US","tz_name":"Europe\\/Berlin","tz_offset":7200,"oaid_may_support":False,"req_id":req_id,"apk_first_install_time":1653436407842,"is_system_app":0,"sdk_flavor":"global"},"_gen_time":1653464286461} 18 | 19 | headers = { 20 | "Host": "log-va.tiktokv.com", 21 | "accept-encoding": "gzip", 22 | "sdk-version": "2", 23 | "passport-sdk-version": "17", 24 | "content-type": "application/octet-stream", 25 | "user-agent": "okhttp/3.10.0.1" 26 | } 27 | response = request("POST", url, headers=headers, data=bytes.fromhex(tt_encrypt(payload))).json() 28 | try: 29 | install_id = response["install_id_str"] 30 | device_id = response["device_id_str"] 31 | return {"install_id":install_id,"device_id":device_id,"openudid":openudid,'cdid':cdid} 32 | except: 33 | pass 34 | 35 | -------------------------------------------------------------------------------- /Gorgon.py: -------------------------------------------------------------------------------- 1 | import hashlib 2 | import json 3 | import time 4 | class Gorgon: 5 | def __init__(self, params: str, unix: int, data: str = None, cookies: str = None) -> None: 6 | self.unix = unix 7 | self.params = params 8 | self.data = data 9 | self.cookies = cookies 10 | 11 | def hash(self, data: str) -> str: 12 | return str(hashlib.md5(data.encode()).hexdigest()) 13 | 14 | def get_base_string(self) -> str: 15 | base_str = self.hash(self.params) 16 | base_str = ( 17 | base_str + self.hash(self.data) if self.data else base_str + str("0" * 32) 18 | ) 19 | base_str = ( 20 | base_str + self.hash(self.cookies) 21 | if self.cookies 22 | else base_str + str("0" * 32) 23 | ) 24 | return base_str 25 | 26 | def get_value(self) -> json: 27 | return self.encrypt(self.get_base_string()) 28 | 29 | def encrypt(self, data: str) -> json: 30 | len = 0x14 31 | key = [ 32 | 0xDF, 33 | 0x77, 34 | 0xB9, 35 | 0x40, 36 | 0xB9, 37 | 0x9B, 38 | 0x84, 39 | 0x83, 40 | 0xD1, 41 | 0xB9, 42 | 0xCB, 43 | 0xD1, 44 | 0xF7, 45 | 0xC2, 46 | 0xB9, 47 | 0x85, 48 | 0xC3, 49 | 0xD0, 50 | 0xFB, 51 | 0xC3, 52 | ] 53 | param_list = [] 54 | for i in range(0, 12, 4): 55 | temp = data[8 * i : 8 * (i + 1)] 56 | for j in range(4): 57 | H = int(temp[j * 2 : (j + 1) * 2], 16) 58 | param_list.append(H) 59 | param_list.extend([0x0, 0x6, 0xB, 0x1C]) 60 | H = int(hex(int(self.unix)), 16) 61 | param_list.append((H & 0xFF000000) >> 24) 62 | param_list.append((H & 0x00FF0000) >> 16) 63 | param_list.append((H & 0x0000FF00) >> 8) 64 | param_list.append((H & 0x000000FF) >> 0) 65 | eor_result_list = [] 66 | for A, B in zip(param_list, key): 67 | eor_result_list.append(A ^ B) 68 | for i in range(len): 69 | C = self.reverse(eor_result_list[i]) 70 | D = eor_result_list[(i + 1) % len] 71 | E = C ^ D 72 | F = self.rbit_algorithm(E) 73 | H = ((F ^ 0xFFFFFFFF) ^ len) & 0xFF 74 | eor_result_list[i] = H 75 | result = "" 76 | 77 | for param in eor_result_list: 78 | result += self.hex_string(param) 79 | 80 | return { 81 | "x-ss-req-ticket": str(int(self.unix * 1000)), 82 | "x-khronos" : str(int(self.unix)), 83 | "x-gorgon" : f"0404b0d30000{result}" 84 | } 85 | 86 | def rbit_algorithm(self, num): 87 | result = "" 88 | tmp_string = bin(num)[2:] 89 | while len(tmp_string) < 8: 90 | tmp_string = "0" + tmp_string 91 | for i in range(0, 8): 92 | result = result + tmp_string[7 - i] 93 | return int(result, 2) 94 | 95 | def hex_string(self, num): 96 | tmp_string = hex(num)[2:] 97 | if len(tmp_string) < 2: 98 | tmp_string = "0" + tmp_string 99 | return tmp_string 100 | 101 | def reverse(self, num): 102 | tmp_string = self.hex_string(num) 103 | return int(tmp_string[1:] + tmp_string[:1], 16) -------------------------------------------------------------------------------- /Ladon.py: -------------------------------------------------------------------------------- 1 | from pkcs7_padding import pkcs7_padding_pad_buffer, padding_size 2 | import base64 3 | import hashlib 4 | import ctypes 5 | from os import urandom 6 | def md5bytes(data: bytes) -> str: 7 | m = hashlib.md5() 8 | m.update(data) 9 | return m.hexdigest() 10 | 11 | 12 | def get_type_data(ptr, index, data_type): 13 | if data_type == "uint64_t": 14 | return int.from_bytes(ptr[index * 8 : (index + 1) * 8], "little") 15 | else: 16 | raise ValueError("Invalid data type") 17 | 18 | 19 | def set_type_data(ptr, index, data, data_type): 20 | if data_type == "uint64_t": 21 | ptr[index * 8 : (index + 1) * 8] = data.to_bytes(8, "little") 22 | else: 23 | raise ValueError("Invalid data type") 24 | 25 | 26 | def validate(num): 27 | return num & 0xFFFFFFFFFFFFFFFF 28 | 29 | 30 | def __ROR__(value: ctypes.c_ulonglong, count: int) -> ctypes.c_ulonglong: 31 | nbits = ctypes.sizeof(value) * 8 32 | count %= nbits 33 | low = ctypes.c_ulonglong(value.value << (nbits - count)).value 34 | value = ctypes.c_ulonglong(value.value >> count).value 35 | value = value | low 36 | return value 37 | 38 | 39 | def encrypt_ladon_input(hash_table, input_data): 40 | data0 = int.from_bytes(input_data[:8], byteorder="little") 41 | data1 = int.from_bytes(input_data[8:], byteorder="little") 42 | 43 | for i in range(0x22): 44 | hash = int.from_bytes(hash_table[i * 8 : (i + 1) * 8], byteorder="little") 45 | data1 = validate(hash ^ (data0 + ((data1 >> 8) | (data1 << (64 - 8))))) 46 | data0 = validate(data1 ^ ((data0 >> 0x3D) | (data0 << (64 - 0x3D)))) 47 | 48 | output_data = bytearray(26) 49 | output_data[:8] = data0.to_bytes(8, byteorder="little") 50 | output_data[8:] = data1.to_bytes(8, byteorder="little") 51 | 52 | return bytes(output_data) 53 | 54 | 55 | def encrypt_ladon(md5hex: bytes, data: bytes, size: int): 56 | hash_table = bytearray(272 + 16) 57 | hash_table[:32] = md5hex 58 | 59 | temp = [] 60 | for i in range(4): 61 | temp.append(int.from_bytes(hash_table[i * 8 : (i + 1) * 8], byteorder="little")) 62 | 63 | buffer_b0 = temp[0] 64 | buffer_b8 = temp[1] 65 | temp.pop(0) 66 | temp.pop(0) 67 | 68 | for i in range(0, 0x22): 69 | x9 = buffer_b0 70 | x8 = buffer_b8 71 | x8 = validate(__ROR__(ctypes.c_ulonglong(x8), 8)) 72 | x8 = validate(x8 + x9) 73 | x8 = validate(x8 ^ i) 74 | temp.append(x8) 75 | x8 = validate(x8 ^ __ROR__(ctypes.c_ulonglong(x9), 61)) 76 | set_type_data(hash_table, i + 1, x8, "uint64_t") 77 | buffer_b0 = x8 78 | buffer_b8 = temp[0] 79 | temp.pop(0) 80 | 81 | new_size = padding_size(size) 82 | 83 | input = bytearray(new_size) 84 | input[:size] = data 85 | pkcs7_padding_pad_buffer(input, size, new_size, 16) 86 | 87 | output = bytearray(new_size) 88 | for i in range(new_size // 16): 89 | output[i * 16 : (i + 1) * 16] = encrypt_ladon_input( 90 | hash_table, input[i * 16 : (i + 1) * 16] 91 | ) 92 | 93 | return output 94 | 95 | 96 | def ladon_encrypt( 97 | khronos : int, 98 | lc_id : int = 1611921764, 99 | aid : int = 1233, 100 | random_bytes : bytes = urandom(4)) -> str: 101 | 102 | data = f"{khronos}-{lc_id}-{aid}" 103 | 104 | keygen = random_bytes + str(aid).encode() 105 | md5hex = md5bytes(keygen) 106 | 107 | size = len(data) 108 | new_size = padding_size(size) 109 | 110 | output = bytearray(new_size + 4) 111 | output[:4] = random_bytes 112 | 113 | output[4:] = encrypt_ladon(md5hex.encode(), data.encode(), size) 114 | 115 | return base64.b64encode(bytes(output)).decode() 116 | 117 | 118 | class Ladon: 119 | @staticmethod 120 | def encrypt(x_khronos: int, lc_id: str, aid: int) -> str: 121 | return ladon_encrypt(x_khronos, lc_id, aid) 122 | 123 | 124 | if __name__ == "__main__": 125 | print(ladon_encrypt(1674223203, 1611921764, 1233)) -------------------------------------------------------------------------------- /Argus.py: -------------------------------------------------------------------------------- 1 | from random import randint 2 | from time import time 3 | from struct import unpack 4 | from base64 import b64encode 5 | from hashlib import md5 6 | from urllib.parse import parse_qs 7 | from Crypto.Cipher.AES import new, MODE_CBC, block_size 8 | from Crypto.Util.Padding import pad 9 | from Sm3 import SM3 10 | from Simon import simon_enc 11 | from protobuf import ProtoBuf 12 | 13 | from Crypto.Cipher.AES import new, MODE_CBC, block_size 14 | 15 | class Argus: 16 | def encrypt_enc_pb(data, l): 17 | data = list(data) 18 | xor_array = data[:8] 19 | 20 | for i in range(8, l): 21 | data[i] ^= xor_array[i % 8] 22 | 23 | return bytes(data[::-1]) 24 | 25 | @staticmethod 26 | def get_bodyhash(stub: str or None = None) -> bytes: 27 | return ( 28 | SM3().sm3_hash(bytes(16))[0:6] 29 | if stub == None or len(stub) == 0 30 | else SM3().sm3_hash(bytes.fromhex(stub))[0:6] 31 | ) 32 | 33 | @staticmethod 34 | def get_queryhash(query: str) -> bytes: 35 | return ( 36 | SM3().sm3_hash(bytes(16))[0:6] 37 | if query == None or len(query) == 0 38 | else SM3().sm3_hash(query.encode())[0:6] 39 | ) 40 | 41 | @staticmethod 42 | def encrypt(xargus_bean: dict): 43 | protobuf = pad(bytes.fromhex(ProtoBuf(xargus_bean).toBuf().hex()), block_size) 44 | new_len = len(protobuf) 45 | sign_key = b"\xac\x1a\xda\xae\x95\xa7\xaf\x94\xa5\x11J\xb3\xb3\xa9}\xd8\x00P\xaa\n91L@R\x8c\xae\xc9RV\xc2\x8c" 46 | sm3_output = b"\xfcx\xe0\xa9ez\x0ct\x8c\xe5\x15Y\x90<\xcf\x03Q\x0eQ\xd3\xcf\xf22\xd7\x13C\xe8\x8a2\x1cS\x04" 47 | 48 | key = sm3_output[:32] 49 | key_list = [] 50 | enc_pb = bytearray(new_len) 51 | 52 | for _ in range(2): 53 | key_list = key_list + list(unpack(" dict: 84 | params_dict = parse_qs(queryhash) 85 | 86 | return Argus.encrypt( 87 | { 88 | 1: 0x20200929 << 1, 89 | 2: 2, 90 | 3: randint(0, 0x7FFFFFFF), 91 | 4: str(aid), 92 | 5: params_dict["device_id"][0], 93 | 6: str(license_id), 94 | 7: params_dict["version_name"][0], 95 | 8: sdk_version, 96 | 9: sdk_version_int, 97 | 10: bytes(8), 98 | 11: platform, 99 | 12: timestamp << 1, 100 | 13: Argus.get_bodyhash(data), 101 | 14: Argus.get_queryhash(queryhash), 102 | 15: { 103 | 1: 1, 104 | 2: 1, 105 | 3: 1, 106 | 7: 3348294860, 107 | }, 108 | 16: sec_device_id, 109 | 20: "none", 110 | 21: 738, 111 | 23: {1: "NX551J", 2: 8196, 4: 2162219008}, 112 | 25: 2, 113 | } 114 | ) 115 | -------------------------------------------------------------------------------- /dictionary.py: -------------------------------------------------------------------------------- 1 | from Gorgon import Gorgon 2 | from Argus import Argus 3 | from Ladon import Ladon 4 | from urllib.parse import urlencode 5 | import time 6 | from tiktok import device_register 7 | import requests 8 | import time 9 | import random 10 | from ms4 import InfoTik 11 | from TikTokAg import UserAgent 12 | from binascii import hexlify 13 | from random import randbytes 14 | from uuid import uuid4 15 | 16 | 17 | 18 | 19 | user = input("Enter The Target Username : ") 20 | 21 | 22 | 23 | info = InfoTik.TikTok_Info(user) 24 | Mahos = UserAgent() 25 | agent = Mahos['User-Agent'] 26 | brand = Mahos['brand'] 27 | type = Mahos['type'] 28 | 29 | 30 | def sign(params, payload: str = None, sec_device_id: str = "", cookie: str or None = None, aid: int = 1233, license_id: int = 1611921764, sdk_version_str: str = "v04.04.05-ov-android", sdk_version: int = 134744640, platform: int = 0, unix: int = None): 31 | x_ss_stub = md5(payload.encode('utf-8')).hexdigest() if payload != None else None 32 | if not unix: unix = int(time.time()) 33 | 34 | return Gorgon(params, unix, payload, cookie).get_value() | { 35 | "x-ladon" : Ladon.encrypt(unix, license_id, aid), 36 | "x-argus" : Argus.get_sign(params, x_ss_stub, unix, 37 | platform = platform, 38 | aid = aid, 39 | license_id = license_id, 40 | sec_device_id = sec_device_id, 41 | sdk_version = sdk_version_str, 42 | sdk_version_int = sdk_version 43 | ) 44 | } 45 | 46 | 47 | 48 | 49 | 50 | def base_params(): 51 | tim = '{:.0f}'.format(time.time() * 1000) 52 | data = device_register() 53 | try: 54 | did = data['device_id'] 55 | except: 56 | did = '73' + ''.join(random.choices('0123456789', k=16)), 57 | try: 58 | iid = data['install_id'] 59 | except: 60 | iid = '73' + ''.join(random.choices('0123456789', k=16)), 61 | try: 62 | udid = data['openudid'] 63 | except: 64 | udid = hexlify(randbytes(8)).decode() 65 | try: 66 | cdid = data['cdid'] 67 | except: 68 | cdid = str(uuid4()) 69 | target_id = info['id'] 70 | 71 | 72 | return { 73 | 'owner_id': target_id, 74 | 'object_id': target_id, 75 | 'report_type': "user", 76 | 'enter_from': "others_homepage", 77 | 'isFirst': "1", 78 | 'no_hw': "1", 79 | 'report_desc': "", 80 | 'uri': "", 81 | 'reason': "90084", 82 | 'category': "porn", 83 | 'request_tag_from': "h5", 84 | 'iid': iid, 85 | 'device_id': did, 86 | 'ac': "MOBILE_4G", 87 | 'channel': "googleplay", 88 | 'aid': "1233", 89 | 'app_name': "musical_ly", 90 | 'version_code': "310503", 91 | 'version_name': "31.5.3", 92 | 'device_platform': "android", 93 | 'os': "android", 94 | 'ab_version': "31.5.3", 95 | 'ssmix': "a", 96 | 'device_type': type, 97 | 'device_brand': brand, 98 | 'language': "ar", 99 | 'os_api': "29", 100 | 'os_version': "10", 101 | 'openudid': udid, 102 | 'manifest_version_code': "2023105030", 103 | 'resolution': "720*1491", 104 | 'dpi': "320", 105 | 'update_version_code': "2023105030", 106 | '_rticket': tim, 107 | 'is_pad': "0", 108 | 'current_region': "YE", 109 | 'app_type': "normal", 110 | 'mcc_mnc': "42102", 111 | 'timezone_name': "Asia/Aden", 112 | 'carrier_region_v2': "421", 113 | 'residence': "YE", 114 | 'app_language': "ar", 115 | 'carrier_region': "YE", 116 | 'ac2': "lte", 117 | 'uoo': "1", 118 | 'op_region': "YE", 119 | 'timezone_offset': "10800", 120 | 'build_number': "31.5.3", 121 | 'host_abi': "arm64-v8a", 122 | 'locale': "ar", 123 | 'ts': str(int(time.time())), 124 | 'cdid': cdid, 125 | } 126 | 127 | 128 | 129 | 130 | def killman(): 131 | headers = { 132 | 'User-Agent': agent, 133 | 'sdk-version': "2", 134 | 'passport-sdk-version': "19", 135 | 'x-tt-dm-status': "login=0;ct=0;rt=7", 136 | 'x-vc-bdturing-sdk-version': "2.3.3.i18n", 137 | 'x-tt-store-region': "ye", 138 | 'x-tt-store-region-src': "did", 139 | 'x-ss-dp': "1233", 140 | 'x-khronos': str(int(time.time())) 141 | } 142 | headers.update(sign(urlencode(base_params()))) 143 | 144 | return headers 145 | 146 | 147 | 148 | -------------------------------------------------------------------------------- /Sm3.py: -------------------------------------------------------------------------------- 1 | class SM3: 2 | def __init__(self) -> None: 3 | self.IV = [1937774191, 1226093241, 388252375, 3666478592, 2842636476, 372324522, 3817729613, 2969243214] 4 | self.TJ = [2043430169, 2043430169, 2043430169, 2043430169, 2043430169, 2043430169, 2043430169, 2043430169, 2043430169, 2043430169, 2043430169, 2043430169, 2043430169, 2043430169, 2043430169, 2043430169, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042, 2055708042] 5 | 6 | def __rotate_left(self, a: int, k: int) -> int: 7 | k = k % 32 8 | 9 | return ((a << k) & 0xFFFFFFFF) | ((a & 0xFFFFFFFF) >> (32 - k)) 10 | 11 | def __FFJ(self, X: int, Y: int, Z: int, j: int) -> int: 12 | 13 | if 0 <= j and j < 16: 14 | ret = X ^ Y ^ Z 15 | elif 16 <= j and j < 64: 16 | ret = (X & Y) | (X & Z) | (Y & Z) 17 | 18 | return ret 19 | 20 | def __GGJ(self, X: int, Y: int, Z: int, j: int) -> int: 21 | 22 | if 0 <= j and j < 16: 23 | ret = X ^ Y ^ Z 24 | elif 16 <= j and j < 64: 25 | ret = (X & Y) | ((~X) & Z) 26 | 27 | return ret 28 | 29 | def __P_0(self, X: int) -> int: 30 | return X ^ (self.__rotate_left(X, 9)) ^ (self.__rotate_left(X, 17)) 31 | 32 | def __P_1(self, X: int) -> int: 33 | Z = X ^ (self.__rotate_left(X, 15)) ^ (self.__rotate_left(X, 23)) 34 | 35 | return Z 36 | 37 | def __CF(self, V_i: list, B_i: bytearray) -> list: 38 | 39 | W = [] 40 | for i in range(16): 41 | weight = 0x1000000 42 | data = 0 43 | for k in range(i * 4, (i + 1) * 4): 44 | data = data + B_i[k] * weight 45 | weight = int(weight / 0x100) 46 | W.append(data) 47 | 48 | for j in range(16, 68): 49 | W.append(0) 50 | W[j] = ( 51 | self.__P_1(W[j - 16] ^ W[j - 9] ^ (self.__rotate_left(W[j - 3], 15))) 52 | ^ (self.__rotate_left(W[j - 13], 7)) 53 | ^ W[j - 6] 54 | ) 55 | 56 | W_1 = [] 57 | for j in range(0, 64): 58 | W_1.append(0) 59 | W_1[j] = W[j] ^ W[j + 4] 60 | 61 | A, B, C, D, E, F, G, H = V_i 62 | 63 | for j in range(0, 64): 64 | 65 | SS1 = self.__rotate_left( 66 | ((self.__rotate_left(A, 12)) + E + (self.__rotate_left(self.TJ[j], j))) 67 | & 0xFFFFFFFF, 68 | 7, 69 | ) 70 | 71 | SS2 = SS1 ^ (self.__rotate_left(A, 12)) 72 | TT1 = (self.__FFJ(A, B, C, j) + D + SS2 + W_1[j]) & 0xFFFFFFFF 73 | TT2 = (self.__GGJ(E, F, G, j) + H + SS1 + W[j]) & 0xFFFFFFFF 74 | D = C 75 | C = self.__rotate_left(B, 9) 76 | B = A 77 | A = TT1 78 | H = G 79 | G = self.__rotate_left(F, 19) 80 | F = E 81 | E = self.__P_0(TT2) 82 | 83 | return [ 84 | A & 0xFFFFFFFF ^ V_i[0], 85 | B & 0xFFFFFFFF ^ V_i[1], 86 | C & 0xFFFFFFFF ^ V_i[2], 87 | D & 0xFFFFFFFF ^ V_i[3], 88 | E & 0xFFFFFFFF ^ V_i[4], 89 | F & 0xFFFFFFFF ^ V_i[5], 90 | G & 0xFFFFFFFF ^ V_i[6], 91 | H & 0xFFFFFFFF ^ V_i[7], 92 | ] 93 | 94 | def sm3_hash(self, msg: bytes) -> bytes: 95 | msg = bytearray(msg) 96 | len1 = len(msg) 97 | reserve1 = len1 % 64 98 | msg.append(0x80) 99 | reserve1 = reserve1 + 1 100 | # 56-64, add 64 byte 101 | range_end = 56 102 | if reserve1 > range_end: 103 | range_end += 64 104 | 105 | for i in range(reserve1, range_end): 106 | msg.append(0x00) 107 | 108 | bit_length = (len1) * 8 109 | bit_length_str = [bit_length % 0x100] 110 | for i in range(7): 111 | bit_length = int(bit_length / 0x100) 112 | bit_length_str.append(bit_length % 0x100) 113 | for i in range(8): 114 | msg.append(bit_length_str[7 - i]) 115 | 116 | group_count = round(len(msg) / 64) 117 | 118 | B = [] 119 | for i in range(0, group_count): 120 | B.append(msg[i * 64 : (i + 1) * 64]) 121 | 122 | V = [] 123 | V.append(self.IV) 124 | for i in range(0, group_count): 125 | V.append(self.__CF(V[i], B[i])) 126 | 127 | y = V[i + 1] 128 | res = b"" 129 | 130 | for i in y: 131 | res += int(i).to_bytes(4, "big") 132 | 133 | return res -------------------------------------------------------------------------------- /protobuf.py: -------------------------------------------------------------------------------- 1 | from enum import IntEnum, unique 2 | 3 | class ProtoError(Exception): 4 | def __init__(self, msg): 5 | self.msg = msg 6 | 7 | def __str__(self): 8 | return repr(self.msg) 9 | 10 | 11 | @unique 12 | class ProtoFieldType(IntEnum): 13 | VARINT = 0 14 | INT64 = 1 15 | STRING = 2 16 | GROUPSTART = 3 17 | GROUPEND = 4 18 | INT32 = 5 19 | ERROR1 = 6 20 | ERROR2 = 7 21 | 22 | 23 | class ProtoField: 24 | def __init__(self, idx, type, val): 25 | self.idx = idx 26 | self.type = type 27 | self.val = val 28 | 29 | def isAsciiStr(self): 30 | if (type(self.val) != bytes): 31 | return False 32 | 33 | for b in self.val: 34 | if b < 0x20 or b > 0x7e: 35 | return False 36 | return True 37 | 38 | def __str__(self): 39 | if ((self.type == ProtoFieldType.INT32) or 40 | (self.type == ProtoFieldType.INT64) or 41 | (self.type == ProtoFieldType.VARINT)): 42 | return '%d(%s): %d' % (self.idx, self.type.name, self.val) 43 | elif self.type == ProtoFieldType.STRING: 44 | if self.isAsciiStr(): # self.val.isalnum() 45 | return '%d(%s): "%s"' % (self.idx, self.type.name, self.val.decode('ascii')) 46 | else: 47 | return '%d(%s): h"%s"' % (self.idx, self.type.name, self.val.hex()) 48 | elif ((self.type == ProtoFieldType.GROUPSTART) or (self.type == ProtoFieldType.GROUPEND)): 49 | return '%d(%s): %s' % (self.idx, self.type.name, self.val) 50 | else: 51 | return '%d(%s): %s' % (self.idx, self.type.name, self.val) 52 | 53 | 54 | class ProtoReader: 55 | def __init__(self, data): 56 | self.data = data 57 | self.pos = 0 58 | 59 | def seek(self, pos): 60 | self.pos = pos 61 | 62 | def isRemain(self, length): 63 | return self.pos + length <= len(self.data) 64 | 65 | def read0(self): 66 | assert (self.isRemain(1)) 67 | ret = self.data[self.pos] 68 | self.pos += 1 69 | return ret & 0xFF 70 | 71 | def read(self, length): 72 | assert (self.isRemain(length)) 73 | ret = self.data[self.pos:self.pos+length] 74 | self.pos += length 75 | return ret 76 | 77 | def readInt32(self): 78 | return int.from_bytes(self.read(4), byteorder='little', signed=False) 79 | 80 | def readInt64(self): 81 | return int.from_bytes(self.read(8), byteorder='little', signed=False) 82 | 83 | def readVarint(self): 84 | vint = 0 85 | n = 0 86 | while True: 87 | byte = self.read0() 88 | vint |= ((byte & 0x7F) << (7 * n)) 89 | if byte < 0x80: 90 | break 91 | n += 1 92 | 93 | return vint 94 | 95 | def readString(self): 96 | len = self.readVarint() 97 | return self.read(len) 98 | 99 | 100 | class ProtoWriter: 101 | def __init__(self): 102 | self.data = bytearray() 103 | 104 | def write0(self, byte): 105 | self.data.append(byte & 0xFF) 106 | 107 | def write(self, bytes): 108 | self.data.extend(bytes) 109 | 110 | def writeInt32(self, int32): 111 | bs = int32.to_bytes(4, byteorder='little', signed=False) 112 | self.write(bs) 113 | 114 | def writeInt64(self, int64): 115 | bs = int64.to_bytes(8, byteorder='little', signed=False) 116 | self.write(bs) 117 | 118 | def writeVarint(self, vint): 119 | vint = vint & 0xFFFFFFFF 120 | while (vint > 0x80): 121 | self.write0((vint & 0x7F) | 0x80) 122 | vint >>= 7 123 | self.write0(vint & 0x7F) 124 | 125 | def writeString(self, bytes): 126 | self.writeVarint(len(bytes)) 127 | self.write(bytes) 128 | 129 | def toBytes(self): 130 | return bytes(self.data) 131 | 132 | 133 | class ProtoBuf: 134 | def __init__(self, data=None): 135 | self.fields = list[ProtoField]() 136 | if (data != None): 137 | if (type(data) != bytes and type(data) != dict): 138 | raise ProtoError( 139 | 'unsupport type(%s) to protobuf' % (type(data))) 140 | 141 | if (type(data) == bytes) and (len(data) > 0): 142 | self.__parseBuf(data) 143 | elif (type(data) == dict) and (len(data) > 0): 144 | self.__parseDict(data) 145 | 146 | def __getitem__(self, idx): 147 | pf = self.get(int(idx)) 148 | if (pf == None): 149 | return None 150 | if (pf.type != ProtoFieldType.STRING): 151 | return pf.val 152 | if (type(idx) != int): 153 | return pf.val 154 | if (pf.val == None): 155 | return None 156 | if (pf.isAsciiStr()): 157 | return pf.val.decode('utf-8') 158 | return ProtoBuf(pf.val) 159 | 160 | def __parseBuf(self, bytes): 161 | reader = ProtoReader(bytes) 162 | while reader.isRemain(1): 163 | key = reader.readVarint() 164 | field_type = ProtoFieldType(key & 0x7) 165 | field_idx = key >> 3 166 | if (field_idx == 0): 167 | break 168 | if (field_type == ProtoFieldType.INT32): 169 | self.put(ProtoField(field_idx, field_type, reader.readInt32())) 170 | elif (field_type == ProtoFieldType.INT64): 171 | self.put(ProtoField(field_idx, field_type, reader.readInt64())) 172 | elif (field_type == ProtoFieldType.VARINT): 173 | self.put(ProtoField(field_idx, field_type, reader.readVarint())) 174 | elif (field_type == ProtoFieldType.STRING): 175 | self.put(ProtoField(field_idx, field_type, reader.readString())) 176 | else: 177 | raise ProtoError( 178 | 'parse protobuf error, unexpected field type: %s' % (field_type.name)) 179 | 180 | def toBuf(self): 181 | writer = ProtoWriter() 182 | for field in self.fields: 183 | key = (field.idx << 3) | (field.type & 7) 184 | writer.writeVarint(key) 185 | if field.type == ProtoFieldType.INT32: 186 | writer.writeInt32(field.val) 187 | elif field.type == ProtoFieldType.INT64: 188 | writer.writeInt64(field.val) 189 | elif field.type == ProtoFieldType.VARINT: 190 | writer.writeVarint(field.val) 191 | elif field.type == ProtoFieldType.STRING: 192 | writer.writeString(field.val) 193 | else: 194 | raise ProtoError( 195 | 'encode to protobuf error, unexpected field type: %s' % (field.type.name)) 196 | return writer.toBytes() 197 | 198 | def dump(self): 199 | for field in self.fields: 200 | print(field) 201 | 202 | def getList(self, idx): 203 | return [field for field in self.fields if field.idx == idx] 204 | 205 | def get(self, idx): 206 | for field in self.fields: 207 | if field.idx == idx: 208 | return field 209 | return None 210 | 211 | def getInt(self, idx): 212 | pf = self.get(idx) 213 | if (pf == None): 214 | return 0 215 | if ((pf.type == ProtoFieldType.INT32) or (pf.type == ProtoFieldType.INT64) or (pf.type == ProtoFieldType.VARINT)): 216 | return pf.val 217 | raise ProtoError("getInt(%d) -> %s" % (idx, pf.type)) 218 | 219 | def getBytes(self, idx): 220 | pf = self.get(idx) 221 | if (pf == None): 222 | return None 223 | if (pf.type == ProtoFieldType.STRING): 224 | return pf.val 225 | raise ProtoError("getBytes(%d) -> %s" % (idx, pf.type)) 226 | 227 | def getUtf8(self, idx): 228 | bs = self.getBytes(idx) 229 | if (bs == None): 230 | return None 231 | return bs.decode('utf-8') 232 | 233 | def getProtoBuf(self, idx): 234 | bs = self.getBytes(idx) 235 | if (bs == None): 236 | return None 237 | return ProtoBuf(bs) 238 | 239 | def put(self, field: ProtoField): 240 | self.fields.append(field) 241 | 242 | def putInt32(self, idx, int32): 243 | self.put(ProtoField(idx, ProtoFieldType.INT32, int32)) 244 | 245 | def putInt64(self, idx, int64): 246 | self.put(ProtoField(idx, ProtoFieldType.INT64, int64)) 247 | 248 | def putVarint(self, idx, vint): 249 | self.put(ProtoField(idx, ProtoFieldType.VARINT, vint)) 250 | 251 | def putBytes(self, idx, data): 252 | self.put(ProtoField(idx, ProtoFieldType.STRING, data)) 253 | 254 | def putUtf8(self, idx, data): 255 | self.put(ProtoField(idx, ProtoFieldType.STRING, data.encode('utf-8'))) 256 | 257 | def putProtoBuf(self, idx, data): 258 | self.put(ProtoField(idx, ProtoFieldType.STRING, data.toBuf())) 259 | 260 | def __parseDict(self, data): 261 | for k, v in data.items(): 262 | if (isinstance(v, int)): 263 | self.putVarint(k, v) 264 | elif (isinstance(v, str)): 265 | self.putUtf8(k, v) 266 | elif (isinstance(v, bytes)): 267 | self.putBytes(k, v) 268 | elif (isinstance(v, dict)): 269 | self.putProtoBuf(k, ProtoBuf(v)) 270 | else: 271 | raise ProtoError('unsupport type(%s) to protobuf' % (type(v))) 272 | 273 | def toDict(self, out): 274 | for k, v in out.items(): 275 | if (isinstance(v, int)): 276 | out[k] = self.getInt(k) 277 | elif (isinstance(v, str)): 278 | out[k] = self.getUtf8(k) 279 | elif (isinstance(v, bytes)): 280 | out[k] = self.getBytes(k) 281 | elif (isinstance(v, dict)): 282 | out[k] = self.getProtoBuf(k).toDict(v) 283 | else: 284 | raise ProtoError('unsupport type(%s) to protobuf' % (type(v))) 285 | return out 286 | -------------------------------------------------------------------------------- /ttencrypt.py: -------------------------------------------------------------------------------- 1 | import gzip 2 | import binascii 3 | import random 4 | 5 | class ttencrypt: 6 | __content = [] 7 | __content_raw = [] 8 | CF = 0 9 | begining = [0x74, 0x63, 0x05, 0x10, 0, 0] 10 | dword_0 = [99, 124, 119, 123, 242, 107, 111, 197, 48, 1, 103, 43, 254, 215, 171, 118, 202, 130, 201, 125, 250, 89, 71, 240, 173, 212, 162, 175, 156, 164, 114, 192, 183, 253, 147, 38, 54, 63, 247, 204, 52, 165, 229, 241, 113, 216, 49, 21, 4, 199, 35, 195, 24, 150, 5, 154, 7, 18, 128, 226, 235, 39, 178, 117, 9, 131, 44, 26, 27, 110, 90, 160, 82, 59, 214, 179, 41, 227, 47, 132, 83, 209, 0, 237, 32, 252, 177, 91, 106, 203, 190, 57, 74, 76, 88, 207, 208, 239, 170, 251, 67, 77, 51, 133, 69, 249, 2, 127, 80, 60, 159, 168, 81, 163, 64, 143, 146, 157, 56, 245, 188, 182, 218, 33, 16, 255, 243, 210, 205, 12, 19, 236, 95, 151, 68, 23, 196, 167, 126, 61, 100, 93, 25, 115, 96, 129, 79, 220, 34, 42, 144, 136, 70, 238, 184, 20, 222, 94, 11, 219, 224, 50, 58, 10, 73, 6, 36, 92, 194, 211, 172, 98, 145, 149, 228, 121, 231, 200, 55, 109, 141, 213, 78, 169, 108, 86, 244, 234, 101, 122, 174, 8, 186, 120, 37, 46, 28, 166, 180, 198, 232, 221, 116, 31, 75, 189, 139, 138, 112, 62, 181, 102, 72, 3, 246, 14, 97, 53, 87, 185, 134, 193, 29, 158, 225, 248, 152, 17, 105, 217, 142, 148, 155, 30, 135, 233, 206, 85, 40, 223, 140, 161, 137, 13, 191, 230, 66, 104, 65, 153, 45, 15, 176, 84, 187, 22] 11 | dword_1 = [16777216, 33554432, 67108864, 134217728, 268435456, 536870912, 1073741824, 2147483648, 452984832, 905969664] 12 | dword_2 = [0, 235474187, 470948374, 303765277, 941896748, 908933415, 607530554, 708780849, 1883793496, 2118214995, 1817866830, 1649639237, 1215061108, 1181045119, 1417561698, 1517767529, 3767586992, 4003061179, 4236429990, 4069246893, 3635733660, 3602770327, 3299278474, 3400528769, 2430122216, 2664543715, 2362090238, 2193862645, 2835123396, 2801107407, 3035535058, 3135740889, 3678124923, 3576870512, 3341394285, 3374361702, 3810496343, 3977675356, 4279080257, 4043610186, 2876494627, 2776292904, 3076639029, 3110650942, 2472011535, 2640243204, 2403728665, 2169303058, 1001089995, 899835584, 666464733, 699432150, 59727847, 226906860, 530400753, 294930682, 1273168787, 1172967064, 1475418501, 1509430414, 1942435775, 2110667444, 1876241833, 1641816226, 2910219766, 2743034109, 2976151520, 3211623147, 2505202138, 2606453969, 2302690252, 2269728455, 3711829422, 3543599269, 3240894392, 3475313331, 3843699074, 3943906441, 4178062228, 4144047775, 1306967366, 1139781709, 1374988112, 1610459739, 1975683434, 2076935265, 1775276924, 1742315127, 1034867998, 866637845, 566021896, 800440835, 92987698, 193195065, 429456164, 395441711, 1984812685, 2017778566, 1784663195, 1683407248, 1315562145, 1080094634, 1383856311, 1551037884, 101039829, 135050206, 437757123, 337553864, 1042385657, 807962610, 573804783, 742039012, 2531067453, 2564033334, 2328828971, 2227573024, 2935566865, 2700099354, 3001755655, 3168937228, 3868552805, 3902563182, 4203181171, 4102977912, 3736164937, 3501741890, 3265478751, 3433712980, 1106041591, 1340463100, 1576976609, 1408749034, 2043211483, 2009195472, 1708848333, 1809054150, 832877231, 1068351396, 766945465, 599762354, 159417987, 126454664, 361929877, 463180190, 2709260871, 2943682380, 3178106961, 3009879386, 2572697195, 2538681184, 2236228733, 2336434550, 3509871135, 3745345300, 3441850377, 3274667266, 3910161971, 3877198648, 4110568485, 4211818798, 2597806476, 2497604743, 2261089178, 2295101073, 2733856160, 2902087851, 3202437046, 2968011453, 3936291284, 3835036895, 4136440770, 4169408201, 3535486456, 3702665459, 3467192302, 3231722213, 2051518780, 1951317047, 1716890410, 1750902305, 1113818384, 1282050075, 1584504582, 1350078989, 168810852, 67556463, 371049330, 404016761, 841739592, 1008918595, 775550814, 540080725, 3969562369, 3801332234, 4035489047, 4269907996, 3569255213, 3669462566, 3366754619, 3332740144, 2631065433, 2463879762, 2160117071, 2395588676, 2767645557, 2868897406, 3102011747, 3069049960, 202008497, 33778362, 270040487, 504459436, 875451293, 975658646, 675039627, 641025152, 2084704233, 1917518562, 1615861247, 1851332852, 1147550661, 1248802510, 1484005843, 1451044056, 933301370, 967311729, 733156972, 632953703, 260388950, 25965917, 328671808, 496906059, 1206477858, 1239443753, 1543208500, 1441952575, 2144161806, 1908694277, 1675577880, 1842759443, 3610369226, 3644379585, 3408119516, 3307916247, 4011190502, 3776767469, 4077384432, 4245618683, 2809771154, 2842737049, 3144396420, 3043140495, 2673705150, 2438237621, 2203032232, 2370213795] 13 | dword_3 = [0, 185469197, 370938394, 487725847, 741876788, 657861945, 975451694, 824852259, 1483753576, 1400783205, 1315723890, 1164071807, 1950903388, 2135319889, 1649704518, 1767536459, 2967507152, 3152976349, 2801566410, 2918353863, 2631447780, 2547432937, 2328143614, 2177544179, 3901806776, 3818836405, 4270639778, 4118987695, 3299409036, 3483825537, 3535072918, 3652904859, 2077965243, 1893020342, 1841768865, 1724457132, 1474502543, 1559041666, 1107234197, 1257309336, 598438867, 681933534, 901210569, 1052338372, 261314535, 77422314, 428819965, 310463728, 3409685355, 3224740454, 3710368113, 3593056380, 3875770207, 3960309330, 4045380933, 4195456072, 2471224067, 2554718734, 2237133081, 2388260884, 3212035895, 3028143674, 2842678573, 2724322336, 4138563181, 4255350624, 3769721975, 3955191162, 3667219033, 3516619604, 3431546947, 3347532110, 2933734917, 2782082824, 3099667487, 3016697106, 2196052529, 2313884476, 2499348523, 2683765030, 1179510461, 1296297904, 1347548327, 1533017514, 1786102409, 1635502980, 2087309459, 2003294622, 507358933, 355706840, 136428751, 53458370, 839224033, 957055980, 605657339, 790073846, 2373340630, 2256028891, 2607439820, 2422494913, 2706270690, 2856345839, 3075636216, 3160175349, 3573941694, 3725069491, 3273267108, 3356761769, 4181598602, 4063242375, 4011996048, 3828103837, 1033297158, 915985419, 730517276, 545572369, 296679730, 446754879, 129166120, 213705253, 1709610350, 1860738147, 1945798516, 2029293177, 1239331162, 1120974935, 1606591296, 1422699085, 4148292826, 4233094615, 3781033664, 3931371469, 3682191598, 3497509347, 3446004468, 3328955385, 2939266226, 2755636671, 3106780840, 2988687269, 2198438022, 2282195339, 2501218972, 2652609425, 1201765386, 1286567175, 1371368976, 1521706781, 1805211710, 1620529459, 2105887268, 1988838185, 533804130, 350174575, 164439672, 46346101, 870912086, 954669403, 636813900, 788204353, 2358957921, 2274680428, 2592523643, 2441661558, 2695033685, 2880240216, 3065962831, 3182487618, 3572145929, 3756299780, 3270937875, 3388507166, 4174560061, 4091327024, 4006521127, 3854606378, 1014646705, 930369212, 711349675, 560487590, 272786309, 457992840, 106852767, 223377554, 1678381017, 1862534868, 1914052035, 2031621326, 1211247597, 1128014560, 1580087799, 1428173050, 32283319, 182621114, 401639597, 486441376, 768917123, 651868046, 1003007129, 818324884, 1503449823, 1385356242, 1333838021, 1150208456, 1973745387, 2125135846, 1673061617, 1756818940, 2970356327, 3120694122, 2802849917, 2887651696, 2637442643, 2520393566, 2334669897, 2149987652, 3917234703, 3799141122, 4284502037, 4100872472, 3309594171, 3460984630, 3545789473, 3629546796, 2050466060, 1899603969, 1814803222, 1730525723, 1443857720, 1560382517, 1075025698, 1260232239, 575138148, 692707433, 878443390, 1062597235, 243256656, 91341917, 409198410, 325965383, 3403100636, 3252238545, 3704300486, 3620022987, 3874428392, 3990953189, 4042459122, 4227665663, 2460449204, 2578018489, 2226875310, 2411029155, 3198115200, 3046200461, 2827177882, 2743944855] 14 | dword_4 = [0, 218828297, 437656594, 387781147, 875313188, 958871085, 775562294, 590424639, 1750626376, 1699970625, 1917742170, 2135253587, 1551124588, 1367295589, 1180849278, 1265195639, 3501252752, 3720081049, 3399941250, 3350065803, 3835484340, 3919042237, 4270507174, 4085369519, 3102249176, 3051593425, 2734591178, 2952102595, 2361698556, 2177869557, 2530391278, 2614737639, 3145456443, 3060847922, 2708326185, 2892417312, 2404901663, 2187128086, 2504130317, 2555048196, 3542330227, 3727205754, 3375740769, 3292445032, 3876557655, 3926170974, 4246310725, 4027744588, 1808481195, 1723872674, 1910319033, 2094410160, 1608975247, 1391201670, 1173430173, 1224348052, 59984867, 244860394, 428169201, 344873464, 935293895, 984907214, 766078933, 547512796, 1844882806, 1627235199, 2011214180, 2062270317, 1507497298, 1423022939, 1137477952, 1321699145, 95345982, 145085239, 532201772, 313773861, 830661914, 1015671571, 731183368, 648017665, 3175501286, 2957853679, 2807058932, 2858115069, 2305455554, 2220981195, 2474404304, 2658625497, 3575528878, 3625268135, 3473416636, 3254988725, 3778151818, 3963161475, 4213447064, 4130281361, 3599595085, 3683022916, 3432737375, 3247465558, 3802222185, 4020912224, 4172763771, 4122762354, 3201631749, 3017672716, 2764249623, 2848461854, 2331590177, 2280796200, 2431590963, 2648976442, 104699613, 188127444, 472615631, 287343814, 840019705, 1058709744, 671593195, 621591778, 1852171925, 1668212892, 1953757831, 2037970062, 1514790577, 1463996600, 1080017571, 1297403050, 3673637356, 3623636965, 3235995134, 3454686199, 4007360968, 3822090177, 4107101658, 4190530515, 2997825956, 3215212461, 2830708150, 2779915199, 2256734592, 2340947849, 2627016082, 2443058075, 172466556, 122466165, 273792366, 492483431, 1047239000, 861968209, 612205898, 695634755, 1646252340, 1863638845, 2013908262, 1963115311, 1446242576, 1530455833, 1277555970, 1093597963, 1636604631, 1820824798, 2073724613, 1989249228, 1436590835, 1487645946, 1337376481, 1119727848, 164948639, 81781910, 331544205, 516552836, 1039717051, 821288114, 669961897, 719700128, 2973530695, 3157750862, 2871682645, 2787207260, 2232435299, 2283490410, 2667994737, 2450346104, 3647212047, 3564045318, 3279033885, 3464042516, 3980931627, 3762502690, 4150144569, 4199882800, 3070356634, 3121275539, 2904027272, 2686254721, 2200818878, 2384911031, 2570832044, 2486224549, 3747192018, 3528626907, 3310321856, 3359936201, 3950355702, 3867060991, 4049844452, 4234721005, 1739656202, 1790575107, 2108100632, 1890328081, 1402811438, 1586903591, 1233856572, 1149249077, 266959938, 48394827, 369057872, 418672217, 1002783846, 919489135, 567498868, 752375421, 209336225, 24197544, 376187827, 459744698, 945164165, 895287692, 574624663, 793451934, 1679968233, 1764313568, 2117360635, 1933530610, 1343127501, 1560637892, 1243112415, 1192455638, 3704280881, 3519142200, 3336358691, 3419915562, 3907448597, 3857572124, 4075877127, 4294704398, 3029510009, 3113855344, 2927934315, 2744104290, 2159976285, 2377486676, 2594734927, 2544078150] 15 | dword_5 = [0, 151849742, 303699484, 454499602, 607398968, 758720310, 908999204, 1059270954, 1214797936, 1097159550, 1517440620, 1400849762, 1817998408, 1699839814, 2118541908, 2001430874, 2429595872, 2581445614, 2194319100, 2345119218, 3034881240, 3186202582, 2801699524, 2951971274, 3635996816, 3518358430, 3399679628, 3283088770, 4237083816, 4118925222, 4002861748, 3885750714, 1002142683, 850817237, 698445255, 548169417, 529487843, 377642221, 227885567, 77089521, 1943217067, 2061379749, 1640576439, 1757691577, 1474760595, 1592394909, 1174215055, 1290801793, 2875968315, 2724642869, 3111247143, 2960971305, 2405426947, 2253581325, 2638606623, 2487810577, 3808662347, 3926825029, 4044981591, 4162096729, 3342319475, 3459953789, 3576539503, 3693126241, 1986918061, 2137062819, 1685577905, 1836772287, 1381620373, 1532285339, 1078185097, 1229899655, 1040559837, 923313619, 740276417, 621982671, 439452389, 322734571, 137073913, 19308535, 3871163981, 4021308739, 4104605777, 4255800159, 3263785589, 3414450555, 3499326569, 3651041127, 2933202493, 2815956275, 3167684641, 3049390895, 2330014213, 2213296395, 2566595609, 2448830231, 1305906550, 1155237496, 1607244650, 1455525988, 1776460110, 1626319424, 2079897426, 1928707164, 96392454, 213114376, 396673818, 514443284, 562755902, 679998000, 865136418, 983426092, 3708173718, 3557504664, 3474729866, 3323011204, 4180808110, 4030667424, 3945269170, 3794078908, 2507040230, 2623762152, 2272556026, 2390325492, 2975484382, 3092726480, 2738905026, 2857194700, 3973773121, 3856137295, 4274053469, 4157467219, 3371096953, 3252932727, 3673476453, 3556361835, 2763173681, 2915017791, 3064510765, 3215307299, 2156299017, 2307622919, 2459735317, 2610011675, 2081048481, 1963412655, 1846563261, 1729977011, 1480485785, 1362321559, 1243905413, 1126790795, 878845905, 1030690015, 645401037, 796197571, 274084841, 425408743, 38544885, 188821243, 3613494426, 3731654548, 3313212038, 3430322568, 4082475170, 4200115116, 3780097726, 3896688048, 2668221674, 2516901860, 2366882550, 2216610296, 3141400786, 2989552604, 2837966542, 2687165888, 1202797690, 1320957812, 1437280870, 1554391400, 1669664834, 1787304780, 1906247262, 2022837584, 265905162, 114585348, 499347990, 349075736, 736970802, 585122620, 972512814, 821712160, 2595684844, 2478443234, 2293045232, 2174754046, 3196267988, 3079546586, 2895723464, 2777952454, 3537852828, 3687994002, 3234156416, 3385345166, 4142626212, 4293295786, 3841024952, 3992742070, 174567692, 57326082, 410887952, 292596766, 777231668, 660510266, 1011452712, 893681702, 1108339068, 1258480242, 1343618912, 1494807662, 1715193156, 1865862730, 1948373848, 2100090966, 2701949495, 2818666809, 3004591147, 3122358053, 2235061775, 2352307457, 2535604243, 2653899549, 3915653703, 3764988233, 4219352155, 4067639125, 3444575871, 3294430577, 3746175075, 3594982253, 836553431, 953270745, 600235211, 718002117, 367585007, 484830689, 133361907, 251657213, 2041877159, 1891211689, 1806599355, 1654886325, 1568718495, 1418573201, 1335535747, 1184342925] 16 | dword_6 = [3328402341, 4168907908, 4000806809, 4135287693, 4294111757, 3597364157, 3731845041, 2445657428, 1613770832, 33620227, 3462883241, 1445669757, 3892248089, 3050821474, 1303096294, 3967186586, 2412431941, 528646813, 2311702848, 4202528135, 4026202645, 2992200171, 2387036105, 4226871307, 1101901292, 3017069671, 1604494077, 1169141738, 597466303, 1403299063, 3832705686, 2613100635, 1974974402, 3791519004, 1033081774, 1277568618, 1815492186, 2118074177, 4126668546, 2211236943, 1748251740, 1369810420, 3521504564, 4193382664, 3799085459, 2883115123, 1647391059, 706024767, 134480908, 2512897874, 1176707941, 2646852446, 806885416, 932615841, 168101135, 798661301, 235341577, 605164086, 461406363, 3756188221, 3454790438, 1311188841, 2142417613, 3933566367, 302582043, 495158174, 1479289972, 874125870, 907746093, 3698224818, 3025820398, 1537253627, 2756858614, 1983593293, 3084310113, 2108928974, 1378429307, 3722699582, 1580150641, 327451799, 2790478837, 3117535592, 0, 3253595436, 1075847264, 3825007647, 2041688520, 3059440621, 3563743934, 2378943302, 1740553945, 1916352843, 2487896798, 2555137236, 2958579944, 2244988746, 3151024235, 3320835882, 1336584933, 3992714006, 2252555205, 2588757463, 1714631509, 293963156, 2319795663, 3925473552, 67240454, 4269768577, 2689618160, 2017213508, 631218106, 1269344483, 2723238387, 1571005438, 2151694528, 93294474, 1066570413, 563977660, 1882732616, 4059428100, 1673313503, 2008463041, 2950355573, 1109467491, 537923632, 3858759450, 4260623118, 3218264685, 2177748300, 403442708, 638784309, 3287084079, 3193921505, 899127202, 2286175436, 773265209, 2479146071, 1437050866, 4236148354, 2050833735, 3362022572, 3126681063, 840505643, 3866325909, 3227541664, 427917720, 2655997905, 2749160575, 1143087718, 1412049534, 999329963, 193497219, 2353415882, 3354324521, 1807268051, 672404540, 2816401017, 3160301282, 369822493, 2916866934, 3688947771, 1681011286, 1949973070, 336202270, 2454276571, 201721354, 1210328172, 3093060836, 2680341085, 3184776046, 1135389935, 3294782118, 965841320, 831886756, 3554993207, 4068047243, 3588745010, 2345191491, 1849112409, 3664604599, 26054028, 2983581028, 2622377682, 1235855840, 3630984372, 2891339514, 4092916743, 3488279077, 3395642799, 4101667470, 1202630377, 268961816, 1874508501, 4034427016, 1243948399, 1546530418, 941366308, 1470539505, 1941222599, 2546386513, 3421038627, 2715671932, 3899946140, 1042226977, 2521517021, 1639824860, 227249030, 260737669, 3765465232, 2084453954, 1907733956, 3429263018, 2420656344, 100860677, 4160157185, 470683154, 3261161891, 1781871967, 2924959737, 1773779408, 394692241, 2579611992, 974986535, 664706745, 3655459128, 3958962195, 731420851, 571543859, 3530123707, 2849626480, 126783113, 865375399, 765172662, 1008606754, 361203602, 3387549984, 2278477385, 2857719295, 1344809080, 2782912378, 59542671, 1503764984, 160008576, 437062935, 1707065306, 3622233649, 2218934982, 3496503480, 2185314755, 697932208, 1512910199, 504303377, 2075177163, 2824099068, 1841019862, 739644986] 17 | dword_7 = [2781242211, 2230877308, 2582542199, 2381740923, 234877682, 3184946027, 2984144751, 1418839493, 1348481072, 50462977, 2848876391, 2102799147, 434634494, 1656084439, 3863849899, 2599188086, 1167051466, 2636087938, 1082771913, 2281340285, 368048890, 3954334041, 3381544775, 201060592, 3963727277, 1739838676, 4250903202, 3930435503, 3206782108, 4149453988, 2531553906, 1536934080, 3262494647, 484572669, 2923271059, 1783375398, 1517041206, 1098792767, 49674231, 1334037708, 1550332980, 4098991525, 886171109, 150598129, 2481090929, 1940642008, 1398944049, 1059722517, 201851908, 1385547719, 1699095331, 1587397571, 674240536, 2704774806, 252314885, 3039795866, 151914247, 908333586, 2602270848, 1038082786, 651029483, 1766729511, 3447698098, 2682942837, 454166793, 2652734339, 1951935532, 775166490, 758520603, 3000790638, 4004797018, 4217086112, 4137964114, 1299594043, 1639438038, 3464344499, 2068982057, 1054729187, 1901997871, 2534638724, 4121318227, 1757008337, 0, 750906861, 1614815264, 535035132, 3363418545, 3988151131, 3201591914, 1183697867, 3647454910, 1265776953, 3734260298, 3566750796, 3903871064, 1250283471, 1807470800, 717615087, 3847203498, 384695291, 3313910595, 3617213773, 1432761139, 2484176261, 3481945413, 283769337, 100925954, 2180939647, 4037038160, 1148730428, 3123027871, 3813386408, 4087501137, 4267549603, 3229630528, 2315620239, 2906624658, 3156319645, 1215313976, 82966005, 3747855548, 3245848246, 1974459098, 1665278241, 807407632, 451280895, 251524083, 1841287890, 1283575245, 337120268, 891687699, 801369324, 3787349855, 2721421207, 3431482436, 959321879, 1469301956, 4065699751, 2197585534, 1199193405, 2898814052, 3887750493, 724703513, 2514908019, 2696962144, 2551808385, 3516813135, 2141445340, 1715741218, 2119445034, 2872807568, 2198571144, 3398190662, 700968686, 3547052216, 1009259540, 2041044702, 3803995742, 487983883, 1991105499, 1004265696, 1449407026, 1316239930, 504629770, 3683797321, 168560134, 1816667172, 3837287516, 1570751170, 1857934291, 4014189740, 2797888098, 2822345105, 2754712981, 936633572, 2347923833, 852879335, 1133234376, 1500395319, 3084545389, 2348912013, 1689376213, 3533459022, 3762923945, 3034082412, 4205598294, 133428468, 634383082, 2949277029, 2398386810, 3913789102, 403703816, 3580869306, 2297460856, 1867130149, 1918643758, 607656988, 4049053350, 3346248884, 1368901318, 600565992, 2090982877, 2632479860, 557719327, 3717614411, 3697393085, 2249034635, 2232388234, 2430627952, 1115438654, 3295786421, 2865522278, 3633334344, 84280067, 33027830, 303828494, 2747425121, 1600795957, 4188952407, 3496589753, 2434238086, 1486471617, 658119965, 3106381470, 953803233, 334231800, 3005978776, 857870609, 3151128937, 1890179545, 2298973838, 2805175444, 3056442267, 574365214, 2450884487, 550103529, 1233637070, 4289353045, 2018519080, 2057691103, 2399374476, 4166623649, 2148108681, 387583245, 3664101311, 836232934, 3330556482, 3100665960, 3280093505, 2955516313, 2002398509, 287182607, 3413881008, 4238890068, 3597515707, 975967766] 18 | dword_8 = [1671808611, 2089089148, 2006576759, 2072901243, 4061003762, 1807603307, 1873927791, 3310653893, 810573872, 16974337, 1739181671, 729634347, 4263110654, 3613570519, 2883997099, 1989864566, 3393556426, 2191335298, 3376449993, 2106063485, 4195741690, 1508618841, 1204391495, 4027317232, 2917941677, 3563566036, 2734514082, 2951366063, 2629772188, 2767672228, 1922491506, 3227229120, 3082974647, 4246528509, 2477669779, 644500518, 911895606, 1061256767, 4144166391, 3427763148, 878471220, 2784252325, 3845444069, 4043897329, 1905517169, 3631459288, 827548209, 356461077, 67897348, 3344078279, 593839651, 3277757891, 405286936, 2527147926, 84871685, 2595565466, 118033927, 305538066, 2157648768, 3795705826, 3945188843, 661212711, 2999812018, 1973414517, 152769033, 2208177539, 745822252, 439235610, 455947803, 1857215598, 1525593178, 2700827552, 1391895634, 994932283, 3596728278, 3016654259, 695947817, 3812548067, 795958831, 2224493444, 1408607827, 3513301457, 0, 3979133421, 543178784, 4229948412, 2982705585, 1542305371, 1790891114, 3410398667, 3201918910, 961245753, 1256100938, 1289001036, 1491644504, 3477767631, 3496721360, 4012557807, 2867154858, 4212583931, 1137018435, 1305975373, 861234739, 2241073541, 1171229253, 4178635257, 33948674, 2139225727, 1357946960, 1011120188, 2679776671, 2833468328, 1374921297, 2751356323, 1086357568, 2408187279, 2460827538, 2646352285, 944271416, 4110742005, 3168756668, 3066132406, 3665145818, 560153121, 271589392, 4279952895, 4077846003, 3530407890, 3444343245, 202643468, 322250259, 3962553324, 1608629855, 2543990167, 1154254916, 389623319, 3294073796, 2817676711, 2122513534, 1028094525, 1689045092, 1575467613, 422261273, 1939203699, 1621147744, 2174228865, 1339137615, 3699352540, 577127458, 712922154, 2427141008, 2290289544, 1187679302, 3995715566, 3100863416, 339486740, 3732514782, 1591917662, 186455563, 3681988059, 3762019296, 844522546, 978220090, 169743370, 1239126601, 101321734, 611076132, 1558493276, 3260915650, 3547250131, 2901361580, 1655096418, 2443721105, 2510565781, 3828863972, 2039214713, 3878868455, 3359869896, 928607799, 1840765549, 2374762893, 3580146133, 1322425422, 2850048425, 1823791212, 1459268694, 4094161908, 3928346602, 1706019429, 2056189050, 2934523822, 135794696, 3134549946, 2022240376, 628050469, 779246638, 472135708, 2800834470, 3032970164, 3327236038, 3894660072, 3715932637, 1956440180, 522272287, 1272813131, 3185336765, 2340818315, 2323976074, 1888542832, 1044544574, 3049550261, 1722469478, 1222152264, 50660867, 4127324150, 236067854, 1638122081, 895445557, 1475980887, 3117443513, 2257655686, 3243809217, 489110045, 2662934430, 3778599393, 4162055160, 2561878936, 288563729, 1773916777, 3648039385, 2391345038, 2493985684, 2612407707, 505560094, 2274497927, 3911240169, 3460925390, 1442818645, 678973480, 3749357023, 2358182796, 2717407649, 2306869641, 219617805, 3218761151, 3862026214, 1120306242, 1756942440, 1103331905, 2578459033, 762796589, 252780047, 2966125488, 1425844308, 3151392187, 372911126] 19 | dword_9 = [1667474886, 2088535288, 2004326894, 2071694838, 4075949567, 1802223062, 1869591006, 3318043793, 808472672, 16843522, 1734846926, 724270422, 4278065639, 3621216949, 2880169549, 1987484396, 3402253711, 2189597983, 3385409673, 2105378810, 4210693615, 1499065266, 1195886990, 4042263547, 2913856577, 3570689971, 2728590687, 2947541573, 2627518243, 2762274643, 1920112356, 3233831835, 3082273397, 4261223649, 2475929149, 640051788, 909531756, 1061110142, 4160160501, 3435941763, 875846760, 2779116625, 3857003729, 4059105529, 1903268834, 3638064043, 825316194, 353713962, 67374088, 3351728789, 589522246, 3284360861, 404236336, 2526454071, 84217610, 2593830191, 117901582, 303183396, 2155911963, 3806477791, 3958056653, 656894286, 2998062463, 1970642922, 151591698, 2206440989, 741110872, 437923380, 454765878, 1852748508, 1515908788, 2694904667, 1381168804, 993742198, 3604373943, 3014905469, 690584402, 3823320797, 791638366, 2223281939, 1398011302, 3520161977, 0, 3991743681, 538992704, 4244381667, 2981218425, 1532751286, 1785380564, 3419096717, 3200178535, 960056178, 1246420628, 1280103576, 1482221744, 3486468741, 3503319995, 4025428677, 2863326543, 4227536621, 1128514950, 1296947098, 859002214, 2240123921, 1162203018, 4193849577, 33687044, 2139062782, 1347481760, 1010582648, 2678045221, 2829640523, 1364325282, 2745433693, 1077985408, 2408548869, 2459086143, 2644360225, 943212656, 4126475505, 3166494563, 3065430391, 3671750063, 555836226, 269496352, 4294908645, 4092792573, 3537006015, 3452783745, 202118168, 320025894, 3974901699, 1600119230, 2543297077, 1145359496, 387397934, 3301201811, 2812801621, 2122220284, 1027426170, 1684319432, 1566435258, 421079858, 1936954854, 1616945344, 2172753945, 1330631070, 3705438115, 572679748, 707427924, 2425400123, 2290647819, 1179044492, 4008585671, 3099120491, 336870440, 3739122087, 1583276732, 185277718, 3688593069, 3772791771, 842159716, 976899700, 168435220, 1229577106, 101059084, 606366792, 1549591736, 3267517855, 3553849021, 2897014595, 1650632388, 2442242105, 2509612081, 3840161747, 2038008818, 3890688725, 3368567691, 926374254, 1835907034, 2374863873, 3587531953, 1313788572, 2846482505, 1819063512, 1448540844, 4109633523, 3941213647, 1701162954, 2054852340, 2930698567, 134748176, 3132806511, 2021165296, 623210314, 774795868, 471606328, 2795958615, 3031746419, 3334885783, 3907527627, 3722280097, 1953799400, 522133822, 1263263126, 3183336545, 2341176845, 2324333839, 1886425312, 1044267644, 3048588401, 1718004428, 1212733584, 50529542, 4143317495, 235803164, 1633788866, 892690282, 1465383342, 3115962473, 2256965911, 3250673817, 488449850, 2661202215, 3789633753, 4177007595, 2560144171, 286339874, 1768537042, 3654906025, 2391705863, 2492770099, 2610673197, 505291324, 2273808917, 3924369609, 3469625735, 1431699370, 673740880, 3755965093, 2358021891, 2711746649, 2307489801, 218961690, 3217021541, 3873845719, 1111672452, 1751693520, 1094828930, 2576986153, 757954394, 252645662, 2964376443, 1414855848, 3149649517, 370555436] 20 | LIST_6B0 = [4089235720, 1779033703, 2227873595, 3144134277, 4271175723, 1013904242, 1595750129, 2773480762, 2917565137, 1359893119, 725511199, 2600822924, 4215389547, 528734635, 327033209, 1541459225] 21 | ord_list = [77, 212, 194, 230, 184, 49, 98, 9, 14, 82, 179, 199, 166, 115, 59, 164, 28, 178, 70, 43, 130, 154, 181, 138, 25, 107, 57, 219, 87, 23, 117, 36, 244, 155, 175, 127, 8, 232, 214, 141, 38, 167, 46, 55, 193, 169, 90, 47, 31, 5, 165, 24, 146, 174, 242, 148, 151, 50, 182, 42, 56, 170, 221, 88] 22 | rodata = [3609767458, 1116352408, 602891725, 1899447441, 3964484399, 3049323471, 2173295548, 3921009573, 4081628472, 961987163, 3053834265, 1508970993, 2937671579, 2453635748, 3664609560, 2870763221, 2734883394, 3624381080, 1164996542, 310598401, 1323610764, 607225278, 3590304994, 1426881987, 4068182383, 1925078388, 991336113, 2162078206, 633803317, 2614888103, 3479774868, 3248222580, 2666613458, 3835390401, 944711139, 4022224774, 2341262773, 264347078, 2007800933, 604807628, 1495990901, 770255983, 1856431235, 1249150122, 3175218132, 1555081692, 2198950837, 1996064986, 3999719339, 2554220882, 766784016, 2821834349, 2566594879, 2952996808, 3203337956, 3210313671, 1034457026, 3336571891, 2466948901, 3584528711, 3758326383, 113926993, 168717936, 338241895, 1188179964, 666307205, 1546045734, 773529912, 1522805485, 1294757372, 2643833823, 1396182291, 2343527390, 1695183700, 1014477480, 1986661051, 1206759142, 2177026350, 344077627, 2456956037, 1290863460, 2730485921, 3158454273, 2820302411, 3505952657, 3259730800, 106217008, 3345764771, 3606008344, 3516065817, 1432725776, 3600352804, 1467031594, 4094571909, 851169720, 275423344, 3100823752, 430227734, 1363258195, 506948616, 3750685593, 659060556, 3785050280, 883997877, 3318307427, 958139571, 3812723403, 1322822218, 2003034995, 1537002063, 3602036899, 1747873779, 1575990012, 1955562222, 1125592928, 2024104815, 2716904306, 2227730452, 442776044, 2361852424, 593698344, 2428436474, 3733110249, 2756734187, 2999351573, 3204031479, 3815920427, 3329325298, 3928383900, 3391569614, 566280711, 3515267271, 3454069534, 3940187606, 4000239992, 4118630271, 1914138554, 116418474, 2731055270, 174292421, 3203993006, 289380356, 320620315, 460393269, 587496836, 685471733, 1086792851, 852142971, 365543100, 1017036298, 2618297676, 1126000580, 3409855158, 1288033470, 4234509866, 1501505948, 987167468, 1607167915, 1246189591, 1816402316] 23 | list_9C8 = [] 24 | 25 | def encrypt(self, data): 26 | headers = [31, 139, 8, 0, 0, 0, 0, 0, 0, 0] 27 | data = gzip.compress(bytes(data.encode("latin-1")), compresslevel=9, mtime=0) 28 | data = list(data) 29 | self.setData(data) 30 | for i in range(len(headers)): 31 | self.__content[i] = headers[i] 32 | list_0B0 = self.calculate(self.list_9C8) + self.ord_list 33 | list_5D8 = self.calculate(list_0B0) 34 | list_378 = [] 35 | list_740 = [] 36 | for i in range(0x10): 37 | list_378.append(list_5D8[i]) 38 | list_378Array = self.dump_list(list_378) 39 | for i in range(0x10, 0x20): 40 | list_740.append(list_5D8[i]) 41 | list_8D8 = self.calculate(self.__content) 42 | list_AB0 = list_8D8 + self.__content 43 | list_AB0List = self.convertLongList(list_AB0) 44 | differ = 0x10 - len(list_AB0) % 0x10 45 | for i in range(differ): 46 | list_AB0List.append(differ) 47 | list_AB0 = list_AB0List 48 | list_55C = self.hex_CF8(list_378Array) 49 | final_list = self.hex_0A2(list_AB0, list_740, list_55C) 50 | final_list = (self.begining + self.list_9C8) + final_list 51 | final_list = self.changeLongArrayTobytes(final_list) 52 | return bytes(i % 256 for i in final_list).hex() 53 | 54 | def decrypt(self, data): 55 | data = bytearray.fromhex(data) 56 | data = list(data) 57 | self.setData(data) 58 | self.__content = self.__content_raw[38:] 59 | self.list_9C8 = self.__content_raw[6:38] 60 | self.__content = self.changeByteArrayToLong(self.__content) 61 | list_0B0 = self.calculate(self.list_9C8) + self.ord_list 62 | list_5D8 = self.calculate(list_0B0) 63 | list_378 = [] 64 | list_740 = [] 65 | for i in range(0x10): 66 | list_378.append(list_5D8[i]) 67 | list_378Array = self.dump_list(list_378) 68 | for i in range(0x10, 0x20): 69 | list_740.append(list_5D8[i]) 70 | key_longs = self.hex_list(list_378Array) 71 | decrypted = self.aes_decrypt(bytes(key_longs), bytes(self.__content)) 72 | decryptedByteArray = ([0] * 16) + list(decrypted) 73 | toDecompress = decryptedByteArray[64:] 74 | result = gzip.decompress(bytes(toDecompress)) 75 | return result.decode() 76 | 77 | def aes_decrypt(self, secretKey, encoded): 78 | initVector = encoded[0:16] 79 | data = encoded[16:] 80 | decryptor = AES.new(secretKey, AES.MODE_CBC, initVector) 81 | decoded = decryptor.decrypt(data) 82 | return decoded[: -decoded[-1]] 83 | 84 | def bytearray_decode(self, arrays): 85 | out = [] 86 | for d in arrays: 87 | out.append(chr(d)) 88 | return "".join(out) 89 | 90 | def changeLongArrayTobytes(self, array): 91 | result = [] 92 | for i in range(len(array)): 93 | if array[i] > 127: 94 | result.append(array[i] - 256) 95 | else: 96 | result.append(array[i]) 97 | return result 98 | 99 | def hex_0A2(self, content, list_740, list_55C): 100 | result = [] 101 | l55cl = len(list_55C) 102 | lens = len(content) 103 | end = lens // 16 104 | for i in range(end): 105 | for j in range(16): 106 | list_740[j] = list_740[j] ^ content[16 * i + j] 107 | tmp_list = self.dump_list(list_740) 108 | R6 = tmp_list[3] 109 | LR = tmp_list[0] 110 | R8 = tmp_list[1] 111 | R12 = tmp_list[2] 112 | R5 = list_55C[0] 113 | R4 = list_55C[1] 114 | R1 = list_55C[2] 115 | R2 = list_55C[3] 116 | R11 = 0 117 | v_334 = 0 118 | R2 = R2 ^ R6 119 | v_33C = R2 120 | R1 = R1 ^ R12 121 | v_338 = R1 122 | R4 = R4 ^ R8 123 | R12 = R5 ^ LR 124 | for j in range(5): 125 | R3 = v_33C 126 | R9 = R4 127 | R0 = int(self.UBFX(R12, 0x10, 8)) 128 | R1 = R3 >> 0x18 129 | R1 = self.dword_6[R1] 130 | R0 = self.dword_7[R0] 131 | R0 = R0 ^ R1 132 | R1 = int(self.UBFX(R4, 8, 8)) 133 | R8 = v_338 134 | R1 = self.dword_8[R1] 135 | LR = list_55C[8 * j + 6] 136 | R0 = R0 ^ R1 137 | R1 = int(self.UTFX(R8)) 138 | R1 = self.dword_9[R1] 139 | R0 = R0 ^ R1 140 | R1 = list_55C[8 * j + 4] 141 | v_334 = R1 142 | R1 = list_55C[8 * j + 5] 143 | v_330 = R1 144 | R1 = list_55C[8 * j + 7] 145 | R11 = R0 ^ R1 146 | R1 = int(self.UBFX(R3, 0x10, 8)) 147 | R0 = R8 >> 24 148 | R0 = self.dword_6[R0] 149 | R1 = self.dword_7[R1] 150 | R0 = R0 ^ R1 151 | R1 = int(self.UBFX(R12, 8, 8)) 152 | R1 = self.dword_8[R1] 153 | R0 = R0 ^ R1 154 | R1 = int(self.UTFX(R9)) 155 | R1 = self.dword_9[R1] 156 | R0 = R0 ^ R1 157 | R1 = int(self.UBFX(R8, 0x10, 8)) 158 | R6 = R0 ^ LR 159 | R0 = R9 >> 24 160 | R0 = self.dword_6[R0] 161 | R1 = self.dword_7[R1] 162 | R0 = R0 ^ R1 163 | R1 = int(self.UBFX(R3, 8, 8)) 164 | R1 = self.dword_8[R1] 165 | R0 = R0 ^ R1 166 | R1 = int(self.UTFX(R12)) 167 | R1 = self.dword_9[R1] 168 | R0 = R0 ^ R1 169 | R1 = v_330 170 | LR = R0 ^ R1 171 | R0 = int(self.UTFX(R3)) 172 | R0 = self.dword_9[R0] 173 | R4 = R12 >> 24 174 | R1 = int(self.UBFX(R8, 8, 8)) 175 | R4 = self.dword_6[R4] 176 | R5 = int(self.UBFX(R9, 16, 8)) 177 | R1 = self.dword_8[R1] 178 | R5 = self.dword_7[R5] 179 | R5 = R5 ^ R4 180 | R1 = R1 ^ R5 181 | R0 = R0 ^ R1 182 | R1 = v_334 183 | R1 = R1 ^ R0 184 | R0 = R1 >> 0x18 185 | v_334 = R0 186 | if j == 4: 187 | break 188 | else: 189 | R4 = int(self.UBFX(R1, 16, 8)) 190 | R5 = R11 >> 24 191 | R10 = R6 192 | R5 = self.dword_6[R5] 193 | R4 = self.dword_7[R4] 194 | R5 = R5 ^ R4 195 | R4 = int(self.UBFX(LR, 8, 8)) 196 | R4 = self.dword_8[R4] 197 | R5 = R5 ^ R4 198 | R4 = int(self.UTFX(R10)) 199 | R4 = self.dword_9[R4] 200 | R5 = R5 ^ R4 201 | R4 = list_55C[8 * j + 11] 202 | R0 = R5 ^ R4 203 | v_33C = R0 204 | R4 = int(self.UBFX(R11, 16, 8)) 205 | R5 = R10 >> 24 206 | R5 = self.dword_6[R5] 207 | R4 = self.dword_7[R4] 208 | R5 = R5 ^ R4 209 | R4 = int(self.UBFX(R1, 8, 8)) 210 | R0 = list_55C[8 * j + 9] 211 | R9 = list_55C[8 * j + 8] 212 | R1 = int(self.UTFX(R1)) 213 | R4 = self.dword_8[R4] 214 | R1 = self.dword_9[R1] 215 | R5 = R5 ^ R4 216 | R4 = int(self.UTFX(LR)) 217 | R4 = self.dword_9[R4] 218 | R5 = R5 ^ R4 219 | R4 = list_55C[8 * j + 10] 220 | R4 = R4 ^ R5 221 | v_338 = R4 222 | R5 = int(self.UBFX(R10, 16, 8)) 223 | R4 = LR >> 24 224 | R4 = self.dword_6[R4] 225 | R5 = self.dword_7[R5] 226 | R4 = R4 ^ R5 227 | R5 = int(self.UBFX(R11, 8, 8)) 228 | R5 = self.dword_8[R5] 229 | R4 = R4 ^ R5 230 | R1 = R1 ^ R4 231 | R4 = R1 ^ R0 232 | R0 = v_334 233 | R1 = int(self.UBFX(LR, 16, 8)) 234 | R5 = int(self.UBFX(R10, 8, 8)) 235 | R0 = self.dword_6[R0] 236 | R1 = self.dword_7[R1] 237 | R5 = self.dword_8[R5] 238 | R0 = R0 ^ R1 239 | R1 = int(self.UTFX(R11)) 240 | R1 = self.dword_9[R1] 241 | R0 = R0 ^ R5 242 | R0 = R0 ^ R1 243 | R12 = R0 ^ R9 244 | R2 = R11 >> 24 245 | R3 = int(self.UBFX(R1, 16, 8)) 246 | R10 = R6 247 | R0 = R10 >> 24 248 | R2 = self.dword_0[R2] 249 | R2 = int(self.parseLong(self.toHex(R2) + "000000", 10, 16)) 250 | R9 = R10 251 | R3 = self.dword_0[R3] 252 | R3 = int(self.parseLong(self.toHex(R3) + "0000", 10, 16)) 253 | R0 = self.dword_0[R0] 254 | R0 = int(self.parseLong(self.toHex(R0) + "000000", 10, 16)) 255 | R2 = R2 ^ R3 256 | v_350 = R2 257 | R2 = int(self.UBFX(R11, 0x10, 8)) 258 | R2 = self.dword_0[R2] 259 | R2 = int(self.parseLong(self.toHex(R2) + "0000", 10, 16)) 260 | R0 = R0 ^ R2 261 | R2 = int(self.UBFX(R1, 8, 8)) 262 | R1 = int(self.UTFX(R1)) 263 | R2 = self.dword_0[R2] 264 | R2 = int(self.parseLong(self.toHex(R2) + "00", 10, 16)) 265 | R1 = self.dword_0[R1] 266 | R0 = R0 ^ R2 267 | R2 = int(self.UTFX(LR)) 268 | R2 = self.dword_0[R2] 269 | R12 = R0 ^ R2 270 | R0 = list_55C[l55cl - 2] 271 | R10 = list_55C[l55cl - 3] 272 | R12 = R12 ^ R0 273 | R2 = list_55C[l55cl - 1] 274 | R0 = LR >> 24 275 | v_34C = R2 276 | R2 = int(self.UBFX(R9, 0x10, 8)) 277 | R0 = self.dword_0[R0] 278 | R0 = int(self.parseLong(self.toHex(R0) + "000000", 10, 16)) 279 | R2 = self.dword_0[R2] 280 | R2 = int(self.parseLong(self.toHex(R2) + "0000", 10, 16)) 281 | R0 = R0 ^ R2 282 | R2 = int(self.UBFX(R11, 8, 8)) 283 | R2 = self.dword_0[R2] 284 | R2 = int(self.parseLong(self.toHex(R2) + "00", 10, 16)) 285 | R0 = R0 ^ R2 286 | R0 = R0 ^ R1 287 | R1 = R0 ^ R10 288 | R0 = v_334 289 | R2 = int(self.UBFX(LR, 0x10, 8)) 290 | R0 = self.dword_0[R0] 291 | R0 = int(self.parseLong(self.toHex(R0) + "000000", 10, 16)) 292 | R2 = self.dword_0[R2] 293 | R2 = int(self.parseLong(self.toHex(R2) + "0000", 10, 16)) 294 | R0 = R0 ^ R2 295 | R2 = int(self.UBFX(R9, 8, 8)) 296 | R2 = self.dword_0[R2] 297 | R2 = int(self.parseLong(self.toHex(R2) + "00", 10, 16)) 298 | R0 = R0 ^ R2 299 | R2 = int(self.UTFX(R11)) 300 | R2 = self.dword_0[R2] 301 | R0 = R0 ^ R2 302 | R2 = int(self.UTFX(R9)) 303 | R2 = self.dword_0[R2] 304 | R3 = int(self.UBFX(LR, 8, 8)) 305 | R3 = self.dword_0[R3] 306 | R3 = int(self.parseLong(self.toHex(R3) + "00", 10, 16)) 307 | R5 = v_350 308 | R6 = list_55C[l55cl - 4] 309 | R3 = R3 ^ R5 310 | R2 = R2 ^ R3 311 | R3 = v_34C 312 | R0 = R0 ^ R6 313 | R2 = R2 ^ R3 314 | list_740 = self.hex_list([R0, R1, R12, R2]) 315 | result = result + list_740 316 | return result 317 | 318 | def calculate(self, content): 319 | hex_6A8 = 0 320 | tmp_list = [] 321 | length = len(content) 322 | list_6B0 = self.LIST_6B0.copy() 323 | for item in content: 324 | tmp_list.append(item) 325 | 326 | divisible = length % 0x80 327 | tmp = 0x80 - divisible 328 | if tmp > 0x11: 329 | tmp_list.append(0x80) 330 | for i in range(tmp - 0x11): 331 | tmp_list.append(0) 332 | for j in range(16): 333 | tmp_list.append(0) 334 | else: 335 | tmp_list.append(128) 336 | for i in range(128 - 16 + tmp + 1): 337 | tmp_list.append(0) 338 | for j in range(16): 339 | tmp_list.append(0) 340 | tmp_list_size = len(tmp_list) 341 | d = tmp_list_size // 0x80 342 | for i in range(tmp_list_size // 0x80): 343 | if (tmp_list_size // 128 - 1) == i: 344 | ending = self.handle_ending(hex_6A8, divisible) 345 | for j in range(8): 346 | index = tmp_list_size - j - 1 347 | tmp_list[index] = ending[7 - j] 348 | param_list = [] 349 | for j in range(32): 350 | tmpss = "" 351 | for k in range(4): 352 | tmp_string = self.toHex(tmp_list[0x80 * i + 4 * j + k]) 353 | if len(tmp_string) < 2: 354 | tmp_string = "0" + tmp_string 355 | tmpss = tmpss + tmp_string 356 | param_list.append(int(self.parseLong(tmpss, 10, 16))) 357 | list_3B8 = self.hex_27E(param_list) 358 | list_6B0 = self.hex_30A(list_6B0, list_3B8) 359 | hex_6A8 += 0x400 360 | list_8D8 = self.hex_C52(list_6B0) 361 | return list_8D8 362 | 363 | def convertLongList(self, content): 364 | if len(content) == 0: 365 | return [] 366 | result = [] 367 | for i in content: 368 | result.append(i) 369 | return result 370 | 371 | def dump_list(self, content): 372 | size = len(content) 373 | ssize = size // 4 374 | result = [] 375 | for index in range(ssize): 376 | tmp_string = "" 377 | for j in range(4): 378 | tmp = self.toHex(content[4 * index + j]) 379 | if len(tmp) < 2: 380 | tmp = "0" + tmp 381 | 382 | tmp_string = tmp_string + tmp 383 | i = int(self.parseLong(tmp_string, 10, 16)) 384 | result.append(int(i)) 385 | return result 386 | 387 | def hex_CF8(self, param_list): 388 | list_388 = [] 389 | list_378 = param_list 390 | for i in range(0xA): 391 | R3 = list_378[0] 392 | R8 = list_378[1] 393 | R9 = list_378[2] 394 | R5 = list_378[3] 395 | R6 = int(self.UBFX(R5, 8, 8)) 396 | R6 = self.dword_0[R6] 397 | R6 = int(self.parseLong(self.toHex(R6) + "0000", 10, 16)) 398 | R4 = int(self.UBFX(R5, 0x10, 8)) 399 | R11 = self.dword_1[i] 400 | R4 = self.dword_0[R4] 401 | R4 = int(self.parseLong(self.toHex(R4) + "000000", 10, 16)) 402 | R3 = R3 ^ R4 403 | R4 = int(self.UTFX(R5)) 404 | R3 = R3 ^ R6 405 | R4 = self.dword_0[R4] 406 | R4 = int(self.parseLong(self.toHex(R4) + "00", 10, 16)) 407 | R3 = R3 ^ R4 408 | R4 = R5 >> 24 409 | R4 = self.dword_0[R4] 410 | R3 = R3 ^ R4 411 | R3 = R3 ^ R11 412 | R2 = R8 ^ R3 413 | R4 = R9 ^ R2 414 | R5 = R5 ^ R4 415 | list_378 = [R3, R2, R4, R5] 416 | list_388 = list_388 + list_378 417 | l388l = len(list_388) 418 | list_478 = [] 419 | for i in range(0x9): 420 | R5 = list_388[l388l - 8 - 4 * i] 421 | R4 = int(self.UBFX(R5, 0x10, 8)) 422 | R6 = R5 >> 0x18 423 | R6 = self.dword_2[R6] 424 | R4 = self.dword_3[R4] 425 | R6 = R6 ^ R4 426 | R4 = int(self.UBFX(R5, 8, 8)) 427 | R5 = int(self.UTFX(R5)) 428 | R4 = self.dword_4[R4] 429 | R5 = self.dword_5[R5] 430 | R6 = R6 ^ R4 431 | R6 = R6 ^ R5 432 | list_478.append(R6) 433 | R6 = list_388[l388l - 7 - 4 * i] 434 | R1 = int(self.UBFX(R6, 0x10, 8)) 435 | R4 = R6 >> 0x18 436 | R4 = self.dword_2[R4] 437 | R1 = self.dword_3[R1] 438 | R1 = R1 ^ R4 439 | R4 = int(self.UBFX(R6, 8, 8)) 440 | R4 = self.dword_4[R4] 441 | R1 = R1 ^ R4 442 | R4 = int(self.UTFX(R6)) 443 | R4 = self.dword_5[R4] 444 | R1 = R1 ^ R4 445 | list_478.append(R1) 446 | R1 = list_388[l388l - 6 - 4 * i] 447 | R6 = int(self.UBFX(R1, 0x10, 8)) 448 | R4 = R1 >> 0x18 449 | R4 = self.dword_2[R4] 450 | R6 = self.dword_3[R6] 451 | R4 = R4 ^ R6 452 | R6 = int(self.UBFX(R1, 8, 8)) 453 | R1 = int(self.UTFX(R1)) 454 | R6 = self.dword_4[R6] 455 | R1 = self.dword_5[R1] 456 | R4 = R4 ^ R6 457 | R1 = R1 ^ R4 458 | list_478.append(R1) 459 | R0 = list_388[l388l - 5 - 4 * i] 460 | R1 = int(self.UTFX(R0)) 461 | R4 = int(self.UBFX(R0, 8, 8)) 462 | R6 = R0 >> 0x18 463 | R0 = int(self.UBFX(R0, 0x10, 8)) 464 | R6 = self.dword_2[R6] 465 | R0 = self.dword_3[R0] 466 | R4 = self.dword_4[R4] 467 | R1 = self.dword_5[R1] 468 | R0 = R0 ^ R6 469 | R0 = R0 ^ R4 470 | R0 = R0 ^ R1 471 | list_478.append(R0) 472 | list_468 = param_list + list_388 473 | return list_468 474 | 475 | def handle_ending(self, num, r0): 476 | s = self.toHex(num) 477 | r1 = None 478 | r2 = None 479 | if len(s) <= 8: 480 | r1 = num 481 | r2 = 0 482 | else: 483 | num_str = self.toHex(num) 484 | length = len(num) 485 | r1 = self.parseLong(num_str[: length - 8], 10, 16) 486 | r2 = self.parseLong(num_str[2 : length - 8], 10, 16) 487 | r1 = self.ADDS(r1, r0 << 3) 488 | r2 = self.ADC(r2, r0 >> 29) 489 | a = self.hex_list([r2, r1]) 490 | return self.hex_list([r2, r1]) 491 | 492 | def UTFX(self, num): 493 | tmp_string = self.toBinaryString(num) 494 | start = len(tmp_string) - 8 495 | return self.parseLong(tmp_string[start:], 10, 2) 496 | 497 | def hex_27E(self, param_list): 498 | r6 = param_list[0] 499 | r8 = param_list[1] 500 | for i in range(0x40): 501 | r0 = param_list[2 * i + 0x1C] 502 | r5 = param_list[2 * i + 0x1D] 503 | r4 = self.LSRS(r0, 0x13) 504 | r3 = self.LSRS(r0, 0x1D) 505 | lr = r4 | self.check(r5) << 13 506 | r4 = self.LSLS(r0, 3) 507 | r4 = r4 | self.check(r5) >> 29 508 | r3 = r3 | self.check(r5) << 3 509 | r4 = r4 ^ self.check(r0) >> 6 510 | lr = lr ^ r4 511 | r4 = self.LSRS(r5, 6) 512 | r4 = r4 | self.check(r0) << 26 513 | r9 = r3 ^ r4 514 | r4 = self.LSRS(r5, 0x13) 515 | r0 = r4 | self.check(r0) << 13 516 | r10 = param_list[2 * i + 0x12] 517 | r3 = param_list[2 * i + 0x13] 518 | r5 = param_list[2 * i + 0x2] 519 | r4 = param_list[2 * i + 0x3] 520 | r0 = r0 ^ r9 521 | r3 = self.ADDS(r3, r8) 522 | r6 = self.ADC(r6, r10) 523 | r8 = self.ADDS(r3, r0) 524 | lr = self.ADC(lr, r6) 525 | r6 = self.LSRS(r4, 7) 526 | r3 = self.LSRS(r4, 8) 527 | r6 = r6 | self.check(r5) << 25 528 | r3 = r3 | self.check(r5) << 24 529 | r3 = int(self.EORS(r3, r6)) 530 | r6 = self.LSRS(r5, 1) 531 | r0 = int(self.RRX(r4)) 532 | r0 = int(self.EORS(r0, r3)) 533 | r3 = r6 | self.check(r4) << 31 534 | r6 = self.LSRS(r5, 8) 535 | r0 = int(self.ADDS(r0, r8)) 536 | r6 = r6 | self.check(r4) << 24 537 | r8 = r4 538 | r6 = r6 ^ self.check(r5) >> 7 539 | r3 = r3 ^ r6 540 | r6 = r5 541 | r3 = self.ADC(r3, lr) 542 | param_list = param_list + [r3, r0] 543 | return param_list 544 | 545 | def hex_30A(self, param_list, list_3B8): 546 | v_3A0 = param_list[7] 547 | v_3A4 = param_list[6] 548 | v_374 = param_list[5] 549 | v_378 = param_list[4] 550 | LR = param_list[0] 551 | R12 = param_list[1] 552 | v_39C = param_list[2] 553 | v_398 = param_list[3] 554 | v_3AC = param_list[11] 555 | v_3A8 = param_list[10] 556 | R9 = param_list[12] 557 | R10 = param_list[13] 558 | R5 = param_list[9] 559 | R8 = param_list[8] 560 | R4 = param_list[15] 561 | R6 = param_list[14] 562 | for index in range(10): 563 | v_384 = R5 564 | R3 = self.rodata[0x10 * index] 565 | R1 = self.rodata[0x10 * index + 2] 566 | R2 = self.rodata[0x10 * index + 1] 567 | R3 = self.ADDS(R3, R6) 568 | R6 = self.check(R8) >> 14 569 | v_390 = R1 570 | R6 = R6 | self.check(R5) << 18 571 | R1 = self.rodata[0x10 * index + 3] 572 | R0 = self.rodata[0x10 * index + 4] 573 | v_36C = R0 574 | R0 = self.ADC(R2, R4) 575 | R2 = self.LSRS(R5, 0x12) 576 | R4 = self.LSRS(R5, 0xE) 577 | R2 = R2 | self.check(R8) << 14 578 | R4 = R4 | self.check(R8) << 18 579 | R2 = self.EORS(R2, R4) 580 | R4 = self.LSLS(R5, 0x17) 581 | R4 = R4 | self.check(R8) >> 9 582 | v_38C = R1 583 | R2 = self.EORS(R2, R4) 584 | R4 = self.check(R8) >> 18 585 | R4 = R4 | self.check(R5) << 14 586 | R6 = self.EORS(R6, R4) 587 | R4 = self.LSRS(R5, 9) 588 | R4 = R4 | self.check(R8) << 23 589 | v_354 = R8 590 | R6 = self.EORS(R6, R4) 591 | R3 = self.ADDS(R3, R6) 592 | R0 = self.ADCS(R0, R2) 593 | R2 = list_3B8[0x10 * index + 1] 594 | R2 = self.ADDS(R2, R3) 595 | R3 = list_3B8[0x10 * index + 3] 596 | R6 = list_3B8[0x10 * index] 597 | v_358 = R10 598 | R6 = self.ADCS(R6, R0) 599 | R0 = v_3AC 600 | v_360 = R3 601 | R0 = R0 ^ R10 602 | R3 = list_3B8[0x10 * index + 2] 603 | R0 = self.ANDS(R0, R5) 604 | R1 = list_3B8[0x10 * index + 5] 605 | R4 = R0 ^ R10 606 | R0 = v_3A8 607 | v_364 = R1 608 | R0 = R0 ^ R9 609 | R1 = v_374 610 | R0 = R0 & R8 611 | R8 = v_39C 612 | R0 = R0 ^ R9 613 | v_35C = R3 614 | R10 = self.ADDS(R2, R0) 615 | R0 = v_398 616 | R11 = self.ADC(R6, R4) 617 | R3 = v_378 618 | R2 = R0 | R12 619 | R6 = R0 & R12 620 | R2 = self.ANDS(R2, R1) 621 | R1 = R0 622 | R2 = self.ORRS(R2, R6) 623 | R6 = R8 | LR 624 | R6 = self.ANDS(R6, R3) 625 | R3 = R8 & LR 626 | R3 = self.ORRS(R3, R6) 627 | R6 = self.check(R12) << 30 628 | R0 = self.check(R12) >> 28 629 | R6 = R6 | self.check(LR) >> 2 630 | R0 = R0 | self.check(LR) << 4 631 | R4 = self.check(LR) >> 28 632 | R0 = self.EORS(R0, R6) 633 | R6 = self.check(R12) << 25 634 | R6 = R6 | self.check(LR) >> 7 635 | R4 = R4 | self.check(R12) << 4 636 | R0 = self.EORS(R0, R6) 637 | R6 = self.check(R12) >> 2 638 | R6 = R6 | self.check(LR) << 30 639 | R3 = self.ADDS(R3, R10) 640 | R6 = R6 ^ R4 641 | R4 = self.check(R12) >> 7 642 | R4 = R4 | self.check(LR) << 25 643 | R2 = self.ADC(R2, R11) 644 | R6 = self.EORS(R6, R4) 645 | v_37C = R12 646 | R5 = self.ADDS(R3, R6) 647 | R6 = self.ADC(R2, R0) 648 | R0 = R6 | R12 649 | R2 = R6 & R12 650 | R0 = self.ANDS(R0, R1) 651 | R3 = self.LSRS(R6, 0x1C) 652 | R0 = self.ORRS(R0, R2) 653 | R2 = self.LSLS(R6, 0x1E) 654 | R2 = R2 | self.check(R5) >> 2 655 | R3 = R3 | self.check(R5) << 4 656 | R2 = self.EORS(R2, R3) 657 | R3 = self.LSLS(R6, 0x19) 658 | R3 = R3 | self.check(R5) >> 7 659 | R4 = self.LSRS(R5, 0x1C) 660 | R3 = self.EORS(R3, R2) 661 | R2 = self.LSRS(R6, 2) 662 | R2 = R2 | self.check(R5) << 30 663 | R4 = R4 | self.check(R6) << 4 664 | R2 = self.EORS(R2, R4) 665 | R4 = self.LSRS(R6, 7) 666 | R4 = R4 | self.check(R5) << 25 667 | R12 = R6 668 | R2 = self.EORS(R2, R4) 669 | R4 = R5 | LR 670 | R4 = R4 & R8 671 | R6 = R5 & LR 672 | R4 = self.ORRS(R4, R6) 673 | v_388 = R5 674 | R5 = self.ADDS(R2, R4) 675 | R0 = self.ADCS(R0, R3) 676 | v_398 = R1 677 | R4 = R9 678 | v_350 = R0 679 | R0 = v_3A4 680 | R1 = v_3A0 681 | v_380 = LR 682 | LR = self.ADDS(R0, R10) 683 | R9 = self.ADC(R1, R11) 684 | R0 = v_3AC 685 | R6 = self.check(LR) >> 14 686 | R1 = v_384 687 | R3 = self.check(R9) >> 18 688 | R2 = self.check(R9) >> 14 689 | R3 = R3 | self.check(LR) << 14 690 | R2 = R2 | self.check(LR) << 18 691 | R2 = self.EORS(R2, R3) 692 | R3 = self.check(R9) << 23 693 | R3 = R3 | self.check(LR) >> 9 694 | R6 = R6 | self.check(R9) << 18 695 | R2 = self.EORS(R2, R3) 696 | R3 = self.check(LR) >> 18 697 | R3 = R3 | self.check(R9) << 14 698 | v_39C = R8 699 | R3 = self.EORS(R3, R6) 700 | R6 = self.check(R9) >> 9 701 | R6 = R6 | self.check(LR) << 23 702 | R8 = v_354 703 | R3 = self.EORS(R3, R6) 704 | R6 = R0 ^ R1 705 | R6 = R6 & R9 706 | v_370 = R12 707 | R6 = self.EORS(R6, R0) 708 | R0 = v_3A8 709 | R1 = R0 ^ R8 710 | R1 = R1 & LR 711 | R1 = self.EORS(R1, R0) 712 | R0 = v_358 713 | R1 = self.ADDS(R1, R4) 714 | R6 = self.ADCS(R6, R0) 715 | R0 = v_390 716 | R1 = self.ADDS(R1, R0) 717 | R0 = v_38C 718 | R6 = self.ADCS(R6, R0) 719 | R0 = v_360 720 | R1 = self.ADDS(R1, R0) 721 | R0 = v_35C 722 | R6 = self.ADCS(R6, R0) 723 | R1 = self.ADDS(R1, R3) 724 | R3 = self.ADC(R6, R2) 725 | R2 = v_350 726 | R0 = self.ADDS(R5, R1) 727 | R5 = v_37C 728 | R4 = self.ADC(R2, R3) 729 | v_390 = R4 730 | R2 = R4 | R12 731 | R6 = R4 & R12 732 | R2 = self.ANDS(R2, R5) 733 | R5 = self.LSRS(R4, 0x1C) 734 | R10 = R2 | R6 735 | R2 = self.LSLS(R4, 0x1E) 736 | R2 = R2 | self.check(R0) >> 2 737 | R5 = R5 | self.check(R0) << 4 738 | R2 = self.EORS(R2, R5) 739 | R5 = self.LSLS(R4, 0x19) 740 | R5 = R5 | self.check(R0) >> 7 741 | R6 = self.LSRS(R0, 0x1C) 742 | R12 = R2 ^ R5 743 | R2 = self.LSRS(R4, 2) 744 | R2 = R2 | self.check(R0) << 30 745 | R6 = R6 | self.check(R4) << 4 746 | R2 = self.EORS(R2, R6) 747 | R6 = self.LSRS(R4, 7) 748 | R4 = v_388 749 | R6 = R6 | self.check(R0) << 25 750 | R5 = v_380 751 | R2 = self.EORS(R2, R6) 752 | R6 = R0 | R4 753 | R4 = self.ANDS(R4, R0) 754 | R6 = self.ANDS(R6, R5) 755 | v_38C = R0 756 | R4 = self.ORRS(R4, R6) 757 | R6 = LR ^ R8 758 | R0 = self.ADDS(R2, R4) 759 | v_3A4 = R0 760 | R0 = self.ADC(R12, R10) 761 | v_3A0 = R0 762 | R0 = v_378 763 | R10 = self.ADDS(R1, R0) 764 | R0 = v_374 765 | R6 = R6 & R10 766 | R1 = self.ADC(R3, R0) 767 | R5 = self.check(R10) >> 14 768 | R0 = v_384 769 | R6 = R6 ^ R8 770 | R3 = self.LSRS(R1, 0x12) 771 | R4 = self.LSRS(R1, 0xE) 772 | R3 = R3 | self.check(R10) << 14 773 | R4 = R4 | self.check(R10) << 18 774 | R3 = self.EORS(R3, R4) 775 | R4 = self.LSLS(R1, 0x17) 776 | R4 = R4 | self.check(R10) >> 9 777 | R5 = R5 | self.check(R1) << 18 778 | R11 = R3 ^ R4 779 | R3 = self.check(R10) >> 18 780 | R3 = R3 | self.check(R1) << 14 781 | v_378 = R1 782 | R3 = self.EORS(R3, R5) 783 | R5 = self.LSRS(R1, 9) 784 | R5 = R5 | self.check(R10) << 23 785 | R3 = self.EORS(R3, R5) 786 | R5 = R9 ^ R0 787 | R5 = self.ANDS(R5, R1) 788 | R1 = v_3A8 789 | R5 = self.EORS(R5, R0) 790 | R0 = v_36C 791 | R4 = self.ADDS(R0, R1) 792 | R2 = self.rodata[0x10 * index + 5] 793 | R0 = v_3AC 794 | R2 = self.ADCS(R2, R0) 795 | R0 = v_364 796 | R4 = self.ADDS(R4, R0) 797 | R12 = list_3B8[0x10 * index + 4] 798 | R0 = v_3A4 799 | R2 = self.ADC(R2, R12) 800 | R6 = self.ADDS(R6, R4) 801 | R2 = self.ADCS(R2, R5) 802 | R3 = self.ADDS(R3, R6) 803 | R11 = self.ADC(R11, R2) 804 | R1 = self.ADDS(R0, R3) 805 | R0 = v_3A0 806 | R6 = v_390 807 | R4 = self.check(R1) >> 28 808 | R0 = self.ADC(R0, R11) 809 | R5 = v_370 810 | R2 = R0 | R6 811 | R6 = self.ANDS(R6, R0) 812 | R2 = self.ANDS(R2, R5) 813 | R5 = self.LSRS(R0, 0x1C) 814 | R12 = R2 | R6 815 | R6 = self.LSLS(R0, 0x1E) 816 | R6 = R6 | self.check(R1) >> 2 817 | R5 = R5 | self.check(R1) << 4 818 | R6 = self.EORS(R6, R5) 819 | R5 = self.LSLS(R0, 0x19) 820 | R5 = R5 | self.check(R1) >> 7 821 | R4 = R4 | self.check(R0) << 4 822 | R6 = self.EORS(R6, R5) 823 | R5 = self.LSRS(R0, 2) 824 | R5 = R5 | self.check(R1) << 30 825 | v_3AC = R0 826 | R5 = self.EORS(R5, R4) 827 | R4 = self.LSRS(R0, 7) 828 | R0 = v_38C 829 | R4 = R4 | self.check(R1) << 25 830 | R2 = v_388 831 | R5 = self.EORS(R5, R4) 832 | R4 = R1 | R0 833 | v_3A8 = R1 834 | R4 = self.ANDS(R4, R2) 835 | R2 = R1 & R0 836 | R2 = self.ORRS(R2, R4) 837 | R0 = self.ADDS(R5, R2) 838 | v_3A4 = R0 839 | R0 = self.ADC(R6, R12) 840 | v_3A0 = R0 841 | R0 = v_39C 842 | R2 = v_398 843 | R0 = self.ADDS(R0, R3) 844 | v_39C = R0 845 | R11 = self.ADC(R11, R2) 846 | R4 = self.LSRS(R0, 0xE) 847 | R3 = self.check(R11) >> 18 848 | R6 = self.check(R11) >> 14 849 | R3 = R3 | self.check(R0) << 14 850 | R6 = R6 | self.check(R0) << 18 851 | R3 = self.EORS(R3, R6) 852 | R6 = self.check(R11) << 23 853 | R6 = R6 | self.check(R0) >> 9 854 | R4 = R4 | self.check(R11) << 18 855 | R1 = self.EORS(R3, R6) 856 | R6 = self.LSRS(R0, 0x12) 857 | R6 = R6 | self.check(R11) << 14 858 | R3 = R10 ^ LR 859 | R6 = self.EORS(R6, R4) 860 | R4 = self.check(R11) >> 9 861 | R3 = self.ANDS(R3, R0) 862 | R4 = R4 | self.check(R0) << 23 863 | R5 = R6 ^ R4 864 | v_398 = R1 865 | R3 = R3 ^ LR 866 | R1 = v_378 867 | R6 = self.rodata[0x10 * index + 6] 868 | R12 = self.rodata[0x10 * index + 7] 869 | R4 = R1 ^ R9 870 | R0 = v_384 871 | R6 = self.ADDS(R6, R8) 872 | R4 = R4 & R11 873 | R12 = self.ADC(R12, R0) 874 | R4 = R4 ^ R9 875 | R8 = list_3B8[0x10 * index + 7] 876 | R2 = list_3B8[0x10 * index + 6] 877 | R6 = self.ADDS(R6, R8) 878 | R0 = v_398 879 | R2 = self.ADC(R2, R12) 880 | R3 = self.ADDS(R3, R6) 881 | R2 = self.ADCS(R2, R4) 882 | R6 = self.ADDS(R3, R5) 883 | R12 = self.ADC(R2, R0) 884 | R0 = v_3A4 885 | R4 = v_390 886 | R1 = self.ADDS(R0, R6) 887 | R0 = v_3A0 888 | v_384 = R1 889 | R5 = self.ADC(R0, R12) 890 | R0 = v_3AC 891 | R8 = self.check(R1) >> 28 892 | R2 = R5 | R0 893 | R3 = R8 | self.check(R5) << 4 894 | R2 = self.ANDS(R2, R4) 895 | R4 = R5 & R0 896 | R0 = R2 | R4 897 | R4 = self.LSLS(R5, 0x1E) 898 | R2 = self.LSRS(R5, 0x1C) 899 | R4 = R4 | self.check(R1) >> 2 900 | R2 = R2 | self.check(R1) << 4 901 | v_3A0 = R0 902 | R2 = self.EORS(R2, R4) 903 | R4 = self.LSLS(R5, 0x19) 904 | R4 = R4 | self.check(R1) >> 7 905 | R0 = v_3A8 906 | R2 = self.EORS(R2, R4) 907 | R4 = self.LSRS(R5, 2) 908 | R4 = R4 | self.check(R1) << 30 909 | R8 = R5 910 | R3 = self.EORS(R3, R4) 911 | R4 = self.LSRS(R5, 7) 912 | R4 = R4 | self.check(R1) << 25 913 | R5 = v_38C 914 | R3 = self.EORS(R3, R4) 915 | R4 = R1 | R0 916 | R4 = self.ANDS(R4, R5) 917 | R5 = R1 & R0 918 | R4 = self.ORRS(R4, R5) 919 | v_36C = R8 920 | R0 = self.ADDS(R3, R4) 921 | v_3A4 = R0 922 | R0 = v_3A0 923 | R0 = self.ADCS(R0, R2) 924 | v_3A0 = R0 925 | R0 = v_380 926 | R2 = v_37C 927 | R0 = self.ADDS(R0, R6) 928 | R5 = self.ADC(R12, R2) 929 | v_37C = R5 930 | R4 = self.LSRS(R0, 0xE) 931 | v_380 = R0 932 | R2 = self.LSRS(R5, 0x12) 933 | R3 = self.LSRS(R5, 0xE) 934 | R2 = R2 | self.check(R0) << 14 935 | R3 = R3 | self.check(R0) << 18 936 | R2 = self.EORS(R2, R3) 937 | R3 = self.LSLS(R5, 0x17) 938 | R3 = R3 | self.check(R0) >> 9 939 | R4 = R4 | self.check(R5) << 18 940 | R1 = R2 ^ R3 941 | R3 = self.LSRS(R0, 0x12) 942 | R3 = R3 | self.check(R5) << 14 943 | v_398 = R1 944 | R3 = self.EORS(R3, R4) 945 | R4 = self.LSRS(R5, 9) 946 | R1 = v_378 947 | R4 = R4 | self.check(R0) << 23 948 | R12 = R3 ^ R4 949 | R3 = list_3B8[0x10 * index + 9] 950 | R4 = R11 ^ R1 951 | R4 = self.ANDS(R4, R5) 952 | R4 = self.EORS(R4, R1) 953 | R1 = v_39C 954 | R5 = R1 ^ R10 955 | R5 = self.ANDS(R5, R0) 956 | R5 = R5 ^ R10 957 | R2 = self.rodata[0x10 * index + 8] 958 | R0 = self.ADDS(R2, LR) 959 | R2 = self.rodata[0x10 * index + 9] 960 | R2 = self.ADC(R2, R9) 961 | R0 = self.ADDS(R0, R3) 962 | R3 = list_3B8[0x10 * index + 8] 963 | R2 = self.ADCS(R2, R3) 964 | R0 = self.ADDS(R0, R5) 965 | R2 = self.ADCS(R2, R4) 966 | R1 = self.ADDS(R0, R12) 967 | R0 = v_398 968 | R3 = v_3AC 969 | R4 = self.ADC(R2, R0) 970 | R0 = v_3A4 971 | R6 = self.ADDS(R0, R1) 972 | R0 = v_3A0 973 | v_3A4 = R6 974 | R0 = self.ADCS(R0, R4) 975 | v_3A0 = R0 976 | R2 = R0 | R8 977 | R2 = self.ANDS(R2, R3) 978 | R3 = R0 & R8 979 | LR = R2 | R3 980 | R8 = R6 981 | R3 = self.LSLS(R0, 0x1E) 982 | R5 = self.LSRS(R0, 0x1C) 983 | R3 = R3 | self.check(R8) >> 2 984 | R5 = R5 | self.check(R8) << 4 985 | R3 = self.EORS(R3, R5) 986 | R5 = self.LSLS(R0, 0x19) 987 | R5 = R5 | self.check(R8) >> 7 988 | R2 = self.check(R8) >> 28 989 | R12 = R3 ^ R5 990 | R5 = self.LSRS(R0, 2) 991 | R5 = R5 | self.check(R8) << 30 992 | R2 = R2 | self.check(R0) << 4 993 | R2 = self.EORS(R2, R5) 994 | R5 = self.LSRS(R0, 7) 995 | R3 = v_384 996 | R5 = R5 | self.check(R8) << 25 997 | R6 = v_3A8 998 | R2 = self.EORS(R2, R5) 999 | R5 = R8 | R3 1000 | R5 = self.ANDS(R5, R6) 1001 | R6 = R8 & R3 1002 | R5 = self.ORRS(R5, R6) 1003 | R0 = self.ADDS(R2, R5) 1004 | v_398 = R0 1005 | R2 = v_388 1006 | R12 = self.ADC(R12, LR) 1007 | R0 = v_370 1008 | R3 = self.ADDS(R1, R2) 1009 | R1 = v_380 1010 | R8 = self.ADC(R4, R0) 1011 | R0 = R3 1012 | R2 = self.check(R8) >> 18 1013 | R3 = self.check(R8) >> 14 1014 | R2 = R2 | self.check(R0) << 14 1015 | R3 = R3 | self.check(R0) << 18 1016 | R2 = self.EORS(R2, R3) 1017 | R3 = self.check(R8) << 23 1018 | R3 = R3 | self.check(R0) >> 9 1019 | R4 = self.LSRS(R0, 0xE) 1020 | LR = R2 ^ R3 1021 | R3 = self.LSRS(R0, 0x12) 1022 | R3 = R3 | self.check(R8) << 14 1023 | R4 = R4 | self.check(R8) << 18 1024 | R3 = self.EORS(R3, R4) 1025 | R4 = self.check(R8) >> 9 1026 | R4 = R4 | self.check(R0) << 23 1027 | R2 = R0 1028 | R0 = v_37C 1029 | R3 = self.EORS(R3, R4) 1030 | v_388 = R2 1031 | R4 = R0 ^ R11 1032 | R0 = v_39C 1033 | R4 = R4 & R8 1034 | R5 = R1 ^ R0 1035 | R4 = R4 ^ R11 1036 | R5 = self.ANDS(R5, R2) 1037 | R5 = self.EORS(R5, R0) 1038 | R6 = self.rodata[0x10 * index + 10] 1039 | R1 = self.ADDS(R6, R10) 1040 | R6 = self.rodata[0x10 * index + 11] 1041 | R0 = v_378 1042 | R6 = self.ADCS(R6, R0) 1043 | R2 = list_3B8[0x10 * index + 11] 1044 | R1 = self.ADDS(R1, R2) 1045 | R2 = list_3B8[0x10 * index + 10] 1046 | R0 = v_398 1047 | R2 = self.ADCS(R2, R6) 1048 | R1 = self.ADDS(R1, R5) 1049 | R2 = self.ADCS(R2, R4) 1050 | R1 = self.ADDS(R1, R3) 1051 | R4 = self.ADC(R2, LR) 1052 | R6 = v_3A0 1053 | R0 = self.ADDS(R0, R1) 1054 | R9 = self.ADC(R12, R4) 1055 | R3 = v_36C 1056 | R2 = R9 | R6 1057 | R5 = self.check(R9) >> 28 1058 | v_374 = R9 1059 | R2 = self.ANDS(R2, R3) 1060 | R3 = R9 & R6 1061 | R10 = R2 | R3 1062 | R3 = self.check(R9) << 30 1063 | R3 = R3 | self.check(R0) >> 2 1064 | R5 = R5 | self.check(R0) << 4 1065 | R3 = self.EORS(R3, R5) 1066 | R5 = self.check(R9) << 25 1067 | R5 = R5 | self.check(R0) >> 7 1068 | R6 = self.LSRS(R0, 0x1C) 1069 | R12 = R3 ^ R5 1070 | R5 = self.check(R9) >> 2 1071 | R5 = R5 | self.check(R0) << 30 1072 | R6 = R6 | self.check(R9) << 4 1073 | R5 = self.EORS(R5, R6) 1074 | R6 = self.check(R9) >> 7 1075 | R3 = v_3A4 1076 | R6 = R6 | self.check(R0) << 25 1077 | R2 = v_384 1078 | R5 = self.EORS(R5, R6) 1079 | R6 = R0 | R3 1080 | R6 = self.ANDS(R6, R2) 1081 | R2 = R0 & R3 1082 | R2 = R2 | R6 1083 | R2 = self.ADDS(R2, R5) 1084 | v_398 = R2 1085 | R2 = self.ADC(R12, R10) 1086 | v_378 = R2 1087 | R2 = v_38C 1088 | R12 = self.ADDS(R1, R2) 1089 | R1 = v_390 1090 | LR = self.ADC(R4, R1) 1091 | R4 = self.check(R12) >> 14 1092 | R1 = self.check(LR) >> 18 1093 | R2 = self.check(LR) >> 14 1094 | R1 = R1 | self.check(R12) << 14 1095 | R2 = R2 | self.check(R12) << 18 1096 | R1 = self.EORS(R1, R2) 1097 | R2 = self.check(LR) << 23 1098 | R2 = R2 | self.check(R12) >> 9 1099 | R4 = R4 | self.check(LR) << 18 1100 | R1 = self.EORS(R1, R2) 1101 | R2 = self.check(R12) >> 18 1102 | R2 = R2 | self.check(LR) << 14 1103 | v_390 = R1 1104 | R2 = self.EORS(R2, R4) 1105 | R4 = self.check(LR) >> 9 1106 | R1 = v_37C 1107 | R4 = R4 | self.check(R12) << 23 1108 | R10 = R2 ^ R4 1109 | R2 = v_388 1110 | R4 = R8 ^ R1 1111 | R4 = R4 & LR 1112 | R4 = self.EORS(R4, R1) 1113 | R1 = v_380 1114 | R5 = R2 ^ R1 1115 | R2 = v_39C 1116 | R5 = R5 & R12 1117 | R5 = self.EORS(R5, R1) 1118 | R6 = self.rodata[0x10 * index + 12] 1119 | R3 = self.rodata[0x10 * index + 13] 1120 | R6 = self.ADDS(R6, R2) 1121 | R3 = self.ADC(R3, R11) 1122 | R1 = list_3B8[0x10 * index + 13] 1123 | R1 = self.ADDS(R1, R6) 1124 | R6 = list_3B8[0x10 * index + 12] 1125 | R3 = self.ADCS(R3, R6) 1126 | R1 = self.ADDS(R1, R5) 1127 | R3 = self.ADCS(R3, R4) 1128 | R5 = self.ADDS(R1, R10) 1129 | R1 = v_390 1130 | R2 = self.ADC(R3, R1) 1131 | R1 = v_398 1132 | R3 = v_3A0 1133 | R10 = self.ADDS(R1, R5) 1134 | R1 = v_378 1135 | v_378 = R0 1136 | R11 = self.ADC(R1, R2) 1137 | R6 = self.check(R10) >> 28 1138 | R1 = R11 | R9 1139 | v_398 = R11 1140 | R1 = self.ANDS(R1, R3) 1141 | R3 = R11 & R9 1142 | R9 = R1 | R3 1143 | R3 = self.check(R11) << 30 1144 | R4 = self.check(R11) >> 28 1145 | R3 = R3 | self.check(R10) >> 2 1146 | R4 = R4 | self.check(R10) << 4 1147 | R6 = R6 | self.check(R11) << 4 1148 | R3 = self.EORS(R3, R4) 1149 | R4 = self.check(R11) << 25 1150 | R4 = R4 | self.check(R10) >> 7 1151 | R1 = v_3A4 1152 | R3 = self.EORS(R3, R4) 1153 | R4 = self.check(R11) >> 2 1154 | R4 = R4 | self.check(R10) << 30 1155 | v_39C = R10 1156 | R4 = self.EORS(R4, R6) 1157 | R6 = self.check(R11) >> 7 1158 | R6 = R6 | self.check(R10) << 25 1159 | R4 = self.EORS(R4, R6) 1160 | R6 = R10 | R0 1161 | R6 = self.ANDS(R6, R1) 1162 | R1 = R10 & R0 1163 | R1 = self.ORRS(R1, R6) 1164 | R10 = LR 1165 | R0 = self.ADDS(R4, R1) 1166 | v_390 = R0 1167 | R0 = self.ADC(R3, R9) 1168 | v_38C = R0 1169 | R0 = v_3A8 1170 | R9 = R12 1171 | R4 = self.ADDS(R5, R0) 1172 | R0 = v_3AC 1173 | v_3A8 = R4 1174 | R0 = self.ADCS(R0, R2) 1175 | R3 = self.LSRS(R4, 0xE) 1176 | v_3AC = R0 1177 | R1 = self.LSRS(R0, 0x12) 1178 | R2 = self.LSRS(R0, 0xE) 1179 | R1 = R1 | self.check(R4) << 14 1180 | R2 = R2 | self.check(R4) << 18 1181 | R1 = self.EORS(R1, R2) 1182 | R2 = self.LSLS(R0, 0x17) 1183 | R2 = R2 | self.check(R4) >> 9 1184 | R3 = R3 | self.check(R0) << 18 1185 | R11 = R1 ^ R2 1186 | R2 = self.LSRS(R4, 0x12) 1187 | R2 = R2 | self.check(R0) << 14 1188 | R2 = self.EORS(R2, R3) 1189 | R3 = self.LSRS(R0, 9) 1190 | R3 = R3 | self.check(R4) << 23 1191 | R2 = self.EORS(R2, R3) 1192 | R3 = LR ^ R8 1193 | R3 = self.ANDS(R3, R0) 1194 | R0 = v_388 1195 | LR = R3 ^ R8 1196 | R5 = R12 ^ R0 1197 | R5 = self.ANDS(R5, R4) 1198 | R3 = R0 1199 | R5 = self.EORS(R5, R0) 1200 | R4 = self.rodata[0x10 * index + 14] 1201 | R6 = self.rodata[0x10 * index + 15] 1202 | R0 = v_380 1203 | R4 = self.ADDS(R4, R0) 1204 | R0 = v_37C 1205 | R6 = self.ADCS(R6, R0) 1206 | R0 = list_3B8[0x10 * index + 14] 1207 | R1 = list_3B8[0x10 * index + 15] 1208 | R1 = self.ADDS(R1, R4) 1209 | R0 = self.ADCS(R0, R6) 1210 | R1 = self.ADDS(R1, R5) 1211 | R0 = self.ADC(R0, LR) 1212 | R1 = self.ADDS(R1, R2) 1213 | R2 = v_390 1214 | R0 = self.ADC(R0, R11) 1215 | R4 = R8 1216 | LR = self.ADDS(R2, R1) 1217 | R2 = v_38C 1218 | R6 = R3 1219 | R12 = self.ADC(R2, R0) 1220 | R2 = v_384 1221 | R8 = self.ADDS(R1, R2) 1222 | R2 = v_36C 1223 | R5 = self.ADC(R0, R2) 1224 | list_638 = [ 1225 | self.check(LR), 1226 | self.check(R12), 1227 | self.check(v_39C), 1228 | self.check(v_398), 1229 | self.check(v_378), 1230 | self.check(v_374), 1231 | self.check(v_3A4), 1232 | self.check(v_3A0), 1233 | self.check(R8), 1234 | self.check(R5), 1235 | self.check(v_3A8), 1236 | self.check(v_3AC), 1237 | self.check(R9), 1238 | self.check(R10), 1239 | self.check(R6), 1240 | self.check(R4), 1241 | ] 1242 | for i in range(8): 1243 | R0 = param_list[2 * i] 1244 | R1 = param_list[2 * i + 1] 1245 | R0 = self.ADDS(R0, list_638[2 * i]) 1246 | R1 = self.ADCS(R1, list_638[2 * i + 1]) 1247 | param_list[2 * i] = R0 1248 | param_list[2 * i + 1] = R1 1249 | return param_list 1250 | 1251 | def hex_C52(self, list_6B0): 1252 | list_8D8 = [] 1253 | for i in range(8): 1254 | tmp = self.hex_list([list_6B0[2 * i + 1], list_6B0[2 * i]]) 1255 | list_8D8 = list_8D8 + tmp 1256 | return list_8D8 1257 | 1258 | def toHex(self, num): 1259 | return format(int(num), "x") 1260 | 1261 | def check(self, tmp): 1262 | ss = "" 1263 | if tmp < 0: 1264 | ss = self.toHex(4294967296 + int(tmp)) 1265 | else: 1266 | ss = self.toHex(tmp) 1267 | if len(ss) > 8: 1268 | size = len(ss) 1269 | start = size - 8 1270 | ss = ss[start:] 1271 | tmp = int(self.parseLong(ss, 10, 16)) 1272 | return tmp 1273 | 1274 | def ADDS(self, a, b): 1275 | c = self.check(a) + self.check(b) 1276 | if len(self.toHex(c)) > 8: 1277 | self.CF = 1 1278 | else: 1279 | self.CF = 0 1280 | result = self.check(c) 1281 | return result 1282 | 1283 | def ANDS(self, a, b): 1284 | return self.check(a & b) 1285 | 1286 | def EORS(self, a, b): 1287 | return self.check(a ^ b) 1288 | 1289 | def ADC(self, a, b): 1290 | c = self.check(a) + self.check(b) 1291 | d = self.check(c + self.CF) 1292 | return d 1293 | 1294 | def ADCS(self, a, b): 1295 | c = self.check(a) + self.check(b) 1296 | d = self.check(c + self.CF) 1297 | if len(self.toHex(c)) > 8: 1298 | self.CF = 1 1299 | else: 1300 | self.CF = 0 1301 | return d 1302 | 1303 | def LSLS(self, num, k): 1304 | result = self.bin_type(num) 1305 | self.CF = result[k - 1] 1306 | return self.check(self.check(num) << k) 1307 | 1308 | def LSRS(self, num, k): 1309 | result = self.bin_type(num) 1310 | self.CF = result[len(result) - k] 1311 | return self.check(self.check(num) >> k) 1312 | 1313 | def ORRS(self, a, b): 1314 | return self.check(a | b) 1315 | 1316 | def RRX(self, num): 1317 | result = self.bin_type(num) 1318 | lenght = len(result) 1319 | s = str(self.CF) + result[: lenght - 1 - 0] 1320 | return self.parseLong(s, 10, 2) 1321 | 1322 | def bin_type(self, num): 1323 | result = "" 1324 | num = self.check(num) 1325 | lst = self.toBinaryString(num) 1326 | for i in range(32): 1327 | if i < len(lst): 1328 | result += str(lst[i]) 1329 | else: 1330 | result = "0" + result 1331 | return result 1332 | 1333 | def UBFX(self, num, lsb, width): 1334 | tmp_string = self.toBinaryString(num) 1335 | while len(tmp_string) < 32: 1336 | tmp_string = "0" + tmp_string 1337 | lens = len(tmp_string) 1338 | start = lens - lsb - width 1339 | end = start - lsb 1340 | a = int(self.parseLong(tmp_string[start : end - start], 10, 2)) 1341 | 1342 | return int(self.parseLong(tmp_string[start : end - start], 10, 2)) 1343 | 1344 | def UFTX(self, num): 1345 | tmp_string = self.toBinaryString(num) 1346 | start = len(tmp_string) - 8 1347 | return self.parseLong(tmp_string[start:], 10, 2) 1348 | 1349 | def toBinaryString(self, num): 1350 | return "{0:b}".format(num) 1351 | 1352 | def setData(self, data): 1353 | self.__content_raw = data 1354 | self.__content = data 1355 | self.list_9C8 = self.hex_9C8() 1356 | 1357 | def hex_9C8(self): 1358 | result = [] 1359 | for i in range(32): 1360 | result.append(self.chooice(0, 0x100)) 1361 | return result 1362 | 1363 | def chooice(self, start, end): 1364 | return int(random.uniform(0, 1) * (end + 1 - start) + start) 1365 | 1366 | def s2b(self, data): 1367 | arr = [] 1368 | for i in range(len(data)): 1369 | arr.append(data[i]) 1370 | return arr 1371 | 1372 | def hex_list(self, content): 1373 | result = [] 1374 | for value in content: 1375 | tmp = self.toHex(value) 1376 | while len(tmp) < 8: 1377 | tmp = "0" + tmp 1378 | for i in range(4): 1379 | start = 2 * i 1380 | end = 2 * i + 2 1381 | ss = tmp[start:end] 1382 | result.append(int(self.parseLong(ss, 10, 16))) 1383 | return result 1384 | 1385 | def parseLong(self, num, to_base=10, from_base=10): 1386 | if isinstance(num, str): 1387 | n = int(num, from_base) 1388 | else: 1389 | n = int(num) 1390 | alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ" 1391 | if n < to_base: 1392 | return alphabet[n] 1393 | else: 1394 | return self.parseLong(n // to_base, to_base) + alphabet[n % to_base] 1395 | 1396 | def byteArray2str(self, b): 1397 | return binascii.hexlify(bytes(b)).decode() 1398 | 1399 | def changeByteArrayToLong(self, bytes): 1400 | result = [] 1401 | for byte in bytes: 1402 | if byte < 0: 1403 | result.append(byte + 256) 1404 | else: 1405 | result.append(byte) 1406 | return result --------------------------------------------------------------------------------