added files.

.gitignore

@@ -0,0 +1,8 @@
+.gradle/
+build/
+out/
+.idea/
+*.iml
+.classpath
+.project
+.settings/

README.md

@@ -0,0 +1,43 @@
+<p align="center">
+  <img src="assets/ss.png" alt="Skid Solutions Banner" width="350" />
+  <br>
+  <font size="6"><b>OpenAllatori</b></font>
+  <br>
+  <font size="3">by Skid Solutions</font>
+</p>
+
+---
+
+<p align="center">
+  <a href="https://discord.gg/AEwatvnvSf">https://discord.gg/AEwatvnvSf</a>
+</p>
+
+<p align="center">
+  <img src="assets/jak.jpg" alt="jak" height="150" />
+  <img src="assets/hack.jpg" alt="hack" height="150" />
+  <img src="assets/deobf2.png" alt="deobf2" height="150" />
+  <img src="assets/deobf.jpg" alt="deobf" height="150" />
+</p>
+
+---
+
+## How to build
+
+### Prerequisites
+- **Java Development Kit**: JDK 17 (the Gradle wrapper 8.14.3 does not run on newer JDKs)
+
+---
+
+### Building OpenAllatori
+
+Run from this folder:
+
+```powershell
+$env:JAVA_HOME = "C:\Program Files\Java\jdk-17"
+
+.\gradlew.bat clean build
+```
+
+Generated `build/libs/`:
+- `OpenAllatori-9.9.jar`
+- `OpenAllatori-9.9-sources.jar`

build.gradle

@@ -0,0 +1,53 @@
+plugins {
+    id 'java'
+    id 'application'
+    id 'idea'
+    id 'eclipse'
+}
+group = 'com.allatori'
+version = '9.9'
+repositories { mavenCentral() }
+java {
+    toolchain.languageVersion = JavaLanguageVersion.of(17)
+    withSourcesJar()
+}
+application {
+    mainClass = 'com.allatori.Obfuscate'
+    applicationDefaultJvmArgs = ['--add-opens=java.base/java.util.zip=ALL-UNNAMED']
+}
+sourceSets {
+    wtkApi { java.srcDir 'src/wtkApi/java' }
+    main { compileClasspath += sourceSets.wtkApi.output }
+}
+dependencies {
+    compileOnly 'org.apache.ant:ant:1.10.15'
+    compileOnly('org.eclipse.platform:org.eclipse.equinox.registry:3.11.200') { transitive = false }
+    compileOnly('org.eclipse.platform:org.eclipse.core.resources:3.18.100') { transitive = false }
+    compileOnly('org.eclipse.platform:org.eclipse.core.runtime:3.26.100') { transitive = false }
+    compileOnly('org.eclipse.platform:org.eclipse.equinox.common:3.17.0') { transitive = false }
+    compileOnly('org.eclipse.platform:org.eclipse.core.jobs:3.13.200') { transitive = false }
+    compileOnly('org.eclipse.platform:org.eclipse.core.commands:3.10.300') { transitive = false }
+    compileOnly('org.eclipse.platform:org.eclipse.core.expressions:3.8.200') { transitive = false }
+    compileOnly('org.eclipse.platform:org.eclipse.jface:3.28.0') { transitive = false }
+    compileOnly('org.eclipse.platform:org.eclipse.ui.workbench:3.127.0') { transitive = false }
+    compileOnly('org.eclipse.platform:org.eclipse.osgi:3.18.200') { transitive = false }
+    compileOnly('org.eclipse.jdt:org.eclipse.jdt.core:3.32.0') { transitive = false }
+}
+tasks.named('compileJava') { dependsOn tasks.named('wtkApiClasses') }
+tasks.withType(JavaCompile).configureEach {
+    options.release = 17
+    options.encoding = 'UTF-8'
+    options.compilerArgs += ['-parameters', '-Xmaxerrs', '2000']
+}
+tasks.withType(AbstractArchiveTask).configureEach {
+    preserveFileTimestamps = false
+    reproducibleFileOrder = true
+}
+jar {
+    manifest {
+        from('src/main/resources/META-INF/MANIFEST.MF')
+        attributes('Main-Class': 'com.allatori.Obfuscate', 'Bundle-RequiredExecutionEnvironment': 'JavaSE-17', 'Add-Opens': 'java.base/java.util.zip')
+    }
+}
+processResources { exclude 'META-INF/MANIFEST.MF' }
+tasks.register('resolveCompileApis') { doLast { configurations.compileClasspath.files.each { println it.name } } }

gradle.properties

@@ -0,0 +1,2 @@
+org.gradle.jvmargs=-Xmx3g -Dfile.encoding=UTF-8
+org.gradle.workers.max=2

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,8 @@
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.14.3-bin.zip
+networkTimeout=10000
+validateDistributionUrl=true
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionSha256Sum=bd71102213493060956ec229d946beee57158dbd89d0e62b91bca0fa2c5f3531

gradlew

@@ -0,0 +1,251 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+# This is normally unused
+# shellcheck disable=SC2034
+APP_BASE_NAME=${0##*/}
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s\n' "$PWD" ) || exit
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH="\\\"\\\""
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        -jar "$APP_HOME/gradle/wrapper/gradle-wrapper.jar" \
+        "$@"
+
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,94 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
+
+@if "%DEBUG%"=="" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if %ERRORLEVEL% equ 0 goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" -jar "%APP_HOME%\gradle\wrapper\gradle-wrapper.jar" %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if %ERRORLEVEL% equ 0 goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

settings.gradle

@@ -0,0 +1,7 @@
+pluginManagement {
+    repositories {
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}
+rootProject.name = 'OpenAllatori'

src/main/java/com/allatori/Obfuscate.java

@@ -0,0 +1,75 @@
+package com.allatori;
+
+import com.allatori.cli.ObfuscationCommandSupport;
+import com.allatori.config.Configuration;
+import com.allatori.engine.ObfuscationEngine;
+import com.allatori.engine.ObfuscationException;
+import com.allatori.model.ClassStorage;
+import com.allatori.naming.MappingXmlWriter;
+import com.allatori.util.Log;
+import java.io.File;
+import java.io.IOException;
+
+public class Obfuscate extends ObfuscationCommandSupport {
+
+  public static void obfuscate(ClassStorage classStorage) {
+    new ObfuscationEngine(classStorage).obfuscate();
+  }
+
+  public static void runObfuscation()
+      throws IOException, ObfuscationException, ClassNotFoundException {
+    ClassStorage classStorage;
+    obfuscate(classStorage = createClassStorage());
+    if (Configuration.getWatermarkOptions().getText2() != null
+        && Configuration.getWatermarkOptions().getText() != null) {
+      addWatermark(classStorage);
+    }
+    if (Configuration.getObfuscationOptions().isJava6Enabled()) {
+      limitClassVersion(classStorage);
+    }
+    writeAllOutputs(classStorage);
+    Log.info2("Obfuscation completed. Writing log file...");
+    MappingXmlWriter.update();
+  }
+
+  public static void main(String[] texts) {
+    String[] texts2;
+    if (texts.length > 1 && "-silent".equals(texts[1])) {
+      Log.setSilent(true);
+      texts2 = texts;
+    } else {
+      System.out.println(getBanner());
+      texts2 = texts;
+    }
+    if (texts2.length != 1 && !Log.isSilent()) {
+      printUsage();
+      System.exit(0);
+    }
+    if (!loadConfigurationSafely(texts[0])) {
+      System.exit(-1);
+    }
+    try {
+      runObfuscation();
+    } catch (Exception exception) {
+      Log.error(exception.getMessage());
+      System.out.println(
+          "############### EXCEPTION (" + VersionInfo.getVersion() + ") ###############");
+      exception.printStackTrace();
+      System.out.println("#################################################");
+      System.exit(-1);
+    }
+    Configuration.update();
+  }
+
+  public static void printUsage() {
+    System.out.println("" + VersionInfo.getProductName() + " " + VersionInfo.getVersion());
+    System.out.println("Usage:");
+    System.out.println("com.allatori.Obfuscate <config file>");
+  }
+
+  public static void run(File file) throws Exception {
+    loadConfiguration(file.getPath());
+    runObfuscation();
+    Configuration.update();
+  }
+}

src/main/java/com/allatori/StackTrace.java

@@ -0,0 +1,109 @@
+package com.allatori;
+
+import com.allatori.cli.ObfuscationCommandSupport;
+import com.allatori.stacktrace.MappingXmlReader;
+import com.allatori.stacktrace.StackTraceMappings;
+import com.allatori.stacktrace.StackTraceRestorer;
+import com.allatori.util.Log;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.io.UnsupportedEncodingException;
+import javax.xml.parsers.ParserConfigurationException;
+import org.xml.sax.SAXException;
+
+public class StackTrace {
+
+  public static void printUsage() {
+    System.out.println("Restore Stack Trace Utility");
+    System.out.println("Usage:");
+    System.out.println("com.allatori.StackTrace <log file> <input file> <output file>");
+  }
+
+  public static String restoreStackTrace(File file, String text)
+      throws FileNotFoundException,
+          UnsupportedEncodingException,
+          IOException,
+          ParserConfigurationException,
+          SAXException {
+    StackTraceMappings stackTraceMappings =
+        MappingXmlReader.createStackTraceMappings(
+            new InputStreamReader(new FileInputStream(file), "UTF-8"));
+    BufferedReader bufferedReader = new BufferedReader(new StringReader(text));
+    StringWriter stringWriter = new StringWriter();
+    PrintWriter printWriter = new PrintWriter(stringWriter);
+    StackTraceRestorer.processPrintWriter(bufferedReader, stackTraceMappings, printWriter);
+    bufferedReader.close();
+    printWriter.close();
+    return stringWriter.toString();
+  }
+
+  public static void main(String[] texts) {
+    BufferedReader bufferedReader;
+    System.out.println(ObfuscationCommandSupport.getBanner());
+    try {
+      if (texts.length != 3) {
+        printUsage();
+        System.exit(0);
+      }
+      StackTraceMappings stackTraceMappings = null;
+      String text = texts[0];
+      String[] texts2;
+      label39:
+      {
+        try {
+          stackTraceMappings =
+              MappingXmlReader.createStackTraceMappings(
+                  new InputStreamReader(new FileInputStream(text), "UTF-8"));
+        } catch (FileNotFoundException fileNotFoundException) {
+          Log.error("Log file not found: " + fileNotFoundException.getMessage());
+          System.exit(0);
+          texts2 = texts;
+          break label39;
+        } catch (Exception exception) {
+          Log.error("Error reading log file: " + exception.getMessage());
+          System.exit(0);
+          texts2 = texts;
+          break label39;
+        }
+        texts2 = texts;
+      }
+      String text2 = texts2[1];
+      String text3 = texts[2];
+      BufferedReader bufferedReader2 = null;
+      try {
+        bufferedReader2 = new BufferedReader(new FileReader(text2));
+      } catch (FileNotFoundException fileNotFoundException2) {
+        Log.error("Input file not found: " + fileNotFoundException2.getMessage());
+        System.exit(0);
+      }
+      PrintWriter printWriter = null;
+      label34:
+      {
+        try {
+          printWriter = new PrintWriter(new BufferedWriter(new FileWriter(text3)));
+        } catch (IOException oException) {
+          Log.error("Error writing output file: " + oException.getMessage());
+          System.exit(0);
+          bufferedReader = bufferedReader2;
+          break label34;
+        }
+        bufferedReader = bufferedReader2;
+      }
+      StackTraceRestorer.processPrintWriter(bufferedReader, stackTraceMappings, printWriter);
+      bufferedReader2.close();
+      printWriter.close();
+    } catch (Exception exception2) {
+      System.out.println("Error: " + exception2.getMessage());
+    }
+  }
+}

src/main/java/com/allatori/StackTrace2.java

@@ -0,0 +1,109 @@
+package com.allatori;
+
+import com.allatori.cli.ObfuscationCommandSupport;
+import com.allatori.stacktrace.MappingXmlReader;
+import com.allatori.stacktrace.StackTraceMappings;
+import com.allatori.stacktrace.StackTraceRestorer;
+import com.allatori.util.Log;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.io.StringReader;
+import java.io.StringWriter;
+import java.io.UnsupportedEncodingException;
+import javax.xml.parsers.ParserConfigurationException;
+import org.xml.sax.SAXException;
+
+public class StackTrace2 {
+
+  public static String restoreStackTrace(File file, String text)
+      throws FileNotFoundException,
+          UnsupportedEncodingException,
+          IOException,
+          ParserConfigurationException,
+          SAXException {
+    StackTraceMappings stackTraceMappings =
+        MappingXmlReader.createStackTraceMappings(
+            new InputStreamReader(new FileInputStream(file), "UTF-8"));
+    BufferedReader bufferedReader = new BufferedReader(new StringReader(text));
+    StringWriter stringWriter = new StringWriter();
+    PrintWriter printWriter = new PrintWriter(stringWriter);
+    StackTraceRestorer.processPrintWriter2(bufferedReader, stackTraceMappings, printWriter);
+    bufferedReader.close();
+    printWriter.close();
+    return stringWriter.toString();
+  }
+
+  public static void printUsage() {
+    System.out.println("Restore Stack Trace Utility");
+    System.out.println("Usage:");
+    System.out.println("com.allatori.StackTrace2 <log file> <input file> <output file>");
+  }
+
+  public static void main(String[] texts) {
+    BufferedReader bufferedReader;
+    System.out.println(ObfuscationCommandSupport.getBanner());
+    try {
+      if (texts.length != 3) {
+        printUsage();
+        System.exit(0);
+      }
+      StackTraceMappings stackTraceMappings = null;
+      String text = texts[0];
+      String[] texts2;
+      label39:
+      {
+        try {
+          stackTraceMappings =
+              MappingXmlReader.createStackTraceMappings(
+                  new InputStreamReader(new FileInputStream(text), "UTF-8"));
+        } catch (FileNotFoundException fileNotFoundException) {
+          Log.error("Log file not found: " + fileNotFoundException.getMessage());
+          System.exit(0);
+          texts2 = texts;
+          break label39;
+        } catch (Exception exception) {
+          Log.error("Error reading log file: " + exception.getMessage());
+          System.exit(0);
+          texts2 = texts;
+          break label39;
+        }
+        texts2 = texts;
+      }
+      String text2 = texts2[1];
+      String text3 = texts[2];
+      BufferedReader bufferedReader2 = null;
+      try {
+        bufferedReader2 = new BufferedReader(new FileReader(text2));
+      } catch (FileNotFoundException fileNotFoundException2) {
+        Log.error("Input file not found: " + fileNotFoundException2.getMessage());
+        System.exit(0);
+      }
+      PrintWriter printWriter = null;
+      label34:
+      {
+        try {
+          printWriter = new PrintWriter(new BufferedWriter(new FileWriter(text3)));
+        } catch (IOException oException) {
+          Log.error("Error writing output file: " + oException.getMessage());
+          System.exit(0);
+          bufferedReader = bufferedReader2;
+          break label34;
+        }
+        bufferedReader = bufferedReader2;
+      }
+      StackTraceRestorer.processPrintWriter2(bufferedReader, stackTraceMappings, printWriter);
+      bufferedReader2.close();
+      printWriter.close();
+    } catch (Exception exception2) {
+      System.out.println("Error: " + exception2.getMessage());
+    }
+  }
+}

src/main/java/com/allatori/VersionInfo.java

@@ -0,0 +1,16 @@
+package com.allatori;
+
+public class VersionInfo {
+
+  public static String getProductName() {
+    return "OpenAllatori";
+  }
+
+  public static String getVersion() {
+    return "v9.9";
+  }
+
+  public static String getWebsite() {
+    return "https://github.com/Skid-Technology";
+  }
+}

src/main/java/com/allatori/Watermark.java

@@ -0,0 +1,65 @@
+package com.allatori;
+
+import com.allatori.cli.ObfuscationCommandSupport;
+import com.allatori.config.Configuration;
+import com.allatori.model.ClassStorage;
+import com.allatori.util.Log;
+
+public class Watermark extends ObfuscationCommandSupport {
+
+  public static void main(String[] texts) {
+    System.out.println(getBanner());
+    if (texts.length != 2) {
+      printUsage();
+      System.exit(0);
+    }
+    byte value = 0;
+    String[] texts2;
+    if ("-add".equals(texts[0])) {
+      value = 0;
+      texts2 = texts;
+    } else if ("-extract".equals(texts[0])) {
+      value = 1;
+      texts2 = texts;
+    } else {
+      printUsage();
+      System.exit(0);
+      texts2 = texts;
+    }
+    if (!loadConfigurationSafely(texts2[1], value != 0)) {
+      System.exit(-1);
+    }
+    try {
+      ClassStorage classStorage = Obfuscate.createClassStorage();
+      if (Configuration.getWatermarkOptions().isEnabled()) {
+        if (Configuration.getWatermarkOptions().getText2() == null) {
+          Log.error("Configuration error. Watermark key is not set.");
+          System.exit(0);
+        }
+        System.out.println("Extracted watermark: \"" + extractWatermark(classStorage) + "\"");
+      } else {
+        if (Configuration.getWatermarkOptions().getText2() == null) {
+          Log.error("Configuration error. Watermark key is not set.");
+          System.exit(0);
+        }
+        if (Configuration.getWatermarkOptions().getText() == null) {
+          Log.error("Configuration error. Watermark value is not set.");
+          System.exit(0);
+        }
+        addWatermark(classStorage);
+        writeAllOutputs(classStorage);
+      }
+    } catch (Exception exception) {
+      Log.error(exception.getMessage());
+    }
+    Configuration.update();
+  }
+
+  public static void printUsage() {
+    System.out.println("" + VersionInfo.getProductName() + " " + VersionInfo.getVersion());
+    System.out.println("Usage:");
+    System.out.println("com.allatori.Watermark -add <config file>");
+    System.out.println("or");
+    System.out.println("com.allatori.Watermark -extract <config file>");
+  }
+}

src/main/java/com/allatori/ant/ObfuscatorTask.java

@@ -0,0 +1,39 @@
+package com.allatori.ant;
+
+import com.allatori.Obfuscate;
+import com.allatori.config.Configuration;
+import com.allatori.util.FileUtils;
+import java.io.File;
+import org.apache.tools.ant.BuildException;
+import org.apache.tools.ant.Task;
+
+public class ObfuscatorTask extends Task {
+
+  public String config;
+
+  public void execute() {
+    if (this.config == null) {
+      throw new BuildException("Missing 'config' attribute.");
+    }
+    try {
+      File file;
+      if (!(file = new File(this.config)).canRead()) {
+        throw new BuildException(("Cannot find configuration file: '" + this.config + "'"));
+      }
+      File file2 = new File(("" + this.config + ".resolved"));
+      file2.deleteOnExit();
+      String text = FileUtils.createText(file, "UTF-8");
+      String text2 = this.getProject().replaceProperties(text);
+      FileUtils.processText(file2, "UTF-8", text2);
+      Configuration.processText(file2.getPath());
+      Obfuscate.runObfuscation();
+      Configuration.update();
+    } catch (Exception exception) {
+      throw new BuildException(exception);
+    }
+  }
+
+  public void setConfig(String config) {
+    this.config = config;
+  }
+}

src/main/java/com/allatori/bytecode/ClassHierarchy.java

@@ -0,0 +1,336 @@
+package com.allatori.bytecode;
+
+import com.allatori.config.Configuration;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.lib.bcel.generic.MethodGen$2;
+import com.allatori.lib.bcel.generic.Type;
+import com.allatori.model.ClassStorage;
+import com.allatori.util.Log;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Collections;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.Vector;
+
+public class ClassHierarchy {
+
+  public Hashtable entries;
+
+  public Hashtable entries2;
+
+  public Vector values;
+
+  public static final String TEXT = "-=404=-";
+
+  public static final Vector VALUES = new Vector();
+
+  public static final Set VALUES2 = new OrderedClassSet();
+
+  public ClassStorage classStorage;
+
+  public Set values2;
+
+  public Set createValues(Set values) {
+    if (values.contains("-=404=-")) {
+      return VALUES2;
+    }
+    TreeSet treeSet = new TreeSet();
+    for (String text : ((Iterable<String>) ((Iterable<?>) values))) {
+      if (this.classStorage.getClassGen(text) == null) {
+        try {
+          Method[] methods;
+          for (int value =
+                  (methods =
+                              Class.forName(text, false, this.classStorage.getClassLoader())
+                                  .getDeclaredMethods())
+                          .length
+                      - 1;
+              value >= 0;
+              value--) {
+            Method method = methods[value];
+            if (this.matchesMethod(method)) {
+              treeSet.add(method.getName() + "&" + Type.getSignature(method));
+            }
+          }
+        } catch (ClassNotFoundException classNotFoundException) {
+        } catch (NoClassDefFoundError noClassDefFoundError) {
+          String text2;
+          if ((text2 = noClassDefFoundError.getMessage()).length() > 0) {
+            String text3 = text2.replace('/', '.');
+            if (!this.entries.containsKey(text3)) {
+              this.entries.put(text3, "");
+              Log.warn("Class '" + text3 + "' cannot be found.");
+            }
+          }
+        } catch (VerifyError verifyError) {
+          Log.warn(
+              "Cannot read class. Possible JVM compile and runtime versions mismatch: "
+                  + verifyError.getMessage());
+        }
+      } else {
+        int value2;
+        if (Configuration.getIgnoreClassesOptions()
+            .matchesClassGen(this.classStorage, this.classStorage.getClassGen(text))) {
+          com.allatori.lib.bcel.classfile.Method[] methods2;
+          for (int value3 =
+                  value2 = (methods2 = this.classStorage.getClassGen(text).getMethods()).length - 1;
+              value3 >= 0;
+              value3 = --value2) {
+            com.allatori.lib.bcel.classfile.Method method2;
+            if (!(method2 = methods2[value2]).isEnabled9() && !method2.isEnabled11()) {
+              treeSet.add("" + method2.getText() + "&" + method2.getText2());
+            }
+          }
+        }
+      }
+    }
+    return treeSet;
+  }
+
+  public void processClassGen(ClassGen classGen) {
+    this.values.remove(classGen);
+    this.values.add(0, classGen);
+    String superclassName = classGen.getSuperclassName();
+    ClassGen classGen2 = this.classStorage.getClassGen(superclassName);
+    if (classGen2 != null) {
+      this.processClassGen(classGen2);
+    }
+    String[] texts;
+    int value;
+    for (int value2 = value = (texts = classGen.getInterfaceNames()).length - 1;
+        value2 >= 0;
+        value2 = --value) {
+      ClassGen classGen3;
+      if ((classGen3 = this.classStorage.getClassGen(texts[value])) != null) {
+        this.processClassGen(classGen3);
+      }
+    }
+  }
+
+  public void update() {
+    Hashtable hashtable = new Hashtable();
+    int value;
+    for (int value2 = value = 0; value2 < this.values.size(); value2 = ++value) {
+      ClassGen classGen = (ClassGen) this.values.get(value);
+      hashtable.put(classGen, "");
+      Vector values2 = this.getValues(classGen.getClassName());
+      int value3 = 0;
+      for (int value4 = value3; value4 < values2.size(); value4 = ++value3) {
+        ClassGen classGen2 = (ClassGen) values2.get(value3);
+        if (hashtable.containsKey(classGen2)) {
+          Log.error("Incorrect classes order");
+        }
+      }
+    }
+  }
+
+  public boolean matchesText(String text, String text2, String text3) {
+    return this.values2.contains("" + text + "&" + text2 + "&" + text3);
+  }
+
+  public void processClassGen2(ClassGen classGen) {
+    Set values = this.createValues(classGen);
+    Set values3;
+    Set values4 = this.createValues(values3 = this.createValues2(classGen));
+    Iterator iterator2;
+    Iterator iterator3 = iterator2 = this.createValues(values, values4).iterator();
+    while (iterator3.hasNext()) {
+      Set values5 = this.values2;
+      StringBuilder stringBuilder =
+          new StringBuilder().insert(0, classGen.getClassName()).append("&");
+      iterator3 = iterator2;
+      values5.add(stringBuilder.append(iterator2.next()).toString());
+    }
+    this.processValues(values3, values4);
+  }
+
+  public void update2() {
+    Vector vector = new Vector();
+    Iterator iterator;
+    Iterator iterator2 = iterator = this.classStorage.getClassesByName2();
+    while (iterator2.hasNext()) {
+      iterator2 = iterator;
+      vector.add(iterator.next());
+    }
+    Collections.sort(vector, new ClassHierarchyComparator(this));
+    this.values = new Vector();
+    for (ClassGen classGen : ((Iterable<ClassGen>) ((Iterable<?>) vector))) {
+      if (this.getValues(classGen.getClassName()).size() == 0) {
+        this.processClassGen(classGen);
+      }
+    }
+    Collections.sort(this.values, new MethodGen$2(this));
+    this.update();
+  }
+
+  public Set createValues(Set values, Set values2) {
+    TreeSet treeSet = new TreeSet();
+    Set values3 = values.size() < values2.size() ? values : values2;
+    Set values4 = values.size() < values2.size() ? values2 : values;
+    for (Object result : values3) {
+      if (values4.contains(result)) {
+        treeSet.add(result);
+      }
+    }
+    return treeSet;
+  }
+
+  public void processValues(Set values, Set values3) {
+    Iterator iterator2 = values.iterator();
+    label36:
+    while (true) {
+      for (Iterator iterator3 = iterator2; iterator3.hasNext(); iterator3 = iterator2) {
+        String text = (String) iterator2.next();
+        if (!"-=404=-".equals(text)) {
+          ClassGen classGen;
+          if ((classGen = this.classStorage.getClassGen(text)) != null && classGen.isEnabled5()) {
+            Iterator iterator4;
+            iterator3 =
+                iterator4 = this.createValues(this.createValues(classGen), values3).iterator();
+            while (iterator3.hasNext()) {
+              Set values4 = this.values2;
+              StringBuilder stringBuilder =
+                  new StringBuilder().insert(0, classGen.getClassName()).append("&");
+              iterator3 = iterator4;
+              values4.add(stringBuilder.append(iterator4.next()).toString());
+            }
+          }
+          continue label36;
+        }
+      }
+      return;
+    }
+  }
+
+  public Vector getValues() {
+    return this.values;
+  }
+
+  public void processClassGen3(ClassGen classGen) {
+    this.processClassGen(classGen.getSuperclassName(), classGen);
+    int value;
+    String[] texts;
+    for (int value2 = value = (texts = classGen.getInterfaceNames()).length - 1;
+        value2 >= 0;
+        value2 = value) {
+      int value3 = value;
+      String[] texts2 = texts;
+      value--;
+      this.processClassGen(texts2[value3], classGen);
+    }
+  }
+
+  public Set createValues(ClassGen classGen) {
+    TreeSet treeSet = new TreeSet();
+    com.allatori.lib.bcel.classfile.Method[] methods;
+    int value;
+    for (int value2 = value = (methods = classGen.getMethods()).length - 1;
+        value2 >= 0;
+        value2 = --value) {
+      com.allatori.lib.bcel.classfile.Method method = methods[value];
+      if (this.matchesMethod(method)) {
+        treeSet.add(method.getText() + "&" + method.getText2());
+      }
+    }
+    return treeSet;
+  }
+
+  public ClassHierarchy(ClassStorage classStorage2) {
+    super();
+    this.entries2 = new Hashtable();
+    this.values2 = new TreeSet();
+    this.entries = new Hashtable();
+    this.classStorage = classStorage2;
+  }
+
+  public void processText(Set values, String text) {
+    values.add(text);
+    ClassGen classGen = this.classStorage.getClassGen(text);
+    if (classGen != null) {
+      this.processText(values, classGen.getSuperclassName());
+      int value;
+      String[] texts;
+      for (int value2 = value = (texts = classGen.getInterfaceNames()).length - 1;
+          value2 >= 0;
+          value2 = value) {
+        int value3 = value;
+        String[] texts2 = texts;
+        value--;
+        this.processText(values, texts2[value3]);
+      }
+    } else {
+      try {
+        Class classValue;
+        if ((classValue = Class.forName(text, false, this.classStorage.getClassLoader()))
+                .getSuperclass()
+            != null) {
+          this.processText(values, classValue.getSuperclass().getName());
+        }
+        Class[] classs;
+        int value4 = (classs = classValue.getInterfaces()).length - 1;
+        while (value4 >= 0) {
+          int value5 = value4;
+          Class[] classs2 = classs;
+          value4--;
+          this.processText(values, classs2[value5].getName());
+        }
+      } catch (Exception exception) {
+        values.add("-=404=-");
+        if (!this.entries.containsKey(text)) {
+          this.entries.put(text, "");
+          Log.warn("Class '" + text + "' cannot be found.");
+        }
+      }
+    }
+  }
+
+  public boolean matchesMethod(com.allatori.lib.bcel.classfile.Method method) {
+    return !method.isEnabled9() && !method.isEnabled11();
+  }
+
+  public Vector getValues(String text) {
+    Vector vector;
+    return (vector = (Vector) this.entries2.get(text)) != null ? vector : VALUES;
+  }
+
+  public Set createValues2(ClassGen classGen) {
+    TreeSet treeSet = new TreeSet();
+    this.processText(treeSet, classGen.getClassName());
+    return treeSet;
+  }
+
+  public boolean matchesMethod(Method method) {
+    return !Modifier.isPrivate(method.getModifiers()) && !Modifier.isStatic(method.getModifiers());
+  }
+
+  public void update3() {
+    Iterator iterator;
+    Iterator iterator2 = iterator = this.classStorage.getClassesByName2();
+    while (iterator2.hasNext()) {
+      ClassGen classGen = (ClassGen) iterator.next();
+      iterator2 = iterator;
+      this.processClassGen3(classGen);
+      this.processClassGen2(classGen);
+    }
+    if (this.entries.size() > 0) {
+      Log.warn(
+          "Some classes weren't found. It may result in weaker obfuscation. Add needed jars to the"
+              + " 'classpath' element of the configuration file.");
+    }
+    this.update2();
+  }
+
+  public void processClassGen(String text, ClassGen classGen) {
+    if (this.classStorage.getClassGen(text) != null) {
+      Vector vector;
+      if ((vector = (Vector) this.entries2.get(text)) == null) {
+        vector = new Vector();
+      }
+      vector.add(classGen);
+      this.entries2.put(text, vector);
+    }
+  }
+}

src/main/java/com/allatori/bytecode/ClassHierarchyComparator.java

@@ -0,0 +1,21 @@
+package com.allatori.bytecode;
+
+import com.allatori.lib.bcel.generic.ClassGen;
+import java.util.Comparator;
+
+public class ClassHierarchyComparator implements Comparator {
+
+  public final ClassHierarchy classHierarchy;
+
+  @Override
+  public int compare(Object result, Object result2) {
+    String className = ((ClassGen) result).getClassName();
+    String className2 = ((ClassGen) result2).getClassName();
+    return className.compareTo(className2);
+  }
+
+  public ClassHierarchyComparator(ClassHierarchy classHierarchy2) {
+    super();
+    this.classHierarchy = classHierarchy2;
+  }
+}

src/main/java/com/allatori/bytecode/MethodFactory.java

@@ -0,0 +1,15 @@
+package com.allatori.bytecode;
+
+import com.allatori.lib.bcel.classfile.ConstantPool;
+import com.allatori.lib.bcel.classfile.Method;
+import com.allatori.lib.bcel.generic.ConstantPoolGen;
+import com.allatori.lib.bcel.generic.MethodGen;
+
+public class MethodFactory {
+
+  public static MethodGen createMethodGen(
+      Method method, String text, ConstantPoolGen constantPoolGen, ConstantPool constantPool) {
+    method.setConstantPool(constantPool);
+    return new MethodGen(method, text, constantPoolGen);
+  }
+}

src/main/java/com/allatori/bytecode/OrderedClassSet.java

@@ -0,0 +1,16 @@
+package com.allatori.bytecode;
+
+import java.util.TreeSet;
+
+public class OrderedClassSet extends TreeSet {
+
+  @Override
+  public boolean contains(Object result) {
+    return true;
+  }
+
+  @Override
+  public int size() {
+    return Integer.MAX_VALUE;
+  }
+}

src/main/java/com/allatori/cli/ObfuscationCommandSupport.java

@@ -0,0 +1,236 @@
+package com.allatori.cli;
+
+import com.allatori.VersionInfo;
+import com.allatori.config.ClassPathEntry;
+import com.allatori.config.Configuration;
+import com.allatori.config.ConfigurationException;
+import com.allatori.config.InputEntry;
+import com.allatori.config.InputJar;
+import com.allatori.engine.ObfuscationException;
+import com.allatori.io.ClassStorageClassLoader;
+import com.allatori.io.DirectoryClassReader;
+import com.allatori.io.DirectoryWriter;
+import com.allatori.io.JarClassReader;
+import com.allatori.io.JarWriter;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.model.ClassStorage;
+import com.allatori.util.Log;
+import com.allatori.watermark.WatermarkProcessor;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.net.URL;
+import java.util.Iterator;
+import java.util.Vector;
+
+public class ObfuscationCommandSupport {
+
+  public static void limitClassVersion(ClassStorage classStorage) {
+    Iterator classesByName2 = classStorage.getClassesByName2();
+    while (classesByName2.hasNext()) {
+      ClassGen classGen;
+      if ((classGen = (ClassGen) classesByName2.next()).getMajor() > 50) {
+        classGen.setMajor(50);
+      }
+    }
+  }
+
+  public static void writeOutputs(ClassStorage classStorage)
+      throws IOException, FileNotFoundException {
+    JarWriter jarWriter = new JarWriter();
+    Iterator iterator2;
+    Iterator iterator3 = iterator2 = Configuration.getInputOptions().getValues().iterator();
+    while (iterator3.hasNext()) {
+      InputJar inputJar = (InputJar) iterator2.next();
+      iterator3 = iterator2;
+      jarWriter.processClassStorage(inputJar.text2, inputJar.text, classStorage);
+    }
+    Iterator iterator4;
+    iterator3 = iterator4 = Configuration.getInputOptions().getValues3().iterator();
+    while (iterator3.hasNext()) {
+      InputEntry inputEntry = (InputEntry) iterator4.next();
+      iterator3 = iterator4;
+      jarWriter.processClassStorage(inputEntry.text2, inputEntry.text, classStorage);
+    }
+    if (Configuration.getInputOptions().getText() != null) {
+      Vector vector;
+      String[] texts = new String[(vector = Configuration.getInputOptions().getValues3()).size()];
+      int value;
+      for (int value2 = value = 0; value2 < vector.size(); value2 = value) {
+        String text3 = ((InputEntry) vector.get(value)).text;
+        int value3 = value;
+        value++;
+        texts[value3] = text3;
+      }
+      jarWriter.processText(texts, Configuration.getInputOptions().getText());
+    }
+    jarWriter.update();
+  }
+
+  public static void loadConfiguration(String text) throws Exception {
+    try {
+      Configuration.processText(text);
+    } catch (ConfigurationException configurationException) {
+      if (configurationException.getCause() == null) {
+        throw new Exception(("Configuration error. " + configurationException.getMessage()));
+      } else {
+        throw new Exception(
+            ("Error reading configuration. " + configurationException.getCause().getMessage()),
+            configurationException.getCause());
+      }
+    }
+  }
+
+  public static void addWatermark(ClassStorage classStorage) throws ObfuscationException {
+    new WatermarkProcessor(classStorage, Configuration.getWatermarkOptions().getText2())
+        .processText(Configuration.getWatermarkOptions().getText());
+  }
+
+  public static String extractWatermark(ClassStorage classStorage) throws ObfuscationException {
+    return new WatermarkProcessor(classStorage, Configuration.getWatermarkOptions().getText2())
+        .createText();
+  }
+
+  public static void writeAllOutputs(ClassStorage classStorage)
+      throws IOException, FileNotFoundException, ClassNotFoundException {
+    writeOutputs(classStorage);
+    writeDirectoryOutputs(classStorage);
+  }
+
+  public static StringBuffer getStringBuffer(StringBuffer stringBuffer, char value, int value2) {
+    int value3;
+    for (int value4 = value3 = 0; value4 < value2; value4 = value3) {
+      value3++;
+      stringBuffer.append(value);
+    }
+    return stringBuffer;
+  }
+
+  public static boolean loadConfigurationSafely(String text) {
+    return loadConfigurationSafely(text, false);
+  }
+
+  public static String getBanner() {
+    String text = " ## #   #    ## ### ### ##  ###";
+    String text2 = "Java bytecode obfuscator";
+    String text3 = "" + VersionInfo.getProductName() + " " + VersionInfo.getVersion();
+    String website = VersionInfo.getWebsite();
+    int value =
+        Math.max(
+            text.length(), Math.max(text3.length(), Math.max(website.length(), text2.length())));
+    value += 4;
+    StringBuffer stringBuffer;
+    getStringBuffer(stringBuffer = new StringBuffer("\n"), '#', value).append("\n#");
+    getStringBuffer(stringBuffer, ' ', value - 2).append("#\n#");
+    int value2 = (value - text.length() - 2) / 2;
+    int value3 = value - value2 - text.length() - 2;
+    if (value2 > value3) {
+      value3++;
+      value2--;
+    }
+    getStringBuffer(stringBuffer, ' ', value2).append(text);
+    getStringBuffer(stringBuffer, ' ', value3).append("#\n#");
+    getStringBuffer(stringBuffer, ' ', value2).append((String) "# # #   #   # #  #  # # # #  # ");
+    getStringBuffer(stringBuffer, ' ', value3).append("#\n#");
+    getStringBuffer(stringBuffer, ' ', value2).append((String) "### #   #   ###  #  # # ##   # ");
+    getStringBuffer(stringBuffer, ' ', value3).append("#\n#");
+    getStringBuffer(stringBuffer, ' ', value2).append((String) "# # ### ### # #  #  ### # # ###");
+    getStringBuffer(stringBuffer, ' ', value3).append("#\n#");
+    int value4 = (value - text2.length() - 2) / 2;
+    int value5 = value - value4 - text2.length() - 2;
+    if (value4 > value5) {
+      value5++;
+      value4--;
+    }
+    getStringBuffer(stringBuffer, ' ', value - 2).append("#\n#");
+    getStringBuffer(stringBuffer, ' ', value4).append(text2);
+    getStringBuffer(stringBuffer, ' ', value5).append("#\n#");
+    getStringBuffer(stringBuffer, ' ', value - 2).append("#\n#");
+    int value6 = (value - text3.length() - 2) / 2;
+    int value7 = value - value6 - text3.length() - 2;
+    if (value6 > value7) {
+      value7++;
+      value6--;
+    }
+    getStringBuffer(stringBuffer, ' ', value6).append(text3);
+    getStringBuffer(stringBuffer, ' ', value7).append("#\n#");
+    getStringBuffer(stringBuffer, ' ', value - 2).append("#\n#");
+    int value8 = (value - website.length() - 2) / 2;
+    int value9 = value - value8 - website.length() - 2;
+    if (value8 > value9) {
+      value9++;
+      value8--;
+    }
+    getStringBuffer(stringBuffer, ' ', value8).append(website);
+    getStringBuffer(stringBuffer, ' ', value9).append("#\n#");
+    getStringBuffer(stringBuffer, ' ', value - 2).append("#\n");
+    getStringBuffer(stringBuffer, '#', value).append("\n");
+    return stringBuffer.toString();
+  }
+
+  public static boolean loadConfigurationSafely(String text, boolean matches) {
+    try {
+      Configuration.processEnabled(text, matches);
+      return true;
+    } catch (ConfigurationException configurationException) {
+      if (configurationException.getCause() == null) {
+        Log.error("Configuration error. " + configurationException.getMessage());
+      } else {
+        Log.error("Error reading configuration. " + configurationException.getCause().getMessage());
+      }
+      return false;
+    }
+  }
+
+  public static ClassStorage createClassStorage() throws IOException {
+    ClassStorage classStorage = new ClassStorage(createClassLoader());
+    Iterator iterator2;
+    Iterator iterator3 = iterator2 = Configuration.getInputOptions().getValues().iterator();
+    while (iterator3.hasNext()) {
+      InputJar inputJar = (InputJar) iterator2.next();
+      iterator3 = iterator2;
+      JarClassReader.processClassStorage(inputJar.text2, classStorage);
+    }
+    Iterator iterator4;
+    iterator3 = iterator4 = Configuration.getInputOptions().getValues3().iterator();
+    while (iterator3.hasNext()) {
+      InputEntry inputEntry = (InputEntry) iterator4.next();
+      iterator3 = iterator4;
+      JarClassReader.processClassStorage(inputEntry.text2, classStorage);
+    }
+    Iterator iterator5;
+    iterator3 = iterator5 = Configuration.getInputOptions().getValues2().iterator();
+    while (iterator3.hasNext()) {
+      ClassPathEntry classPathEntry = (ClassPathEntry) iterator5.next();
+      iterator3 = iterator5;
+      DirectoryClassReader.processText(classPathEntry.text, classStorage, classPathEntry.text);
+    }
+    return classStorage;
+  }
+
+  public static ClassStorageClassLoader createClassLoader() {
+    Vector values = Configuration.getClassPathOptions().getValues();
+    int value;
+    for (int value2 = value = 0; value2 < values.size(); value2 = ++value) {
+      try {
+        values.set(value, new File((String) values.get(value)).toURL());
+      } catch (Exception exception) {
+        exception.printStackTrace();
+      }
+    }
+    URL[] uRLs = (URL[]) values.toArray(new URL[0]);
+    return new ClassStorageClassLoader(uRLs);
+  }
+
+  public static void writeDirectoryOutputs(ClassStorage classStorage)
+      throws FileNotFoundException, IOException, ClassNotFoundException {
+    DirectoryWriter directoryWriter = new DirectoryWriter();
+    Iterator iterator2;
+    Iterator iterator3 = iterator2 = Configuration.getInputOptions().getValues2().iterator();
+    while (iterator3.hasNext()) {
+      ClassPathEntry classPathEntry = (ClassPathEntry) iterator2.next();
+      iterator3 = iterator2;
+      directoryWriter.processClassStorage(classPathEntry.text, classPathEntry.text2, classStorage);
+    }
+  }
+}

src/main/java/com/allatori/config/ClassPathEntry.java

@@ -0,0 +1,14 @@
+package com.allatori.config;
+
+public class ClassPathEntry {
+
+  public String text;
+
+  public String text2;
+
+  public ClassPathEntry(String text, String text2) {
+    super();
+    this.text = text;
+    this.text2 = text2;
+  }
+}

src/main/java/com/allatori/config/ClassPathOptions.java

@@ -0,0 +1,24 @@
+package com.allatori.config;
+
+import java.util.Vector;
+
+public class ClassPathOptions {
+
+  public final Configuration configuration;
+
+  public Vector values;
+
+  public void processText(String text) {
+    this.values.add(text);
+  }
+
+  public Vector getValues() {
+    return this.values;
+  }
+
+  public ClassPathOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.values = new Vector();
+  }
+}

src/main/java/com/allatori/config/Configuration.java

@@ -0,0 +1,153 @@
+package com.allatori.config;
+
+import com.allatori.util.random.RandomUtils;
+
+public class Configuration {
+
+  public ObfuscationOptions obfuscationOptions;
+
+  public OutputOptions outputOptions = new OutputOptions(this);
+
+  public LogOptions logOptions;
+
+  public MethodRemovalOptions methodRemovalOptions;
+
+  public MemberOrderOptions memberOrderOptions;
+
+  public WatermarkOptions watermarkOptions;
+
+  public static Configuration configuration = null;
+
+  public RenamingOptions renamingOptions;
+
+  public DebugInfoOptions debugInfoOptions;
+
+  public SyntheticOptions syntheticOptions;
+
+  public IgnoreClassesOptions ignoreClassesOptions;
+
+  public OptimizationOptions optimizationOptions;
+
+  public FieldRemovalOptions fieldRemovalOptions;
+
+  public MethodCallRemovalOptions methodCallRemovalOptions;
+
+  public ClassPathOptions classPathOptions;
+
+  public PackageRenamingOptions packageRenamingOptions;
+
+  public InputOptions inputOptions = new InputOptions(this);
+
+  public MappingOptions mappingOptions;
+
+  public ExtensiveFlowOptions extensiveFlowOptions;
+
+  public static MemberOrderOptions getMemberOrderOptions() {
+    return configuration.memberOrderOptions;
+  }
+
+  public static void processText(String text) throws ConfigurationException {
+    processEnabled(text, false);
+  }
+
+  public static InputOptions getInputOptions() {
+    return configuration.inputOptions;
+  }
+
+  public static IgnoreClassesOptions getIgnoreClassesOptions() {
+    return configuration.ignoreClassesOptions;
+  }
+
+  public static RenamingOptions getRenamingOptions() {
+    return configuration.renamingOptions;
+  }
+
+  public static MethodCallRemovalOptions getMethodCallRemovalOptions() {
+    return configuration.methodCallRemovalOptions;
+  }
+
+  public static ExtensiveFlowOptions getExtensiveFlowOptions() {
+    return configuration.extensiveFlowOptions;
+  }
+
+  public static void processEnabled(String text, boolean matches) throws ConfigurationException {
+    configuration = new Configuration();
+    configuration.watermarkOptions.setEnabled(matches);
+    new XmlParsingContext(text).parse();
+    RandomUtils.update();
+    if (getObfuscationOptions().getCharacter() == '\uffff') {
+      getObfuscationOptions().setCharacter((char) (RandomUtils.calculateCount(125) + 1));
+    }
+  }
+
+  public static MethodRemovalOptions getMethodRemovalOptions() {
+    return configuration.methodRemovalOptions;
+  }
+
+  public static SyntheticOptions getSyntheticOptions() {
+    return configuration.syntheticOptions;
+  }
+
+  public static ClassPathOptions getClassPathOptions() {
+    return configuration.classPathOptions;
+  }
+
+  public static FieldRemovalOptions getFieldRemovalOptions() {
+    return configuration.fieldRemovalOptions;
+  }
+
+  public Configuration() {
+    this.classPathOptions = new ClassPathOptions(this);
+    this.renamingOptions = new RenamingOptions(this);
+    this.watermarkOptions = new WatermarkOptions(this);
+    this.obfuscationOptions = new ObfuscationOptions(this);
+    this.debugInfoOptions = new DebugInfoOptions(this);
+    this.extensiveFlowOptions = new ExtensiveFlowOptions(this);
+    this.syntheticOptions = new SyntheticOptions(this);
+    this.memberOrderOptions = new MemberOrderOptions(this);
+    this.methodCallRemovalOptions = new MethodCallRemovalOptions(this);
+    this.optimizationOptions = new OptimizationOptions(this);
+    this.fieldRemovalOptions = new FieldRemovalOptions(this);
+    this.packageRenamingOptions = new PackageRenamingOptions(this);
+    this.ignoreClassesOptions = new IgnoreClassesOptions(this);
+    this.logOptions = new LogOptions(this);
+    this.methodRemovalOptions = new MethodRemovalOptions(this);
+    this.mappingOptions = new MappingOptions(this);
+  }
+
+  public static OptimizationOptions getOptimizationOptions() {
+    return configuration.optimizationOptions;
+  }
+
+  public static void update() {
+    configuration = null;
+  }
+
+  public static WatermarkOptions getWatermarkOptions() {
+    return configuration.watermarkOptions;
+  }
+
+  public static LogOptions getLogOptions() {
+    return configuration.logOptions;
+  }
+
+  public static DebugInfoOptions getDebugInfoOptions() {
+    return configuration.debugInfoOptions;
+  }
+
+  public static MappingOptions getMappingOptions() {
+    return configuration.mappingOptions;
+  }
+
+  public static PackageRenamingOptions getPackageRenamingOptions() {
+    return configuration.packageRenamingOptions;
+  }
+
+  public static ObfuscationOptions getObfuscationOptions() {
+    return configuration.obfuscationOptions;
+  }
+
+  public static OutputOptions getOutputOptions() {
+    return configuration.outputOptions;
+  }
+}

src/main/java/com/allatori/config/ConfigurationConstructorToken.java

@@ -0,0 +1,3 @@
+package com.allatori.config;
+
+public class ConfigurationConstructorToken {}

src/main/java/com/allatori/config/ConfigurationException.java

@@ -0,0 +1,12 @@
+package com.allatori.config;
+
+public class ConfigurationException extends Exception {
+
+  public ConfigurationException(Throwable throwable) {
+    super(throwable);
+  }
+
+  public ConfigurationException(String text) {
+    super(text);
+  }
+}

src/main/java/com/allatori/config/ConfigurationLocator.java

@@ -0,0 +1,33 @@
+package com.allatori.config;
+
+import org.xml.sax.Locator;
+
+public class ConfigurationLocator implements Locator {
+
+  public final ConfigurationHandler configurationHandler;
+
+  @Override
+  public int getLineNumber() {
+    return -1;
+  }
+
+  @Override
+  public String getPublicId() {
+    return null;
+  }
+
+  @Override
+  public int getColumnNumber() {
+    return -1;
+  }
+
+  public ConfigurationLocator(ConfigurationHandler configurationHandler2) {
+    super();
+    this.configurationHandler = configurationHandler2;
+  }
+
+  @Override
+  public String getSystemId() {
+    return null;
+  }
+}

src/main/java/com/allatori/config/ConfigurationSaxException.java

@@ -0,0 +1,13 @@
+package com.allatori.config;
+
+import org.xml.sax.SAXException;
+
+public class ConfigurationSaxException extends SAXException {
+
+  public final XmlParsingContext xmlParsingContext;
+
+  public ConfigurationSaxException(XmlParsingContext xmlParsingContext2, String text) {
+    super(text);
+    this.xmlParsingContext = xmlParsingContext2;
+  }
+}

src/main/java/com/allatori/config/ConfigurationSource.java

@@ -0,0 +1,6 @@
+package com.allatori.config;
+
+public interface ConfigurationSource {
+
+  void parse() throws ConfigurationException;
+}

src/main/java/com/allatori/config/DebugInfoOptions.java

@@ -0,0 +1,63 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.RuleEntry;
+import com.allatori.config.rule.RuleSet;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.lib.bcel.generic.MethodGen;
+import com.allatori.model.ClassStorage;
+
+public class DebugInfoOptions {
+
+  public String text;
+
+  public boolean enabled;
+
+  public final Configuration configuration;
+
+  public String text2;
+
+  public RuleSet ruleSet;
+
+  public void setEnabled(boolean enabled) {
+    this.enabled = enabled;
+  }
+
+  public void setText(String text) {
+    this.text = text;
+  }
+
+  public boolean isEnabled() {
+    return this.enabled;
+  }
+
+  public String getText() {
+    return this.text;
+  }
+
+  public String getText2() {
+    return this.text2;
+  }
+
+  public DebugInfoOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.ruleSet = new RuleSet(0);
+  }
+
+  public boolean matchesMethodGen(
+      ClassStorage classStorage, ClassGen classGen, MethodGen methodGen) {
+    return this.ruleSet.calculateCount(classStorage, classGen, methodGen) == 1;
+  }
+
+  public boolean matchesClassGen(ClassStorage classStorage, ClassGen classGen) {
+    return this.ruleSet.calculateCount(classStorage, classGen) == 1;
+  }
+
+  public void setText2(String text2) {
+    this.text2 = text2;
+  }
+
+  public void processRuleEntry(RuleEntry ruleEntry) {
+    this.ruleSet.processRuleEntry(ruleEntry);
+  }
+}

