Search the Community

View File Zombie games - Survival point Zombie games - Survival point / Survivalist Invasion Package: Playstore https://play.google.com/store/apps/details?id=com.teslagamesglobal.survivalist Work 64 bit / Armv8 Game Version : 0.0.616 Feature script : 1. God Mode 2. Magic Stacks 20 3. Free Craft & Upgrade 4. Free Building & Upgrade 5. Finalize no parts 6. Unique Blueprint 7. Durability no decrease 8. Can Take Daily Rewards 9. Speedup Travel (Walk to run To actived) 10. Learning Points for Crafting +(60000) 11. Instant Crafting + Gold 255 12. Credits $60000 13. Free Shopping (Jill Sparrow / Salty Witch) Credits script: Kabut Hitam & Sammax71 my telegram: @kabuthitm grup telegram: t.me/+wYuS_O-YxI41ODVl my facebook: Kabut Hitamm Submitter KabutHitam Submitted 02/04/2023 Category LUA scripts  

There is a unity based polywar game. I tried many time to hack round (single fire with many bullets) but no luck. I found field in dump.cs file for shotgun ( intround) and search with badcase il2cpp field edit and success but.... My problem is (1) shotgun fire 13 bullet each time but it shows 10 When i edit field its working (2) i tried group search 13;1 (no luck) And 10;1 (no luck) So to modify other gun shot data 1 to something 10 Please help me

