From 324e11722f63d77b43bbea83af7df5d3a9afcb04 Mon Sep 17 00:00:00 2001
From: obvWolf <crvn152006@gmail.com>
Date: Mon, 6 Nov 2023 22:36:41 -0600
Subject: [PATCH] Making a universal intObf that can dynamicaly toggle the
 complexers and increasers that it uses (currently failing at it though)

---
 .idea/jarRepositories.xml                     |   5 +
 build.gradle                                  |   7 +-
 .../me/trouper/{Main.java => Countroll.java}  |  37 +++---
 .../java/me/trouper/Data/ConfigManager.java   |  76 +++++++++++++
 .../java/me/trouper/Functions/Complexers.java |  55 ++++-----
 src/main/java/me/trouper/Functions/Eval.java  |  19 +---
 .../java/me/trouper/Functions/Increasers.java |  43 +++++--
 src/main/java/me/trouper/Functions/Obf.java   | 107 +++++++++++++-----
 src/main/java/me/trouper/Utils/Utils.java     |  35 ++++--
 src/main/java/me/trouper/Utils/Verbose.java   |  29 ++++-
 src/main/resources/Manifest.mf                |   2 +-
 11 files changed, 309 insertions(+), 106 deletions(-)
 rename src/main/java/me/trouper/{Main.java => Countroll.java} (84%)
 create mode 100644 src/main/java/me/trouper/Data/ConfigManager.java

diff --git a/.idea/jarRepositories.xml b/.idea/jarRepositories.xml
index fdc392f..9bc006e 100644
--- a/.idea/jarRepositories.xml
+++ b/.idea/jarRepositories.xml
@@ -16,5 +16,10 @@
       <option name="name" value="MavenRepo" />
       <option name="url" value="https://repo.maven.apache.org/maven2/" />
     </remote-repository>
+    <remote-repository>
+      <option name="id" value="maven" />
+      <option name="name" value="maven" />
+      <option name="url" value="https://nexus.stirante.com/repository/maven-snapshots/" />
+    </remote-repository>
   </component>
 </project>
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
index 98b7a2f..9036833 100644
--- a/build.gradle
+++ b/build.gradle
@@ -7,11 +7,14 @@ version '0.0.4'
 
 repositories {
     mavenCentral()
+    maven {
+        url 'https://nexus.stirante.com/repository/maven-snapshots/'
+    }
 }
 
 dependencies {
     implementation 'net.objecthunter:exp4j:0.4.8'
-    implementation 'com.ezylang:EvalEx:3.0.5'
+    implementation group: 'com.google.code.gson', name: 'gson', version: '2.7'
     testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1'
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
 }