src/main/java/com/allatori/config/ExtensiveFlowOptions.java

@@ -0,0 +1,87 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.RuleEntry;
+import com.allatori.config.rule.RuleSet;
+import com.allatori.lib.bcel.generic.AnnotationEntryGen;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.lib.bcel.generic.ElementValuePairGen;
+import com.allatori.lib.bcel.generic.MethodGen;
+import com.allatori.model.ClassStorage;
+import java.util.List;
+
+public class ExtensiveFlowOptions {
+
+  public static final int COUNT = 0;
+
+  public static final int COUNT2 = 2;
+
+  public static final int COUNT3 = 1;
+
+  public final Configuration configuration;
+
+  public RuleSet ruleSet;
+
+  public ExtensiveFlowOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.ruleSet = new RuleSet(1);
+  }
+
+  public int calculateCount(ClassStorage classStorage, ClassGen classGen, MethodGen methodGen) {
+    if (!Configuration.getObfuscationOptions().isEnabled()
+        && methodGen.getName().startsWith("Allatori")) {
+      return 1;
+    }
+    byte value = 1;
+    AnnotationEntryGen[] annotationEntryGens = methodGen.getAnnotationEntryGens();
+    while (true) {
+      AnnotationEntryGen[] annotationEntryGens2 = annotationEntryGens;
+      int value2 = annotationEntryGens2.length;
+      int value3;
+      for (int value4 = value3 = 0; value4 < value2; value4 = ++value3) {
+        AnnotationEntryGen annotationEntryGen = annotationEntryGens2[value3];
+        if ("Lcom/allatori/annotations/DisableExtensiveFlowObfuscation;"
+            .equals(annotationEntryGen.getText2())) {
+          return 0;
+        }
+        if ("Lcom/allatori/annotations/NormalExtensiveFlowObfuscation;"
+            .equals(annotationEntryGen.getText2())) {
+          return 1;
+        }
+        if ("Lcom/allatori/annotations/MaximumExtensiveFlowObfuscation;"
+            .equals(annotationEntryGen.getText2())) {
+          return 2;
+        }
+        List values;
+        if ("Lcom/allatori/annotations/ExtensiveFlowObfuscation;"
+                .equals(annotationEntryGen.getText2())
+            && (values = annotationEntryGen.getValues()) != null
+            && values.size() > 0
+            && ((ElementValuePairGen) values.get(0)).getValue() != null) {
+          if ("maximum".equals(((ElementValuePairGen) values.get(0)).getValue().stringifyValue())) {
+            return 2;
+          }
+          if ("normal".equals(((ElementValuePairGen) values.get(0)).getValue().stringifyValue())) {
+            return 1;
+          }
+          if ("disable".equals(((ElementValuePairGen) values.get(0)).getValue().stringifyValue())) {
+            return 0;
+          }
+        }
+      }
+      if (value == 0) {
+        if (Configuration.getObfuscationOptions().isEnabled3()
+            && Configuration.getObfuscationOptions().isMethodsNamingEnabled()) {
+          return 0;
+        }
+        return this.ruleSet.calculateCount(classStorage, classGen, methodGen);
+      }
+      value = 0;
+      annotationEntryGens = classGen.getAnnotationEntries();
+    }
+  }
+
+  public void processRuleEntry(RuleEntry ruleEntry) {
+    this.ruleSet.processRuleEntry(ruleEntry);
+  }
+}

src/main/java/com/allatori/config/FieldRemovalOptions.java

@@ -0,0 +1,50 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.RuleEntry;
+import com.allatori.config.rule.RuleSet;
+import com.allatori.lib.bcel.classfile.Field;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.model.ClassStorage;
+import java.util.Vector;
+
+public class FieldRemovalOptions {
+
+  public Vector values;
+
+  public final Configuration configuration;
+
+  public RuleSet ruleSet;
+
+  public boolean isValues() {
+    return this.values.size() > 0;
+  }
+
+  public FieldRemovalOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.ruleSet = new RuleSet(0);
+    this.values = new Vector();
+  }
+
+  public void processText(String text) {
+    this.values.add(text);
+  }
+
+  public boolean matchesText(String text) {
+    return this.values.contains(text);
+  }
+
+  public boolean matchesField(ClassStorage classStorage, ClassGen classGen, Field field) {
+    if (classStorage == null) {
+      return false;
+    } else {
+      return this.ruleSet.getValues() == 0
+          ? false
+          : this.ruleSet.calculateCount(classStorage, classGen, field) > 0;
+    }
+  }
+
+  public void processRuleEntry(RuleEntry ruleEntry) {
+    this.ruleSet.processRuleEntry(ruleEntry);
+  }
+}

src/main/java/com/allatori/config/IgnoreClassesOptions.java

@@ -0,0 +1,45 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.ClassRule;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.model.ClassStorage;
+import java.util.Iterator;
+import java.util.Vector;
+
+public class IgnoreClassesOptions {
+
+  public final Configuration configuration;
+
+  public boolean enabled;
+
+  public Vector values;
+
+  public boolean matchesClassGen(ClassStorage classStorage, ClassGen classGen) {
+    if (!this.enabled) {
+      return false;
+    }
+    Iterator iterator2 = this.values.iterator();
+    while (iterator2.hasNext()) {
+      ClassRule classRule;
+      if ((classRule = (ClassRule) iterator2.next()).matches(classStorage, classGen)) {
+        if (!classRule.matches()) {
+          return true;
+        }
+        return false;
+      }
+    }
+    return false;
+  }
+
+  public void processClassRule(ClassRule classRule) {
+    this.values.add(classRule);
+    this.enabled = true;
+  }
+
+  public IgnoreClassesOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.values = new Vector();
+    this.enabled = false;
+  }
+}

src/main/java/com/allatori/config/InputEntry.java

@@ -0,0 +1,14 @@
+package com.allatori.config;
+
+public class InputEntry {
+
+  public String text;
+
+  public String text2;
+
+  public InputEntry(String text2, String text) {
+    super();
+    this.text2 = text2;
+    this.text = text;
+  }
+}

src/main/java/com/allatori/config/InputJar.java

@@ -0,0 +1,14 @@
+package com.allatori.config;
+
+public class InputJar extends InputEntry {
+
+  public String text;
+
+  public String text2;
+
+  public InputJar(String text3, String text4, String text, String text2) {
+    super(text3, text4);
+    this.text = text;
+    this.text2 = text2;
+  }
+}

src/main/java/com/allatori/config/InputOptions.java

@@ -0,0 +1,57 @@
+package com.allatori.config;
+
+import java.util.Vector;
+
+public class InputOptions {
+
+  public final Configuration configuration;
+
+  public Vector values;
+
+  public Vector values2;
+
+  public Vector values3;
+
+  public String text;
+
+  public void setText(String text) {
+    this.text = text;
+  }
+
+  public void processInputJar(InputJar inputJar) {
+    this.values.add(inputJar);
+  }
+
+  public String getText() {
+    return this.text;
+  }
+
+  public Vector getValues() {
+    return this.values;
+  }
+
+  public Vector getValues3() {
+    return this.values3;
+  }
+
+  public InputOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.values3 = new Vector();
+    this.values = new Vector();
+    this.values2 = new Vector();
+    this.text = null;
+  }
+
+  public void processInputEntry(InputEntry inputEntry) {
+    this.values3.add(inputEntry);
+  }
+
+  public void processClassPathEntry(ClassPathEntry classPathEntry) {
+    this.values2.add(classPathEntry);
+  }
+
+  public Vector getValues2() {
+    return this.values2;
+  }
+}

src/main/java/com/allatori/config/KeepNamesOptions.java

@@ -0,0 +1,200 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.ClassRule;
+import com.allatori.config.rule.FieldRule;
+import com.allatori.config.rule.MethodRule;
+import com.allatori.lib.bcel.classfile.AnnotationEntry;
+import com.allatori.lib.bcel.classfile.Field;
+import com.allatori.lib.bcel.classfile.Method;
+import com.allatori.lib.bcel.generic.AnnotationEntryGen;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.model.ClassStorage;
+import java.util.Vector;
+
+public class KeepNamesOptions {
+
+  public final RenamingOptions renamingOptions;
+
+  public Vector values;
+
+  public ClassRule classRule;
+
+  public boolean matchesMethod(ClassStorage classStorage, ClassGen classGen, Method method) {
+    if (this.matchesMethod2(classStorage, classGen, method)) {
+      return true;
+    }
+    if (RenamingOptions.matchesRenamingOptions(this.renamingOptions)) {
+      return false;
+    }
+    AnnotationEntry[] annotationEntries = method.getAnnotationEntries();
+    int value;
+    for (int value2 = value = 0; value2 < annotationEntries.length; value2 = ++value) {
+      AnnotationEntry annotationEntry = annotationEntries[value];
+      if ("Lcom/allatori/annotations/Rename;".equals(annotationEntry.getText())) {
+        return true;
+      }
+      if ("Lcom/allatori/annotations/DoNotRename;".equals(annotationEntry.getText())) {
+        return false;
+      }
+      if ("Lcom/allatori/annotations/KeepName;".equals(annotationEntry.getText())) {
+        return false;
+      }
+    }
+    int value3;
+    for (int value4 = value3 = 0; value4 < this.values.size(); value4 = ++value3) {
+      ClassRule classRule2;
+      if ((classRule2 = (ClassRule) this.values.get(value3)).matches5()
+          && classRule2.matches(classStorage, classGen)
+          && classRule2.matches(method)) {
+        return false;
+      }
+      if (classRule2.matches() && classRule2.matches(classStorage, classGen)) {
+        return true;
+      }
+    }
+    return !this.classRule.matches5() || !this.classRule.matches(method);
+  }
+
+  public boolean matchesMethod2(ClassStorage classStorage, ClassGen classGen, Method method) {
+    return method.getText().startsWith("Allatori") || this.matchesClassGen2(classStorage, classGen);
+  }
+
+  public void processFieldRule(FieldRule fieldRule) {
+    this.classRule.processFieldRule(fieldRule);
+  }
+
+  public KeepNamesOptions(
+      RenamingOptions renamingOptions,
+      NamingOptionsConstructorToken namingOptionsConstructorToken) {
+    this(renamingOptions);
+  }
+
+  public boolean matchesField(ClassStorage classStorage, ClassGen classGen, Field field) {
+    if (this.matchesField2(classStorage, classGen, field)) {
+      return true;
+    }
+    if (RenamingOptions.matchesRenamingOptions(this.renamingOptions)) {
+      return false;
+    }
+    AnnotationEntry[] annotationEntries = field.getAnnotationEntries();
+    int value;
+    for (int value2 = value = 0; value2 < annotationEntries.length; value2 = ++value) {
+      AnnotationEntry annotationEntry = annotationEntries[value];
+      if ("Lcom/allatori/annotations/Rename;".equals(annotationEntry.getText())) {
+        return true;
+      }
+      if ("Lcom/allatori/annotations/DoNotRename;".equals(annotationEntry.getText())) {
+        return false;
+      }
+      if ("Lcom/allatori/annotations/KeepName;".equals(annotationEntry.getText())) {
+        return false;
+      }
+    }
+    int value3;
+    for (int value4 = value3 = 0; value4 < this.values.size(); value4 = ++value3) {
+      ClassRule classRule2;
+      if ((classRule2 = (ClassRule) this.values.get(value3)).matches4()
+          && classRule2.matches(classStorage, classGen)
+          && classRule2.matches(classStorage, field)) {
+        return false;
+      }
+      if (classRule2.matches() && classRule2.matches(classStorage, classGen)) {
+        return true;
+      }
+    }
+    return !this.classRule.matches4() || !this.classRule.matches(classStorage, field);
+  }
+
+  public boolean matchesField2(ClassStorage classStorage, ClassGen classGen, Field field) {
+    return this.matchesClassGen2(classStorage, classGen);
+  }
+
+  public boolean matchesClassGen(ClassStorage classStorage, ClassGen classGen) {
+    if (this.matchesClassGen2(classStorage, classGen)) {
+      return true;
+    }
+    if (RenamingOptions.matchesRenamingOptions(this.renamingOptions)) {
+      return false;
+    }
+    AnnotationEntryGen[] annotationEntries = classGen.getAnnotationEntries();
+    int value;
+    for (int value2 = value = 0; value2 < annotationEntries.length; value2 = ++value) {
+      AnnotationEntryGen annotationEntryGen = annotationEntries[value];
+      if ("Lcom/allatori/annotations/Rename;".equals(annotationEntryGen.getText2())) {
+        return true;
+      }
+      if ("Lcom/allatori/annotations/DoNotRename;".equals(annotationEntryGen.getText2())) {
+        return false;
+      }
+      if ("Lcom/allatori/annotations/KeepName;".equals(annotationEntryGen.getText2())) {
+        return false;
+      }
+    }
+    int value3;
+    for (int value4 = value3 = 0; value4 < this.values.size(); value4 = ++value3) {
+      ClassRule classRule;
+      if ((!(classRule = (ClassRule) this.values.get(value3)).matches2() || classRule.matches())
+          && classRule.matches(classStorage, classGen)) {
+        if (classRule.matches()) {
+          return true;
+        }
+        if (!classRule.matches3()) {
+          return false;
+        }
+        int value5;
+        Field[] fields;
+        for (int value6 = value5 = (fields = classGen.getFields()).length - 1;
+            value6 >= 0;
+            value6 = --value5) {
+          Field field = fields[value5];
+          if (!Configuration.getRenamingOptions()
+              .getKeepNamesOptions()
+              .matchesField(classStorage, classGen, field)) {
+            return false;
+          }
+        }
+        int value7;
+        Method[] methods;
+        for (int value8 = value7 = (methods = classGen.getMethods()).length - 1;
+            value8 >= 0;
+            value8 = --value7) {
+          Method method = methods[value7];
+          if (!Configuration.getRenamingOptions()
+              .getKeepNamesOptions()
+              .matchesMethod(classStorage, classGen, method)) {
+            return false;
+          }
+        }
+      }
+    }
+    return true;
+  }
+
+  public void processClassRule(ClassRule classRule) {
+    this.values.add(classRule);
+  }
+
+  public KeepNamesOptions(RenamingOptions renamingOptions2) {
+    super();
+    this.renamingOptions = renamingOptions2;
+    this.values = new Vector();
+    try {
+      this.classRule = new ClassRule("class *", true, false);
+      ClassRule classRule2 = new ClassRule("class * extends java.lang.Enum", true, false);
+      classRule2.processMethodRule(new MethodRule("values(**)", false, false));
+      classRule2.processMethodRule(new MethodRule("valueOf(**)", false, false));
+      this.processClassRule(classRule2);
+      this.processClassRule(new ClassRule("interface *.package-info", false, false));
+    } catch (ConfigurationException configurationException) {
+      configurationException.printStackTrace();
+    }
+  }
+
+  public void processMethodRule(MethodRule methodRule) {
+    this.classRule.processMethodRule(methodRule);
+  }
+
+  public boolean matchesClassGen2(ClassStorage classStorage, ClassGen classGen) {
+    return classStorage.getInputClasses().contains(classGen);
+  }
+}

src/main/java/com/allatori/config/LineNumberOptions.java

@@ -0,0 +1,28 @@
+package com.allatori.config;
+
+public class LineNumberOptions {
+
+  public static final int COUNT = 3;
+
+  public final RenamingOptions renamingOptions;
+
+  public int lineNumbersMode;
+
+  public static final int COUNT2 = 2;
+
+  public static final int COUNT3 = 1;
+
+  public void setLineNumbersMode(int lineNumbersMode) {
+    this.lineNumbersMode = lineNumbersMode;
+  }
+
+  public int getLineNumbersMode() {
+    return this.lineNumbersMode;
+  }
+
+  public LineNumberOptions(RenamingOptions renamingOptions2) {
+    super();
+    this.renamingOptions = renamingOptions2;
+    this.lineNumbersMode = 1;
+  }
+}

src/main/java/com/allatori/config/LocalVariableOptions.java

@@ -0,0 +1,76 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.RuleEntry;
+import com.allatori.config.rule.RuleSet;
+import com.allatori.lib.bcel.classfile.Method;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.lib.bcel.generic.MethodGen;
+import com.allatori.model.ClassStorage;
+
+public class LocalVariableOptions {
+
+  public RuleSet ruleSet;
+
+  public static final int COUNT = 4;
+
+  public static final int COUNT2 = 5;
+
+  public final RenamingOptions renamingOptions;
+
+  public static final int COUNT3 = 3;
+
+  public static final int COUNT4 = 1;
+
+  public static final int COUNT5 = 6;
+
+  public String localVariablesNaming;
+
+  public static final int COUNT6 = 2;
+
+  public int localVariablesNamingMode;
+
+  public void setLocalVariablesNaming(String localVariablesNaming) {
+    this.localVariablesNaming = localVariablesNaming;
+  }
+
+  public void processRuleEntry(RuleEntry ruleEntry) {
+    this.ruleSet.processRuleEntry(ruleEntry);
+  }
+
+  public int calculateCount(ClassStorage classStorage, ClassGen classGen, MethodGen methodGen) {
+    return Configuration.getObfuscationOptions().isEnabled3()
+            && Configuration.getObfuscationOptions().isMethodsNamingEnabled()
+        ? 4
+        : this.ruleSet.calculateCount(classStorage, classGen, methodGen);
+  }
+
+  public void setLocalVariablesNamingMode(int localVariablesNamingMode) {
+    this.localVariablesNamingMode = localVariablesNamingMode;
+  }
+
+  public int calculateCount(ClassStorage classStorage, ClassGen classGen, Method method) {
+    return Configuration.getObfuscationOptions().isEnabled3()
+            && Configuration.getObfuscationOptions().isMethodsNamingEnabled()
+        ? 4
+        : this.ruleSet.calculateCount(classStorage, classGen, method);
+  }
+
+  public LocalVariableOptions(RenamingOptions renamingOptions2) {
+    super();
+    this.renamingOptions = renamingOptions2;
+    this.localVariablesNamingMode = 6;
+    this.ruleSet = new RuleSet(6);
+    this.localVariablesNaming = "a";
+  }
+
+  public String getLocalVariablesNaming() {
+    return this.localVariablesNaming;
+  }
+
+  public int calculateCount() {
+    return Configuration.getObfuscationOptions().isEnabled3()
+            && Configuration.getObfuscationOptions().isMethodsNamingEnabled()
+        ? 4
+        : this.localVariablesNamingMode;
+  }
+}

src/main/java/com/allatori/config/LogOptions.java

@@ -0,0 +1,26 @@
+package com.allatori.config;
+
+public class LogOptions {
+
+  public String comLicense4jSupport;
+
+  public final Configuration configuration;
+
+  public void setComLicense4jSupport(String comLicense4jSupport) {
+    this.comLicense4jSupport = comLicense4jSupport;
+  }
+
+  public boolean isText() {
+    return this.comLicense4jSupport != null;
+  }
+
+  public LogOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.comLicense4jSupport = null;
+  }
+
+  public String getComLicense4jSupport() {
+    return this.comLicense4jSupport;
+  }
+}