Quick Notes: Low Registers (R0 to R7): Accessible by all instructions using general-purpose registers. High Registers (R8 to R12): Accessible by 32-bit instructions specifying a general-purpose register, not all 16-bit instructions. Stack Pointer (R13): Used as the Stack Pointer (SP). Autoaligned to a word, four-byte boundary, ignoring writes to bits [1:0]. Link Register (R14): Subroutine Link Register (LR). Receives return address from PC during Branch and Link (BL) or Branch and Link with Exchange (BLX). Also used for exception return. Treat as a general-purpose register. Program Counter (R15): PC. FPU (Floating Point Unit): Supports single-precision operations - add, subtract, multiply, divide, multiply and accumulate, and square root. Also handles conversions between fixed-point and floating-point formats, and floating-point constant instructions. FPU Registers: Sixteen 64-bit doubleword registers: D0-D15. Thirty-two 32-bit single-word registers: S0-S31. ->Source <- --------------------------------------------------------------------------------------------------------------------------------- In Arm Patching we are using only Low Registers and the FPU. True and false Editing. ~A MOV R0, #1 MOV means Move , by this instruction we are telling the proccessor to move the value 1 to register R0 similar when you assign a variable name : R0 = 1 in most programing languages the true statment always = 1 and the false statment = 0 so #1 = true and #0 = false ~A BX LR BX Means branch exit LR or in another way return the value we stored to the caller. Int Editing : we can use MOV R0, # aswell for the int value but you need to know the integral data types. • byte : Signed: From −128 to 127 ­ ­ ­ ­ ­ ­ ­ ­ ­: Unsigned: From 0 to 255 we can use MOV here if the int value we want is between -128 and 255 so the instruction will be : ~A MOV R0, #-128 or #255 at max • short : Signed: From −32,768 to 32,767 : Unsigned: From 0 to 65,535 in this case we use MOVW the W stands for Word so same as above the instruction will be : ~A MOVW R0, #−32,768 or #65,535 at max NOTE : • Don't forget to return (~A BX LR) • We can Use MVN which mean Move Negative so the Max Negative Value will be #255 for Byte and MVNW for Short #65,535 (Don't add "-" since we already telling the proccessor we are dealing with negative number) • #value will be converted automatically to hex value in the Register means #8 will be 0x00000008 and so on • Int 32 : Signed: From −2,147,483,648 to 2,147,483,647 : Unsigned: From 0 to 4,294,967,295 the typical DWORD in GG : here we move to the advanced Part of this guide: as I said in the Note above the values are converted in the register automatically to hex so the max value in short in hex will be 0x0000FFFF so we have 4 zero's we can't change in the int 32, in this case we use one more instructon MOVT T stands for Top example : MOVW R0, #22136 -> R0 will be : 0X00005678 MOVT R0 , #4660 -> R0 will be : 0x12345678 So in case of INT32 we need 2 things • Convert the value we want to change to hex value • 3 instruction in total the Same concept here work for QWORD aswell (64 bit) 0x0000000000000001 Note : MVN R0, #2 will change to 0xFFFFFFF2 in hex MOV R0, #2 or MOV R0, #0x2 are the same Float and Double: • Float and Double are IEEE 754 Floating-Point: We need the FPU here and things will get a little bit complicated, • we need 2 or 3 registers in this case R0 , R1 and S0(for float) or D0(for double) Suppose the hex value of this float 12.6 is : 0x4149999A same as the int 32 : ~A MOVW R0, #0x999A (R0 = 0x0000999A) ~A MOVT R0, #0x4149 (R0 now = 0x4149999A) now R0 is set but if we return the value (~A BX LR) the result will be : 1095342490 and we don't want that value we want 12.6 as float (This Doesn't Work Because we didn't tell the proccessor that is a float number) the right way is to use FPU VMOV S15, R0 ( VMOV is the instruction MOV in the FPU : by that instruction we mean move the register value of R0 to the FPU register R15 ) VMOV.F32 S0, S15 (here we are telling the FPU we are dealing with Float number (F32) and move the value from S15 to S0 ) for double we use the same concept except we use F64 instead and register D16 and D0 Float : so the final code will be : ~A MOVW R0, #0x999A (R0 = 0x0000999A) ~A MOVT R0, #0x4149 (R0 = 0x4149999A) ~A VMOV S15, R0 ~A VMOV.F32 S0, S15 ~A BX LR ----------------- Double : For double the hex value of 12.6 is : 0x4029333333333333 (Same Concept for Big Float Number) • Here we use R0, R1 , D0 and D16 • divide the hex value 0x4029333333333333 into 2 part 0x40293333 and 0x33333333 one goes for R0 and the other one goes for R1 Be carful of the placement of the hex value we start from the last 4 to the 1st 4 means we start with 0x3333 -> 0x4029 Use same concept of MOVW and MOVT to get the result. Result: ~A MOVW R0, #0x3333 (R0 = 0x00003333) ~A MOVT R0, #0x3333 (R0 = 0x33333333) ~A MOVW R1, # 0x3333 (R1 = 0x00003333) ~A MOVT R1, #0x4029 (R1 = 0x40293333) ~A VMOV D16, R0, R1 (Move value Of R0 and R1 to register D16 Be Careful here R0 last 8 hex 1st then R1 the top 8 hex) ~A VMOV.F64 D0, D16 (here we use F64 and D0 , and D16 instead of F32 , S0 and S15 because the hex value is 64 bit) ~A BX LR ------ This is How you arm patch bool / int / float / double NOTE : When it comes to function args and returns the only register that give return or args are R0,R1,R2,R3 (and SP) this is why we use R0 and VMOV S15/D16 to S0/D0 ARMv8 : In ARMv8, LSL stands for "Logical Shift Left". It is an instruction used to shift the bits in a register to the left by a specified number of bits, and the bits that are shifted off the left-hand end are discarded. LSL can be used with immediate values or with a register value. The immediate value specifies the number of bits to shift, which can be between 0 and 63. When using a register value, the bottom byte of the register specifies the number of bits to shift Example : Level 1 ) LSL X1, X2, #3 --> Shift the contents of X2 left by 3 bits and store the result in X1 -> In this example, X2 is being multiplied by 8 (since 8 is 2 to the power of 3), and the result is stored in X1. Level 2) MOV and LSL example: MOV X1, #0x10 -->Move the value 0x10 into register X1 LSL X1, X1, #3 --> Shift the contents of X1 left by 3 bits (multiply by 8 ) Level 3) Float Value : 3.14159 / Hex : 0x40490FD0 --Load the value 0x0FD00000 into bits 16-31 of W0 • MOVK W0, #0x0FD0, LSL #16 --> W0 = 0x00000FD0 -- Load the value 0x40490000 into bits 32-47 of W0 • MOVK W0, #0x4049, LSL #32 -> W0 = 0x40490FD0 -- Move the value of W0 into single-precision floating-point register S0 • FMOV S0, W0 --> S0 = 0x40490FD0 (interpreted as a floating-point value) Note : 4 bytes hex (32) value we use register W and for float we use S Level 4 ) Double value : 3.14159 / Hex : 0x400921F9F01B866E MOVK X0, #0xF01B866E, LSL #16 -->X0 = 0x00000000F01B866E MOVK X0, #0x400921F9, LSL #48 -->X0 = 0x400921F9F01B866E FMOV D0, X0 Note: 8 bytes hex (64) value we use register X and for Double we use D NOTE: SAME CONCEPT IN AARCH32 WITH (INT, BOOL, FLOAT, AND DOUBLE) LSL and MOV(Z/K) is the diffrences. PART II (LDR / STR): [STRING] ( NON UNITY GAMES ) Little-endian / Big-endians : LDR and STR are instructions used in ARMv7 and ARMv8 architectures to load and store data from memory. LDR stands for "Load Register" and is used to load a value from memory into a register. The syntax for LDR in ARMv7 and ARMv8 is LDR <Register>, [<Address>] STR stands for "Store Register" and is used to store a value from a register into memory. The syntax for STR in ARMv7 and ARMv8 is STR <Register>, [<Address>] where <Register> is the name of the register to load the value into, and <Address> is the memory address from which to load the value. In both cases, the square brackets around <Address> indicate that the value inside the brackets is a memory address, rather than a register. To load the string 'GG TESTING' into a register, you can use the LDR instruction. Assume the pointer to 'G' is 0x00000004 we can use this address as the base address for the LDR instruction. The instruction for loading the first four characters of the string into a 32-bit register (e.g., R1/X1) would be: • LDR R1/X1, [0x00000004] -- R1/X1 = 'GG T' This instruction loads the 32-bit value at memory address 0x00000004 into R1/X1. Note: Use the Move instructions above (PART I) to assign the value (address) to a register BEFOR USING LDR --> LDR R1/X1, [R0] -- R0 = 0x123456789 ( use MOV to assign the correct address to R0 or X0) To load the entire string into a register, you can use the LDR instruction with a register offset. Assuming the string is stored in consecutive memory locations, we can use the following instruction to load the entire string into a register (e.g., R1/X1) LDR R1/X1, [0x00000004], #10 This instruction loads the 32-bit value at memory address 0x00000004 into R1 and increments the base address by 10 (the length of the string). As a result, the entire string 'GG TESTING' will be loaded into R1. ADVANCED : If 'GG TESTING' is a half-word (i.e., each character is 2 bytes or 16 bits) and the pointer to 'G' is located at memory address 0x0000004 + 0x8, then the instructions for loading the string into a register would be different Dummy memory: 0x0000004 (<-- pointer )= 123 0x0000008 = 21 0x000000C = 9999999 0x0000010 = 'GG' 0x0000014 = ' T' -- with space at the start. 0x0000018 = 'ES' etc.. --> between every byte value ( character ) there is 0 [ example in memory 0x00000010 = 71 (G) <-- byte 0x00000011 = 0 <-- byte 0x00000012 = 71 (G) <-- byte 0x00000013 = 0 <-- byte 0x00000014 = 32 (space) <- byte ] To load the half-word 'GG' into a 32-bit register (e.g., R0/X0), we can use the LDRH instruction as follows: LDRH R0, [0x00000004, 0x8] This instruction loads the 16-bit value at memory address 0x00000010 into the lower 16 bits of R0/X0. Since we want to load the first two characters of the string, we add an offset of 0x8 to the base address. Read more about LDR To load the entire string into a register, we can use the LDRH instruction with a register offset as follows: LDRH R0, [0x00000004, 0x8], #0xC This instruction loads the 16-bit value at memory address 0x00000010 into the lower 16 bits of R1, and increments the base address by 0xC (or 12 bytes) to load the remaining characters of the string. The 'GG TESTING' string has a length of 10 characters, which corresponds to 20 bytes (11 characters x 2 bytes per character), so we need to load 12 bytes in addition to the first 2 bytes to load the entire string. AARCH64 : LDRH --> LDURH (Load Unsigned Halfword with a 64-bit offset) or LDSRH (signed) LDURH W0, [X1, #16] ; Load a halfword from the memory address X1 + 16 into W0 This loads a 16-bit unsigned halfword from the memory address X1 + 16 into the 32-bit register W0. Note that the offset value is added to the base register X1 to form the memory address. Also, because LDURH is an unsigned load instruction, the loaded halfword is zero-extended to 32 bits. NOTE: the LDURH instruction is specific to AArch64 architecture and is not available in AArch32 architecture. STR: STR is used to store the contents of a register into a memory location that is addressed using a base register and an optional offset. The contents of the register are written to the memory location, overwriting any previous data that was stored at that location. -->STR Rd, [Rn {, #offset}] where Rd is the source register whose contents will be stored in memory, Rn is the base register that points to the memory location where the data will be stored, and offset is an optional 32-bit offset that is added to the base register to form the memory address. Example of using the STR instruction to store the contents of R0 register into a memory location: --> STR R0/X0, [R1/X1, #4] ; Store the contents of R0/X1 into the memory location R1/X1 + 4. NOTE : STR Wd, [Xn, #offset], imm | the STR instruction with the imm option is only available in AArch64. |--> Wd/Xd, [Xn, #offset] The imm option allows you to add an immediate value to the offset to form the memory address. The immediate value is sign-extended to 64 bits, shifted left by the scale factor (which is determined by the size of the data being transferred), and then added to the offset. -> STR W0, [X1, #0x100], #0x20 -- This stores the contents of register W0 into the memory location pointed to by register X1 plus 0x100 plus 0x20, overwriting any previous data stored at that location. In AArch32, there is no imm option for the STR instruction. However, you can achieve a similar effect by adding the immediate value to the offset before using it in the instruction. Here's an example: ADD R2, R1, #0x120 --> R2 = R1 + 0x120 STR R0, [R2] --> Store R0 at address R2 Here, the ADD instruction adds the immediate value 0x20 to the base register R1, storing the result in R2. The STR instruction then stores the contents of register R0 into the memory location pointed to by register R2. Note: that the immediate value is added to the offset before using it in the instruction, rather than being added as a separate operand like the imm option in AArch64. --->FOR Using LDR / STR on values just LDR/STR R0/X0, [DESTINATION ADDRESS] Note : Unity games use pointers for the string ----------------------------------------------> Converting Float and Double to Hex <--------------------------------- This is mainly IEEE Standard for Floating-Point Arithmetic. (you can skip this part by using online converter) > You need : • Advanced Lua scripting Knowladge. • Math Knowladge. • Binary 32 and 64 Knowladge. --------------Please read--------------