@@ -22,7 +25,7 @@ test {
 
 jar {
     manifest {
-        attributes 'Main-Class': 'me.trouper.Main'
+        attributes 'Main-Class': 'me.trouper.Countroll'
     }
     from {
         configurations.runtimeClasspath.collect {
diff --git a/src/main/java/me/trouper/Main.java b/src/main/java/me/trouper/Countroll.java
similarity index 84%
rename from src/main/java/me/trouper/Main.java
rename to src/main/java/me/trouper/Countroll.java
index 76f700d..ce66c30 100644
--- a/src/main/java/me/trouper/Main.java
+++ b/src/main/java/me/trouper/Countroll.java
@@ -1,23 +1,26 @@
 package me.trouper;
 
+import me.trouper.Data.ConfigManager;
 import me.trouper.Functions.Complexers;
 import me.trouper.Functions.Obf;
 import me.trouper.Utils.Timer;
 import me.trouper.Utils.Utils;
+import me.trouper.Utils.Verbose;
 
 import java.util.Scanner;
 
 import static me.trouper.Functions.Eval.eval;
-import static me.trouper.Functions.Eval.evalM;
 import static me.trouper.Utils.Utils.removeColors;
 
-public class Main {
-    public static boolean verbose;
+public class Countroll {
+    public static boolean doCopy;
     public static boolean deep;
     public static boolean color;
     public static boolean printHelp;
+    public static String mode;
 
     /* Statistics */
+    public static int errorCount = 0;
     public static int expCount = 0;
     public static int factorCount = 0;
     public static int addCount = 0;
@@ -41,32 +44,36 @@ public class Main {
          rootCount = 0;
          perfectCount = 0;
          total = 0;
+         errorCount = 0;
     }
     public static void main(String[] args) {
+
         Scanner scanner = new Scanner(System.in);
-        boolean doCopy = false;
-        String mode = "N";
+        ConfigManager.loadConfig();
 
         for (String arg : args) {
             switch (arg) {
                 case "--copy", "-c" -> doCopy = true;
-                case "--verbose", "-v" -> verbose = true;
+                case "--verbose", "-v" -> Verbose.all = true;
                 case "--deep", "-d" -> deep = true;
                 case "--color", "-rgb" -> color = true;
                 case "--help", "--h", "-h" -> printHelp = true;
-                case "--mode=numselli", "-m=n" -> mode = "N";
+                case "--mode=test", "-m=t" -> mode = "TEST";
                 case "--mode=duckgroup", "-m=d" -> mode = "D";
-                case "--mode=TEST", "-m=t" -> mode = "TEST";
+                case "--mode=numselli", "-m=n" -> mode = "N";
+                case "--mode=universal", "-m=u" -> mode = "U";
             }
         }
 
+        Verbose.send("INIT","Loading config");
 
-        Complexers.useRoot = !mode.equals("D");
+        Verbose.send("INIT","Config loaded, mode: " + mode);
+        Complexers.useRoot = true;
         Complexers.usePower = true;
         Complexers.useDivide = true;
         Complexers.useRDivisor = true;
         Complexers.useRDividend = true;
-
+        if (mode.equals("D")) Complexers.useRoot = false;
 
         if (mode.equals("TEST")) {
             while (true) {
@@ -78,7 +85,7 @@ public class Main {
                 }
 
                 try {
-                    double result = evalM(userInput);
+                    double result = eval(userInput);
                     System.out.println("Result: " + result);
                 } catch (Exception e) {
                     System.out.println("Error: " + e.getMessage());
@@ -95,14 +102,14 @@ public class Main {
                 int target = scanner.nextInt();
                 Timer obfTimer = Timer.start();
                 String expression = null;
-                switch (mode) {
-                    case "N" -> expression = Obf.obfIntN(target, deep);
-                    case "D" -> expression = Obf.obfIntD(target, deep);
-                }
+
+                expression = Obf.obfIntN(target,deep);
+
                 long obfTime = obfTimer.end().timePassed();
                 double output = eval(removeColors(expression));
 
                 System.out.println("\nStatistics" +
+                        "\nErrors: " + errorCount +
                         "\nExponents: " + expCount +
                         "\nFactors: " + factorCount +
                         "\nAdditions: " + addCount +
diff --git a/src/main/java/me/trouper/Data/ConfigManager.java b/src/main/java/me/trouper/Data/ConfigManager.java
new file mode 100644
index 0000000..0bd73ad
--- /dev/null
+++ b/src/main/java/me/trouper/Data/ConfigManager.java
@@ -0,0 +1,76 @@
+package me.trouper.Data;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonIOException;
+import com.google.gson.JsonSyntaxException;
+import me.trouper.Countroll;
+import me.trouper.Utils.Verbose;
+
+import java.io.*;
+import java.util.HashMap;
+import java.util.Map;
+
+public class ConfigManager {
+    private static final String CONFIG_FILENAME = "countroll.json";
+
+    public static void loadConfig() {
+        File configFile = new File(CONFIG_FILENAME);
+
+        if (!configFile.exists()) {
+            generateDefaultConfig();
+        } else {
+            try (Reader reader = new FileReader(configFile)) {
+                Gson gson = new Gson();
+                Map<String, Object> config = gson.fromJson(reader, HashMap.class);
+                setMainClassVariables(config);
+            } catch (JsonSyntaxException | JsonIOException | IOException e) {
+                e.printStackTrace();
+                generateDefaultConfig();
+            }
+        }
+    }
+
+    private static void generateDefaultConfig() {
+        Map<String, Object> defaultConfig = new HashMap<>();
+        defaultConfig.put("doCopy", false);
+        defaultConfig.put("deep", false);
+        defaultConfig.put("color", false);
+        defaultConfig.put("printHelp", false);
+        defaultConfig.put("mode", "N");
+        defaultConfig.put("verbose.all",false);
+        defaultConfig.put("verbose.processes",true);
+        defaultConfig.put("verbose.loops",false);
+        defaultConfig.put("verbose.eval",false);
+        defaultConfig.put("verbose.complexers",false);
+        defaultConfig.put("verbose.increasers",false);
+        defaultConfig.put("verbose.utils",false);
+        defaultConfig.put("verbose.errors",true);
+
+        try (Writer writer = new FileWriter(CONFIG_FILENAME)) {
+            Gson gson = new GsonBuilder().setPrettyPrinting().create();
+            gson.toJson(defaultConfig, writer);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        setMainClassVariables(defaultConfig);
+    }
+
+    private static void setMainClassVariables(Map<String, Object> config) {
+        Verbose.send("INIT", "Loading main class variables");
+        Countroll.doCopy = (boolean) config.get("doCopy");
+        Countroll.deep = (boolean) config.get("deep");
+        Countroll.color = (boolean) config.get("color");
+        Countroll.printHelp = (boolean) config.get("printHelp");
+        Countroll.mode = (String) config.get("mode");
+        Verbose.all = (boolean) config.get("verbose.all");
+        Verbose.processes = (boolean) config.get("verbose.processes");
+        Verbose.loops = (boolean) config.get("verbose.loops");
+        Verbose.eval = (boolean) config.get("verbose.eval");
+        Verbose.complexers = (boolean) config.get("verbose.complexers");
+        Verbose.increasers = (boolean) config.get("verbose.increasers");
+        Verbose.utils = (boolean) config.get("verbose.utils");
+        Verbose.errors = (boolean) config.get("verbose.errors");
+        Verbose.send("INIT","mode = " + Countroll.mode);
+    }
+}
diff --git a/src/main/java/me/trouper/Functions/Complexers.java b/src/main/java/me/trouper/Functions/Complexers.java
index c63c12e..c24860a 100644
--- a/src/main/java/me/trouper/Functions/Complexers.java
+++ b/src/main/java/me/trouper/Functions/Complexers.java
@@ -1,7 +1,8 @@
 package me.trouper.Functions;
 
-import me.trouper.Main;
+import me.trouper.Countroll;
 import me.trouper.Utils.Utils;
+import me.trouper.Utils.Verbose;
 
 import java.util.*;
 
@@ -40,6 +41,7 @@ public class Complexers {
                 return divide(i,deep);
             }
             case "power" -> {
+                if (!isPerfectSquare(i)) return complex(i,deep);
                 return power(i,deep);
             }
             case "root" -> {
@@ -49,7 +51,7 @@ public class Complexers {
                 return mRootDividend(i,deep);
             }
             case "mrDivisor" -> {
-                return mRootDivisor(i,deep);
+                return mRootDivisor(i,false);
             }
             default -> {
                 return divide(i,false);
@@ -62,21 +64,20 @@ public class Complexers {
      * @return Colored String
      */
     public static String divide(int i, boolean deep) {
-        Main.divideCount++;
+        Verbose.send("COMP", "Running Divide Complexer, I:" + i + " Deep: " + deep);
+        Countroll.divideCount++;
         Random random = new Random();
 
         int factor = random.nextInt(9)+1;
         int doubled = i * factor;
-        boolean expFac = false;
-        boolean expDoub = false;
 
         String result = "<&f>(<&r><&e>" + doubled + "<&b>/<&r><&e>" + factor + "<&f>)<&r>";
 
         if (deep) {
             result = "<&3>(<&r><&d>" + (complex(doubled,false)) + "<&b>/<&r><&d>" + (complex(factor,false)) + "<&3>)<&r>";
         }
-        if (eval(result) != i) Utils.verbose("Failed to divide " + i + ", Attempted: " + result + "=" + eval(result));
-        return eval(result) == i ? result : "(" + i + ")";
+        if (eval(result) != i) Verbose.send("ERR","<&ch>Failed to divide <&r>" + i + ", Attempted: " + result + "=" + eval(result));
+        return eval(result) == i ? result : "<&ch>(" + i + ")<&r>";
     }
 
     /**
@@ -86,10 +87,8 @@ public class Complexers {
      * @return Colored String
      */
     public static String power(int i, boolean deep) {
-        Main.powerCount++;
-        if (!Eval.isPerfectSquare(i)) {
-            return "(" + i + ")";
-        }
+        Verbose.send("COMP", "Running Power Complexer, I:" + i + " Deep: " + deep);
+        Countroll.powerCount++;
 
         int root = (int) Math.sqrt(i);
         String result =  "<&r><&f>(<&e>" + root + "<&b>^<&e>2<&f>)<&r>";
@@ -97,8 +96,8 @@ public class Complexers {
         if (deep) {
             result = "<&r><&3>(<&d>" + complex(root,false) + "<&b>^<&d>2<&3>)<&r>";
         }
-        if (eval(result) != i) Utils.verbose("<&ch>Failed to power <&r>" + i + ", Attempted: " + result + "=" + eval(result));
-        return eval(result) == i ? result : "(" + i + ")";
+        if (eval(result) != i) Verbose.send("ERR","<&ch>Failed to power <&r>" + i + ", Attempted: " + result + "=" + eval(result));
+        return eval(result) == i ? result : "<&ch>(" + i + ")<&r>";
     }
 
     /**
@@ -107,15 +106,16 @@ public class Complexers {
      * @return Colored String
      */
     public static String root(int i, boolean deep) {
-        Main.rootCount++;
+        Verbose.send("COMP", "Running Root Complexer, I:" + i + " Deep: " + deep);
+        Countroll.rootCount++;
         int squared = (int) Math.pow(i,2);
         String result = "<&9>sqrt<&r><&f>(<&r><&e>" + squared + "<&f>)<&r>";
 
         if (deep) {
             result = "<&1>sqrt<&r><&3>(<&r><&d>" + complex(squared, false) + "<&3>)<&r>";
         }
-        if (eval(result) != i) Utils.verbose("<&ch>Failed to root <&r>" + i + ", Attempted: " + result + "=" + eval(result));
-        return (eval(result) == i) ? result : "(" + i + ")";
+        if (eval(result) != i) Verbose.send("ERR","<&ch>Failed to root <&r>" + i + ", Attempted: " + result + "=" + eval(result));
+        return (eval(result) == i) ? result : "<&ch>(" + i + ")<&r>";
     }
 
     /**
@@ -124,22 +124,24 @@ public class Complexers {
      * @return Colored string
      */
     public static String mRootDivisor(int i, boolean deep) {
-        Main.rDivisorCount++;
+        Verbose.send("COMP", "Running mrDivisor Complexer, I:" + i + " Deep: " + deep);
+        Countroll.rDivisorCount++;
         Random random = new Random();
-        int dividend = random.nextInt(9)+i+10;
+        int dividend = random.nextInt(9)+random.nextInt(48)+1+i;
         int divisor = Utils.moduRootDivisor(dividend,i);
         String result = "<&r><&f>(<&e>" + dividend + "<&b>%<&e>" + divisor + "<&f>)<&r>";
         if (deep) {
-            result = "<&r><&7>(<&d>" + complex(dividend,false) + "<&b>%<&d>" + complex(divisor, false) + "<&7>)<&r>";
+            result = "<&r><&7>(<&d>" + complex(dividend,false) + "<&b>%<&d>" + complex(divisor,false) + "<&7>)<&r>";
         }
-        Utils.verbose("<&dh><&b>mRootDivisor has ran!<&r>" +
+
+        Verbose.send("COMP","<&dh><&b>mRootDivisor has ran!<&r>" +
                 "\nWanted: " + i +
                 "\nDivisor: " + divisor +
                 "\nDividend: " + dividend +
                 "\nCheck: " + dividend + "%" + divisor + "=" + i +
                 "\nResult: " + result);
-        if (eval(result) != i) Utils.verbose("<&ch>Failed to mRootDivisor<&r> " + i + ", Attempted: " + result + "=" + eval(result));
-        return (eval(result) == i) ? result : "(" + i + ")";
+        if (eval(result) != i) Verbose.send("ERR","<&ch>Failed to mRootDivisor<&r> " + i + ", Attempted: " + result + "=" + eval(result));
+        return (eval(result) == i) ? result : mRootDividend(i,false);
     }
 
     /**
@@ -148,7 +150,8 @@ public class Complexers {
      * @return Colored String
      */
     public static String mRootDividend(int i, boolean deep) {
-        Main.rDividendCount++;
+        Verbose.send("COMP", "Running mrDividend Complexer, I:" + i + " Deep: " + deep);
+        Countroll.rDividendCount++;
         Random random = new Random();
         int divisor = random.nextInt(9)+i+10;
         int dividend = Utils.moduRootDividend(divisor,i);
@@ -156,14 +159,14 @@ public class Complexers {
         if (deep) {
             result = "<&r><&7>(<&d>" + complex(dividend,false) + "<&b>%<&d>" + complex(divisor,false)  + "<&7>)<&r>";
         }
-        Utils.verbose("<&dh><&b>mRootDividend has been ran!<&r>" +
+        Verbose.send("COMP","<&dh><&b>mRootDividend has been ran!<&r>" +
                 "\nWanted:" + i +
                 "\nDivisor: " + divisor +
                 "\nDividend: " + dividend +
                 "\nCheck: " + dividend + "%" + divisor + "=" + i +
                 "\nResult: " + result);
-        if (eval(result) != i) Utils.verbose("<&ch>Failed to mRootDividend<&r> " + i + ", Attempted: " + result + "=" + eval(result));
-        return (eval(result) == i) ? result : "(" + i + ")";
+        if (eval(result) != i) Verbose.send("ERR","<&ch>Failed to mRootDividend<&r> " + i + ", Attempted: " + result + "=" + eval(result));
+        return (eval(result) == i) ? result : "<&ch>(" + i + ")<&r>";
 
     }
 }
diff --git a/src/main/java/me/trouper/Functions/Eval.java b/src/main/java/me/trouper/Functions/Eval.java
index 400c17b..b2c3978 100644
--- a/src/main/java/me/trouper/Functions/Eval.java
+++ b/src/main/java/me/trouper/Functions/Eval.java
@@ -1,32 +1,23 @@
 package me.trouper.Functions;
 
-import com.ezylang.evalex.EvaluationException;
-import com.ezylang.evalex.data.EvaluationValue;
-import com.ezylang.evalex.parser.ParseException;
 import me.trouper.Utils.Utils;
+import me.trouper.Utils.Verbose;
 import net.objecthunter.exp4j.Expression;
 import net.objecthunter.exp4j.ExpressionBuilder;
 
 public class Eval {
     public static double eval(String expression) {
         final String cleaned = Utils.removeColors(expression);
-        Utils.verbose("Evaluating Expression: " + cleaned);
+        Verbose.send("EVAL","Evaluating Expression: " + cleaned);
         Expression exp = new ExpressionBuilder(cleaned).build();
         return exp.evaluate();
     }
     public static boolean isPerfectSquare(int num) {
-        if (num < 0) {
-            return false;
-        }
-        int sqrt = (int) Math.sqrt(num);
-        return sqrt * sqrt == num;
+        if (num == 0) return false;
+        final double sq = Math.sqrt(num);
+        return sq == Math.floor(sq);
     }
     public static boolean isInt(double number) {
         return (number == Math.floor(number)) && !Double.isInfinite(number);
     }
-    public static double evalM(String exp) throws EvaluationException, ParseException {
-        com.ezylang.evalex.Expression expression = new com.ezylang.evalex.Expression(exp);
-        EvaluationValue result = expression.evaluate();
-        return result.getNumberValue().doubleValue();
-    }
 }
diff --git a/src/main/java/me/trouper/Functions/Increasers.java b/src/main/java/me/trouper/Functions/Increasers.java
index 9d93f5d..dba800f 100644
--- a/src/main/java/me/trouper/Functions/Increasers.java
+++ b/src/main/java/me/trouper/Functions/Increasers.java
@@ -1,29 +1,56 @@
 package me.trouper.Functions;
 
+import me.trouper.Countroll;
+import me.trouper.Utils.Utils;
+import me.trouper.Utils.Verbose;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
 import static me.trouper.Functions.Eval.eval;
 import static me.trouper.Functions.Eval.isPerfectSquare;
 
 public class Increasers {
-    public static String multiply(int i, int factor, boolean deep) {
-        boolean useExp = isPerfectSquare(i);
 
+    public static String increase(int current, int target, int i, boolean deep) {
+
+        if (target - current > 4069) {
+            return power(i,10,deep);
+        } else if (target - current > 10000000) {
+            return power(i,8,deep);
+        } else if (target - current > 1000000) {
+            return power(i,6,deep);
+        } else if (target - current > 100000) {
+            return power(i,4,deep);
+        } else if (target - current > 10000) {
+            return power(i,3,deep);
+        } else if (target - current > 1000) {
+            return power(i,2,deep);
+        } else if (target - current > 100) {
+            return multiply(i,9,deep);
+        } else {
+            return multiply(i,2,deep);
+        }
+    }
+    public static String multiply(int i, int factor, boolean deep) {
+        Countroll.factorCount++;
         String result = "<&7>(<&r><&2>" + i + "<&b>*<&r><&2>" + factor + "<&7>)<&r>";
 
         if (deep) {
-            result = "<&7>(<&r><&2>" + (useExp ? Complexers.power(i,true) : Complexers.divide(i,true)) + "<&b>*<&r><&2>" + factor + "<&7>)<&r>";
+            result = "<&7>(<&r><&2>" + (Complexers.complex(i,true)) + "<&b>*<&r><&2>" + Complexers.complex(i,true) + "<&7>)<&r>";
         }
-
+        if (!(eval(result) == i * factor)) Verbose.send("ERR", "Failed multiply increaser!");
         return eval(result) == i * factor ? result : "(" + i + ")";
     }
     public static String power(int i, int exp, boolean deep) {
-        boolean useExp = isPerfectSquare(i);
-
+        Countroll.powerCount++;
         String result = "<&7>(<&r><&2>" + i + "<&b>^<&r><&2>" + exp + "<&7>)<&r>";
 
         if (deep) {
-            result = "<&7>(<&r><&2>" + (useExp ? Complexers.power(i,true) : Complexers.divide(i,true)) + "<&b>^<&r><&2>" + exp + "<&7>)<&r>";
+            result = "<&7>(<&r><&2>" + Complexers.complex(i,true) + "<&b>^<&r><&2>" + Complexers.complex(i,true) + "<&7>)<&r>";
         }
-
+        if (!(eval(result) == Math.pow(i,exp))) Verbose.send("ERR", "Failed power increaser!");
         return eval(result) == Math.pow(i,exp) ? result : "(" + i + ")";
     }
 }
diff --git a/src/main/java/me/trouper/Functions/Obf.java b/src/main/java/me/trouper/Functions/Obf.java
index f62d060..31aac2b 100644
--- a/src/main/java/me/trouper/Functions/Obf.java
+++ b/src/main/java/me/trouper/Functions/Obf.java
@@ -1,15 +1,61 @@
 package me.trouper.Functions;
 
-import me.trouper.Main;
+import me.trouper.Countroll;
+import me.trouper.Utils.Verbose;
 
 import java.util.Random;
 
 import static me.trouper.Functions.Eval.*;
 import static me.trouper.Functions.Eval.eval;
 import static me.trouper.Utils.Utils.removeColors;
-import static me.trouper.Utils.Utils.verbose;
 
 public class Obf {
+    public static String obfInt(int target) {
+        Verbose.send("PROC", "Starting Obfuscation (Universal)");
+        StringBuilder expression = new StringBuilder();
+        Random rand = new Random();
+
+        // INIT
+        int init = rand.nextInt(9)+1;
+        Verbose.send("PROC", "Initializing Expression: " + init);
+        expression.append("<&dh><&f>").append(init).append("<&r>");
+
+        // MAIN LOOP
+        Verbose.send("PROC", "Beginning Main Loop: ");
+        while (eval(expression.toString()) != target) {
+
+            Countroll.total++;
+            int current = (int) eval(expression.toString());
+            int ri = rand.nextInt(9)+1;
+
+            if (!isInt(eval(expression.toString()))) {
+                System.out.println("Something went horribly wrong, Here is the relevant info." +
+                        "\nEvaluation: " + eval(expression.toString()) +
+                        "\nRandom Pick: " + ri +
+                        "\nCaught at: \n" + removeColors(expression.toString()));
+                break;
+            }
+
+            String comp = Complexers.complex(ri,Countroll.deep);
+            String incr = Increasers.increase(current,target,ri,Countroll.deep);
+
+            if (current < target) {
+                Countroll.addCount++;
+                expression.append("<&b>+<&r><&e>").append(comp).append("<&r>");
+                if (target - current > 128) {
+                    expression.append("<&b>+<&r><&e>").append(incr).append("<&r>");
+                }
+            }
+            if (current > target) {
+                Countroll.subCount++;
+                expression.append("<&b>-<&r><&e>").append(comp).append("<&r>");
+                if (current - target > 128) {
+                    expression.append("<&b>-<&r><&e>").append(incr).append("<&r>");
+                }
+            }
+        }
+        return expression.toString();
+    }
     /**
      * ObfIntN will work for Numselli's counting bot
      * @param target Integer to reach
@@ -23,12 +69,12 @@ public class Obf {
         Random random = new Random();
 
         int initializer = random.nextInt(9)+1;
-        verbose("Initializing Expression: " + initializer);
+        Verbose.send("PROC","Initializing Expression: " + initializer);
         expression.append("<&dh><&f>").append(initializer).append("<&r>");
 
 
         while (eval(expression.toString()) != target) {
-            Main.total++;
+            Countroll.total++;
             int eval = (int) eval(expression.toString());
             int ri = random.nextInt(9)+1;
             int op = random.nextInt(2);
@@ -43,12 +89,12 @@ public class Obf {
                 break;
             }
 
-            verbose("Random: " + ri);
-            verbose("Current: " + eval(expression.toString()));
+            Verbose.send("LOOP","Random: " + ri);
+            Verbose.send("LOOP","Current: " + eval(expression.toString()));
 
             if (isPerfectSquare(eval) && eval != 1) {
-                Main.perfectCount++;
-                verbose("PERFECT SQUARE TIME! (" + Main.perfectCount+ ")");
+                Countroll.perfectCount++;
+                Verbose.send("LOOP","PERFECT SQUARE TIME! (" + Countroll.perfectCount+ ")");
                 expression.insert(0,"<&eh><&b>sqrt(<&r>").append("<&eh><&b>)<&r>");
                 eval = (int) eval(expression.toString());
             }
@@ -57,34 +103,34 @@ public class Obf {
 
             if (eval < target) {
                 if (target - eval > 4069) {
-                    Main.expCount++;
-                    verbose("Large than (" + Main.expCount + ")");
+                    Countroll.expCount++;
+                    Verbose.send("LOOP","Large than (" + Countroll.expCount + ")");
                     expression.append("<&b>*<&r><&a>").append(Increasers.power(ri,3,deep)).append("<&r>");
                 } else if (target - eval > 1048) {
-                    Main.expCount++;
-                    verbose("Large than (" + Main.expCount + ")");
+                    Countroll.expCount++;
+                    Verbose.send("LOOP","Large than (" + Countroll.expCount + ")");
                     expression.append("<&b>*<&r><&a>").append(Increasers.power(ri,2,deep)).append("<&r>");
                 } else if (target - eval > 128) {
-                    Main.factorCount++;
-                    verbose("Big than (" + Main.factorCount + ")");
+                    Countroll.factorCount++;
+                    Verbose.send("LOOP","Big than (" + Countroll.factorCount + ")");
                     expression.append("<&b>*<&r><&a>").append(Increasers.multiply(ri,9,deep)).append("<&r>");
                 }
-                Main.addCount++;
+                Countroll.addCount++;
                 expression.append("<&b>+<&r><&e>").append(toAdd).append("<&r>");
-                verbose("Less than (" + Main.addCount + ")");
+                Verbose.send("LOOP","Less than (" + Countroll.addCount + ")");
             }
 
             if (eval > target) {
-                Main.subCount++;
+                Countroll.subCount++;
                 expression.insert(0,"<&c>(<&r>").append("<&c>)<&r>");
                 expression.append("<&b>-<&r><&e>").append(toAdd).append("<&r>");
-                verbose("Greater than (" + Main.subCount + ")");
+                Verbose.send("LOOP","Greater than (" + Countroll.subCount + ")");
             }
         }
 
-        verbose("Broke out of loop. Value: " + eval(expression.toString()));
-        verbose("Expression: " + expression);
-        verbose("Expression (Cleaned): " + removeColors(expression.toString()));
+        Verbose.send("PROC","Broke out of loop. Value: " + eval(expression.toString()));
+        Verbose.send("EVAL","Expression: " + expression);
+        Verbose.send("EVAL","Expression (Cleaned): " + removeColors(expression.toString()));
         return expression.toString();
     }
 
@@ -101,11 +147,10 @@ public class Obf {
         Random random = new Random();
 
         int initializer = random.nextInt(9)+1;
-        verbose("Initializing Expression: " + initializer);
         expression.append("<&dh><&f>").append(initializer).append("<&r>");
 
         while (eval(expression.toString()) != target) {
-            Main.total++;
+            Countroll.total++;
             int eval = (int) eval(expression.toString());
             int ri = random.nextInt(9)+1;
 
@@ -114,30 +159,30 @@ public class Obf {
 
             if (eval < target) {
                 if (target - eval > 4096) {
-                Main.expCount++;
+                Countroll.expCount++;
                 expression.append("<&b>*<&r>").append(Increasers.power(ri,4,deep));
                 } else if (target - eval > 1048) {
-                    Main.expCount++;
+                    Countroll.expCount++;
                     expression.append("<&b>*<&r>").append(Increasers.power(ri,2,deep));
                 } else if (target - eval > 128) {
-                    Main.factorCount++;
+                    Countroll.factorCount++;
                     expression.append("<&b>*<&r>").append(Increasers.multiply(ri,2,deep));
                 }
-                Main.addCount++;
+                Countroll.addCount++;
                 expression.append("<&b>+<&r>").append(toAdd);
             }
             if (eval > target) {
                 if (eval - target > 4096) {
-                    Main.expCount++;
+                    Countroll.expCount++;
                     expression.append("<&b>-<&r>").append(Increasers.power(ri,5,deep));
                 } else if (eval - target> 1048) {
-                    Main.expCount++;
+                    Countroll.expCount++;
                     expression.append("<&b>-<&r>").append(Increasers.power(ri,3,deep));
                 } else if (eval - target > 128) {
-                    Main.factorCount++;
+                    Countroll.factorCount++;
                     expression.append("<&b>-<&r>").append(Increasers.multiply(ri,2,deep));
                 }
-                Main.subCount++;
+                Countroll.subCount++;
                 expression.insert(0,"<&c>(<&r>").append("<&c>)<&r>");
                 expression.append("<&b>-<&r>").append(toAdd);
             }
diff --git a/src/main/java/me/trouper/Utils/Utils.java b/src/main/java/me/trouper/Utils/Utils.java
index 2da742a..acdfba2 100644
--- a/src/main/java/me/trouper/Utils/Utils.java
+++ b/src/main/java/me/trouper/Utils/Utils.java
@@ -1,7 +1,8 @@
 package me.trouper.Utils;
 
 import me.trouper.Data.MC2Ansi;
-import me.trouper.Main;
+import me.trouper.Countroll;
+import me.trouper.Functions.Eval;
 
 import java.awt.*;
 import java.awt.datatransfer.Clipboard;
@@ -9,14 +10,26 @@ import java.awt.datatransfer.StringSelection;
 import java.util.Map;
 
 public class Utils {
+    public static int calcExp(int difference) {
+        int result = 1;
+        
+        if (difference >= 4096) result = 2;
+        if (difference >= 8192) result = 3;
+        if (difference >= 16384) result = 4;
+        if (difference >= 32768) result = 5;
+        if (difference >= 65536) result = 6;
+        if (difference >= 131072) result = 7;
+        if (difference >= 262144) result = 8;
+        if (difference >= 524288) result = 9;
+        if (difference >= 1048576) result = 10;
+
+        return result;
+    }
     public static void copyToClip(String text) {
         StringSelection parsed = new StringSelection(text);
         Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
         clipboard.setContents(parsed,null);
     }
-    public static void verbose(String text) {
-        if (Main.verbose) System.out.println(activateColors(text));
-    }
     public static String removeColors(String input) {
         return input.replaceAll("<&[0-9a-fr]>|<&[0-9a-frh]h>", "");
     }
@@ -70,12 +83,20 @@ public class Utils {
      * @return The divisor
      */
     public static int moduRootDivisor(int dividend, int modulus) {
+
         int divisor = dividend - modulus;
-        verbose("<&1h><&e>Finding mrDivisor:<&r> " +
+        Verbose.send("UTIL","<&1h><&e>Finding mrDivisor:<&r> " +
                 "\nDividend (Given): " + dividend +
                 "\nDivisor (Unknown): " + divisor +
-                "\nModulus (Given): " + modulus);
+                "\nModulus (Given): " + modulus +
+                "\nCheck: " + dividend + "%" + divisor + "=" + Eval.eval(dividend + "%" + divisor));
         return divisor;
+          /*
+        int divisor = 1;
+        while (divisor * dividend % modulus != 0 || divisor != 1) {
+            divisor++;
+        }
+        return divisor;*/
     }
 
     /**
@@ -87,7 +108,7 @@ public class Utils {
      */
     public static int moduRootDividend(int divisor, int modulus) {
         int dividend = modulus + divisor;
-        verbose("<&1h><&e>Finding mrDivisor:<&r> " +
+        Verbose.send("UTIL","<&1h><&e>Finding mrDivisor:<&r> " +
                 "\nDividend (Unknown): " + dividend +
                 "\nDivisor (Given): " + divisor +
                 "\nModulus (Given): " + modulus);
diff --git a/src/main/java/me/trouper/Utils/Verbose.java b/src/main/java/me/trouper/Utils/Verbose.java
index 1e7646d..047f588 100644
--- a/src/main/java/me/trouper/Utils/Verbose.java
+++ b/src/main/java/me/trouper/Utils/Verbose.java
@@ -1,7 +1,32 @@
 package me.trouper.Utils;
 
-public class Verbose {
-    public static void send(String message, String klass, String type) {
+import me.trouper.Countroll;
 
+public class Verbose {
+    public static boolean processes;
+    public static boolean all;
+    public static boolean loops;
+    public static boolean eval;
+    public static boolean complexers;
+    public static boolean increasers;
+    public static boolean utils;
+    public static boolean errors;
+    public static void send(String type, String message) {
+        message = Utils.activateColors(message);
+        if (all) {
+            System.out.println(message);
+            return;
+        }
+        if (type.equals("INIT")) System.out.println(message);
+        if (type.equals("PROC") && processes) System.out.println(message);
+        if (type.equals("LOOP") && loops) System.out.println(message);
+        if (type.equals("UTIL") && utils) System.out.println(message);
+        if (type.equals("EVAL") && eval) System.out.println(message);
+        if (type.equals("COMP") && complexers) System.out.println(message);
+        if (type.equals("INCR") && increasers) System.out.println(message);
+        if (type.equals("ERR") && errors) {
+            System.out.println(message);
+            Countroll.errorCount++;
+        }
     }
 }
diff --git a/src/main/resources/Manifest.mf b/src/main/resources/Manifest.mf
index 09f1bfb..abe096b 100644
--- a/src/main/resources/Manifest.mf
+++ b/src/main/resources/Manifest.mf
@@ -1,2 +1,2 @@
 Manifest-Version: 1.0
-Main-Class: me.trouper.Main
+Main-Class: me.trouper.Countroll