Input:
import com.google.gson.annotations.Expose;
import com.google.gson.annotations.SerializedName;
import java.awt.Color;
import java.security.SecureRandom;
import net.augustus.Augustus;
import net.augustus.modules.render.ClickGUI;
import net.augustus.notify.GeneralNotifyManager;
import net.augustus.notify.NotificationType;
import net.augustus.notify.xenza.Notification;
import net.augustus.notify.xenza.NotificationsManager;
import net.augustus.utils.AnimationUtil;
import net.augustus.utils.interfaces.MC;
import net.augustus.utils.interfaces.MM;
import net.augustus.utils.interfaces.SM;
import net.augustus.utils.skid.lorious.anims.Animation;
import net.augustus.utils.skid.lorious.anims.Easings;
import net.augustus.utils.sound.SoundUtil;
import net.lenni0451.eventapi.manager.EventManager;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.ScaledResolution;

Context:
src/minecraft/net/augustus/modules/Module.java
package net.augustus.modules;

public class Module implements MC, MM, SM, Comparable<Module> {
   public Animation yPos = new Animation();
   public Animation xPos = new Animation();
   @Expose
   @SerializedName("Name")
   private String name;
   private String displayName = "";
   @Expose
   @SerializedName("Toggled")
   private boolean toggled;
   @Expose
   @SerializedName("Key")
   private int key;
   @Expose
   @SerializedName("Category")
   private Categorys category;
   private Color color;
   private float x;
   private float y;
   private float minX;
   private float maxX;
   private float moduleWidth = 0.0F;
   public AnimationUtil animationUtil;
   protected ScaledResolution sr = new ScaledResolution(mc);
   public SecureRandom RANDOM = new SecureRandom();