@sammax71 any chance you have an updated version for 1.3.0.1. Thanks mate.

Hi @bluechipps, I'm not an expert in this debugging field and also; I don't have the problem in hand: - Based on 'Breakpoint', we can't really sure if that's the exact problem but it can be the one trivia. GG sets breakpoint into Kernels, specificly time() function, to do Client-sided Speed-Hack. Altho it's related, we need to dive further into function side of the game or the kernel itself. - Also judging from WIF's, it returns a True value. It means the sys call / process that are called is stopped. As you can see from WIFSTOPPED(1). - It reminds me that SpeedHack is intended for 32-bit architecture (Altho, many x64 games can also use it). Probably try the Armeabi version of the game. - I'm afraid you're running the latest version of Android as it can be more problematic. On newer Android 11-13, introduces new Phantom processes, which limits the Access to Higher Permission. The behavior is: It will likely to stop the process if it's exceed high memory limit, Apps can't see the process side of another Apps, etc. It's been painful. I can be wrong about my points. I think it also safe to say that: don't use newer Android version for Kernels / High Permission related activity. About returning the phone, I can't really say if it's the Phone faults but I've been biased towards Xiaomi/Infinix community for something related to Rooting. The community has been really great by being really active and also still provides Android 10.

Hi i have been doing hack for this game a long time ago, i got less time to develop hack so all i can do is to provide you offset so you can make your own hack, these offset are for the version 4.8.2 64 bit LocalSave.CharacterOne : get_ATKLevel [Xa]: libil2cpp.so + 0x2291484 [ON]: 00 12 A0 52 C0 03 5F D6 [OFF]: FF 43 01 D1 F5 13 00 F9 LocalSave.CharacterOne : get_HPMaxLevel [Xa]: libil2cpp.so + 0x2291DAC [ON]: 00 12 A0 52 C0 03 5F D6 [OFF]: FF 43 01 D1 F5 13 00 F9 32 Bit LocalSave.CharacterOne : get_ATKLevel [Xa]: libil2cpp.so + 0x15EA9A4 [ON]: 01 04 A0 E3 1E FF 2F E1 [OFF]: F0 48 2D E9 10 B0 8D E2 LocalSave.CharacterOne : get_HPMaxLevel [Xa]: libil2cpp.so + 0x15EB584 [ON]: 01 04 A0 E3 1E FF 2F E1 [OFF]: F0 48 2D E9 10 B0 8D E2 here you have the full dump of both 32 and 64bit feel free to explore the dump.cs, i will recommend you looking into the namespace LocalSave.CharacterOne first. I am here if you got any question

