package aP;

import C.BiInterfaceFoxtrot;
import G.R;
import G.S;
import G.T;
import G.GInterfaceAg;
import G.ExceptionprintstacktraceInGPackage;
import G.AeInterfaceMikeTostring;
import V.ExceptionInVPackage;
import W.ManagerUsingFile;
import aE.ExceptionInVPackage;
import aQ.ExceptionInVPackage;
import az.AzInterfaceCharlie;
import az.AzInterfaceDelta;
import az.ThreadedInAzPackage;
import az.AzInterfaceTango;
import bH.A;
import bH.C;
import bH.D;
import bH.J;
import bH.P;
import bH.U;
import bH.X;
import bH.ae;
import bH.b;
import bH.n;
import bH.AzInterfaceTango;
import bI.BiInterfaceFoxtrot;
import bI.BiInterfaceHotel;
import bV.ExceptionInVPackage;
import bV.AzInterfaceDelta;
import bV.BvInterfaceEcho;
import com.efiAnalytics.ui.aN;
import com.efiAnalytics.ui.bU;
import com.efiAnalytics.ui.bV;
import com.efiAnalytics.ui.cS;
import com.efiAnalytics.ui.dI;
import com.efiAnalytics.ui.dS;
import BiInterfaceFoxtrot.AzInterfaceDelta;
import BiInterfaceHotel.RInterfaceIndia;
import java.awt.AWTEvent;
import java.awt.BorderLayout;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.GridLayout;
import java.awt.Image;
import java.awt.Insets;
import java.awt.KeyboardFocusManager;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.Window;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.Locale;
import java.util.Properties;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.zip.ZipException;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JRootPane;
import javax.swing.ToolTipManager;
import r.ExceptionInVPackage;
import r.RInterfaceIndia;
import r.ThreadedFile;
import s.SComponentGolf;

public class WindowListenerAzinterfacecharlie extends JFrame implements S, GInterfaceAg, aX, b, WindowListener {
  long ExceptionInVPackage = 604800000L;
  
  private dB AzInterfaceDelta = null;
  
  private cb BvInterfaceEcho = cb.ExceptionInVPackage();
  
  public static boolean b = false;
  
  private static String BiInterfaceFoxtrot = RInterfaceIndia.AzInterfaceCharlie;
  
  private static String SComponentGolf = RInterfaceIndia.b;
  
  private boolean BiInterfaceHotel = false;
  
  private boolean RInterfaceIndia = false;
  
  boolean AzInterfaceCharlie = false;
  
  public WindowListenerAzinterfacecharlie() {
    this(true);
  }
  