   public Module(String name, Color color, Categorys category) {

src/minecraft/net/augustus/notify/NotificationType.java
public enum NotificationType {
    Info,
    Alert,
    Error,
    ToggleOn,
    ToggleOff
}

src/minecraft/net/augustus/notify/GeneralNotifyManager.java
public class GeneralNotifyManager implements MM {
    public static void addNotification(String content, NotificationType type) {
        switch(mm.notifications.mode.getSelected()) {
            case "Xenza": {
                NotificationsManager.addNotification(new Notification(content, type));
                break;
            }
            case "Rise5": {
                Augustus.getInstance().getRise5notifyManager().registerNotification(content, type);
                break;
            }
            case "New": {
                CleanNotificationManager.addCleanNotification(new CleanNotification(content, type));
                break;
            }
        }
    }
}

src/minecraft/net/augustus/utils/interfaces/MC.java
public interface MC {
   Minecraft mc = Minecraft.getMinecraft();
}

src/minecraft/net/augustus/utils/interfaces/MM.java
public interface MM {
   ModuleManager mm = Augustus.getInstance().getModuleManager();
}

src/minecraft/net/augustus/notify/xenza/Notification.java
public class Notification {
    public float x;
    public float width, height;
    public String name;
    public float lastTime;
    public TimeHelper timer;
    public NotificationType type;
    public boolean setBack;
    private float fy, cy = 0;
    private TimeHelper anitimer = new TimeHelper();
    private static UnicodeFontRenderer arial16;
    private AnimationUtils animationUtils = new AnimationUtils();
    private AnimationUtils animationUtils2 = new AnimationUtils();
    private ResourceLocation check = ResourceUtil.loadResourceLocation("pictures/check.png", "check");
    private ResourceLocation cross = ResourceUtil.loadResourceLocation("pictures/cross.png", "cross");;
    static {
        try {
            arial16 = new UnicodeFontRenderer(Font.createFont(0, GuiIngameHook.class.getResourceAsStream("/ressources/arial.ttf")).deriveFont(16F));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public Notification(String name, NotificationType type) {
        this.name = name;
        this.type = type;
        this.lastTime = 1.5f;
        this.width = arial16.getStringWidth(name) + 25;
        this.height = 20;
    }

    public Notification(String name, NotificationType type, float lastTime) {
        this.name = name;
        this.type = type;
        this.lastTime = lastTime;
        this.width = arial16.getStringWidth(name) + 25;
        this.height = 20;

    }

    public void render(float y) {
        fy = y;
        if (cy == 0) {
            cy = fy + 25;
        }
        ScaledResolution sr = new ScaledResolution(Minecraft.getMinecraft());
        RenderUtil.drawRect((float) (sr.getScaledWidth_double() - x), cy, (float) ((sr.getScaledWidth_double() - x) + width), cy + height, new Color(10, 10, 10, 220));
        RenderUtil.drawRect((float) (sr.getScaledWidth_double() - x), cy + height - 1, (float) (sr.getScaledWidth_double() - x) + width, cy + height, new Color(180, 180, 180));

        //RenderUtil.drawCustomImageAlpha(sr.getScaledWidth() - x + 3, cy + 4, 12, 12, new ResourceLocation("client/back.png"), -1, 255);
        switch (type) {
            case ToggleOn: {
                RenderUtil.drawCustomImageAlpha(sr.getScaledWidth() - x + 3, cy + 4, 12, 12, check, -1, 255);
                break;
            }
            case ToggleOff: {
                RenderUtil.drawCustomImageAlpha(sr.getScaledWidth() - x + 3, cy + 4, 12, 12, cross, -1, 255);
                break;
            }
        }

        arial16.drawString(name, (sr.getScaledWidth() - x) + 18, cy + 7, -1);
    }

    public void update() {
        ScaledResolution sr = new ScaledResolution(Minecraft.getMinecraft());
        if (timer == null && Math.abs(x - width) < 0.1f) {
            timer = new TimeHelper();
            timer.reset();
        }
        if (anitimer.reached(10)) {
            cy = animationUtils.animate(fy, cy, 0.1f);

            if (!setBack) {
                x = animationUtils2.animate(width, x, 0.1f);
            } else {
                x = animationUtils2.animate(0, x, 0.1f);
            }
            anitimer.reset();
        }
    }
}

src/minecraft/net/augustus/utils/sound/SoundUtil.java
public class SoundUtil {
    private static Clip clip;
    public static final URL button = SoundUtil.class.getClassLoader().getResource("ressources/sounds/buttonClick.wav");
    public static final URL toggleOnSound = SoundUtil.class.getClassLoader().getResource("ressources/sounds/toggleSound.wav");
    public static final URL toggleOffSound = SoundUtil.class.getClassLoader().getResource("ressources/sounds/toggleSound2.wav");
    public static final URL loginSuccessful = SoundUtil.class.getClassLoader().getResource("ressources/sounds/loginSuccessful.wav");
    public static final URL loginFailed = SoundUtil.class.getClassLoader().getResource("ressources/sounds/loginFailed.wav");

    public static void play(URL filePath) {
        try {
            clip = AudioSystem.getClip();
            clip.open(AudioSystem.getAudioInputStream(filePath));
            FloatControl floatControl = (FloatControl)clip.getControl(Type.MASTER_GAIN);
            floatControl.setValue(0.0F);
            clip.start();
        } catch (UnsupportedAudioFileException | IOException | LineUnavailableException | IllegalArgumentException var2) {
            //var2.printStackTrace();
        }
    }
}

src/minecraft/net/augustus/utils/interfaces/SM.java
public interface SM {
   SettingsManager sm = Augustus.getInstance().getSettingsManager();
}

src/minecraft/net/augustus/utils/AnimationUtil.java
public class AnimationUtil implements MC {
   private float x;
   private float minX;
   private float maxX;
   private float speed;
   private long lastTime;
   private int side;

   public AnimationUtil(float xy, float minXY, float maxXY, float speed) {
      this.x = xy;
      this.minX = minXY;
      this.maxX = maxXY;
      this.speed = speed;
   }

   public float updateAnimation(int side) {
      long deltaTime = System.currentTimeMillis() - this.lastTime;
      float sx = 0.0F;
      if (this.speed != 0.0F) {
         float var1 = this.speed / (float)deltaTime;
         sx = (this.maxX - this.minX) / var1;
      }

      if (this.side == 0) {
         this.lastTime = System.currentTimeMillis();
         return this.x;
      } else {
         if (this.side > 0) {
            this.side = 1;
         } else {
            this.side = -1;
         }

         float cxy = this.x + sx * (float)side;
         if (cxy < this.minX) {
            cxy = this.minX;
         } else if (cxy > this.maxX) {
            cxy = this.maxX;
         }

         this.x = cxy;
         this.lastTime = System.currentTimeMillis();
         return this.x;
      }
   }

   public float updateAnimation(float minXY, float maxXY) {
      this.minX = minXY;
      this.maxX = maxXY;
      long deltaTime = System.currentTimeMillis() - this.lastTime;
      if (deltaTime > 60L) {
         deltaTime = 60L;
      }

      float sx = 0.0F;
      if (this.speed != 0.0F) {
         float var1 = this.speed / (float)deltaTime;
         sx = (this.maxX - this.minX) / var1;
         if (this.side == 0) {
            this.lastTime = System.currentTimeMillis();
            return this.x;
         } else {
            if (this.side > 0) {
               this.side = 1;
            } else {
               this.side = -1;
            }

            var1 = this.x + sx * (float)this.side;
            if (var1 < minXY) {
               var1 = minXY;
            } else if (var1 > maxXY) {
               var1 = maxXY;
            }

            this.x = var1;
            this.lastTime = System.currentTimeMillis();
            return this.x;
         }
      } else {
         return this.x;
      }
   }

   public void setSide(int side) {
      this.side = side;
   }

   public void setSpeed(float speed) {
      this.speed = speed;
   }
}

src/minecraft/net/augustus/modules/render/ClickGUI.java
public class ClickGUI extends Module {
   public StringValue sorting = new StringValue(1, "Sorting", this, "Random", new String[]{"Random", "Length", "Alphabet"});
   public StringValue mode = new StringValue(25, "Mode", this, "Default", new String[]{"Default", "Clean", "New"});

   public ClickGUI() {
      super("ClickGui", Color.BLACK, Categorys.RENDER);
   }

   @Override
   public void onEnable() {
      Augustus.getInstance().getConverter().moduleSaver(mm.getModules());
      Augustus.getInstance().getConverter().settingSaver(sm.getStgs());
      if(mode.getSelected().equalsIgnoreCase("Default")) {
         mc.displayGuiScreen(Augustus.getInstance().getClickGui());
      //} else if(mode.getSelected().equalsIgnoreCase("Clean")) {
//         mc.displayGuiScreen(Augustus.getInstance().getCleanClickGui());
      } else if(mode.getSelected().equalsIgnoreCase("New")) {
         EventManager.call(new EventClickGui());
         mc.displayGuiScreen(new Dark());
      } else {
         mc.displayGuiScreen(Augustus.getInstance().getClickGui());
      }
   }

   @Override
   public void onDisable() {
      Augustus.getInstance().getConverter().moduleSaver(mm.getModules());
      Augustus.getInstance().getConverter().settingSaver(sm.getStgs());
   }

   @EventTarget
   public void onEventTick(EventTick eventTick) {
      if (!(mc.currentScreen instanceof ClickGui) && this.isToggled()) {
         this.toggle();
      }
   }
}

src/minecraft/net/augustus/Augustus.java
@Getter
@Setter
public class Augustus {
   private static final Augustus instance = new Augustus();
   private String name = null;
   private String version = "reborn b2";
   private String dev = null;
   private final Color clientColor = new Color(41, 146, 222);
   private List<String> lastAlts = new ArrayList<>();
   private final Manager manager = new Manager();
   private ModuleManager moduleManager;
   private SettingsManager settingsManager;
   private CommandManager commandManager;
   private CleanClickGui cleanClickGui;
   private ClickGui clickGui;
   private Converter converter;
   private BackgroundShaderUtil backgroundShaderUtil;
   private float shaderSpeed = 1800.0F;
   private SettingSorter settingSorter;
   private YawPitchHelper yawPitchHelper;
   public String uid = "";
   private BlockUtil blockUtil;
   private Fonts loriousFontService;
   private Proxy proxy;
   private NotificationManager rise5notifyManager;
   private ColorUtil colorUtil;

   public static Augustus getInstance() {
      return instance;
   }

   public void preStart() {
      Path dir = Paths.get("xenzarecode/configs");
      if (!Files.exists(dir)) {
         try {
            Files.createDirectories(dir);
         } catch (IOException var2) {
            var2.printStackTrace();
         }
      }
   }

   public void start() {
      name = "xenza";
      dev = "jDev + Cookie + SaFeBaum";
      System.out.println("Starting Client...");
      FontUtil.bootstrap();
      this.loriousFontService = new Fonts();
      this.loriousFontService.bootstrap();
      this.colorUtil = new ColorUtil();
      this.yawPitchHelper = new YawPitchHelper();
      this.settingsManager = new SettingsManager();
      this.moduleManager = new ModuleManager();
      this.commandManager = new CommandManager();
      this.rise5notifyManager = new NotificationManager();
      this.clickGui = new ClickGui("ClickGui");
      this.converter = new Converter();
      this.converter.settingReader(this.settingsManager.getStgs());
      this.converter.settingSaver(this.settingsManager.getStgs());
      this.converter.moduleReader(this.moduleManager.getModules());
      this.converter.readLastAlts();
      this.converter.clickGuiLoader(this.clickGui.getCategoryButtons());
      this.backgroundShaderUtil = new BackgroundShaderUtil();
      this.settingSorter = new SettingSorter();
      this.cleanClickGui = new CleanClickGui();
      AugustusSounds.currentSound = this.converter.readSound();
      this.blockUtil = new BlockUtil();
      EventManager.register(this.settingSorter);
      EventManager.register(this);
      try {
         ViaMCP.getInstance().start();
      } catch (Exception var2) {
         var2.printStackTrace();
      }
   }
}

src/minecraft/net/lenni0451/eventapi/manager/EventManager.java
public class EventManager {
   private static final Map<Class<? extends IEvent>, List<EventExecutor>> EVENT_LISTENER = new ConcurrentHashMap<>();
   private static final List<IErrorListener> ERROR_LISTENER = new CopyOnWriteArrayList<>();

   public static void call(IEvent event) {
      if (event != null) {
         List<EventExecutor> eventListener = new ArrayList<>();
         if (EVENT_LISTENER.containsKey(event.getClass())) {
            eventListener.addAll(EVENT_LISTENER.get(event.getClass()));
         }

         if (EVENT_LISTENER.containsKey(IEvent.class)) {
            eventListener.addAll(EVENT_LISTENER.get(IEvent.class));
         }

         for(EventExecutor listener : eventListener) {
            try {
               listener.getEventListener().onEvent(event);
            } catch (Throwable var5) {
               if (ERROR_LISTENER.isEmpty()) {
                  throw new RuntimeException(var5);
               }

               ERROR_LISTENER.forEach(errorListener -> errorListener.catchException(var5));
            }

            if (event instanceof IStoppable && ((IStoppable)event).isStopped()) {
               break;
            }
         }
      }
   }

   public static <T extends IEventListener> void register(T listener) {
      register(IEvent.class, (byte)2, listener);
   }

   public static void register(Object listener) {
      Method[] var4;
      for(Method method : var4 = listener.getClass().getMethods()) {
         if (method.isAnnotationPresent(EventTarget.class)) {
            EventTarget anno = method.getAnnotation(EventTarget.class);
            Class[] methodArguments = method.getParameterTypes();
            if (methodArguments.length == 1 && IEvent.class.isAssignableFrom(methodArguments[0])) {
               ReflectedEventListener eventListener = new ReflectedEventListener(listener, methodArguments[0], method);
               if (methodArguments[0].equals(IEvent.class)) {
                  register(anno.priority(), eventListener);
               } else {
                  register(methodArguments[0], anno.priority(), eventListener);
               }
            }
         }
      }
   }

   public static <T extends IEventListener> void register(Class<? extends IEvent> eventType, T listener) {
      register(eventType, (byte)2, listener);
   }

   public static <T extends IEventListener> void register(byte eventPriority, T listener) {
      register(IEvent.class, eventPriority, listener);
   }

   public static <T extends IEventListener> void register(Class<? extends IEvent> eventType, byte eventPriority, T listener) {
      List<EventExecutor> eventListener = EVENT_LISTENER.computeIfAbsent(eventType, k -> new CopyOnWriteArrayList());
      eventListener.add(new EventExecutor(listener, eventPriority));

      for(Entry<Class<? extends IEvent>, List<EventExecutor>> entry : EVENT_LISTENER.entrySet()) {
         List<EventExecutor> eventExecutor = entry.getValue();
         Collections.sort(eventExecutor, new Comparator<EventExecutor>() {
            public int compare(EventExecutor o1, EventExecutor o2) {
               return Integer.compare(o2.getPriority(), o1.getPriority());
            }
         });
      }
   }

   public static void unregister(Object listener) {
      for(Entry<Class<? extends IEvent>, List<EventExecutor>> entry : EVENT_LISTENER.entrySet()) {
         entry.getValue()
            .removeIf(
               eventExecutor -> eventExecutor.getEventListener().equals(listener)
                     || eventExecutor.getEventListener() instanceof ReflectedEventListener
                        && ((ReflectedEventListener)eventExecutor.getEventListener()).getCallInstance().equals(listener)
            );
      }
   }

   public static void addErrorListener(IErrorListener errorListener) {
      if (!ERROR_LISTENER.contains(errorListener)) {
         ERROR_LISTENER.add(errorListener);
      }
   }

   public static boolean removeErrorListener(IErrorListener errorListener) {
      return ERROR_LISTENER.remove(errorListener);
   }
}

src/minecraft/net/augustus/notify/xenza/NotificationsManager.java
public class NotificationsManager {
    public static ArrayList<Notification> notifications = new ArrayList<Notification>();

    public static ArrayList<Notification> getNotifications() {
        return notifications;
    }

    public static void addNotification(Notification n) {
        notifications.add(n);
    }

    public static void renderNotifications() {
        ScaledResolution sr = new ScaledResolution(Minecraft.getMinecraft());
        float y = sr.getScaledHeight() - 30;
        Iterator<Notification> it = notifications.iterator();
        while (it.hasNext()) {
            it.next().render(y);
            y -= 25;
        }

    }

    public static void update() {
        ArrayList<Notification> temp = new ArrayList<>();

        for (Notification no : notifications){
            temp.add(no);
            no.update();
//            System.out.println(no.timer.delay(no.lastTime * 1000) + " " );
            if(no.timer != null) {
                if (no.timer.reached((long) (no.lastTime * 1000))) {
                    no.setBack = true;
//                    no.timer.reset();
                    if(no.x <= 0.1f) {
                        temp.remove(no);
                    }
                }
            }

        }
        notifications.clear();
        for (Notification no : temp) {
            notifications.add(no);
        }
    }
}

src/minecraft/net/augustus/utils/skid/lorious/anims/Easings.java
public final class Easings {
    public static final double c1 = 1.70158;
    public static final double c2 = 2.5949095;
    public static final double c3 = 2.70158;
    public static final double c4 = 2.0943951023931953;
    public static final double c5 = 1.3962634015954636;
    public static final Easing NONE = value -> value;
    public static final Easing QUAD_IN = Easings.powIn(2);
    public static final Easing QUAD_OUT = Easings.powOut(2);
    public static final Easing QUAD_BOTH = Easings.powBoth(2.0);
    public static final Easing CUBIC_IN = Easings.powIn(3);
    public static final Easing CUBIC_OUT = Easings.powOut(3);
    public static final Easing CUBIC_BOTH = Easings.powBoth(3.0);
    public static final Easing QUART_IN = Easings.powIn(4);
    public static final Easing QUART_OUT = Easings.powOut(4);
    public static final Easing QUART_BOTH = Easings.powBoth(4.0);
    public static final Easing QUINT_IN = Easings.powIn(5);
    public static final Easing QUINT_OUT = Easings.powOut(5);
    public static final Easing QUINT_BOTH = Easings.powBoth(5.0);
    public static final Easing SINE_IN = value -> 1.0 - Math.cos((double)(value * Math.PI / 2.0));
    public static final Easing SINE_OUT = value -> Math.sin((double)(value * Math.PI / 2.0));
    public static final Easing SINE_BOTH = value -> -(Math.cos((double)(Math.PI * value)) - 1.0) / 2.0;
    public static final Easing CIRC_IN = value -> 1.0 - Math.sqrt((double)(1.0 - Math.pow((double)value, (double)2.0)));
    public static final Easing CIRC_OUT = value -> Math.sqrt((double)(1.0 - Math.pow((double)(value - 1.0), (double)2.0)));
    public static final Easing CIRC_BOTH = value -> value < 0.5 ? (1.0 - Math.sqrt((double)(1.0 - Math.pow((double)(2.0 * value), (double)2.0)))) / 2.0 : (Math.sqrt((double)(1.0 - Math.pow((double)(-2.0 * value + 2.0), (double)2.0))) + 1.0) / 2.0;
    public static final Easing ELASTIC_IN = value -> value != 0.0 && value != 1.0 ? Math.pow((double)-2.0, (double)(10.0 * value - 10.0)) * Math.sin((double)((value * 10.0 - 10.75) * 2.0943951023931953)) : value;
    public static final Easing ELASTIC_OUT = value -> value != 0.0 && value != 1.0 ? Math.pow((double)2.0, (double)(-10.0 * value)) * Math.sin((double)((value * 10.0 - 0.75) * 2.0943951023931953)) + 1.0 : value;
    public static final Easing ELASTIC_BOTH = value -> {
        if (value != 0.0 && value != 1.0) {
            return value < 0.5 ? -(Math.pow((double)2.0, (double)(20.0 * value - 10.0)) * Math.sin((double)((20.0 * value - 11.125) * 1.3962634015954636))) / 2.0 : Math.pow((double)2.0, (double)(-20.0 * value + 10.0)) * Math.sin((double)((20.0 * value - 11.125) * 1.3962634015954636)) / 2.0 + 1.0;
        }
        return value;
    };
    public static final Easing EXPO_IN = value -> value != 0.0 ? Math.pow((double)2.0, (double)(10.0 * value - 10.0)) : value;
    public static final Easing EXPO_OUT = value -> value != 1.0 ? 1.0 - Math.pow((double)2.0, (double)(-10.0 * value)) : value;
    public static final Easing EXPO_BOTH = value -> {
        if (value != 0.0 && value != 1.0) {
            return value < 0.5 ? Math.pow((double)2.0, (double)(20.0 * value - 10.0)) / 2.0 : (2.0 - Math.pow((double)2.0, (double)(-20.0 * value + 10.0))) / 2.0;
        }
        return value;
    };
    public static final Easing BACK_IN = value -> 2.70158 * Math.pow((double)value, (double)3.0) - 1.70158 * Math.pow((double)value, (double)2.0);
    public static final Easing BACK_OUT = value -> 1.0 + 2.70158 * Math.pow((double)(value - 1.0), (double)3.0) + 1.70158 * Math.pow((double)(value - 1.0), (double)2.0);
    public static final Easing BACK_BOTH = value -> value < 0.5 ? Math.pow((double)(2.0 * value), (double)2.0) * (7.189819 * value - 2.5949095) / 2.0 : (Math.pow((double)(2.0 * value - 2.0), (double)2.0) * (3.5949095 * (value * 2.0 - 2.0) + 2.5949095) + 2.0) / 2.0;
    public static final Easing BOUNCE_OUT = x -> {
        double n1 = 7.5625;
        double d1 = 2.75;
        if (x < 1.0 / d1) {
            return n1 * Math.pow((double)x, (double)2.0);
        }
        if (x < 2.0 / d1) {
            return n1 * Math.pow((double)(x - 1.5 / d1), (double)2.0) + 0.75;
        }
        return x < 2.5 / d1 ? n1 * Math.pow((double)(x - 2.25 / d1), (double)2.0) + 0.9375 : n1 * Math.pow((double)(x - 2.625 / d1), (double)2.0) + 0.984375;
    };
    public static final Easing BOUNCE_IN = value -> 1.0 - BOUNCE_OUT.ease(1.0 - value);
    public static final Easing BOUNCE_BOTH = value -> value < 0.5 ? (1.0 - BOUNCE_OUT.ease(1.0 - 2.0 * value)) / 2.0 : (1.0 + BOUNCE_OUT.ease(2.0 * value - 1.0)) / 2.0;

    public static Easing powIn(double n) {
        return value -> Math.pow((double)value, (double)n);
    }

    public static Easing powIn(int n) {
        return Easings.powIn((double)n);
    }

    public static Easing powOut(double n) {
        return value -> 1.0 - Math.pow((double)(1.0 - value), (double)n);
    }

    public static Easing powOut(int n) {
        return Easings.powOut((double)n);
    }

    public static Easing powBoth(double n) {
        return value -> value < 0.5 ? Math.pow((double)2.0, (double)(n - 1.0)) * Math.pow((double)value, (double)n) : 1.0 - Math.pow((double)(-2.0 * value + 2.0), (double)n) / 2.0;
    }

    public static Easing getEasingByName(String name) {
        if (name.equalsIgnoreCase("default") || name.equalsIgnoreCase("none")) {
            return NONE;
        }
        if (name.equalsIgnoreCase("sine in")) {
            return SINE_IN;
        }
        if (name.equalsIgnoreCase("sine out")) {
            return SINE_OUT;
        }
        if (name.equalsIgnoreCase("sine both")) {
            return SINE_BOTH;
        }
        if (name.equalsIgnoreCase("quad in")) {
            return QUAD_IN;
        }
        if (name.equalsIgnoreCase("quad out")) {
            return QUAD_OUT;
        }
        if (name.equalsIgnoreCase("quad both")) {
            return QUAD_BOTH;
        }
        if (name.equalsIgnoreCase("cubic in")) {
            return CUBIC_IN;
        }
        if (name.equalsIgnoreCase("cubic out")) {
            return CUBIC_OUT;
        }
        if (name.equalsIgnoreCase("cubic both")) {
            return CUBIC_BOTH;
        }
        if (name.equalsIgnoreCase("quart in")) {
            return QUART_IN;
        }
        if (name.equalsIgnoreCase("quart out")) {
            return QUART_OUT;
        }
        if (name.equalsIgnoreCase("quart both")) {
            return QUART_BOTH;
        }
        if (name.equalsIgnoreCase("quint in")) {
            return QUINT_IN;
        }
        if (name.equalsIgnoreCase("quint out")) {
            return QUINT_OUT;
        }
        if (name.equalsIgnoreCase("quint both")) {
            return QUINT_BOTH;
        }
        if (name.equalsIgnoreCase("expo in")) {
            return EXPO_IN;
        }
        if (name.equalsIgnoreCase("expo out")) {
            return EXPO_OUT;
        }
        if (name.equalsIgnoreCase("expo both")) {
            return EXPO_BOTH;
        }
        if (name.equalsIgnoreCase("circ in")) {
            return CIRC_IN;
        }
        if (name.equalsIgnoreCase("circ out")) {
            return CIRC_OUT;
        }
        if (name.equalsIgnoreCase("circ both")) {
            return CIRC_BOTH;
        }
        if (name.equalsIgnoreCase("back in")) {
            return BACK_IN;
        }
        if (name.equalsIgnoreCase("back out")) {
            return BACK_OUT;
        }
        if (name.equalsIgnoreCase("back both")) {
            return BACK_BOTH;
        }
        if (name.equalsIgnoreCase("elastic in")) {
            return ELASTIC_IN;
        }
        if (name.equalsIgnoreCase("elastic out")) {
            return ELASTIC_OUT;
        }
        if (name.equalsIgnoreCase("elastic both")) {
            return ELASTIC_BOTH;
        }
        if (name.equalsIgnoreCase("bounce in")) {
            return BOUNCE_IN;
        }
        if (name.equalsIgnoreCase("bounce out")) {
            return BOUNCE_OUT;
        }
        return BOUNCE_BOTH;
    }
}

src/minecraft/net/augustus/utils/skid/lorious/anims/Animation.java
public class Animation {
    private long animationStart;
    private double duration;
    private double animationFromValue;
    private double animationToValue;
    private Easing easing = Easings.NONE;
    private double lastValue;

    public double getValue() {
        return this.lastValue;
    }

    public void setValue(double value) {
        this.animationFromValue = value;
        this.animationToValue = value;
        this.lastValue = value;
    }

    public void animate(double value, double duration, Easing easing) {
        this.animationFromValue = this.lastValue;
        this.animationToValue = value;
        this.animationStart = System.currentTimeMillis();
        this.duration = duration;
        this.easing = easing;
    }

    public double getTarget() {
        return this.animationToValue;
    }

    private double interpolateValue(double start, double end, double pct) {
        return start + (end - start) * pct;
    }

    public boolean updateAnimation() {
        double value;
        double part = (double)(System.currentTimeMillis() - this.animationStart) / this.duration;
        if (this.isAlive()) {
            part = this.easing.ease(part);
            value = this.interpolateValue(this.animationFromValue, this.animationToValue, part);
        } else {
            this.animationStart = 0L;
            value = this.animationToValue;
        }
        this.lastValue = value;
        return this.isAlive();
    }

    public boolean isDone() {
        double part = (double)(System.currentTimeMillis() - this.animationStart) / this.duration;
        return part >= 1.0;
    }

    public boolean isAlive() {
        double part = (double)(System.currentTimeMillis() - this.animationStart) / this.duration;
        return part < 1.0;
    }
}

src/minecraft/net/minecraft/client/gui/ScaledResolution.java
public class ScaledResolution {
   private final double scaledWidthD;
   private final double scaledHeightD;
   private int scaledWidth;
   private int scaledHeight;
   private int scaleFactor;

   public ScaledResolution(Minecraft p_i46445_1_) {
      this.scaledWidth = p_i46445_1_.displayWidth;
      this.scaledHeight = p_i46445_1_.displayHeight;
      this.scaleFactor = 1;
      boolean flag = p_i46445_1_.isUnicode();
      int i = p_i46445_1_.gameSettings.guiScale;
      if (i == 0) {
         i = 1000;
      }

      while(this.scaleFactor < i && this.scaledWidth / (this.scaleFactor + 1) >= 320 && this.scaledHeight / (this.scaleFactor + 1) >= 240) {
         ++this.scaleFactor;
      }

      if (flag && this.scaleFactor % 2 != 0 && this.scaleFactor != 1) {
         --this.scaleFactor;
      }

      this.scaledWidthD = (double)this.scaledWidth / (double)this.scaleFactor;
      this.scaledHeightD = (double)this.scaledHeight / (double)this.scaleFactor;
      this.scaledWidth = MathHelper.ceiling_double_int(this.scaledWidthD);
      this.scaledHeight = MathHelper.ceiling_double_int(this.scaledHeightD);
   }

   public int getScaledWidth() {
      return this.scaledWidth;
   }

   public int getScaledHeight() {
      return this.scaledHeight;
   }

   public double getScaledWidth_double() {
      return this.scaledWidthD;
   }

   public double getScaledHeight_double() {
      return this.scaledHeightD;
   }

   public int getScaleFactor() {
      return this.scaleFactor;
   }
}

src/minecraft/net/minecraft/client/gui/FontRenderer.java
public class FontRenderer implements IResourceManagerReloadListener {
   private static final ResourceLocation[] unicodePageLocations = new ResourceLocation[256];
   private float[] charWidth = new float[256];
   public int FONT_HEIGHT = 9;
   public Random fontRandom = new Random();
   private byte[] glyphWidth = new byte[65536];
   private int[] colorCode = new int[32];
   private ResourceLocation locationFontTexture;
   private final TextureManager renderEngine;
   private float posX;
   private float posY;
   private boolean unicodeFlag;
   private boolean bidiFlag;
   private float red;
   private float blue;
   private float green;
   private float alpha;
   private int textColor;
   private boolean randomStyle;
   private boolean boldStyle;
   private boolean italicStyle;
   private boolean underlineStyle;
   private boolean strikethroughStyle;
   private static final String __OBFID = "CL_00000660";
   public GameSettings gameSettings;
   public ResourceLocation locationFontTextureBase;
   public boolean enabled = true;
   public float offsetBold = 1.0F;

   public FontRenderer(GameSettings gameSettingsIn, ResourceLocation location, TextureManager textureManagerIn, boolean unicode) {
      this.gameSettings = gameSettingsIn;
      this.locationFontTextureBase = location;
      this.locationFontTexture = location;
      this.renderEngine = textureManagerIn;
      this.unicodeFlag = unicode;
      this.locationFontTexture = FontUtils.getHdFontLocation(this.locationFontTextureBase);
      this.bindTexture(this.locationFontTexture);

      for(int i = 0; i < 32; ++i) {
         int j = (i >> 3 & 1) * 85;
         int k = (i >> 2 & 1) * 170 + j;
         int l = (i >> 1 & 1) * 170 + j;
         int i1 = (i >> 0 & 1) * 170 + j;
         if (i == 6) {
            k += 85;
         }

         if (gameSettingsIn.anaglyph) {
            int j1 = (k * 30 + l * 59 + i1 * 11) / 100;
            int k1 = (k * 30 + l * 70) / 100;
            int l1 = (k * 30 + i1 * 70) / 100;
            k = j1;
            l = k1;
            i1 = l1;
         }

         if (i >= 16) {
            k /= 4;
            l /= 4;
            i1 /= 4;
         }

         this.colorCode[i] = (k & 0xFF) << 16 | (l & 0xFF) << 8 | i1 & 0xFF;
      }

      this.readGlyphSizes();
   }

   @Override
   public void onResourceManagerReload(IResourceManager resourceManager) {
      this.locationFontTexture = FontUtils.getHdFontLocation(this.locationFontTextureBase);

      for(int i = 0; i < unicodePageLocations.length; ++i) {
         unicodePageLocations[i] = null;
      }

      this.readFontTexture();
      this.readGlyphSizes();
   }

   private void readFontTexture() {
      BufferedImage bufferedimage;
      try {
         bufferedimage = TextureUtil.readBufferedImage(this.getResourceInputStream(this.locationFontTexture));
      } catch (IOException var21) {
         throw new RuntimeException(var21);
      }

      Properties properties = FontUtils.readFontProperties(this.locationFontTexture);
      int i = bufferedimage.getWidth();
      int j = bufferedimage.getHeight();
      int k = i / 16;
      int l = j / 16;
      float f = (float)i / 128.0F;
      float f1 = Config.limit(f, 1.0F, 2.0F);
      this.offsetBold = 1.0F / f1;
      float f2 = FontUtils.readFloat(properties, "offsetBold", -1.0F);
      if (f2 >= 0.0F) {
         this.offsetBold = f2;
      }

      int[] aint = new int[i * j];
      bufferedimage.getRGB(0, 0, i, j, aint, 0, i);

      for(int i1 = 0; i1 < 256; ++i1) {
         int j1 = i1 % 16;
         int k1 = i1 / 16;
         int l1 = 0;

         for(l1 = k - 1; l1 >= 0; --l1) {
            int i2 = j1 * k + l1;
            boolean flag = true;

            for(int j2 = 0; j2 < l && flag; ++j2) {
               int k2 = (k1 * l + j2) * i;
               int l2 = aint[i2 + k2];
               int i3 = l2 >> 24 & 0xFF;
               if (i3 > 16) {
                  flag = false;
               }
            }

            if (!flag) {
               break;
            }
         }

         if (i1 == 65) {
            i1 = i1;
         }

         if (i1 == 32) {
            if (k <= 8) {
               l1 = (int)(2.0F * f);
            } else {
               l1 = (int)(1.5F * f);
            }
         }

         this.charWidth[i1] = (float)(l1 + 1) / f + 1.0F;
      }

      FontUtils.readCustomCharWidths(properties, this.charWidth);
   }

   private void readGlyphSizes() {
      InputStream inputstream = null;

      try {
         inputstream = this.getResourceInputStream(new ResourceLocation("font/glyph_sizes.bin"));
         inputstream.read(this.glyphWidth);
      } catch (IOException var6) {
         throw new RuntimeException(var6);
      } finally {
         IOUtils.closeQuietly(inputstream);
      }
   }

   private float func_181559_a(char p_181559_1_, boolean p_181559_2_) {
      if (p_181559_1_ == ' ') {
         return !this.unicodeFlag ? this.charWidth[p_181559_1_] : 4.0F;
      } else {
         int i = "ÀÁÂÈÊËÍÓÔÕÚßãõğİıŒœŞşŴŵžȇ\u0000\u0000\u0000\u0000\u0000\u0000\u0000 !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u0000ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜø£Ø×ƒáíóúñÑªº¿®¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αβΓπΣσμτΦΘΩδ∞∅∈∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■\u0000"
            .indexOf(p_181559_1_);
         return i != -1 && !this.unicodeFlag ? this.renderDefaultChar(i, p_181559_2_) : this.renderUnicodeChar(p_181559_1_, p_181559_2_);
      }
   }

   private float renderDefaultChar(int p_78266_1_, boolean p_78266_2_) {
      int i = p_78266_1_ % 16 * 8;
      int j = p_78266_1_ / 16 * 8;
      int k = p_78266_2_ ? 1 : 0;
      this.bindTexture(this.locationFontTexture);
      float f = this.charWidth[p_78266_1_];
      float f1 = 7.99F;
      GL11.glBegin(5);
      GL11.glTexCoord2f((float)i / 128.0F, (float)j / 128.0F);
      GL11.glVertex3f(this.posX + (float)k, this.posY, 0.0F);
      GL11.glTexCoord2f((float)i / 128.0F, ((float)j + 7.99F) / 128.0F);
      GL11.glVertex3f(this.posX - (float)k, this.posY + 7.99F, 0.0F);
      GL11.glTexCoord2f(((float)i + f1 - 1.0F) / 128.0F, (float)j / 128.0F);
      GL11.glVertex3f(this.posX + f1 - 1.0F + (float)k, this.posY, 0.0F);
      GL11.glTexCoord2f(((float)i + f1 - 1.0F) / 128.0F, ((float)j + 7.99F) / 128.0F);
      GL11.glVertex3f(this.posX + f1 - 1.0F - (float)k, this.posY + 7.99F, 0.0F);
      GL11.glEnd();
      return f;
   }

   private ResourceLocation getUnicodePageLocation(int p_111271_1_) {
      if (unicodePageLocations[p_111271_1_] == null) {
         unicodePageLocations[p_111271_1_] = new ResourceLocation(String.format("textures/font/unicode_page_%02x.png", p_111271_1_));
         unicodePageLocations[p_111271_1_] = FontUtils.getHdFontLocation(unicodePageLocations[p_111271_1_]);
      }

      return unicodePageLocations[p_111271_1_];
   }

   private void loadGlyphTexture(int p_78257_1_) {
      this.bindTexture(this.getUnicodePageLocation(p_78257_1_));
   }

   private float renderUnicodeChar(char p_78277_1_, boolean p_78277_2_) {
      if (this.glyphWidth[p_78277_1_] == 0) {
         return 0.0F;
      } else {
         int i = p_78277_1_ / 256;
         this.loadGlyphTexture(i);
         int j = this.glyphWidth[p_78277_1_] >>> 4;
         int k = this.glyphWidth[p_78277_1_] & 15;
         j &= 15;
         float f = (float)j;
         float f1 = (float)(k + 1);
         float f2 = (float)(p_78277_1_ % 16 * 16) + f;
         float f3 = (float)((p_78277_1_ & 255) / 16 * 16);
         float f4 = f1 - f - 0.02F;
         float f5 = p_78277_2_ ? 1.0F : 0.0F;
         GL11.glBegin(5);
         GL11.glTexCoord2f(f2 / 256.0F, f3 / 256.0F);
         GL11.glVertex3f(this.posX + f5, this.posY, 0.0F);
         GL11.glTexCoord2f(f2 / 256.0F, (f3 + 15.98F) / 256.0F);
         GL11.glVertex3f(this.posX - f5, this.posY + 7.99F, 0.0F);
         GL11.glTexCoord2f((f2 + f4) / 256.0F, f3 / 256.0F);
         GL11.glVertex3f(this.posX + f4 / 2.0F + f5, this.posY, 0.0F);
         GL11.glTexCoord2f((f2 + f4) / 256.0F, (f3 + 15.98F) / 256.0F);
         GL11.glVertex3f(this.posX + f4 / 2.0F - f5, this.posY + 7.99F, 0.0F);
         GL11.glEnd();
         return (f1 - f) / 2.0F + 1.0F;
      }
   }

   public int drawStringWithShadow(String text, float x, float y, int color) {
      return this.drawString(text, x, y, color, true);
   }

   public int drawString(String text, int x, int y, int color) {
      return !this.enabled ? 0 : this.drawString(text, (float)x, (float)y, color, false);
   }

   public int drawString(String text, float x, float y, int color, boolean dropShadow) {
      this.enableAlpha();
      this.resetStyles();
      int i;
      if (dropShadow) {
         i = this.renderString(text, x + 1.0F, y + 1.0F, color, true);
         i = Math.max(i, this.renderString(text, x, y, color, false));
      } else {
         i = this.renderString(text, x, y, color, false);
      }

      return i;
   }

   public int drawString(String text, float x, float y, int color, boolean dropShadow, float dropAdd) {
      this.enableAlpha();
      this.resetStyles();
      int i;
      if (dropShadow) {
         i = this.renderString(text, x + dropAdd, y + dropAdd, color, true);
         i = Math.max(i, this.renderString(text, x, y, color, false));
      } else {
         i = this.renderString(text, x, y, color, false);
      }

      return i;
   }

   private String bidiReorder(String p_147647_1_) {
      try {
         Bidi bidi = new Bidi(new ArabicShaping(8).shape(p_147647_1_), 127);
         bidi.setReorderingMode(0);
         return bidi.writeReordered(2);
      } catch (ArabicShapingException var31) {
         return p_147647_1_;
      }
   }

   private void resetStyles() {
      this.randomStyle = false;
      this.boldStyle = false;
      this.italicStyle = false;
      this.underlineStyle = false;
      this.strikethroughStyle = false;
   }

   private void renderStringAtPos(String p_78255_1_, boolean p_78255_2_) {
      for(int i = 0; i < p_78255_1_.length(); ++i) {
         char c0 = p_78255_1_.charAt(i);
         if (c0 == 167 && i + 1 < p_78255_1_.length()) {
            int i1 = "0123456789abcdefklmnor".indexOf(p_78255_1_.toLowerCase().charAt(i + 1));
            if (i1 < 16) {
               this.randomStyle = false;
               this.boldStyle = false;
               this.strikethroughStyle = false;
               this.underlineStyle = false;
               this.italicStyle = false;
               if (i1 < 0 || i1 > 15) {
                  i1 = 15;
               }

               if (p_78255_2_) {
                  i1 += 16;
               }

               int j1 = this.colorCode[i1];
               if (Config.isCustomColors()) {
                  j1 = CustomColors.getTextColor(i1, j1);
               }

               this.textColor = j1;
               this.setColor((float)(j1 >> 16) / 255.0F, (float)(j1 >> 8 & 0xFF) / 255.0F, (float)(j1 & 0xFF) / 255.0F, this.alpha);
            } else if (i1 == 16) {
               this.randomStyle = true;
            } else if (i1 == 17) {
               this.boldStyle = true;
            } else if (i1 == 18) {
               this.strikethroughStyle = true;
            } else if (i1 == 19) {
               this.underlineStyle = true;
            } else if (i1 == 20) {
               this.italicStyle = true;
            } else if (i1 == 21) {
               this.randomStyle = false;
               this.boldStyle = false;
               this.strikethroughStyle = false;
               this.underlineStyle = false;
               this.italicStyle = false;
               this.setColor(this.red, this.blue, this.green, this.alpha);
            }

            ++i;
         } else {
            int j = "ÀÁÂÈÊËÍÓÔÕÚßãõğİıŒœŞşŴŵžȇ\u0000\u0000\u0000\u0000\u0000\u0000\u0000 !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u0000ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜø£Ø×ƒáíóúñÑªº¿®¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αβΓπΣσμτΦΘΩδ∞∅∈∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■\u0000"
               .indexOf(c0);
            if (this.randomStyle && j != -1) {
               int k = this.getCharWidth(c0);

               char c1;
               do {
                  j = this.fontRandom
                     .nextInt(
                        "ÀÁÂÈÊËÍÓÔÕÚßãõğİıŒœŞşŴŵžȇ\u0000\u0000\u0000\u0000\u0000\u0000\u0000 !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u0000ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜø£Ø×ƒáíóúñÑªº¿®¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αβΓπΣσμτΦΘΩδ∞∅∈∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■\u0000"
                           .length()
                     );
                  c1 = "ÀÁÂÈÊËÍÓÔÕÚßãõğİıŒœŞşŴŵžȇ\u0000\u0000\u0000\u0000\u0000\u0000\u0000 !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u0000ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜø£Ø×ƒáíóúñÑªº¿®¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αβΓπΣσμτΦΘΩδ∞∅∈∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■\u0000"
                     .charAt(j);
               } while(k != this.getCharWidth(c1));

               c0 = c1;
            }

            float f1 = j != -1 && !this.unicodeFlag ? this.offsetBold : 0.5F;
            boolean flag = (c0 == 0 || j == -1 || this.unicodeFlag) && p_78255_2_;
            if (flag) {
               this.posX -= f1;
               this.posY -= f1;
            }

            float f = this.func_181559_a(c0, this.italicStyle);
            if (flag) {
               this.posX += f1;
               this.posY += f1;
            }

            if (this.boldStyle) {
               this.posX += f1;
               if (flag) {
                  this.posX -= f1;
                  this.posY -= f1;
               }

               this.func_181559_a(c0, this.italicStyle);
               this.posX -= f1;
               if (flag) {
                  this.posX += f1;
                  this.posY += f1;
               }

               f += f1;
            }

            if (this.strikethroughStyle) {
               Tessellator tessellator = Tessellator.getInstance();
               WorldRenderer worldrenderer = tessellator.getWorldRenderer();
               GlStateManager.disableTexture2D();
               worldrenderer.begin(7, DefaultVertexFormats.POSITION);
               worldrenderer.pos((double)this.posX, (double)(this.posY + (float)(this.FONT_HEIGHT / 2)), 0.0).endVertex();
               worldrenderer.pos((double)(this.posX + f), (double)(this.posY + (float)(this.FONT_HEIGHT / 2)), 0.0).endVertex();
               worldrenderer.pos((double)(this.posX + f), (double)(this.posY + (float)(this.FONT_HEIGHT / 2) - 1.0F), 0.0).endVertex();
               worldrenderer.pos((double)this.posX, (double)(this.posY + (float)(this.FONT_HEIGHT / 2) - 1.0F), 0.0).endVertex();
               tessellator.draw();
               GlStateManager.enableTexture2D();
            }

            if (this.underlineStyle) {
               Tessellator tessellator1 = Tessellator.getInstance();
               WorldRenderer worldrenderer1 = tessellator1.getWorldRenderer();
               GlStateManager.disableTexture2D();
               worldrenderer1.begin(7, DefaultVertexFormats.POSITION);
               int l = this.underlineStyle ? -1 : 0;
               worldrenderer1.pos((double)(this.posX + (float)l), (double)(this.posY + (float)this.FONT_HEIGHT), 0.0).endVertex();
               worldrenderer1.pos((double)(this.posX + f), (double)(this.posY + (float)this.FONT_HEIGHT), 0.0).endVertex();
               worldrenderer1.pos((double)(this.posX + f), (double)(this.posY + (float)this.FONT_HEIGHT - 1.0F), 0.0).endVertex();
               worldrenderer1.pos((double)(this.posX + (float)l), (double)(this.posY + (float)this.FONT_HEIGHT - 1.0F), 0.0).endVertex();
               tessellator1.draw();
               GlStateManager.enableTexture2D();
            }

            this.posX += f;
         }
      }
   }

   private int renderStringAligned(String text, int x, int y, int p_78274_4_, int color, boolean dropShadow) {
      if (this.bidiFlag) {
         int i = this.getStringWidth(this.bidiReorder(text));
         x = x + p_78274_4_ - i;
      }

      return this.renderString(text, (float)x, (float)y, color, dropShadow);
   }

   private int renderString(String text, float x, float y, int color, boolean dropShadow) {
      if (text == null) {
         return 0;
      } else {
         if (this.bidiFlag) {
            text = this.bidiReorder(text);
         }

         if ((color & -67108864) == 0) {
            color |= -16777216;
         }

         if (dropShadow) {
            color = (color & 16579836) >> 2 | color & 0xFF000000;
         }

         this.red = (float)(color >> 16 & 0xFF) / 255.0F;
         this.blue = (float)(color >> 8 & 0xFF) / 255.0F;
         this.green = (float)(color & 0xFF) / 255.0F;
         this.alpha = (float)(color >> 24 & 0xFF) / 255.0F;
         this.setColor(this.red, this.blue, this.green, this.alpha);
         this.posX = x;
         this.posY = y;
         this.renderStringAtPos(text, dropShadow);
         return (int)this.posX;
      }
   }

   public int getStringWidth(String text) {
      if (text == null) {
         return 0;
      } else {
         float f = 0.0F;
         boolean flag = false;

         for(int i = 0; i < text.length(); ++i) {
            char c0 = text.charAt(i);
            float f1 = this.getCharWidthFloat(c0);
            if (f1 < 0.0F && i < text.length() - 1) {
               c0 = text.charAt(++i);
               if (c0 == 'l' || c0 == 'L') {
                  flag = true;
               } else if (c0 == 'r' || c0 == 'R') {
                  flag = false;
               }

               f1 = 0.0F;
            }

            f += f1;
            if (flag && f1 > 0.0F) {
               f += this.unicodeFlag ? 1.0F : this.offsetBold;
            }
         }

         return (int)f;
      }
   }

   public int getCharWidth(char character) {
      return Math.round(this.getCharWidthFloat(character));
   }

   private float getCharWidthFloat(char p_getCharWidthFloat_1_) {
      if (p_getCharWidthFloat_1_ == 167) {
         return -1.0F;
      } else if (p_getCharWidthFloat_1_ == ' ') {
         return this.charWidth[32];
      } else {
         int i = "ÀÁÂÈÊËÍÓÔÕÚßãõğİıŒœŞşŴŵžȇ\u0000\u0000\u0000\u0000\u0000\u0000\u0000 !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\u0000ÇüéâäàåçêëèïîìÄÅÉæÆôöòûùÿÖÜø£Ø×ƒáíóúñÑªº¿®¬½¼¡«»░▒▓│┤╡╢╖╕╣║╗╝╜╛┐└┴┬├─┼╞╟╚╔╩╦╠═╬╧╨╤╥╙╘╒╓╫╪┘┌█▄▌▐▀αβΓπΣσμτΦΘΩδ∞∅∈∩≡±≥≤⌠⌡÷≈°∙·√ⁿ²■\u0000"
            .indexOf(p_getCharWidthFloat_1_);
         if (p_getCharWidthFloat_1_ > 0 && i != -1 && !this.unicodeFlag) {
            return this.charWidth[i];
         } else if (this.glyphWidth[p_getCharWidthFloat_1_] != 0) {
            int j = this.glyphWidth[p_getCharWidthFloat_1_] >>> 4;
            int k = this.glyphWidth[p_getCharWidthFloat_1_] & 15;
            j &= 15;
            ++k;
            return (float)((k - j) / 2 + 1);
         } else {
            return 0.0F;
         }
      }
   }

   public String trimStringToWidth(String text, int width) {
      return this.trimStringToWidth(text, width, false);
   }

   public String trimStringToWidth(String text, int width, boolean reverse) {
      StringBuilder stringbuilder = new StringBuilder();
      float f = 0.0F;
      int i = reverse ? text.length() - 1 : 0;
      int j = reverse ? -1 : 1;
      boolean flag = false;
      boolean flag1 = false;

      for(int k = i; k >= 0 && k < text.length() && f < (float)width; k += j) {
         char c0 = text.charAt(k);
         float f1 = this.getCharWidthFloat(c0);
         if (flag) {
            flag = false;
            if (c0 == 'l' || c0 == 'L') {
               flag1 = true;
            } else if (c0 == 'r' || c0 == 'R') {
               flag1 = false;
            }
         } else if (f1 < 0.0F) {
            flag = true;
         } else {
            f += f1;
            if (flag1) {
               ++f;
            }
         }

         if (f > (float)width) {
            break;
         }

         if (reverse) {
            stringbuilder.insert(0, c0);
         } else {
            stringbuilder.append(c0);
         }
      }

      return stringbuilder.toString();
   }

   private String trimStringNewline(String text) {
      while(text != null && text.endsWith("\n")) {
         text = text.substring(0, text.length() - 1);
      }

      return text;
   }

   public void drawSplitString(String str, int x, int y, int wrapWidth, int textColor) {
      this.resetStyles();
      this.textColor = textColor;
      str = this.trimStringNewline(str);
      this.renderSplitString(str, x, y, wrapWidth, false);
   }

   private void renderSplitString(String str, int x, int y, int wrapWidth, boolean addShadow) {
      for(Object s : this.listFormattedStringToWidth(str, wrapWidth)) {
         this.renderStringAligned((String)s, x, y, wrapWidth, this.textColor, addShadow);
         y += this.FONT_HEIGHT;
      }
   }

   public int splitStringWidth(String p_78267_1_, int p_78267_2_) {
      return this.FONT_HEIGHT * this.listFormattedStringToWidth(p_78267_1_, p_78267_2_).size();
   }

   public void setUnicodeFlag(boolean unicodeFlagIn) {
      this.unicodeFlag = unicodeFlagIn;
   }

   public boolean getUnicodeFlag() {
      return this.unicodeFlag;
   }

   public void setBidiFlag(boolean bidiFlagIn) {
      this.bidiFlag = bidiFlagIn;
   }

   public List listFormattedStringToWidth(String str, int wrapWidth) {
      return Arrays.asList(this.wrapFormattedStringToWidth(str, wrapWidth).split("\n"));
   }

   String wrapFormattedStringToWidth(String str, int wrapWidth) {
      int i = this.sizeStringToWidth(str, wrapWidth);
      if (str.length() <= i) {
         return str;
      } else {
         String s = str.substring(0, i);
         char c0 = str.charAt(i);
         boolean flag = c0 == ' ' || c0 == '\n';
         String s1 = getFormatFromString(s) + str.substring(i + (flag ? 1 : 0));
         return s + "\n" + this.wrapFormattedStringToWidth(s1, wrapWidth);
      }
   }

   private int sizeStringToWidth(String str, int wrapWidth) {
      int i = str.length();
      float f = 0.0F;
      int j = 0;
      int k = -1;

      for(boolean flag = false; j < i; ++j) {
         char c0 = str.charAt(j);
         switch(c0) {
            case '\n':
               --j;
               break;
            case ' ':
               k = j;
            default:
               f += this.getCharWidthFloat(c0);
               if (flag) {
                  ++f;
               }
               break;
            case '§':
               if (j < i - 1) {
                  char c1 = str.charAt(++j);
                  if (c1 == 'l' || c1 == 'L') {
                     flag = true;
                  } else if (c1 == 'r' || c1 == 'R' || isFormatColor(c1)) {
                     flag = false;
                  }
               }
         }

         if (c0 == '\n') {
            k = ++j;
            break;
         }

         if (f > (float)wrapWidth) {
            break;
         }
      }

      return j != i && k != -1 && k < j ? k : j;
   }

   private static boolean isFormatColor(char colorChar) {
      return colorChar >= '0' && colorChar <= '9' || colorChar >= 'a' && colorChar <= 'f' || colorChar >= 'A' && colorChar <= 'F';
   }

   private static boolean isFormatSpecial(char formatChar) {
      return formatChar >= 'k' && formatChar <= 'o' || formatChar >= 'K' && formatChar <= 'O' || formatChar == 'r' || formatChar == 'R';
   }

   public static String getFormatFromString(String text) {
      String s = "";
      int i = -1;
      int j = text.length();

      while((i = text.indexOf(167, i + 1)) != -1) {
         if (i < j - 1) {
            char c0 = text.charAt(i + 1);
            if (isFormatColor(c0)) {
               s = "§" + c0;
            } else if (isFormatSpecial(c0)) {
               s = s + "§" + c0;
            }
         }
      }

      return s;
   }

   public boolean getBidiFlag() {
      return this.bidiFlag;
   }

   public int getColorCode(char character) {
      int i = "0123456789abcdef".indexOf(character);
      if (i >= 0 && i < this.colorCode.length) {
         int j = this.colorCode[i];
         if (Config.isCustomColors()) {
            j = CustomColors.getTextColor(i, j);
         }

         return j;
      } else {
         return 16777215;
      }
   }

   protected void setColor(float p_setColor_1_, float p_setColor_2_, float p_setColor_3_, float p_setColor_4_) {
      GlStateManager.color(p_setColor_1_, p_setColor_2_, p_setColor_3_, p_setColor_4_);
   }

   protected void enableAlpha() {
      GlStateManager.enableAlpha();
   }

   protected void bindTexture(ResourceLocation p_bindTexture_1_) {
      this.renderEngine.bindTexture(p_bindTexture_1_);
   }

   protected InputStream getResourceInputStream(ResourceLocation p_getResourceInputStream_1_) throws IOException {
      return Minecraft.getMinecraft().getResourceManager().getResource(p_getResourceInputStream_1_).getInputStream();
   }

    public void drawString(String string, float x, float y, int rgb) {
      drawString(string, (int)x, (int)y, rgb);
    }
}

Answer: this.name = name;

<think>
In the Module class, the constructor begins with the signature `public Module(String name, Color color, Categorys category) {`. The first logical step inside the constructor is to assign the passed-in name to the instance field `name`. This matches typical Java practice of initializing fields at the start of a constructor.
</think>
this.name = name;