Hey what's the new video you post can you send to me thanks mate

View File Pure Lua library import this lib to your script : • setup ! XEK = nil load_lib = gg.makeRequest('https://raw.githubusercontent.com/chihaamin/XEKEX/main/xLIB.lua') if load_json_lib.code == 200 then -- check the status of the request XEK = load(load_json_lib.content,'bt')() end • Comment if you find a bug / error or if you have Idea for implementation. • All the file is documented and commented for beginners. ♥ Add "XEKEX was here" in your script if it was helful ------------------------------------------------------------------------------- IMPORT : JSON = XEK.import('https://raw.githubusercontent.com/rxi/json.lua/master/json.lua') -- this will import a lib into your script JSON.decode(response.content) Text2Dword : -- Text2Dword function Convert a text to dword value local DWORD = XEK.Text2Dword("berry") -- Print the result print(DWORD) --> Output: '6619234;7471218;121::9' Dword2Text : -- Dword2Text function Convert a Dword value to text local sampleValue = "6619234;7471218;121" local text = XEK.Dword2Text(sampleValue) -- Print the result print(text) --> Output: 'berry' hex : The 'hex' function takes two arguments: a value to convert to hexadecimal and a boolean 'hx' indicating whether to add '0x' or 'h' prefix to the output. --[[ If hx is true, the function returns the hexadecimal value with '0x' prefix. If hx is false, the function returns the hexadecimal value with 'h' suffix. If hx is not provided or not a boolean, the function returns the hexadecimal value without any prefix or suffix. The function uses string formatting to convert the value to hexadecimal. ]] --> Examples: --Convert decimal value to hexadecimal with '0x' prefix print(XEK.hex(255, true)) --> Output: 0xFF --Convert decimal value to hexadecimal with 'h' suffix print(XEK.hex(255, false)) --> Output: FFh --Convert decimal value to hexadecimal without any prefix or suffix print(XEK.hex(255)) --> Output: FF dump : --[[ dump function takes a table as input and returns a string representation of the table. If the input is not a table, it returns a string representation of the input. Parameters: tab (table): the table to be dumped Returns: (string): the string representation of the table ]] --> Example usage: local myTable = {name = "John", age = 30, hobbies = {"reading", "running"}} print(XEK.Dump(myTable)) -- Output: { ["name"] = "John", ["age"] = 30, ["hobbies"] = { [1] = "reading", [2] = "running", } } split : --split function splits a string into a table of substrings using a specified delimiter --The function takes two parameters: s, which is the string to be split, and delimiter, which is the character or string used to separate the substrings --> Example usage: local myString = "apple,banana,cherry,orange" local myTable = XEK.split(myString, ",") -- The above code will split the string "apple,banana,cherry,orange" into substrings using the comma as the delimiter and store the result in a table called myTable --The resulting table will contain the following values: myTable[1] = "apple" myTable[2] = "banana" myTable[3] = "cherry" myTable[4] = "orange" ARMIT fix : --# Example 1: Converting an Integer to Assembly Instructions local instructions = XEK.ARMIT(123456, "int", true) --The above function call will generate assembly instructions to move the value 123456 into a register in AArch64. --> Output: instructions = { [1] = '~A8 MOVK W0, #0xE240, LSL #16', [2] = '~A8 MOVK W0, #0x0001, LSL #32', [3] = '~A8 RET', } --# Example 2: Converting a Boolean to Assembly Instructions local instructions = XEK.ARMIT(true, "bool") --The above function call will generate assembly instructions to move the value 1 (true) into a register in AArch32. --> Output: instructions = { [1] = '~A MOV R0, #0x1', [2] = '~A BX LR', } --# Example 3: Converting a Float to Assembly Instructions local instructions = XEK.ARMIT(3.14159, "f", true) --The above function call will generate assembly instructions to move the value 3.14159 into a floating point register in AArch64. --> Output: instructions = { [1] = '~A8 MOVK W0, #0x0FD0, LSL #16', [2] = '~A8 MOVK W0, #0x4049, LSL #32', [3] = '~A8 FMOV S0, W0', [4] = '~A8 RET', } --# Example 4: Converting a Double to Assembly Instructions local instructions = XEK.ARMIT(123456789.987654321, "d") --The above function call will generate assembly instructions to move the value 123456789.987654321 into a double precision floating point register in AArch32. --> Output: instructions = { [1] = '~A MOVW R0, #0x5BA8', [2] = '~A MOVT R0, #0x57F3', [3] = '~A MOVW R1, #0x6F34', [4] = '~A MOVT R1, #0x419D', [5] = '~A VMOV D0, R1, R0', [6] = '~A BX LR', } readBytes | readWord | readDword | readFloat | readDouble : local words = XEK.readWord(addr, size, ';') <-| return a string local dwords = XEK.readDword(addr, size, '-') <-| return a string local floats = XEK.readFloat(addr, size, '|') <-| return a string local doubles = XEK.readDouble(addr, size, ':') <-| return a string -- OR local words = XEK.readWord(addr, size) <-| return a table local dwords = XEK.readDword(addr, size) <-| return a table local floats = XEK.readFloat(addr, size) <-| return a table local doubles = XEK.readDouble(addr, size) <-| return a table --<< these function purpose is to read values from memory for comparison >>-- getResults : --# Example usage of getResults function and its returned table local t = XEK.getResults(10) or t = XEK.getResults() <-|-- Get 10 results or all result | you can specified parameter same as GG print(t.data[1].address) <-|-- Print the address of the first result --# Example usage of focus function t:focus() <-|-- Save original values of results table print(t.original[1]) <-|-- Print the original value of the first result --# Example usage of update function t:update(999) <-|-- Set all values in result table to 999 --# Example usage of reset function t:reset() <-|-- Reset all values in result table to their original values --# Example usage of offset function t:offset(0x8) <-|-- Add 8 to the address of each result --# Example usage of append function local t2 = XEK.getResults(5) <-|-- Get 5 more results t:append(t2) <-|-- Append t2 results to t print(#t.data) <-|-- Print the total number of results in t --# Example usage of get function t:get() <-|-- Refresh the results table --# Example usage of clear function t:clear() <-|-- Destroy the results table and clear garbage MakeMenu : -- Create a new menu object local myMenu = XEK.MakeMenu().Menu:new({"Option 1", "Option 2", "Option 3"}) | this will add Menues -- Add a new action to the menu myMenu.actions:new(1, function() -- argument 1 is the index of menu ( option 1 function ) | index must be a number print("Option 1 was selected!") end) myMenu.actions:new(2, function() print("Option 2 was selected!") end) -- etc -- . -- . -- . -- Display the menu and wait for the user to make a selection myMenu:display() --whenever the user select a menu item it will trigger the functions inside myMenu.actions ( created with myMenu.actions:new(index, function) ) Submitter XEKEX Submitted 01/13/2023 Category Tools  