  public WindowListenerAzinterfacecharlie(boolean paramBoolean) {
    cS cS = cS.ExceptionInVPackage((C)new dy(this));
    cS.AzInterfaceCharlie = 800;
    bV.ExceptionInVPackage((bU)ExceptionInVPackage.ExceptionInVPackage());
    cS.AzInterfaceCharlie += 700;
    AzInterfaceTango AzInterfaceTango = new AzInterfaceTango();
    BiInterfaceHotel.ExceptionInVPackage().ExceptionInVPackage((BiInterfaceFoxtrot)AzInterfaceTango);
    dd.ExceptionInVPackage().ExceptionInVPackage(this);
    cS.AzInterfaceCharlie += 466;
    y();
    (A.RInterfaceIndia()).AzInterfaceCharlie = cS.AzInterfaceCharlie;
    A.RInterfaceIndia().ExceptionInVPackage(true);
    String str1 = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.cF, "");
    hO hO = new hO(this);
    boolean bool1 = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.J, false);
    String str2 = X.b(ExceptionInVPackage.AzInterfaceCharlie, SComponentGolf, "");
    boolean bool2 = x();
    if (bool2)
      ThreadedInAzPackage.ExceptionInVPackage(true); 
    if (!bool1 && cS.ExceptionInVPackage(str1)) {
      this.BiInterfaceHotel = u();
      if (!this.BiInterfaceHotel) {
        ExceptionInVPackage.ExceptionInVPackage().AzInterfaceDelta(ExceptionInVPackage.ThreadedFile, "");
        try {
          ExceptionInVPackage.ExceptionInVPackage().RInterfaceIndia();
        } catch (ExceptionInVPackage ExceptionInVPackage) {
          Logger.getLogger(dl.class.getName()).log(Level.SEVERE, (String)null, (Throwable)ExceptionInVPackage);
        } 
      } 
      str2 = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.n, ExceptionInVPackage.AzInterfaceCharlie);
      boolean bool = RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage(ExceptionInVPackage.b, str2);
      if (bool) {
        ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(bool);
        str2 = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.cn, str2);
      } 
      if (this.BiInterfaceHotel && ExceptionInVPackage.AzInterfaceCharlie.contains(RInterfaceIndia.b) && !str2.contains(RInterfaceIndia.b)) {
        ExceptionInVPackage.AzInterfaceCharlie = str2 + RInterfaceIndia.b;
      } else {
        ExceptionInVPackage.AzInterfaceCharlie = str2;
      } 
    } else {
      this.BiInterfaceHotel = false;
    } 
    if (!this.BiInterfaceHotel) {
      ExceptionInVPackage.AzInterfaceCharlie += BiInterfaceFoxtrot;
      bF.ExceptionInVPackage().ExceptionInVPackage(ExceptionInVPackage.b, ExceptionInVPackage.AzInterfaceCharlie);
    } else {
      bF.ExceptionInVPackage().ExceptionInVPackage(ExceptionInVPackage.b, str2);
    } 
    AzInterfaceCharlie();
    jN.ExceptionInVPackage();
    if (ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.y, false)) {
      dg.ExceptionInVPackage().ExceptionInVPackage(true);
    } else if (!ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.bP, ExceptionInVPackage.bQ) && !dg.ExceptionInVPackage().b()) {
      System.exit(0);
    } 
    if (paramBoolean)
      SComponentGolf(); 
    if (ExceptionInVPackage.b.equals(ExceptionInVPackage.av) || ExceptionInVPackage.b.equals(ExceptionInVPackage.aw)) {
      Image image = Toolkit.getDefaultToolkit().getImage(getClass().getResource("resources/MTicon.png"));
      setIconImage(image);
    } else if (ExceptionInVPackage.b.equals(ExceptionInVPackage.au)) {
      Image image = Toolkit.getDefaultToolkit().getImage(getClass().getResource("resources/GRicon32.png"));
      setIconImage(image);
    } else if (ExceptionInVPackage.b.equals(ExceptionInVPackage.as)) {
      Image image = Toolkit.getDefaultToolkit().getImage(getClass().getResource("resources/BigCommIcon.png"));
      setIconImage(image);
    } else if (ExceptionInVPackage.b.equals(ExceptionInVPackage.at)) {
      Image image = Toolkit.getDefaultToolkit().getImage(getClass().getResource("resources/BigCommGen4Icon.png"));
      setIconImage(image);
    } else {
      Image image = Toolkit.getDefaultToolkit().getImage(getClass().getResource("resources/TSicon.gif"));
      setIconImage(image);
    } 
    jN.ExceptionInVPackage();
    int RInterfaceIndia = ExceptionInVPackage.ExceptionInVPackage().ExceptionInVPackage(ExceptionInVPackage.aT, 1000);
    if (RInterfaceIndia == 1000 || Math.random() < 0.1D) {
      dm dm = new dm(this);
      dm.start();
    } 
    if (bV.AzInterfaceDelta()) {
      ExceptionInVPackage.class.getClass();
      Window window = ExceptionInVPackage.ExceptionInVPackage();
    } 
    if (bool2) {
      hq.ExceptionInVPackage().ExceptionInVPackage("Finishing Upgrade....");
      Thread.yield();
      A();
      z();
      BiInterfaceFoxtrot();
      ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.aR, "" + (System.currentTimeMillis() - this.ExceptionInVPackage - 1000L));
      ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.aS, "" + (System.currentTimeMillis() - 1000L));
      try {
        ExceptionInVPackage.ExceptionInVPackage().BvInterfaceEcho();
      } catch (ExceptionInVPackage ExceptionInVPackage) {
        D.ExceptionInVPackage("Error saving preference file.", (Exception)ExceptionInVPackage, this);
      } 
      if (J.BiInterfaceFoxtrot()) {
        File file1 = new File(".", "environment.txt");
        File file2 = new File(".", "runtime");
        if (!file2.isDirectory()) {
          D.AzInterfaceDelta("Running on XP, but cannot switch JRE as there is no runtime dir.");
        } else {
          D.AzInterfaceDelta("Running on XP, switching JRE");
          if (!file1.exists()) {
            D.AzInterfaceDelta("environment.txt missing, creating");
          } else if (!file1.delete()) {
            D.b("Failed to delete environment.txt");
          } else {
            try {
              file1.createNewFile();
              BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file1));
              bufferedWriter.append("-Xms128m -Xmx512m -cp .;./plugins/;./runtime/lib/*;./lib/*.jar -Djava.home=./runtime -Djava.library.path=./lib -jar ");
              bufferedWriter.append(ExceptionInVPackage.RInterfaceIndia);
              bufferedWriter.newLine();
              bufferedWriter.append("runtime");
              bufferedWriter.newLine();
              bufferedWriter.append(ExceptionInVPackage.RInterfaceIndia);
              bufferedWriter.newLine();
              bufferedWriter.flush();
              bufferedWriter.close();
            } catch (IOException iOException) {
              D.ExceptionInVPackage(iOException);
            } 
          } 
        } 
      } 
    } 
    AzInterfaceDelta();
    hO.b();
    hO.start();
    setTitle("");
    addWindowListener(this);
    hq.ExceptionInVPackage().ExceptionInVPackage("Initializing User Interface");
    Dimension dimension = Toolkit.getDefaultToolkit().getScreenSize();
    int ThreadedFile = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie("x", 100);
    if (ThreadedFile > dimension.width && !bV.BiInterfaceHotel())
      ThreadedFile = 100; 
    int k = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie("y", 50);
    int m = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie("width", dimension.width - 200);
    int n = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie("height", dimension.height - 100);
    ToolTipManager.sharedInstance().setEnabled(true);
    hb hb = new hb();
    T.ExceptionInVPackage().ExceptionInVPackage(hb);
    add("Center", hb);
    boolean bool3 = (!this.BiInterfaceHotel && !RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage("surpressAds")) ? true : false;
    iW iW = new iW(bool3);
    JPanel jPanel1 = new JPanel();
    jPanel1.setLayout(new BorderLayout(5, 5));
    JPanel jPanel2 = new JPanel();
    jPanel2.setLayout(new GridLayout(1, 1));
    jPanel1.add("North", jPanel2);
    dd.ExceptionInVPackage().ExceptionInVPackage(jPanel2);
    jPanel1.add("South", iW);
    add("South", jPanel1);
    this.AzInterfaceDelta = new dB(this, BiInterfaceFoxtrot.ExceptionInVPackage());
    dd.ExceptionInVPackage().ExceptionInVPackage(this.AzInterfaceDelta);
    BiInterfaceFoxtrot.ExceptionInVPackage().ExceptionInVPackage(this.AzInterfaceDelta);
    T t1 = T.ExceptionInVPackage();
    t1.ExceptionInVPackage(this);
    t1.ExceptionInVPackage(this.AzInterfaceDelta);
    t1.ExceptionInVPackage(iW);
    Rectangle rectangle = new Rectangle(ThreadedFile, k, m, n);
    rectangle = bV.ExceptionInVPackage(rectangle);
    setBounds(rectangle);
    if (ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie("mainWindowMaximized", false))
      setExtendedState(6); 
    doLayout();
    enableEvents(1L);
    enableEvents(262144L);
    bV.ExceptionInVPackage(this);
    BiInterfaceFoxtrot.ExceptionInVPackage().ExceptionInVPackage(this);
    KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher(this.BvInterfaceEcho);
    T.ExceptionInVPackage().ExceptionInVPackage(this.BvInterfaceEcho);
    BiInterfaceHotel();
    boolean bool4 = false;
    if (bool4) {
      char AzInterfaceCharlie = 'ߩ';
      Calendar calendar1 = Calendar.getInstance();
      if (calendar1.get(1) > 2500 && !Locale.getDefault().equals(Locale.US)) {
        calendar1.set(AzInterfaceCharlie + 543, 6, 28);
      } else {
        calendar1.set(AzInterfaceCharlie, 6, 28);
      } 
      long l = ExceptionInVPackage.ExceptionInVPackage().ExceptionInVPackage(ExceptionInVPackage.aS, 0L);
      Properties properties = new Properties();
      properties.setProperty(BiInterfaceFoxtrot.b, ExceptionInVPackage.b);
      properties.setProperty(BiInterfaceFoxtrot.AzInterfaceCharlie, ExceptionInVPackage.AzInterfaceCharlie);
      if (!this.BiInterfaceHotel && (calendar1.getTime().getTime() < System.currentTimeMillis() || l > calendar1.getTimeInMillis())) {
        boolean bool = false;
        try {
          bool = !l() ? true : false;
        } catch (ExceptionInVPackage ExceptionInVPackage) {
          D.ExceptionInVPackage("Unable to get upgrade, please try ExceptionInVPackage manual install.", (Exception)ExceptionInVPackage, this);
          bool = true;
        } 
        if (bool) {
          cS.ExceptionInVPackage().ExceptionInVPackage(this);
          bV.AzInterfaceDelta(BiInterfaceFoxtrot.ExceptionInVPackage(properties, BiInterfaceFoxtrot.BiInterfaceFoxtrot), this);
        } 
        aN.ExceptionInVPackage(ExceptionInVPackage.BiInterfaceHotel);
        System.exit(0);
      } 
      ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.aS, "" + System.currentTimeMillis());
      Calendar calendar2 = Calendar.getInstance();
      calendar2.set(1979, 5, 1);
      if (!this.BiInterfaceHotel && calendar2.getTime().getTime() > System.currentTimeMillis()) {
        bV.AzInterfaceDelta(BiInterfaceFoxtrot.ExceptionInVPackage(properties, BiInterfaceFoxtrot.SComponentGolf), this);
        aN.ExceptionInVPackage(ExceptionInVPackage.BiInterfaceHotel);
        System.exit(0);
      } 
      if (!this.BiInterfaceHotel && calendar1.getTime().getTime() < System.currentTimeMillis() + 2592000000L) {
        long l1 = (long)((calendar1.getTime().getTime() - System.currentTimeMillis()) / 8.64E7D);
        properties.setProperty(BiInterfaceFoxtrot.AzInterfaceDelta, l1 + "");
        String str = BiInterfaceFoxtrot.ExceptionInVPackage(properties, BiInterfaceFoxtrot.ThreadedFile);
        bV.AzInterfaceDelta(str, this);
      } 
      if (this.BiInterfaceHotel && ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.cM, false)) {
        String str = BiInterfaceFoxtrot.ExceptionInVPackage(properties, BiInterfaceFoxtrot.BiInterfaceHotel);
        ExceptionInVPackage.ExceptionInVPackage().BvInterfaceEcho(ExceptionInVPackage.cM);
        try {
          v();
        } catch (ExceptionInVPackage ExceptionInVPackage) {}
        bV.AzInterfaceDelta(str, this);
        aN.ExceptionInVPackage(ExceptionInVPackage.BiInterfaceHotel);
        System.exit(0);
      } 
    } 
    setVisible(true);
    boolean bool5 = (ExceptionInVPackage.ExceptionInVPackage().ExceptionInVPackage(ExceptionInVPackage.aR, 0L) + this.ExceptionInVPackage < System.currentTimeMillis() && (ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.aQ, true) || !A.RInterfaceIndia().ExceptionInVPackage(ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.cF, "")))) ? true : false;
    if (ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.y, false) && ThreadedFile.ExceptionInVPackage(".")) {
      ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.aR, "0");
      BiInterfaceFoxtrot.ExceptionInVPackage().BvInterfaceEcho(SComponentGolf.b("Updating Application Files"));
      this.RInterfaceIndia = true;
      (new dA(this, true, this)).start();
    } else if (bool5) {
      (new dA(this, false, this)).start();
    } 
    setTransferHandler(new dx(this));
  }
  
  public void AzInterfaceCharlie() {
    ExceptionInVPackage.ExceptionInVPackage = new dn(this);
    SComponentGolf.ExceptionInVPackage();
    String str = ExceptionInVPackage.ExceptionInVPackage().ExceptionInVPackage("viewLanguageCode", "en");
    try {
      hq.ExceptionInVPackage().ExceptionInVPackage("Loading Language Content.");
      SComponentGolf.ExceptionInVPackage(str);
      SComponentGolf.b(" dummyToLoad");
      ExceptionprintstacktraceInGPackage.ExceptionInVPackage(SComponentGolf.AzInterfaceDelta());
    } catch (ExceptionInVPackage ExceptionInVPackage) {
      bV.AzInterfaceDelta("Unable to set language code.\n" + ExceptionInVPackage.getMessage(), this);
    } 
  }
  
  public void AzInterfaceDelta() {
    try {
      double AzInterfaceDelta = Double.parseDouble(System.getProperty("java.specification.version"));
      if (AzInterfaceDelta < 1.8D)
        if (J.ExceptionInVPackage()) {
          String str = "https://www.efianalytics.com/TunerStudio/download/";
          if (bV.ExceptionInVPackage(ExceptionInVPackage.b + " is currently running on JRE version " + AzInterfaceDelta + ".\nThis application requires JRE 1.8 or higher.\nIf you continue, you will experience problems.\n\nThe easiest way to correct this is to download and run the installer.\n\nWould you like to go to the download page now?", this, true))
            aN.ExceptionInVPackage(str); 
        } else {
          String str = "https://adoptopenjdk.net/";
          if (bV.ExceptionInVPackage(ExceptionInVPackage.b + " is currently running on JRE version " + AzInterfaceDelta + ".\nThis application requires JRE 1.8 or higher.\nIf you continue, you will experience problems.\n\nWould you like to get the latest JRE now?", this, true))
            aN.ExceptionInVPackage(str); 
        }  
    } catch (Exception exception) {
      bV.AzInterfaceDelta("Unable to determine the JRE version.\nJRE version 1.8 is required for this application", this);
    } 
  }
  
  public void BvInterfaceEcho() {
    (new dA(this, false, this)).start();
  }
  
  public void BiInterfaceFoxtrot() {
    File file1 = new File(ThreadedFile.D(), "firmwareLoader");
    File file2 = new File(ThreadedFile.C(), "firmwareLoader");
    try {
      if (file1.exists())
        AzInterfaceTango.ExceptionInVPackage(file1, file2); 
    } catch (ExceptionInVPackage ExceptionInVPackage) {
      Logger.getLogger(dl.class.getName()).log(Level.SEVERE, (String)null, (Throwable)ExceptionInVPackage);
    } 
  }
  
  public void repaint(long paramLong, int paramInt1, int paramInt2, int paramInt3, int paramInt4) {
    super.repaint(paramLong, paramInt1, paramInt2, paramInt3, paramInt4);
  }
  
  public static void SComponentGolf() {
    if (dd.ExceptionInVPackage().BvInterfaceEcho() == null) {
      String str = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.aX);
      if (str == null) {
        D.b("No splash Image found, not showing splash screen.");
        return;
      } 
      boolean bool = false;
      iJ iJ = new iJ(null, str, bool);
      dd.ExceptionInVPackage().ExceptionInVPackage(iJ);
    } 
  }
  
  private boolean u() {
    if (!RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage(";'GD;'GD[PHGD-0HL")) {
      ThreadedInAzPackage ThreadedInAzPackage = ThreadedInAzPackage.ExceptionInVPackage((AzInterfaceDelta)new ExceptionInVPackage(), SComponentGolf.AzInterfaceDelta());
      AzInterfaceDelta AzInterfaceDelta = ThreadedInAzPackage.BiInterfaceHotel();
      if (AzInterfaceDelta != null) {
        if (AzInterfaceDelta.ExceptionInVPackage() == 0) {
          this.BiInterfaceHotel = true;
          NumericTextField numericTextField = new NumericTextField(this, ThreadedInAzPackage);
          numericTextField.start();
        } else if (AzInterfaceDelta.ExceptionInVPackage() == 4) {
          bV.AzInterfaceDelta(SComponentGolf.b(AzInterfaceCharlie.BiInterfaceHotel) + "\n" + SComponentGolf.b(AzInterfaceCharlie.BiInterfaceFoxtrot), this);
          this.BiInterfaceHotel = false;
        } else if (AzInterfaceDelta.ExceptionInVPackage() == 1) {
          D.AzInterfaceCharlie("renewal over due");
          String str = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.n, ExceptionInVPackage.AzInterfaceCharlie);
          if (str.contains(RInterfaceIndia.AzInterfaceDelta)) {
            bV.AzInterfaceDelta(SComponentGolf.b("Trial Activation has expired.") + "\n" + SComponentGolf.b("Please connect to the internet to see if trial period is still valid and reactivate."), this);
            ExceptionInVPackage.ExceptionInVPackage().AzInterfaceDelta(ExceptionInVPackage.ThreadedFile, "");
            try {
              ExceptionInVPackage.ExceptionInVPackage().RInterfaceIndia();
            } catch (ExceptionInVPackage ExceptionInVPackage) {
              Logger.getLogger(dl.class.getName()).log(Level.SEVERE, (String)null, (Throwable)ExceptionInVPackage);
            } 
            this.BiInterfaceHotel = false;
          } else {
            this.BiInterfaceHotel = true;
          } 
        } else if (AzInterfaceDelta.ExceptionInVPackage() == 2) {
          bV.AzInterfaceDelta(SComponentGolf.b(AzInterfaceCharlie.BiInterfaceHotel) + "\n" + SComponentGolf.b(AzInterfaceDelta.b()), this);
          this.BiInterfaceHotel = false;
        } else if (AzInterfaceDelta.ExceptionInVPackage() == 7) {
          bV.AzInterfaceDelta(SComponentGolf.b(AzInterfaceCharlie.ThreadedFile) + "\n" + SComponentGolf.b(AzInterfaceDelta.b()), this);
          this.BiInterfaceHotel = false;
        } else if (AzInterfaceDelta.ExceptionInVPackage() == 5) {
          bV.AzInterfaceDelta(AzInterfaceCharlie.AzInterfaceCharlie(SComponentGolf.AzInterfaceDelta()) + "\n" + SComponentGolf.b(AzInterfaceDelta.b()), this);
          this.BiInterfaceHotel = false;
        } else if (AzInterfaceDelta.ExceptionInVPackage() == 6) {
          String str1 = X.b(ExceptionInVPackage.AzInterfaceCharlie, RInterfaceIndia.AzInterfaceCharlie, "");
          str1 = X.b(str1, RInterfaceIndia.b, "");
          String str2 = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.n, "");
          if (str2 != null && str2.contains(RInterfaceIndia.AzInterfaceDelta)) {
            String str3 = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.cF, "");
            String str4 = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.cI, "");
            if (str4 != null && !str4.isEmpty() && !str4.equals(str3)) {
              ExceptionInVPackage.ExceptionInVPackage().AzInterfaceDelta(ExceptionInVPackage.cF, str4);
              ExceptionInVPackage.ExceptionInVPackage().AzInterfaceDelta(ExceptionInVPackage.cI, "");
              ExceptionInVPackage.ExceptionInVPackage().AzInterfaceDelta(ExceptionInVPackage.n, str1);
              if (A.RInterfaceIndia().ExceptionInVPackage(str4)) {
                try {
                  ExceptionInVPackage.ExceptionInVPackage().RInterfaceIndia();
                } catch (ExceptionInVPackage ExceptionInVPackage) {
                  Logger.getLogger(dl.class.getName()).log(Level.SEVERE, (String)null, (Throwable)ExceptionInVPackage);
                } 
                String str = RInterfaceIndia.ExceptionInVPackage().b();
                if (str != null && !str.isEmpty()) {
                  String str5 = ExceptionInVPackage.b + " Registration Notice!\n\n" + SComponentGolf.b("We apologize, but your trial registration has expired.") + "\n" + SComponentGolf.b("Your previous registration has be restored.") + "\n\n" + SComponentGolf.b("Would you like to check for current Upgrades?");
                  String[] arrayOfString = { SComponentGolf.b("Check for Upgrades"), SComponentGolf.b("Use previous registration") };
                  boolean bool = bV.ExceptionInVPackage(str5, "Trial Ended", this, arrayOfString);
                  if (bool)
                    aN.ExceptionInVPackage(str); 
                } 
                return u();
              } 
            } else {
              ExceptionInVPackage.ExceptionInVPackage().AzInterfaceDelta(ExceptionInVPackage.cF, "");
              ExceptionInVPackage.ExceptionInVPackage().AzInterfaceDelta(ExceptionInVPackage.n, "");
              String str = ExceptionInVPackage.b + " Registration Notice!\n\n" + SComponentGolf.b("We apologize, but your trial registration has expired.") + "\n\n" + SComponentGolf.b("Unfortunately, there is no previous registration information on this computer.") + "\n" + SComponentGolf.b("You will need your previous registration if you have one.") + "\n\n" + SComponentGolf.b("Would you like to check for current Upgrades?");
              String[] arrayOfString = { SComponentGolf.b("Check for Upgrades"), SComponentGolf.b("Enter previous registration"), SComponentGolf.b("Use Lite! Edition") };
              int RInterfaceIndia = JOptionPane.showOptionDialog(this, str, "Trial Ended", 1, 3, null, (Object[])arrayOfString, arrayOfString[0]);
              if (RInterfaceIndia == 0) {
                String str5 = ExceptionInVPackage.M;
                aN.ExceptionInVPackage(str5);
              } else if (RInterfaceIndia == 1) {
                aN.ExceptionInVPackage(ExceptionInVPackage.N);
                dp dp = new dp(this);
                dp.start();
              } 
              try {
                ExceptionInVPackage.ExceptionInVPackage().RInterfaceIndia();
              } catch (ExceptionInVPackage ExceptionInVPackage) {
                Logger.getLogger(dl.class.getName()).log(Level.SEVERE, (String)null, (Throwable)ExceptionInVPackage);
              } 
              this.BiInterfaceHotel = false;
              return this.BiInterfaceHotel;
            } 
          } else {
            bV.AzInterfaceDelta("The registration information provided is no longer valid for " + ExceptionInVPackage.ExceptionInVPackage().l() + ".\n\nPlease contact EFI Analytics if you believe this registration is valid.", dd.ExceptionInVPackage().AzInterfaceCharlie());
            aN.ExceptionInVPackage("https://www.efianalytics.com/register/register.jsp?appName=" + ExceptionInVPackage.b + str1);
          } 
          try {
            v();
          } catch (ExceptionInVPackage ExceptionInVPackage) {
            Logger.getLogger(dl.class.getName()).log(Level.SEVERE, (String)null, (Throwable)ExceptionInVPackage);
          } 
          this.BiInterfaceHotel = false;
        } 
      } else {
        ExceptionInVPackage.AzInterfaceCharlie += BiInterfaceFoxtrot;
        this.BiInterfaceHotel = false;
      } 
    } 
    return this.BiInterfaceHotel;
  }
  
  private void v() {
    ExceptionInVPackage.ExceptionInVPackage().AzInterfaceDelta(ExceptionInVPackage.cF, "");
    ExceptionInVPackage.ExceptionInVPackage().AzInterfaceDelta(ExceptionInVPackage.cE, "");
    ExceptionInVPackage.ExceptionInVPackage().AzInterfaceDelta(ExceptionInVPackage.cC, "");
    ExceptionInVPackage.ExceptionInVPackage().AzInterfaceDelta(ExceptionInVPackage.cD, "");
    ExceptionInVPackage.ExceptionInVPackage().AzInterfaceDelta(ExceptionInVPackage.n, "");
    ExceptionInVPackage.ExceptionInVPackage().RInterfaceIndia();
    ExceptionInVPackage.ExceptionInVPackage().BvInterfaceEcho();
  }
  
  private void b(String paramString) {
    try {
      String str = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.cN, "");
      String[] arrayOfString = str.split(";");
      for (byte b1 = 0; b1 < arrayOfString.length; b1++) {
        if (!arrayOfString[b1].equals(paramString))
          str = str + arrayOfString[b1] + ";"; 
      } 
      ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.cN, str);
      ExceptionInVPackage.ExceptionInVPackage().BvInterfaceEcho();
    } catch (ExceptionInVPackage ExceptionInVPackage) {}
  }
  
  public void BiInterfaceHotel() {
    iJ iJ = dd.ExceptionInVPackage().BvInterfaceEcho();
    if (iJ != null) {
      boolean bool = (!this.BiInterfaceHotel && !RInterfaceIndia.ExceptionInVPackage().ExceptionInVPackage("surpressAds")) ? true : false;
      if (bool) {
        dq dq = new dq(this);
        dq.start();
      } else {
        iJ.dispose();
        dd.ExceptionInVPackage().ExceptionInVPackage((iJ)null);
      } 
    } 
  }
  
  public void RInterfaceIndia() {
    if (this.RInterfaceIndia)
      return; 
    boolean bool = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.bf, ExceptionInVPackage.cP);
    if (bool) {
      String str = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie("lastProjectPath", "");
      if (str.equals("") || ExceptionInVPackage.u(str)) {
        String str1 = ThreadedFile.s();
        if ((new File(str1)).exists()) {
          hq.ExceptionInVPackage().ExceptionInVPackage("Opening default Project....");
          BiInterfaceFoxtrot.ExceptionInVPackage().ExceptionInVPackage(this, str1);
        } 
        return;
      } 
      hq.ExceptionInVPackage().ExceptionInVPackage("Opening Last Project....");
      jN.ExceptionInVPackage();
      BiInterfaceFoxtrot.ExceptionInVPackage().k(this);
      boolean bool1 = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.bg, false);
      if (bool1) {
        jN.ExceptionInVPackage();
        dr dr = new dr(this);
        BiInterfaceFoxtrot.ExceptionInVPackage().ExceptionInVPackage(dr);
      } 
    } else {
      BiInterfaceFoxtrot.ExceptionInVPackage().G();
    } 
  }
  
  public int ThreadedFile() {
    int RInterfaceIndia = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.aT, 0);
    D.AzInterfaceCharlie("Running speed test");
    U u = new U();
    u.ExceptionInVPackage();
    int ThreadedFile = u.ExceptionInVPackage();
    ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.aT, "" + ThreadedFile);
    D.AzInterfaceCharlie("Processor Score:" + ThreadedFile);
    return ThreadedFile;
  }
  
  public void k() {
    ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.aR, "0");
    ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.aR + P.b, "0");
    ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.aR + P.b, "0");
    (new dA(this, true, this)).start();
    P p = new P(ManagerUsingFile.b, P.b);
    p.ExceptionInVPackage();
    try {
      P p1 = new P(ThreadedFile.AzInterfaceCharlie(), P.ExceptionInVPackage);
      p1.ExceptionInVPackage();
    } catch (ExceptionInVPackage ExceptionInVPackage) {
      D.ExceptionInVPackage(ExceptionInVPackage.getLocalizedMessage());
    } 
  }
  
  public boolean ExceptionInVPackage(String paramString1, String paramString2, String paramString3, String paramString4, String paramString5) {
    ExceptionInVPackage ExceptionInVPackage = new ExceptionInVPackage();
    AzInterfaceDelta AzInterfaceDelta = null;
    try {
      AzInterfaceDelta = ExceptionInVPackage.ExceptionInVPackage(ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.aN, ""), ExceptionInVPackage.b, ExceptionInVPackage.ExceptionInVPackage, ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.aO, ""), ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.aT, ""), ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.cF, ""), paramString5, ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.cO, ""));
    } catch (IOException iOException) {
      System.out.println("Unable to read from update server, connection to server unavailable");
      throw new ExceptionInVPackage("Update server is currently unavailable");
    } 
    if (AzInterfaceDelta == null)
      throw new ExceptionInVPackage("Update server is currently unavailable"); 
    if (AzInterfaceDelta.ExceptionInVPackage() == 4 || AzInterfaceDelta.ExceptionInVPackage() == 8)
      return true; 
    b(paramString3);
    ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.cM, "false");
    ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.cL, "false");
    return false;
  }
  
  public boolean l() {
    Date date1 = new Date();
    date1.setTime(ExceptionInVPackage.ExceptionInVPackage().ExceptionInVPackage(ExceptionInVPackage.aR, (new Date()).getTime() - this.ExceptionInVPackage - 1L));
    Date date2 = new Date();
    date2.setTime(System.currentTimeMillis() - this.ExceptionInVPackage);
    boolean bool = false;
    if (date1.before(date2)) {
      ExceptionInVPackage ExceptionInVPackage = new ExceptionInVPackage();
      AzInterfaceDelta AzInterfaceDelta = null;
      if (n.ExceptionInVPackage()) {
        try {
          String str = X.b(ExceptionInVPackage.AzInterfaceCharlie, BiInterfaceFoxtrot, "").trim();
          str = X.b(str, RInterfaceIndia.AzInterfaceDelta, "").trim();
          BvInterfaceEcho BvInterfaceEcho = new BvInterfaceEcho();
          BvInterfaceEcho.ExceptionInVPackage(ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.aN, ""));
          BvInterfaceEcho.b(ExceptionInVPackage.b);
          BvInterfaceEcho.AzInterfaceCharlie(ExceptionInVPackage.ExceptionInVPackage);
          BvInterfaceEcho.AzInterfaceDelta(ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.aO, ""));
          BvInterfaceEcho.BvInterfaceEcho(ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.aT, ""));
          BvInterfaceEcho.BiInterfaceFoxtrot(ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.cF, ""));
          BvInterfaceEcho.SComponentGolf(str);
          BvInterfaceEcho.BiInterfaceHotel(ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.cO, ""));
          BvInterfaceEcho.RInterfaceIndia(SComponentGolf.AzInterfaceCharlie().getLanguage());
          AzInterfaceDelta = ExceptionInVPackage.ExceptionInVPackage(BvInterfaceEcho);
        } catch (IOException iOException) {
          System.out.println("Unable to read from update server, connection to server unavailable");
          throw new ExceptionInVPackage("Update server is currently unavailable");
        } 
      } else {
        throw new ExceptionInVPackage("Unable to connect to Internet");
      } 
      if (AzInterfaceDelta == null)
        return false; 
      if (AzInterfaceDelta.ExceptionInVPackage() == 0) {
        this.AzInterfaceCharlie = false;
        w();
        ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.aR, "" + (new Date()).getTime());
        ExceptionInVPackage.ExceptionInVPackage().BvInterfaceEcho();
        return false;
      } 
      if (AzInterfaceDelta.ExceptionInVPackage() == 2) {
        w();
        String[] arrayOfString = { SComponentGolf.b("Complete Update"), SComponentGolf.b("Update Later") };
        boolean bool1 = (this.RInterfaceIndia || bV.ExceptionInVPackage(AzInterfaceDelta.b(), SComponentGolf.b("Update Available"), this, arrayOfString)) ? true : false;
        if (bool1) {
          if (!ThreadedFile.ExceptionInVPackage(".") && bV.AzInterfaceDelta()) {
            String str = "Elevate.exe";
            if ((new File(str)).exists()) {
              boolean bool2 = true;
              if (bool2) {
                ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.y, "true");
                ExceptionInVPackage.ExceptionInVPackage().BvInterfaceEcho();
                try {
                  if (T.ExceptionInVPackage().AzInterfaceCharlie() != null && T.ExceptionInVPackage().AzInterfaceCharlie().R())
                    T.ExceptionInVPackage().AzInterfaceCharlie().C().AzInterfaceCharlie(); 
                } catch (Exception exception) {}
                try {
                  Runtime.getRuntime().exec("Elevate.exe " + X.b(ExceptionInVPackage.b, " ", "") + ".exe");
                  Runtime.getRuntime().halt(0);
                } catch (IOException iOException) {
                  Logger.getLogger(BiInterfaceFoxtrot.class.getName()).log(Level.SEVERE, (String)null, iOException);
                } 
              } else {
                return false;
              } 
            } else {
              String str1 = ExceptionInVPackage.ExceptionInVPackage().b() + " does not currently have write access to the installation folder.\n\nUsing Auto Update with all Windows after XP requires \nAdministrator rights. Please start " + ExceptionInVPackage.ExceptionInVPackage().b() + "\nUsing Run As Administrator to complete Auto Update. \nWith Windows 7 the \"Run As Administrator\" Option can be found by \nPressing the Shift Key and right clicking on the icon you used to start " + ExceptionInVPackage.ExceptionInVPackage().b() + "\n\nAlternatively you can download the latest installer from:\nhttps://www.efiAnalytics.com/" + X.b(ExceptionInVPackage.b, " ", "") + "/\n\nWould you like to go to the download site now?";
              if (bV.ExceptionInVPackage(str1, this, true))
                aN.ExceptionInVPackage("https://www.efiAnalytics.com/" + ExceptionInVPackage.b + "/"); 
            } 
            return true;
          } 
          try {
            BiInterfaceFoxtrot.ExceptionInVPackage().BvInterfaceEcho(SComponentGolf.b("Initializing downloads") + "........");
            dt dt = new dt(this);
            ExceptionInVPackage.ExceptionInVPackage(dt);
            ExceptionInVPackage.ExceptionInVPackage(AzInterfaceDelta);
            bool = true;
          } catch (IOException iOException) {
            String str = "Auto update is unable to upgrade " + ExceptionInVPackage.ExceptionInVPackage().b() + "\nThis is usually due to ExceptionInVPackage lost connection to the internet or insufficient access \nto write to the installation directory.\n\nInternal Error:\n" + iOException.getMessage();
            bV.AzInterfaceDelta(str, this);
            iOException.printStackTrace();
          } 
        } else {
          return true;
        } 
      } else if (AzInterfaceDelta.ExceptionInVPackage() == 1) {
        bV.AzInterfaceDelta(AzInterfaceDelta.b(), this);
      } else if (AzInterfaceDelta.ExceptionInVPackage() == 8) {
        ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.cM, "true");
      } else if (AzInterfaceDelta.ExceptionInVPackage() == 4) {
        ExceptionInVPackage a1 = new ExceptionInVPackage();
        a1.ExceptionInVPackage("");
        ThreadedInAzPackage ThreadedInAzPackage = ThreadedInAzPackage.ExceptionInVPackage((AzInterfaceDelta)a1, SComponentGolf.AzInterfaceDelta());
        ThreadedInAzPackage.BiInterfaceFoxtrot();
        u();
      } 
      ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.aR, "" + (new Date()).getTime());
      ExceptionInVPackage.ExceptionInVPackage().BvInterfaceEcho();
    } else {
      System.out.println("No check, last update check=" + date1.toString());
    } 
    this.AzInterfaceCharlie = false;
    if (bool) {
      ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.y, "false");
      ExceptionInVPackage.ExceptionInVPackage().BvInterfaceEcho();
      RInterfaceIndia.SComponentGolf();
      BiInterfaceFoxtrot.ExceptionInVPackage().AzInterfaceDelta(this);
      Runtime.getRuntime().halt(0);
    } 
    return true;
  }
  
  private void w() {
    if (A.RInterfaceIndia().ExceptionInVPackage(ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.cF, "")))
      ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.cK, "true"); 
  }
  
  private boolean x() {
    String str = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.aP, "");
    if (!ExceptionInVPackage.ExceptionInVPackage.equals(str)) {
      ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.aP, ExceptionInVPackage.ExceptionInVPackage);
      try {
        RInterfaceIndia.AzInterfaceCharlie("version", ExceptionInVPackage.ExceptionInVPackage);
      } catch (Exception exception) {}
      return true;
    } 
    return false;
  }
  
  private void y() {
    try {
      String str1 = ExceptionInVPackage.ExceptionInVPackage().BiInterfaceHotel().getProperty(ExceptionInVPackage.aN, "");
      if (AzInterfaceCharlie(str1))
        return; 
      ExceptionInVPackage.ExceptionInVPackage().AzInterfaceDelta(ExceptionInVPackage.aN, "" + (long)(9.223372036854776E18D * Math.random()));
      String str2 = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.aO, "");
      if (str2.equals("")) {
        Date date = new Date();
        str2 = "" + date.getTime();
      } 
      ExceptionInVPackage.ExceptionInVPackage().AzInterfaceDelta(ExceptionInVPackage.aO, str2);
      ExceptionInVPackage.ExceptionInVPackage().RInterfaceIndia();
      ExceptionInVPackage.ExceptionInVPackage().BvInterfaceEcho(ExceptionInVPackage.aN);
      ExceptionInVPackage.ExceptionInVPackage().BvInterfaceEcho(ExceptionInVPackage.aO);
    } catch (Exception exception) {
      System.out.println("Failed to set uid");
      exception.printStackTrace();
    } 
  }
  
  private boolean AzInterfaceCharlie(String paramString) {
    try {
      long l = Long.parseLong(paramString);
      if (l == 0L)
        return false; 
    } catch (Exception exception) {
      return false;
    } 
    ArrayList<Character> arrayList = new ArrayList();
    Character character = null;
    byte b1 = 0;
    char[] arrayOfChar = paramString.toCharArray();
    int RInterfaceIndia = arrayOfChar.length;
    for (byte b2 = 0; b2 < RInterfaceIndia; b2++) {
      Character character1 = Character.valueOf(arrayOfChar[b2]);
      if (!arrayList.contains(character1))
        arrayList.add(character1); 
      if (character != null && character1.equals(character))
        b1++; 
      character = character1;
    } 
    return (!paramString.contains("234") && !paramString.contains("678") && arrayList.size() >= 4 && b1 < 4);
  }
  
  public void m() {
    bV.AzInterfaceDelta("No Updates Available, " + ExceptionInVPackage.ExceptionInVPackage + " is the latest version.", this);
  }
  
  private void z() {
    ExceptionInVPackage.ExceptionInVPackage().BvInterfaceEcho(ExceptionInVPackage.aS);
    ExceptionInVPackage.ExceptionInVPackage().BvInterfaceEcho(ExceptionInVPackage.cL);
    try {
      iP.ExceptionInVPackage().b();
    } catch (Exception exception) {
      D.b("Failed to clear start screen dir.");
      Logger.getLogger(dl.class.getName()).log(Level.SEVERE, (String)null, exception);
    } 
    if (ExceptionInVPackage.ExceptionInVPackage.equals("2.7.09")) {
      for (byte b1 = 0; b1 < 4; b1++) {
        String[] arrayOfString = ExceptionInVPackage.ExceptionInVPackage().BiInterfaceFoxtrot("graph" + b1);
        for (byte b2 = 0; b2 < arrayOfString.length; b2++)
          ExceptionInVPackage.ExceptionInVPackage().BvInterfaceEcho(arrayOfString[b2]); 
      } 
      ExceptionInVPackage.ExceptionInVPackage().b("selectionTable2Multiview_Fuel_Table1_checked3D", "true");
    } 
    File file = new File("OSX_fixperm-217-leo.sh");
    if (file.exists())
      file.delete(); 
  }
  
  private void A() {
    String[] arrayOfString = (new File(".")).list();
    for (byte b1 = 0; b1 < arrayOfString.length; b1++) {
      if (arrayOfString[b1].toLowerCase().endsWith(".zip")) {
        File file = new File(arrayOfString[b1]);
        try {
          hq.ExceptionInVPackage().ExceptionInVPackage("Updating Files in " + X.b(arrayOfString[b1], ".zip", ""));
          if (ae.ExceptionInVPackage(arrayOfString[b1], X.b(arrayOfString[b1], ".zip", ""), null).equals(ae.ExceptionInVPackage))
            (new File(arrayOfString[b1])).delete(); 
        } catch (ZipException zipException) {
          zipException.printStackTrace();
        } catch (IOException iOException) {
          iOException.printStackTrace();
        } 
      } 
    } 
  }
  
  public boolean n() {
    D.AzInterfaceDelta("closeApp Called");
    long l = System.currentTimeMillis() + 30000L;
    if (this.AzInterfaceCharlie) {
      setVisible(false);
      System.out.println("Update In Progress, delaying app shut down.");
      while (this.AzInterfaceCharlie && System.currentTimeMillis() < l) {
        try {
          Thread.currentThread();
          Thread.sleep(200L);
        } catch (Exception exception) {}
      } 
      D.AzInterfaceDelta("Delay Close released.");
    } 
    return !!BiInterfaceFoxtrot.ExceptionInVPackage().SComponentGolf();
  }
  
  public void ThreadedInAzPackage() {
    if (getExtendedState() == 6)
      return; 
    Insets insets = getInsets();
    ExceptionInVPackage.ExceptionInVPackage().b("x", "" + getX());
    ExceptionInVPackage.ExceptionInVPackage().b("y", "" + getY());
    ExceptionInVPackage.ExceptionInVPackage().b("width", "" + getWidth());
    ExceptionInVPackage.ExceptionInVPackage().b("height", "" + getHeight());
  }
  
  public void windowActivated(WindowEvent paramWindowEvent) {
    boolean bool = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.aa, ExceptionInVPackage.ManagerUsingFile);
    if (bool && !dI.ExceptionInVPackage().AzInterfaceDelta())
      dI.ExceptionInVPackage().b(); 
  }
  
  public void windowClosed(WindowEvent paramWindowEvent) {}
  
  public void windowClosing(WindowEvent paramWindowEvent) {
    du du = new du(this);
    du.start();
    BiInterfaceFoxtrot.ExceptionInVPackage().y();
    ExceptionInVPackage.ExceptionInVPackage().ExceptionInVPackage(true);
    System.exit(0);
  }
  
  public void windowDeactivated(WindowEvent paramWindowEvent) {
    boolean bool = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.aa, ExceptionInVPackage.ManagerUsingFile);
    if (!bool && dI.ExceptionInVPackage().AzInterfaceDelta())
      dI.ExceptionInVPackage().AzInterfaceCharlie(); 
  }
  
  public void windowDeiconified(WindowEvent paramWindowEvent) {}
  
  public void windowIconified(WindowEvent paramWindowEvent) {}
  
  public void windowOpened(WindowEvent paramWindowEvent) {}
  
  public void processEvent(AWTEvent paramAWTEvent) {
    if ((paramAWTEvent.getID() == 101 || paramAWTEvent.getID() == 100) && !J.b()) {
      ThreadedInAzPackage();
      if (isAlwaysOnTop())
        setAlwaysOnTop(false); 
    } 
    if (paramAWTEvent.getID() == 201 && J.b()) {
      ThreadedInAzPackage();
      if (isAlwaysOnTop())
        setAlwaysOnTop(false); 
    } else if (paramAWTEvent.getID() == 209) {
      if (getExtendedState() == 6) {
        ExceptionInVPackage.ExceptionInVPackage().b("mainWindowMaximized", "true");
        ExceptionInVPackage();
      } else {
        ExceptionInVPackage.ExceptionInVPackage().b("mainWindowMaximized", "false");
        ExceptionInVPackage();
      } 
    } else if (paramAWTEvent.getID() == 200 && isAlwaysOnTop()) {
      setAlwaysOnTop(false);
    } 
    super.processEvent(paramAWTEvent);
  }
  
  public void ExceptionInVPackage() {
    (new dw(this)).start();
  }
  
  public void p() {
    EventQueue.invokeLater(new dv(this));
  }
  
  private void B() {
    if (!isVisible())
      setVisible(true); 
    int RInterfaceIndia = getExtendedState();
    RInterfaceIndia &= 0xFFFFFFFE;
    if (bV.AzInterfaceDelta()) {
      setExtendedState(RInterfaceIndia);
      setAlwaysOnTop(true);
      toFront();
      requestFocus();
      setAlwaysOnTop(false);
    } else {
      setVisible(false);
      setVisible(true);
      setExtendedState(RInterfaceIndia);
    } 
  }
  
  public void setTitle(String paramString) {
    String str1 = ExceptionInVPackage.AzInterfaceCharlie;
    if (!this.BiInterfaceHotel && b)
      if (str1.contains(RInterfaceIndia.b)) {
        str1 = RInterfaceIndia.b;
      } else {
        str1 = X.b(str1, RInterfaceIndia.AzInterfaceCharlie, "");
      }  
    String str2 = ExceptionInVPackage.b + " " + str1 + " v" + ExceptionInVPackage.ExceptionInVPackage + " - ";
    if (paramString != null) {
      paramString = X.b(paramString, str2, "");
      paramString = paramString.trim();
    } else {
      paramString = "";
    } 
    if (!this.BiInterfaceHotel) {
      paramString = paramString + " EFI Simplified ";
    } else {
      String str3 = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.cC, "Invalid");
      String str4 = ExceptionInVPackage.ExceptionInVPackage().AzInterfaceCharlie(ExceptionInVPackage.cD, "Registration");
      paramString = paramString + " " + SComponentGolf.b("Registered to:") + " " + str3 + " " + str4;
    } 
    super.setTitle(str2 + paramString);
  }
  
  public void ExceptionInVPackage(R paramR) {
    String str = "";
    if (str != null && !str.equals("")) {
      setTitle(paramR.AzInterfaceCharlie() + " (" + str + ")");
    } else if (b) {
      setTitle(paramR.AzInterfaceCharlie() + " (offline)");
    } else {
      String str1 = paramR.Z();
      if (str1 == null || str1.isEmpty()) {
        setTitle(paramR.AzInterfaceCharlie() + " ( " + SComponentGolf.b("Go Online for Firmware Version") + " )");
      } else {
        setTitle(paramR.AzInterfaceCharlie() + " ( " + str1 + " )");
      } 
    } 
  }
  
  public void b(R paramR) {
    paramR.C().b(this);
  }
  
  public void AzInterfaceCharlie(R paramR) {
    paramR.C().ExceptionInVPackage(this);
  }
  
  public boolean ExceptionInVPackage(String paramString, AeInterfaceMikeTostring parambT) {
    if (ExceptionInVPackage.b.equals(ExceptionInVPackage.as)) {
      setTitle(paramString + " ( Firmware Version: " + parambT.b() + ", Serial #" + parambT.AzInterfaceCharlie() + " )");
    } else if (parambT.b().equals(ExceptionInVPackage.A().E().RInterfaceIndia())) {
      setTitle(paramString + " (" + parambT.AzInterfaceCharlie() + ")");
      if (parambT.AzInterfaceCharlie() != null) {
        ExceptionInVPackage.A().setProperty("firmwareDescription", parambT.AzInterfaceCharlie());
      } else {
        ExceptionInVPackage.A().setProperty("firmwareDescription", "");
      } 
      ExceptionInVPackage.ExceptionInVPackage().b(ExceptionInVPackage.cO, parambT.b());
    } 
    return true;
  }
  
  public void ExceptionInVPackage(String paramString) {}
  
  public boolean b() {
    return n();
  }
  
  public String q() {
    String str = "";
    if (str == null || str.equals(""))
      try {
        str = "file://" + (new File(".")).getCanonicalPath() + "/help/learnMore.html";
      } catch (Exception exception) {
        bV.AzInterfaceDelta("While online go to\n" + ExceptionInVPackage.BiInterfaceHotel, this);
      }  
    return str;
  }
  
  public void r() {
    dS dS = new dS(this, new dy(this));
    bV.ExceptionInVPackage(this, (Component)dS);
    dS.setVisible(true);
  }
}


/* Location:              /home/rewrich/Downloads/TunerStudioMS/TunerStudioMS/!/aP/dl.class
 * Java compiler version: 8 (52.0)
 * JD-Core Version:       1.1.3
 */