src/main/java/com/allatori/config/MappingOptions.java

@@ -0,0 +1,20 @@
+package com.allatori.config;
+
+import com.allatori.naming.RenamingLog;
+import com.allatori.util.LookupTable;
+
+public class MappingOptions {
+
+  public LookupTable lookupTable;
+
+  public RenamingLog renamingLog;
+
+  public final Configuration configuration;
+
+  public LookupTable lookupTable2;
+
+  public MappingOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+  }
+}

src/main/java/com/allatori/config/MemberOrderOptions.java

@@ -0,0 +1,44 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.RuleEntry;
+import com.allatori.config.rule.RuleSet;
+import com.allatori.lib.bcel.classfile.Field;
+import com.allatori.lib.bcel.classfile.Method;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.model.ClassStorage;
+
+public class MemberOrderOptions {
+
+  public final Configuration configuration;
+
+  public RuleSet ruleSet;
+
+  public RuleSet ruleSet2;
+
+  public void processRuleEntry(RuleEntry ruleEntry) {
+    this.ruleSet2.processRuleEntry(ruleEntry);
+  }
+
+  public boolean matchesMethod(ClassStorage classStorage, ClassGen classGen, Method method) {
+    return classStorage == null || this.ruleSet.getValues() == 0
+        ? false
+        : this.ruleSet.calculateCount(classStorage, classGen, method) > 0;
+  }
+
+  public boolean matchesField(ClassStorage classStorage, ClassGen classGen, Field field) {
+    return classStorage == null || this.ruleSet2.getValues() == 0
+        ? false
+        : this.ruleSet2.calculateCount(classStorage, classGen, field) > 0;
+  }
+
+  public void processRuleEntry2(RuleEntry ruleEntry) {
+    this.ruleSet.processRuleEntry(ruleEntry);
+  }
+
+  public MemberOrderOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.ruleSet2 = new RuleSet(0);
+    this.ruleSet = new RuleSet(0);
+  }
+}

src/main/java/com/allatori/config/MethodCallRemovalOptions.java

@@ -0,0 +1,73 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.RuleEntry;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.lib.bcel.generic.MethodGen;
+import com.allatori.model.ClassStorage;
+import com.allatori.transform.DistributedStringEncryptionTransformer;
+import java.util.Iterator;
+import java.util.Vector;
+
+public class MethodCallRemovalOptions {
+
+  public Vector values;
+
+  public boolean enabled;
+
+  public final Configuration configuration;
+
+  public boolean isEnabled() {
+    return this.enabled;
+  }
+
+  public MethodCallRemovalOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.enabled = false;
+    this.values = new Vector();
+  }
+
+  public boolean matchesText(
+      ClassStorage classStorage,
+      ClassGen classGen,
+      MethodGen methodGen,
+      String text3,
+      String text5,
+      String text6) {
+    if (classStorage != null && text3 != null && text5 != null) {
+      if (text5.startsWith(DistributedStringEncryptionTransformer.text4)) {
+        return false;
+      }
+      if ("<init>".equals(text5)) {
+        return false;
+      }
+      if ("<clinit>".equals(text5)) {
+        return false;
+      }
+      if (this.values.size() == 0) {
+        return false;
+      }
+      Iterator iterator2 = this.values.iterator();
+      while (iterator2.hasNext()) {
+        MethodCallRemovalRule methodCallRemovalRule;
+        if ((methodCallRemovalRule = (MethodCallRemovalRule) iterator2.next())
+                .ruleEntry.classRule.matches(classStorage, classGen)
+            && methodCallRemovalRule.ruleEntry.classRule.matches(methodGen)
+            && text3.matches(methodCallRemovalRule.text)
+            && text5.matches(methodCallRemovalRule.text2)) {
+          return true;
+        }
+      }
+      return Configuration.getOptimizationOptions().matchesText("" + text3 + "." + text5 + text6);
+    } else {
+      return false;
+    }
+  }
+
+  public void processText(RuleEntry ruleEntry, String text, String text2) {
+    this.enabled = true;
+    String text3 = text.replaceAll("\\.", "\\\\.").replaceAll("\\*", ".*");
+    String text4 = text2.replaceAll("\\.", "\\\\.").replaceAll("\\*", ".*");
+    this.values.add(new MethodCallRemovalRule(this, ruleEntry, text3, text4));
+  }
+}

src/main/java/com/allatori/config/MethodCallRemovalRule.java

@@ -0,0 +1,26 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.RuleEntry;
+
+public class MethodCallRemovalRule {
+
+  public String text;
+
+  public RuleEntry ruleEntry;
+
+  public final MethodCallRemovalOptions methodCallRemovalOptions;
+
+  public String text2;
+
+  public MethodCallRemovalRule(
+      MethodCallRemovalOptions methodCallRemovalOptions2,
+      RuleEntry ruleEntry2,
+      String text,
+      String text2) {
+    super();
+    this.methodCallRemovalOptions = methodCallRemovalOptions2;
+    this.ruleEntry = ruleEntry2;
+    this.text = text;
+    this.text2 = text2;
+  }
+}

src/main/java/com/allatori/config/MethodRemovalOptions.java

@@ -0,0 +1,45 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.RuleEntry;
+import com.allatori.config.rule.RuleSet;
+import com.allatori.lib.bcel.classfile.Method;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.model.ClassStorage;
+
+public class MethodRemovalOptions {
+
+  public String testString;
+
+  public RuleSet ruleSet;
+
+  public final Configuration configuration;
+
+  public void setTestString(String testString) {
+    this.testString = testString;
+  }
+
+  public void processRuleEntry(RuleEntry ruleEntry) {
+    this.ruleSet.processRuleEntry(ruleEntry);
+  }
+
+  public MethodRemovalOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.ruleSet = new RuleSet(0);
+    this.testString = null;
+  }
+
+  public String getTestString() {
+    return this.testString;
+  }
+
+  public boolean matchesMethod(ClassStorage classStorage, ClassGen classGen, Method method) {
+    if (classStorage == null) {
+      return false;
+    } else {
+      return this.ruleSet.getValues() == 0
+          ? false
+          : this.ruleSet.calculateCount(classStorage, classGen, method) > 0;
+    }
+  }
+}

src/main/java/com/allatori/config/NameGenerationOptions.java

@@ -0,0 +1,346 @@
+package com.allatori.config;
+
+import com.allatori.naming.generator.AsciiNameGenerator;
+import com.allatori.naming.generator.JavaKeywordNameGenerator;
+import com.allatori.naming.generator.LengthBoundNameGenerator;
+import com.allatori.naming.generator.LowercaseConfusableNameGenerator;
+import com.allatori.naming.generator.LowercaseNameGenerator;
+import com.allatori.naming.generator.MainNameGenerator;
+import com.allatori.naming.generator.MethodNameGenerator;
+import com.allatori.naming.generator.MixedConfusableNameGenerator;
+import com.allatori.naming.generator.NameGenerator;
+import com.allatori.naming.generator.NumericNameGenerator;
+import com.allatori.naming.generator.PackageNameGenerator;
+import com.allatori.naming.generator.PrefixedNameGenerator;
+import com.allatori.naming.generator.RandomizedNameGenerator;
+import com.allatori.naming.generator.TypeNameGenerator;
+import com.allatori.naming.generator.UppercaseNameGenerator;
+import com.allatori.naming.generator.WindowsDeviceNameGenerator;
+import java.util.Locale;
+
+public class NameGenerationOptions {
+
+  public String[] texts;
+
+  public static final int COUNT = 3;
+
+  public static final int COUNT2 = 1;
+
+  public static final int COUNT3 = 9;
+
+  public String[] texts2;
+
+  public static final int COUNT4 = 4;
+
+  public String methodsNamingPrefix;
+
+  public static final int COUNT5 = 8;
+
+  public String text2;
+
+  public String[] texts3;
+
+  public int classesNamingMode;
+
+  public final RenamingOptions renamingOptions;
+
+  public static final int COUNT6 = 2;
+
+  public String classesNamingPrefix;
+
+  public String[] texts4;
+
+  public static final int COUNT7 = 6;
+
+  public String fieldsNamingPrefix;
+
+  public int packagesNamingMode;
+
+  public int methodsNamingMode;
+
+  public int fieldsNamingMode;
+
+  public boolean fieldsNamingEnabled;
+
+  public boolean classesNamingEnabled;
+
+  public static final int COUNT8 = 5;
+
+  public boolean methodsNamingEnabled;
+
+  public static final int COUNT9 = 7;
+
+  public void setTexts3(String[] texts) {
+    this.texts3 = texts;
+  }
+
+  public void setMethodsNamingPrefix(String methodsNamingPrefix) {
+    this.methodsNamingPrefix = methodsNamingPrefix;
+  }
+
+  public NameGenerator createNameGenerator() {
+    return new LengthBoundNameGenerator(new LowercaseNameGenerator());
+  }
+
+  public void setEnabled(boolean fieldsNamingEnabled) {
+    this.fieldsNamingEnabled = fieldsNamingEnabled;
+  }
+
+  public void setTexts(String[] texts2) {
+    this.texts = texts2;
+  }
+
+  public String getText() {
+    if (this.methodsNamingMode == 5) {
+      return MixedConfusableNameGenerator.nextName2();
+    } else {
+      return this.methodsNamingMode == 9
+          ? LowercaseConfusableNameGenerator.nextName2()
+          : RenamingOptions.getLocalVariableOptions(this.renamingOptions).getLocalVariablesNaming();
+    }
+  }
+
+  public NameGenerator createNameGenerator2() {
+    NameGenerator nameGenerator;
+    NameGenerationOptions nameGenerationOptions;
+    if (this.methodsNamingMode == 1) {
+      nameGenerator = new LowercaseNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.methodsNamingMode == 8) {
+      nameGenerator = new UppercaseNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.methodsNamingMode == 3) {
+      nameGenerator = new JavaKeywordNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.methodsNamingMode == 5) {
+      nameGenerator = new MixedConfusableNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.methodsNamingMode == 9) {
+      nameGenerator = new LowercaseConfusableNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.methodsNamingMode == 6) {
+      nameGenerator = new NumericNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.methodsNamingMode == 7) {
+      nameGenerator = new PackageNameGenerator(this.texts);
+      nameGenerationOptions = this;
+    } else {
+      nameGenerator = new AsciiNameGenerator();
+      nameGenerationOptions = this;
+    }
+    if (nameGenerationOptions.methodsNamingEnabled) {
+      nameGenerator = new MainNameGenerator(nameGenerator, false, true);
+    }
+    NameGenerator nameGenerator2 = new LengthBoundNameGenerator(nameGenerator);
+    if (this.text2 != null) {
+      nameGenerator2 = new MethodNameGenerator(this.text2, nameGenerator2);
+    }
+    if (this.methodsNamingPrefix != null) {
+      nameGenerator2 = new TypeNameGenerator(this.methodsNamingPrefix, nameGenerator2);
+    }
+    return nameGenerator2;
+  }
+
+  public NameGenerator createNameGenerator3() {
+    if (RenamingOptions.getLocalVariableOptions(this.renamingOptions).calculateCount() == 2) {
+      return new LowercaseNameGenerator();
+    } else {
+      return RenamingOptions.getLocalVariableOptions(this.renamingOptions).calculateCount() == 1
+          ? new PrefixedNameGenerator(
+              RenamingOptions.getLocalVariableOptions(this.renamingOptions)
+                  .getLocalVariablesNaming())
+          : new LowercaseNameGenerator();
+    }
+  }
+
+  public NameGenerator createNameGenerator4() {
+    NameGenerator nameGenerator;
+    if (this.packagesNamingMode == 6) {
+      nameGenerator = new NumericNameGenerator();
+    } else if (this.packagesNamingMode == 7) {
+      nameGenerator = new PackageNameGenerator(this.texts4);
+    } else if (this.packagesNamingMode == 8) {
+      nameGenerator = new UppercaseNameGenerator();
+    } else {
+      nameGenerator = new LowercaseNameGenerator();
+    }
+    return new LengthBoundNameGenerator(nameGenerator);
+  }
+
+  public NameGenerationOptions(RenamingOptions renamingOptions2) {
+    super();
+    this.renamingOptions = renamingOptions2;
+    this.packagesNamingMode = 1;
+    this.classesNamingMode = 2;
+    this.classesNamingEnabled = false;
+    this.fieldsNamingMode = 2;
+    this.methodsNamingMode = 2;
+    this.fieldsNamingEnabled = false;
+    this.methodsNamingEnabled = false;
+    this.text2 = null;
+    this.fieldsNamingPrefix = null;
+    this.methodsNamingPrefix = null;
+    this.classesNamingPrefix = null;
+    this.texts2 = null;
+    this.texts = null;
+    this.texts3 = null;
+    this.texts4 = null;
+  }
+
+  public boolean isClassesNamingEnabled() {
+    return this.classesNamingEnabled;
+  }
+
+  public void setMethodsNamingMode(int methodsNamingMode) {
+    this.methodsNamingMode = methodsNamingMode;
+  }
+
+  public void setFieldsNamingMode(int fieldsNamingMode) {
+    this.fieldsNamingMode = fieldsNamingMode;
+  }
+
+  public boolean isFieldsNamingEnabled() {
+    return this.fieldsNamingEnabled;
+  }
+
+  public void setClassesNamingPrefix(String classesNamingPrefix) {
+    this.classesNamingPrefix = classesNamingPrefix;
+  }
+
+  public NameGenerator createNameGenerator5() {
+    NameGenerator nameGenerator;
+    NameGenerationOptions nameGenerationOptions;
+    if (this.fieldsNamingMode == 1) {
+      nameGenerator = new LowercaseNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.fieldsNamingMode == 8) {
+      nameGenerator = new UppercaseNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.fieldsNamingMode == 3) {
+      nameGenerator = new JavaKeywordNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.fieldsNamingMode == 5) {
+      nameGenerator = new MixedConfusableNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.fieldsNamingMode == 9) {
+      nameGenerator = new LowercaseConfusableNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.fieldsNamingMode == 6) {
+      nameGenerator = new NumericNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.fieldsNamingMode == 7) {
+      nameGenerator = new PackageNameGenerator(this.texts2);
+      nameGenerationOptions = this;
+    } else {
+      nameGenerator = new AsciiNameGenerator();
+      nameGenerationOptions = this;
+    }
+    if (nameGenerationOptions.fieldsNamingEnabled) {
+      nameGenerator = new MainNameGenerator(nameGenerator, true, false);
+    }
+    NameGenerator nameGenerator2 = new LengthBoundNameGenerator(nameGenerator);
+    if (this.text2 != null) {
+      nameGenerator2 = new MethodNameGenerator(this.text2, nameGenerator2);
+    }
+    if (this.fieldsNamingPrefix != null) {
+      nameGenerator2 = new TypeNameGenerator(this.fieldsNamingPrefix, nameGenerator2);
+    }
+    return nameGenerator2;
+  }
+
+  public void setTexts4(String[] texts) {
+    this.texts4 = texts;
+  }
+
+  public void setEnabled3(boolean methodsNamingEnabled) {
+    this.methodsNamingEnabled = methodsNamingEnabled;
+  }
+
+  public NameGenerator createNameGenerator6() {
+    NameGenerator nameGenerator;
+    NameGenerationOptions nameGenerationOptions;
+    if (this.classesNamingMode == 1) {
+      nameGenerator = new LowercaseNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.classesNamingMode == 8) {
+      nameGenerator = new UppercaseNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.classesNamingMode == 4) {
+      nameGenerator = new WindowsDeviceNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.classesNamingMode == 5) {
+      nameGenerator = new MixedConfusableNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.classesNamingMode == 9) {
+      nameGenerator = new LowercaseConfusableNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.classesNamingMode == 6) {
+      nameGenerator = new NumericNameGenerator();
+      nameGenerationOptions = this;
+    } else if (this.classesNamingMode == 7) {
+      nameGenerator = new PackageNameGenerator(this.texts3);
+      nameGenerationOptions = this;
+    } else {
+      nameGenerator = new AsciiNameGenerator();
+      nameGenerationOptions = this;
+    }
+    String text;
+    if (nameGenerationOptions.classesNamingMode != 1
+        && this.classesNamingMode != 8
+        && this.classesNamingMode != 6
+        && this.classesNamingMode != 9
+        && this.classesNamingMode != 7
+        && Configuration.getInputOptions().getValues2().size() > 0
+        && ((text = System.getProperty("os.name").toLowerCase(Locale.ENGLISH)) == null
+            || text.indexOf("win") >= 0
+            || text.indexOf("mac") >= 0)) {
+      nameGenerator = new LowercaseNameGenerator();
+    }
+    if (Configuration.getObfuscationOptions().isEnabled3()) {
+      nameGenerator = new RandomizedNameGenerator(nameGenerator);
+    }
+    NameGenerator nameGenerator2 = new LengthBoundNameGenerator(nameGenerator);
+    if (this.classesNamingPrefix != null) {
+      nameGenerator2 = new TypeNameGenerator(this.classesNamingPrefix, nameGenerator2);
+    }
+    return nameGenerator2;
+  }
+
+  public void setEnabled2(boolean classesNamingEnabled) {
+    this.classesNamingEnabled = classesNamingEnabled;
+  }
+
+  public NameGenerationOptions(
+      RenamingOptions renamingOptions,
+      NamingOptionsConstructorToken namingOptionsConstructorToken) {
+    this(renamingOptions);
+  }
+
+  public void setTexts2(String[] texts) {
+    this.texts2 = texts;
+  }
+
+  public void processText(String text2) {
+    if (this.text2 == null) {
+      this.text2 = text2;
+    } else {
+      this.text2 = "" + this.text2 + this.text2.substring(8, 9) + text2;
+    }
+  }
+
+  public void setFieldsNamingPrefix(String fieldsNamingPrefix) {
+    this.fieldsNamingPrefix = fieldsNamingPrefix;
+  }
+
+  public void setClassesNamingMode(int classesNamingMode) {
+    this.classesNamingMode = classesNamingMode;
+  }
+
+  public boolean isMethodsNamingEnabled() {
+    return this.methodsNamingEnabled;
+  }
+
+  public void setPackagesNamingMode(int packagesNamingMode) {
+    this.packagesNamingMode = packagesNamingMode;
+  }
+}

src/main/java/com/allatori/config/NamingOptionsConstructorToken.java

@@ -0,0 +1,3 @@
+package com.allatori.config;
+
+public class NamingOptionsConstructorToken {}

src/main/java/com/allatori/config/ObfuscationOptions.java

@@ -0,0 +1,426 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.RuleEntry;
+import com.allatori.config.rule.RuleSet;
+import com.allatori.lib.bcel.classfile.Method;
+import com.allatori.lib.bcel.generic.AnnotationEntryGen;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.lib.bcel.generic.ElementValuePairGen;
+import com.allatori.lib.bcel.generic.MethodGen;
+import com.allatori.model.ClassStorage;
+import java.util.Hashtable;
+import java.util.List;
+
+public class ObfuscationOptions {
+
+  public RuleSet ruleSet;
+
+  public static final int COUNT = 1;
+
+  public char stringEncryptionSeed;
+
+  public boolean enabled;
+
+  public static final int COUNT2 = 2;
+
+  public static final int COUNT3 = 1;
+
+  public RuleSet ruleSet2;
+
+  public boolean outputJarCommentEnabled;
+
+  public String decryptorExcludePattern;
+
+  public boolean enabled3;
+
+  public static final int COUNT4 = 0;
+
+  public RuleSet ruleSet3;
+
+  public static final int COUNT5 = 100;
+
+  public static final int COUNT6 = 0;
+
+  public boolean java6Enabled;
+
+  public String stringEncryptionIgnoredStrings;
+
+  public boolean packageStringEncryptionEnabled;
+
+  public Hashtable entries;
+
+  public String decryptorIncludePattern;
+
+  public static final int COUNT7 = 0;
+
+  public RuleSet ruleSet4;
+
+  public String randomSeed;
+
+  public String outputJarComment;
+
+  public boolean methodsNamingEnabled;
+
+  public boolean globalStringEncryptionEnabled;
+
+  public String text6;
+
+  public int stringEncryptionVersion;
+
+  public static final int COUNT8 = 1000;
+
+  public static final int COUNT9 = 3;
+
+  public final Configuration configuration;
+
+  public static final int COUNT10 = 1;
+
+  public RuleSet ruleSet5;
+
+  public static final int COUNT11 = 0;
+
+  public static final int COUNT12 = 101;
+
+  public static final int COUNT13 = 1;
+
+  public RuleSet ruleSet6;
+
+  public boolean finalizeEnabled;
+
+  public RuleSet ruleSet7;
+
+  public void setDecryptorExcludePattern(String decryptorExcludePattern) {
+    this.decryptorExcludePattern = decryptorExcludePattern;
+  }
+
+  public void setEnabled7(boolean globalStringEncryptionEnabled) {
+    this.globalStringEncryptionEnabled = globalStringEncryptionEnabled;
+  }
+
+  public void setCharacter(char stringEncryptionSeed) {
+    this.stringEncryptionSeed = stringEncryptionSeed;
+  }
+
+  public boolean isOutputJarCommentEnabled() {
+    return this.outputJarCommentEnabled;
+  }
+
+  public String getRandomSeed() {
+    return this.randomSeed;
+  }
+
+  public void setEnabled3(boolean enabled3) {
+    this.enabled3 = enabled3;
+  }
+
+  public ObfuscationOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.entries = new Hashtable();
+    this.ruleSet6 = new RuleSet(1);
+    this.ruleSet5 = new RuleSet(0);
+    this.ruleSet3 = new RuleSet(1);
+    this.ruleSet = new RuleSet(1);
+    this.ruleSet7 = new RuleSet(0);
+    this.ruleSet2 = new RuleSet(0);
+    this.ruleSet4 = new RuleSet(0);
+    this.randomSeed = null;
+    this.finalizeEnabled = false;
+    this.enabled = false;
+    this.enabled3 = false;
+    this.methodsNamingEnabled = true;
+    this.outputJarCommentEnabled = true;
+    this.outputJarComment = null;
+    this.stringEncryptionSeed = '\uffff';
+    this.stringEncryptionVersion = 1;
+    this.globalStringEncryptionEnabled = false;
+    this.packageStringEncryptionEnabled = false;
+    this.decryptorIncludePattern = "";
+    this.decryptorExcludePattern = "";
+    this.java6Enabled = false;
+    this.text6 = "org.springframework.boot.";
+  }
+
+  public boolean matchesMethod(ClassStorage classStorage, ClassGen classGen, Method method) {
+    return classStorage == null
+        ? false
+        : this.ruleSet4.calculateCount(classStorage, classGen, method) > 0;
+  }
+
+  public void setEnabled8(boolean finalizeEnabled) {
+    this.finalizeEnabled = finalizeEnabled;
+  }
+
+  public void setEnabled(boolean enabled) {
+    this.enabled = enabled;
+  }
+
+  public int calculateCount(ClassStorage classStorage, ClassGen classGen) {
+    if (!this.packageStringEncryptionEnabled && classGen.getClassName().startsWith(this.text6)) {
+      return 0;
+    }
+    AnnotationEntryGen[] annotationEntryGens;
+    int value = (annotationEntryGens = classGen.getAnnotationEntries()).length;
+    int value2;
+    for (int value3 = value2 = 0; value3 < value; value3 = ++value2) {
+      AnnotationEntryGen annotationEntryGen = annotationEntryGens[value2];
+      if ("Lcom/allatori/annotations/DisableStringEncryption;"
+          .equals(annotationEntryGen.getText2())) {
+        return 0;
+      }
+      if ("Lcom/allatori/annotations/EnableStringEncryption;"
+          .equals(annotationEntryGen.getText2())) {
+        return 1;
+      }
+      if ("Lcom/allatori/annotations/MaximumStringEncryption;"
+          .equals(annotationEntryGen.getText2())) {
+        return 3;
+      }
+      List values;
+      if ("Lcom/allatori/annotations/StringEncryption;".equals(annotationEntryGen.getText2())
+          && (values = annotationEntryGen.getValues()) != null
+          && values.size() > 0
+          && ((ElementValuePairGen) values.get(0)).getValue() != null) {
+        if ("enable".equals(((ElementValuePairGen) values.get(0)).getValue().stringifyValue())) {
+          return 1;
+        }
+        if ("disable".equals(((ElementValuePairGen) values.get(0)).getValue().stringifyValue())) {
+          return 0;
+        }
+        if ("maximum".equals(((ElementValuePairGen) values.get(0)).getValue().stringifyValue())) {
+          return 2;
+        }
+        if ("maximum-with-warnings"
+            .equals(((ElementValuePairGen) values.get(0)).getValue().stringifyValue())) {
+          return 3;
+        }
+      }
+    }
+    return this.ruleSet6.calculateCount(classStorage, classGen);
+  }
+
+  public boolean isGlobalStringEncryptionEnabled() {
+    return this.globalStringEncryptionEnabled;
+  }
+
+  public void setEnabled5(boolean packageStringEncryptionEnabled) {
+    this.packageStringEncryptionEnabled = packageStringEncryptionEnabled;
+  }
+
+  public boolean isMethodsNamingEnabled() {
+    return this.methodsNamingEnabled;
+  }
+
+  public void setRandomSeed(String randomSeed) {
+    this.randomSeed = randomSeed;
+  }
+
+  public String getDecryptorIncludePattern() {
+    return this.decryptorIncludePattern;
+  }
+
+  public String getDecryptorExcludePattern() {
+    return this.decryptorExcludePattern;
+  }
+
+  public int calculateCount2(ClassStorage classStorage, ClassGen classGen) {
+    return this.ruleSet3.calculateCount(classStorage, classGen);
+  }
+
+  public Hashtable getEntries() {
+    return this.entries;
+  }
+
+  public String getStringEncryptionIgnoredStrings() {
+    return this.stringEncryptionIgnoredStrings;
+  }
+
+  public void setStringEncryptionVersion(int stringEncryptionVersion) {
+    this.stringEncryptionVersion = stringEncryptionVersion;
+  }
+
+  public void processRuleEntry(RuleEntry ruleEntry) {
+    this.ruleSet7.processRuleEntry(ruleEntry);
+  }
+
+  public int calculateCount(ClassStorage classStorage, ClassGen classGen, MethodGen methodGen) {
+    if (this.enabled) {
+      return 0;
+    }
+    AnnotationEntryGen[] annotationEntryGens;
+    int value = (annotationEntryGens = classGen.getAnnotationEntries()).length;
+    int value2;
+    for (int value3 = value2 = 0; value3 < value; value3 = ++value2) {
+      AnnotationEntryGen annotationEntryGen = annotationEntryGens[value2];
+      if ("Lcom/allatori/annotations/StrongStringEncryptionType;"
+          .equals(annotationEntryGen.getText2())) {
+        return 1;
+      }
+      if ("Lcom/allatori/annotations/FastStringEncryptionType;"
+          .equals(annotationEntryGen.getText2())) {
+        return 0;
+      }
+      List values;
+      if ("Lcom/allatori/annotations/StringEncryptionType;".equals(annotationEntryGen.getText2())
+          && (values = annotationEntryGen.getValues()) != null
+          && values.size() > 0
+          && ((ElementValuePairGen) values.get(0)).getValue() != null) {
+        if ("fast".equals(((ElementValuePairGen) values.get(0)).getValue().stringifyValue())) {
+          return 0;
+        }
+        if ("strong".equals(((ElementValuePairGen) values.get(0)).getValue().stringifyValue())) {
+          return 1;
+        }
+      }
+    }
+    return this.ruleSet5.calculateCount(classStorage, classGen, methodGen);
+  }
+
+  public void setEnabled2(boolean outputJarCommentEnabled) {
+    this.outputJarCommentEnabled = outputJarCommentEnabled;
+  }
+
+  public void processRuleEntry2(RuleEntry ruleEntry) {
+    this.ruleSet4.processRuleEntry(ruleEntry);
+  }
+
+  public boolean isPackageStringEncryptionEnabled() {
+    return this.packageStringEncryptionEnabled;
+  }
+
+  public void processRuleEntry3(RuleEntry ruleEntry) {
+    this.ruleSet.processRuleEntry(ruleEntry);
+  }
+
+  public void setStringEncryptionIgnoredStrings(String stringEncryptionIgnoredStrings) {
+    this.stringEncryptionIgnoredStrings = stringEncryptionIgnoredStrings;
+  }
+
+  public void processRuleEntry4(RuleEntry ruleEntry) {
+    this.ruleSet6.processRuleEntry(ruleEntry);
+  }
+
+  public boolean matchesClassGen(ClassStorage classStorage, ClassGen classGen) {
+    return classStorage == null ? false : this.ruleSet7.calculateCount(classStorage, classGen) > 0;
+  }
+
+  public void setEnabled6(boolean methodsNamingEnabled) {
+    this.methodsNamingEnabled = methodsNamingEnabled;
+  }
+
+  public char getCharacter() {
+    return this.stringEncryptionSeed;
+  }
+
+  public int getStringEncryptionVersion() {
+    return this.stringEncryptionVersion;
+  }
+
+  public boolean isJava6Enabled() {
+    return this.java6Enabled;
+  }
+
+  public void processRuleEntry5(RuleEntry ruleEntry) {
+    this.ruleSet5.processRuleEntry(ruleEntry);
+  }
+
+  public void setDecryptorIncludePattern(String decryptorIncludePattern) {
+    this.decryptorIncludePattern = decryptorIncludePattern;
+  }
+
+  public boolean isFinalizeEnabled() {
+    return this.finalizeEnabled;
+  }
+
+  public String getOutputJarComment() {
+    return this.outputJarComment;
+  }
+
+  public void processRuleEntry6(RuleEntry ruleEntry) {
+    this.ruleSet3.processRuleEntry(ruleEntry);
+  }
+
+  public void setOutputJarComment(String outputJarComment) {
+    this.outputJarComment = outputJarComment;
+  }
+
+  public boolean isEnabled3() {
+    return this.enabled3;
+  }
+
+  public void setEnabled4(boolean java6Enabled) {
+    this.java6Enabled = java6Enabled;
+  }
+
+  public boolean matchesMethodGen(
+      ClassStorage classStorage, ClassGen classGen, MethodGen methodGen) {
+    if (methodGen.getName().startsWith("Allatori")) {
+      return !Configuration.getObfuscationOptions().isEnabled();
+    }
+    AnnotationEntryGen[] annotationEntryGens;
+    int value = (annotationEntryGens = methodGen.getAnnotationEntryGens()).length;
+    int value2;
+    for (int value3 = value2 = 0; value3 < value; value3 = ++value2) {
+      AnnotationEntryGen annotationEntryGen = annotationEntryGens[value2];
+      if ("Lcom/allatori/annotations/DisableControlFlowObfuscation;"
+          .equals(annotationEntryGen.getText2())) {
+        return false;
+      }
+      if ("Lcom/allatori/annotations/EnableControlFlowObfuscation;"
+          .equals(annotationEntryGen.getText2())) {
+        return true;
+      }
+      List values;
+      if ("Lcom/allatori/annotations/ControlFlowObfuscation;".equals(annotationEntryGen.getText2())
+          && (values = annotationEntryGen.getValues()) != null
+          && values.size() > 0
+          && ((ElementValuePairGen) values.get(0)).getValue() != null) {
+        if ("enable".equals(((ElementValuePairGen) values.get(0)).getValue().stringifyValue())) {
+          return true;
+        }
+        if ("disable".equals(((ElementValuePairGen) values.get(0)).getValue().stringifyValue())) {
+          return false;
+        }
+      }
+    }
+    AnnotationEntryGen[] annotationEntryGens2;
+    int value4 = (annotationEntryGens2 = classGen.getAnnotationEntries()).length;
+    int value5;
+    for (int value6 = value5 = 0; value6 < value4; value6 = ++value5) {
+      AnnotationEntryGen annotationEntryGen2 = annotationEntryGens2[value5];
+      if ("Lcom/allatori/annotations/DisableControlFlowObfuscation;"
+          .equals(annotationEntryGen2.getText2())) {
+        return false;
+      }
+      if ("Lcom/allatori/annotations/EnableControlFlowObfuscation;"
+          .equals(annotationEntryGen2.getText2())) {
+        return true;
+      }
+      List values2;
+      if ("Lcom/allatori/annotations/ControlFlowObfuscation;".equals(annotationEntryGen2.getText2())
+          && (values2 = annotationEntryGen2.getValues()) != null
+          && values2.size() > 0
+          && ((ElementValuePairGen) values2.get(0)).getValue() != null) {
+        if ("enable".equals(((ElementValuePairGen) values2.get(0)).getValue().stringifyValue())) {
+          return true;
+        }
+        if ("disable".equals(((ElementValuePairGen) values2.get(0)).getValue().stringifyValue())) {
+          return false;
+        }
+      }
+    }
+    return this.ruleSet.calculateCount(classStorage, classGen, methodGen) > 0;
+  }
+
+  public boolean matchesClassGen2(ClassStorage classStorage, ClassGen classGen) {
+    return classStorage == null ? false : this.ruleSet2.calculateCount(classStorage, classGen) > 0;
+  }
+
+  public boolean isEnabled() {
+    return this.enabled;
+  }
+
+  public void processRuleEntry7(RuleEntry ruleEntry) {
+    this.ruleSet2.processRuleEntry(ruleEntry);
+  }
+}

src/main/java/com/allatori/config/OptimizationOptions.java

@@ -0,0 +1,63 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.RuleEntry;
+import com.allatori.config.rule.RuleSet;
+import com.allatori.lib.bcel.classfile.Method;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.model.ClassStorage;
+import java.util.Vector;
+
+public class OptimizationOptions {
+
+  public RuleSet ruleSet;
+
+  public Vector values;
+
+  public RuleSet ruleSet2;
+
+  public final Configuration configuration;
+
+  public boolean matchesClassGen(ClassStorage classStorage, ClassGen classGen) {
+    if (classStorage == null) {
+      return false;
+    } else {
+      return this.ruleSet.getValues() == 0
+          ? false
+          : this.ruleSet.calculateCount(classStorage, classGen) > 0;
+    }
+  }
+
+  public void processRuleEntry(RuleEntry ruleEntry) {
+    this.ruleSet.processRuleEntry(ruleEntry);
+  }
+
+  public void processRuleEntry2(RuleEntry ruleEntry) {
+    this.ruleSet2.processRuleEntry(ruleEntry);
+  }
+
+  public boolean matchesText(String text) {
+    return this.values.contains(text);
+  }
+
+  public OptimizationOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.ruleSet = new RuleSet(0);
+    this.ruleSet2 = new RuleSet(0);
+    this.values = new Vector();
+  }
+
+  public boolean matchesMethod(ClassStorage classStorage, ClassGen classGen, Method method) {
+    if (classStorage == null) {
+      return false;
+    } else {
+      return this.ruleSet2.getValues() == 0
+          ? false
+          : this.ruleSet2.calculateCount(classStorage, classGen, method) > 0;
+    }
+  }
+
+  public void processText(String text) {
+    this.values.add(text);
+  }
+}