View File CS Surf Go Vip Script • Options Include: Daily Reward Unlimited Money , All Cases Free , Auto Win Hack Submitter 999Luckyday Submitted 01/10/2023 Category LUA scripts  

Hi @Marks01, the purpose of the video is to use HideMyAppList to Hide GG from the Game as an Alternative to SudoHide, and it works. The idea to Install Magisk is just for that. I can't help you more than this, unless you gave me some Screen-Record of your problem. I'm really sorry, I don't have the idea what's being the problem here. You can use OBS to record your screen. In reply to your previous question, it's because LSPosed and Shamiko requires newer SDK. You're using LDPlayer 4 with Android 7-5 that has lower SDK (26-24). You need at least Android 9 or newer to able to install. I'm using LDPlayer 9.0.11.0 x64-bit. I suggest you to install Windows 10 x64-bit to install LDPlayer 64bit. You might want to follow my setup, altho it's not needed, it must be other thing that cause this problem. Again, I request you to do some Screen-Record, so I can inspect the possible causes.

I did everything as in the 1st video, but after turning off the root modules stop working. So I decided to do everything as in the 2 videos, I was able to run the game, but the game 10 seconds after starting detects GG and closes. I tried different modes of hiding GG, but it did not help me.

Hi @Marks01, are you sure you're doing the exact same step like I did on the video? The reason it's need to be disabled is because: MagiskSu will conflct with SuperSu ( See 'Install Magisk on Emulator' video at 01:34 ). Please clarify the following: - The reason Modules tab is greyed out: Magisk isn't installed properly ( Redo steps from 'Install Magisk on Emulator' video at 00:10 - 00:41 ). - From the first Installation, make sure You still have the Root ENABLED when opening Magisk App ( See 'Install Magisk on Emulator' video at 01:13 ). - DONT USE 'Hide Magisk App' or the Magisk App will lose it's Root previleges. The reason for this is: Magisk Root are handled by Magisk App. Be paying attention when Installing Magisk App. The Indication of MagiskSu is successfully installed are mentioned in this time list: - The Magisk Terminal says 'Done' and the Installation ended ( See 'Install Magisk on Emulator' video at 0:38) - The Magisk App will ask for Root and it says 'Abnormal State' ( See 'Install Magisk on Emulator' video at 01:13 and 01:34 ) Above timestamp is a VITAL Part of Magisk Installation. I can't really tell if you're doing something wrong, perhaps a screen-recording would helps.

