diff --git a/deobfuscator-impl/src/test/java/uwu/narumi/deobfuscator/TestDeobfuscation.java b/deobfuscator-impl/src/test/java/uwu/narumi/deobfuscator/TestDeobfuscation.java index a0a3b090..b6c466a6 100644 --- a/deobfuscator-impl/src/test/java/uwu/narumi/deobfuscator/TestDeobfuscation.java +++ b/deobfuscator-impl/src/test/java/uwu/narumi/deobfuscator/TestDeobfuscation.java @@ -172,8 +172,8 @@ protected void registerAll() { .inputClassesDir(InputType.CUSTOM_CLASS, "qprotect/sample2") .register(); - test("qProtect Sample 3") - .transformers(Composed_qProtectTransformer::new) + test("qProtect Strong String Sample 3") + .transformers(() -> new Composed_qProtectTransformer(true)) .inputClassesDir(InputType.CUSTOM_CLASS, "qprotect/sample3") .register(); diff --git a/deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/composed/Composed_qProtectTransformer.java b/deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/composed/Composed_qProtectTransformer.java index e21783fe..891b3f73 100644 --- a/deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/composed/Composed_qProtectTransformer.java +++ b/deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/composed/Composed_qProtectTransformer.java @@ -1,22 +1,15 @@ package uwu.narumi.deobfuscator.core.other.composed; import uwu.narumi.deobfuscator.api.transformer.ComposedTransformer; +import uwu.narumi.deobfuscator.core.other.composed.general.ComposedGeneralFlowTransformer; import uwu.narumi.deobfuscator.core.other.composed.general.ComposedPeepholeCleanTransformer; import uwu.narumi.deobfuscator.core.other.impl.clean.LocalVariableNamesCleanTransformer; import uwu.narumi.deobfuscator.core.other.impl.pool.InlineLocalVariablesTransformer; import uwu.narumi.deobfuscator.core.other.impl.pool.InlineStaticFieldTransformer; -import uwu.narumi.deobfuscator.core.other.impl.qprotect.qProtectAESStringEncryptionTransformer; -import uwu.narumi.deobfuscator.core.other.impl.qprotect.qProtectFieldFlowTransformer; -import uwu.narumi.deobfuscator.core.other.impl.qprotect.qProtectInvokeDynamicStrongTransformer; -import uwu.narumi.deobfuscator.core.other.impl.universal.SourceFileNameRecoverTransformer; +import uwu.narumi.deobfuscator.core.other.impl.qprotect.*; +import uwu.narumi.deobfuscator.core.other.impl.universal.*; import uwu.narumi.deobfuscator.core.other.impl.universal.pool.UniversalStringPoolTransformer; -import uwu.narumi.deobfuscator.core.other.impl.qprotect.qProtectStringTransformer; -import uwu.narumi.deobfuscator.core.other.impl.qprotect.qProtectTryCatchTransformer; -import uwu.narumi.deobfuscator.core.other.impl.qprotect.qProtectInvokeDynamicTransformer; import uwu.narumi.deobfuscator.core.other.impl.universal.pool.UniversalNumberPoolTransformer; -import uwu.narumi.deobfuscator.core.other.impl.universal.TryCatchRepairTransformer; -import uwu.narumi.deobfuscator.core.other.impl.universal.UniversalFlowTransformer; -import uwu.narumi.deobfuscator.core.other.impl.universal.UniversalNumberTransformer; /** * https://qtechnologies.dev/ @@ -33,7 +26,7 @@ public Composed_qProtectTransformer() { InlineStaticFieldTransformer::new, InlineLocalVariablesTransformer::new, - // Inline number pools + // Inline number pools, but keep byte arrays for StrongStringEncryption UniversalNumberPoolTransformer::new, // Decrypt method invocation qProtectInvokeDynamicTransformer::new, @@ -42,9 +35,10 @@ public Composed_qProtectTransformer() { // Fix flow UniversalFlowTransformer::new, - // Decrypt strings + // Strings qProtectStringTransformer::new, qProtectAESStringEncryptionTransformer::new, + // Inline string pools UniversalStringPoolTransformer::new, @@ -63,4 +57,48 @@ public Composed_qProtectTransformer() { qProtectFieldFlowTransformer::new ); } + + public Composed_qProtectTransformer(boolean strongStrings) { + super( + // This fixes some weird issues where "this" is used as a local variable name. + LocalVariableNamesCleanTransformer::new, + + // Initial cleaning code from garbage + UniversalNumberTransformer::new, + InlineStaticFieldTransformer::new, + InlineLocalVariablesTransformer::new, + + // Inline number pools, but keep byte arrays for StrongStringEncryption + UniversalNumberPoolTransformer::new, + // Decrypt method invocation + qProtectInvokeDynamicTransformer::new, + qProtectInvokeDynamicStrongTransformer::new, + + // Fix flow + UniversalFlowTransformer::new, + + // Inline fields again + InlineStaticFieldTransformer::new, + InlineLocalVariablesTransformer::new, + + // Cleanup + ComposedPeepholeCleanTransformer::new, + + // Resolve qProtect flow that uses try-catches + qProtectTryCatchTransformer::new, + TryCatchRepairTransformer::new, + + // String Strings + qProtectStrongStringTransformer::new, + qProtectAESStringEncryptionTransformer::new, + StringBuilderTransformer::new, + + // Inline string pools + UniversalStringPoolTransformer::new, + StringBuilderTransformer::new, + + // Remove field flow after cleaning code from garbage, so we can do pattern matching + qProtectFieldFlowTransformer::new + ); + } } diff --git a/deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/qprotect/qProtectInvokeDynamicStrongTransformer.java b/deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/qprotect/qProtectInvokeDynamicStrongTransformer.java index 54894798..8bb7d223 100644 --- a/deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/qprotect/qProtectInvokeDynamicStrongTransformer.java +++ b/deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/qprotect/qProtectInvokeDynamicStrongTransformer.java @@ -11,6 +11,7 @@ import uwu.narumi.deobfuscator.api.asm.MethodContext; import uwu.narumi.deobfuscator.api.asm.MethodRef; import uwu.narumi.deobfuscator.api.asm.matcher.Match; +import uwu.narumi.deobfuscator.api.asm.matcher.group.AnyMatch; import uwu.narumi.deobfuscator.api.asm.matcher.impl.FrameMatch; import uwu.narumi.deobfuscator.api.asm.matcher.impl.MethodMatch; import uwu.narumi.deobfuscator.api.asm.matcher.impl.NewArrayMatch; @@ -32,9 +33,10 @@ public class qProtectInvokeDynamicStrongTransformer extends Transformer { private static final int XOR_KEY_ARRAY_SIZE = 16; - private static final Match RESOLVE_HANDLE_MATCH = MethodMatch.invokeSpecial().owner("java/lang/invoke/ConstantCallSite").name("").desc("(Ljava/lang/invoke/MethodHandle;)V") - .and(FrameMatch.stack(0, OpcodeMatch.of(CHECKCAST) - .and(FrameMatch.stack(0, MethodMatch.invokeStatic().desc("([Ljava/lang/Object;)Ljava/lang/Object;").capture("resolveHandleMethod"))))); + private static final Match RESOLVE_HANDLE_MATCH = AnyMatch.of(MethodMatch.invokeSpecial().owner("java/lang/invoke/ConstantCallSite").name("").desc("(Ljava/lang/invoke/MethodHandle;)V") + .and(FrameMatch.stack(0, OpcodeMatch.of(CHECKCAST) + .and(FrameMatch.stack(0, MethodMatch.invokeStatic().desc("([Ljava/lang/Object;)Ljava/lang/Object;").capture("resolveHandleMethod"))))), + MethodMatch.invokeStatic().desc("([Ljava/lang/Object;)Ljava/lang/Object;").capture("resolveHandleMethod")); private static final Match FIND_METHOD_HANDLE_MATCH = MethodMatch.invokeStatic().desc("(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;"); diff --git a/deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/qprotect/qProtectStrongStringTransformer.java b/deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/qprotect/qProtectStrongStringTransformer.java new file mode 100644 index 00000000..0af3da03 --- /dev/null +++ b/deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/qprotect/qProtectStrongStringTransformer.java @@ -0,0 +1,181 @@ +package uwu.narumi.deobfuscator.core.other.impl.qprotect; + +import org.objectweb.asm.tree.LdcInsnNode; +import org.objectweb.asm.tree.MethodInsnNode; +import org.objectweb.asm.tree.MethodNode; +import org.objectweb.asm.tree.TableSwitchInsnNode; +import uwu.narumi.deobfuscator.api.asm.MethodContext; +import uwu.narumi.deobfuscator.api.asm.MethodRef; +import uwu.narumi.deobfuscator.api.asm.matcher.Match; +import uwu.narumi.deobfuscator.api.asm.matcher.MatchContext; +import uwu.narumi.deobfuscator.api.asm.matcher.group.SequenceMatch; +import uwu.narumi.deobfuscator.api.asm.matcher.impl.*; +import uwu.narumi.deobfuscator.api.transformer.Transformer; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.concurrent.atomic.AtomicReference; + +/** + * Transforms encrypted strings in qProtect obfuscated code. Example here: {@link qprotect.StringStrongEncryption} + */ +public class qProtectStrongStringTransformer extends Transformer { + + private static final Match DECRYPT_STRING_MATCH = MethodMatch.invokeStatic().desc("(II)Ljava/lang/String;") + .and(FrameMatch.stack(0, NumberMatch.numInteger().capture("salt2"))) + .and(FrameMatch.stack(1, NumberMatch.numInteger().capture("salt1"))); + + @Override + protected void transform() throws Exception { + scopedClasses().forEach(classWrapper -> { + AtomicReference decryptionMethodRef = new AtomicReference<>(); + + Map encryptedArray = new HashMap<>(); + + classWrapper.findClInit().ifPresent(clinit -> { + if (clinit.instructions.size() > 3 && clinit.instructions.get(0).isNumber()) { + MethodContext clinitContext = MethodContext.of(classWrapper, clinit); + SequenceMatch.of(OpcodeMatch.of(DUP), NumberMatch.of().capture("array-index"), StringMatch.of().capture("encrypted-value"), OpcodeMatch.of(AASTORE)).findAllMatches(clinitContext).forEach(matchContext -> { + encryptedArray.put(matchContext.captures().get("array-index").insn().asInteger(), matchContext.captures().get("encrypted-value").insn().asString()); + matchContext.removeAll(); + }); + } + }); + if (encryptedArray.isEmpty()) return; + + String[] decryptedArray = new String[encryptedArray.size()]; + + classWrapper.methods().forEach(methodNode -> { + DECRYPT_STRING_MATCH.findAllMatches(MethodContext.of(classWrapper, methodNode)).forEach(matchContext -> { + int salt1 = matchContext.captures().get("salt1").insn().asInteger(); + int salt2 = matchContext.captures().get("salt2").insn().asInteger(); + + MethodInsnNode decryptMethodInsn = (MethodInsnNode) matchContext.insn(); + decryptionMethodRef.set(MethodRef.of(decryptMethodInsn)); + + MethodNode decryptionMethod = findMethod(classWrapper.classNode(), MethodRef.of(decryptMethodInsn)).orElseThrow(); + + MethodContext decryptedMethodContext = MethodContext.of(classWrapper, decryptionMethod); + List numbers = NumberMatch.of().findAllMatches(decryptedMethodContext); + + int swappedKey = -1; + + int[] numbersArray = new int[2]; + for (int i = 0, hit = 0; i < numbers.size() && hit < 2; i++) { + if (numbers.get(i).insn().asInteger() != -1) { + numbersArray[hit] = numbers.get(i).insn().asInteger(); + hit++; + } + } + int number1 = numbersArray[0]; + int number2 = numbersArray[1]; + + if (!encryptedArray.containsKey(swappedKey)) { + int key = salt1; + swappedKey = (~(key = (key | number1) & (~key | number2)) | 0xFFFF) - ~key; + } + if (!encryptedArray.containsKey(swappedKey)) { + int key = salt1; + swappedKey = (~(key = key & number1 | ~key & number2) | 0xFFFF) - ~key; + } + if (!encryptedArray.containsKey(swappedKey)) { + int key = salt1; + swappedKey = (~(key = (key | number1) & ~(key & number2)) | 0xFFFF) - ~key; + } + + if (!encryptedArray.containsKey(swappedKey)) { + int key = salt1; + swappedKey = (~(key = (key | number1) - (key & number1)) | 0xFFFF) - ~key; + } + + + if (!encryptedArray.containsKey(swappedKey)) { + System.out.println(swappedKey); + return; + } + + + int n3 = encryptedArray.get(swappedKey).toCharArray()[0]; + int switchCaseKey = (~n3 | 0xFF) - ~n3; + int switchReturnKey; + TableSwitchInsnNode table = (TableSwitchInsnNode) Match.of(ctx -> ctx.insn() instanceof TableSwitchInsnNode).findFirstMatch(decryptedMethodContext).insn(); + if (switchCaseKey >= table.min && switchCaseKey <= table.max) { + switchReturnKey = table.labels.get(switchCaseKey).getNext().asNumber().intValue(); + } else { + switchReturnKey = table.dflt.getNext().asNumber().intValue(); + } + + String decryptedString = decrypt(encryptedArray.get(swappedKey), decryptedArray, salt1, salt2, swappedKey, switchReturnKey); + methodNode.instructions.insert(matchContext.insn(), new LdcInsnNode(decryptedString)); + matchContext.removeAll(); + + markChange(); + }); + }); + + // Remove decryption method + if (decryptionMethodRef.get() != null) { + classWrapper.methods().removeIf(methodNode -> methodNode.name.equals(decryptionMethodRef.get().name()) && methodNode.desc.equals(decryptionMethodRef.get().desc())); + } + }); + } + /* + * n pierwszy klucz + * n2 drugi klucz + * n4 klucz rozszyfrowany po pierwszej matematyce losowej + * n5 zwrocony przez switch klucz + * */ + private static String decrypt(String encryptedString, String[] decryptedArray, int n, int n2, int n4, int n5) { + int n3 = n; + if (decryptedArray[n4] == null) { + char[] cArray = encryptedString.toCharArray(); + + n3 = (short)n2; + int n6 = (~n3 | 0xFF) - ~n3 + ~n5 + 1; + if (n6 < 0) { + n6 += 256; + } + n3 = (short)n2; + int n7 = n5; + int n8 = ((n3 = (~n3 | 0xFFFF) - ~n3 >>> 8) & ~n7) - (~n3 & n7); + if (n8 < 0) { + n8 += 256; + } + int n9 = 0; + while (n9 < cArray.length) { + int n10 = n9 % 2; + int n11 = n9; + char[] cArray2 = cArray; + int n12 = cArray[n11]; + if (n10 == 0) { + n7 = n6; + n3 = n12; + cArray2[n11] = (char)(n3 & ~n7 | ~n3 & n7); + n7 = n6 << 5; + n3 = n6 >>> 3; + int n13 = (n3 & ~n7) + n7; + n7 = cArray[n9]; + n3 = n13; + n3 = (n3 | n7) & (~n3 | ~n7); + n6 = (~n3 | 0xFF) - ~n3; + } else { + n7 = n8; + n3 = n12; + cArray2[n11] = (char)(n3 & ~n7 | ~n3 & n7); + n7 = n8 << 5; + n3 = n8 >>> 3; + int n14 = (n3 & ~n7) + n7; + n7 = cArray[n9]; + n3 = n14; + n3 = (n3 | n7) - (n3 & n7); + n8 = (~n3 | 0xFF) - ~n3; + } + ++n9; + } + decryptedArray[n4] = new String(cArray).intern(); + } + return decryptedArray[n4]; + } +} diff --git a/deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/universal/pool/UniversalNumberPoolTransformer.java b/deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/universal/pool/UniversalNumberPoolTransformer.java index dca07ae7..8706323b 100644 --- a/deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/universal/pool/UniversalNumberPoolTransformer.java +++ b/deobfuscator-transformers/src/main/java/uwu/narumi/deobfuscator/core/other/impl/universal/pool/UniversalNumberPoolTransformer.java @@ -11,6 +11,7 @@ import uwu.narumi.deobfuscator.api.asm.matcher.Match; import uwu.narumi.deobfuscator.api.asm.matcher.MatchContext; import uwu.narumi.deobfuscator.api.asm.matcher.group.AnyMatch; +import uwu.narumi.deobfuscator.api.asm.matcher.group.SequenceMatch; import uwu.narumi.deobfuscator.api.asm.matcher.impl.FieldMatch; import uwu.narumi.deobfuscator.api.asm.matcher.impl.FrameMatch; import uwu.narumi.deobfuscator.api.asm.matcher.impl.InsnMatch; @@ -24,6 +25,7 @@ import java.util.Objects; import java.util.Set; +import java.util.concurrent.atomic.AtomicBoolean; /** * Transforms number pool references to actual values. diff --git a/testData/compiled/custom-classes/qprotect/sample4/fastcode/IIlIllllIIIlIlllIl.class b/testData/compiled/custom-classes/qprotect/sample4/fastcode/IIlIllllIIIlIlllIl.class new file mode 100644 index 00000000..5c6e5c10 Binary files /dev/null and b/testData/compiled/custom-classes/qprotect/sample4/fastcode/IIlIllllIIIlIlllIl.class differ diff --git a/testData/results/custom-classes/qprotect/sample3/fastcode/IlllIIlIIlllIIIl.dec b/testData/results/custom-classes/qprotect/sample3/fastcode/IlllIIlIIlllIIIl.dec index f5b6116d..090e0adc 100644 --- a/testData/results/custom-classes/qprotect/sample3/fastcode/IlllIIlIIlllIIIl.dec +++ b/testData/results/custom-classes/qprotect/sample3/fastcode/IlllIIlIIlllIIIl.dec @@ -10,9 +10,7 @@ import org.bukkit.configuration.file.YamlConfiguration; import org.bukkit.inventory.ItemStack; public class IlllIIlIIlllIIIl { - private static final String[] IlIIlIlIIIIIlll = new String[]{ - "EáÞ\u0018¸", "ßÖA", "Õ", "%Qj\u0002", "\u009fS\u0085NÓúØ", "÷Ö\u0006\u0095ù", "ÚÈb\u001cÛ9", "$wòÊ=j", "ý»\u0001\u0018\u009a", "\u0090¦]í®*" - }; + private static final String[] IlIIlIlIIIIIlll = new String[10]; public IIIlllIIIIllIl userManager; public IIIIlIIIIIIl plugin = IIIIlIIIIIIl.getPlugin(); private static final String[] IIllIIIlIlIIlII = new String[10]; @@ -24,24 +22,19 @@ public class IlllIIlIIlllIIIl { public IlllIIlIIlllIIIl() { this.userManager = this.plugin.getUserManager(); - this.database = new File(this.plugin.getDataFolder(), IIIllIIIlIIIIIl(-2044252752, 906984765)); + this.database = new File(this.plugin.getDataFolder(), "users"); } public void loadUser(IllIlIIIllIIll var1, File var2) { try { YamlConfiguration var3 = YamlConfiguration.loadConfiguration(var2); ArrayList var4 = new ArrayList(); - if (var3.contains(IIIllIIIlIIIIIl(498347452, -1569708320) + IIIllIIIlIIIIIl(-472699458, -412626163))) { - Objects.requireNonNull( - var3.getList( - IIIllIIIlIIIIIl(-260821569, 1878136150) + IIIllIIIlIIIIIl(525217201, -1963008494) + IIIllIIIlIIIIIl(-924701254, -1452694356) - ) - ) - .forEach(var1x -> { - if (var1x instanceof ItemStack) { - var4.add((ItemStack)var1x); - } - }); + if (var3.contains("sakiewkaItems")) { + Objects.requireNonNull(var3.getList("sakiewkaItems")).forEach(var1x -> { + if (var1x instanceof ItemStack) { + var4.add((ItemStack)var1x); + } + }); } var1.setSakiewkaItems(var4); @@ -58,21 +51,14 @@ public class IlllIIlIIlllIIIl { } else { try { YamlConfiguration var3 = YamlConfiguration.loadConfiguration(var2); - IllIlIIIllIIll var4 = new IllIlIIIllIIll(var3.getString(IIIllIIIlIIIIIl(-466014789, -1870939692))); + IllIlIIIllIIll var4 = new IllIlIIIllIIll(var3.getString("name")); ArrayList var5 = new ArrayList(); - if (var3.contains(IIIllIIIlIIIIIl(-616747585, 821106006) + IIIllIIIlIIIIIl(-681955919, -1796547054) + IIIllIIIlIIIIIl(1487220154, -1766480724)) - ) - { - Objects.requireNonNull( - var3.getList( - IIIllIIIlIIIIIl(-1446695489, -1084877482) + IIIllIIIlIIIIIl(493628849, -115483118) + IIIllIIIlIIIIIl(135540154, -998923092) - ) - ) - .forEach(var1x -> { - if (var1x instanceof ItemStack) { - var5.add((ItemStack)var1x); - } - }); + if (var3.contains("sakiewkaItems")) { + Objects.requireNonNull(var3.getList("sakiewkaItems")).forEach(var1x -> { + if (var1x instanceof ItemStack) { + var5.add((ItemStack)var1x); + } + }); } var4.setSakiewkaItems(var5); @@ -90,9 +76,9 @@ public class IlllIIlIIlllIIIl { YamlConfiguration var3 = new YamlConfiguration(); try { - var3.set(IIIllIIIlIIIIIl(224341435, 1776794068), var1.getName()); + var3.set("name", var1.getName()); List var4 = var1.getSakiewkaItems(); - var3.set(IIIllIIIlIIIIIl(1792421304, 826715748) + IIIllIIIlIIIIIl(-24891971, 315653954) + IIIllIIIlIIIIIl(378023353, 747270512), var4); + var3.set("sakiewkaItems", var4); var3.save(var2); } catch (IOException var5) { Bukkit.getLogger().severe("Failed to save user data to file: " + var2.getName()); @@ -100,318 +86,6 @@ public class IlllIIlIIlllIIIl { } } - private static String IIIllIIIlIIIIIl(int var0, int var1) { - int var12 = (var0 | 11704) & ~(var0 & 11704); - int var2 = (~var12 | 65535) - ~var12; - if (IIllIIIlIlIIlII[var2] == null) { - char[] var3 = IlIIlIlIIIIIlll[var2].toCharArray(); - int var14 = var3[0]; - - short var4 = switch ((~var14 | 0xFF) - ~var14) { - case 0 -> 55; - case 1 -> 95; - case 2 -> 0; - case 3 -> 21; - case 4 -> 105; - case 5 -> 38; - case 6 -> 116; - case 7 -> 80; - case 8 -> 19; - case 9 -> 65; - case 10 -> 2; - case 11 -> 123; - case 12 -> 161; - case 13 -> 163; - case 14 -> 233; - case 15 -> 50; - case 16 -> 10; - case 17 -> 243; - case 18 -> 177; - case 19 -> 127; - case 20 -> 199; - case 21 -> 62; - case 22 -> 81; - case 23 -> 58; - case 24 -> 162; - case 25 -> 120; - case 26 -> 229; - case 27 -> 74; - case 28 -> 11; - case 29 -> 159; - case 30 -> 119; - case 31 -> 66; - case 32 -> 225; - case 33 -> 190; - case 34 -> 167; - case 35 -> 18; - case 36 -> 255; - case 37 -> 137; - case 38 -> 215; - case 39 -> 201; - case 40 -> 131; - case 41 -> 37; - case 42 -> 22; - case 43 -> 91; - case 44 -> 178; - case 45 -> 113; - case 46 -> 157; - case 47 -> 246; - case 48 -> 25; - case 49 -> 180; - case 50 -> 170; - case 51 -> 14; - case 52 -> 138; - case 53 -> 17; - case 54 -> 212; - case 55 -> 72; - case 56 -> 9; - case 57 -> 88; - case 58 -> 149; - case 59 -> 124; - case 60 -> 168; - case 61 -> 226; - case 62 -> 107; - case 63 -> 64; - case 64 -> 188; - case 65 -> 184; - case 66 -> 34; - case 67 -> 213; - case 68 -> 63; - case 69 -> 46; - case 70 -> 223; - case 71 -> 92; - case 72 -> 133; - case 73 -> 164; - case 74 -> 98; - case 75 -> 208; - case 76 -> 197; - case 77 -> 28; - case 78 -> 7; - case 79 -> 13; - case 80 -> 155; - case 81 -> 148; - case 82 -> 117; - case 83 -> 15; - case 84 -> 114; - case 85 -> 247; - case 86 -> 236; - case 87 -> 205; - case 88 -> 32; - case 89 -> 41; - case 90 -> 76; - case 91 -> 189; - case 92 -> 141; - case 93 -> 69; - case 94 -> 192; - case 95 -> 135; - case 96 -> 89; - case 97 -> 40; - case 98 -> 51; - case 99 -> 47; - case 100 -> 110; - case 101 -> 118; - case 102 -> 57; - case 103 -> 239; - case 104 -> 253; - case 105 -> 54; - case 106 -> 206; - case 107 -> 60; - case 108 -> 165; - case 109 -> 102; - case 110 -> 125; - case 111 -> 130; - case 112 -> 166; - case 113 -> 12; - case 114 -> 36; - case 115 -> 222; - case 116 -> 26; - case 117 -> 142; - case 118 -> 45; - case 119 -> 129; - case 120 -> 78; - case 121 -> 156; - case 122 -> 132; - case 123 -> 195; - case 124 -> 220; - case 125 -> 71; - case 126 -> 238; - case 127 -> 49; - case 128 -> 202; - case 129 -> 151; - case 130 -> 126; - case 131 -> 230; - case 132 -> 173; - case 133 -> 53; - case 134 -> 245; - case 135 -> 5; - case 136 -> 150; - case 137 -> 187; - case 138 -> 8; - case 139 -> 61; - case 140 -> 193; - case 141 -> 68; - case 142 -> 99; - case 143 -> 175; - case 144 -> 23; - case 145 -> 196; - case 146 -> 30; - case 147 -> 85; - case 148 -> 4; - case 149 -> 101; - case 150 -> 44; - case 151 -> 139; - case 152 -> 70; - case 153 -> 83; - case 154 -> 209; - case 155 -> 174; - case 156 -> 87; - case 157 -> 75; - case 158 -> 29; - case 159 -> 244; - case 160 -> 154; - case 161 -> 94; - case 162 -> 147; - case 163 -> 171; - case 164 -> 112; - case 165 -> 59; - case 166 -> 35; - case 167 -> 79; - case 168 -> 204; - case 169 -> 97; - case 170 -> 146; - case 171 -> 108; - case 172 -> 1; - case 173 -> 104; - case 174 -> 176; - case 175 -> 73; - case 176 -> 198; - case 177 -> 90; - case 178 -> 158; - case 179 -> 221; - case 180 -> 152; - case 181 -> 103; - case 182 -> 100; - case 183 -> 248; - case 184 -> 143; - case 185 -> 240; - case 186 -> 31; - case 187 -> 43; - case 188 -> 252; - case 189 -> 234; - case 190 -> 235; - case 191 -> 249; - case 192 -> 144; - case 193 -> 254; - case 194 -> 153; - case 195 -> 140; - case 196 -> 207; - case 197 -> 217; - case 198 -> 3; - case 199 -> 160; - case 200 -> 224; - case 201 -> 109; - case 202 -> 121; - case 203 -> 203; - case 204 -> 172; - case 205 -> 93; - case 206 -> 186; - case 207 -> 231; - case 208 -> 218; - case 209 -> 52; - case 210 -> 77; - case 211 -> 219; - case 212 -> 48; - case 213 -> 6; - case 214 -> 122; - case 215 -> 20; - case 216 -> 191; - case 217 -> 16; - case 218 -> 82; - case 219 -> 136; - case 220 -> 242; - case 221 -> 39; - case 222 -> 96; - case 223 -> 182; - case 224 -> 169; - case 225 -> 67; - case 226 -> 33; - case 227 -> 145; - case 228 -> 241; - case 229 -> 250; - case 230 -> 24; - case 231 -> 183; - case 232 -> 115; - case 233 -> 128; - case 234 -> 27; - case 235 -> 251; - case 236 -> 228; - case 237 -> 84; - case 238 -> 179; - case 239 -> 237; - case 240 -> 214; - case 241 -> 56; - case 242 -> 86; - case 243 -> 42; - case 244 -> 227; - case 245 -> 185; - case 246 -> 106; - case 247 -> 194; - case 248 -> 200; - case 249 -> 210; - case 250 -> 216; - case 251 -> 111; - case 252 -> 232; - case 253 -> 181; - case 254 -> 134; - default -> 211; - }; - int var15 = (short)var1; - int var5 = (~var15 | 0xFF) - ~var15 + ~var4 + 1; - if (var5 < 0) { - var5 += 256; - } - - var15 = (short)var1; - var14 = (~var15 | 65535) - ~var15 >>> 8; - int var6 = (var14 ^ var4) - 2 * (~var14 & var4); - if (var6 < 0) { - var6 += 256; - } - - for (int var7 = 0; var7 < var3.length; var7++) { - int var8 = var7 % 2; - char var10002 = var3[var7]; - if (var8 == 0) { - char var18 = var10002; - var3[var7] = (char)((var18 | var5) & ~(var18 & var5)); - int var29 = var5 >>> 3; - int var13 = var5 << 5; - var15 = var29; - var29 = (var15 & ~var13) + var13; - char var26 = var3[var7]; - var15 = var29; - var15 = var15 & ~var26 | ~var15 & var26; - var5 = (~var15 | 0xFF) - ~var15; - } else { - int var22 = var10002; - var3[var7] = (char)((var22 | var6) - (var22 & var6)); - int var31 = var6 >>> 3; - int var27 = var6 << 5; - var22 = var31; - var31 = (var22 & ~var27) + var27; - char var28 = var3[var7]; - var22 = var31; - var22 = (var22 | var28) - (var22 & var28); - var6 = (~var22 | 0xFF) - ~var22; - } - } - - IIllIIIlIlIIlII[var2] = new String(var3).intern(); - } - - return IIllIIIlIlIIlII[var2]; - } - private File getFile(String var1) { return new File(this.database, var1 + ".yml"); }