src/main/java/com/allatori/config/OutputOptions.java

@@ -0,0 +1,43 @@
+package com.allatori.config;
+
+public class OutputOptions {
+
+  public int compressionLevel;
+
+  public String logFile;
+
+  public final Configuration configuration;
+
+  public boolean keepDuplicateEntries;
+
+  public void setEnabled(boolean keepDuplicateEntries) {
+    this.keepDuplicateEntries = keepDuplicateEntries;
+  }
+
+  public OutputOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.compressionLevel = -1;
+    this.keepDuplicateEntries = false;
+  }
+
+  public void setCompressionLevel(int compressionLevel) {
+    this.compressionLevel = compressionLevel;
+  }
+
+  public boolean isKeepDuplicateEntries() {
+    return this.keepDuplicateEntries;
+  }
+
+  public void setLogFile(String logFile) {
+    this.logFile = logFile;
+  }
+
+  public String getLogFile() {
+    return this.logFile;
+  }
+
+  public int getCompressionLevel() {
+    return this.compressionLevel;
+  }
+}

src/main/java/com/allatori/config/PackageNameRule.java

@@ -0,0 +1,20 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.RuleEntry;
+
+public class PackageNameRule {
+
+  public RuleEntry ruleEntry;
+
+  public final PackageRenamingOptions packageRenamingOptions;
+
+  public String text;
+
+  public PackageNameRule(
+      PackageRenamingOptions packageRenamingOptions2, RuleEntry ruleEntry2, String text) {
+    super();
+    this.packageRenamingOptions = packageRenamingOptions2;
+    this.ruleEntry = ruleEntry2;
+    this.text = text;
+  }
+}

src/main/java/com/allatori/config/PackageRenamingOptions.java

@@ -0,0 +1,53 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.RuleEntry;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.model.ClassStorage;
+import java.util.Iterator;
+import java.util.Vector;
+
+public class PackageRenamingOptions {
+
+  public Vector values;
+
+  public boolean enabled;
+
+  public final Configuration configuration;
+
+  public boolean isEnabled() {
+    return this.enabled;
+  }
+
+  public boolean matchesText(ClassStorage classStorage, ClassGen classGen, String text2) {
+    if (classStorage != null && classGen != null && text2 != null) {
+      if (this.values.size() == 0) {
+        return false;
+      }
+      Iterator iterator2 = this.values.iterator();
+      while (iterator2.hasNext()) {
+        PackageNameRule packageNameRule;
+        if ((packageNameRule = (PackageNameRule) iterator2.next())
+                .ruleEntry.classRule.matches(classStorage, classGen)
+            && text2.matches(packageNameRule.text)) {
+          return true;
+        }
+      }
+      return false;
+    } else {
+      return false;
+    }
+  }
+
+  public void processText(RuleEntry ruleEntry, String text) {
+    this.enabled = true;
+    String text2 = text.replaceAll("\\.", "\\\\.").replaceAll("\\*", ".*");
+    this.values.add(new PackageNameRule(this, ruleEntry, text2));
+  }
+
+  public PackageRenamingOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.enabled = false;
+    this.values = new Vector();
+  }
+}

src/main/java/com/allatori/config/RenamingOptions.java

@@ -0,0 +1,186 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.RuleEntry;
+import com.allatori.config.rule.RuleSet;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.model.ClassStorage;
+
+public class RenamingOptions {
+
+  public String defaultPackage;
+
+  public boolean enabled;
+
+  public NameGenerationOptions nameGenerationOptions;
+
+  public boolean compatibleRenamingEnabled;
+
+  public KeepNamesOptions keepNamesOptions;
+
+  public boolean randomizeNamesEnabled;
+
+  public LocalVariableOptions localVariableOptions;
+
+  public String incrementalObfuscation;
+
+  public boolean classesNamingEnabled;
+
+  public boolean skipRenamingEnabled;
+
+  public RuleSet ruleSet;
+
+  public boolean fieldsNamingEnabled;
+
+  public final Configuration configuration;
+
+  public LineNumberOptions lineNumberOptions;
+
+  public ResourceRenamingOptions resourceRenamingOptions;
+
+  public boolean forceDefaultPackageEnabled;
+
+  public boolean enabled8;
+
+  public boolean isSkipRenamingEnabled() {
+    return this.skipRenamingEnabled;
+  }
+
+  public void setIncrementalObfuscation(String incrementalObfuscation) {
+    this.incrementalObfuscation = incrementalObfuscation;
+  }
+
+  public void setEnabled2(boolean compatibleRenamingEnabled) {
+    this.compatibleRenamingEnabled = compatibleRenamingEnabled;
+  }
+
+  public boolean isForceDefaultPackageEnabled() {
+    return this.forceDefaultPackageEnabled;
+  }
+
+  public RenamingOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.skipRenamingEnabled = false;
+    this.forceDefaultPackageEnabled = false;
+    this.enabled8 = false;
+    this.fieldsNamingEnabled = false;
+    this.randomizeNamesEnabled = true;
+    this.enabled = false;
+    this.compatibleRenamingEnabled = false;
+    this.classesNamingEnabled = false;
+    this.ruleSet = new RuleSet(0);
+    this.keepNamesOptions = new KeepNamesOptions(this, null);
+    this.lineNumberOptions = new LineNumberOptions(this);
+    this.nameGenerationOptions = new NameGenerationOptions(this, null);
+    this.localVariableOptions = new LocalVariableOptions(this);
+    this.resourceRenamingOptions = new ResourceRenamingOptions(this);
+  }
+
+  public KeepNamesOptions getKeepNamesOptions() {
+    return this.keepNamesOptions;
+  }
+
+  public NameGenerationOptions getNameGenerationOptions() {
+    return this.nameGenerationOptions;
+  }
+
+  public LocalVariableOptions getLocalVariableOptions() {
+    return this.localVariableOptions;
+  }
+
+  public boolean matchesClassGen(ClassStorage classStorage, ClassGen classGen) {
+    return this.ruleSet.calculateCount(classStorage, classGen) == 1;
+  }
+
+  public LineNumberOptions getLineNumberOptions() {
+    return this.lineNumberOptions;
+  }
+
+  public void setEnabled3(boolean randomizeNamesEnabled) {
+    this.randomizeNamesEnabled = randomizeNamesEnabled;
+  }
+
+  public boolean isClassesNamingEnabled() {
+    return this.classesNamingEnabled;
+  }
+
+  public static boolean matchesRenamingOptions(RenamingOptions renamingOptions) {
+    return renamingOptions.skipRenamingEnabled;
+  }
+
+  public ResourceRenamingOptions getResourceRenamingOptions() {
+    return this.resourceRenamingOptions;
+  }
+
+  public boolean isEnabled() {
+    return this.enabled;
+  }
+
+  public void setEnabled4(boolean classesNamingEnabled) {
+    this.classesNamingEnabled = classesNamingEnabled;
+  }
+
+  public void processRuleEntry(RuleEntry ruleEntry) {
+    this.ruleSet.processRuleEntry(ruleEntry);
+  }
+
+  public boolean isText2() {
+    return this.incrementalObfuscation != null;
+  }
+
+  public void setEnabled8(boolean enabled8) {
+    this.enabled8 = enabled8;
+  }
+
+  public void setEnabled7(boolean forceDefaultPackageEnabled) {
+    this.forceDefaultPackageEnabled = forceDefaultPackageEnabled;
+  }
+
+  public void setEnabled(boolean enabled) {
+    this.enabled = enabled;
+  }
+
+  public void setDefaultPackage(String defaultPackage) {
+    this.defaultPackage = defaultPackage;
+  }
+
+  public boolean isFieldsNamingEnabled() {
+    return this.fieldsNamingEnabled;
+  }
+
+  public static LocalVariableOptions getLocalVariableOptions(RenamingOptions renamingOptions) {
+    return renamingOptions.localVariableOptions;
+  }
+
+  public void setEnabled6(boolean fieldsNamingEnabled) {
+    this.fieldsNamingEnabled = fieldsNamingEnabled;
+  }
+
+  public boolean isEnabled8() {
+    return this.enabled8;
+  }
+
+  public String getDefaultPackage() {
+    return this.defaultPackage;
+  }
+
+  public boolean isCompatibleRenamingEnabled() {
+    return this.compatibleRenamingEnabled;
+  }
+
+  public boolean isRandomizeNamesEnabled() {
+    return this.randomizeNamesEnabled;
+  }
+
+  public String getIncrementalObfuscation() {
+    return this.incrementalObfuscation;
+  }
+
+  public boolean isText() {
+    return this.defaultPackage != null;
+  }
+
+  public void setEnabled5(boolean skipRenamingEnabled) {
+    this.skipRenamingEnabled = skipRenamingEnabled;
+  }
+}

src/main/java/com/allatori/config/ResourceNameRule.java

@@ -0,0 +1,36 @@
+package com.allatori.config;
+
+public class ResourceNameRule {
+
+  public final ResourceRenamingOptions resourceRenamingOptions;
+
+  public boolean enabled;
+
+  public String text;
+
+  public String text2;
+
+  public static boolean matchesResourceNameRule(ResourceNameRule resourceNameRule) {
+    return resourceNameRule.enabled;
+  }
+
+  public static String getText(ResourceNameRule resourceNameRule) {
+    return resourceNameRule.text;
+  }
+
+  public static String getText2(ResourceNameRule resourceNameRule) {
+    return resourceNameRule.text2;
+  }
+
+  public ResourceNameRule(
+      ResourceRenamingOptions resourceRenamingOptions2,
+      String text,
+      boolean enabled,
+      String text2) {
+    super();
+    this.resourceRenamingOptions = resourceRenamingOptions2;
+    this.text = text;
+    this.enabled = enabled;
+    this.text2 = text2;
+  }
+}

src/main/java/com/allatori/config/ResourceRenamingOptions.java

@@ -0,0 +1,69 @@
+package com.allatori.config;
+
+import java.util.Locale;
+import java.util.Vector;
+
+public class ResourceRenamingOptions {
+
+  public boolean updateResourceNamesEnabled;
+
+  public Vector values;
+
+  public final RenamingOptions renamingOptions;
+
+  public void processText(String text, boolean matches, String text2) {
+    String text3 = text.replaceAll("\\.", "\\\\.").replaceAll("\\*", ".*");
+    this.values.add(new ResourceNameRule(this, text3, matches, text2));
+  }
+
+  public boolean matchesText(String text) {
+    String text2;
+    if (!(text2 = text.toLowerCase(Locale.ENGLISH)).endsWith(".jar")
+        && !text2.endsWith(".class")
+        && !text2.endsWith(".jks")
+        && !text2.endsWith(".ttf")
+        && !text2.endsWith(".png")
+        && !text2.endsWith(".jpg")
+        && !text2.endsWith(".jpeg")
+        && !text2.endsWith(".gif")
+        && !text2.endsWith(".bmp")
+        && !text2.endsWith(".svg")
+        && !text2.endsWith(".ico")) {
+      for (ResourceNameRule resourceNameRule :
+          ((Iterable<ResourceNameRule>) ((Iterable<?>) this.values))) {
+        if (text.matches(ResourceNameRule.getText(resourceNameRule))) {
+          return ResourceNameRule.matchesResourceNameRule(resourceNameRule);
+        }
+      }
+      return false;
+    } else {
+      return false;
+    }
+  }
+
+  public String getText(String text) {
+    text.toLowerCase(Locale.ENGLISH);
+    for (ResourceNameRule resourceNameRule :
+        ((Iterable<ResourceNameRule>) ((Iterable<?>) this.values))) {
+      if (text.matches(ResourceNameRule.getText(resourceNameRule))) {
+        return ResourceNameRule.getText2(resourceNameRule);
+      }
+    }
+    return "UTF-8";
+  }
+
+  public void setEnabled(boolean updateResourceNamesEnabled) {
+    this.updateResourceNamesEnabled = updateResourceNamesEnabled;
+  }
+
+  public ResourceRenamingOptions(RenamingOptions renamingOptions2) {
+    super();
+    this.renamingOptions = renamingOptions2;
+    this.updateResourceNamesEnabled = false;
+    this.values = new Vector();
+  }
+
+  public boolean isUpdateResourceNamesEnabled() {
+    return this.updateResourceNamesEnabled;
+  }
+}

src/main/java/com/allatori/config/SyntheticOptions.java

@@ -0,0 +1,67 @@
+package com.allatori.config;
+
+import com.allatori.config.rule.RuleEntry;
+import com.allatori.config.rule.RuleSet;
+import com.allatori.lib.bcel.classfile.AnnotationEntry;
+import com.allatori.lib.bcel.classfile.Field;
+import com.allatori.lib.bcel.classfile.Method;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.model.ClassStorage;
+
+public class SyntheticOptions {
+
+  public RuleSet ruleSet;
+
+  public RuleSet ruleSet2;
+
+  public final Configuration configuration;
+
+  public boolean matchesMethod(ClassStorage classStorage, ClassGen classGen, Method method) {
+    if (classStorage == null) {
+      return false;
+    }
+    AnnotationEntry[] annotationEntries = method.getAnnotationEntries();
+    int value;
+    for (int value2 = value = 0; value2 < annotationEntries.length; value2 = ++value) {
+      AnnotationEntry annotationEntry = annotationEntries[value];
+      if ("Lcom/allatori/annotations/Synthetize;".equals(annotationEntry.getText())) {
+        return true;
+      }
+    }
+    return this.ruleSet2.getValues() == 0
+        ? method.isEnabled9()
+        : this.ruleSet2.calculateCount(classStorage, classGen, method) > 0;
+  }
+
+  public void processRuleEntry(RuleEntry ruleEntry) {
+    this.ruleSet.processRuleEntry(ruleEntry);
+  }
+
+  public SyntheticOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.ruleSet = new RuleSet(0);
+    this.ruleSet2 = new RuleSet(0);
+  }
+
+  public void processRuleEntry2(RuleEntry ruleEntry) {
+    this.ruleSet2.processRuleEntry(ruleEntry);
+  }
+
+  public boolean matchesField(ClassStorage classStorage, ClassGen classGen, Field field) {
+    if (classStorage == null) {
+      return false;
+    }
+    AnnotationEntry[] annotationEntries = field.getAnnotationEntries();
+    int value;
+    for (int value2 = value = 0; value2 < annotationEntries.length; value2 = ++value) {
+      AnnotationEntry annotationEntry = annotationEntries[value];
+      if ("Lcom/allatori/annotations/Synthetize;".equals(annotationEntry.getText())) {
+        return true;
+      }
+    }
+    return this.ruleSet.getValues() == 0
+        ? false
+        : this.ruleSet.calculateCount(classStorage, classGen, field) > 0;
+  }
+}

src/main/java/com/allatori/config/WatermarkOptions.java

@@ -0,0 +1,42 @@
+package com.allatori.config;
+
+public class WatermarkOptions {
+
+  public boolean enabled;
+
+  public String text;
+
+  public final Configuration configuration;
+
+  public String text2;
+
+  public void setText(String text) {
+    this.text = text;
+  }
+
+  public WatermarkOptions(Configuration configuration2) {
+    super();
+    this.configuration = configuration2;
+    this.enabled = false;
+  }
+
+  public void setEnabled(boolean enabled) {
+    this.enabled = enabled;
+  }
+
+  public boolean isEnabled() {
+    return this.enabled;
+  }
+
+  public void setText2(String text2) {
+    this.text2 = text2;
+  }
+
+  public String getText2() {
+    return this.text2;
+  }
+
+  public String getText() {
+    return this.text;
+  }
+}

src/main/java/com/allatori/config/XmlParsingContext.java

@@ -0,0 +1,34 @@
+package com.allatori.config;
+
+import java.io.FileReader;
+import javax.xml.parsers.SAXParserFactory;
+import org.xml.sax.InputSource;
+import org.xml.sax.XMLReader;
+
+public class XmlParsingContext implements ConfigurationSource {
+
+  public String text;
+
+  @Override
+  public void parse() throws ConfigurationException {
+    try {
+      FileReader fileReader = new FileReader(this.text);
+      XMLReader xMLReader = SAXParserFactory.newInstance().newSAXParser().getXMLReader();
+      xMLReader.setContentHandler(new ConfigurationHandler(this, null));
+      xMLReader.parse(new InputSource(fileReader));
+    } catch (ConfigurationSaxException configurationSaxException) {
+      throw new ConfigurationException(configurationSaxException.getMessage());
+    } catch (Exception exception) {
+      throw new ConfigurationException(exception);
+    }
+  }
+
+  public XmlParsingContext(String text) {
+    super();
+    this.text = text;
+  }
+
+  public static String getText(XmlParsingContext xmlParsingContext) {
+    return xmlParsingContext.text;
+  }
+}

src/main/java/com/allatori/config/property/PropertyHandler.java

@@ -0,0 +1,6 @@
+package com.allatori.config.property;
+
+public abstract class PropertyHandler {
+
+  public abstract void apply(String text, String text2);
+}

src/main/java/com/allatori/config/property/PropertyRegistry.java

@@ -0,0 +1,30 @@
+package com.allatori.config.property;
+
+import com.allatori.config.ConfigurationException;
+
+public class PropertyRegistry {
+
+  public static Object[][] values =
+      new Object[][] {{"string-encryption", StringEncryptionProperty.class}, {"", ""}, {"", ""}};
+
+  public static String text3 = "enable";
+
+  public static String text = "disable";
+
+  public static String text2 = "maximum";
+
+  public static PropertyHandler createPropertyHandler(String text) throws ConfigurationException {
+    int value;
+    for (int value2 = value = values.length - 1; value2 >= 0; value2 = --value) {
+      if (text.equals(values[value][0])) {
+        Class classValue = (Class) values[value][1];
+        try {
+          return (PropertyHandler) classValue.newInstance();
+        } catch (Exception exception) {
+          throw new ConfigurationException("Cannot instantiate property class");
+        }
+      }
+    }
+    throw new ConfigurationException("Unknown property");
+  }
+}

src/main/java/com/allatori/config/property/StringEncryptionProperty.java

@@ -0,0 +1,7 @@
+package com.allatori.config.property;
+
+public class StringEncryptionProperty extends PropertyHandler {
+
+  @Override
+  public void apply(String text, String text2) {}
+}

src/main/java/com/allatori/config/rule/ClassRule.java

@@ -0,0 +1,197 @@
+package com.allatori.config.rule;
+
+import com.allatori.config.ConfigurationException;
+import com.allatori.lib.bcel.classfile.Field;
+import com.allatori.lib.bcel.classfile.Method;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.lib.bcel.generic.MethodGen;
+import com.allatori.model.ClassStorage;
+import java.util.Vector;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class ClassRule {
+
+  public Vector values;
+
+  public String[] texts;
+
+  public int count;
+
+  public boolean enabled;
+
+  public boolean enabled2;
+
+  public String text;
+
+  public boolean enabled3;
+
+  public String text2;
+
+  public String text3;
+
+  public String text4;
+
+  public Vector values2;
+
+  public boolean enabled4 = false;
+
+  public ClassRule(
+      String text, boolean matches, boolean matches2, boolean enabled4, boolean enabled3)
+      throws ConfigurationException {
+    this(text, matches, matches2);
+    this.enabled4 = enabled4;
+    this.enabled3 = enabled3;
+  }
+
+  public boolean matches(MethodGen methodGen) {
+    int value;
+    for (int value2 = value = 0; value2 < this.values.size(); value2 = ++value) {
+      MethodRule methodRule;
+      if ((methodRule = (MethodRule) this.values.get(value)).matches(methodGen)) {
+        if (!methodRule.matches()) {
+          return true;
+        }
+        return false;
+      }
+    }
+    return false;
+  }
+
+  public boolean matches() {
+    return this.enabled2;
+  }
+
+  public ClassRule(String text, boolean enabled, boolean enabled2) throws ConfigurationException {
+    super();
+    this.enabled4 = false;
+    this.enabled3 = false;
+    this.values2 = new Vector();
+    this.values = new Vector();
+    this.enabled = enabled;
+    this.enabled2 = enabled2;
+    this.processText(text);
+  }
+
+  public void processText(String text5) throws ConfigurationException {
+    Matcher matcher2;
+    if ((matcher2 =
+            Pattern.compile(
+                    "(.*?(?:class|interface))\\s+(.+?)(?:\\s+extends\\s+(.+?))?(?:\\s+implements\\s+(.+?))?(?:\\s+instanceof\\s+(.+?))?")
+                .matcher(text5))
+        .matches()) {
+      String text6 = matcher2.group(1);
+      this.count = TemplateUtils.calculateCount(text6);
+      Matcher matcher3;
+      if (TemplateUtils.matches2(text6)) {
+        int value;
+        if ((value = text6.indexOf(32)) == -1) {
+          value = text6.length();
+        }
+        this.text = TemplateUtils.getText2(text6.substring(1, value));
+        this.text = 'L' + this.text.replaceAll("\\\\\\.", "/") + ';';
+        matcher3 = matcher2;
+      } else {
+        this.text = null;
+        matcher3 = matcher2;
+      }
+      String text7 = matcher3.group(2);
+      this.text2 = TemplateUtils.getText2(text7);
+      this.text3 = TemplateUtils.getText2(matcher2.group(3));
+      this.texts = TemplateUtils.getTexts(matcher2.group(4));
+      this.text4 = TemplateUtils.getText2(matcher2.group(5));
+    } else {
+      throw new ConfigurationException("Invalid template.");
+    }
+  }
+
+  public ClassRule() {
+    this.enabled3 = false;
+    this.values2 = new Vector();
+    this.values = new Vector();
+  }
+
+  public boolean matches(ClassStorage classStorage, ClassGen classGen) {
+    if (!TemplateUtils.matches(classGen, this.count)) {
+      return this.enabled3;
+    } else if (!classGen.getClassName().matches(this.text2)) {
+      return this.enabled3;
+    } else if (!classGen.getSuperclassName().matches(this.text3)) {
+      return this.enabled3;
+    } else if (!TemplateUtils.matches(classGen.getInterfaceNames(), this.texts)) {
+      return this.enabled3;
+    } else if (!TemplateUtils.matches(classStorage, classGen.getClassName(), this.text4)) {
+      return this.enabled3;
+    } else {
+      return this.text != null && !TemplateUtils.matches(classGen.getAnnotationEntries(), this.text)
+          ? this.enabled3
+          : !this.enabled3;
+    }
+  }
+
+  public void processMethodRule(MethodRule methodRule) {
+    this.values.add(methodRule);
+  }
+
+  public boolean matches2() {
+    return this.enabled;
+  }
+
+  public void processFieldRule(FieldRule fieldRule) {
+    this.values2.add(fieldRule);
+  }
+
+  public boolean matches(ClassStorage classStorage, Field field) {
+    int value;
+    for (int value2 = value = 0; value2 < this.values2.size(); value2 = ++value) {
+      FieldRule fieldRule;
+      if ((fieldRule = (FieldRule) this.values2.get(value)).matches(classStorage, field)) {
+        if (!fieldRule.matches()) {
+          return true;
+        }
+        return false;
+      }
+    }
+    return false;
+  }
+
+  public boolean matches(Method method) {
+    int value;
+    for (int value2 = value = 0; value2 < this.values.size(); value2 = ++value) {
+      MethodRule methodRule;
+      if ((methodRule = (MethodRule) this.values.get(value)).matches(method)) {
+        if (!methodRule.matches()) {
+          return true;
+        }
+        return false;
+      }
+    }
+    return false;
+  }
+
+  public boolean matches3() {
+    return this.enabled4;
+  }
+
+  public ClassRule createClassRule() {
+    ClassRule classRule = new ClassRule();
+    classRule.enabled = this.enabled;
+    classRule.enabled2 = this.enabled2;
+    classRule.enabled4 = this.enabled4;
+    classRule.count = this.count;
+    classRule.text2 = this.text2;
+    classRule.text3 = this.text3;
+    classRule.text4 = this.text4;
+    classRule.texts = this.texts;
+    classRule.text = this.text;
+    return classRule;
+  }
+
+  public boolean matches4() {
+    return this.values2.size() > 0;
+  }
+
+  public boolean matches5() {
+    return this.values.size() > 0;
+  }
+}

src/main/java/com/allatori/config/rule/FieldRule.java

@@ -0,0 +1,96 @@
+package com.allatori.config.rule;
+
+import com.allatori.config.ConfigurationException;
+import com.allatori.lib.bcel.classfile.Field;
+import com.allatori.model.ClassStorage;
+
+public class FieldRule {
+
+  public String text;
+
+  public boolean enabled;
+
+  public String text2;
+
+  public String text3;
+
+  public String text4;
+
+  public boolean enabled2;
+
+  public int count;
+
+  public boolean matches(ClassStorage classStorage, Field field) {
+    if (!TemplateUtils.matches(field, this.count)) {
+      return this.enabled;
+    }
+    if (!field.getText().matches(this.text4)) {
+      return this.enabled;
+    }
+    if (!field.getType().toString().matches(this.text3)) {
+      return this.enabled;
+    }
+    if (this.text != null && !TemplateUtils.matches(field.getAnnotationEntries(), this.text)) {
+      return this.enabled;
+    }
+    if (this.text2 != null) {
+      String text5;
+      if ((text5 = field.getText2()).charAt(0) != 'L' || text5.charAt(text5.length() - 1) != ';') {
+        return this.enabled;
+      }
+      String text6 = text5.substring(1, text5.length() - 1).replace('/', '.');
+      if (!TemplateUtils.matches(classStorage, text6, this.text2)) {
+        return this.enabled;
+      }
+    }
+    return !this.enabled;
+  }
+
+  public void processText(String text5) throws ConfigurationException {
+    String[] texts;
+    if ((texts = text5.split("\\s+")) != null && texts.length != 0) {
+      int value;
+      FieldRule fieldRule;
+      if ((value = texts.length) >= 3 && "instanceof".equals(texts[value - 2])) {
+        int value2 = value - 1;
+        String[] texts2 = texts;
+        value -= 2;
+        fieldRule = this;
+        this.text2 = TemplateUtils.getText2(texts2[value2]);
+      } else {
+        fieldRule = this;
+        this.text2 = null;
+      }
+      fieldRule.text4 = TemplateUtils.getText(texts[value - 1]);
+      if (value > 1
+          && !TemplateUtils.matches3(texts[value - 2])
+          && !TemplateUtils.matches2(texts[value - 2])) {
+        fieldRule = this;
+        this.text3 = TemplateUtils.getText2(texts[value - 2]);
+      } else {
+        fieldRule = this;
+        this.text3 = ".*";
+      }
+      fieldRule.count = TemplateUtils.calculateCount(text5);
+      if (TemplateUtils.matches2(texts[0])) {
+        this.text = TemplateUtils.getText2(texts[0].substring(1));
+        this.text = 'L' + this.text.replaceAll("\\\\\\.", "/") + ';';
+      } else {
+        this.text = null;
+      }
+    } else {
+      throw new ConfigurationException("Invalid template.");
+    }
+  }
+
+  public FieldRule(String text, boolean enabled2, boolean enabled) throws ConfigurationException {
+    super();
+    this.processText(text);
+    this.enabled2 = enabled2;
+    this.enabled = enabled;
+  }
+
+  public boolean matches() {
+    return this.enabled2;
+  }
+}

src/main/java/com/allatori/config/rule/MethodRule.java

@@ -0,0 +1,117 @@
+package com.allatori.config.rule;
+
+import com.allatori.config.ConfigurationException;
+import com.allatori.lib.bcel.classfile.Method;
+import com.allatori.lib.bcel.generic.MethodGen;
+
+public class MethodRule {
+
+  public String text;
+
+  public String text2;
+
+  public String text3;
+
+  public String text4;
+
+  public boolean enabled;
+
+  public boolean enabled2;
+
+  public int count;
+
+  public boolean matches(MethodGen methodGen) {
+    if (!TemplateUtils.matches(methodGen, this.count)) {
+      return this.enabled2;
+    } else if (!methodGen.getName().matches(this.text3)) {
+      return this.enabled2;
+    } else if (!methodGen.getReturnType().toString().matches(this.text)) {
+      return this.enabled2;
+    } else if (!TemplateUtils.matches(methodGen.getArgumentTypes(), this.text2)) {
+      return this.enabled2;
+    } else {
+      return this.text4 != null
+              && !TemplateUtils.matches(methodGen.getAnnotationEntryGens(), this.text4)
+          ? this.enabled2
+          : !this.enabled2;
+    }
+  }
+
+  public void processText(String text5) throws ConfigurationException {
+    String[] texts;
+    String[] texts2;
+    if ((texts = text5.split("\\(|\\)")).length != 2) {
+      if (texts.length == 1 && text5.endsWith("()")) {
+        texts2 = texts;
+      } else {
+        if (texts.length <= 2 || !text5.contains("regex:")) {
+          throw new ConfigurationException("Invalid template.");
+        }
+        String text6 = text5.substring(0, text5.lastIndexOf(40));
+        String text7 = text5.substring(text5.lastIndexOf(40) + 1, text5.lastIndexOf(41));
+        texts2 = texts = new String[] {text6, text7};
+      }
+    } else {
+      texts2 = texts;
+    }
+    if (texts2.length == 1) {
+      texts2 = texts;
+      this.text2 = "";
+    } else {
+      texts2 = texts;
+      String text8 = texts[1];
+      this.text2 = TemplateUtils.getText4(text8);
+    }
+    String[] texts3;
+    String text9;
+    if ((texts3 = (text9 = texts2[0]).split("\\s+")) != null && texts3.length != 0) {
+      this.text3 = TemplateUtils.getText(texts3[texts3.length - 1]);
+      MethodRule methodRule;
+      if (texts3.length > 1
+          && !TemplateUtils.matches3(texts3[texts3.length - 2])
+          && !TemplateUtils.matches2(texts3[texts3.length - 2])) {
+        this.text = TemplateUtils.getText2(texts3[texts3.length - 2]);
+        methodRule = this;
+      } else {
+        methodRule = this;
+        this.text = ".*";
+      }
+      methodRule.count = TemplateUtils.calculateCount(text9);
+      if (TemplateUtils.matches2(texts3[0])) {
+        this.text4 = TemplateUtils.getText2(texts3[0].substring(1));
+        this.text4 = 'L' + this.text4.replaceAll("\\\\\\.", "/") + ';';
+      } else {
+        this.text4 = null;
+      }
+    } else {
+      throw new ConfigurationException("Invalid template.");
+    }
+  }
+
+  public boolean matches() {
+    return this.enabled;
+  }
+
+  public MethodRule(String text, boolean enabled, boolean enabled2) throws ConfigurationException {
+    super();
+    this.processText(text);
+    this.enabled = enabled;
+    this.enabled2 = enabled2;
+  }
+
+  public boolean matches(Method method) {
+    if (!TemplateUtils.matches(method, this.count)) {
+      return this.enabled2;
+    } else if (!method.getText().matches(this.text3)) {
+      return this.enabled2;
+    } else if (!method.getReturnType().toString().matches(this.text)) {
+      return this.enabled2;
+    } else if (!TemplateUtils.matches(method.getArgumentTypes(), this.text2)) {
+      return this.enabled2;
+    } else {
+      return this.text4 != null && !TemplateUtils.matches(method.getAnnotationEntries(), this.text4)
+          ? this.enabled2
+          : !this.enabled2;
+    }
+  }
+}

src/main/java/com/allatori/config/rule/RuleEntry.java

@@ -0,0 +1,14 @@
+package com.allatori.config.rule;
+
+public class RuleEntry {
+
+  public int count;
+
+  public ClassRule classRule;
+
+  public RuleEntry(int count, ClassRule classRule2) {
+    super();
+    this.count = count;
+    this.classRule = classRule2;
+  }
+}

src/main/java/com/allatori/config/rule/RuleSet.java

@@ -0,0 +1,84 @@
+package com.allatori.config.rule;
+
+import com.allatori.lib.bcel.classfile.Field;
+import com.allatori.lib.bcel.classfile.Method;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.lib.bcel.generic.MethodGen;
+import com.allatori.model.ClassStorage;
+import java.util.Vector;
+
+public class RuleSet {
+
+  public Vector values;
+
+  public int count;
+
+  public int getValues() {
+    return this.values.size();
+  }
+
+  public int calculateCount(ClassStorage classStorage, ClassGen classGen, Field field) {
+    int value;
+    for (int value2 = value = 0; value2 < this.values.size(); value2 = ++value) {
+      RuleEntry ruleEntry;
+      if ((ruleEntry = (RuleEntry) this.values.get(value))
+          .classRule.matches(classStorage, classGen)) {
+        if (field == null) {
+          return ruleEntry.count;
+        }
+        if (ruleEntry.classRule.matches(classStorage, field)) {
+          return ruleEntry.count;
+        }
+      }
+    }
+    return this.count;
+  }
+
+  public int calculateCount(ClassStorage classStorage, ClassGen classGen, Method method) {
+    int value;
+    for (int value2 = value = 0; value2 < this.values.size(); value2 = ++value) {
+      RuleEntry ruleEntry;
+      if ((ruleEntry = (RuleEntry) this.values.get(value))
+          .classRule.matches(classStorage, classGen)) {
+        if (method == null) {
+          return ruleEntry.count;
+        }
+        if (ruleEntry.classRule.matches(method)) {
+          return ruleEntry.count;
+        }
+      }
+    }
+    return this.count;
+  }
+
+  public RuleSet(int count) {
+    super();
+    this.values = new Vector();
+    this.count = count;
+  }
+
+  public void processRuleEntry(RuleEntry ruleEntry) {
+    this.values.add(ruleEntry);
+  }
+
+  public int calculateCount(ClassStorage classStorage, ClassGen classGen, MethodGen methodGen) {
+    int value;
+    for (int value2 = value = 0; value2 < this.values.size(); value2 = ++value) {
+      RuleEntry ruleEntry;
+      if ((ruleEntry = (RuleEntry) this.values.get(value))
+          .classRule.matches(classStorage, classGen)) {
+        if (methodGen == null) {
+          return ruleEntry.count;
+        }
+        if (ruleEntry.classRule.matches(methodGen)) {
+          return ruleEntry.count;
+        }
+      }
+    }
+    return this.count;
+  }
+
+  public int calculateCount(ClassStorage classStorage, ClassGen classGen) {
+    return this.calculateCount(classStorage, classGen, (MethodGen) null);
+  }
+}

src/main/java/com/allatori/config/rule/TemplateUtils.java