note* Leave one place for the G2 velo. 1. First, Search this code as dword. code: 8CAE1414h;6F736572h 2. Then enter the code below and press refine. code: -1934748652 It should have a result of 2 or 4 codes. If you get 2 codes you can skip step 3, but if you get 4 results then follow the method below 3. If you have 4 codes, then see one by one until you find a structure like this -1934748652;10 and you will find two codes like that and just delete the rest -1934748652 is id for velo G2 10 is the dino level in the store (so you can buy a dino with the maximum level at once by changing the number 10) 4. If you have found the code then enter the Velo G2 tab as shown below. 5. If you have just changed the code -1934748652 to the dinosaur id you want. 6. Press the green button. 7. And voila, you got what you wanted (This can be used to get any dino) To complete the tutorial: Therizinosaurus Gen 2: 1689534356 Kaprodacthylus: -1078620487 Ophthacerapsis: -676392169 Tyrannolophosaur: 1342369609 Spinoceratops: -1409718305 Rexy: 1019074437 Platypterygius: -1560866862 Meiolania: -2133883974 Beta: 188668218

View File Heroes Strike 3v3 Script || Dimaz GG no pasword script Expired (25 Dec 2022) Buy No Expired Version @DimazGG how to use script? enjoy the script ❤ Submitter ScripterIndonesia Submitted 12/10/2022 Category LUA scripts  

View File Sniper Champions (1) Boosters x65000 (2) Tokens x65000 (3) Trophy x65000 (4) All Reticle Unlocked (5) All Bullet Unlocked (6) All Target Unlocked (7) All Effects Unlocked (8) Weapon Upgrade x65000 (9) All Emoji Unlocked (10) All Reactions Unlocked Submitter sammax71 Submitted 12/09/2022 Category LUA scripts  

soo basically the Excel is filled with Item_name, Dword values, Length of String item_ID This Excel is used for item swap, and no pointer is used lets say you wanted a Terem Ball We find the Terem ITEM ID by using String Item ID and use the String ID to located Item ID Using Query, you'll need Length (len) = 10; Divider = 0; String ID = Q 'ball_terem' Group Size (vary, mine 20) = :20 Search: 10D;0D; Q 'ball_terem':20 Type: Any and Using DWORD, you'll need Length (len) = 10; Divider(always there) = 0; Dword 1st 4 = 1,819,042,146; Dword 2nd 4 (if available) = 1,919,251,551; Dword 3rd 4 (if available) = 28,005; Dword 4th 4 (if available) = N/A Group Size (vary, mine 20) = :20 Search: 10;0;1,819,042,146;1,919,251,551;28,005:20 TYPE: DWORD and you'll find the item's string ID, and use the Length as reference point to find the Item ID which most the time located 3 address above Length. Here i attach a video for you, Droplist Item Swap wood to Terem and Terem to Mysterious Map sorry for low bitrate, i use 1mb bitrate for recording gudie.mp4

For your character level try to give a look at this chart XP Level, try to find, more or less, your xp and after that go to game guardian and for example write 4000~5400 (if you are around level 9-10) and after that refine with the "unknow value N = 0 + D" while gaining exp or, if you do not know how many xp are you gaining, with the "increased" button.

View File NFS NO LIMITS VIP 10 I bring the vip points script so you can hack the vip points to be able to activate your vip 10 and save a lot of money, important to activate it will be necessary to purchase the 50 gold package in the game store values vary for each country ... if you have doubts watch the video below on my channel Submitter AlemaoGamer Submitted 12/04/2022 Category LUA scripts