@@ -0,0 +1,352 @@
+package com.allatori.config.rule;
+
+import com.allatori.lib.bcel.classfile.AccessFlags;
+import com.allatori.lib.bcel.classfile.AnnotationEntry;
+import com.allatori.lib.bcel.generic.AnnotationEntryGen;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.lib.bcel.generic.Type;
+import com.allatori.model.ClassStorage;
+import com.allatori.util.Log;
+
+public class TemplateUtils {
+
+  public static final int COUNT = 2048;
+
+  public static final int COUNT2 = 512;
+
+  public static final int COUNT3 = 32;
+
+  public static final int COUNT4 = 8192;
+
+  public static final int COUNT5 = 128;
+
+  public static final int COUNT6 = 4;
+
+  public static final int COUNT7 = 256;
+
+  public static final int COUNT8 = 1;
+
+  public static final int COUNT9 = 2;
+
+  public static final int COUNT10 = 8;
+
+  public static final int COUNT11 = 1024;
+
+  public static final int COUNT12 = 16;
+
+  public static final int COUNT13 = 4096;
+
+  public static final int COUNT14 = 64;
+
+  public static boolean matches(String text) {
+    if (text.equals("public")) {
+      return true;
+    } else if (text.equals("protected")) {
+      return true;
+    } else if (text.equals("package")) {
+      return true;
+    } else if (text.equals("private")) {
+      return true;
+    } else if (text.equals("protected+")) {
+      return true;
+    } else {
+      return text.equals("package+") ? true : text.equals("private+");
+    }
+  }
+
+  public static boolean matches(String[] texts, String[] texts2) {
+    int value;
+    int value2;
+    for (int value3 = value2 = texts2.length - 1; value3 >= 0; value3 = --value2) {
+      byte value4 = 0;
+      int value5;
+      value3 = value5 = texts.length - 1;
+      while (true) {
+        if (value3 < 0) {
+          value = value4;
+          break;
+        }
+        if (texts[value5].matches(texts2[value2])) {
+          value = 1;
+          break;
+        }
+        value3 = --value5;
+      }
+      if (value == 0) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  public static String getText(String text) {
+    return getText2(text);
+  }
+
+  public static String getText2(String text) {
+    return text == null ? ".*" : getText3(text.trim().replaceAll("\\$", "\\\\\\$"));
+  }
+
+  public static String getText3(String text) {
+    return text.startsWith("regex:")
+        ? text.substring(6)
+        : text.replaceAll("\\.", "\\\\.").replaceAll("\\*", ".*");
+  }
+
+  public static boolean matches(AnnotationEntry[] annotationEntrys, String text) {
+    if (text == null) {
+      return true;
+    }
+    int value;
+    for (int value2 = value = annotationEntrys.length - 1; value2 >= 0; value2 = --value) {
+      if (annotationEntrys[value].getText().matches(text)) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public static String[] getTexts(String text) {
+    if (text == null) {
+      return new String[0];
+    }
+    String[] texts;
+    if ((texts = text.split("\\s*,\\s*")) == null) {
+      return new String[0];
+    }
+    int value;
+    for (int value2 = value = texts.length - 1; value2 >= 0; value2 = value) {
+      texts[value] = texts[value].replaceAll("\\$", "\\\\\\$");
+      String text3 = getText3(texts[value]);
+      int value3 = value;
+      String[] texts2 = texts;
+      value--;
+      texts2[value3] = text3;
+    }
+    return texts;
+  }
+
+  public static int calculateCount(String text) {
+    String text2 = text.trim();
+    short value = 0;
+    if (text2.indexOf("public") >= 0) {
+      value = 1;
+    }
+    if (text2.indexOf("protected") >= 0) {
+      value |= 2;
+    }
+    if (text2.indexOf("package") >= 0) {
+      value |= 4;
+    }
+    if (text2.indexOf("private") >= 0) {
+      value |= 8;
+    }
+    if (text2.indexOf("protected+") >= 0) {
+      value |= 3;
+    }
+    if (text2.indexOf("package+") >= 0) {
+      value |= 7;
+    }
+    if (text2.indexOf("private+") >= 0) {
+      value |= 15;
+    }
+    if (value == 0) {
+      value = 15;
+    }
+    if (text2.indexOf("static") >= 0) {
+      value |= 16;
+    }
+    if (text2.indexOf("final") >= 0) {
+      value |= 32;
+    }
+    if (text2.indexOf("synchronized") >= 0) {
+      value |= 64;
+    }
+    if (text2.indexOf("volatile") >= 0) {
+      value |= 128;
+    }
+    if (text2.indexOf("transient") >= 0) {
+      value |= 256;
+    }
+    if (text2.indexOf("native") >= 0) {
+      value |= 512;
+    }
+    if (text2.indexOf("interface") >= 0) {
+      value |= 1024;
+    }
+    if (text2.indexOf("abstract") >= 0) {
+      value |= 2048;
+    }
+    if (text2.indexOf("strictfp") >= 0) {
+      value |= 4096;
+    }
+    if (text2.indexOf("enum") >= 0) {
+      value |= 8192;
+    }
+    return value;
+  }
+
+  public static boolean matches2(String text) {
+    return text.charAt(0) == '@';
+  }
+
+  public static boolean matches3(String text) {
+    if (text.indexOf("public") >= 0) {
+      return true;
+    } else if (text.indexOf("protected") >= 0) {
+      return true;
+    } else if (text.indexOf("package") >= 0) {
+      return true;
+    } else if (text.indexOf("private") >= 0) {
+      return true;
+    } else if (text.indexOf("static") >= 0) {
+      return true;
+    } else if (text.indexOf("final") >= 0) {
+      return true;
+    } else if (text.indexOf("synchronized") >= 0) {
+      return true;
+    } else if (text.indexOf("volatile") >= 0) {
+      return true;
+    } else if (text.indexOf("transient") >= 0) {
+      return true;
+    } else if (text.indexOf("native") >= 0) {
+      return true;
+    } else if (text.indexOf("interface") >= 0) {
+      return true;
+    } else if (text.indexOf("abstract") >= 0) {
+      return true;
+    } else {
+      return text.indexOf("strictfp") >= 0 ? true : text.indexOf("enum") >= 0;
+    }
+  }
+
+  public static boolean matches(AnnotationEntryGen[] annotationEntryGens, String text) {
+    if (text == null) {
+      return true;
+    }
+    int value;
+    for (int value2 = value = annotationEntryGens.length - 1; value2 >= 0; value2 = --value) {
+      try {
+        if (annotationEntryGens[value].getText2().matches(text)) {
+          return true;
+        }
+      } catch (ClassCastException classCastException) {
+        throw classCastException;
+      }
+    }
+    return false;
+  }
+
+  public static boolean matches(ClassStorage classStorage, String text, String text2) {
+    if (text == null) {
+      return false;
+    }
+    if (text.matches(text2)) {
+      return true;
+    }
+    ClassGen classGen;
+    if ((classGen = classStorage.getClassGen(text)) != null) {
+      int value;
+      String[] texts;
+      for (int value2 = value = (texts = classGen.getInterfaceNames()).length - 1;
+          value2 >= 0;
+          value2 = --value) {
+        if (matches(classStorage, texts[value], text2)) {
+          return true;
+        }
+      }
+      return matches(classStorage, classGen.getSuperclassName(), text2);
+    } else {
+      try {
+        int value3;
+        Class classValue;
+        Class[] classs;
+        for (int value4 =
+                value3 =
+                    (classs =
+                                (classValue =
+                                        Class.forName(text, false, classStorage.getClassLoader()))
+                                    .getInterfaces())
+                            .length
+                        - 1;
+            value4 >= 0;
+            value4 = --value3) {
+          if (matches(classStorage, classs[value3].getName(), text2)) {
+            return true;
+          }
+        }
+        return classValue.getSuperclass() != null
+            ? matches(classStorage, classValue.getSuperclass().getName(), text2)
+            : false;
+      } catch (ClassNotFoundException classNotFoundException) {
+        return true;
+      } catch (SecurityException securityException) {
+        Log.error("Cannot read class: " + text);
+        throw securityException;
+      }
+    }
+  }
+
+  public static boolean matches(Type[] types, String text) {
+    StringBuffer stringBuffer = new StringBuffer("");
+    int value;
+    for (int value2 = value = types.length - 1; value2 >= 0; value2 = value) {
+      StringBuilder stringBuilder = new StringBuilder().append(types[value].toString());
+      value--;
+      stringBuffer.insert((byte) 0, stringBuilder.append((String) ",").toString());
+    }
+    if (stringBuffer.length() > 0) {
+      stringBuffer.deleteCharAt(stringBuffer.length() - 1);
+    }
+    return stringBuffer.toString().matches(text);
+  }
+
+  public static String getText4(String text) {
+    return text.replaceAll("\\s+", "")
+        .replaceAll("\\[", "\\\\[")
+        .replaceAll("]", "\\\\]")
+        .replaceAll("\\.", "\\\\.")
+        .replaceAll("\\*\\*", "%@#")
+        .replaceAll("\\*", "[^,]*")
+        .replaceAll("\\%\\@\\#", ".*");
+  }
+
+  public static boolean matches(AccessFlags accessFlags, int value) {
+    if (accessFlags.isEnabled6()) {
+      if ((value & 1) == 0) {
+        return false;
+      }
+    } else if (accessFlags.isEnabled13()) {
+      if ((value & 2) == 0) {
+        return false;
+      }
+    } else if (accessFlags.isEnabled9()) {
+      if ((value & 8) == 0) {
+        return false;
+      }
+    } else if ((value & 4) == 0) {
+      return false;
+    }
+    if ((value & 16) > 0 && !accessFlags.isEnabled11()) {
+      return false;
+    } else if ((value & 32) > 0 && !accessFlags.isEnabled3()) {
+      return false;
+    } else if ((value & 64) > 0 && !accessFlags.isEnabled12()) {
+      return false;
+    } else if ((value & 128) > 0 && !accessFlags.isEnabled()) {
+      return false;
+    } else if ((value & 256) > 0 && !accessFlags.isEnabled4()) {
+      return false;
+    } else if ((value & 512) > 0 && !accessFlags.isEnabled14()) {
+      return false;
+    } else if ((value & 1024) > 0 && !accessFlags.isEnabled5()) {
+      return false;
+    } else if ((value & 2048) > 0 && !accessFlags.isEnabled15()) {
+      return false;
+    } else {
+      return (value & 4096) > 0 && !accessFlags.isEnabled7()
+          ? false
+          : (value & 8192) <= 0 || accessFlags.isEnabled10();
+    }
+  }
+}

src/main/java/com/allatori/crypto/CustomStringEncryption.java

@@ -0,0 +1,120 @@
+package com.allatori.crypto;
+
+import com.allatori.config.Configuration;
+import com.allatori.lib.bcel.generic.InstructionFactory;
+import com.allatori.lib.bcel.generic.InvokeInstruction;
+import com.allatori.lib.bcel.generic.Type;
+import com.allatori.util.Log;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+
+public class CustomStringEncryption {
+
+  public static String text = "allatori-custom-12321-32123:";
+
+  public static String createText(
+      String text, ClassLoader classLoader, String text2, String text3) {
+    String text4 = text;
+    String[] texts = null;
+    try {
+      int value = Integer.parseInt(text4.substring(text4.indexOf(91) + 1, text4.indexOf(93)));
+      text4 = text4.substring(text4.indexOf(93) + 1);
+      String text5;
+      if ((text5 =
+              (String)
+                  Class.forName(
+                          (texts =
+                                  (String[])
+                                      Configuration.getObfuscationOptions().getEntries().get(value))
+                              [0],
+                          true,
+                          classLoader)
+                      .getDeclaredMethod(texts[1], String.class, String.class, String.class)
+                      .invoke(null, text4, text2, text3))
+          == null) {
+        Log.error(
+            "Custom string encryption error: null value is returned by "
+                + texts[0]
+                + "."
+                + texts[1]
+                + "()");
+        throw new NullPointerException();
+      } else {
+        return text5;
+      }
+    } catch (ClassNotFoundException classNotFoundException) {
+      Log.error("Cannot load custom string encryption class (class not found): " + texts[0]);
+      return text4;
+    } catch (NoSuchMethodException noSuchMethodException) {
+      Log.error("Cannot find custom string encryption method: " + texts[0] + "." + texts[1] + "()");
+      return text4;
+    } catch (Exception exception) {
+      Log.error("Custom string encryption error: " + exception.getMessage());
+      return text4;
+    }
+  }
+
+  public static InvokeInstruction getInvokeInstruction(
+      InstructionFactory instructionFactory, int value) {
+    String[] texts = (String[]) Configuration.getObfuscationOptions().getEntries().get(value);
+    return instructionFactory.createInvoke(
+        texts[2], texts[3], Type.STRING, new Type[] {Type.STRING}, (short) 184);
+  }
+
+  public static String createText(String text2, int value, ClassLoader classLoader) {
+    String[] texts = (String[]) Configuration.getObfuscationOptions().getEntries().get(value);
+    try {
+      Class classValue = Class.forName(texts[0], true, classLoader);
+      try {
+        Method method;
+        if (!Modifier.isStatic(
+                (method = classValue.getDeclaredMethod(texts[1], String.class)).getModifiers())
+            || !Modifier.isPublic(method.getModifiers())) {
+          Log.error(
+              "Custom string encryption method is not static and public: "
+                  + texts[0]
+                  + "."
+                  + texts[1]
+                  + "()");
+        }
+        String text3;
+        if ((text3 = (String) method.invoke(null, text2)) == null) {
+          Log.error(
+              "Custom string encryption error: null value is returned by "
+                  + texts[0]
+                  + "."
+                  + texts[1]
+                  + "()");
+          throw new NullPointerException();
+        } else {
+          return text3;
+        }
+      } catch (NoSuchMethodException noSuchMethodException) {
+        Method method2;
+        if (!Modifier.isStatic(
+                (method2 =
+                        classValue.getDeclaredMethod(
+                            texts[1], String.class, String.class, String.class))
+                    .getModifiers())
+            || !Modifier.isPublic(method2.getModifiers())) {
+          Log.error(
+              "Custom string encryption method is not static and public: "
+                  + texts[0]
+                  + "."
+                  + texts[1]
+                  + "()");
+        }
+        return "" + text + '[' + value + ']' + text2;
+      }
+    } catch (ClassNotFoundException classNotFoundException) {
+      Log.error("Cannot load custom string encryption class (class not found): " + texts[0]);
+      return text2;
+    } catch (NoSuchMethodException noSuchMethodException2) {
+      Log.error("Cannot find custom string encryption method: " + texts[0] + "." + texts[1] + "()");
+      return text2;
+    } catch (Exception exception) {
+      Log.error("Custom string encryption error: " + exception.getMessage());
+      return text2;
+    }
+  }
+}

src/main/java/com/allatori/crypto/StringEncryptionUtils.java

@@ -0,0 +1,738 @@
+package com.allatori.crypto;
+
+import com.allatori.bytecode.MethodFactory;
+import com.allatori.config.Configuration;
+import com.allatori.lib.bcel.classfile.Attribute;
+import com.allatori.lib.bcel.classfile.Constant;
+import com.allatori.lib.bcel.classfile.ConstantPool;
+import com.allatori.lib.bcel.classfile.ConstantString;
+import com.allatori.lib.bcel.classfile.ConstantUtf8;
+import com.allatori.lib.bcel.classfile.ConstantValue;
+import com.allatori.lib.bcel.classfile.Field;
+import com.allatori.lib.bcel.classfile.Method;
+import com.allatori.lib.bcel.classfile.SourceFile;
+import com.allatori.lib.bcel.classfile.StackMap;
+import com.allatori.lib.bcel.classfile.StackMapEntry;
+import com.allatori.lib.bcel.classfile.StackMapType;
+import com.allatori.lib.bcel.generic.ArrayType;
+import com.allatori.lib.bcel.generic.BranchInstruction;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.lib.bcel.generic.ConstantPoolGen;
+import com.allatori.lib.bcel.generic.FieldGen;
+import com.allatori.lib.bcel.generic.FieldInstruction;
+import com.allatori.lib.bcel.generic.GETFIELD;
+import com.allatori.lib.bcel.generic.GETSTATIC;
+import com.allatori.lib.bcel.generic.IF_ACMPEQ;
+import com.allatori.lib.bcel.generic.IF_ACMPNE;
+import com.allatori.lib.bcel.generic.IINC;
+import com.allatori.lib.bcel.generic.Instruction;
+import com.allatori.lib.bcel.generic.InstructionConstants;
+import com.allatori.lib.bcel.generic.InstructionFactory;
+import com.allatori.lib.bcel.generic.InstructionHandle;
+import com.allatori.lib.bcel.generic.InstructionList;
+import com.allatori.lib.bcel.generic.InstructionTargeter;
+import com.allatori.lib.bcel.generic.LDC;
+import com.allatori.lib.bcel.generic.LineNumberGen;
+import com.allatori.lib.bcel.generic.MethodGen;
+import com.allatori.lib.bcel.generic.PUSH;
+import com.allatori.lib.bcel.generic.PUTFIELD;
+import com.allatori.lib.bcel.generic.PUTSTATIC;
+import com.allatori.lib.bcel.generic.Type;
+import com.allatori.util.Log;
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.util.Collection;
+import java.util.Vector;
+import java.util.regex.Pattern;
+
+public class StringEncryptionUtils {
+
+  public static Vector values = new Vector();
+
+  public static boolean matchesText(Vector vector, String text) {
+    if ("000".equals(text)) {
+      return false;
+    }
+    if ("001".equals(text)) {
+      vector.add(InstructionConstants.ICONST_1);
+    } else if ("010".equals(text)) {
+      vector.add(InstructionConstants.ICONST_2);
+    } else if ("011".equals(text)) {
+      vector.add(InstructionConstants.ICONST_3);
+    } else if ("100".equals(text)) {
+      vector.add(InstructionConstants.ICONST_4);
+    } else if ("101".equals(text)) {
+      vector.add(InstructionConstants.ICONST_5);
+    } else if ("110".equals(text)) {
+      vector.add(InstructionConstants.ICONST_3);
+      vector.add(InstructionConstants.ICONST_5);
+      vector.add(InstructionConstants.IXOR);
+    } else if ("111".equals(text)) {
+      vector.add(InstructionConstants.ICONST_2);
+      vector.add(InstructionConstants.ICONST_5);
+      vector.add(InstructionConstants.IXOR);
+    }
+    return true;
+  }
+
+  public static void processCollection(ClassGen classGen, Collection values) {
+    InstructionHandle instructionHandle;
+    int value;
+    Field[] fields;
+    for (int value2 = value = (fields = classGen.getFields()).length - 1;
+        value2 >= 0;
+        value2 = --value) {
+      Constant constant;
+      ConstantValue constantValue;
+      if ((constantValue = fields[value].getConstantValue()) != null
+          && (constant =
+                  classGen.getConstantPool().getConstant(constantValue.getConstantValueIndex()))
+              instanceof ConstantString) {
+        String bytes =
+            ((ConstantUtf8)
+                    classGen
+                        .getConstantPool()
+                        .getConstant(((ConstantString) constant).getStringIndex()))
+                .getBytes();
+        values.add(bytes);
+      }
+    }
+    Method[] methods;
+    int value3;
+    for (int value4 = value3 = (methods = classGen.getMethods()).length - 1;
+        value4 >= 0;
+        value4 = --value3) {
+      Method method;
+      if ((method = methods[value3]).getCode() != null) {
+        InstructionList instructionList;
+        InstructionHandle instructionHandle2;
+        InstructionHandle instructionHandle3 =
+            instructionHandle2 =
+                (instructionList =
+                        MethodFactory.createMethodGen(
+                                method,
+                                classGen.getClassName(),
+                                classGen.getConstantPool(),
+                                classGen.getConstantPool().getConstantPool())
+                            .getInstructionList())
+                    .getStart();
+        while (instructionHandle3 != null) {
+          label119:
+          {
+            if (instructionHandle2.getInstruction() instanceof PUTSTATIC
+                || instructionHandle2.getInstruction() instanceof PUTFIELD) {
+              if (instructionHandle2.getInstructionHandle() == null) {
+                instructionHandle = instructionHandle2;
+                break label119;
+              }
+              InstructionHandle instructionHandle4;
+              if ((instructionHandle4 = instructionHandle2.getInstructionHandle()).getInstruction()
+                  instanceof LDC) {
+                LDC lDC = (LDC) instructionHandle4.getInstruction();
+                Constant constant2;
+                if ((constant2 = classGen.getConstantPool().getConstant(lDC.getIndex()))
+                    instanceof ConstantString) {
+                  String bytes2 =
+                      ((ConstantUtf8)
+                              classGen
+                                  .getConstantPool()
+                                  .getConstant(((ConstantString) constant2).getStringIndex()))
+                          .getBytes();
+                  values.add(bytes2);
+                }
+              }
+            }
+            instructionHandle = instructionHandle2;
+          }
+          instructionHandle3 = instructionHandle2 = instructionHandle.getInstructionHandle2();
+        }
+        InstructionHandle instructionHandle5;
+        InstructionHandle instructionHandle6 = instructionHandle5 = instructionList.getStart();
+        while (instructionHandle6 != null) {
+          InstructionHandle instructionHandle7;
+          if (!(instructionHandle5.getInstruction() instanceof LDC)) {
+            instructionHandle7 = instructionHandle5;
+          } else {
+            LDC lDC2 = (LDC) instructionHandle5.getInstruction();
+            Constant constant3;
+            if (!((constant3 = classGen.getConstantPool().getConstant(lDC2.getIndex()))
+                instanceof ConstantString)) {
+              instructionHandle7 = instructionHandle5;
+            } else {
+              ConstantPoolGen constantPool = classGen.getConstantPool();
+              int value5 = lDC2.produceStack(constantPool);
+              InstructionHandle instructionHandle22 = instructionHandle5.getInstructionHandle2();
+              int value6 = 0;
+              while (true) {
+                if (instructionHandle22 != null) {
+                  int value7 = instructionHandle22.getInstruction().produceStack(constantPool);
+                  int value8 = instructionHandle22.getInstruction().consumeStack(constantPool);
+                  if (value7 != -2) {
+                    if (value8 == -2) {
+                      instructionHandle7 = instructionHandle5;
+                      break;
+                    }
+                    int value9;
+                    if ((value9 = value5 - value8) > 0) {
+                      value5 = value9 + value7;
+                      instructionHandle22 = instructionHandle22.getInstructionHandle2();
+                      int value10 = value6++;
+                      if (value10 > (byte) 33) {
+                        instructionHandle7 = instructionHandle5;
+                        break;
+                      }
+                      continue;
+                    }
+                    Instruction instruction;
+                    if ((instruction = instructionHandle22.getInstruction()) instanceof IF_ACMPEQ
+                        || instruction instanceof IF_ACMPNE) {
+                      String bytes3 =
+                          ((ConstantUtf8)
+                                  classGen
+                                      .getConstantPool()
+                                      .getConstant(((ConstantString) constant3).getStringIndex()))
+                              .getBytes();
+                      instructionHandle7 = instructionHandle5;
+                      values.add(bytes3);
+                      break;
+                    }
+                  }
+                }
+                instructionHandle7 = instructionHandle5;
+                break;
+              }
+            }
+          }
+          instructionHandle6 = instructionHandle5 = instructionHandle7.getInstructionHandle2();
+        }
+      }
+    }
+  }
+
+  public static void update() {
+    values = new Vector();
+    if (Configuration.getObfuscationOptions().getStringEncryptionIgnoredStrings() != null) {
+      BufferedReader bufferedReader;
+      try {
+        for (String text =
+                (bufferedReader =
+                        new BufferedReader(
+                            new FileReader(
+                                Configuration.getObfuscationOptions()
+                                    .getStringEncryptionIgnoredStrings())))
+                    .readLine();
+            text != null;
+            text = bufferedReader.readLine()) {
+          if (text.length() > 0) {
+            String text2;
+            if (text.startsWith("regex:")) {
+              text2 = text.substring(6);
+            } else {
+              text2 = text.replaceAll("\\.", "\\\\.").replaceAll("\\*", ".*");
+            }
+            values.add(Pattern.compile(text2, 32));
+          }
+        }
+      } catch (Exception exception) {
+        exception.printStackTrace();
+      }
+    }
+  }
+
+  public static void processCharacter(ClassGen classGen, String text, char value) {
+    InstructionFactory instructionFactory = new InstructionFactory(classGen);
+    ConstantPoolGen constantPool = classGen.getConstantPool();
+    InstructionList instructionList = new InstructionList();
+    MethodGen methodGen =
+        new MethodGen(
+            9,
+            Type.STRING,
+            new Type[] {Type.STRING},
+            new String[] {"s"},
+            text,
+            classGen.getClassName(),
+            instructionList,
+            constantPool);
+    int value2 = constantPool.addClass("java.lang.String");
+    int value3 = constantPool.addClass("[C");
+    int value4 = constantPool.addUtf8("StackMap");
+    ConstantPool constantPool2 = constantPool.getConstantPool();
+    StackMapType[] stackMapTypes = new StackMapType[4];
+    stackMapTypes[0] = new StackMapType((byte) 7, value2, constantPool2);
+    stackMapTypes[1] = new StackMapType((byte) 7, value3, constantPool2);
+    stackMapTypes[2] = new StackMapType((byte) 1, 0, constantPool2);
+    stackMapTypes[3] = new StackMapType((byte) 1, 0, constantPool2);
+    StackMapEntry stackMapEntry =
+        new StackMapEntry(27, 4, stackMapTypes, 0, new StackMapType[0], constantPool2);
+    StackMapEntry stackMapEntry2 =
+        new StackMapEntry(
+            58,
+            4,
+            new StackMapType[] {
+              new StackMapType((byte) 7, value2, constantPool2),
+              new StackMapType((byte) 7, value3, constantPool2),
+              new StackMapType((byte) 1, 0, constantPool2),
+              new StackMapType((byte) 1, 0, constantPool2)
+            },
+            0,
+            new StackMapType[0],
+            constantPool2);
+    StackMap stackMap =
+        new StackMap(
+            value4, 30, new StackMapEntry[] {stackMapEntry, stackMapEntry2}, constantPool2);
+    methodGen.addCodeAttribute(stackMap);
+    instructionList.getInstructionHandle(
+        InstructionFactory.createLocalVariableInstruction2(Type.OBJECT, 0));
+    instructionList.getInstructionHandle(
+        instructionFactory.createInvoke(
+            "java.lang.String", "length", Type.INT, Type.NO_ARGS, (short) 182));
+    instructionList.getInstructionHandle(instructionFactory.createNewArray(Type.CHAR, (short) 1));
+    instructionList.getInstructionHandle(new PUSH(constantPool, 1));
+    instructionList.getInstructionHandle(InstructionConstants.DUP);
+    instructionList.getInstructionHandle(InstructionConstants.POP2);
+    instructionList.getInstructionHandle(
+        InstructionFactory.createLocalVariableInstruction(Type.OBJECT, 1));
+    instructionList.getInstructionHandle(new PUSH(constantPool, value));
+    instructionList.getInstructionHandle(new PUSH(constantPool, 1));
+    instructionList.getInstructionHandle(InstructionConstants.DUP);
+    instructionList.getInstructionHandle(InstructionConstants.POP2);
+    instructionList.getInstructionHandle(
+        InstructionFactory.createLocalVariableInstruction(Type.INT, 2));
+    instructionList.getInstructionHandle(
+        InstructionFactory.createLocalVariableInstruction2(Type.OBJECT, 1));
+    instructionList.getInstructionHandle(InstructionConstants.ARRAYLENGTH);
+    instructionList.getInstructionHandle(new PUSH(constantPool, 1));
+    instructionList.getInstructionHandle(new PUSH(constantPool, 1));
+    instructionList.getInstructionHandle(InstructionConstants.DUP);
+    instructionList.getInstructionHandle(InstructionConstants.POP2);
+    instructionList.getInstructionHandle(InstructionConstants.ISUB);
+    instructionList.getInstructionHandle(
+        InstructionFactory.createLocalVariableInstruction(Type.INT, 3));
+    BranchInstruction branchInstruction =
+        InstructionFactory.createBranchInstruction((short) 167, null);
+    instructionList.getBranchHandle(branchInstruction);
+    InstructionHandle instructionHandle =
+        instructionList.getInstructionHandle(
+            InstructionFactory.createLocalVariableInstruction2(Type.OBJECT, 1));
+    instructionList.getInstructionHandle(
+        InstructionFactory.createLocalVariableInstruction2(Type.INT, 3));
+    instructionList.getInstructionHandle(
+        InstructionFactory.createLocalVariableInstruction2(Type.OBJECT, 0));
+    instructionList.getInstructionHandle(
+        InstructionFactory.createLocalVariableInstruction2(Type.INT, 3));
+    instructionList.getInstructionHandle(
+        instructionFactory.createInvoke(
+            "java.lang.String", "charAt", Type.CHAR, new Type[] {Type.INT}, (short) 182));
+    instructionList.getInstructionHandle(
+        InstructionFactory.createLocalVariableInstruction2(Type.INT, 2));
+    instructionList.getInstructionHandle(InstructionConstants.IXOR);
+    instructionList.getInstructionHandle(InstructionConstants.I2C);
+    instructionList.getInstructionHandle(new PUSH(constantPool, 1));
+    instructionList.getInstructionHandle(InstructionConstants.DUP);
+    instructionList.getInstructionHandle(InstructionConstants.POP2);
+    instructionList.getInstructionHandle(InstructionConstants.CASTORE);
+    instructionList.getInstructionHandle(
+        InstructionFactory.createLocalVariableInstruction2(Type.INT, 2));
+    instructionList.getInstructionHandle(
+        InstructionFactory.createLocalVariableInstruction2(Type.INT, 3));
+    instructionList.getInstructionHandle(InstructionConstants.IXOR);
+    instructionList.getInstructionHandle(InstructionConstants.I2C);
+    instructionList.getInstructionHandle(
+        InstructionFactory.createLocalVariableInstruction(Type.INT, 2));
+    instructionList.getInstructionHandle(
+        InstructionFactory.createLocalVariableInstruction2(Type.INT, 2));
+    instructionList.getInstructionHandle(new PUSH(constantPool, 63));
+    instructionList.getInstructionHandle(new PUSH(constantPool, 1));
+    instructionList.getInstructionHandle(InstructionConstants.DUP);
+    instructionList.getInstructionHandle(InstructionConstants.POP2);
+    instructionList.getInstructionHandle(InstructionConstants.IAND);
+    instructionList.getInstructionHandle(InstructionConstants.I2C);
+    instructionList.getInstructionHandle(
+        InstructionFactory.createLocalVariableInstruction(Type.INT, 2));
+    instructionList.getInstructionHandle(new IINC(3, -1));
+    InstructionHandle instructionHandle2 =
+        instructionList.getInstructionHandle(
+            InstructionFactory.createLocalVariableInstruction2(Type.INT, 3));
+    instructionList.getBranchHandle(
+        InstructionFactory.createBranchInstruction((short) 156, instructionHandle));
+    instructionList.getInstructionHandle(instructionFactory.createNew("java.lang.String"));
+    instructionList.getInstructionHandle(InstructionConstants.DUP);
+    instructionList.getInstructionHandle(
+        InstructionFactory.createLocalVariableInstruction2(Type.OBJECT, 1));
+    instructionList.getInstructionHandle(
+        instructionFactory.createInvoke(
+            "java.lang.String",
+            "<init>",
+            Type.VOID,
+            new Type[] {new ArrayType(Type.CHAR, 1)},
+            (short) 183));
+    instructionList.getInstructionHandle(InstructionFactory.createReturn(Type.OBJECT));
+    branchInstruction.setTarget(instructionHandle2);
+    methodGen.update5();
+    methodGen.update4();
+    classGen.processMethod2(methodGen.getMethod());
+    instructionList.update3();
+  }
+
+  public static boolean matchesText(String text) {
+    int value;
+    for (int value2 = value = values.size() - 1; value2 >= 0; value2 = --value) {
+      if (((Pattern) values.get(value)).matcher(text).matches()) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  public static boolean matchesText2(Vector vector, String text) {
+    if ("00".equals(text)) {
+      return false;
+    }
+    if ("01".equals(text)) {
+      vector.add(InstructionConstants.ICONST_1);
+    } else if ("10".equals(text)) {
+      vector.add(InstructionConstants.ICONST_2);
+    } else if ("11".equals(text)) {
+      vector.add(InstructionConstants.ICONST_3);
+    }
+    return true;
+  }
+
+  public static Vector createValues(int value) {
+    Vector vector = new Vector();
+    String text;
+    String text2 = text = Integer.toBinaryString(value);
+    while (text2.length() < 7) {
+      text2 = text = "0" + text;
+    }
+    if (text.startsWith("0")) {
+      boolean matches;
+      if (matches = matchesText(vector, text.substring(1, 4))) {
+        vector.add(InstructionConstants.ICONST_3);
+        vector.add(InstructionConstants.ISHL);
+      }
+      if (matchesText(vector, text.substring(4, 7)) && matches) {
+        vector.add(InstructionConstants.IXOR);
+      }
+      return vector;
+    } else if (text.endsWith("0")) {
+      boolean matches2;
+      if (matches2 = matchesText(vector, text.substring(0, 3))) {
+        vector.add(InstructionConstants.ICONST_4);
+        vector.add(InstructionConstants.ISHL);
+      }
+      if (matchesText(vector, text.substring(3, 6)) && matches2) {
+        vector.add(InstructionConstants.ICONST_1);
+        vector.add(InstructionConstants.ISHL);
+        vector.add(InstructionConstants.IXOR);
+      }
+      return vector;
+    } else if (text.charAt(3) == '0') {
+      boolean matches3;
+      if (matches3 = matchesText(vector, text.substring(0, 3))) {
+        vector.add(InstructionConstants.ICONST_4);
+        vector.add(InstructionConstants.ISHL);
+      }
+      if (matchesText(vector, text.substring(4, 7)) && matches3) {
+        vector.add(InstructionConstants.IXOR);
+      }
+      return vector;
+    } else {
+      matchesText(vector, text.substring(0, 3));
+      vector.add(InstructionConstants.ICONST_4);
+      vector.add(InstructionConstants.ISHL);
+      boolean matches4 = matchesText2(vector, text.substring(3, 5));
+      if (matches4) {
+        vector.add(InstructionConstants.ICONST_2);
+        vector.add(InstructionConstants.ISHL);
+      }
+      if (matchesText2(vector, text.substring(5, 7))) {
+        vector.add(InstructionConstants.IXOR);
+      }
+      if (matches4) {
+        vector.add(InstructionConstants.IXOR);
+      }
+      return vector;
+    }
+  }
+
+  public static String getText(ClassGen classGen) {
+    Attribute[] attributes;
+    if ((attributes = classGen.getAttributes()) == null) {
+      return "Unknown Source";
+    }
+    int value;
+    for (int value2 = value = attributes.length - 1; value2 >= 0; value2 = --value) {
+      if (attributes[value] instanceof SourceFile) {
+        return ((SourceFile) attributes[value]).getText();
+      }
+    }
+    return "Unknown Source";
+  }
+
+  public static void processClassGen(ClassGen classGen) {
+    Method[] methods;
+    int value;
+    for (int value2 = value = (methods = classGen.getMethods()).length - 1;
+        value2 >= 0;
+        value2 = --value) {
+      Method method;
+      if ((method = methods[value]).getCode() != null) {
+        InstructionHandle instructionHandle;
+        InstructionList instructionList;
+        InstructionHandle instructionHandle2 =
+            instructionHandle =
+                (instructionList =
+                        MethodFactory.createMethodGen(
+                                method,
+                                classGen.getClassName(),
+                                classGen.getConstantPool(),
+                                classGen.getConstantPool().getConstantPool())
+                            .getInstructionList())
+                    .getStart();
+        while (instructionHandle2 != null) {
+          InstructionHandle instructionHandle3;
+          if (!(instructionHandle.getInstruction() instanceof LDC)) {
+            instructionHandle3 = instructionHandle;
+          } else {
+            LDC lDC = (LDC) instructionHandle.getInstruction();
+            if (!(classGen.getConstantPool().getConstant(lDC.getIndex())
+                instanceof ConstantString)) {
+              instructionHandle3 = instructionHandle;
+            } else {
+              label145:
+              {
+                ConstantPoolGen constantPool = classGen.getConstantPool();
+                int value3 = lDC.produceStack(constantPool);
+                InstructionHandle instructionHandle22 = instructionHandle.getInstructionHandle2();
+                int value4 = 0;
+                while (instructionHandle22 != null) {
+                  int value5 = instructionHandle22.getInstruction().produceStack(constantPool);
+                  int value6 = instructionHandle22.getInstruction().consumeStack(constantPool);
+                  if (value5 == -2) {
+                    break;
+                  }
+                  if (value6 == -2) {
+                    instructionHandle3 = instructionHandle;
+                    break label145;
+                  }
+                  int value7;
+                  if ((value7 = value3 - value6) <= 0) {
+                    Instruction instruction;
+                    if (!((instruction = instructionHandle22.getInstruction()) instanceof IF_ACMPEQ)
+                        && !(instruction instanceof IF_ACMPNE)) {
+                      break;
+                    }
+                    int value8;
+                    do {
+                      value8 = calculateCount(instructionHandle22);
+                    } while ((instructionHandle22 = instructionHandle22.getInstructionHandle())
+                            != null
+                        && value8 == -1);
+                    String text =
+                        ""
+                            + classGen.getClassName()
+                            + "."
+                            + method.getText()
+                            + "("
+                            + getText(classGen);
+                    if (value8 != -1) {
+                      text = "" + text + ":" + value8;
+                    }
+                    String text2 = "" + text + ")";
+                    Log.warn("Comparing strings using '==' operator at " + text2);
+                    instructionHandle3 = instructionHandle;
+                    break label145;
+                  }
+                  value3 = value7 + value5;
+                  instructionHandle22 = instructionHandle22.getInstructionHandle2();
+                  int value9 = value4++;
+                  if (value9 > (byte) 33) {
+                    instructionHandle3 = instructionHandle;
+                    break label145;
+                  }
+                }
+                instructionHandle3 = instructionHandle;
+              }
+            }
+          }
+          instructionHandle2 = instructionHandle = instructionHandle3.getInstructionHandle2();
+        }
+        InstructionHandle instructionHandle4;
+        InstructionHandle instructionHandle5 = instructionHandle4 = instructionList.getStart();
+        while (instructionHandle5 != null) {
+          InstructionHandle instructionHandle6;
+          if (!(instructionHandle4.getInstruction() instanceof GETSTATIC)
+              && !(instructionHandle4.getInstruction() instanceof GETFIELD)) {
+            instructionHandle6 = instructionHandle4;
+          } else {
+            FieldInstruction fieldInstruction =
+                (FieldInstruction) instructionHandle4.getInstruction();
+            ConstantPoolGen constantPool2 = classGen.getConstantPool();
+            if (!((String) "Ljava/lang/String;").equals(fieldInstruction.getText3(constantPool2))) {
+              instructionHandle6 = instructionHandle4;
+            } else {
+              label142:
+              {
+                int value10 = fieldInstruction.produceStack(constantPool2);
+                InstructionHandle instructionHandle23 = instructionHandle4.getInstructionHandle2();
+                int value11 = 0;
+                while (instructionHandle23 != null) {
+                  int value12 = instructionHandle23.getInstruction().produceStack(constantPool2);
+                  int value13 = instructionHandle23.getInstruction().consumeStack(constantPool2);
+                  if (value12 == -2) {
+                    break;
+                  }
+                  if (value13 == -2) {
+                    instructionHandle6 = instructionHandle4;
+                    break label142;
+                  }
+                  int value14;
+                  if ((value14 = value10 - value13) <= 0) {
+                    Instruction instruction2;
+                    if (!((instruction2 = instructionHandle23.getInstruction())
+                            instanceof IF_ACMPEQ)
+                        && !(instruction2 instanceof IF_ACMPNE)) {
+                      break;
+                    }
+                    int value15;
+                    do {
+                      value15 = calculateCount(instructionHandle23);
+                    } while ((instructionHandle23 = instructionHandle23.getInstructionHandle())
+                            != null
+                        && value15 == -1);
+                    String text3 =
+                        ""
+                            + classGen.getClassName()
+                            + "."
+                            + method.getText()
+                            + "("
+                            + getText(classGen);
+                    if (value15 != -1) {
+                      text3 = "" + text3 + ":" + value15;
+                    }
+                    String text4 = "" + text3 + ")";
+                    Log.warn("Comparing strings using '==' operator at " + text4);
+                    instructionHandle6 = instructionHandle4;
+                    break label142;
+                  }
+                  value10 = value14 + value12;
+                  instructionHandle23 = instructionHandle23.getInstructionHandle2();
+                  int value16 = value11++;
+                  if (value16 > (byte) 33) {
+                    instructionHandle6 = instructionHandle4;
+                    break label142;
+                  }
+                }
+                instructionHandle6 = instructionHandle4;
+              }
+            }
+          }
+          instructionHandle5 = instructionHandle4 = instructionHandle6.getInstructionHandle2();
+        }
+      }
+    }
+  }
+
+  public static int calculateCount(InstructionHandle instructionHandle) {
+    InstructionTargeter[] instructionTargeters;
+    if ((instructionTargeters = instructionHandle.getTargeters()) == null) {
+      return -1;
+    }
+    int value;
+    for (int value2 = value = instructionTargeters.length - 1; value2 >= 0; value2 = --value) {
+      if (instructionTargeters[value] instanceof LineNumberGen) {
+        return ((LineNumberGen) instructionTargeters[value]).getSourceLine();
+      }
+    }
+    return -1;
+  }
+
+  public static void processClassGen2(ClassGen classGen) {
+    int value;
+    Field[] fields;
+    for (int value2 = value = (fields = classGen.getFields()).length - 1;
+        value2 >= 0;
+        value2 = --value) {
+      Field field;
+      ConstantValue constantValue;
+      Constant constant;
+      if ((constantValue = (field = fields[value]).getConstantValue()) != null
+          && (constant =
+                  classGen.getConstantPool().getConstant(constantValue.getConstantValueIndex()))
+              instanceof ConstantString
+          && field.isEnabled3()) {
+        if (!field.isEnabled11()) {
+          FieldGen fieldGen = new FieldGen(field, classGen.getConstantPool());
+          fieldGen.cancelInitValue();
+          classGen.replaceField(field, fieldGen.getField());
+        } else {
+          Method method = null;
+          int value3;
+          Method[] methods;
+          for (int value4 = value3 = (methods = classGen.getMethods()).length - 1;
+              value4 >= 0;
+              value4 = --value3) {
+            Method method2 = methods[value3];
+            if ("<clinit>".equals(method2.getText())) {
+              method = method2;
+              break;
+            }
+          }
+          InstructionList instructionList = new InstructionList();
+          instructionList.getInstructionHandle4(InstructionFactory.createReturn(Type.VOID));
+          MethodGen methodGen;
+          ClassGen classGen2;
+          if (method != null) {
+            instructionList =
+                (methodGen =
+                        MethodFactory.createMethodGen(
+                            method,
+                            classGen.getClassName(),
+                            classGen.getConstantPool(),
+                            classGen.getConstantPool().getConstantPool()))
+                    .getInstructionList();
+            classGen2 = classGen;
+          } else {
+            methodGen =
+                new MethodGen(
+                    8,
+                    Type.VOID,
+                    Type.NO_ARGS,
+                    new String[0],
+                    "<clinit>",
+                    classGen.getClassName(),
+                    instructionList,
+                    classGen.getConstantPool());
+            classGen2 = classGen;
+          }
+          String bytes =
+              ((ConstantUtf8)
+                      classGen2
+                          .getConstantPool()
+                          .getConstant(((ConstantString) constant).getStringIndex()))
+                  .getBytes();
+          InstructionFactory instructionFactory = new InstructionFactory(classGen);
+          instructionList.getInstructionHandle4(
+              instructionFactory.createFieldAccess(
+                  classGen.getClassName(), field.getText(), Type.STRING, (short) 179));
+          instructionList.getInstructionHandle2(new PUSH(classGen.getConstantPool(), bytes));
+          methodGen.update5();
+          methodGen.update4();
+          InstructionList instructionList2;
+          if (method != null) {
+            classGen.replaceMethod(method, methodGen.getMethod());
+            instructionList2 = instructionList;
+          } else {
+            classGen.processMethod2(methodGen.getMethod());
+            instructionList2 = instructionList;
+          }
+          instructionList2.update3();
+          FieldGen fieldGen2 = new FieldGen(field, classGen.getConstantPool());
+          fieldGen2.cancelInitValue();
+          classGen.replaceField(field, fieldGen2.getField());
+        }
+      }
+    }
+  }
+}

src/main/java/com/allatori/eclipse/AllatoriBuilder.java

@@ -0,0 +1,152 @@
+package com.allatori.eclipse;
+
+import com.allatori.Obfuscate;
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.util.Map;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IncrementalProjectBuilder;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.jdt.core.IClasspathEntry;
+import org.eclipse.jdt.core.IJavaProject;
+import org.eclipse.jdt.core.JavaCore;
+
+public class AllatoriBuilder extends IncrementalProjectBuilder {
+
+  public static final String TEXT = "com.allatori.eclipse";
+
+  public IProject[] build(int value, Map entries, IProgressMonitor progressMonitor)
+      throws CoreException {
+    this.getProject();
+    switch (value) {
+      case 6:
+        this.processIProgressMonitor(progressMonitor);
+      case 7:
+      case 8:
+      case 9:
+      case 10:
+      default:
+        return null;
+    }
+  }
+
+  public void processIProgressMonitor(IProgressMonitor progressMonitor) throws CoreException {
+    try {
+      String text = this.getProject().getLocation().toString();
+      File file;
+      File file2;
+      if (!(file = new File(text + "/allatori.xml")).exists()) {
+        StringBuilder stringBuilder = new StringBuilder();
+        StringBuilder stringBuilder2 = new StringBuilder();
+        IClasspathEntry[] classpathEntrys;
+        IJavaProject javaProject;
+        int value =
+            (classpathEntrys =
+                    (javaProject = JavaCore.create(this.getProject())).getResolvedClasspath(true))
+                .length;
+        int value2;
+        for (int value3 = value2 = 0; value3 < value; value3 = ++value2) {
+          IClasspathEntry classpathEntry;
+          if ((classpathEntry = classpathEntrys[value2]).getEntryKind() == 3) {
+            if (classpathEntry.getOutputLocation() != null) {
+              String text2 = classpathEntry.getOutputLocation().removeFirstSegments(1).toString();
+              stringBuilder.append("        <dir in=\"" + text2 + "\" out=\"" + text2 + "\"/>\n");
+            }
+          } else if (classpathEntry.getEntryKind() == 1) {
+            stringBuilder2.append(
+                "        <jar name=\"" + classpathEntry.getPath().toString() + "\"/>\n");
+          }
+        }
+        if (javaProject.getOutputLocation() != null) {
+          String text3 = javaProject.getOutputLocation().removeFirstSegments(1).toString();
+          stringBuilder.append("        <dir in=\"" + text3 + "\" out=\"" + text3 + "\"/>\n");
+        }
+        String text4 =
+            "<config>\n    <input>\n"
+                + stringBuilder
+                + "    </input>\n\n"
+                + "    <classpath>\n"
+                + stringBuilder2
+                + "    </classpath>\n\n"
+                + "    <keep-names>\n"
+                + "        <class access=\"protected+\">\n"
+                + "            <field access=\"protected+\"/>\n"
+                + "            <method access=\"protected+\"/>\n"
+                + "        </class>\n"
+                + "    </keep-names>\n\n"
+                + "    <property name=\"log-file\" value=\"allatori-log.xml\"/>\n"
+                + "</config>\n";
+        BufferedWriter bufferedWriter =
+            new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF-8"));
+        file2 = file;
+        bufferedWriter.write(text4);
+        bufferedWriter.close();
+      } else {
+        StringBuffer stringBuffer = new StringBuffer((int) file.length());
+        int value4;
+        BufferedReader bufferedReader;
+        for (BufferedReader bufferedReader2 =
+                bufferedReader =
+                    new BufferedReader(new InputStreamReader(new FileInputStream(file), "UTF-8"));
+            (value4 = bufferedReader2.read()) != -1;
+            bufferedReader2 = bufferedReader) {
+          stringBuffer.append((char) value4);
+        }
+        bufferedReader.close();
+        String text5;
+        if ((text5 = stringBuffer.toString()).contains("${eclipse-")) {
+          StringBuilder stringBuilder3 = new StringBuilder();
+          StringBuilder stringBuilder4 = new StringBuilder();
+          IJavaProject javaProject2;
+          IClasspathEntry[] classpathEntrys2;
+          int value5 =
+              (classpathEntrys2 =
+                      (javaProject2 = JavaCore.create(this.getProject()))
+                          .getResolvedClasspath(true))
+                  .length;
+          int value6;
+          for (int value7 = value6 = 0; value7 < value5; value7 = ++value6) {
+            IClasspathEntry classpathEntry2;
+            if ((classpathEntry2 = classpathEntrys2[value6]).getEntryKind() == 3) {
+              if (classpathEntry2.getOutputLocation() != null) {
+                String text6 =
+                    classpathEntry2.getOutputLocation().removeFirstSegments(1).toString();
+                stringBuilder3.append(
+                    "        <dir in=\"" + text6 + "\" out=\"" + text6 + "\"/>\n");
+              }
+            } else if (classpathEntry2.getEntryKind() == 1) {
+              stringBuilder4.append(
+                  "        <jar name=\"" + classpathEntry2.getPath().toString() + "\"/>\n");
+            }
+          }
+          if (javaProject2.getOutputLocation() != null) {
+            String text7 = javaProject2.getOutputLocation().removeFirstSegments(1).toString();
+            stringBuilder3.append("        <dir in=\"" + text7 + "\" out=\"" + text7 + "\"/>\n");
+          }
+          String text8 =
+              text5
+                  .replace("${eclipse-input}", stringBuilder3)
+                  .replace("${eclipse-classpath}", stringBuilder4);
+          file = new File(text + "/allatori-resolved.xml");
+          BufferedWriter bufferedWriter2 =
+              new BufferedWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF-8"));
+          bufferedWriter2.write(text8);
+          bufferedWriter2.close();
+        }
+        file2 = file;
+      }
+      Obfuscate.run(file2);
+    } catch (Exception exception) {
+      exception.printStackTrace();
+      throw new CoreException(
+          new Status(4, "com.allatori.eclipse", 0, exception.getMessage(), exception));
+    }
+  }
+}

src/main/java/com/allatori/eclipse/AllatoriPropertyTester.java

@@ -0,0 +1,20 @@
+package com.allatori.eclipse;
+
+import org.eclipse.core.expressions.PropertyTester;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.runtime.Platform;
+
+public class AllatoriPropertyTester extends PropertyTester {
+
+  public static final String TEXT = "isEnabled";
+
+  public boolean test(Object result, String text, Object[] results, Object result2) {
+    IProject project;
+    return "isEnabled".equals(text)
+            && (project =
+                    (IProject) Platform.getAdapterManager().getAdapter(result, IProject.class))
+                != null
+        ? MenuAddBuilder.matchesIProject(project)
+        : false;
+  }
+}

src/main/java/com/allatori/eclipse/MenuAddBuilder.java

@@ -0,0 +1,84 @@
+package com.allatori.eclipse;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import org.eclipse.core.commands.AbstractHandler;
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.commands.IHandler;
+import org.eclipse.core.resources.ICommand;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IProjectDescription;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.jface.viewers.ISelection;
+import org.eclipse.jface.viewers.IStructuredSelection;
+import org.eclipse.ui.handlers.HandlerUtil;
+
+public class MenuAddBuilder extends AbstractHandler implements IHandler {
+
+  public static final boolean matchesIProject(IProject project) {
+    try {
+      ICommand[] commands;
+      int value = (commands = project.getDescription().getBuildSpec()).length;
+      int value2;
+      for (int value3 = value2 = 0; value3 < value; value3 = ++value2) {
+        ICommand command = commands[value2];
+        if ("com.allatori.eclipse".equals(command.getBuilderName())) {
+          return true;
+        }
+      }
+    } catch (CoreException coreException) {
+    }
+    return false;
+  }
+
+  public static IProject getIProject(ExecutionEvent executionEvent) {
+    ISelection selection;
+    if ((selection = HandlerUtil.getCurrentSelection(executionEvent))
+        instanceof IStructuredSelection) {
+      Object firstElement = ((IStructuredSelection) selection).getFirstElement();
+      return (IProject) Platform.getAdapterManager().getAdapter(firstElement, IProject.class);
+    } else {
+      return null;
+    }
+  }
+
+  public Object execute(ExecutionEvent executionEvent) {
+    IProject project;
+    if ((project = getIProject(executionEvent)) != null) {
+      try {
+        if (matchesIProject(project)) {
+          return null;
+        }
+        ICommand command;
+        IProjectDescription projectDescription;
+        (command = (projectDescription = project.getDescription()).newCommand())
+            .setBuilderName("com.allatori.eclipse");
+        ArrayList values;
+        (values = new ArrayList()).addAll(Arrays.asList(projectDescription.getBuildSpec()));
+        int value = 0;
+        Iterator iterator2 = values.iterator();
+        ArrayList values2;
+        label29:
+        {
+          for (Iterator iterator3 = iterator2; iterator3.hasNext(); iterator3 = iterator2) {
+            value++;
+            ICommand command2 = (ICommand) iterator2.next();
+            if ("org.eclipse.jdt.core.javabuilder".equals(command2.getBuilderName())) {
+              values2 = values;
+              break label29;
+            }
+          }
+          values2 = values;
+        }
+        values2.add(value, command);
+        projectDescription.setBuildSpec((ICommand[]) values.toArray(new ICommand[values.size()]));
+        project.setDescription(projectDescription, null);
+      } catch (CoreException coreException) {
+        coreException.printStackTrace();
+      }
+    }
+    return null;
+  }
+}

src/main/java/com/allatori/eclipse/MenuRemoveBuilder.java

@@ -0,0 +1,39 @@
+package com.allatori.eclipse;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import org.eclipse.core.commands.AbstractHandler;
+import org.eclipse.core.commands.ExecutionEvent;
+import org.eclipse.core.commands.IHandler;
+import org.eclipse.core.resources.ICommand;
+import org.eclipse.core.resources.IProject;
+import org.eclipse.core.resources.IProjectDescription;
+import org.eclipse.core.runtime.CoreException;
+
+public class MenuRemoveBuilder extends AbstractHandler implements IHandler {
+
+  public Object execute(ExecutionEvent executionEvent) {
+    IProject project;
+    if ((project = MenuAddBuilder.getIProject(executionEvent)) != null) {
+      try {
+        IProjectDescription description = project.getDescription();
+        ArrayList values;
+        (values = new ArrayList()).addAll(Arrays.asList(description.getBuildSpec()));
+        ICommand[] commands;
+        int value = (commands = description.getBuildSpec()).length;
+        int value2;
+        for (int value3 = value2 = 0; value3 < value; value3 = ++value2) {
+          ICommand command = commands[value2];
+          if ("com.allatori.eclipse".equals(command.getBuilderName())) {
+            values.remove(command);
+          }
+        }
+        description.setBuildSpec((ICommand[]) values.toArray(new ICommand[values.size()]));
+        project.setDescription(description, null);
+      } catch (CoreException coreException) {
+        coreException.printStackTrace();
+      }
+    }
+    return null;
+  }
+}

src/main/java/com/allatori/engine/ObfuscationAbortException.java

@@ -0,0 +1,3 @@
+package com.allatori.engine;
+
+public class ObfuscationAbortException extends Exception {}

src/main/java/com/allatori/engine/ObfuscationEngine.java

@@ -0,0 +1,177 @@
+package com.allatori.engine;
+
+import com.allatori.bytecode.ConstantPoolEditor;
+import com.allatori.config.Configuration;
+import com.allatori.lib.bcel.classfile.Method;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.lib.bcel.util.comparator.MethodComparator;
+import com.allatori.model.ClassStorage;
+import com.allatori.naming.NameRenamer;
+import com.allatori.naming.generator.LowercaseConfusableNameGenerator;
+import com.allatori.naming.generator.MixedConfusableNameGenerator;
+import com.allatori.transform.ClassConstantPoolTransformer;
+import com.allatori.transform.ClassTransformer;
+import com.allatori.transform.ControlFlowTransformer;
+import com.allatori.transform.DistributedStringEncryptionTransformer;
+import com.allatori.transform.FieldAccessTransformer;
+import com.allatori.transform.GlobalStringEncryptionTransformer;
+import com.allatori.transform.HardwareIdTransformer;
+import com.allatori.transform.MemberConstantPoolTransformer;
+import com.allatori.transform.MemberReorderTransformer;
+import com.allatori.transform.MemberVisibilityTransformer;
+import com.allatori.transform.MethodAccessTransformer;
+import com.allatori.transform.OptimizerTransformer;
+import com.allatori.transform.RemoveFieldsTransformer;
+import com.allatori.transform.RemoveMethodsTransformer;
+import com.allatori.transform.StripAttributesTransformer;
+import com.allatori.util.Log;
+import java.util.Iterator;
+import java.util.Vector;
+
+public class ObfuscationEngine {
+
+  public ClassStorage classStorage;
+
+  public boolean enabled;
+
+  public void update() {
+    if (Configuration.getLogOptions().isText()) {
+      new HardwareIdTransformer(this.classStorage).transform(null);
+    }
+    Vector vector = new Vector();
+    vector.add(new MemberVisibilityTransformer(this.classStorage));
+    vector.add(new RemoveMethodsTransformer(this.classStorage));
+    vector.add(new RemoveFieldsTransformer(this.classStorage));
+    if (Configuration.getDebugInfoOptions().getText2() != null
+        && Configuration.getDebugInfoOptions().getText() != null) {
+      vector.add(new FieldAccessTransformer(this.classStorage));
+    }
+    int stringEncryptionVersion =
+        Configuration.getObfuscationOptions().getStringEncryptionVersion();
+    Configuration.getObfuscationOptions();
+    if (stringEncryptionVersion == 1) {
+      DistributedStringEncryptionTransformer distributedStringEncryptionTransformer;
+      if ((distributedStringEncryptionTransformer =
+              new DistributedStringEncryptionTransformer(this.classStorage))
+          .isEnabled()) {
+        vector.add(distributedStringEncryptionTransformer);
+        this.enabled = true;
+      } else {
+        vector.add(new GlobalStringEncryptionTransformer(this.classStorage));
+      }
+    } else {
+      vector.add(new GlobalStringEncryptionTransformer(this.classStorage));
+    }
+    vector.add(new MethodAccessTransformer(this.classStorage));
+    vector.add(new ControlFlowTransformer(this.classStorage));
+    vector.add(new OptimizerTransformer(this.classStorage));
+    Iterator classesByName2 = this.classStorage.getClassesByName2();
+    while (classesByName2.hasNext()) {
+      ClassGen classGen = (ClassGen) classesByName2.next();
+      Iterator iterator2;
+      if (!Configuration.getIgnoreClassesOptions().matchesClassGen(this.classStorage, classGen)) {
+        for (Iterator iterator3 = iterator2 = vector.iterator();
+            iterator3.hasNext();
+            iterator3 = iterator2) {
+          ((ClassTransformer) iterator2.next()).transform(classGen);
+        }
+      }
+    }
+    Iterator iterator4;
+    Iterator iterator5 = iterator4 = vector.iterator();
+    while (iterator5.hasNext()) {
+      ClassTransformer classTransformer = (ClassTransformer) iterator4.next();
+      iterator5 = iterator4;
+      classTransformer.finish();
+    }
+  }
+
+  public ObfuscationEngine(ClassStorage classStorage2) {
+    super();
+    this.enabled = false;
+    this.classStorage = classStorage2;
+    Method.setComparator(MethodComparator.getMethodComparator());
+    MixedConfusableNameGenerator.processCount(
+        Integer.toBinaryString(classStorage2.getClassesByName()).length());
+    LowercaseConfusableNameGenerator.processCount(
+        Integer.toBinaryString(classStorage2.getClassesByName()).length() + 1);
+  }
+
+  public void update2() {
+    ConstantPoolEditor constantPoolEditor = new ConstantPoolEditor(this.classStorage);
+    Iterator classesByName2 = this.classStorage.getClassesByName2();
+    while (classesByName2.hasNext()) {
+      ClassGen classGen = (ClassGen) classesByName2.next();
+      if (!Configuration.getIgnoreClassesOptions().matchesClassGen(this.classStorage, classGen)) {
+        constantPoolEditor.processClassGen(classGen);
+      }
+    }
+  }
+
+  public void obfuscate() {
+    Iterator classesByName2 = this.classStorage.getClassesByName2();
+    ObfuscationEngine obfuscationEngine;
+    while (true) {
+      if (classesByName2.hasNext()) {
+        ClassGen classGen;
+        if ((classGen = (ClassGen) classesByName2.next())
+            .getSuperclassName()
+            .startsWith("javax.microedition.")) {
+          Configuration.getObfuscationOptions().setEnabled(true);
+          obfuscationEngine = this;
+          break;
+        }
+        if (!classGen.getSuperclassName().startsWith("android.")) {
+          continue;
+        }
+        Configuration.getObfuscationOptions().setEnabled3(true);
+        obfuscationEngine = this;
+        break;
+      }
+      obfuscationEngine = this;
+      break;
+    }
+    obfuscationEngine.update();
+    MemberReorderTransformer memberReorderTransformer =
+        new MemberReorderTransformer(this.classStorage);
+    Iterator classesByName22 = this.classStorage.getClassesByName2();
+    while (classesByName22.hasNext()) {
+      ClassGen classGen2 = (ClassGen) classesByName22.next();
+      if (!Configuration.getIgnoreClassesOptions().matchesClassGen(this.classStorage, classGen2)) {
+        memberReorderTransformer.transform(classGen2);
+      }
+    }
+    this.renameMembers();
+    memberReorderTransformer.finish();
+    ClassTransformer classTransformer;
+    if (this.enabled) {
+      classTransformer = new ClassConstantPoolTransformer(this.classStorage);
+      obfuscationEngine = this;
+    } else {
+      classTransformer = new MemberConstantPoolTransformer(this.classStorage);
+      obfuscationEngine = this;
+    }
+    Iterator classesByName23 = obfuscationEngine.classStorage.getClassesByName2();
+    while (classesByName23.hasNext()) {
+      ClassGen classGen3 = (ClassGen) classesByName23.next();
+      if (!Configuration.getIgnoreClassesOptions().matchesClassGen(this.classStorage, classGen3)) {
+        classTransformer.transform(classGen3);
+      }
+    }
+    classTransformer.finish();
+    this.update2();
+    new StripAttributesTransformer(this.classStorage).transform(null);
+  }
+
+  public void renameMembers() {
+    try {
+      new NameRenamer(this.classStorage).rename();
+    } catch (ObfuscationAbortException obfuscationAbortException) {
+      try {
+        Log.warn("Rerunning obfuscation due to un-renamed packages.");
+        new NameRenamer(this.classStorage).rename();
+      } catch (ObfuscationAbortException obfuscationAbortException2) {
+      }
+    }
+  }
+}

src/main/java/com/allatori/engine/ObfuscationException.java

@@ -0,0 +1,8 @@
+package com.allatori.engine;
+
+public class ObfuscationException extends Exception {
+
+  public ObfuscationException(String text) {
+    super(text);
+  }
+}

src/main/java/com/allatori/internal/BytecodeSupport.java

@@ -0,0 +1,8 @@
+package com.allatori.internal;
+
+import com.allatori.lib.bcel.generic.ClassGen;
+
+public interface BytecodeSupport {
+
+  void processClassGen(ClassGen classGen);
+}

src/main/java/com/allatori/internal/NameSignatureInstructionSupport.java

@@ -0,0 +1,114 @@
+package com.allatori.internal;
+
+import com.allatori.lib.bcel.Constants;
+import com.allatori.lib.bcel.ExceptionConstants;
+import com.allatori.lib.bcel.classfile.Constant;
+import com.allatori.lib.bcel.classfile.ConstantInvokeDynamic;
+import com.allatori.lib.bcel.classfile.ConstantNameAndType;
+import com.allatori.lib.bcel.classfile.ConstantPool;
+import com.allatori.lib.bcel.generic.ConstantPoolGen;
+import com.allatori.lib.bcel.generic.ExceptionThrower;
+import com.allatori.lib.bcel.generic.NameSignatureInstruction;
+import com.allatori.lib.bcel.generic.StackConsumer;
+import com.allatori.lib.bcel.generic.StackProducer;
+import com.allatori.lib.bcel.generic.Type;
+import com.allatori.lib.bcel.generic.Visitor;
+import com.allatori.lib.bcel.util.ByteSequence;
+import java.io.DataOutputStream;
+import java.io.IOException;
+import java.util.StringTokenizer;
+
+public class NameSignatureInstructionSupport extends NameSignatureInstruction
+    implements ExceptionThrower, StackConsumer, StackProducer {
+
+  public ConstantInvokeDynamic getConstantInvokeDynamic(ConstantPoolGen constantPoolGen) {
+    return (ConstantInvokeDynamic) constantPoolGen.getConstantPool().getConstant(this.index);
+  }
+
+  public Type[] getTypes(ConstantPoolGen constantPoolGen) {
+    return Type.getArgumentTypes(this.getText(constantPoolGen));
+  }
+
+  @Override
+  public void accept(Visitor visitor) {
+    visitor.visitExceptionThrower(this);
+    visitor.visitTypedInstruction(this);
+    visitor.visitStackConsumer(this);
+    visitor.visitStackProducer(this);
+    visitor.visitCPInstruction(this);
+  }
+
+  @Override
+  public int produceStack(ConstantPoolGen constantPoolGen) {
+    return Type.calculateCount(this.getText(constantPoolGen));
+  }
+
+  @Override
+  public void initFromFile(ByteSequence byteSequence, boolean matches) throws IOException {
+    super.initFromFile(byteSequence, matches);
+    this.length = 5;
+    byteSequence.readUnsignedShort();
+  }
+
+  @Override
+  public Class[] getExceptions() {
+    Class[] classs = new Class[4 + ExceptionConstants.TYPES4.length];
+    System.arraycopy(ExceptionConstants.TYPES4, 0, classs, 0, ExceptionConstants.TYPES4.length);
+    classs[ExceptionConstants.TYPES4.length + 3] = ExceptionConstants.TYPE9;
+    classs[ExceptionConstants.TYPES4.length + 2] = ExceptionConstants.TYPE7;
+    classs[ExceptionConstants.TYPES4.length + 1] = ExceptionConstants.TYPE14;
+    classs[ExceptionConstants.TYPES4.length] = ExceptionConstants.TYPE6;
+    return classs;
+  }
+
+  @Override
+  public String toString(ConstantPool constantPool) {
+    Constant constant = constantPool.getConstant(this.index);
+    StringTokenizer stringTokenizer = new StringTokenizer(constantPool.constantToString(constant));
+    return ""
+        + Constants.TEXTS8[this.opcode]
+        + " "
+        + stringTokenizer.nextToken().replace('.', '/')
+        + stringTokenizer.nextToken();
+  }
+
+  @Override
+  public int consumeStack(ConstantPoolGen constantPoolGen) {
+    return Type.calculateCount2(this.getText(constantPoolGen));
+  }
+
+  public Type getType2(ConstantPoolGen constantPoolGen) {
+    return Type.getReturnType(this.getText(constantPoolGen));
+  }
+
+  public NameSignatureInstructionSupport() {}
+
+  @Override
+  public Type getType(ConstantPoolGen constantPoolGen) {
+    return this.getType2(constantPoolGen);
+  }
+
+  public String getText3(ConstantPoolGen constantPoolGen) {
+    return this.getText2(constantPoolGen);
+  }
+
+  @Override
+  public void dump(DataOutputStream dataOutputStream) throws IOException {
+    dataOutputStream.writeByte(this.opcode);
+    dataOutputStream.writeShort(this.index);
+    dataOutputStream.writeByte(0);
+    dataOutputStream.writeByte(0);
+  }
+
+  @Override
+  public ConstantNameAndType getNameAndType(ConstantPoolGen constantPoolGen) {
+    ConstantPool constantPool = constantPoolGen.getConstantPool();
+    ConstantInvokeDynamic constantInvokeDynamic = this.getConstantInvokeDynamic(constantPoolGen);
+    return (ConstantNameAndType)
+        constantPool.getConstant(constantInvokeDynamic.getBootstrapMethodAttrIndex2());
+  }
+
+  public NameSignatureInstructionSupport(short value, int value2) {
+    super(value, value2);
+  }
+}

src/main/java/com/allatori/internal/VerifierConstraintViolatedExceptionSupport.java

@@ -0,0 +1,13 @@
+package com.allatori.internal;
+
+import com.allatori.lib.bcel.verifier.exc.VerifierConstraintViolatedException;
+
+public class VerifierConstraintViolatedExceptionSupport
+    extends VerifierConstraintViolatedException {
+
+  public VerifierConstraintViolatedExceptionSupport(String text) {
+    super(text);
+  }
+
+  public VerifierConstraintViolatedExceptionSupport() {}
+}

src/main/java/com/allatori/io/ClassStorageClassLoader.java

@@ -0,0 +1,81 @@
+package com.allatori.io;
+
+import com.allatori.config.Configuration;
+import com.allatori.config.InputEntry;
+import com.allatori.model.ClassStorage;
+import com.allatori.util.Log;
+import java.io.DataInputStream;
+import java.io.IOException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Vector;
+import java.util.jar.JarFile;
+import java.util.zip.ZipEntry;
+
+public class ClassStorageClassLoader extends URLClassLoader {
+
+  public ClassStorage classStorage;
+
+  public byte[] createValues(JarFile jarFile, ZipEntry zipEntry) throws IOException {
+    byte[] values = new byte[(int) zipEntry.getSize()];
+    DataInputStream dataInputStream;
+    (dataInputStream = new DataInputStream(jarFile.getInputStream(zipEntry)))
+        .readFully(values, 0, values.length);
+    dataInputStream.close();
+    return values;
+  }
+
+  public ClassStorageClassLoader(URL[] uRLs) {
+    super(uRLs, ClassStorageClassLoader.class.getClassLoader());
+  }
+
+  @Override
+  public Class findClass(String name) throws ClassNotFoundException, ClassNotFoundException {
+    try {
+      try {
+        if (classStorage.getClassGen(name) != null) return createType(name);
+      } catch (Exception ignored) {
+      }
+      return super.findClass(name);
+    } catch (ClassNotFoundException failure) {
+      try {
+        return createType(name);
+      } catch (Exception ignored) {
+        throw failure;
+      }
+    }
+  }
+
+  public Class createType(String text) throws Exception {
+    try {
+      String text3 = text.replace('.', '/').concat(".class");
+      Vector values3 = Configuration.getInputOptions().getValues3();
+      int value;
+      for (int value2 = value = 0; value2 < values3.size(); value2 = ++value) {
+        InputEntry inputEntry = (InputEntry) values3.get(value);
+        JarFile jarFile = new JarFile(inputEntry.text2);
+        try {
+          ZipEntry zipEntry;
+          if ((zipEntry = jarFile.getEntry(text3)) != null) {
+            byte[] values = this.createValues(jarFile, zipEntry);
+            try {
+              return this.defineClass(text, values, 0, values.length);
+            } catch (IncompatibleClassChangeError incompatibleClassChangeError) {
+              Log.error("IncompatibleClassChangeError for class " + text);
+              throw incompatibleClassChangeError;
+            }
+          }
+        } finally {
+          jarFile.close();
+        }
+      }
+      throw new Exception();
+    } catch (Exception exception) {
+      throw exception;
+    }
+  }
+
+  public void setClassStorage(ClassStorage classStorage2) {
+    this.classStorage = classStorage2;
+  }
+}

src/main/java/com/allatori/io/DirectoryClassReader.java

@@ -0,0 +1,42 @@
+package com.allatori.io;
+
+import com.allatori.lib.bcel.classfile.ClassParser;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.model.ClassStorage;
+import com.allatori.util.Log;
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+
+public class DirectoryClassReader {
+
+  public static ClassGen createClassGen(InputStream inputStream, String text) throws IOException {
+    ClassGen classGen = new ClassGen(new ClassParser(inputStream, text).parse());
+    inputStream.close();
+    return classGen;
+  }
+
+  public static void processText(String text, ClassStorage classStorage, String text2) {
+    File[] files = new File(text).listFiles();
+    int value;
+    for (int value2 = value = 0; value2 < files.length; value2 = ++value) {
+      File file;
+      if ((file = files[value]).isDirectory()) {
+        processText(file.getPath(), classStorage, text2);
+      }
+      if (file.getName().endsWith(".class")) {
+        try {
+          classStorage.processText(
+              createClassGen(new BufferedInputStream(new FileInputStream(file)), file.getName()),
+              text2);
+        } catch (Exception exception) {
+          if (!file.getName().endsWith("module-info.class")) {
+            Log.error("Cannot parse class " + file.getName());
+          }
+        }
+      }
+    }
+  }
+}

src/main/java/com/allatori/io/DirectoryClassWriter.java

@@ -0,0 +1,69 @@
+package com.allatori.io;
+
+import com.allatori.lib.asm.ClassWriter;
+import com.allatori.util.Log;
+
+public class DirectoryClassWriter extends ClassWriter {
+
+  public final ClassLoader classLoader;
+
+  public final DirectoryWriter directoryWriter;
+
+  public DirectoryClassWriter(
+      DirectoryWriter directoryWriter2, int value, ClassLoader classLoader2) {
+    super(value);
+    this.directoryWriter = directoryWriter2;
+    this.classLoader = classLoader2;
+  }
+
+  @Override
+  public String getCommonSuperClass(String text, String text2) {
+    Class classValue;
+    Class classValue2;
+    try {
+      classValue2 = Class.forName(text.replace('/', '.'), false, this.classLoader);
+      classValue = Class.forName(text2.replace('/', '.'), false, this.classLoader);
+    } catch (ClassNotFoundException classNotFoundException) {
+      if (!DirectoryWriter.getValues(this.directoryWriter)
+          .contains(classNotFoundException.getMessage())) {
+        DirectoryWriter.getValues(this.directoryWriter).add(classNotFoundException.getMessage());
+        Log.error("CLASS NOT FOUND: " + classNotFoundException.getMessage());
+        Log.error("  ADD NEEDED JAR TO THE 'classpath' ELEMENT OF THE CONFIGURATION FILE.");
+      }
+      return "java/lang/Object";
+    } catch (NoClassDefFoundError noClassDefFoundError) {
+      if (!DirectoryWriter.getValues(this.directoryWriter)
+          .contains(noClassDefFoundError.getMessage())) {
+        DirectoryWriter.getValues(this.directoryWriter).add(noClassDefFoundError.getMessage());
+        Log.error("CLASS NOT FOUND: " + noClassDefFoundError.getMessage());
+        Log.error("  ADD NEEDED JAR TO THE 'classpath' ELEMENT OF THE CONFIGURATION FILE.");
+      }
+      return "java/lang/Object";
+    } catch (Exception exception) {
+      throw new RuntimeException(exception.toString());
+    } catch (UnsupportedClassVersionError unsupportedClassVersionError) {
+      if (!DirectoryWriter.matchesDirectoryWriter(this.directoryWriter)) {
+        DirectoryWriter.matchesEnabled(this.directoryWriter, true);
+        Log.error(
+            "SOME CLASS(ES) CANNOT BE READ DUE TO JVM VERSION INCOMPATIBILITY: "
+                + unsupportedClassVersionError.toString());
+        Log.error("  USE NEWER JVM VERSION TO RUN ALLATORI.");
+      }
+      return "java/lang/Object";
+    } catch (Error error2) {
+      return "java/lang/Object";
+    }
+    if (classValue2.isAssignableFrom(classValue)) {
+      return text;
+    }
+    if (classValue.isAssignableFrom(classValue2)) {
+      return text2;
+    }
+    if (!classValue2.isInterface() && !classValue.isInterface()) {
+      while (!(classValue2 = classValue2.getSuperclass()).isAssignableFrom(classValue)) {}
+      return classValue2.getName().replace('.', '/');
+    } else {
+      return "java/lang/Object";
+    }
+  }
+}

src/main/java/com/allatori/io/DirectoryWriter.java

@@ -0,0 +1,207 @@
+package com.allatori.io;
+
+import com.allatori.config.Configuration;
+import com.allatori.lib.asm.ClassReader;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.model.ClassStorage;
+import com.allatori.util.FileUtils;
+import com.allatori.util.Log;
+import com.allatori.util.StreamUtils;
+import java.io.BufferedOutputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.HashSet;
+import java.util.Vector;
+
+public class DirectoryWriter {
+
+  public String text;
+
+  public ClassStorage classStorage;
+
+  public boolean enabled;
+
+  public HashSet values = new HashSet();
+
+  public DirectoryWriter() {
+    this.enabled = false;
+  }
+
+  public void processFile(ClassGen classGen, File file)
+      throws FileNotFoundException, ClassNotFoundException, IOException {
+    file.getParentFile().mkdirs();
+    BufferedOutputStream bufferedOutputStream =
+        new BufferedOutputStream(new FileOutputStream(file));
+    BufferedOutputStream bufferedOutputStream2;
+    if (classGen.getMajor() > 50) {
+      ResolvingClassLoader resolvingClassLoader =
+          new ResolvingClassLoader(
+              this.classStorage, Configuration.getMappingOptions().lookupTable);
+      ClassReader classReader = new ClassReader(classGen.getJavaClass().getBytes());
+      DirectoryClassWriter directoryClassWriter =
+          new DirectoryClassWriter(this, 2, resolvingClassLoader);
+      bufferedOutputStream2 = bufferedOutputStream;
+      classReader.accept(directoryClassWriter, 4);
+      bufferedOutputStream.write(directoryClassWriter.toByteArray());
+    } else {
+      bufferedOutputStream2 = bufferedOutputStream;
+      bufferedOutputStream.write(classGen.getJavaClass().getBytes());
+    }
+    bufferedOutputStream2.close();
+  }
+
+  public void processText(File file, File file2, ClassStorage classStorage, String text2)
+      throws FileNotFoundException, IOException, ClassNotFoundException {
+    File[] files = file.listFiles();
+    int value;
+    for (int value2 = value = 0; value2 < files.length; value2 = ++value) {
+      File file3;
+      if ((file3 = files[value]).isDirectory()) {
+        String text3;
+        if ((text3 = "" + text2 + "." + file3.getName()).startsWith(".")) {
+          text3 = text3.substring(1);
+        }
+        this.processText(
+            file3, new File(("" + file2.getPath() + "/" + file3.getName())), classStorage, text3);
+      } else if (file3.getName().endsWith(".class")) {
+        String name = file3.getName();
+        String text4 = name.substring(0, name.length() - 6);
+        if (text2.length() > 0) {
+          text4 = "" + text2 + "." + text4;
+        }
+        ClassGen classGen;
+        if ((classGen = classStorage.getClassGen(text4)) != null
+            && !Configuration.getIgnoreClassesOptions().matchesClassGen(classStorage, classGen)) {
+          String className = classGen.getClassName();
+          String text5 = "" + className.replace('.', '/') + ".class";
+          this.processFile(classGen, new File(("" + this.text + "/" + text5)));
+        } else {
+          if (classGen == null) {
+            Log.warn(
+                "File "
+                    + file3.getPath()
+                    + " is copied with no modifications, as it is not in its package.");
+          }
+          new File(file2.getPath()).mkdirs();
+          FileUtils.processFile(file3, new File(("" + file2.getPath() + "/" + file3.getName())));
+        }
+      } else {
+        String text6 = "" + file2.getPath() + "/" + file3.getName();
+        if (Configuration.getRenamingOptions()
+            .getResourceRenamingOptions()
+            .isUpdateResourceNamesEnabled()) {
+          if ((text6 =
+                  ""
+                      + this.text
+                      + "/"
+                      + StreamUtils.createText(
+                          "",
+                          new StringBuilder()
+                              .insert(0, text2.replace('.', '/'))
+                              .append('/')
+                              .append(file3.getName())
+                              .toString()))
+              .contains("/")) {
+            new File(text6.substring(0, text6.lastIndexOf(47))).mkdirs();
+          }
+        } else {
+          new File(file2.getPath()).mkdirs();
+        }
+        if (Configuration.getRenamingOptions()
+            .getResourceRenamingOptions()
+            .matchesText(file3.getName())) {
+          FileInputStream fileInputStream = new FileInputStream(file3);
+          FileOutputStream fileOutputStream = new FileOutputStream(new File(text6));
+          StreamUtils.processText(
+              fileInputStream,
+              fileOutputStream,
+              Configuration.getRenamingOptions()
+                  .getResourceRenamingOptions()
+                  .getText(file3.getName()));
+          fileInputStream.close();
+          fileOutputStream.close();
+        } else {
+          FileUtils.processFile(file3, new File(text6));
+        }
+      }
+    }
+    Vector inputClasses = classStorage.getInputClasses();
+    int value3;
+    for (int value4 = value3 = 0; value4 < inputClasses.size(); value4 = value3) {
+      ClassGen classGen2;
+      String className2 = (classGen2 = (ClassGen) inputClasses.get(value3)).getClassName();
+      String text7 = "" + className2.replace('.', '/') + ".class";
+      StringBuilder stringBuilder =
+          new StringBuilder().insert(0, this.text).append("/").append(text7);
+      value3++;
+      this.processFile(classGen2, new File(stringBuilder.toString()));
+    }
+  }
+
+  public void processClassStorage(String text2, String text, ClassStorage classStorage2)
+      throws FileNotFoundException, IOException, ClassNotFoundException {
+    this.classStorage = classStorage2;
+    this.text = text;
+    if (text2.equals(text)) {
+      this.processText(new File(text2), classStorage2, "");
+    } else {
+      this.processText(new File(text2), new File(text), classStorage2, "");
+    }
+  }
+
+  public static boolean matchesDirectoryWriter(DirectoryWriter directoryWriter) {
+    return directoryWriter.enabled;
+  }
+
+  public void processText(File file, ClassStorage classStorage, String text2)
+      throws FileNotFoundException, ClassNotFoundException, IOException {
+    File[] files = file.listFiles();
+    int value;
+    for (int value2 = value = 0; value2 < files.length; value2 = ++value) {
+      File file2;
+      if ((file2 = files[value]).isDirectory()) {
+        String text3;
+        if ((text3 = "" + text2 + "." + file2.getName()).startsWith(".")) {
+          text3 = text3.substring(1);
+        }
+        this.processText(file2, classStorage, text3);
+      } else if (file2.getName().endsWith(".class")) {
+        String name = file2.getName();
+        String text4 = name.substring(0, name.length() - 6);
+        if (text2.length() > 0) {
+          text4 = "" + text2 + "." + text4;
+        }
+        ClassGen classGen;
+        if ((classGen = classStorage.getClassGen(text4)) != null
+            && !Configuration.getIgnoreClassesOptions().matchesClassGen(classStorage, classGen)) {
+          file2.delete();
+          String className = classGen.getClassName();
+          String text5 = "" + className.replace('.', '/') + ".class";
+          this.processFile(classGen, new File(("" + this.text + "/" + text5)));
+        }
+      }
+    }
+    Vector inputClasses = classStorage.getInputClasses();
+    int value3;
+    for (int value4 = value3 = 0; value4 < inputClasses.size(); value4 = value3) {
+      ClassGen classGen2;
+      String className2 = (classGen2 = (ClassGen) inputClasses.get(value3)).getClassName();
+      String text6 = "" + className2.replace('.', '/') + ".class";
+      StringBuilder stringBuilder =
+          new StringBuilder().insert(0, this.text).append("/").append(text6);
+      value3++;
+      this.processFile(classGen2, new File(stringBuilder.toString()));
+    }
+  }
+
+  public static HashSet getValues(DirectoryWriter directoryWriter) {
+    return directoryWriter.values;
+  }
+
+  public static boolean matchesEnabled(DirectoryWriter directoryWriter, boolean matches) {
+    return directoryWriter.enabled = matches;
+  }
+}

src/main/java/com/allatori/io/JarClassReader.java

@@ -0,0 +1,43 @@
+package com.allatori.io;
+
+import com.allatori.lib.bcel.classfile.ClassParser;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.model.ClassStorage;
+import com.allatori.util.Log;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Enumeration;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+
+public class JarClassReader {
+
+  public static ClassGen createClassGen(InputStream inputStream, String text) throws IOException {
+    ClassGen classGen = new ClassGen(new ClassParser(inputStream, text).parse());
+    inputStream.close();
+    return classGen;
+  }
+
+  public static void processClassStorage(String text, ClassStorage classStorage)
+      throws IOException {
+    JarFile jarFile;
+    Enumeration enumeration = (jarFile = new JarFile(text)).entries();
+    while (enumeration.hasMoreElements()) {
+      JarEntry jarEntry;
+      if (!(jarEntry = (JarEntry) enumeration.nextElement()).isDirectory()
+          && jarEntry.getName().endsWith(".class")) {
+        try {
+          classStorage.processText(
+              createClassGen(jarFile.getInputStream(jarEntry), jarEntry.getName()),
+              text,
+              jarEntry.getName());
+        } catch (Exception exception) {
+          if (!jarEntry.getName().endsWith("module-info.class")) {
+            Log.error("Cannot parse class " + jarEntry.getName());
+          }
+        }
+      }
+    }
+    jarFile.close();
+  }
+}

src/main/java/com/allatori/io/JarClassWriter.java

@@ -0,0 +1,66 @@
+package com.allatori.io;
+
+import com.allatori.lib.asm.ClassWriter;
+import com.allatori.util.Log;
+
+public class JarClassWriter extends ClassWriter {
+
+  public final JarWriter jarWriter;
+
+  public final ClassLoader classLoader;
+
+  @Override
+  public String getCommonSuperClass(String text, String text2) {
+    Class classValue;
+    Class classValue2;
+    try {
+      classValue = Class.forName(text.replace('/', '.'), false, this.classLoader);
+      classValue2 = Class.forName(text2.replace('/', '.'), false, this.classLoader);
+    } catch (ClassNotFoundException classNotFoundException) {
+      if (!JarWriter.getValues(this.jarWriter).contains(classNotFoundException.getMessage())) {
+        JarWriter.getValues(this.jarWriter).add(classNotFoundException.getMessage());
+        Log.error("CLASS NOT FOUND: " + classNotFoundException.getMessage());
+        Log.error("  ADD NEEDED JAR TO THE 'classpath' ELEMENT OF THE CONFIGURATION FILE.");
+      }
+      return "java/lang/Object";
+    } catch (NoClassDefFoundError noClassDefFoundError) {
+      if (!JarWriter.getValues(this.jarWriter).contains(noClassDefFoundError.getMessage())) {
+        JarWriter.getValues(this.jarWriter).add(noClassDefFoundError.getMessage());
+        Log.error("CLASS NOT FOUND: " + noClassDefFoundError.getMessage());
+        Log.error("  ADD NEEDED JAR TO THE 'classpath' ELEMENT OF THE CONFIGURATION FILE.");
+      }
+      return "java/lang/Object";
+    } catch (Exception exception) {
+      throw new RuntimeException(exception.toString());
+    } catch (UnsupportedClassVersionError unsupportedClassVersionError) {
+      if (!JarWriter.matchesJarWriter(this.jarWriter)) {
+        JarWriter.matchesEnabled(this.jarWriter, true);
+        Log.error(
+            "SOME CLASS(ES) CANNOT BE READ DUE TO JVM VERSION INCOMPATIBILITY: "
+                + unsupportedClassVersionError.toString());
+        Log.error("  USE NEWER JVM VERSION TO RUN ALLATORI.");
+      }
+      return "java/lang/Object";
+    } catch (Error error2) {
+      return "java/lang/Object";
+    }
+    if (classValue.isAssignableFrom(classValue2)) {
+      return text;
+    }
+    if (classValue2.isAssignableFrom(classValue)) {
+      return text2;
+    }
+    if (!classValue.isInterface() && !classValue2.isInterface()) {
+      while (!(classValue = classValue.getSuperclass()).isAssignableFrom(classValue2)) {}
+      return classValue.getName().replace('.', '/');
+    } else {
+      return "java/lang/Object";
+    }
+  }
+
+  public JarClassWriter(JarWriter jarWriter2, int value, ClassLoader classLoader2) {
+    super(value);
+    this.jarWriter = jarWriter2;
+    this.classLoader = classLoader2;
+  }
+}

src/main/java/com/allatori/io/JarWriter.java

@@ -0,0 +1,425 @@
+package com.allatori.io;
+
+import com.allatori.config.Configuration;
+import com.allatori.config.InputJar;
+import com.allatori.lib.asm.ClassReader;
+import com.allatori.lib.bcel.classfile.ClassParser;
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.model.ClassStorage;
+import com.allatori.util.Log;
+import com.allatori.util.StreamUtils;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Field;
+import java.util.Enumeration;
+import java.util.HashSet;
+import java.util.Hashtable;
+import java.util.Iterator;
+import java.util.Vector;
+import java.util.jar.JarEntry;
+import java.util.jar.JarFile;
+import java.util.jar.JarOutputStream;
+import java.util.zip.CRC32;
+import java.util.zip.ZipException;
+import java.util.zip.ZipOutputStream;
+
+public class JarWriter {
+
+  public final String text;
+
+  public Hashtable entries;
+
+  public boolean enabled;
+
+  public ClassStorage classStorage;
+
+  public Vector values;
+
+  public HashSet values2;
+
+  public JarWriter() {
+    super();
+    this.text = ".tmp";
+    this.values = new Vector();
+    this.values2 = new HashSet();
+    this.enabled = false;
+  }
+
+  public String createText(JarFile jarFile, JarEntry jarEntry) {
+    try {
+      InputStream inputStream = jarFile.getInputStream(jarEntry);
+      ClassGen classGen = new ClassGen(new ClassParser(inputStream, jarEntry.getName()).parse());
+      inputStream.close();
+      return jarEntry
+          .getName()
+          .substring(0, jarEntry.getName().length() - classGen.getClassName().length() - 6);
+    } catch (Exception exception) {
+      return "";
+    }
+  }
+
+  public void processText(String[] texts, String text) throws FileNotFoundException, IOException {
+    byte[] values = new byte[262144];
+    JarOutputStream jarOutputStream =
+        new JarOutputStream(new FileOutputStream(("" + text + ".tmp")));
+    if (Configuration.getOutputOptions().getCompressionLevel() != -1) {
+      jarOutputStream.setLevel(Configuration.getOutputOptions().getCompressionLevel());
+    }
+    Hashtable hashtable = new Hashtable();
+    int value;
+    for (int value2 = value = 0; value2 < texts.length; value2 = value) {
+      JarFile jarFile;
+      Enumeration enumeration;
+      Enumeration enumeration2 = enumeration = (jarFile = new JarFile(texts[value])).entries();
+      while (enumeration2.hasMoreElements()) {
+        JarEntry jarEntry = (JarEntry) enumeration.nextElement();
+        if (hashtable.containsKey(jarEntry.getName())) {
+          enumeration2 = enumeration;
+        } else {
+          hashtable.put(jarEntry.getName(), "");
+          InputStream inputStream = jarFile.getInputStream(jarEntry);
+          JarEntry jarEntry2 = new JarEntry(jarEntry.getName());
+          jarOutputStream.putNextEntry(jarEntry2);
+          InputStream inputStream2 = inputStream;
+          int value3;
+          while ((value3 = inputStream2.read(values)) > 0) {
+            inputStream2 = inputStream;
+            jarOutputStream.write(values, 0, value3);
+          }
+          jarOutputStream.closeEntry();
+          enumeration2 = enumeration;
+        }
+      }
+      JarFile jarFile2 = jarFile;
+      value++;
+      jarFile2.close();
+    }
+    if (Configuration.getObfuscationOptions().isOutputJarCommentEnabled()
+        && !Configuration.getObfuscationOptions().isEnabled()) {
+      this.processJarOutputStream(jarOutputStream);
+    }
+    jarOutputStream.finish();
+    jarOutputStream.close();
+    this.processText(text + ".tmp", text);
+  }
+
+  public static HashSet getValues(JarWriter jarWriter) {
+    return jarWriter.values2;
+  }
+
+  public void processJarOutputStream(String text, JarOutputStream jarOutputStream)
+      throws IOException {
+    String text2 = "";
+    label17:
+    while (true) {
+      String text3 = text;
+      while (text3.indexOf(47) > 0) {
+        text2 = "" + text2 + text.substring(0, text.indexOf(47) + 1);
+        text = text.substring(text.indexOf(47) + 1);
+        if (this.entries.containsKey(text2)) {
+          continue label17;
+        }
+        text3 = text;
+        this.entries.put(text2, ".tmp");
+        jarOutputStream.putNextEntry(new JarEntry(text2));
+        jarOutputStream.closeEntry();
+      }
+      return;
+    }
+  }
+
+  public void processText(
+      Vector vector, JarOutputStream jarOutputStream, ClassStorage classStorage, String text)
+      throws IOException {
+    int value;
+    for (int value2 = value = vector.size() - 1; value2 >= 0; value2 = value) {
+      ClassGen classGen = (ClassGen) vector.get(value);
+      value--;
+      this.processText(classGen, jarOutputStream, classStorage, text);
+    }
+  }
+
+  public void processJarOutputStream(JarOutputStream jarOutputStream) {
+    if (Configuration.getObfuscationOptions().getOutputJarComment() != null) {
+      jarOutputStream.setComment(Configuration.getObfuscationOptions().getOutputJarComment());
+    }
+  }
+
+  public void processClassStorage(String text3, String text4, ClassStorage classStorage2)
+      throws IOException, FileNotFoundException, ZipException {
+    byte value;
+    this.classStorage = classStorage2;
+    this.entries = new Hashtable();
+    byte[] values2 = new byte[262144];
+    String text5 = "";
+    JarFile jarFile = new JarFile(text3);
+    JarOutputStream jarOutputStream =
+        new JarOutputStream(new FileOutputStream(("" + text4 + ".tmp")));
+    HashSet values3 = new HashSet();
+    if (Configuration.getOutputOptions().isKeepDuplicateEntries()) {
+      try {
+        Field field;
+        if ((field = ZipOutputStream.class.getDeclaredField("names")) != null) {
+          field.setAccessible(true);
+          values3 = (HashSet) field.get(jarOutputStream);
+        }
+      } catch (RuntimeException runtimeException) {
+        if (runtimeException.getClass().getName().endsWith("InaccessibleObjectException")) {
+          Log.warn(
+              "Use '--add-opens java.base/java.util.zip=ALL-UNNAMED' Java launcher option to keep"
+                  + " output jar duplicate entries");
+        }
+      } catch (Exception exception) {
+      }
+    }
+    if (Configuration.getOutputOptions().getCompressionLevel() != -1) {
+      jarOutputStream.setLevel(Configuration.getOutputOptions().getCompressionLevel());
+    }
+    Vector vector = new Vector();
+    Enumeration enumeration = jarFile.entries();
+    while (true) {
+      Enumeration enumeration2 = enumeration;
+      JarEntry jarEntry;
+      InputStream inputStream;
+      JarEntry jarEntry2;
+      while (true) {
+        if (!enumeration2.hasMoreElements()) {
+          this.processText(vector, jarOutputStream, classStorage2, text3);
+          this.processText(classStorage2.getInputClasses(), jarOutputStream, classStorage2, text3);
+          jarFile.close();
+          if (Configuration.getObfuscationOptions().isOutputJarCommentEnabled()
+              && !Configuration.getObfuscationOptions().isEnabled()) {
+            this.processJarOutputStream(jarOutputStream);
+          }
+          jarOutputStream.finish();
+          jarOutputStream.close();
+          this.processText("" + text4 + ".tmp", text4);
+          return;
+        }
+        if ((jarEntry = (JarEntry) enumeration.nextElement()).isDirectory()) {
+          enumeration2 = enumeration;
+        } else {
+          String text6;
+          if (jarEntry.getName().endsWith(".class")
+              && (text6 = classStorage2.getText("" + text3 + '#' + jarEntry.getName())) != null) {
+            text5 = classStorage2.getText2("" + text3 + '#' + text6);
+            ClassGen classGen;
+            if ((classGen = classStorage2.getClassGen(text6)) != null
+                && !Configuration.getIgnoreClassesOptions()
+                    .matchesClassGen(classStorage2, classGen)) {
+              enumeration2 = enumeration;
+              vector.add(classGen);
+              continue;
+            }
+          }
+          if (jarEntry.getName().equals("META-INF/INDEX.LIST")) {
+            enumeration2 = enumeration;
+            this.values.add(text4);
+          } else {
+            inputStream = jarFile.getInputStream(jarEntry);
+            String name = jarEntry.getName();
+            if (Configuration.getRenamingOptions()
+                .getResourceRenamingOptions()
+                .isUpdateResourceNamesEnabled()) {
+              if (text5 == null && text3.endsWith(".war")) {
+                text5 = "WEB-INF/classes/";
+              }
+              if (jarEntry.getName().startsWith("BOOT-INF/classes/")) {
+                text5 = "BOOT-INF/classes/";
+              }
+              if (jarEntry.getName().startsWith("WEB-INF/classes/")) {
+                text5 = "WEB-INF/classes/";
+              }
+              name = StreamUtils.createText(text5, jarEntry.getName());
+            }
+            ClassGen classGen2;
+            if (Configuration.getLogOptions().isText()
+                && "com/license4j/resources/d.bfi".equals(jarEntry.getName())
+                && (classGen2 = classStorage2.getClassGen("com.license4j.HardwareID")) != null) {
+              String text7;
+              if ((text7 = classGen2.getClassName()).indexOf(46) > 0) {
+                String text8 = text7.substring(0, text7.lastIndexOf(46) + 1).replace('.', '/');
+                name = "" + text8 + Configuration.getLogOptions().getComLicense4jSupport();
+              } else {
+                name = Configuration.getLogOptions().getComLicense4jSupport();
+              }
+            }
+            jarEntry2 = new JarEntry(name);
+            if (!name.endsWith(".jar")) {
+              break;
+            }
+            byte value2 = 0;
+            Iterator iterator2 = Configuration.getInputOptions().getValues().iterator();
+            while (true) {
+              if (!iterator2.hasNext()) {
+                value = value2;
+                break;
+              }
+              InputJar inputJar;
+              if ((inputJar = (InputJar) iterator2.next()).text.equals(text3)
+                  && inputJar.text2.equals(jarEntry.getName())) {
+                if (jarEntry.getMethod() == 0) {
+                  jarEntry2.setMethod(0);
+                }
+                File file = new File(inputJar.text);
+                jarEntry2.setSize(file.length());
+                FileInputStream fileInputStream = new FileInputStream(file);
+                CRC32 cRC32 = new CRC32();
+                FileInputStream fileInputStream2 = fileInputStream;
+                int value3;
+                while ((value3 = fileInputStream2.read(values2)) > 0) {
+                  fileInputStream2 = fileInputStream;
+                  cRC32.update(values2, 0, value3);
+                }
+                jarEntry2.setCrc(cRC32.getValue());
+                fileInputStream.close();
+                FileInputStream fileInputStream3 = new FileInputStream(file);
+                this.processJarOutputStream(jarEntry2.getName(), jarOutputStream);
+                try {
+                  jarOutputStream.putNextEntry(jarEntry2);
+                  if (Configuration.getOutputOptions().isKeepDuplicateEntries()) {
+                    values3.clear();
+                  }
+                  FileInputStream fileInputStream4 = fileInputStream3;
+                  int value4;
+                  while ((value4 = fileInputStream4.read(values2)) > 0) {
+                    fileInputStream4 = fileInputStream3;
+                    jarOutputStream.write(values2, 0, value4);
+                  }
+                  fileInputStream3.close();
+                  jarOutputStream.closeEntry();
+                } catch (ZipException zipException) {
+                  if (!zipException.getMessage().contains("duplicate")) {
+                    throw zipException;
+                  }
+                }
+                value = value2 = 1;
+                break;
+              }
+            }
+            if (value == 0 && jarEntry.getMethod() == 0) {
+              jarEntry2.setMethod(0);
+              jarEntry2.setSize(jarEntry.getSize());
+              jarEntry2.setCrc(jarEntry.getCrc());
+            }
+            if (value2 == 0) {
+              break;
+            }
+            enumeration2 = enumeration;
+          }
+        }
+      }
+      this.processJarOutputStream(jarEntry2.getName(), jarOutputStream);
+      try {
+        jarOutputStream.putNextEntry(jarEntry2);
+        if (Configuration.getOutputOptions().isKeepDuplicateEntries()) {
+          values3.clear();
+        }
+        boolean matches =
+            Configuration.getRenamingOptions()
+                .getResourceRenamingOptions()
+                .matchesText(jarEntry.getName());
+        InputStream inputStream2 = inputStream;
+        JarOutputStream jarOutputStream2;
+        if (matches) {
+          StreamUtils.processText(
+              inputStream,
+              jarOutputStream,
+              Configuration.getRenamingOptions()
+                  .getResourceRenamingOptions()
+                  .getText(jarEntry.getName()));
+          jarOutputStream2 = jarOutputStream;
+        } else {
+          int value5;
+          while ((value5 = inputStream2.read(values2)) > 0) {
+            inputStream2 = inputStream;
+            jarOutputStream.write(values2, 0, value5);
+          }
+          jarOutputStream2 = jarOutputStream;
+        }
+        jarOutputStream2.closeEntry();
+      } catch (ZipException zipException2) {
+        if (!zipException2.getMessage().contains("duplicate")) {
+          throw zipException2;
+        }
+      }
+    }
+  }
+
+  public static boolean matchesEnabled(JarWriter jarWriter, boolean matches) {
+    return jarWriter.enabled = matches;
+  }
+
+  public static boolean matchesJarWriter(JarWriter jarWriter) {
+    return jarWriter.enabled;
+  }
+
+  public void processText(String text, String text2) {
+    File file = new File(text);
+    File file2;
+    if ((file2 = new File(text2)).exists() && !file2.delete()) {
+      Log.warn("Cannot delete '" + file2.getPath() + "'");
+    }
+    if (!file.renameTo(file2)) {
+      Log.warn("Cannot rename '" + file.getPath() + "' to '" + file2.getPath() + "'");
+      Log.warn("Resulting file is '" + file.getPath() + "'");
+    }
+  }
+
+  public void update() {
+    int value;
+    for (int value2 = value = 0; value2 < this.values.size(); value2 = value) {
+      String text = (String) this.values.get(value);
+      value++;
+      this.processText(text);
+    }
+  }
+
+  public void processText(String text) {
+    try {
+      File file = new File(text);
+      Runtime.getRuntime().exec("jar -i " + file.getName(), null, file.getParentFile());
+    } catch (Exception exception) {
+    }
+  }
+
+  public void processText(
+      ClassGen classGen, JarOutputStream jarOutputStream, ClassStorage classStorage, String text)
+      throws IOException {
+    String text2;
+    String text3 = text2 = classGen.getClassName();
+    if (Configuration.getMappingOptions().lookupTable != null) {
+      text3 = Configuration.getMappingOptions().lookupTable.getText(text2);
+    }
+    String text4;
+    if ((text4 = classStorage.getText2("" + text + '#' + text3)) == null) {
+      text4 = "";
+    }
+    String text5 = "" + text4 + text2.replace('.', '/') + ".class";
+    JarEntry jarEntry = new JarEntry(text5);
+    this.processJarOutputStream(text5, jarOutputStream);
+    try {
+      jarOutputStream.putNextEntry(jarEntry);
+      JarOutputStream jarOutputStream2;
+      if (classGen.getMajor() > 50) {
+        ResolvingClassLoader resolvingClassLoader =
+            new ResolvingClassLoader(classStorage, Configuration.getMappingOptions().lookupTable);
+        ClassReader classReader = new ClassReader(classGen.getJavaClass().getBytes());
+        JarClassWriter jarClassWriter = new JarClassWriter(this, 2, resolvingClassLoader);
+        jarOutputStream2 = jarOutputStream;
+        classReader.accept(jarClassWriter, 4);
+        jarOutputStream.write(jarClassWriter.toByteArray());
+      } else {
+        jarOutputStream2 = jarOutputStream;
+        jarOutputStream.write(classGen.getJavaClass().getBytes());
+      }
+      jarOutputStream2.closeEntry();
+    } catch (Exception exception) {
+      exception.printStackTrace();
+    }
+  }
+}

src/main/java/com/allatori/io/ResolvingClassLoader.java

@@ -0,0 +1,41 @@
+package com.allatori.io;
+
+import com.allatori.lib.bcel.generic.ClassGen;
+import com.allatori.model.ClassStorage;
+import com.allatori.util.LookupTable;
+import java.net.URL;
+import java.net.URLClassLoader;
+
+public class ResolvingClassLoader extends URLClassLoader {
+
+  public ClassStorage classStorage;
+
+  public LookupTable lookupTable;
+
+  public ResolvingClassLoader(ClassStorage classStorage2, LookupTable lookupTable2) {
+    super(new URL[0], classStorage2.getClassLoader());
+    this.classStorage = classStorage2;
+    this.lookupTable = lookupTable2;
+  }
+
+  public Class getType(String text) {
+    ClassGen classGen = this.classStorage.getClassGen(text);
+    byte[] bytes = classGen.getJavaClass().getBytes();
+    return this.defineClass(classGen.getClassName(), bytes, 0, bytes.length);
+  }
+
+  @Override
+  public Class findClass(String text) throws ClassNotFoundException {
+    String text2 = text;
+    try {
+      if (this.lookupTable.matchesText(text2)) {
+        text2 = this.lookupTable.getText(text2);
+      }
+      if (this.classStorage.getClassGen(text2) != null) {
+        return this.getType(text2);
+      }
+    } catch (Exception exception) {
+    }
+    return super.findClass(text2);
+  }
+}

src/main/java/com/allatori/lib/asm/AnnotationVisitor.java

@@ -0,0 +1,64 @@
+package com.allatori.lib.asm;
+
+public abstract class AnnotationVisitor {
+
+  public final int api;
+
+  public AnnotationVisitor av;
+
+  public void visitEnum(String text, String text2, String text3) {
+    if (this.av != null) {
+      this.av.visitEnum(text, text2, text3);
+    }
+  }
+
+  public AnnotationVisitor(int api, AnnotationVisitor annotationVisitor) {
+    super();
+    if (api != 589824
+        && api != 524288
+        && api != 458752
+        && api != 393216
+        && api != 327680
+        && api != 262144
+        && api != 17432576) {
+      throw new IllegalArgumentException(stringConcat$0(api));
+    }
+    if (api == 17432576) {
+      Constants.checkAsmExperimental(this);
+    }
+    this.api = api;
+    this.av = annotationVisitor;
+  }
+
+  public static String stringConcat$0(int value) {
+    return "Unsupported api " + value;
+  }
+
+  public AnnotationVisitor visitAnnotation(String text, String text2) {
+    return this.av != null ? this.av.visitAnnotation(text, text2) : null;
+  }
+
+  public AnnotationVisitor(int value) {
+    this(value, null);
+  }
+
+  public AnnotationVisitor visitArray(String text) {
+    return this.av != null ? this.av.visitArray(text) : null;
+  }
+
+  public void visitEnd() {
+    if (this.av != null) {
+      this.av.visitEnd();
+    }
+  }
+
+  public AnnotationVisitor getDelegate() {
+    return this.av;
+  }
+
+  public void visit(String text, Object result) {
+    if (this.av != null) {
+      this.av.visit(text, result);
+    }
+  }
+}

src/main/java/com/allatori/lib/asm/AnnotationWriter.java

@@ -0,0 +1,361 @@
+package com.allatori.lib.asm;
+
+public final class AnnotationWriter extends AnnotationVisitor {
+
+  public int count;
+
+  public AnnotationWriter nextAnnotation;
+
+  public final AnnotationWriter previousAnnotation;
+
+  public final int numElementValuePairsOffset;
+
+  public final boolean useNamedValues;
+
+  public final SymbolTable symbolTable;
+
+  public final ByteVector annotation;
+
+  @Override
+  public AnnotationVisitor visitAnnotation(String text, String text2) {
+    this.count++;
+    if (this.useNamedValues) {
+      this.annotation.putShort(this.symbolTable.addConstantUtf8(text));
+    }
+    this.annotation.put12(64, this.symbolTable.addConstantUtf8(text2)).putShort(0);
+    return new AnnotationWriter(this.symbolTable, true, this.annotation, null);
+  }
+
+  @Override
+  public void visit(String text, Object result) {
+    this.count++;
+    if (this.useNamedValues) {
+      this.annotation.putShort(this.symbolTable.addConstantUtf8(text));
+    }
+    if (result instanceof String) {
+      this.annotation.put12(115, this.symbolTable.addConstantUtf8((String) result));
+    } else if (result instanceof Byte) {
+      this.annotation.put12(66, this.symbolTable.getSymbol((Byte) result).index);
+    } else if (result instanceof Boolean) {
+      int value = (Boolean) result ? 1 : 0;
+      this.annotation.put12(90, this.symbolTable.getSymbol(value).index);
+    } else if (result instanceof Character) {
+      this.annotation.put12(67, this.symbolTable.getSymbol((Character) result).index);
+    } else if (result instanceof Short) {
+      this.annotation.put12(83, this.symbolTable.getSymbol((Short) result).index);
+    } else if (result instanceof Type) {
+      this.annotation.put12(99, this.symbolTable.addConstantUtf8(((Type) result).getDescriptor()));
+    } else {
+      if (result instanceof byte[]) {
+        byte[] values = (byte[]) result;
+        this.annotation.put12(91, values.length);
+        int value2 = values.length;
+        int value3;
+        for (int value4 = value3 = 0; value4 < value2; value4 = value3) {
+          byte value5 = values[value3];
+          SymbolTable symbolTable2 = this.symbolTable;
+          ByteVector byteVector = this.annotation;
+          value3++;
+          byteVector.put12((byte) 66, symbolTable2.getSymbol(value5).index);
+        }
+      } else if (result instanceof boolean[]) {
+        boolean[] matchess = (boolean[]) result;
+        this.annotation.put12(91, matchess.length);
+        int value6 = matchess.length;
+        int value7;
+        for (int value8 = value7 = 0; value8 < value6; value8 = value7) {
+          boolean matches = matchess[value7];
+          ByteVector byteVector2 = this.annotation;
+          Symbol symbol = this.symbolTable.getSymbol(matches ? 1 : 0);
+          value7++;
+          byteVector2.put12((byte) 90, symbol.index);
+        }
+      } else if (result instanceof short[]) {
+        short[] values2 = (short[]) result;
+        this.annotation.put12(91, values2.length);
+        int value9 = values2.length;
+        int value10;
+        for (int value11 = value10 = 0; value11 < value9; value11 = value10) {
+          short value12 = values2[value10];
+          SymbolTable symbolTable3 = this.symbolTable;
+          ByteVector byteVector3 = this.annotation;
+          value10++;
+          byteVector3.put12((byte) 83, symbolTable3.getSymbol(value12).index);
+        }
+      } else if (result instanceof char[]) {
+        char[] values3 = (char[]) result;
+        this.annotation.put12(91, values3.length);
+        int value13 = values3.length;
+        int value14;
+        for (int value15 = value14 = 0; value15 < value13; value15 = value14) {
+          char value16 = values3[value14];
+          SymbolTable symbolTable4 = this.symbolTable;
+          ByteVector byteVector4 = this.annotation;
+          value14++;
+          byteVector4.put12((byte) 67, symbolTable4.getSymbol(value16).index);
+        }
+      } else if (result instanceof int[]) {
+        int[] values4 = (int[]) result;
+        this.annotation.put12(91, values4.length);
+        int value17 = values4.length;
+        int value18;
+        for (int value19 = value18 = 0; value19 < value17; value19 = value18) {
+          int value20 = values4[value18];
+          SymbolTable symbolTable5 = this.symbolTable;
+          ByteVector byteVector5 = this.annotation;
+          value18++;
+          byteVector5.put12((byte) 73, symbolTable5.getSymbol(value20).index);
+        }
+      } else if (result instanceof long[]) {
+        long[] values5 = (long[]) result;
+        this.annotation.put12(91, values5.length);
+        int value21 = values5.length;
+        int value22;
+        for (int value23 = value22 = 0; value23 < value21; value23 = value22) {
+          long value24 = values5[value22];
+          SymbolTable symbolTable6 = this.symbolTable;
+          ByteVector byteVector6 = this.annotation;
+          value22++;
+          byteVector6.put12((byte) 74, symbolTable6.addConstantLong(value24).index);
+        }
+      } else if (result instanceof float[]) {
+        float[] values6 = (float[]) result;
+        this.annotation.put12(91, values6.length);
+        int value25 = values6.length;
+        int value26;
+        for (int value27 = value26 = 0; value27 < value25; value27 = value26) {
+          float value28 = values6[value26];
+          SymbolTable symbolTable7 = this.symbolTable;
+          ByteVector byteVector7 = this.annotation;
+          value26++;
+          byteVector7.put12((byte) 70, symbolTable7.addConstantFloat(value28).index);
+        }
+      } else if (result instanceof double[]) {
+        double[] values7 = (double[]) result;
+        this.annotation.put12(91, values7.length);
+        int value29 = values7.length;
+        int value30;
+        for (int value31 = value30 = 0; value31 < value29; value31 = value30) {
+          double value32 = values7[value30];
+          SymbolTable symbolTable8 = this.symbolTable;
+          ByteVector byteVector8 = this.annotation;
+          value30++;
+          byteVector8.put12((byte) 68, symbolTable8.addConstantDouble(value32).index);
+        }
+      } else {
+        Symbol symbol2 = this.symbolTable.addConstant(result);
+        this.annotation.put12(".s.IFJDCS".charAt(symbol2.tag), symbol2.index);
+      }
+    }
+  }
+
+  public static void putParameterAnnotations(
+      int value, AnnotationWriter[] annotationWriters, int value2, ByteVector byteVector) {
+    int value3 = 1 + 2 * value2;
+    int value4;
+    for (int value5 = value4 = 0; value5 < value2; value5 = value4) {
+      AnnotationWriter annotationWriter = annotationWriters[value4];
+      int value6 =
+          value3
+              + (annotationWriter == null ? 0 : annotationWriter.computeAnnotationsSize(null) - 8);
+      value4++;
+      value3 = value6;
+    }
+    byteVector.putShort(value);
+    byteVector.putInt(value3);
+    byteVector.putByte(value2);
+    int value7 = 0;
+    for (int value8 = value7; value8 < value2; value8 = ++value7) {
+      AnnotationWriter annotationWriter2 = annotationWriters[value7];
+      AnnotationWriter annotationWriter3 = null;
+      int value9 = 0;
+      AnnotationWriter annotationWriter4 = annotationWriter2;
+      while (annotationWriter4 != null) {
+        AnnotationWriter annotationWriter5 = annotationWriter2;
+        value9++;
+        annotationWriter5.visitEnd();
+        annotationWriter3 = annotationWriter5;
+        annotationWriter4 = annotationWriter2 = annotationWriter5.previousAnnotation;
+      }
+      byteVector.putShort(value9);
+      AnnotationWriter annotationWriter6 = annotationWriter3;
+      for (AnnotationWriter annotationWriter7 = annotationWriter6;
+          annotationWriter7 != null;
+          annotationWriter7 = annotationWriter6) {
+        byteVector.putByteArray(
+            annotationWriter6.annotation.data, 0, annotationWriter6.annotation.length);
+        annotationWriter6 = annotationWriter6.nextAnnotation;
+      }
+    }
+  }
+
+  public static void putAnnotations(
+      SymbolTable symbolTable,
+      AnnotationWriter annotationWriter,
+      AnnotationWriter annotationWriter2,
+      AnnotationWriter annotationWriter3,
+      AnnotationWriter annotationWriter4,
+      ByteVector byteVector) {
+    if (annotationWriter != null) {
+      annotationWriter.putAnnotations(
+          symbolTable.addConstantUtf8("RuntimeVisibleAnnotations"), byteVector);
+    }
+    if (annotationWriter2 != null) {
+      annotationWriter2.putAnnotations(
+          symbolTable.addConstantUtf8("RuntimeInvisibleAnnotations"), byteVector);
+    }
+    if (annotationWriter3 != null) {
+      annotationWriter3.putAnnotations(
+          symbolTable.addConstantUtf8("RuntimeVisibleTypeAnnotations"), byteVector);
+    }
+    if (annotationWriter4 != null) {
+      annotationWriter4.putAnnotations(
+          symbolTable.addConstantUtf8("RuntimeInvisibleTypeAnnotations"), byteVector);
+    }
+  }
+
+  public static AnnotationWriter create(
+      SymbolTable symbolTable, String text, AnnotationWriter annotationWriter) {
+    ByteVector byteVector;
+    (byteVector = new ByteVector()).putShort(symbolTable.addConstantUtf8(text)).putShort(0);
+    return new AnnotationWriter(symbolTable, true, byteVector, annotationWriter);
+  }
+
+  public int computeAnnotationsSize(String text) {
+    if (text != null) {
+      this.symbolTable.addConstantUtf8(text);
+    }
+    int value = 8;
+    AnnotationWriter annotationWriter;
+    for (AnnotationWriter annotationWriter2 = annotationWriter = this;
+        annotationWriter2 != null;
+        annotationWriter2 = annotationWriter = annotationWriter.previousAnnotation) {
+      value += annotationWriter.annotation.length;
+    }
+    return value;
+  }
+
+  public static AnnotationWriter create(
+      SymbolTable symbolTable,
+      int value,
+      TypePath typePath,
+      String text,
+      AnnotationWriter annotationWriter) {
+    ByteVector byteVector = new ByteVector();
+    TypeReference.putTarget(value, byteVector);
+    TypePath.put(typePath, byteVector);
+    byteVector.putShort(symbolTable.addConstantUtf8(text)).putShort(0);
+    return new AnnotationWriter(symbolTable, true, byteVector, annotationWriter);
+  }
+
+  @Override
+  public void visitEnum(String text, String text2, String text3) {
+    this.count++;
+    if (this.useNamedValues) {
+      this.annotation.putShort(this.symbolTable.addConstantUtf8(text));
+    }
+    this.annotation
+        .put12(101, this.symbolTable.addConstantUtf8(text2))
+        .putShort(this.symbolTable.addConstantUtf8(text3));
+  }
+
+  public static int computeParameterAnnotationsSize(
+      String text, AnnotationWriter[] annotationWriters, int value) {
+    int value2 = 7 + 2 * value;
+    int value3;
+    for (int value4 = value3 = 0; value4 < value; value4 = value3) {
+      AnnotationWriter annotationWriter = annotationWriters[value3];
+      int value5 =
+          value2
+              + (annotationWriter == null ? 0 : annotationWriter.computeAnnotationsSize(text) - 8);
+      value3++;
+      value2 = value5;
+    }
+    return value2;
+  }
+
+  @Override
+  public AnnotationVisitor visitArray(String text) {
+    this.count++;
+    if (this.useNamedValues) {
+      this.annotation.putShort(this.symbolTable.addConstantUtf8(text));
+    }
+    this.annotation.put12(91, 0);
+    return new AnnotationWriter(this.symbolTable, false, this.annotation, null);
+  }
+
+  public static int computeAnnotationsSize(
+      AnnotationWriter annotationWriter,
+      AnnotationWriter annotationWriter2,
+      AnnotationWriter annotationWriter3,
+      AnnotationWriter annotationWriter4) {
+    int value = 0;
+    if (annotationWriter != null) {
+      value += annotationWriter.computeAnnotationsSize("RuntimeVisibleAnnotations");
+    }
+    if (annotationWriter2 != null) {
+      value += annotationWriter2.computeAnnotationsSize("RuntimeInvisibleAnnotations");
+    }
+    if (annotationWriter3 != null) {
+      value += annotationWriter3.computeAnnotationsSize("RuntimeVisibleTypeAnnotations");
+    }
+    if (annotationWriter4 != null) {
+      value += annotationWriter4.computeAnnotationsSize("RuntimeInvisibleTypeAnnotations");
+    }
+    return value;
+  }
+
+  public AnnotationWriter(
+      SymbolTable symbolTable2,
+      boolean useNamedValues,
+      ByteVector byteVector,
+      AnnotationWriter annotationWriter) {
+    super(589824);
+    this.symbolTable = symbolTable2;
+    this.useNamedValues = useNamedValues;
+    this.annotation = byteVector;
+    this.numElementValuePairsOffset = byteVector.length == 0 ? -1 : byteVector.length - 2;
+    if ((this.previousAnnotation = annotationWriter) != null) {
+      annotationWriter.nextAnnotation = this;
+    }
+  }
+
+  public void putAnnotations(int value, ByteVector byteVector) {
+    int value2 = 2;
+    int value3 = 0;
+    AnnotationWriter annotationWriter = this;
+    AnnotationWriter annotationWriter2 = null;
+    AnnotationWriter annotationWriter3 = this;
+    while (annotationWriter3 != null) {
+      annotationWriter.visitEnd();
+      ByteVector byteVector2 = annotationWriter.annotation;
+      int value4 = value2;
+      AnnotationWriter annotationWriter4 = annotationWriter;
+      AnnotationWriter annotationWriter5 = annotationWriter;
+      value3++;
+      value2 = value4 + byteVector2.length;
+      annotationWriter2 = annotationWriter4;
+      annotationWriter3 = annotationWriter = annotationWriter5.previousAnnotation;
+    }
+    byteVector.putShort(value);
+    byteVector.putInt(value2);
+    byteVector.putShort(value3);
+    AnnotationWriter annotationWriter6 = annotationWriter2;
+    for (AnnotationWriter annotationWriter7 = annotationWriter6;
+        annotationWriter7 != null;
+        annotationWriter7 = annotationWriter6) {
+      byteVector.putByteArray(
+          annotationWriter6.annotation.data, 0, annotationWriter6.annotation.length);
+      annotationWriter6 = annotationWriter6.nextAnnotation;
+    }
+  }
+
+  @Override
+  public void visitEnd() {
+    if (this.numElementValuePairsOffset != -1) {
+      byte[] values = this.annotation.data;
+      values[this.numElementValuePairsOffset] = (byte) (this.count >>> 8);
+      values[this.numElementValuePairsOffset + 1] = (byte) this.count;
+    }
+  }
+}

src/main/java/com/allatori/lib/asm/Attribute$Set.java

@@ -0,0 +1,47 @@
+package com.allatori.lib.asm;
+
+public final class Attribute$Set {
+
+  public static final int SIZE_INCREMENT = 6;
+
+  public int size;
+
+  public Attribute[] data = new Attribute[6];
+
+  public void addAttributes(Attribute attribute) {
+    Attribute attribute2;
+    for (Attribute attribute3 = attribute2 = attribute;
+        attribute3 != null;
+        attribute3 = attribute2 = attribute2.nextAttribute) {
+      if (!this.contains(attribute2)) {
+        this.add(attribute2);
+      }
+    }
+  }
+
+  public Attribute[] toArray() {
+    Attribute[] attributes = new Attribute[this.size];
+    System.arraycopy(this.data, 0, attributes, 0, this.size);
+    return attributes;
+  }
+
+  public void add(Attribute attribute) {
+    if (this.size >= this.data.length) {
+      Attribute[] attributes;
+      Attribute[] attributes2 = attributes = new Attribute[this.data.length + 6];
+      System.arraycopy(this.data, 0, attributes, 0, this.size);
+      this.data = attributes2;
+    }
+    this.data[this.size++] = attribute;
+  }
+
+  public boolean contains(Attribute attribute) {
+    int value;
+    for (int value2 = value = 0; value2 < this.size; value2 = ++value) {
+      if (this.data[value].type.equals(attribute.type)) {
+        return true;
+      }
+    }
+    return false;
+  }
+}

src/main/java/com/allatori/lib/asm/Attribute.java

@@ -0,0 +1,160 @@
+package com.allatori.lib.asm;
+
+public class Attribute {
+
+  public Attribute nextAttribute;
+
+  public final String type;
+
+  public ByteVector cachedContent;
+
+  public static Attribute read(
+      Attribute attribute,
+      ClassReader classReader,
+      int value,
+      int value2,
+      char[] values,
+      int value3,
+      Label[] labels) {
+    return attribute.read(classReader, value, value2, values, value3, labels);
+  }
+
+  public final int computeAttributesSize(SymbolTable symbolTable) {
+    return this.computeAttributesSize(symbolTable, (byte[]) (Object) null, 0, -1, -1);
+  }
+
+  public boolean isEnabled() {
+    return true;
+  }
+
+  @Deprecated
+  public Label[] getLabels() {
+    return new Label[0];
+  }
+
+  public final void putAttributes(SymbolTable symbolTable, ByteVector byteVector) {
+    this.putAttributes(symbolTable, (byte[]) (Object) null, 0, -1, -1, byteVector);
+  }
+
+  public static int computeAttributesSize(SymbolTable symbolTable, int value, int value2) {
+    int value3 = 0;
+    if ((value & 4096) != 0 && symbolTable.getCount() < 49) {
+      value3 += 6;
+      symbolTable.addConstantUtf8("Synthetic");
+    }
+    if (value2 != 0) {
+      value3 += 8;
+      symbolTable.addConstantUtf8("Signature");
+    }
+    if ((value & 131072) != 0) {
+      value3 += 6;
+      symbolTable.addConstantUtf8("Deprecated");
+    }
+    return value3;
+  }
+
+  public Attribute read(
+      ClassReader classReader, int value, int value2, char[] values, int value3, Label[] labels) {
+    Attribute attribute = new Attribute(this.type);
+    attribute.cachedContent = new ByteVector(classReader.readBytes(value, value2));
+    return attribute;
+  }
+
+  public final int getAttributeCount() {
+    int value = 0;
+    Attribute attribute;
+    Attribute attribute2 = attribute = this;
+    while (attribute2 != null) {
+      Attribute attribute3 = attribute.nextAttribute;
+      Attribute attribute4 = attribute.nextAttribute;
+      value++;
+      attribute2 = attribute4;
+      attribute = attribute3;
+    }
+    return value;
+  }
+
+  public ByteVector getByteVector(
+      ClassWriter classWriter, byte[] values, int value, int value2, int value3) {
+    if (this.cachedContent == null) {
+      this.cachedContent = this.getByteVector2(classWriter, values, value, value2, value3);
+    }
+    return this.cachedContent;
+  }
+
+  public boolean isEnabled2() {
+    return false;
+  }
+
+  public final int computeAttributesSize(
+      SymbolTable symbolTable, byte[] values, int value, int value2, int value3) {
+    ClassWriter classWriter2 = symbolTable.classWriter;
+    int value4 = 0;
+    Attribute attribute;
+    for (Attribute attribute2 = attribute = this; attribute2 != null; attribute2 = attribute) {
+      symbolTable.addConstantUtf8(attribute.type);
+      value4 += 6 + attribute.getByteVector(classWriter2, values, value, value2, value3).length;
+      attribute = attribute.nextAttribute;
+    }
+    return value4;
+  }
+
+  public ByteVector getByteVector2(
+      ClassWriter classWriter, byte[] values, int value, int value2, int value3) {
+    return this.cachedContent;
+  }
+
+  public static byte[] write(
+      Attribute attribute,
+      ClassWriter classWriter,
+      byte[] values,
+      int value,
+      int value2,
+      int value3) {
+    ByteVector byteVector;
+    ByteVector byteVector2 =
+        byteVector = attribute.getByteVector(classWriter, values, value, value2, value3);
+    byte[] values2 = new byte[byteVector2.length];
+    System.arraycopy(byteVector2.data, 0, values2, 0, byteVector.length);
+    return values2;
+  }
+
+  public static void putAttributes(
+      SymbolTable symbolTable, int value, int value2, ByteVector byteVector) {
+    if ((value & 4096) != 0 && symbolTable.getCount() < 49) {
+      byteVector.putShort(symbolTable.addConstantUtf8("Synthetic")).putInt(0);
+    }
+    if (value2 != 0) {
+      byteVector.putShort(symbolTable.addConstantUtf8("Signature")).putInt(2).putShort(value2);
+    }
+    if ((value & 131072) != 0) {
+      byteVector.putShort(symbolTable.addConstantUtf8("Deprecated")).putInt(0);
+    }
+  }
+
+  public static Label readLabel(ClassReader classReader, int value, Label[] labels) {
+    return classReader.createLabel(value, labels);
+  }
+
+  public Attribute(String type) {
+    super();
+    this.type = type;
+  }
+
+  public final void putAttributes(
+      SymbolTable symbolTable,
+      byte[] values,
+      int value,
+      int value2,
+      int value3,
+      ByteVector byteVector) {
+    ClassWriter classWriter2 = symbolTable.classWriter;
+    Attribute attribute;
+    for (Attribute attribute2 = attribute = this; attribute2 != null; attribute2 = attribute) {
+      ByteVector byteVector2 = attribute.getByteVector(classWriter2, values, value, value2, value3);
+      byteVector.putShort(symbolTable.addConstantUtf8(attribute.type)).putInt(byteVector2.length);
+      byteVector.putByteArray(byteVector2.data, 0, byteVector2.length);
+      attribute = attribute.nextAttribute;
+    }
+  }
+}

src/main/java/com/allatori/lib/asm/ByteVector.java

@@ -0,0 +1,364 @@
+package com.allatori.lib.asm;
+
+public class ByteVector {
+
+  public int length;
+
+  public byte[] data = new byte[64];
+
+  public final ByteVector encodeUtf8(String text, int value, int value2) {
+    int size = text.length();
+    int value3 = value;
+    int value4;
+    for (int value5 = value4 = value; value5 < size; value5 = ++value4) {
+      char value6;
+      if ((value6 = text.charAt(value4)) >= 1 && value6 <= 127) {
+        value3++;
+      } else if (value6 <= 2047) {
+        value3 += 2;
+      } else {
+        value3 += 3;
+      }
+    }
+    if (value3 > value2) {
+      throw new IllegalArgumentException("UTF8 string too large");
+    }
+    int value7;
+    if ((value7 = this.length - value - 2) >= 0) {
+      this.data[value7] = (byte) (value3 >>> 8);
+      this.data[value7 + 1] = (byte) value3;
+    }
+    if (this.length + value3 - value > this.data.length) {
+      this.enlarge(value3 - value);
+    }
+    int value8 = this.length;
+    int value9;
+    for (int value10 = value9 = value; value10 < size; value10 = ++value9) {
+      char value11;
+      if ((value11 = text.charAt(value9)) >= 1 && value11 <= 127) {
+        byte value12 = (byte) value11;
+        int value13 = value8;
+        byte[] values = this.data;
+        value8++;
+        values[value13] = value12;
+      } else if (value11 <= 2047) {
+        char value14 = value11;
+        int value15 = value8;
+        byte[] values2 = this.data;
+        value8++;
+        values2[value15] = (byte) ((short) 192 | value14 >> (byte) 6 & 31);
+        char value16 = value11;
+        int value17 = value8;
+        byte[] values3 = this.data;
+        value8++;
+        values3[value17] = (byte) ((short) 128 | value16 & (byte) 63);
+      } else {
+        char value18 = value11;
+        int value19 = value8;
+        byte[] values4 = this.data;
+        value8++;
+        values4[value19] = (byte) ((short) 224 | value18 >> (byte) 12 & 15);
+        char value20 = value11;
+        int value21 = value8;
+        byte[] values5 = this.data;
+        value8++;
+        values5[value21] = (byte) ((short) 128 | value20 >> (byte) 6 & 63);
+        char value22 = value11;
+        int value23 = value8;
+        byte[] values6 = this.data;
+        value8++;
+        values6[value23] = (byte) ((short) 128 | value22 & (byte) 63);
+      }
+    }
+    this.length = value8;
+    return this;
+  }
+
+  public int size() {
+    return this.length;
+  }
+
+  public ByteVector putInt(int value) {
+    int value2 = this.length;
+    if (this.length + 4 > this.data.length) {
+      this.enlarge(4);
+    }
+    int value3 = value >>> 24;
+    int value4 = value2;
+    byte[] values = this.data;
+    byte[] values2 = this.data;
+    byte[] values3 = this.data;
+    byte[] values4 = this.data;
+    value2++;
+    values[value4] = (byte) value3;
+    int value5 = value >>> 16;
+    int value6 = value2;
+    value2++;
+    values2[value6] = (byte) value5;
+    int value7 = value >>> 8;
+    int value8 = value2;
+    value2++;
+    values3[value8] = (byte) value7;
+    byte value9 = (byte) value;
+    int value10 = value2;
+    value2++;
+    values4[value10] = value9;
+    this.length = value2;
+    return this;
+  }
+
+  public final ByteVector put112(int value, int value2, int value3) {
+    int value4 = this.length;
+    if (this.length + 4 > this.data.length) {
+      this.enlarge(4);
+    }
+    byte value5 = (byte) value;
+    int value6 = value4;
+    byte[] values = this.data;
+    byte[] values2 = this.data;
+    byte[] values3 = this.data;
+    byte[] values4 = this.data;
+    value4++;
+    values[value6] = value5;
+    byte value7 = (byte) value2;
+    int value8 = value4;
+    value4++;
+    values2[value8] = value7;
+    int value9 = value3 >>> 8;
+    int value10 = value4;
+    value4++;
+    values3[value10] = (byte) value9;
+    byte value11 = (byte) value3;
+    int value12 = value4;
+    value4++;
+    values4[value12] = value11;
+    this.length = value4;
+    return this;
+  }
+
+  public ByteVector putByteArray(byte[] values, int value, int length) {
+    if (this.length + length > this.data.length) {
+      this.enlarge(length);
+    }
+    if (values != null) {
+      System.arraycopy(values, value, this.data, this.length, length);
+    }
+    this.length += length;
+    return this;
+  }
+
+  public final ByteVector put12(int value, int value2) {
+    int value3 = this.length;
+    if (this.length + 3 > this.data.length) {
+      this.enlarge(3);
+    }
+    byte value4 = (byte) value;
+    int value5 = value3;
+    byte[] values = this.data;
+    byte[] values2 = this.data;
+    byte[] values3 = this.data;
+    value3++;
+    values[value5] = value4;
+    int value6 = value2 >>> 8;
+    int value7 = value3;
+    value3++;
+    values2[value7] = (byte) value6;
+    byte value8 = (byte) value2;
+    int value9 = value3;
+    value3++;
+    values3[value9] = value8;
+    this.length = value3;
+    return this;
+  }
+
+  public final ByteVector put11(int value, int value2) {
+    int value3 = this.length;
+    if (this.length + 2 > this.data.length) {
+      this.enlarge(2);
+    }
+    byte value4 = (byte) value;
+    int value5 = value3;
+    byte[] values = this.data;
+    byte[] values2 = this.data;
+    value3++;
+    values[value5] = value4;
+    byte value6 = (byte) value2;
+    int value7 = value3;
+    value3++;
+    values2[value7] = value6;
+    this.length = value3;
+    return this;
+  }
+
+  public void enlarge(int value) {
+    if (this.length > this.data.length) {
+      throw new AssertionError("Internal error");
+    }
+    int value2 = 2 * this.data.length;
+    int value3 = this.length + value;
+    byte[] values;
+    byte[] values2 = values = new byte[value2 > value3 ? value2 : value3];
+    System.arraycopy(this.data, 0, values, 0, this.length);
+    this.data = values2;
+  }
+
+  public ByteVector() {}
+
+  public final ByteVector put122(int value, int value2, int value3) {
+    int value4 = this.length;
+    if (this.length + 5 > this.data.length) {
+      this.enlarge(5);
+    }
+    byte value5 = (byte) value;
+    int value6 = value4;
+    byte[] values = this.data;
+    byte[] values2 = this.data;
+    byte[] values3 = this.data;
+    byte[] values4 = this.data;
+    byte[] values5 = this.data;
+    value4++;
+    values[value6] = value5;
+    int value7 = value2 >>> 8;
+    int value8 = value4;
+    value4++;
+    values2[value8] = (byte) value7;
+    byte value9 = (byte) value2;
+    int value10 = value4;
+    value4++;
+    values3[value10] = value9;
+    int value11 = value3 >>> 8;
+    int value12 = value4;
+    value4++;
+    values4[value12] = (byte) value11;
+    byte value13 = (byte) value3;
+    int value14 = value4;
+    value4++;
+    values5[value14] = value13;
+    this.length = value4;
+    return this;
+  }
+
+  public ByteVector(byte[] data) {
+    super();
+    this.data = data;
+    this.length = data.length;
+  }
+
+  public ByteVector putShort(int value) {
+    int value2 = this.length;
+    if (this.length + 2 > this.data.length) {
+      this.enlarge(2);
+    }
+    int value3 = value >>> 8;
+    int value4 = value2;
+    byte[] values = this.data;
+    byte[] values2 = this.data;
+    value2++;
+    values[value4] = (byte) value3;
+    byte value5 = (byte) value;
+    int value6 = value2;
+    value2++;
+    values2[value6] = value5;
+    this.length = value2;
+    return this;
+  }
+
+  public ByteVector putLong(long value) {
+    int value2 = this.length;
+    if (this.length + 8 > this.data.length) {
+      this.enlarge(8);
+    }
+    byte[] values = this.data;
+    int value3 = (int) (value >>> 32);
+    int value4 = value3 >>> 24;
+    int value5 = value2;
+    value2++;
+    values[value5] = (byte) value4;
+    int value6 = value3 >>> 16;
+    int value7 = value2;
+    value2++;
+    values[value7] = (byte) value6;
+    int value8 = value3 >>> 8;
+    int value9 = value2;
+    value2++;
+    values[value9] = (byte) value8;
+    byte value10 = (byte) value3;
+    int value11 = value2;
+    value2++;
+    values[value11] = value10;
+    int value12 = (int) value;
+    int value13 = value12 >>> 24;
+    int value14 = value2;
+    value2++;
+    values[value14] = (byte) value13;
+    int value15 = value12 >>> 16;
+    int value16 = value2;
+    value2++;
+    values[value16] = (byte) value15;
+    int value17 = value12 >>> 8;
+    int value18 = value2;
+    value2++;
+    values[value18] = (byte) value17;
+    byte value19 = (byte) value12;
+    int value20 = value2;
+    value2++;
+    values[value20] = value19;
+    this.length = value2;
+    return this;
+  }
+
+  public ByteVector putByte(int value) {
+    int value2 = this.length;
+    if (this.length + 1 > this.data.length) {
+      this.enlarge(1);
+    }
+    byte value3 = (byte) value;
+    int value4 = value2;
+    byte[] values = this.data;
+    value2++;
+    values[value4] = value3;
+    this.length = value2;
+    return this;
+  }
+
+  public ByteVector(int value) {
+    super();
+    this.data = new byte[value];
+  }
+
+  public ByteVector putUTF8(String text) {
+    int value;
+    if ((value = text.length()) > 65535) {
+      throw new IllegalArgumentException("UTF8 string too large");
+    }
+    int value2 = this.length;
+    if (this.length + 2 + value > this.data.length) {
+      this.enlarge(2 + value);
+    }
+    byte[] values = this.data;
+    int value3 = value >>> 8;
+    int value4 = value2;
+    byte[] values2 = this.data;
+    byte[] values3 = this.data;
+    value2++;
+    values2[value4] = (byte) value3;
+    byte value5 = (byte) value;
+    int value6 = value2;
+    value2++;
+    values3[value6] = value5;
+    int value7;
+    for (int value8 = value7 = 0; value8 < value; value8 = ++value7) {
+      char value9;
+      if ((value9 = text.charAt(value7)) < 1 || value9 > 127) {
+        this.length = value2;
+        return this.encodeUtf8(text, value7, 65535);
+      }
+      byte value10 = (byte) value9;
+      int value11 = value2;
+      value2++;
+      values[value11] = value10;
+    }
+    this.length = value2;
+    return this;
+  }
+}

src/main/java/com/allatori/lib/asm/ClassTooLargeException.java

@@ -0,0 +1,28 @@
+package com.allatori.lib.asm;
+
+public final class ClassTooLargeException extends IndexOutOfBoundsException {
+
+  public final int constantPoolCount;
+
+  public final String className;
+
+  public static final long serialVersionUID = 160715609518896765L;
+
+  public int getConstantPoolCount() {
+    return this.constantPoolCount;
+  }
+
+  public String getClassName() {
+    return this.className;
+  }
+
+  public ClassTooLargeException(String className, int constantPoolCount) {
+    super(stringConcat$0(className));
+    this.className = className;
+    this.constantPoolCount = constantPoolCount;
+  }
+
+  public static String stringConcat$0(String text) {
+    return "Class too large: " + text;
+  }
+}