tustu/app/aP/NetworkHashMap.java

package aP;

import A.Exception;
import PComponentBravo.BInterfaceBravo;
import PComponentBravo.i;
import PComponentBravo.NetworkInBPackage;
import PComponentBravo.Exception;
import AcInterfaceDelta.NInterfaceAlpha;
import AcInterfaceDelta.DInterfaceCharlie;
import G.R;
import G.T;
import G.Y;
import G.ManagerUsingConcurrentHashMap;
import G.SerializableImplUsingArrayList;
import G.GInterfaceAb;
import G.GComponentAj;
import G.EqualsInGPackage;
import G.ExceptionprintstacktraceInGPackage;
import G.ArrayListExceptionprintstacktraceInGPackage;
import G.GInterfaceCq;
import G.GComponentCb;
import G.GComponentCj;
import G.GComponentCq;
import G.ManagerUsingArrayList;
import G.GComponentCx;
import G.GInterfaceDb;
import G.i;
import G.SInterfaceLima;
import G.NetworkInBPackage;
import G.Isoptimizeddrawingenabled;
import G.BsInterfaceRomeo;
import G.Exception;
import JDialogExtensionInBdPackage.ThreadedInIPackage;
import UICloseInPPackage.Abstract;
import K.BInterfaceBravo;
import K.KInterfaceEcho;
import L.SInterfaceLima;
import N.NInterfaceAlpha;
import Q.NInterfaceAlpha;
import S.BInterfaceBravo;
import S.SInterfaceJuliet;
import S.SInterfaceLima;
import U.BInterfaceBravo;
import V.NInterfaceAlpha;
import V.KInterfaceEcho;
import V.ExceptionPrintstacktrace;
import W.A;
import W.PComponentBravo;
import W.UIInBePackage;
import W.AcInterfaceDelta;
import W.JDialogExtensionInBdPackage;
import W.O;
import W.P;
import W.U;
import W.WInterfaceAa;
import W.NetworkExceptionprintstacktrace;
import W.IOExceptioninvpackage;
import W.GComponentAj;
import W.IOInWPackage;
import W.WInterfaceAp;
import W.Properties;
import W.IOExceptioninvpackageInWPackage;
import W.Isoptimizeddrawingenabled;
import W.BsInterfaceOscar;
import W.v;
import W.PInterfaceZulu;
import Y.NInterfaceAlpha;
import Y.DInterfaceCharlie;
import WInterfaceAa.NInterfaceAlpha;
import WInterfaceAa.Abstract;
import aE.NInterfaceAlpha;
import aE.KInterfaceEcho;
import aL.NInterfaceAlpha;
import aM.NInterfaceAlpha;
import aN.NInterfaceAlpha;
import aN.KInterfaceEcho;
import aV.NInterfaceAlpha;
import aV.ExceptionPrintstacktrace;
import aV.AvInterfaceXray;
import aY.NInterfaceAlpha;
import aY.SInterfaceJuliet;
import aY.SInterfaceLima;
import aY.Exception;
import aZ.KInterfaceEcho;
import NetworkExceptionprintstacktrace.NInterfaceAlpha;
import NetworkExceptionprintstacktrace.KInterfaceEcho;
import ac.AcInterfaceDelta;
import ac.NInterfaceAlpha;
import ac.BInterfaceBravo;
import ac.DInterfaceCharlie;
import ac.Abstract;
import ac.AcInterfaceUniform;
import ac.AcInterfaceYankee;
import ai.BInterfaceBravo;
import ai.AiInterfaceDelta;
import ao.hx;
import bD.JDialogExtensionInBdPackage;
import BtInterfaceBh.AcInterfaceDelta;
import BtInterfaceBh.F;
import BtInterfaceBh.UICloseInPPackage;
import BtInterfaceBh.M;
import BtInterfaceBh.X;
import BtInterfaceBh.BInterfaceBravo;
import BtInterfaceBh.Isoptimizeddrawingenabled;
import BtInterfaceBh.t;
import ManagerBfcomponentcharlie.SInterfaceLima;
import bS.BsInterfaceOscar;
import bS.BsInterfaceRomeo;
import ba.NInterfaceAlpha;
import bd.NInterfaceAlpha;
import be.UIInBePackage;
import be.NInterfaceAlpha;
import bg.NInterfaceAlpha;
import bl.Abstract;
import bl.SInterfaceLima;
import bn.NInterfaceAlpha;
import bn.DInterfaceCharlie;
import bn.KInterfaceEcho;
import bt.BtInterfaceBh;
import bt.ManagerBfcomponentcharlie;
import bw.NInterfaceAlpha;
import DInterfaceCharlie.NInterfaceAlpha;
import com.efiAnalytics.apps.ts.dashboard.T;
import com.efiAnalytics.apps.ts.dashboard.Z;
import com.efiAnalytics.apps.ts.dashboard.NetworkExceptionprintstacktrace;
import com.efiAnalytics.apps.ts.dashboard.GInterfaceAb;
import com.efiAnalytics.apps.ts.dashboard.Exception;
import com.efiAnalytics.apps.ts.dashboard.AvInterfaceXray;
import com.efiAnalytics.plugin.ApplicationPlugin;
import com.efiAnalytics.tunerStudio.panels.F;
import com.efiAnalytics.tunerStudio.panels.UICloseInPPackage;
import com.efiAnalytics.tunerStudio.panels.ExceptionPrintstacktrace;
import com.efiAnalytics.tuningwidgets.panels.W;
import com.efiAnalytics.tuningwidgets.panels.X;
import com.efiAnalytics.tuningwidgets.panels.ac;
import com.efiAnalytics.tuningwidgets.panels.ExceptionPrintstacktrace;
import com.efiAnalytics.ui.aN;
import com.efiAnalytics.ui.bV;
import com.efiAnalytics.ui.bc;
import com.efiAnalytics.ui.ck;
import com.efiAnalytics.ui.GComponentCq;
import com.efiAnalytics.ui.dF;
import com.efiAnalytics.ui.dM;
import com.efiAnalytics.ui.dO;
import com.efiAnalytics.ui.dQ;
import com.efiAnalytics.ui.eJ;
import com.efiAnalytics.ui.et;
import Abstract.i;
import i.DInterfaceCharlie;
import java.awt.Color;
import java.awt.Component;
import java.awt.Cursor;
import java.awt.Desktop;
import java.awt.Dialog;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Frame;
import java.awt.Image;
import java.awt.Insets;
import java.awt.KeyEventDispatcher;
import java.awt.KeyboardFocusManager;
import java.awt.Rectangle;
import java.awt.Toolkit;
import java.awt.Window;
import java.io.File;
import java.io.FileFilter;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.net.MalformedURLException;
import java.net.URISyntaxException;
import java.net.URL;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.ImageIcon;
import javax.swing.JDialog;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JRootPane;
import javax.swing.SwingUtilities;
import javax.swing.UIDefaults;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;
import Isoptimizeddrawingenabled.Isoptimizeddrawingenabled;
import Isoptimizeddrawingenabled.BsInterfaceOscar;
import p.PComponentBravo;
import p.UICloseInPPackage;
import p.NInterfaceAlpha;
import p.AvInterfaceXray;
import p.PInterfaceZulu;
import BsInterfaceRomeo.NInterfaceAlpha;
import BsInterfaceRomeo.i;
import BsInterfaceRomeo.SInterfaceJuliet;
import BsInterfaceRomeo.Isoptimizeddrawingenabled;
import Exception.ExceptionPrintstacktrace;
import v.DInterfaceCharlie;
import PInterfaceZulu.KInterfaceEcho;
import PInterfaceZulu.NetworkInBPackage;

public class NetworkHashMap {
  private static f DInterfaceCharlie = null;
  
  private List AiInterfaceDelta = Collections.synchronizedList(new ArrayList());
  
  private List KInterfaceEcho = Collections.synchronizedList(new ArrayList());
  
  private HashMap f = new HashMap<>();
  
  private HashMap ExceptionPrintstacktrace = new HashMap<>();
  
  private int Abstract = 0;
  
  List NInterfaceAlpha = new ArrayList();
  
  private boolean i = false;
  
  private Runnable SInterfaceJuliet = new ExceptionPrintstacktrace(this);
  
  boolean BInterfaceBravo = false;
  
  private HashMap ThreadedInIPackage = new HashMap<>();
  
  public static f NInterfaceAlpha() {
    if (DInterfaceCharlie == null)
      DInterfaceCharlie = new f(); 
    return DInterfaceCharlie;
  }
  
  private void f(R paramR) {
    for (jK jK : this.NInterfaceAlpha)
      jK.NInterfaceAlpha(paramR); 
  }
  
  private void ExceptionPrintstacktrace(R paramR) {
    for (jK jK : this.NInterfaceAlpha)
      jK.BInterfaceBravo(paramR); 
  }
  
  private void Abstract(R paramR) {
    for (jK jK : this.NInterfaceAlpha)
      jK.DInterfaceCharlie(paramR); 
  }
  
  private void i(R paramR) {
    for (jK jK : this.NInterfaceAlpha)
      jK.AiInterfaceDelta(paramR); 
  }
  
  public void NInterfaceAlpha(KInterfaceEcho parame) {
    this.KInterfaceEcho.add(parame);
  }
  
  public void BInterfaceBravo(KInterfaceEcho parame) {
    this.KInterfaceEcho.remove(parame);
  }
  
  private void U() {
    R BsInterfaceRomeo = T.NInterfaceAlpha().DInterfaceCharlie();
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    for (KInterfaceEcho KInterfaceEcho : this.KInterfaceEcho)
      KInterfaceEcho.NInterfaceAlpha(NInterfaceAlpha, BsInterfaceRomeo); 
  }
  
  private void V() {
    Iterator<KInterfaceEcho> iterator = this.KInterfaceEcho.iterator();
    while (iterator.hasNext())
      ((KInterfaceEcho)iterator.next()).e_(); 
    GComponentCb.NInterfaceAlpha().BInterfaceBravo();
  }
  
  private void NInterfaceAlpha(NInterfaceAlpha parama) {
    Iterator<KInterfaceEcho> iterator = this.KInterfaceEcho.iterator();
    while (iterator.hasNext())
      ((KInterfaceEcho)iterator.next()).NInterfaceAlpha(parama); 
  }
  
  public void NInterfaceAlpha(Window paramWindow) {
    if (T.NInterfaceAlpha().DInterfaceCharlie() != null) {
      R BsInterfaceRomeo = T.NInterfaceAlpha().DInterfaceCharlie();
      if (BsInterfaceRomeo.O().al().equals("XCP")) {
        aV aV = new aV(paramWindow);
      } else {
        AcInterfaceDelta.DInterfaceCharlie("Loaded Configuration loaded not using XCP.");
      } 
    } else {
      AcInterfaceDelta.DInterfaceCharlie("No Configurations loaded to show DAQ Report on.");
    } 
  }
  
  public void BInterfaceBravo(Window paramWindow) {
    Isoptimizeddrawingenabled Isoptimizeddrawingenabled = dd.NInterfaceAlpha().NetworkInBPackage();
    if (Isoptimizeddrawingenabled == null || !Isoptimizeddrawingenabled.getTitleAt(Isoptimizeddrawingenabled.getSelectedIndex()).equals(hb.BsInterfaceRomeo))
      (new hC(paramWindow)).NInterfaceAlpha(); 
  }
  
  public com.efiAnalytics.tunerStudio.search.f NInterfaceAlpha(com.efiAnalytics.tunerStudio.search.f paramf) {
    boolean bool = paramf.BInterfaceBravo().equals(BsInterfaceOscar.NInterfaceAlpha);
    NInterfaceAlpha NInterfaceAlpha = new NInterfaceAlpha(paramf.BInterfaceBravo(), paramf.NInterfaceAlpha(), ExceptionPrintstacktrace.AiInterfaceDelta());
    if (bool) {
      if (paramf.ExceptionPrintstacktrace() != null && paramf.ExceptionPrintstacktrace().DInterfaceCharlie().equals("A"))
        return paramf; 
      if (paramf.ExceptionPrintstacktrace() != null)
        paramf.NInterfaceAlpha(new NInterfaceAlpha()); 
      paramf.ExceptionPrintstacktrace().AiInterfaceDelta(NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.cE, ""));
      paramf.ExceptionPrintstacktrace().KInterfaceEcho(NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.cC, ""));
      paramf.ExceptionPrintstacktrace().f(NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.cD, ""));
      paramf.ExceptionPrintstacktrace().BInterfaceBravo(paramf.NInterfaceAlpha());
      paramf.ExceptionPrintstacktrace().DInterfaceCharlie("A");
    } else {
      if (paramf.ExceptionPrintstacktrace() != null && paramf.ExceptionPrintstacktrace().DInterfaceCharlie().equals("A"))
        NInterfaceAlpha.NInterfaceAlpha(paramf.ExceptionPrintstacktrace()); 
      JDialog jDialog = NInterfaceAlpha.NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie());
      jDialog.setVisible(true);
      NInterfaceAlpha a1 = NInterfaceAlpha.NInterfaceAlpha();
      paramf.NInterfaceAlpha(a1);
    } 
    return paramf;
  }
  
  public void NInterfaceAlpha(i parami, boolean paramBoolean) {
    com.efiAnalytics.tunerStudio.search.f f1 = new com.efiAnalytics.tunerStudio.search.f();
    f1.NInterfaceAlpha(parami);
    DInterfaceCharlie DInterfaceCharlie = Abstract.NInterfaceAlpha().DInterfaceCharlie(f1.BInterfaceBravo(), f1.NInterfaceAlpha());
    if (DInterfaceCharlie.NInterfaceAlpha() == 8) {
      bV.AiInterfaceDelta("This Device has been disabled, please Contact support for more information.", dd.NInterfaceAlpha().DInterfaceCharlie());
      return;
    } 
    f1.NInterfaceAlpha(DInterfaceCharlie.BInterfaceBravo());
    byte BInterfaceBravo = 0;
    while (!f1.ExceptionPrintstacktrace().DInterfaceCharlie().equals("A")) {
      f1 = NInterfaceAlpha(f1);
      if (BInterfaceBravo > 3)
        return; 
    } 
    NInterfaceAlpha(f1, paramBoolean);
  }
  
  public void BInterfaceBravo(com.efiAnalytics.tunerStudio.search.f paramf) {}
  
  public void NInterfaceAlpha(com.efiAnalytics.tunerStudio.search.f paramf, boolean paramBoolean) {
    if (paramf.BInterfaceBravo().equals(BsInterfaceOscar.NInterfaceAlpha)) {
      BInterfaceBravo(paramf);
      return;
    } 
    byte BInterfaceBravo = 0;
    while (!paramf.ExceptionPrintstacktrace().DInterfaceCharlie().equals("A")) {
      paramf = NInterfaceAlpha(paramf);
      if (BInterfaceBravo > 3)
        return; 
    } 
    File file = null;
    String str = NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.U + paramf.NInterfaceAlpha(), "");
    if (paramf.Abstract() != null && paramf.Abstract().BInterfaceBravo() != null && paramf.Abstract().BInterfaceBravo().exists()) {
      file = paramf.Abstract().BInterfaceBravo();
    } else if (str != null && !str.isEmpty()) {
      file = new File(str);
    } 
    JFrame jFrame = dd.NInterfaceAlpha().DInterfaceCharlie();
    i i = SInterfaceJuliet.AiInterfaceDelta(file);
    if (i != null && i.KInterfaceEcho() != null && !i.KInterfaceEcho().isEmpty() && !i.KInterfaceEcho().equals(paramf.NInterfaceAlpha())) {
      AcInterfaceDelta.AiInterfaceDelta("Wrong Project for serial #" + paramf.NInterfaceAlpha());
      file = null;
    } 
    if (file == null || !file.exists()) {
      List<File> list = SInterfaceJuliet.BInterfaceBravo(paramf.NInterfaceAlpha());
      if (list.size() == 1) {
        file = list.get(0);
      } else if (list.size() > 1) {
        String str1 = "Multiple projects for this serial number found, using: " + ((File)list.get(0)).getName() + "\nIf you wish to use NInterfaceAlpha different project, select:\nFile --> Vehicle Projects --> Open Project";
        bV.AiInterfaceDelta(str1, null);
        file = list.get(0);
      } else {
        file = NInterfaceAlpha(paramf, jFrame);
        if (file == null)
          return; 
      } 
    } 
    NInterfaceAlpha.NInterfaceAlpha().BInterfaceBravo(NInterfaceAlpha.U + paramf.NInterfaceAlpha(), file.getAbsolutePath());
    H Abstract = new H(this, jFrame, file.getAbsolutePath());
    Abstract.NInterfaceAlpha(paramBoolean);
    Abstract.start();
  }
  
  public File NInterfaceAlpha(com.efiAnalytics.tunerStudio.search.f paramf, Window paramWindow) {
    File file = null;
    BInterfaceBravo.DInterfaceCharlie().NInterfaceAlpha(paramf.f());
    String str = paramf.AiInterfaceDelta();
    try {
      File file1 = SInterfaceJuliet.NInterfaceAlpha(paramWindow, str);
      if (file1 == null || !file1.exists())
        return null; 
      String str1 = PInterfaceZulu.NInterfaceAlpha(file1);
      if (str1 != null && !str1.isEmpty())
        str = str1; 
      ie ie = new ie();
      String str2 = "";
      if (paramf.ExceptionPrintstacktrace() != null && paramf.ExceptionPrintstacktrace().KInterfaceEcho() != null && !paramf.ExceptionPrintstacktrace().KInterfaceEcho().isEmpty() && paramf.ExceptionPrintstacktrace().f() != null && !paramf.ExceptionPrintstacktrace().f().isEmpty()) {
        str2 = paramf.ExceptionPrintstacktrace().KInterfaceEcho() + " " + paramf.ExceptionPrintstacktrace().f();
        if (paramf.f().KInterfaceEcho() != null && !paramf.f().KInterfaceEcho().isEmpty()) {
          str2 = str2 + " Serial " + paramf.f().KInterfaceEcho();
        } else {
          str2 = str2 + " Car";
        } 
      } 
      File file2 = new File(SInterfaceJuliet.AcInterfaceUniform(), str2);
      boolean bool = (file2.exists() || !t.NInterfaceAlpha(str)) ? true : false;
      if (bool) {
        boolean bool1 = false;
        do {
          str2 = bV.NInterfaceAlpha(paramWindow, false, ExceptionPrintstacktrace.BInterfaceBravo("A new project will be created for this " + NInterfaceAlpha.NInterfaceAlpha(str, NInterfaceAlpha.f)) + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("This will help keep logs and calibration files related to this device organized.") + ".\Isoptimizeddrawingenabled\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("What would you like to name this project?"), str2);
          if (str2 == null || str2.equals("")) {
            bool1 = false;
          } else {
            file2 = new File(SInterfaceJuliet.AcInterfaceUniform(), str2);
            if (file2.exists()) {
              boolean bool2 = bV.NInterfaceAlpha(ExceptionPrintstacktrace.BInterfaceBravo("There is already NInterfaceAlpha project by that name.") + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Overwrite?"), paramWindow, true);
              if (!bool2) {
                str2 = null;
                bool1 = true;
              } else {
                t.BInterfaceBravo(file2);
                bool1 = false;
              } 
            } 
          } 
        } while (bool1 || (str2 != null && !str2.equals("") && !t.NInterfaceAlpha(str2)));
      } 
      if (str2 == null || str2.equals(""))
        return null; 
      NInterfaceAlpha NInterfaceAlpha = ie.NInterfaceAlpha(str2, str, file1, null);
      file = new File(NInterfaceAlpha.t());
      if (paramf.f() != null && paramf.f().KInterfaceEcho() != null && !paramf.f().KInterfaceEcho().isEmpty())
        SInterfaceJuliet.NInterfaceAlpha(file, paramf.f()); 
      if (!file.exists()) {
        bV.AiInterfaceDelta("Project Directory not found?", paramWindow);
        return null;
      } 
      NInterfaceAlpha.NInterfaceAlpha(NInterfaceAlpha);
      ExceptionPrintstacktrace();
    } catch (NInterfaceAlpha NInterfaceAlpha) {
      bV.AiInterfaceDelta(NInterfaceAlpha.getMessage(), dd.NInterfaceAlpha().DInterfaceCharlie());
      return null;
    } 
    if (i.NInterfaceAlpha().NInterfaceAlpha("645fds64[=43098=32fsa  ")) {
      String str1 = SInterfaceJuliet.AcInterfaceUniform();
      for (String str2 : SInterfaceJuliet.v()) {
        File file1 = new File(str1, str2);
        if (file1.exists())
          t.BInterfaceBravo(file1); 
      } 
    } 
    return file;
  }
  
  public void DInterfaceCharlie(Window paramWindow) {
    String str = bV.BInterfaceBravo(SInterfaceJuliet.AcInterfaceUniform(), paramWindow);
    if (str == null || str.equals(""))
      return; 
    NInterfaceAlpha(paramWindow, str);
  }
  
  public void NInterfaceAlpha(Window paramWindow, String paramString) {
    File file = new File(paramString);
    if (!file.exists()) {
      bV.AiInterfaceDelta("A valid Project was not found at:\Isoptimizeddrawingenabled" + paramString, paramWindow);
      return;
    } 
    (new H(this, paramWindow, paramString)).start();
  }
  
  public void BInterfaceBravo() {
    NInterfaceAlpha((M)null);
  }
  
  public String NInterfaceAlpha(M paramM) {
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    if (NInterfaceAlpha == null) {
      bV.AiInterfaceDelta("There is no project open to archive", dd.NInterfaceAlpha().DInterfaceCharlie());
      return null;
    } 
    File file = new File(NInterfaceAlpha.t());
    String[] arrayOfString = { NInterfaceAlpha.t };
    String str1 = NInterfaceAlpha.NInterfaceAlpha().NInterfaceAlpha(NInterfaceAlpha.AcInterfaceUniform, SInterfaceJuliet.AcInterfaceUniform());
    String str2 = NInterfaceAlpha.AcInterfaceUniform() + "_" + X.NInterfaceAlpha() + "." + NInterfaceAlpha.t;
    X AvInterfaceXray = new X();
    String str3 = bV.NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie(), ExceptionPrintstacktrace.BInterfaceBravo("Archive Project"), arrayOfString, str2, str1, false, (ck)AvInterfaceXray);
    if (str3 != null && !str3.equals("")) {
      if (!str3.endsWith(arrayOfString[0]))
        str3 = str3 + "." + arrayOfString[0]; 
      FileFilter fileFilter = AvInterfaceXray.DInterfaceCharlie();
      File file1 = new File(str3);
      if (paramM == null)
        paramM = new t(this); 
      AcInterfaceDelta AiInterfaceDelta = new AcInterfaceDelta(this, file, file1, fileFilter, paramM);
      AiInterfaceDelta.start();
    } 
    return str3;
  }
  
  public void DInterfaceCharlie() {
    String[] arrayOfString = { NInterfaceAlpha.t };
    String str1 = NInterfaceAlpha.NInterfaceAlpha().NInterfaceAlpha(NInterfaceAlpha.AcInterfaceUniform, SInterfaceJuliet.AcInterfaceUniform());
    String str2 = "*." + NInterfaceAlpha.t;
    String str3 = bV.NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie(), ExceptionPrintstacktrace.BInterfaceBravo("Import Archive Project"), arrayOfString, str2, str1, false, null);
    NInterfaceAlpha(str3);
  }
  
  public void NInterfaceAlpha(String paramString) {
    if (i.NInterfaceAlpha().NInterfaceAlpha("09RGDKDG;LKIGD") && paramString != null && !paramString.equals("")) {
      File file = new File(paramString);
      String str = null;
      boolean bool = false;
      do {
        str = bV.NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie(), false, ExceptionPrintstacktrace.BInterfaceBravo("Import Project as (Project Name):"), X.BInterfaceBravo(file.getName(), "." + NInterfaceAlpha.t, ""));
        if (str == null || str.equals("")) {
          bool = false;
        } else {
          File file1 = new File(SInterfaceJuliet.AcInterfaceUniform(), str);
          if (file1.exists()) {
            boolean bool1 = bV.NInterfaceAlpha(ExceptionPrintstacktrace.BInterfaceBravo("There is already NInterfaceAlpha project by that name.") + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Overwrite?"), dd.NInterfaceAlpha().DInterfaceCharlie(), true);
            if (!bool1) {
              str = null;
              bool = true;
            } else {
              bool = false;
            } 
          } 
        } 
      } while (bool || (str != null && !str.equals("") && !t.NInterfaceAlpha(str)));
      if (str != null && !str.equals("")) {
        w w = new w(this);
        UICloseInPPackage SInterfaceJuliet = new UICloseInPPackage(this, file, str, w);
        SInterfaceJuliet.start();
      } 
    } 
  }
  
  public void AiInterfaceDelta() {
    JFrame jFrame = dd.NInterfaceAlpha().DInterfaceCharlie();
    R BsInterfaceRomeo = T.NInterfaceAlpha().DInterfaceCharlie();
    if (BsInterfaceRomeo == null) {
      bV.AiInterfaceDelta("There must be NInterfaceAlpha Controller Configuration loaded to use the Expression Evaluator.", jFrame);
      return;
    } 
    SInterfaceLima SInterfaceLima = new SInterfaceLima(jFrame, BsInterfaceRomeo);
    bV.NInterfaceAlpha(jFrame, (Component)SInterfaceLima);
    SInterfaceLima.setVisible(true);
  }
  
  private synchronized void NInterfaceAlpha(Window paramWindow, String paramString, boolean paramBoolean) {
    boolean bool;
    if (!i.NInterfaceAlpha().NInterfaceAlpha("09fewlkm309glkfds09"))
      return; 
    dM dM = dd.NInterfaceAlpha().AiInterfaceDelta();
    if (dd.NInterfaceAlpha().NetworkInBPackage().getSelectedIndex() == 0) {
      bool = false;
    } else {
      KInterfaceEcho(ExceptionPrintstacktrace.BInterfaceBravo("Loading Project"));
      bool = true;
    } 
    AvInterfaceXray AvInterfaceXray = dd.NInterfaceAlpha().BInterfaceBravo();
    hq.NInterfaceAlpha().NInterfaceAlpha(ExceptionPrintstacktrace.BInterfaceBravo("Opening Project") + " ...");
    AvInterfaceXray.ThreadedInIPackage(ExceptionPrintstacktrace.BInterfaceBravo("Loading Project"));
    AvInterfaceXray.repaint();
    Thread.yield();
    GComponentCq.NInterfaceAlpha().AiInterfaceDelta();
    if (bool)
      NInterfaceAlpha(0.1D); 
    dM.BInterfaceBravo(0.1D);
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.NInterfaceAlpha();
    if (NInterfaceAlpha.A() != null)
      ExceptionPrintstacktrace(); 
    AcInterfaceDelta.DInterfaceCharlie("Opening project: " + paramString);
    long SInterfaceLima = System.currentTimeMillis();
    if (paramString == null || paramString.equals(""))
      return; 
    String str = (new File(paramString)).getParent();
    NInterfaceAlpha.BInterfaceBravo(NInterfaceAlpha.aV, str);
    NInterfaceAlpha.DInterfaceCharlie(SInterfaceJuliet.q());
    AcInterfaceDelta.DInterfaceCharlie();
    if (bool)
      NInterfaceAlpha(0.15D); 
    dM.BInterfaceBravo(0.15D);
    NInterfaceAlpha a1 = new NInterfaceAlpha();
    a1.Abstract(paramString);
    File file = new File(paramString);
    a1.i(file.getName());
    try {
      a1.NInterfaceAlpha(paramString);
      if (i.NInterfaceAlpha().NInterfaceAlpha("FDSDSA-0;L;l0")) {
        BInterfaceBravo.NInterfaceAlpha().NInterfaceAlpha((WInterfaceAp)new Properties((Properties)a1, "Triggers."));
        bB.NInterfaceAlpha().BInterfaceBravo();
      } 
      a1 = (new ie()).NInterfaceAlpha(paramString);
      if (i.NInterfaceAlpha().NInterfaceAlpha("FDSDSA-0;L;l0"))
        BInterfaceBravo.NInterfaceAlpha().NInterfaceAlpha((WInterfaceAp)new Properties((Properties)a1, "Triggers.")); 
      if (bool)
        NInterfaceAlpha(0.4D); 
      dM.BInterfaceBravo(0.4D);
      NInterfaceAlpha.NInterfaceAlpha(a1);
    } catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
      AcInterfaceDelta.NInterfaceAlpha("A problem was encountered loading the project " + file.getName() + ".\Isoptimizeddrawingenabled", (Exception)ExceptionPrintstacktrace, paramWindow);
      K ThreadedInIPackage = new K(AcInterfaceDelta.f());
      ThreadedInIPackage.NInterfaceAlpha(paramWindow);
      if (ExceptionPrintstacktrace.NInterfaceAlpha() != 2 && bV.NInterfaceAlpha("Would you like to update your Controller configuration file?", paramWindow, true)) {
        iH iH = new iH();
        File file1 = iH.NInterfaceAlpha();
        if (file1 != null && file1.exists()) {
          iH.NInterfaceAlpha(a1.AcInterfaceUniform(), a1, file1);
          NInterfaceAlpha(paramWindow, paramString);
        } 
      } 
      SInterfaceLima();
      return;
    } catch (KInterfaceEcho KInterfaceEcho) {
      AcInterfaceDelta.NInterfaceAlpha("A problem was encountered loading the project " + file.getName() + ".\Isoptimizeddrawingenabled", (Exception)KInterfaceEcho, paramWindow);
      if (bV.NInterfaceAlpha("The project  " + file.getName() + " appears to be corrupt. \nWould you like to create NInterfaceAlpha new Project?", paramWindow, true))
        BInterfaceBravo(paramWindow); 
      if (bool)
        SInterfaceLima(); 
      return;
    } catch (NInterfaceAlpha a2) {
      AcInterfaceDelta.NInterfaceAlpha("A problem was encountered loading the project " + file.getName() + ".\Isoptimizeddrawingenabled", (Exception)a2, paramWindow);
      K ThreadedInIPackage = new K(AcInterfaceDelta.f());
      ThreadedInIPackage.NInterfaceAlpha(paramWindow);
      if (bool)
        SInterfaceLima(); 
      return;
    } 
    T t = T.NInterfaceAlpha();
    try {
      if (bool)
        NInterfaceAlpha(0.5D); 
      dM.BInterfaceBravo(0.5D);
      boolean bool1 = NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bc, NInterfaceAlpha.bd);
      if ((NInterfaceAlpha.be && AcInterfaceDelta.AiInterfaceDelta() > 0) || (AcInterfaceDelta.KInterfaceEcho() > 0 && bool1)) {
        boolean bool3 = bV.NInterfaceAlpha("There were " + AcInterfaceDelta.AiInterfaceDelta() + " errors and " + AcInterfaceDelta.KInterfaceEcho() + " warnings during Project  load.\nWould you like to review them now?", paramWindow, true);
        if (bool3) {
          K ThreadedInIPackage = new K(AcInterfaceDelta.f());
          ThreadedInIPackage.NInterfaceAlpha(paramWindow);
        } else {
          AcInterfaceDelta.f();
          AcInterfaceDelta.DInterfaceCharlie();
        } 
      } else {
        AcInterfaceDelta.f();
        AcInterfaceDelta.DInterfaceCharlie();
      } 
      for (byte b1 = 0; b1 < a1.AcInterfaceDelta().size(); b1++) {
        R r1 = a1.AcInterfaceDelta().get(b1);
        if (t.DInterfaceCharlie(r1.DInterfaceCharlie()) == null) {
          t.NInterfaceAlpha(r1);
          AcInterfaceDelta.BInterfaceBravo("Config not in Config Manager, adding it: " + r1.DInterfaceCharlie());
        } 
        if (NInterfaceAlpha.AcInterfaceUniform(paramString) || NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bw, true)) {
          NInterfaceAlpha(a1, r1);
          try {
            File file1 = a1.DInterfaceCharlie(r1.DInterfaceCharlie());
            boolean bool3 = NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bj, NInterfaceAlpha.bk);
            if (bool3 && i.NInterfaceAlpha().NInterfaceAlpha(",.fesokdsoi4309") && !NInterfaceAlpha.AcInterfaceUniform(paramString)) {
              NInterfaceAlpha a2 = new NInterfaceAlpha(r1);
              UIInBePackage.NInterfaceAlpha().NInterfaceAlpha(file1, (PComponentBravo)a2);
            } 
            if (bool)
              NInterfaceAlpha(0.6D); 
            dM.BInterfaceBravo(0.6D);
          } catch (Exception exception) {
            AcInterfaceDelta.DInterfaceCharlie("Failed to get offline Tune File for " + r1.DInterfaceCharlie());
            exception.printStackTrace();
          } 
        } 
        r1.Abstract().NInterfaceAlpha(new AvInterfaceXray(this));
      } 
      AcInterfaceDelta.AiInterfaceDelta("!!! Loaded config in " + (System.currentTimeMillis() - SInterfaceLima));
      BInterfaceBravo(paramWindow, a1.AcInterfaceUniform());
      AcInterfaceDelta.AiInterfaceDelta("!!! Activated Project " + (System.currentTimeMillis() - SInterfaceLima));
      boolean bool2 = a1.Q();
      if (i.NInterfaceAlpha().NInterfaceAlpha("98fg54lklk") && bool2)
        NInterfaceAlpha().UICloseInPPackage(); 
      NInterfaceAlpha(t.DInterfaceCharlie(), a1.BsInterfaceOscar().getAbsolutePath());
      if (bool)
        NInterfaceAlpha(0.65D); 
      dM.BInterfaceBravo(0.65D);
      R();
      for (byte b2 = 1; b2 < a1.AcInterfaceDelta().size(); b2++) {
        try {
          R r1 = a1.AcInterfaceDelta().get(b2);
          Z PInterfaceZulu = null;
          if (r1.S()) {
            String str1 = a1.NetworkInBPackage() + r1.DInterfaceCharlie() + "." + NInterfaceAlpha.co;
            File file1 = new File(str1);
            if (i.NInterfaceAlpha().NInterfaceAlpha(" 098u 98u498u98ug") && file1.exists())
              try {
                PInterfaceZulu = (new DInterfaceCharlie(SInterfaceJuliet.G())).NInterfaceAlpha(str1);
              } catch (NInterfaceAlpha a2) {
                bV.AiInterfaceDelta("Gauge Cluster for " + r1.DInterfaceCharlie() + " is corrupt,\nthe default will be used instead.\nLoad error:\Isoptimizeddrawingenabled" + a2.getMessage(), paramWindow);
              }  
            if (PInterfaceZulu == null) {
              PInterfaceZulu = (new NetworkExceptionprintstacktrace()).NInterfaceAlpha(r1, "FrontPage", 1);
              Component[] arrayOfComponent = PInterfaceZulu.DInterfaceCharlie();
              for (byte BInterfaceBravo = 0; BInterfaceBravo < arrayOfComponent.length; BInterfaceBravo++) {
                if (arrayOfComponent[BInterfaceBravo] instanceof Exception) {
                  Exception Exception = (Exception)arrayOfComponent[BInterfaceBravo];
                  if ((Exception.getEcuConfigurationName() == null || Exception.getEcuConfigurationName().equals("")) && !Exception.getEcuConfigurationName().equals(ManagerUsingArrayList.NInterfaceAlpha))
                    Exception.setEcuConfigurationName(r1.DInterfaceCharlie()); 
                } 
              } 
            } 
            if (i.NInterfaceAlpha().NInterfaceAlpha("64865e43s5hjhcurd")) {
              AvInterfaceXray x1 = dd.NInterfaceAlpha().Abstract().NInterfaceAlpha(PInterfaceZulu, r1.DInterfaceCharlie());
              x1.NetworkInBPackage(str1);
              GInterfaceAb.NInterfaceAlpha(x1);
            } 
          } 
        } catch (NInterfaceAlpha a2) {
          AcInterfaceDelta.NInterfaceAlpha("Failed to load project", (Exception)a2, paramWindow);
        } 
      } 
      if (bool)
        NInterfaceAlpha(1.0D); 
      if (paramBoolean)
        NInterfaceAlpha(t.DInterfaceCharlie()); 
      if (dM != null)
        dM.BInterfaceBravo(0.65D); 
    } finally {
      SInterfaceLima();
      dd.NInterfaceAlpha().BInterfaceBravo().repaint();
    } 
    R BsInterfaceRomeo = t.DInterfaceCharlie();
    if (i.NInterfaceAlpha().NInterfaceAlpha("64865e43s5hjhcurd")) {
      if (i.NInterfaceAlpha().NInterfaceAlpha("fdsa0987fdsa43298 fds") && BsInterfaceRomeo.ExceptionPrintstacktrace("etDistanceFt") != null && BsInterfaceRomeo.ExceptionPrintstacktrace("timeTo330Ft") != null) {
        File file1 = SInterfaceJuliet.ExceptionPrintstacktrace();
        aE.f f1 = new aE.f();
        f1.NInterfaceAlpha(ExceptionPrintstacktrace.BInterfaceBravo("Acceleration Performance"));
        f1.BInterfaceBravo("Acceleration_Performance.dash");
        File file2 = new File(f1.NInterfaceAlpha(a1));
        if (file1.exists() && !file2.exists()) {
          try {
            t.NInterfaceAlpha(file1, file2);
            a1.NInterfaceAlpha(f1);
          } catch (NInterfaceAlpha a2) {
            AcInterfaceDelta.NInterfaceAlpha("Failed to copy Performance dash to project!");
            a2.printStackTrace();
          } 
        } else if (!file1.exists()) {
          AcInterfaceDelta.AiInterfaceDelta("Performance Dash file not found in installer, so not loaded.");
        } 
      } 
      int i = a1.G();
      byte BInterfaceBravo = 0;
      Iterator<aE.f> iterator = a1.F();
      while (iterator.hasNext()) {
        aE.f f1 = iterator.next();
        AvInterfaceXray x1 = new AvInterfaceXray(a1.E());
        GInterfaceAb.NInterfaceAlpha(x1);
        dd.NInterfaceAlpha().Abstract().NInterfaceAlpha(x1, f1.NInterfaceAlpha());
        try {
          x1.f(f1.NInterfaceAlpha(a1));
        } catch (NInterfaceAlpha a2) {
          AcInterfaceDelta.NInterfaceAlpha("Error loading User Dashboard \"" + f1.NInterfaceAlpha() + "\"", (Exception)a2, paramWindow);
        } 
        double AiInterfaceDelta = 0.2D * BInterfaceBravo++ / i;
        if (dM != null)
          dM.BInterfaceBravo(0.7D + AiInterfaceDelta); 
      } 
    } 
    AcInterfaceDelta.DInterfaceCharlie("!!! Opened Dash " + (System.currentTimeMillis() - SInterfaceLima));
    if (!NInterfaceAlpha.AcInterfaceUniform(paramString)) {
      String str1 = paramString;
      if (!paramString.startsWith("\\\\"))
        str1 = X.BInterfaceBravo(paramString, File.separator + File.separator, File.separator); 
      NInterfaceAlpha.NInterfaceAlpha().BInterfaceBravo("lastProjectPath", str1);
      (new Isoptimizeddrawingenabled()).NInterfaceAlpha(str1);
    } 
    if (dM != null)
      dM.BInterfaceBravo(0.9D); 
    try {
      if (!T.NInterfaceAlpha().DInterfaceCharlie().UIInBePackage().q()) {
        AvInterfaceXray.ThreadedInIPackage(ExceptionPrintstacktrace.BInterfaceBravo("Not Connected"));
      } else {
        AvInterfaceXray.GInterfaceAb();
      } 
    } catch (Exception exception) {
      exception.printStackTrace();
    } 
    hq.NInterfaceAlpha().NInterfaceAlpha(a1.AcInterfaceUniform() + " " + ExceptionPrintstacktrace.BInterfaceBravo("Ready"));
    if (dM != null)
      dM.BInterfaceBravo(1.0D); 
    U();
  }
  
  public void KInterfaceEcho() {
    ManagerUsingArrayList.NInterfaceAlpha().NInterfaceAlpha("dataLogTime", 0.0D);
  }
  
  public void f() {
    Window[] arrayOfWindow = Window.getWindows();
    try {
      for (byte BInterfaceBravo = 0; BInterfaceBravo < arrayOfWindow.length; BInterfaceBravo++) {
        if (arrayOfWindow[BInterfaceBravo].isVisible() && dd.NInterfaceAlpha().DInterfaceCharlie(arrayOfWindow[BInterfaceBravo]))
          arrayOfWindow[BInterfaceBravo].dispose(); 
      } 
    } catch (Exception exception) {
      exception.printStackTrace();
    } 
  }
  
  public boolean ExceptionPrintstacktrace() {
    AvInterfaceXray AvInterfaceXray = dd.NInterfaceAlpha().BInterfaceBravo();
    try {
      K();
    } catch (Exception exception) {
      AcInterfaceDelta.DInterfaceCharlie("Failed to stop Slave Server");
    } 
    ThreadedInIPackage.NInterfaceAlpha().DInterfaceCharlie();
    boolean bool = false;
    try {
      if (AvInterfaceXray.isVisible() && (AvInterfaceXray.NetworkExceptionprintstacktrace() == null || AvInterfaceXray.NetworkExceptionprintstacktrace().indexOf(ExceptionPrintstacktrace.BInterfaceBravo("Shut down....")) == -1)) {
        AvInterfaceXray.ThreadedInIPackage(ExceptionPrintstacktrace.BInterfaceBravo("Closing Project"));
        AvInterfaceXray.paint(AvInterfaceXray.getGraphics());
        bool = true;
      } 
    } catch (Exception exception) {}
    try {
      if (NInterfaceAlpha.A() != null)
        NInterfaceAlpha(NInterfaceAlpha.A()); 
      f();
      T t = T.NInterfaceAlpha();
      NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
      if (NInterfaceAlpha != null && i.NInterfaceAlpha().NInterfaceAlpha("-=fds[pfds[pgd-0") && NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bz, NInterfaceAlpha.bA)) {
        String str = "Project close";
        DInterfaceCharlie(str);
      } 
      ExceptionPrintstacktrace(dd.NInterfaceAlpha().DInterfaceCharlie());
      bW bW = dd.NInterfaceAlpha().Abstract();
      if (NInterfaceAlpha != null && !t.NInterfaceAlpha(NInterfaceAlpha.t(), 1024L)) {
        bV.AiInterfaceDelta(ExceptionPrintstacktrace.BInterfaceBravo("Unable to save current project.") + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Either the disk is full or the you have insufficient rights."), dd.NInterfaceAlpha().DInterfaceCharlie());
        return true;
      } 
      hx.NInterfaceAlpha().SInterfaceJuliet();
      if (NInterfaceAlpha != null) {
        NInterfaceAlpha.AcInterfaceYankee(dd.NInterfaceAlpha().f().NInterfaceAlpha());
        for (R BsInterfaceRomeo : NInterfaceAlpha.AcInterfaceDelta()) {
          if (BsInterfaceRomeo != null && BsInterfaceRomeo.p().aO() && (!NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bw, true) || NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bx, NInterfaceAlpha.by))) {
            boolean bool1 = bV.NInterfaceAlpha("The tune for " + BsInterfaceRomeo.DInterfaceCharlie() + " has changed.\nWould you like to save NInterfaceAlpha backup with the changes?", dd.NInterfaceAlpha().DInterfaceCharlie(), true);
            if (bool1)
              KInterfaceEcho(dd.NInterfaceAlpha().DInterfaceCharlie()); 
          } 
          if (BsInterfaceRomeo != null) {
            if (!NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bw, true)) {
              File file = NInterfaceAlpha.AiInterfaceDelta(BsInterfaceRomeo.DInterfaceCharlie());
              NetworkExceptionprintstacktrace NetworkExceptionprintstacktrace = new NetworkExceptionprintstacktrace();
              NetworkExceptionprintstacktrace.BInterfaceBravo(BsInterfaceRomeo, file.getAbsolutePath(), (A)new BsInterfaceOscar());
              AcInterfaceDelta.AiInterfaceDelta("Saved PC variables for " + BsInterfaceRomeo.DInterfaceCharlie() + " to:\Isoptimizeddrawingenabled" + file.getAbsolutePath());
            } 
            if (NInterfaceAlpha != null && !NInterfaceAlpha.UICloseInPPackage()) {
              KInterfaceEcho(BsInterfaceRomeo);
              try {
                File file = NInterfaceAlpha.DInterfaceCharlie(BsInterfaceRomeo.DInterfaceCharlie());
                UIInBePackage.NInterfaceAlpha().BInterfaceBravo(file);
              } catch (Exception exception) {
                AcInterfaceDelta.DInterfaceCharlie("Failed to get offline Tune File for " + BsInterfaceRomeo.DInterfaceCharlie());
                exception.printStackTrace();
              } 
            } 
            ManagerUsingArrayList.NInterfaceAlpha().i(BsInterfaceRomeo.DInterfaceCharlie());
            if (BsInterfaceRomeo.DInterfaceCharlie("Dash_Pad") != null)
              try {
                Thread.currentThread();
                Thread.sleep(1000L);
              } catch (InterruptedException interruptedException) {} 
            BsInterfaceRomeo.UIInBePackage().DInterfaceCharlie();
            GInterfaceCq.NInterfaceAlpha().NInterfaceAlpha(BsInterfaceRomeo.DInterfaceCharlie());
          } 
          ManagerUsingConcurrentHashMap.NInterfaceAlpha().BInterfaceBravo(BsInterfaceRomeo.DInterfaceCharlie());
        } 
      } 
      if (dd.NInterfaceAlpha().f() != null)
        dd.NInterfaceAlpha().f().BInterfaceBravo(""); 
      if (NInterfaceAlpha != null)
        if (bW != null) {
          Iterator<AvInterfaceXray> iterator = bW.f();
          while (iterator.hasNext()) {
            AvInterfaceXray x1 = iterator.next();
            if (!x1.KInterfaceEcho(""))
              return false; 
            x1.DInterfaceCharlie();
          } 
        } else if (AvInterfaceXray != null) {
          AvInterfaceXray.DInterfaceCharlie();
        }  
      if (bW != null)
        bW.f_(); 
      jA.NInterfaceAlpha().BInterfaceBravo();
      t.BInterfaceBravo();
      NInterfaceAlpha.NInterfaceAlpha(null);
      this.f.clear();
      if (dd.NInterfaceAlpha().f() != null)
        dd.NInterfaceAlpha().f().BInterfaceBravo(""); 
      if (dd.NInterfaceAlpha().BInterfaceBravo() != null)
        dd.NInterfaceAlpha().BInterfaceBravo().GInterfaceAb(); 
      F.DInterfaceCharlie();
      i.NInterfaceAlpha();
      SInterfaceLima.NInterfaceAlpha().BInterfaceBravo();
      V();
      try {
        if (NInterfaceAlpha != null)
          NInterfaceAlpha.BInterfaceBravo(); 
      } catch (Exception exception) {
        try {
          Thread.sleep(100L);
          if (NInterfaceAlpha != null)
            NInterfaceAlpha.BInterfaceBravo(); 
        } catch (Exception exception1) {
          AcInterfaceDelta.NInterfaceAlpha("Failed to save current Project", exception1, dd.NInterfaceAlpha().DInterfaceCharlie());
        } 
      } 
    } catch (Exception exception) {
      AcInterfaceDelta.BInterfaceBravo("Caught this exception, clean this up:");
      exception.printStackTrace();
    } 
    if (bool)
      AvInterfaceXray.GInterfaceAb(); 
    BInterfaceBravo.DInterfaceCharlie().NInterfaceAlpha(null);
    return true;
  }
  
  public void BInterfaceBravo(Window paramWindow, String paramString) {
    T t = T.NInterfaceAlpha();
    try {
      t.NInterfaceAlpha(paramString);
    } catch (NInterfaceAlpha NInterfaceAlpha) {
      AcInterfaceDelta.NInterfaceAlpha(NInterfaceAlpha.getMessage(), (Exception)NInterfaceAlpha, paramWindow);
    } 
  }
  
  public void NInterfaceAlpha(File paramFile) {
    if (U.NInterfaceAlpha(paramFile)) {
      AcInterfaceYankee AcInterfaceYankee = new AcInterfaceYankee(this);
      if (SwingUtilities.isEventDispatchThread()) {
        AcInterfaceYankee.run();
      } else {
        try {
          SwingUtilities.invokeAndWait(AcInterfaceYankee);
        } catch (InterruptedException interruptedException) {
          Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, interruptedException);
        } catch (InvocationTargetException invocationTargetException) {
          Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, invocationTargetException);
        } 
      } 
      (dd.NInterfaceAlpha().i()).DInterfaceCharlie.NInterfaceAlpha.NInterfaceAlpha(paramFile);
    } else if (i.NInterfaceAlpha().NInterfaceAlpha(" OKFDS09IFDSOK")) {
      PInterfaceZulu PInterfaceZulu = new PInterfaceZulu(this, paramFile);
      SwingUtilities.invokeLater(PInterfaceZulu);
    } else {
      BInterfaceBravo(paramFile.getAbsolutePath());
    } 
  }
  
  public void NInterfaceAlpha(File[] paramArrayOfFile) {
    if (i.NInterfaceAlpha().NInterfaceAlpha(" OKFDS09IFDSOK") && paramArrayOfFile.length > 0) {
      A NInterfaceAlpha = new A(this, paramArrayOfFile);
      SwingUtilities.invokeLater(NInterfaceAlpha);
    } 
  }
  
  public void NInterfaceAlpha(R paramR) {
    if (NInterfaceAlpha.A().UICloseInPPackage())
      return; 
    try {
      T t = T.NInterfaceAlpha();
      String[] arrayOfString = t.AiInterfaceDelta();
      byte BInterfaceBravo;
      for (BInterfaceBravo = 0; BInterfaceBravo < arrayOfString.length; BInterfaceBravo++) {
        R BsInterfaceRomeo = t.DInterfaceCharlie(arrayOfString[BInterfaceBravo]);
        if (BsInterfaceRomeo != null)
          BsInterfaceRomeo.AiInterfaceDelta(); 
      } 
      paramR.UIInBePackage().AiInterfaceDelta();
      for (BInterfaceBravo = 0; BInterfaceBravo < arrayOfString.length; BInterfaceBravo++) {
        R BsInterfaceRomeo = t.DInterfaceCharlie(arrayOfString[BInterfaceBravo]);
        if (!BsInterfaceRomeo.DInterfaceCharlie().equals(paramR.DInterfaceCharlie()) && BsInterfaceRomeo.UIInBePackage() instanceof SInterfaceLima)
          BsInterfaceRomeo.UIInBePackage().AiInterfaceDelta(); 
      } 
    } catch (SInterfaceLima SInterfaceLima) {
      if (paramR.UIInBePackage() instanceof KInterfaceEcho) {
        NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.NInterfaceAlpha();
        if (paramR.UIInBePackage() instanceof KInterfaceEcho) {
          KInterfaceEcho KInterfaceEcho = (KInterfaceEcho)paramR.UIInBePackage();
          KInterfaceEcho.NInterfaceAlpha();
          String str = "promptOnPortNotDetected" + KInterfaceEcho.ExceptionPrintstacktrace();
        } 
      } 
    } 
  }
  
  public void NInterfaceAlpha(R paramR, String paramString) {
    hq.NInterfaceAlpha().NInterfaceAlpha("Opening Gauge Cluster..");
    AvInterfaceXray AvInterfaceXray = dd.NInterfaceAlpha().BInterfaceBravo();
    AvInterfaceXray.N();
    try {
      if (!i.NInterfaceAlpha().NInterfaceAlpha(" 098u 98u498u98ug")) {
        Z PInterfaceZulu = AvInterfaceXray.BInterfaceBravo(paramR);
        AvInterfaceXray.NInterfaceAlpha(PInterfaceZulu);
        NetworkExceptionprintstacktrace NetworkExceptionprintstacktrace = new NetworkExceptionprintstacktrace(paramR.DInterfaceCharlie(), AvInterfaceXray);
        NetworkExceptionprintstacktrace.NInterfaceAlpha(AvInterfaceXray);
        AvInterfaceXray.NInterfaceAlpha(NetworkExceptionprintstacktrace);
        AvInterfaceXray.AiInterfaceDelta(true);
      } else {
        AvInterfaceXray.f(paramString);
      } 
    } catch (NInterfaceAlpha NInterfaceAlpha) {
      AcInterfaceDelta.NInterfaceAlpha("Error opening saved dashboard.", (Exception)NInterfaceAlpha, AvInterfaceXray);
      return;
    } 
    hq.NInterfaceAlpha().NInterfaceAlpha("");
  }
  
  public void Abstract() {
    JFrame jFrame = dd.NInterfaceAlpha().DInterfaceCharlie();
    String[] arrayOfString = { NInterfaceAlpha.cw };
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    if (NInterfaceAlpha == null) {
      bV.AiInterfaceDelta("There is no project open.\nPlease open NInterfaceAlpha project first.", jFrame);
      return;
    } 
    String str1 = NInterfaceAlpha.Exception();
    T t = T.NInterfaceAlpha();
    ac ac = new ac(t.AiInterfaceDelta(), NInterfaceAlpha.AcInterfaceUniform());
    ac.NInterfaceAlpha(true);
    ac.setPreferredSize(eJ.NInterfaceAlpha(200, 150));
    String str2 = bV.BInterfaceBravo(jFrame, "Compare Saved Tune", arrayOfString, "", str1, (ck)ac);
    if (str2 == null || str2.equals(""))
      return; 
    R BsInterfaceRomeo = t.DInterfaceCharlie(ac.NInterfaceAlpha());
    BInterfaceBravo(BsInterfaceRomeo, str2);
  }
  
  public void BInterfaceBravo(R paramR, String paramString) {
    JFrame jFrame = dd.NInterfaceAlpha().DInterfaceCharlie();
    if (paramR == null) {
      bV.AiInterfaceDelta("No open and active ECU Configuration.\nPlease open or create NInterfaceAlpha project before loading NInterfaceAlpha saved tune.", jFrame);
      return;
    } 
    hH hH = new hH();
    if (!hH.NInterfaceAlpha(jFrame, paramR, paramString))
      bV.AiInterfaceDelta("No Differences Found!\nThe settings in the file are the same as the current loaded tune.", jFrame); 
  }
  
  public void NInterfaceAlpha(Frame paramFrame, List paramList) {
    NInterfaceAlpha(paramFrame, (R)null, paramList);
  }
  
  public void NInterfaceAlpha(Frame paramFrame, R paramR, List paramList) {
    String[] arrayOfString1;
    String str1 = NInterfaceAlpha.NInterfaceAlpha().NInterfaceAlpha("tuneFileExt", NInterfaceAlpha.cw) + NInterfaceAlpha.cy;
    String[] arrayOfString2 = { NInterfaceAlpha.cw, str1 };
    String[] arrayOfString3 = NInterfaceAlpha.NInterfaceAlpha().NInterfaceAlpha(NInterfaceAlpha.GComponentCx, NInterfaceAlpha.cw).split(";");
    if (paramList != null) {
      arrayOfString1 = arrayOfString2;
    } else {
      arrayOfString1 = arrayOfString3;
    } 
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    if (NInterfaceAlpha == null) {
      NInterfaceAlpha(paramFrame);
      return;
    } 
    String str2 = NInterfaceAlpha.Exception();
    T t = T.NInterfaceAlpha();
    ac ac = null;
    ac = new ac(t.AiInterfaceDelta(), NInterfaceAlpha.AcInterfaceUniform());
    ac.NInterfaceAlpha(true);
    ac.setPreferredSize(eJ.NInterfaceAlpha(200, 150));
    if (paramR != null)
      ac.NInterfaceAlpha(paramR.DInterfaceCharlie()); 
    String str3 = (paramList != null) ? ExceptionPrintstacktrace.BInterfaceBravo("Load Dialog Settings") : ExceptionPrintstacktrace.BInterfaceBravo("Open Saved Tune");
    String str4 = bV.BInterfaceBravo(paramFrame, str3, arrayOfString1, "", str2, (ck)ac);
    if (str4 == null || str4.equals(""))
      return; 
    File file = new File(str4);
    if (!file.exists()) {
      bV.AiInterfaceDelta(ExceptionPrintstacktrace.BInterfaceBravo("File not found") + ":\Isoptimizeddrawingenabled" + str4, paramFrame);
      return;
    } 
    if (paramR == null)
      paramR = t.DInterfaceCharlie(ac.NInterfaceAlpha()); 
    if (paramR == null) {
      bV.AiInterfaceDelta("No open and active ECU Configuration.\nPlease open or create NInterfaceAlpha project before loading NInterfaceAlpha saved tune.", paramFrame);
      return;
    } 
    str2 = str4.substring(0, str4.lastIndexOf(File.separatorChar));
    NInterfaceAlpha.ExceptionPrintstacktrace(str2);
    String str5 = PInterfaceZulu.NInterfaceAlpha(str4);
    if (str5 != null && !str5.equals("null") && !paramR.i().equals(str5)) {
      String str = ExceptionPrintstacktrace.BInterfaceBravo("Signatures do not match!") + "\nTune File signature: " + str5 + "\nConfiguration signature: " + paramR.i() + "\Isoptimizeddrawingenabled \Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Do you want to load it anyway?");
      if (!bV.NInterfaceAlpha(str, paramFrame, true))
        return; 
      paramR.O().NetworkInBPackage("");
    } 
    if (paramR.UIInBePackage().q()) {
      String str = ExceptionPrintstacktrace.BInterfaceBravo("Would you like to send & burn configuration to controller?");
      if (!paramR.p().Abstract() && paramList == null) {
        str = str + "\Isoptimizeddrawingenabled\nThe current settings will be replaced by the\Isoptimizeddrawingenabled settings in " + file.getName();
        if (i.NInterfaceAlpha().NInterfaceAlpha("-=fds[pfds[pgd-0") && NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bF, NInterfaceAlpha.bG))
          str = str + "\nA restore point with the current " + NInterfaceAlpha.NInterfaceAlpha(str5, NInterfaceAlpha.f) + " settings will be created."; 
      } 
      if (!bV.NInterfaceAlpha(str, paramFrame, true))
        return; 
      if (i.NInterfaceAlpha().NInterfaceAlpha("-=fds[pfds[pgd-0") && NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bF, NInterfaceAlpha.bG)) {
        String str6 = "Before loading " + str4 + " to " + paramR.DInterfaceCharlie();
        AiInterfaceDelta(paramR, str6);
      } 
    } else if (paramList == null && !paramR.p().Abstract() && NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bw, true)) {
      String str = ExceptionPrintstacktrace.BInterfaceBravo("This will load all settings from the file:") + "\Isoptimizeddrawingenabled" + file.getName() + "\nCurrentTune." + NInterfaceAlpha.cw + " will be be updated with all settings from " + file.getName();
      if (i.NInterfaceAlpha().NInterfaceAlpha("-=fds[pfds[pgd-0") && NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bF, NInterfaceAlpha.bG))
        str = str + "\nA restore point with current CurrentTune." + NInterfaceAlpha.cw + " settings will be created."; 
      str = str + "\Isoptimizeddrawingenabled\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Would you like to proceed?");
      if (!bV.NInterfaceAlpha(str, paramFrame, true))
        return; 
      if (i.NInterfaceAlpha().NInterfaceAlpha("-=fds[pfds[pgd-0") && NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bF, NInterfaceAlpha.bG)) {
        String str6 = "Before loading " + str4 + " to " + paramR.DInterfaceCharlie();
        AiInterfaceDelta(paramR, str6);
      } 
    } 
    NInterfaceAlpha(paramFrame, paramR, str4, paramList);
  }
  
  public void NInterfaceAlpha(Window paramWindow, File paramFile) {
    if (U.BInterfaceBravo(paramFile)) {
      if (NInterfaceAlpha.A() == null) {
        DInterfaceCharlie(paramWindow, paramFile.getAbsolutePath());
      } else {
        NInterfaceAlpha(paramWindow, (R)null, paramFile.getAbsolutePath());
      } 
    } else if (U.DInterfaceCharlie(paramFile) && NInterfaceAlpha.A() != null) {
      NInterfaceAlpha(paramFile);
    } 
  }
  
  public void NInterfaceAlpha(Frame paramFrame) {
    ac ac = new ac(null, "");
    ac.NInterfaceAlpha(true);
    ac.setPreferredSize(eJ.NInterfaceAlpha(200, 150));
    String str1 = SInterfaceJuliet.AcInterfaceUniform();
    String[] arrayOfString = NInterfaceAlpha.NInterfaceAlpha().NInterfaceAlpha(NInterfaceAlpha.GComponentCx, NInterfaceAlpha.cw).split(";");
    String str2 = bV.BInterfaceBravo(paramFrame, "Open Saved Tune", arrayOfString, "", str1, (ck)ac);
    if (str2 == null || str2.equals(""))
      return; 
    File file = new File(str2);
    if (!file.exists()) {
      bV.AiInterfaceDelta("File not found:\Isoptimizeddrawingenabled" + str2, paramFrame);
      return;
    } 
    DInterfaceCharlie(paramFrame, str2);
  }
  
  public void DInterfaceCharlie(Window paramWindow, String paramString) {
    String str1 = PInterfaceZulu.NInterfaceAlpha(paramString);
    String str2 = ExceptionPrintstacktrace.BInterfaceBravo("Would you like to use one of your existing projects to open this " + NInterfaceAlpha.cw + "?") + "\Isoptimizeddrawingenabled\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Alternatively, NInterfaceAlpha temporary project can be used for viewing purposes only.") + "\Isoptimizeddrawingenabled\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Note:") + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("For working on NInterfaceAlpha controller you should always create and open your own Project.") + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Temporary projects disable saving the " + NInterfaceAlpha.cw + " and establishing communication with the controller.");
    String[] arrayOfString = { ExceptionPrintstacktrace.BInterfaceBravo("Use an existing Project"), ExceptionPrintstacktrace.BInterfaceBravo("Use NInterfaceAlpha Temporary Project") };
    boolean bool = (0 == JOptionPane.showOptionDialog(paramWindow, str2, ExceptionPrintstacktrace.BInterfaceBravo("Tune File Project"), 0, 3, null, (Object[])arrayOfString, arrayOfString[1])) ? true : false;
    if (bool) {
      String str = bV.BInterfaceBravo(SInterfaceJuliet.AcInterfaceUniform(), paramWindow);
      if (str != null && !str.equals(""))
        (new H(this, paramWindow, str, paramString)).run(); 
      return;
    } 
    try {
      File file1 = SInterfaceJuliet.NInterfaceAlpha(paramWindow, str1);
      NetworkExceptionprintstacktrace NetworkExceptionprintstacktrace = new NetworkExceptionprintstacktrace();
      String[] arrayOfString1 = null;
      try {
        arrayOfString1 = NetworkExceptionprintstacktrace.DInterfaceCharlie(new File(paramString));
      } catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
        AcInterfaceDelta.NInterfaceAlpha("Failed to retrieve settings, loading without.");
      } 
      BsInterfaceRomeo[] arrayOfR = null;
      boolean bool1 = false;
      if (arrayOfString1 != null) {
        arrayOfR = new BsInterfaceRomeo[arrayOfString1.length];
        for (byte BInterfaceBravo = 0; BInterfaceBravo < arrayOfString1.length; BInterfaceBravo++) {
          arrayOfR[BInterfaceBravo] = new BsInterfaceRomeo();
          arrayOfR[BInterfaceBravo].v(arrayOfString1[BInterfaceBravo]);
        } 
      } else {
        Exception[] arrayOfS = v.NInterfaceAlpha().BInterfaceBravo(file1.getAbsolutePath());
        arrayOfS = (new JDialogExtensionInBdPackage()).NInterfaceAlpha(arrayOfS, file1.getAbsolutePath());
        arrayOfR = new BsInterfaceRomeo[arrayOfS.length];
        String str = paramString.substring(paramString.lastIndexOf("."));
        if (arrayOfS != null && arrayOfS.length > 0) {
          bV.AiInterfaceDelta("Warning!\nThis " + str + " is an older format and does not contain project settings.\nYou will need to set them on the Settings Tab of the\nProject Properties dialog after opening the " + str + ".", paramWindow);
          bool1 = true;
          for (byte BInterfaceBravo = 0; BInterfaceBravo < arrayOfR.length; BInterfaceBravo++)
            arrayOfR[BInterfaceBravo] = arrayOfS[BInterfaceBravo].BInterfaceBravo(); 
        } 
      } 
      File file2 = new File(SInterfaceJuliet.AcInterfaceUniform() + "Temp");
      if (file2.exists())
        t.BInterfaceBravo(file2); 
      NInterfaceAlpha NInterfaceAlpha = (new ie()).NInterfaceAlpha(str1, file1, arrayOfR);
      File file3 = NInterfaceAlpha.DInterfaceCharlie(NInterfaceAlpha.AcInterfaceUniform());
      if (file3.exists())
        file3.delete(); 
      AcInterfaceDelta.NInterfaceAlpha().NInterfaceAlpha(new File(NInterfaceAlpha.t()));
      (new H(this, paramWindow, NInterfaceAlpha.t(), paramString)).run();
      if (bool1) {
        ig ig = SInterfaceJuliet(paramWindow);
        ig.NInterfaceAlpha("Settings");
        t.NInterfaceAlpha(new File(paramString), NInterfaceAlpha.DInterfaceCharlie(NInterfaceAlpha.AcInterfaceUniform()));
      } 
    } catch (NInterfaceAlpha NInterfaceAlpha) {
      AcInterfaceDelta.NInterfaceAlpha("Unable to get create working project.", (Exception)NInterfaceAlpha, paramWindow);
      return;
    } 
  }
  
  public void NInterfaceAlpha(Window paramWindow, R paramR, String paramString) {
    f(paramR);
    NInterfaceAlpha(paramWindow, paramR, paramString, (List)null);
    ExceptionPrintstacktrace(paramR);
  }
  
  public void NInterfaceAlpha(Window paramWindow, R paramR, String paramString, List paramList) {
    if (paramR == null)
      if (T.NInterfaceAlpha().AiInterfaceDelta() == null) {
        DInterfaceCharlie(paramWindow, paramString);
      } else if ((T.NInterfaceAlpha().AiInterfaceDelta()).length == 1) {
        paramR = T.NInterfaceAlpha().DInterfaceCharlie();
      } else {
        String str = PInterfaceZulu.NInterfaceAlpha(new File(paramString));
        if (str == null || str.isEmpty()) {
          AcInterfaceDelta.NInterfaceAlpha("Attempt to load invalid tune file: " + paramString);
          return;
        } 
        for (String str1 : T.NInterfaceAlpha().AiInterfaceDelta()) {
          R BsInterfaceRomeo = T.NInterfaceAlpha().DInterfaceCharlie(str1);
          if (BsInterfaceRomeo.i().equals(str)) {
            paramR = BsInterfaceRomeo;
            break;
          } 
        } 
        if (paramR == null) {
          Object object = JOptionPane.showInputDialog(null, "Select Target Controller", "Available Controllers", -1, null, (Object[])T.NInterfaceAlpha().AiInterfaceDelta(), null);
          if (object == null)
            return; 
          paramR = T.NInterfaceAlpha().DInterfaceCharlie(object.toString());
          if (paramR == null) {
            AcInterfaceDelta.BInterfaceBravo("Contrller not found: " + object);
            return;
          } 
          if (!paramR.i().equals(str)) {
            boolean bool = bV.NInterfaceAlpha(ExceptionPrintstacktrace.BInterfaceBravo("This tune file was saved from NInterfaceAlpha different firmware than the selected Controller.") + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Are you sure you want to load this tune?"), paramWindow, true);
            if (!bool)
              return; 
          } 
        } 
      }  
    BInterfaceBravo BInterfaceBravo = new BInterfaceBravo();
    paramR.p().NInterfaceAlpha((GInterfaceAb)BInterfaceBravo);
    AcInterfaceDelta.DInterfaceCharlie();
    try {
      if (i.NInterfaceAlpha().NInterfaceAlpha("FSD;LDSALKPOIERW") && !NetworkExceptionprintstacktrace.NInterfaceAlpha(paramString)) {
        IOExceptioninvpackageInWPackage IOExceptioninvpackageInWPackage = new IOExceptioninvpackageInWPackage();
        IOExceptioninvpackageInWPackage.NInterfaceAlpha(paramR, paramString, paramList);
      } else {
        NetworkExceptionprintstacktrace NetworkExceptionprintstacktrace = new NetworkExceptionprintstacktrace();
        NetworkExceptionprintstacktrace.NInterfaceAlpha(paramR, paramString, paramList);
      } 
      if (BInterfaceBravo.NInterfaceAlpha() > 2) {
        iw iw = new iw(paramR, dd.NInterfaceAlpha().BInterfaceBravo(), BInterfaceBravo.BInterfaceBravo());
        iw.NInterfaceAlpha();
      } 
      if (paramList == null) {
        String str = "Tune opened, " + BInterfaceBravo.NInterfaceAlpha() + " bytes updated. File:" + paramString;
        hq.NInterfaceAlpha().NInterfaceAlpha(str);
        AcInterfaceDelta.AiInterfaceDelta(str);
        KInterfaceEcho KInterfaceEcho = new KInterfaceEcho(paramR);
        KInterfaceEcho.NInterfaceAlpha(paramR);
      } else {
        String str = "Dialog Settings Loaded, " + BInterfaceBravo.NInterfaceAlpha() + " bytes updated. File:" + paramString;
        hq.NInterfaceAlpha().NInterfaceAlpha(str);
        AcInterfaceDelta.AiInterfaceDelta(str);
      } 
    } catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
      AcInterfaceDelta.NInterfaceAlpha("Error opening Saved tune.", (Exception)ExceptionPrintstacktrace, paramWindow);
    } catch (NInterfaceAlpha a1) {
      AcInterfaceDelta.NInterfaceAlpha("Error opening Saved tune.", (Exception)a1, paramWindow);
    } catch (GComponentAj GComponentAj) {
      bV.AiInterfaceDelta("Password Protected, Invalid Password!", paramWindow);
      return;
    } finally {
      paramR.ah();
      paramR.JDialogExtensionInBdPackage();
      paramR.p().BInterfaceBravo((GInterfaceAb)BInterfaceBravo);
    } 
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    if (NInterfaceAlpha != null && paramR.DInterfaceCharlie().equals(NInterfaceAlpha.AcInterfaceUniform()) && dd.NInterfaceAlpha().f() != null && !paramString.contains("CurrentTune"))
      dd.NInterfaceAlpha().f().BInterfaceBravo(paramString); 
    if (!this.i && (AcInterfaceDelta.AiInterfaceDelta() > 0 || (AcInterfaceDelta.KInterfaceEcho() > 0 && !i.NInterfaceAlpha().NInterfaceAlpha("FESLKJGD09432LK ")))) {
      String str = "There were errors or warnings during " + NInterfaceAlpha.cw + " load.\nWould you like to review them now?";
      String[] arrayOfString = { ExceptionPrintstacktrace.BInterfaceBravo("View"), ExceptionPrintstacktrace.BInterfaceBravo("Ignore") };
      boolean bool = (0 == JOptionPane.showOptionDialog(paramWindow, str, ExceptionPrintstacktrace.BInterfaceBravo("Audit Log"), 0, 3, null, (Object[])arrayOfString, arrayOfString[1])) ? true : false;
      if (bool) {
        K ThreadedInIPackage = new K(AcInterfaceDelta.f());
        ThreadedInIPackage.NInterfaceAlpha(paramWindow);
      } 
    } 
    if (paramList == null) {
      paramR.p().ExceptionPrintstacktrace();
      this.f.put(paramR.DInterfaceCharlie(), paramString);
    } 
  }
  
  public void NInterfaceAlpha(NInterfaceAlpha parama, R paramR) {
    File file = parama.DInterfaceCharlie(paramR.DInterfaceCharlie());
    if (!file.exists())
      return; 
    String str1 = file.getAbsolutePath();
    NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie(), paramR, str1);
    String str2 = parama.W();
    if (dd.NInterfaceAlpha().f() != null)
      dd.NInterfaceAlpha().f().BInterfaceBravo(str2); 
  }
  
  public String i() {
    String str = "TunerStudioMS.jar";
    try {
      File file = new File(getClass().getProtectionDomain().getCodeSource().getLocation().toURI());
      if (!file.getName().equals("classes"))
        str = file.getName(); 
      System.out.println("Jar Name:" + str);
    } catch (URISyntaxException uRISyntaxException) {
      uRISyntaxException.printStackTrace();
    } 
    return str;
  }
  
  public void AiInterfaceDelta(Window paramWindow) {
    String str1 = X.BInterfaceBravo(NInterfaceAlpha.DInterfaceCharlie, "(Beta)", "");
    str1 = X.BInterfaceBravo(str1, " Lite!", "");
    str1 = X.BInterfaceBravo(str1, i.AiInterfaceDelta, "");
    String str2 = i();
    String str3 = X.BInterfaceBravo(NInterfaceAlpha.BInterfaceBravo, " ", "") + ".exe";
    String str4 = null;
    String str5 = null;
    try {
      NInterfaceAlpha.NInterfaceAlpha().KInterfaceEcho();
      i.ExceptionPrintstacktrace();
    } catch (NInterfaceAlpha NInterfaceAlpha) {
      AcInterfaceDelta.BInterfaceBravo("Unable to save user properties.");
    } 
    try {
      if (UICloseInPPackage.NInterfaceAlpha()) {
        str5 = "javaw.exe Staging";
        str4 = "javaw.exe -cp .;./plugins/;lib;./lib/*.jar -Djava.library.path=lib -jar " + str2;
        Runtime.getRuntime().exec(str5 + " \"" + str4 + "\"");
      } else if (UICloseInPPackage.BInterfaceBravo()) {
        File file = new File(".", "runtime/bin/java");
        if (file.exists()) {
          AcInterfaceDelta.AiInterfaceDelta("Bundled Java found, using that for restart.");
          str5 = X.BInterfaceBravo(file.getAbsolutePath(), " ", "\\ ");
          str4 = file.getAbsolutePath() + " -cp .:./plugins/:lib:./lib/*.jar -Djava.library.path=lib -jar " + str2;
          AcInterfaceDelta.AiInterfaceDelta("Bundled Java found, using that for restart. Restart Command:\Isoptimizeddrawingenabled" + str4);
          String[] arrayOfString = { str5, "Staging", str4 };
          Runtime.getRuntime().exec(arrayOfString);
        } else {
          AcInterfaceDelta.AiInterfaceDelta("Bundled Java not found, using standard installed Java.");
          str5 = "/usr/bin/java";
          str4 = "/usr/bin/java -cp \".:plugins/:lib\" -Djava.library.path=lib -jar " + str2;
          String[] arrayOfString = { str5, "Staging", str4 };
          AcInterfaceDelta.DInterfaceCharlie("Restarting with command: '" + str5 + "', then '" + str4);
          Runtime.getRuntime().exec(arrayOfString);
        } 
      } else if (UICloseInPPackage.AiInterfaceDelta()) {
        str5 = "/usr/bin/java";
        str4 = "/usr/bin/java -cp \".:plugins/:lib\" -Djava.library.path=lib -jar " + str2;
        File file1 = new File(".");
        File[] arrayOfFile = file1.listFiles(new PComponentBravo(this));
        if (arrayOfFile.length > 0) {
          File file = null;
          for (File file3 : arrayOfFile) {
            if (file == null || file3.getName().startsWith(NInterfaceAlpha.BInterfaceBravo))
              file = file3; 
          } 
          str4 = file.getCanonicalPath();
        } 
        String[] arrayOfString1 = { str5, "Staging", str4 };
        String[] arrayOfString2 = null;
        File file2 = (new File(".")).getAbsoluteFile();
        AcInterfaceDelta.DInterfaceCharlie("Restarting with command: '" + str5 + "', then '" + str4);
        Runtime.getRuntime().exec(arrayOfString1, arrayOfString2, file2);
      } else {
        str5 = "/usr/bin/java";
        str4 = "/usr/bin/java -cp .:./plugins/:lib:./lib/*.jar -Djava.library.path=lib -jar " + str2;
        String[] arrayOfString = { str5, "Staging", str4 };
        AcInterfaceDelta.DInterfaceCharlie("Restarting 3 with command: '" + str5 + "', then '" + str4);
        Runtime.getRuntime().exec(arrayOfString);
      } 
      Exception();
    } catch (IOException iOException) {
      AcInterfaceDelta.NInterfaceAlpha("Failed to restart Application!", iOException, paramWindow);
    } 
  }
  
  public void SInterfaceJuliet() {
    NInterfaceAlpha(false);
  }
  
  public void NInterfaceAlpha(boolean paramBoolean) {
    String str = null;
    if (!paramBoolean) {
      str = DInterfaceCharlie.NInterfaceAlpha().Isoptimizeddrawingenabled();
      if (str == null || str.equals("")) {
        cc cc = dd.NInterfaceAlpha().SInterfaceJuliet();
        if (cc != null) {
          File file = cc.Abstract();
          if (file != null && file.exists())
            str = file.getAbsolutePath(); 
        } 
      } 
    } 
    if (str == null || str.equals("")) {
      JFrame jFrame = dd.NInterfaceAlpha().DInterfaceCharlie();
      String[] arrayOfString = { "msl", "mlg", "csv" };
      String str1 = "";
      NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
      if (NInterfaceAlpha != null)
        str1 = NInterfaceAlpha.q(); 
      str = bV.BInterfaceBravo(jFrame, "Open Log File", arrayOfString, "", str1);
    } 
    if (str != null && !str.equals(""))
      BInterfaceBravo(str); 
  }
  
  public void BInterfaceBravo(String paramString) {
    UIInBePackage DInterfaceCharlie = new UIInBePackage(this);
    hp hp = new hp(DInterfaceCharlie);
    hp.NInterfaceAlpha(paramString);
  }
  
  public void ThreadedInIPackage() {
    Abstract Abstract = new Abstract(this);
    hp hp = new hp(Abstract);
    hp.DInterfaceCharlie("");
  }
  
  public boolean DInterfaceCharlie(R paramR, String paramString) {
    BInterfaceBravo BInterfaceBravo = new BInterfaceBravo();
    paramR.p().NInterfaceAlpha((GInterfaceAb)BInterfaceBravo);
    try {
      NetworkExceptionprintstacktrace NetworkExceptionprintstacktrace = new NetworkExceptionprintstacktrace();
      NetworkExceptionprintstacktrace.NInterfaceAlpha(paramR, paramString);
      if (BInterfaceBravo.NInterfaceAlpha() > 10) {
        iw iw = new iw(paramR, dd.NInterfaceAlpha().BInterfaceBravo(), BInterfaceBravo.BInterfaceBravo());
        iw.NInterfaceAlpha();
      } 
      paramR.JDialogExtensionInBdPackage();
      String str = "Sending, " + BInterfaceBravo.NInterfaceAlpha() + " bytes.";
      hq.NInterfaceAlpha().NInterfaceAlpha(str);
      AcInterfaceDelta.AiInterfaceDelta("Loaded Restore point " + paramString + "\Isoptimizeddrawingenabled\t" + str);
    } catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
      AcInterfaceDelta.NInterfaceAlpha("Error opening Tune Restore Point.", (Exception)ExceptionPrintstacktrace, dd.NInterfaceAlpha().DInterfaceCharlie());
      return false;
    } catch (GComponentAj GComponentAj) {
      bV.AiInterfaceDelta("Password Protected, Invalid Password!", dd.NInterfaceAlpha().DInterfaceCharlie());
      return false;
    } finally {
      paramR.p().BInterfaceBravo((GInterfaceAb)BInterfaceBravo);
      paramR.JDialogExtensionInBdPackage();
    } 
    paramR.p().ExceptionPrintstacktrace();
    return true;
  }
  
  public void DInterfaceCharlie(String paramString) {
    T t = T.NInterfaceAlpha();
    String[] arrayOfString = t.AiInterfaceDelta();
    for (byte BInterfaceBravo = 0; BInterfaceBravo < arrayOfString.length; BInterfaceBravo++) {
      R BsInterfaceRomeo = t.DInterfaceCharlie(arrayOfString[BInterfaceBravo]);
      AiInterfaceDelta(BsInterfaceRomeo, paramString);
    } 
  }
  
  public File AiInterfaceDelta(R paramR, String paramString) {
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    JFrame jFrame = dd.NInterfaceAlpha().DInterfaceCharlie();
    if (NInterfaceAlpha == null) {
      bV.AiInterfaceDelta("There is no project open.\nPlease open NInterfaceAlpha project first.", jFrame);
      return null;
    } 
    if (NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bJ, NInterfaceAlpha.bK)) {
      iq iq = new iq(paramR.DInterfaceCharlie());
      File file1 = SInterfaceJuliet.NInterfaceAlpha(SInterfaceJuliet.BInterfaceBravo(NInterfaceAlpha), iq);
      if (file1 != null && file1.length() > 4096L) {
        hH hH = new hH();
        if (!hH.NInterfaceAlpha(paramR, file1.getAbsolutePath())) {
          AcInterfaceDelta.AiInterfaceDelta("Skip Restore Point for '" + paramR.DInterfaceCharlie() + "' because nothing changed since: " + file1.getName());
          return file1;
        } 
      } 
    } 
    double AiInterfaceDelta = NInterfaceAlpha.NInterfaceAlpha().NInterfaceAlpha(NInterfaceAlpha.BtInterfaceBh, NInterfaceAlpha.EqualsInGPackage);
    SInterfaceJuliet.NInterfaceAlpha(SInterfaceJuliet.BInterfaceBravo(NInterfaceAlpha), AiInterfaceDelta);
    File file = SInterfaceJuliet.NInterfaceAlpha(NInterfaceAlpha, paramR);
    String str = paramR.Q();
    paramR.v("<html>" + ExceptionPrintstacktrace.BInterfaceBravo("Restore Point") + ": " + paramString + " - <br>" + X.BInterfaceBravo(str, "<html>", ""));
    NetworkExceptionprintstacktrace NetworkExceptionprintstacktrace = new NetworkExceptionprintstacktrace();
    try {
      if (!file.getParentFile().exists())
        file.getParentFile().mkdirs(); 
      NetworkExceptionprintstacktrace.NInterfaceAlpha(paramR, file.getAbsolutePath(), (A)new BsInterfaceOscar());
      hq.NInterfaceAlpha().NInterfaceAlpha(paramR.DInterfaceCharlie() + " Restore point saved");
      AcInterfaceDelta.AiInterfaceDelta(paramR.DInterfaceCharlie() + " Restore point saved to: " + file.getName());
    } catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
      bV.AiInterfaceDelta(ExceptionPrintstacktrace.getMessage(), jFrame);
    } catch (Exception exception) {
      String str1 = "Unhandled error occured saving tune.\nSee log for more detail";
      AcInterfaceDelta.NInterfaceAlpha(str1, exception, jFrame);
    } finally {
      paramR.v(str);
    } 
    return file;
  }
  
  public void AiInterfaceDelta(String paramString) {
    JRootPane jRootPane = dd.NInterfaceAlpha().DInterfaceCharlie().getRootPane();
    if (!(jRootPane.getGlassPane() instanceof dO)) {
      dO dO1 = new dO();
      dO1.BInterfaceBravo(true);
      jRootPane.setGlassPane((Component)dO1);
    } 
    dO dO = (dO)jRootPane.getGlassPane();
    if (paramString != null) {
      paramString = ExceptionPrintstacktrace.BInterfaceBravo(paramString);
      dO.NInterfaceAlpha(paramString);
    } 
    dO.NInterfaceAlpha(false);
    dO.NInterfaceAlpha(ExceptionPrintstacktrace.BInterfaceBravo("Dismiss"), new i(this));
    dO.setVisible(true);
    this.Abstract++;
  }
  
  public void KInterfaceEcho(String paramString) {
    JRootPane jRootPane = dd.NInterfaceAlpha().DInterfaceCharlie().getRootPane();
    if (!(jRootPane.getGlassPane() instanceof dO)) {
      dO dO1 = new dO();
      dO1.BInterfaceBravo(true);
      jRootPane.setGlassPane((Component)dO1);
    } 
    dO dO = (dO)jRootPane.getGlassPane();
    if (paramString != null) {
      paramString = ExceptionPrintstacktrace.BInterfaceBravo(paramString);
      dO.NInterfaceAlpha(paramString);
    } 
    dO.NInterfaceAlpha(true);
    dO.NInterfaceAlpha();
    dO.BInterfaceBravo();
    dO.setVisible(true);
    this.Abstract++;
  }
  
  public void SInterfaceLima() {
    BInterfaceBravo(false);
  }
  
  public void BInterfaceBravo(boolean paramBoolean) {
    JRootPane jRootPane = dd.NInterfaceAlpha().DInterfaceCharlie().getRootPane();
    if (--this.Abstract <= 0 || paramBoolean) {
      this.Abstract = 0;
      if (jRootPane.getGlassPane() instanceof dO) {
        dO dO = (dO)jRootPane.getGlassPane();
        dO.setVisible(false);
      } else {
        AcInterfaceDelta.AiInterfaceDelta("endModalBlock called, but Root Pane is not NInterfaceAlpha ProgressPane.");
      } 
    } else {
      AcInterfaceDelta.AiInterfaceDelta("endModalBlock called, but additional block requests in place.");
    } 
  }
  
  public void NInterfaceAlpha(double paramDouble) {
    JRootPane jRootPane = dd.NInterfaceAlpha().DInterfaceCharlie().getRootPane();
    if (jRootPane.getGlassPane() instanceof dO) {
      dO dO = (dO)jRootPane.getGlassPane();
      dO.NInterfaceAlpha(paramDouble);
    } else {
      AcInterfaceDelta.AiInterfaceDelta("updateModalPercent called, but Root Pane is not NInterfaceAlpha ProgressPane.");
    } 
  }
  
  public void f(String paramString) {
    JRootPane jRootPane = dd.NInterfaceAlpha().DInterfaceCharlie().getRootPane();
    if (jRootPane.getGlassPane() instanceof dO) {
      dO dO = (dO)jRootPane.getGlassPane();
      paramString = ExceptionPrintstacktrace.BInterfaceBravo(paramString);
      dO.NInterfaceAlpha(paramString);
    } else {
      AcInterfaceDelta.AiInterfaceDelta("updateModalPercent called, but Root Pane is not NInterfaceAlpha ProgressPane.");
    } 
  }
  
  public boolean BInterfaceBravo(R paramR) {
    if (NInterfaceAlpha.A() == null) {
      bV.AiInterfaceDelta(ExceptionPrintstacktrace.BInterfaceBravo("No Project Open, cannot save custom.ini"), dd.NInterfaceAlpha().DInterfaceCharlie());
      return false;
    } 
    File file = new File(NInterfaceAlpha.A().ThreadedInIPackage(paramR.DInterfaceCharlie()));
    SInterfaceJuliet SInterfaceJuliet = new SInterfaceJuliet(this);
    P p = P.NInterfaceAlpha();
    p.NInterfaceAlpha(true);
    try {
      p.NInterfaceAlpha(file, paramR, SInterfaceJuliet);
    } catch (IOException iOException) {
      Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, iOException);
      bV.AiInterfaceDelta(ExceptionPrintstacktrace.BInterfaceBravo("Error saving custom.ini") + "\Isoptimizeddrawingenabled" + iOException.getMessage(), dd.NInterfaceAlpha().DInterfaceCharlie());
      return false;
    } 
    return true;
  }
  
  public boolean NInterfaceAlpha(R paramR, List paramList) {
    if (NInterfaceAlpha.A() == null) {
      bV.AiInterfaceDelta(ExceptionPrintstacktrace.BInterfaceBravo("No Project Open, cannot save ECU Definition. "), dd.NInterfaceAlpha().DInterfaceCharlie());
      return false;
    } 
    File file1 = NInterfaceAlpha.A().f(paramR.DInterfaceCharlie());
    File file2 = new File(file1.getParentFile(), file1.getName() + "~");
    try {
      t.NInterfaceAlpha(file1, file2);
    } catch (NInterfaceAlpha NInterfaceAlpha) {
      AcInterfaceDelta.NInterfaceAlpha("Failed to backup " + file1.getName() + ", Error: " + NInterfaceAlpha.getLocalizedMessage());
    } 
    ThreadedInIPackage ThreadedInIPackage = new ThreadedInIPackage(this);
    P p = new P();
    for (O BsInterfaceOscar : paramList)
      p.NInterfaceAlpha(BsInterfaceOscar); 
    p.NInterfaceAlpha(true);
    try {
      p.NInterfaceAlpha(file1, paramR, ThreadedInIPackage);
      file2.delete();
    } catch (IOException iOException) {
      Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, iOException);
      bV.AiInterfaceDelta(ExceptionPrintstacktrace.BInterfaceBravo("Error saving ini") + "\nWill attempt to restore previous file.\Isoptimizeddrawingenabled" + iOException.getMessage(), dd.NInterfaceAlpha().DInterfaceCharlie());
      File file = new File(file1.getParentFile(), "Failed_" + file1.getName());
      file.delete();
      try {
        t.NInterfaceAlpha(file1, file);
      } catch (NInterfaceAlpha NInterfaceAlpha) {
        AcInterfaceDelta.AiInterfaceDelta("Failed to copy failed " + file1.getName() + ", Error: " + NInterfaceAlpha.getLocalizedMessage());
      } 
      if (file2.exists() && file2.length() > 100L) {
        file1.delete();
        try {
          t.NInterfaceAlpha(file2, file1);
          file2.delete();
          bV.AiInterfaceDelta(ExceptionPrintstacktrace.BInterfaceBravo("Previous ini restored."), dd.NInterfaceAlpha().DInterfaceCharlie());
        } catch (NInterfaceAlpha NInterfaceAlpha) {
          AcInterfaceDelta.AiInterfaceDelta("Failed to restore main ini backup " + file1.getName() + ", Error: " + NInterfaceAlpha.getLocalizedMessage());
        } 
      } 
      return false;
    } 
    return true;
  }
  
  public void DInterfaceCharlie(R paramR) {
    String[] arrayOfString = { "" };
    JFrame jFrame = dd.NInterfaceAlpha().DInterfaceCharlie();
    String str1 = NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.O, "");
    String str2 = bV.BInterfaceBravo(jFrame, "Import Channel Updates", arrayOfString, "", str1);
    if (str2 == null || str2.equals(""))
      return; 
    File file = new File(str2);
    NInterfaceAlpha.NInterfaceAlpha().BInterfaceBravo(NInterfaceAlpha.O, file.getParentFile().getAbsolutePath());
    NInterfaceAlpha NInterfaceAlpha = new NInterfaceAlpha();
    try {
      NInterfaceAlpha.NInterfaceAlpha(paramR, file, false);
      ArrayList<KInterfaceEcho> arrayList = new ArrayList();
      arrayList.add(new KInterfaceEcho());
      NInterfaceAlpha(paramR, arrayList);
      KInterfaceEcho KInterfaceEcho = new KInterfaceEcho(paramR);
      KInterfaceEcho.NInterfaceAlpha(paramR);
      ManagerUsingArrayList.NInterfaceAlpha().NInterfaceAlpha(paramR);
    } catch (IOException iOException) {
      bV.AiInterfaceDelta(ExceptionPrintstacktrace.BInterfaceBravo("Error saving ECU Definition") + "\Isoptimizeddrawingenabled" + iOException.getMessage(), dd.NInterfaceAlpha().DInterfaceCharlie());
    } 
  }
  
  public void AiInterfaceDelta(R paramR) {
    String[] arrayOfString = { "" };
    JFrame jFrame = dd.NInterfaceAlpha().DInterfaceCharlie();
    String str1 = NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.O, "");
    String str2 = bV.BInterfaceBravo(jFrame, "Import Calibration Updates", arrayOfString, "", str1);
    if (str2 == null || str2.equals(""))
      return; 
    File file = new File(str2);
    NInterfaceAlpha.NInterfaceAlpha().BInterfaceBravo(NInterfaceAlpha.O, file.getParentFile().getAbsolutePath());
    DInterfaceCharlie DInterfaceCharlie = new DInterfaceCharlie();
    try {
      List list = DInterfaceCharlie.NInterfaceAlpha(file);
      ArrayList<NInterfaceAlpha> arrayList = new ArrayList();
      arrayList.add(new NInterfaceAlpha(list));
      NInterfaceAlpha(paramR, arrayList);
    } catch (IOException iOException) {
      bV.AiInterfaceDelta(ExceptionPrintstacktrace.BInterfaceBravo("Error saving ECU Definition") + "\Isoptimizeddrawingenabled" + iOException.getMessage(), dd.NInterfaceAlpha().DInterfaceCharlie());
    } 
  }
  
  public void BInterfaceBravo(Frame paramFrame) {
    UIInBePackage DInterfaceCharlie = new UIInBePackage();
    DInterfaceCharlie.NInterfaceAlpha(T.NInterfaceAlpha().DInterfaceCharlie());
    DInterfaceCharlie.NInterfaceAlpha(paramFrame);
  }
  
  public void NetworkInBPackage() {
    T t = T.NInterfaceAlpha();
    String[] arrayOfString = t.AiInterfaceDelta();
    for (byte BInterfaceBravo = 0; BInterfaceBravo < arrayOfString.length; BInterfaceBravo++) {
      R BsInterfaceRomeo = t.DInterfaceCharlie(arrayOfString[BInterfaceBravo]);
      KInterfaceEcho(BsInterfaceRomeo);
      String str = (String)this.f.get(arrayOfString[BInterfaceBravo]);
      if (str == null && NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bw, true))
        str = NInterfaceAlpha.A().DInterfaceCharlie(arrayOfString[BInterfaceBravo]).getAbsolutePath(); 
      if (str != null)
        KInterfaceEcho(BsInterfaceRomeo, str); 
      if (str == null || NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bx, NInterfaceAlpha.by))
        KInterfaceEcho(dd.NInterfaceAlpha().DInterfaceCharlie()); 
    } 
    if (i.NInterfaceAlpha().NInterfaceAlpha("-=fds[pfds[pgd-0") && NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bB, NInterfaceAlpha.bC)) {
      String str = "User Requested Save of Settings";
      DInterfaceCharlie(str);
    } 
  }
  
  public void NInterfaceAlpha(R paramR, String paramString, List paramList) {
    JFrame jFrame = dd.NInterfaceAlpha().DInterfaceCharlie();
    String[] arrayOfString = new String[1];
    String str1 = NInterfaceAlpha.NInterfaceAlpha().NInterfaceAlpha("tuneFileExt", NInterfaceAlpha.cw) + NInterfaceAlpha.cy;
    arrayOfString[0] = str1;
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    if (NInterfaceAlpha == null) {
      bV.AiInterfaceDelta("There is no project open.\nPlease open NInterfaceAlpha project first.", jFrame);
      return;
    } 
    String str2 = NInterfaceAlpha.Exception();
    String str3 = paramString + "_" + X.NInterfaceAlpha() + "." + str1;
    str3 = bV.NInterfaceAlpha(jFrame, "Save Dialog Tune Settings", arrayOfString, str3, str2, null);
    if (str3 != null && str3.length() > 0) {
      AcInterfaceDelta.DInterfaceCharlie("Save partial msq to: " + str3);
      if (!str3.endsWith(str1))
        str3 = str3 + "." + str1; 
      BInterfaceBravo(paramR, str3, paramList);
    } 
  }
  
  public void KInterfaceEcho(R paramR, String paramString) {
    Abstract(paramR);
    BInterfaceBravo(paramR, paramString, null);
    i(paramR);
  }
  
  public void BInterfaceBravo(R paramR, String paramString, List paramList) {
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    JFrame jFrame = dd.NInterfaceAlpha().DInterfaceCharlie();
    if (NInterfaceAlpha == null) {
      bV.AiInterfaceDelta("There is no project open.\nPlease open NInterfaceAlpha project first.", jFrame);
      return;
    } 
    String str = paramString.substring(0, paramString.lastIndexOf(File.separatorChar));
    NInterfaceAlpha.ExceptionPrintstacktrace(str);
    File file = new File(paramString);
    UIInBePackage.NInterfaceAlpha().DInterfaceCharlie(file);
    if (paramString.endsWith(NInterfaceAlpha.UIInBePackage)) {
      IOExceptioninvpackageInWPackage IOExceptioninvpackageInWPackage = new IOExceptioninvpackageInWPackage();
      try {
        IOExceptioninvpackageInWPackage.NInterfaceAlpha(paramString, paramR);
      } catch (IOException iOException) {
        Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, iOException);
        bV.AiInterfaceDelta("Error Saving Tune.\Isoptimizeddrawingenabled" + iOException.getMessage(), jFrame);
        return;
      } 
    } else {
      NetworkExceptionprintstacktrace NetworkExceptionprintstacktrace = new NetworkExceptionprintstacktrace();
      boolean bool = false;
      try {
        bool = IOInWPackage.BInterfaceBravo(NInterfaceAlpha.SInterfaceJuliet());
      } catch (Exception exception) {
        exception.printStackTrace();
      } 
      try {
        boolean bool1 = NetworkExceptionprintstacktrace.AiInterfaceDelta;
        if (bool)
          NetworkExceptionprintstacktrace.AiInterfaceDelta = bool; 
        NetworkExceptionprintstacktrace.NInterfaceAlpha(paramR, paramString, (A)new BsInterfaceOscar(), paramList);
        NetworkExceptionprintstacktrace.AiInterfaceDelta = bool1;
        if (!paramString.contains("CurrentTune"))
          dd.NInterfaceAlpha().f().BInterfaceBravo(paramString); 
        if (paramList == null) {
          hq.NInterfaceAlpha().NInterfaceAlpha(paramR.DInterfaceCharlie() + " Tune Saved!");
        } else {
          hq.NInterfaceAlpha().NInterfaceAlpha(paramR.DInterfaceCharlie() + " Dialog settings Saved!");
        } 
        ManagerBfcomponentcharlie.NInterfaceAlpha().DInterfaceCharlie();
      } catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
        bV.AiInterfaceDelta(ExceptionPrintstacktrace.getMessage(), jFrame);
      } catch (Exception exception) {
        String str1 = "Unhandled error occured saving tune.\nSee log for more detail";
        AcInterfaceDelta.NInterfaceAlpha(str1, exception, jFrame);
      } 
    } 
    paramR.p().ExceptionPrintstacktrace();
    UIInBePackage.NInterfaceAlpha().AiInterfaceDelta(file);
    this.f.put(paramR.DInterfaceCharlie(), paramString);
  }
  
  public void Isoptimizeddrawingenabled() {
    try {
      if (NInterfaceAlpha.A() != null && NInterfaceAlpha.A().AcInterfaceDelta().size() > 0)
        for (R BsInterfaceRomeo : NInterfaceAlpha.A().AcInterfaceDelta())
          KInterfaceEcho(BsInterfaceRomeo);  
    } catch (Exception exception) {
      AcInterfaceDelta.NInterfaceAlpha("Problem saving CurrentTune files, stack to follow.");
      exception.printStackTrace();
    } 
  }
  
  public void KInterfaceEcho(R paramR) {
    NInterfaceAlpha(paramR, false);
  }
  
  public File NInterfaceAlpha(R paramR, boolean paramBoolean) {
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    JFrame jFrame = dd.NInterfaceAlpha().DInterfaceCharlie();
    if (NInterfaceAlpha == null) {
      AcInterfaceDelta.BInterfaceBravo("Request to save offline tune when project is null!");
      return null;
    } 
    NetworkExceptionprintstacktrace.AiInterfaceDelta = IOInWPackage.BInterfaceBravo(NInterfaceAlpha.SInterfaceJuliet());
    if (!paramBoolean && (NInterfaceAlpha.AcInterfaceUniform(NInterfaceAlpha.t()) || !NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.bw, true)))
      return null; 
    String str = NInterfaceAlpha.DInterfaceCharlie(paramR.DInterfaceCharlie()).getAbsolutePath();
    File file = new File(str);
    UIInBePackage.NInterfaceAlpha().DInterfaceCharlie(file);
    NetworkExceptionprintstacktrace NetworkExceptionprintstacktrace = new NetworkExceptionprintstacktrace();
    try {
      NetworkExceptionprintstacktrace.NInterfaceAlpha(paramR, str, (A)new BsInterfaceOscar());
    } catch (ExceptionPrintstacktrace ExceptionPrintstacktrace) {
      bV.AiInterfaceDelta(ExceptionPrintstacktrace.getMessage(), jFrame);
    } catch (Exception exception) {
      String str1 = "Unhandled error occured saving offline tune.\nSee log for more detail";
      AcInterfaceDelta.NInterfaceAlpha(str1, exception, jFrame);
    } finally {
      UIInBePackage.NInterfaceAlpha().AiInterfaceDelta(file);
    } 
    return new File(str);
  }
  
  public void KInterfaceEcho(Window paramWindow) {
    String[] arrayOfString = new String[1];
    arrayOfString[0] = NInterfaceAlpha.NInterfaceAlpha().NInterfaceAlpha("tuneFileExt", NInterfaceAlpha.cw);
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    T t = T.NInterfaceAlpha();
    if (NInterfaceAlpha == null) {
      bV.AiInterfaceDelta("There is no project open.\nPlease open NInterfaceAlpha project first.", paramWindow);
      return;
    } 
    String str1 = NInterfaceAlpha.Exception();
    String str2 = X.NInterfaceAlpha() + "." + NInterfaceAlpha.cw;
    ac ac = new ac(t.AiInterfaceDelta(), NInterfaceAlpha.AcInterfaceUniform());
    ac.DInterfaceCharlie("Select Controller to save tune for.");
    str2 = bV.NInterfaceAlpha(paramWindow, "Save Tune Configuration", arrayOfString, str2, str1, (ck)ac);
    if (str2 == null || str2.equals(""))
      return; 
    File file = new File(str2);
    String str3 = ExceptionPrintstacktrace.BInterfaceBravo("File already exists!") + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Are you sure you want to over write this file?") + "\Isoptimizeddrawingenabled\Isoptimizeddrawingenabled" + file.getName();
    if (file.exists() && !bV.NInterfaceAlpha(str3, paramWindow, true))
      return; 
    if (str2 != null && str2.length() > 0) {
      AcInterfaceDelta.DInterfaceCharlie("EcuConfigName for Save:" + ac.NInterfaceAlpha());
      if (!str2.endsWith(NInterfaceAlpha.cw) && !str2.endsWith(NInterfaceAlpha.UIInBePackage))
        str2 = str2 + "." + NInterfaceAlpha.cw; 
      R BsInterfaceRomeo = t.DInterfaceCharlie(ac.NInterfaceAlpha());
      KInterfaceEcho(BsInterfaceRomeo, str2);
    } 
  }
  
  public void DInterfaceCharlie(Frame paramFrame) {
    String[] arrayOfString = { "msl" };
    String str1 = X.NInterfaceAlpha() + "." + NInterfaceAlpha.cs;
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    if (NInterfaceAlpha == null || NInterfaceAlpha.q() == null) {
      bV.AiInterfaceDelta("There is no project open.\nPlease open NInterfaceAlpha project first.", paramFrame);
      return;
    } 
    R BsInterfaceRomeo = T.NInterfaceAlpha().DInterfaceCharlie();
    if (BsInterfaceRomeo == null || BsInterfaceRomeo.Abstract().Abstract()) {
      String str = ExceptionPrintstacktrace.BInterfaceBravo("Attention!!") + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("There is no tune loaded.") + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Before generating NInterfaceAlpha log file, it is recommended to either load an (" + NInterfaceAlpha.cw + ") or connect to NInterfaceAlpha controller.") + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Otherwise some field values will be incorrect.") + "\Isoptimizeddrawingenabled\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Would you like to process this log file anyway?");
      boolean bool1 = bV.NInterfaceAlpha(str, paramFrame, true);
      if (!bool1)
        return; 
    } 
    String str2 = NInterfaceAlpha.q();
    str1 = bV.NInterfaceAlpha(paramFrame, "Target Data Log file name", arrayOfString, str1, str2);
    if (str1 == null || str1.equals(""))
      return; 
    str2 = str1.substring(0, str1.lastIndexOf(File.separatorChar));
    NInterfaceAlpha.SInterfaceJuliet(str2);
    if (!str1.endsWith("." + NInterfaceAlpha.cs))
      str1 = str1 + "." + NInterfaceAlpha.cs; 
    File file = new File(str1);
    boolean bool = BsInterfaceRomeo.UIInBePackage().q();
    BsInterfaceRomeo.UIInBePackage().DInterfaceCharlie();
    AvInterfaceXray AvInterfaceXray = dd.NInterfaceAlpha().BInterfaceBravo();
    if (AvInterfaceXray != null)
      AvInterfaceXray.ThreadedInIPackage(ExceptionPrintstacktrace.BInterfaceBravo("Palm Extract Mode")); 
    aY.f f1 = new aY.f(paramFrame, BsInterfaceRomeo, file, true);
    bV.NInterfaceAlpha(paramFrame, (Component)f1);
    f1.setVisible(true);
    f1.DInterfaceCharlie();
    if (AvInterfaceXray != null)
      AvInterfaceXray.ThreadedInIPackage(ExceptionPrintstacktrace.BInterfaceBravo("Not Connected")); 
    if (bool)
      try {
        BsInterfaceRomeo.UIInBePackage().AiInterfaceDelta();
      } catch (SInterfaceLima SInterfaceLima) {
        AcInterfaceDelta.BInterfaceBravo("failed to go back online");
      }  
    System.out.println("Palm Extract Dialog Closed");
  }
  
  public void AiInterfaceDelta(Frame paramFrame) {
    String[] arrayOfString1 = new String[2];
    arrayOfString1[0] = NInterfaceAlpha.ManagerUsingArrayList;
    arrayOfString1[1] = NInterfaceAlpha.cv;
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    if (NInterfaceAlpha == null) {
      bV.AiInterfaceDelta("There is no project open.\nPlease open NInterfaceAlpha project first.", paramFrame);
      return;
    } 
    R BsInterfaceRomeo = T.NInterfaceAlpha().DInterfaceCharlie();
    if (BsInterfaceRomeo == null || BsInterfaceRomeo.Abstract().Abstract()) {
      String str1 = "Attention!!\nThere is no tune loaded. Before generating NInterfaceAlpha log file,\nit is recommended to either load an (" + NInterfaceAlpha.cw + ") or connect to NInterfaceAlpha controller.\nOtherwise some field values will be incorrect.\Isoptimizeddrawingenabled\nWould you like to process this log file anyway?";
      boolean bool = bV.NInterfaceAlpha(str1, paramFrame, true);
      if (!bool)
        return; 
    } 
    String str = NInterfaceAlpha.ThreadedInIPackage();
    String[] arrayOfString2 = null;
    arrayOfString2 = bV.NInterfaceAlpha(paramFrame, "Transform Raw DataLog", arrayOfString1, "", str, true, (ck)null, true);
    if (arrayOfString2 == null || arrayOfString2.length == 0 || arrayOfString2[0] == null)
      return; 
    try {
      String str1 = arrayOfString2[0].substring(0, arrayOfString2[0].lastIndexOf(File.separator));
      NInterfaceAlpha.KInterfaceEcho(str1);
    } catch (Exception exception) {
      AcInterfaceDelta.BInterfaceBravo("Unable to save Log File Folder for:" + arrayOfString2);
    } 
    NInterfaceAlpha(paramFrame, arrayOfString2);
  }
  
  public WInterfaceAa NInterfaceAlpha(Window paramWindow, String[] paramArrayOfString) {
    WInterfaceAa WInterfaceAa = new WInterfaceAa();
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    if (NInterfaceAlpha == null) {
      bV.AiInterfaceDelta("There is no project open.\nPlease open NInterfaceAlpha project first.", paramWindow);
      return WInterfaceAa;
    } 
    ArrayList arrayList = NInterfaceAlpha.A().AcInterfaceDelta();
    R[] arrayOfR = new R[arrayList.size()];
    arrayOfR = (R[])arrayList.toArray((Object[])arrayOfR);
    bR bR = new bR(paramWindow, arrayOfR);
    for (byte BInterfaceBravo = 0; BInterfaceBravo < paramArrayOfString.length; BInterfaceBravo++) {
      File file = new File(paramArrayOfString[BInterfaceBravo]);
      String str = X.NInterfaceAlpha();
      if (!paramArrayOfString[BInterfaceBravo].toLowerCase().endsWith("mlg") && !paramArrayOfString[BInterfaceBravo].toLowerCase().endsWith("csv") && !paramArrayOfString[BInterfaceBravo].toLowerCase().endsWith("msl")) {
        if (paramArrayOfString[BInterfaceBravo].toLowerCase().endsWith("ms3"))
          try {
            Date date1 = IOExceptioninvpackage.NInterfaceAlpha(file);
            Calendar calendar = Calendar.getInstance();
            calendar.set(2010, 0, 1);
            Date date2 = calendar.getTime();
            if (date1.after(date2))
              str = X.NInterfaceAlpha(date1); 
          } catch (Exception exception) {
            exception.printStackTrace();
          }  
        String str1 = paramArrayOfString[BInterfaceBravo].substring(paramArrayOfString[BInterfaceBravo].lastIndexOf(File.separator) + 1);
        if (str1.indexOf(".") != -1)
          str1 = str1.substring(0, str1.lastIndexOf(".")); 
        String str2 = NInterfaceAlpha.cs;
        str1 = str + "_" + str1 + "." + str2;
        String str3 = paramArrayOfString[BInterfaceBravo].substring(0, paramArrayOfString[BInterfaceBravo].lastIndexOf(File.separator) + 1) + str1;
        if (str3.lastIndexOf(File.separator) != -1)
          str3 = str3.substring(str3.lastIndexOf(File.separator)); 
        str3 = NInterfaceAlpha.q() + File.separator + str3;
        File file1 = new File(str3);
        bR.NInterfaceAlpha(file, file1);
      } 
    } 
    if (!bR.Abstract.isEmpty()) {
      File[] arrayOfFile = new File[bR.Abstract.size()];
      byte b1;
      for (b1 = 0; b1 < arrayOfFile.length; b1++)
        arrayOfFile[b1] = ((bU)bR.Abstract.get(b1)).BInterfaceBravo(); 
      arrayOfFile = NInterfaceAlpha(paramWindow, arrayOfFile);
      for (b1 = 0; b1 < arrayOfFile.length; b1++)
        ((bU)bR.Abstract.get(b1)).BInterfaceBravo(arrayOfFile[b1]); 
      bR.start();
    } else {
      File[] arrayOfFile = new File[paramArrayOfString.length];
      for (byte b1 = 0; b1 < arrayOfFile.length; b1++)
        arrayOfFile[b1] = new File(paramArrayOfString[b1]); 
      arrayOfFile = NInterfaceAlpha(paramWindow, arrayOfFile);
      if (bV.NInterfaceAlpha(ExceptionPrintstacktrace.BInterfaceBravo("File(Exception) ready for viewing, would you like to open it now?"), dd.NInterfaceAlpha().DInterfaceCharlie(), true))
        NInterfaceAlpha().NInterfaceAlpha(arrayOfFile); 
    } 
    return WInterfaceAa;
  }
  
  private File[] NInterfaceAlpha(Window paramWindow, File[] paramArrayOfFile) {
    if (NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.ca, NInterfaceAlpha.GComponentCb)) {
      String str1 = ExceptionPrintstacktrace.BInterfaceBravo("Rename Log Files");
      String str2 = ExceptionPrintstacktrace.BInterfaceBravo("Set the log file names downloaded to the Project DataLog Folder.");
      JDialogExtensionInBdPackage i = new JDialogExtensionInBdPackage(paramWindow, str1, str2);
      return i.NInterfaceAlpha(paramArrayOfFile);
    } 
    return paramArrayOfFile;
  }
  
  public void f(Window paramWindow) {
    if (i.NInterfaceAlpha().NInterfaceAlpha(";'rew-043;lh/lhoi")) {
      if (!NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.ce, NInterfaceAlpha.cf).equals(NInterfaceAlpha.bY)) {
        ExceptionPrintstacktrace(paramWindow);
        try {
          BsInterfaceOscar();
        } catch (NInterfaceAlpha NInterfaceAlpha) {
          bV.AiInterfaceDelta(NInterfaceAlpha.getLocalizedMessage(), paramWindow);
        } 
      } else {
        ExceptionPrintstacktrace(paramWindow);
        String str1 = NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.cA, NInterfaceAlpha.cB);
        String[] arrayOfString = new String[2];
        if (str1.equals(NInterfaceAlpha.cs)) {
          arrayOfString[0] = NInterfaceAlpha.cs;
          arrayOfString[1] = NInterfaceAlpha.cr;
        } else {
          arrayOfString[0] = NInterfaceAlpha.cr;
          arrayOfString[1] = NInterfaceAlpha.cs;
        } 
        String str2 = X.NInterfaceAlpha() + "." + str1;
        NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
        if (NInterfaceAlpha == null || NInterfaceAlpha.q() == null) {
          bV.AiInterfaceDelta("There is no project open.\nPlease open NInterfaceAlpha project first.", paramWindow);
          return;
        } 
        String str3 = NInterfaceAlpha.q();
        str2 = bV.NInterfaceAlpha(paramWindow, "Start New Data Log", arrayOfString, str2, str3);
        if (str2 == null || str2.equals(""))
          return; 
        if (!str2.toLowerCase().endsWith(NInterfaceAlpha.cr) && !str2.toLowerCase().endsWith(NInterfaceAlpha.cs) && !str2.toLowerCase().endsWith(".frd") && !str2.toLowerCase().endsWith(".mlg"))
          str2 = str2 + "." + str1; 
        str3 = str2.substring(0, str2.lastIndexOf(File.separatorChar));
        NInterfaceAlpha.SInterfaceJuliet(str3);
        ExceptionPrintstacktrace(str2);
      } 
    } else {
      bV.AiInterfaceDelta("Data Logging is not enabled in this edition of " + NInterfaceAlpha.BInterfaceBravo + "\Isoptimizeddrawingenabled\nUpgrade Now!", paramWindow);
    } 
  }
  
  public void BsInterfaceOscar() {
    if (i.NInterfaceAlpha().NInterfaceAlpha(";'rew-043;lh/lhoi")) {
      String str1 = NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.cA, NInterfaceAlpha.cB);
      String str2 = X.NInterfaceAlpha() + "." + str1;
      NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
      if (NInterfaceAlpha == null || NInterfaceAlpha.q() == null)
        throw new NInterfaceAlpha("There is no project open. Please open NInterfaceAlpha project first."); 
      String str3 = NInterfaceAlpha.q();
      str2 = (new File(str3, str2)).getAbsolutePath();
      if (str2 == null || str2.equals(""))
        return; 
      str3 = str2.substring(0, str2.lastIndexOf(File.separatorChar));
      NInterfaceAlpha.SInterfaceJuliet(str3);
      ExceptionPrintstacktrace(str2);
    } else {
      bV.AiInterfaceDelta("Data Logging is not enabled in this edition of " + NInterfaceAlpha.BInterfaceBravo + "\Isoptimizeddrawingenabled\nUpgrade Now!", dd.NInterfaceAlpha().DInterfaceCharlie());
    } 
  }
  
  public File ExceptionPrintstacktrace(String paramString) {
    T t = T.NInterfaceAlpha();
    String str = NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.cA, NInterfaceAlpha.cB);
    if (!paramString.toLowerCase().endsWith("." + str) && !paramString.toLowerCase().endsWith(".msl") && !paramString.toLowerCase().endsWith(".csv") && !paramString.toLowerCase().endsWith(".frd") && !paramString.toLowerCase().endsWith(".mlg"))
      paramString = paramString + "." + str; 
    String[] arrayOfString = t.AiInterfaceDelta();
    ArrayList<String> arrayList = new ArrayList();
    for (byte BInterfaceBravo = 0; BInterfaceBravo < arrayOfString.length; BInterfaceBravo++) {
      R BsInterfaceRomeo = t.DInterfaceCharlie(arrayOfString[BInterfaceBravo]);
      if (BInterfaceBravo == 0 || (!BsInterfaceRomeo.O().WInterfaceAp() && BsInterfaceRomeo.S()))
        arrayList.add(arrayOfString[BInterfaceBravo]); 
    } 
    arrayOfString = arrayList.<String>toArray(new String[arrayList.size()]);
    try {
      DInterfaceCharlie DInterfaceCharlie;
      KInterfaceEcho KInterfaceEcho = null;
      if (paramString.endsWith(".frd")) {
        KInterfaceEcho = KInterfaceEcho.NInterfaceAlpha();
      } else if (paramString.toLowerCase().endsWith(".mlg")) {
        AcInterfaceUniform AcInterfaceUniform = AcInterfaceUniform.NInterfaceAlpha();
      } else {
        DInterfaceCharlie c1 = DInterfaceCharlie.NInterfaceAlpha();
        DInterfaceCharlie = c1;
        String str1 = NInterfaceAlpha.NInterfaceAlpha().NInterfaceAlpha(NInterfaceAlpha.aK, "\t");
        c1.DInterfaceCharlie(str1);
      } 
      i.BInterfaceBravo();
      if (DInterfaceCharlie.AcInterfaceUniform()) {
        hq.NInterfaceAlpha().NInterfaceAlpha(ExceptionPrintstacktrace.BInterfaceBravo("Already Logging."));
        return new File(DInterfaceCharlie.Isoptimizeddrawingenabled());
      } 
      DInterfaceCharlie.i();
      if (AvInterfaceXray.NInterfaceAlpha().DInterfaceCharlie() && AvInterfaceXray.NInterfaceAlpha().ExceptionPrintstacktrace() != null) {
        List list = ExceptionPrintstacktrace.NInterfaceAlpha();
        Iterator<NInterfaceAlpha> iterator = list.iterator();
        while (iterator.hasNext())
          DInterfaceCharlie.NInterfaceAlpha(iterator.next()); 
      } 
      for (AcInterfaceDelta AiInterfaceDelta : BInterfaceBravo.NInterfaceAlpha())
        DInterfaceCharlie.NInterfaceAlpha((NInterfaceAlpha)AiInterfaceDelta); 
      if (NInterfaceAlpha.A() != null) {
        NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
        String str1 = NInterfaceAlpha.O();
        String[] arrayOfString1 = NInterfaceAlpha.w(str1);
        DInterfaceCharlie.NInterfaceAlpha(arrayOfString1);
      } 
      if (Runtime.getRuntime().availableProcessors() == 1 && Integer.parseInt(T.NInterfaceAlpha().DInterfaceCharlie().UICloseInPPackage()) > 20)
        T.NInterfaceAlpha().DInterfaceCharlie().DInterfaceCharlie(20); 
      try {
        SInterfaceJuliet SInterfaceJuliet = BInterfaceBravo.NInterfaceAlpha().NInterfaceAlpha(t.DInterfaceCharlie().DInterfaceCharlie(), BInterfaceBravo.BInterfaceBravo);
        if (SInterfaceJuliet != null)
          SInterfaceJuliet.BInterfaceBravo(true); 
      } catch (Exception exception) {
        AcInterfaceDelta.NInterfaceAlpha("Error trying to reset Log Stop Trigger. " + exception.getLocalizedMessage());
      } 
      DInterfaceCharlie.NInterfaceAlpha(arrayOfString, paramString);
      hq.NInterfaceAlpha().NInterfaceAlpha("Capturing DataLog");
      return new File(DInterfaceCharlie.Isoptimizeddrawingenabled());
    } catch (Exception exception) {
      bV.AiInterfaceDelta("Failed to start log file. Error:\Isoptimizeddrawingenabled" + exception.getMessage(), dd.NInterfaceAlpha().DInterfaceCharlie());
      exception.printStackTrace();
      return null;
    } 
  }
  
  public void p() {
    Abstract Abstract = Abstract.ThreadedInIPackage();
    if (Abstract != null && Abstract.AcInterfaceUniform()) {
      Abstract.AiInterfaceDelta("Manual");
      hq.NInterfaceAlpha().NInterfaceAlpha("Manual MARK");
    } 
  }
  
  private void W() {
    Isoptimizeddrawingenabled Isoptimizeddrawingenabled = hx.NInterfaceAlpha().BsInterfaceRomeo();
    if (Isoptimizeddrawingenabled != null && Isoptimizeddrawingenabled.Abstract() && Isoptimizeddrawingenabled.ThreadedInIPackage() != null && Isoptimizeddrawingenabled.ThreadedInIPackage().exists())
      try {
        if (Isoptimizeddrawingenabled.ThreadedInIPackage().getAbsolutePath().toLowerCase().endsWith(".mlg")) {
          AcInterfaceYankee.NInterfaceAlpha(Isoptimizeddrawingenabled, Isoptimizeddrawingenabled.ThreadedInIPackage().getAbsolutePath());
        } else {
          BsInterfaceOscar.BInterfaceBravo(Isoptimizeddrawingenabled, Isoptimizeddrawingenabled.ThreadedInIPackage().getAbsolutePath(), i.v);
        } 
      } catch (IOException iOException) {
        iOException.printStackTrace();
      } catch (NInterfaceAlpha NInterfaceAlpha) {
        NInterfaceAlpha.printStackTrace();
        bV.AiInterfaceDelta(NInterfaceAlpha.getLocalizedMessage(), bV.DInterfaceCharlie());
      }  
  }
  
  public void q() {
    KInterfaceEcho KInterfaceEcho;
    AcInterfaceUniform AcInterfaceUniform;
    DInterfaceCharlie DInterfaceCharlie = DInterfaceCharlie.NInterfaceAlpha();
    if (!DInterfaceCharlie.AcInterfaceUniform())
      KInterfaceEcho = KInterfaceEcho.NInterfaceAlpha(); 
    if (!KInterfaceEcho.AcInterfaceUniform())
      AcInterfaceUniform = AcInterfaceUniform.NInterfaceAlpha(); 
    if (AcInterfaceUniform.AcInterfaceUniform())
      try {
        AcInterfaceUniform.SInterfaceLima();
        W();
        hq.NInterfaceAlpha().NInterfaceAlpha("Data log stopped");
      } catch (Exception exception) {
        Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, exception);
      }  
  }
  
  public void ExceptionPrintstacktrace(Window paramWindow) {
    KInterfaceEcho KInterfaceEcho;
    AcInterfaceUniform AcInterfaceUniform;
    T t = T.NInterfaceAlpha();
    R BsInterfaceRomeo = t.DInterfaceCharlie();
    DInterfaceCharlie DInterfaceCharlie = DInterfaceCharlie.NInterfaceAlpha();
    if (!DInterfaceCharlie.AcInterfaceUniform())
      KInterfaceEcho = KInterfaceEcho.NInterfaceAlpha(); 
    if (!KInterfaceEcho.AcInterfaceUniform())
      AcInterfaceUniform = AcInterfaceUniform.NInterfaceAlpha(); 
    try {
      if (AcInterfaceUniform.AcInterfaceUniform()) {
        String str = AcInterfaceUniform.Isoptimizeddrawingenabled();
        AcInterfaceUniform.SInterfaceLima();
        W();
        hq.NInterfaceAlpha().NInterfaceAlpha("Data log stopped");
        if (T.NInterfaceAlpha().DInterfaceCharlie() != null && NInterfaceAlpha.A() != null) {
          int i = 15;
          try {
            i = NInterfaceAlpha.A().DInterfaceCharlie(T.NInterfaceAlpha().DInterfaceCharlie().O().as());
          } catch (Exception exception) {}
          T.NInterfaceAlpha().DInterfaceCharlie().DInterfaceCharlie(i);
        } 
        if (NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.ce, NInterfaceAlpha.cf).equals(NInterfaceAlpha.bX) && str != null && !str.isEmpty()) {
          File file = new File(str);
          String str1 = ExceptionPrintstacktrace.BInterfaceBravo("File already exists.");
          str1 = str1 + ExceptionPrintstacktrace.BInterfaceBravo("Overwrite File?");
          str1 = str1 + "\Isoptimizeddrawingenabled";
          if (file.exists() && file.length() > 1000L) {
            File file1;
            String str2 = NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.cA, NInterfaceAlpha.cB);
            String[] arrayOfString = { str2 };
            do {
              String str3 = bV.NInterfaceAlpha(paramWindow, "Rename Data Log File", arrayOfString, str, file.getParent());
              if (str3 == null || str3.equals(""))
                return; 
              if (!str3.toLowerCase().endsWith(str2))
                str3 = str3 + "." + str2; 
              file1 = new File(str3);
            } while (file1.exists() && !file1.equals(file) && !bV.NInterfaceAlpha(str1 + file1.getName(), paramWindow, true));
            if (!file1.equals(file)) {
              if (file1.exists())
                file1.delete(); 
              if (file.renameTo(file1)) {
                hq.NInterfaceAlpha().NInterfaceAlpha("Data log saved as " + file1.getName());
                AcInterfaceUniform.NInterfaceAlpha(file1);
                DInterfaceCharlie.NInterfaceAlpha().NInterfaceAlpha(file.getAbsolutePath(), file1.getAbsolutePath());
              } else {
                hq.NInterfaceAlpha().NInterfaceAlpha("Unable to rename Data log");
              } 
            } 
          } 
        } 
      } 
    } catch (Exception exception) {
      AcInterfaceDelta.BInterfaceBravo("Something happened stopping the log??? " + exception.getMessage());
    } 
  }
  
  public void BsInterfaceRomeo() {
    JFrame jFrame = dd.NInterfaceAlpha().DInterfaceCharlie();
    if (jFrame instanceof dl)
      ((dl)jFrame).ThreadedInIPackage(); 
  }
  
  public boolean Exception() {
    if (!ExceptionPrintstacktrace())
      return false; 
    NInterfaceAlpha().AcInterfaceYankee();
    System.exit(0);
    return true;
  }
  
  public boolean t() {
    if (this.BInterfaceBravo)
      return true; 
    this.BInterfaceBravo = true;
    SInterfaceLima SInterfaceLima = new SInterfaceLima(this);
    try {
      if (!SwingUtilities.isEventDispatchThread()) {
        SwingUtilities.invokeAndWait(SInterfaceLima);
      } else {
        SInterfaceLima.run();
      } 
    } catch (InterruptedException interruptedException) {
      Logger.getLogger(f.class.getName()).log(Level.SEVERE, "Error waiting for shutdown", interruptedException);
    } catch (InvocationTargetException invocationTargetException) {
      Logger.getLogger(f.class.getName()).log(Level.SEVERE, "Error on shutdown command", invocationTargetException);
    } 
    return true;
  }
  
  public ad KInterfaceEcho(Frame paramFrame) {
    paramFrame.setCursor(Cursor.getPredefinedCursor(3));
    try {
      ad ad = new ad();
      NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
      if (NInterfaceAlpha != null) {
        String str = NInterfaceAlpha.UIInBePackage();
        if (str == null || str.length() == 0)
          str = NInterfaceAlpha.ba; 
        ad.DInterfaceCharlie(str);
      } 
      ad.NInterfaceAlpha(true);
      ad.NInterfaceAlpha(paramFrame);
      return ad;
    } finally {
      paramFrame.setCursor(Cursor.getDefaultCursor());
    } 
  }
  
  public void f(Frame paramFrame) {
    boolean bool1 = false;
    R BsInterfaceRomeo = T.NInterfaceAlpha().DInterfaceCharlie();
    if (BsInterfaceRomeo != null) {
      bool1 = BsInterfaceRomeo.UIInBePackage().q();
      BsInterfaceRomeo.UIInBePackage().DInterfaceCharlie();
    } 
    boolean bool2 = i.NInterfaceAlpha().NInterfaceAlpha("GD[PP-0REP");
    hs hs = new hs(paramFrame, bool2);
    bV.NInterfaceAlpha(paramFrame, hs);
    if (BsInterfaceRomeo != null && bool1) {
      hs.BInterfaceBravo(BsInterfaceRomeo.O().BsInterfaceRomeo() + "");
      hs.NInterfaceAlpha(BsInterfaceRomeo.O().Exception());
      try {
        hs.DInterfaceCharlie();
      } catch (NetworkInBPackage NetworkInBPackage) {
        AcInterfaceDelta.DInterfaceCharlie("Unable to open port: " + BsInterfaceRomeo.O().Exception());
      } 
    } 
    hs.setVisible(true);
    if (BsInterfaceRomeo != null && bool1)
      try {
        BsInterfaceRomeo.UIInBePackage().AiInterfaceDelta();
      } catch (SInterfaceLima SInterfaceLima) {
        AcInterfaceDelta.NInterfaceAlpha("Unable to go back online after closing Mini-Terminal");
      }  
  }
  
  public void ExceptionPrintstacktrace(Frame paramFrame) {
    if (NInterfaceAlpha.A() == null) {
      bV.AiInterfaceDelta("No Project Open.", paramFrame);
      return;
    } 
    if (IOInWPackage.BInterfaceBravo(NInterfaceAlpha.A().SInterfaceJuliet())) {
      IOInWPackage IOInWPackage = new IOInWPackage();
      String str = null;
      str = bV.NInterfaceAlpha(paramFrame, "ECU Definition Password: ");
      if (str == null)
        return; 
      try {
        IOInWPackage.NInterfaceAlpha(NInterfaceAlpha.A().SInterfaceJuliet(), str);
      } catch (FileNotFoundException fileNotFoundException) {
        Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, fileNotFoundException);
        bV.AiInterfaceDelta("File Not Found!", paramFrame);
        return;
      } catch (IOException iOException) {
        Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, iOException);
        bV.AiInterfaceDelta("Unable to read file.", paramFrame);
        return;
      } catch (GComponentAj GComponentAj) {
        bV.AiInterfaceDelta("Invalid Password!", paramFrame);
        return;
      } 
    } 
    T t = T.NInterfaceAlpha();
    R BsInterfaceRomeo = t.DInterfaceCharlie();
    Y AcInterfaceYankee = BsInterfaceRomeo.p();
    jc jc = new jc(paramFrame, AcInterfaceYankee);
    jc.setVisible(true);
  }
  
  public void Abstract(Frame paramFrame) {
    ii ii = new ii(paramFrame);
    ii.setVisible(true);
  }
  
  public void i(Frame paramFrame) {
    T t = T.NInterfaceAlpha();
    R BsInterfaceRomeo = t.DInterfaceCharlie();
    if (BsInterfaceRomeo != null) {
      aG aG = new aG();
      aG.NInterfaceAlpha(BsInterfaceRomeo);
      aG.NInterfaceAlpha(paramFrame);
    } 
  }
  
  public void Abstract(String paramString) {
    File file = new File(".");
    String str = "file:///" + file.getAbsolutePath() + "/help/learnMore.html";
    if (paramString != null && !paramString.isEmpty())
      str = str + "#" + paramString; 
    aN.NInterfaceAlpha(str);
  }
  
  public void SInterfaceJuliet(Frame paramFrame) {
    Image image = Toolkit.getDefaultToolkit().getImage(getClass().getResource("resources/companyLogo.png"));
    ImageIcon imageIcon = new ImageIcon(image);
    String str = NInterfaceAlpha.NInterfaceAlpha().ThreadedInIPackage();
    JOptionPane.showMessageDialog(paramFrame, str, "About " + NInterfaceAlpha.BInterfaceBravo, 0, imageIcon);
  }
  
  public void Abstract(Window paramWindow) {
    if (i.aI) {
      NInterfaceAlpha NInterfaceAlpha = new NInterfaceAlpha(paramWindow, ExceptionPrintstacktrace.AiInterfaceDelta());
      NInterfaceAlpha.NInterfaceAlpha(SInterfaceJuliet.A());
    } else {
      aM.f f1 = new aM.f(paramWindow, ExceptionPrintstacktrace.AiInterfaceDelta());
      f1.NInterfaceAlpha(SInterfaceJuliet.A());
    } 
  }
  
  public void NInterfaceAlpha(R paramR, String paramString, Frame paramFrame) {
    T t = T.NInterfaceAlpha();
    R BsInterfaceRomeo = null;
    if (paramR == null) {
      BsInterfaceRomeo = t.DInterfaceCharlie();
    } else {
      BsInterfaceRomeo = paramR;
    } 
    if (paramString.indexOf("http:") == -1 && paramString.indexOf("file:") == -1 && paramString.indexOf(".") != -1) {
      String str = paramString.substring(0, paramString.lastIndexOf("."));
      BsInterfaceRomeo = t.DInterfaceCharlie(str);
      paramString = paramString.substring(paramString.lastIndexOf(".") + 1);
    } 
    GComponentAj GComponentAj = BsInterfaceRomeo.KInterfaceEcho().BInterfaceBravo(paramString);
    if (GComponentAj == null && BsInterfaceRomeo.KInterfaceEcho().DInterfaceCharlie(paramString) != null) {
      NInterfaceAlpha(paramString, "-1", paramFrame);
      return;
    } 
    if (GComponentAj == null) {
      bV.AiInterfaceDelta("Help:" + paramString + " not found in current configuration.", paramFrame);
      return;
    } 
    if (GComponentAj.DInterfaceCharlie() != null && !GComponentAj.DInterfaceCharlie().equals("")) {
      ai.f f1 = new ai.f(GComponentAj);
      f1.NInterfaceAlpha((et)new dQ(NInterfaceAlpha.NInterfaceAlpha().AiInterfaceDelta(), "HelpViewer"));
      f1.NInterfaceAlpha(paramFrame, GComponentAj.AiInterfaceDelta());
    } else if (GComponentAj.BInterfaceBravo() != null && !GComponentAj.BInterfaceBravo().equals("")) {
      String str = GComponentAj.BInterfaceBravo();
      if (str.toLowerCase().indexOf("www.megasquirt.info") != -1)
        str = X.BInterfaceBravo(str, "www.megasquirt.info", "www.megamanual.com"); 
      URL uRL = null;
      try {
        uRL = new URL(str);
      } catch (MalformedURLException malformedURLException) {
        Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, malformedURLException);
      } 
      if (!t.NInterfaceAlpha(uRL) && paramR.V() != null) {
        File file = t.BInterfaceBravo(uRL);
        String str1 = paramR.V() + file.getName();
        if (!Isoptimizeddrawingenabled.BInterfaceBravo()) {
          String str2 = ExceptionPrintstacktrace.BInterfaceBravo("Help Manual not found on your computer.") + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Try again while connected to Internet and it can be downloaded for future offline use.");
          bV.AiInterfaceDelta(str2, paramFrame);
        } else if (!Isoptimizeddrawingenabled.BInterfaceBravo(str1)) {
          String str2 = ExceptionPrintstacktrace.BInterfaceBravo("Help Manual not found on your computer.") + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Also not found on server.") + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Check with your firmware provider and place manual on your computer at") + ":\Isoptimizeddrawingenabled" + file.getAbsolutePath();
          bV.AiInterfaceDelta(str2, paramFrame);
        } else {
          String str2 = ExceptionPrintstacktrace.BInterfaceBravo("The help manual for your firmware is not installed.") + "\Isoptimizeddrawingenabled\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Would you like to download it now?");
          if (bV.NInterfaceAlpha(str2, paramFrame, true)) {
            G ExceptionPrintstacktrace = new G(this, str);
            NInterfaceAlpha(ExceptionPrintstacktrace.BInterfaceBravo("Downloading Help Manual"), str1, file, ExceptionPrintstacktrace);
          } 
        } 
      } else {
        aN.NInterfaceAlpha(str);
      } 
    } 
  }
  
  public void NInterfaceAlpha(String paramString1, String paramString2, File paramFile, by paramby) {
    JDialog jDialog = bV.NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie(), "<html>" + ExceptionPrintstacktrace.BInterfaceBravo(paramString1) + "<br> " + paramFile.getName() + "</html>");
    NetworkInBPackage NetworkInBPackage = new NetworkInBPackage(this, paramFile, paramString2, paramby, jDialog);
    NetworkInBPackage.start();
  }
  
  public void AcInterfaceUniform() {
    BInterfaceBravo BInterfaceBravo = null;
    NInterfaceAlpha NInterfaceAlpha = new NInterfaceAlpha();
    BInterfaceBravo = NInterfaceAlpha.NInterfaceAlpha();
    if (BInterfaceBravo == null || !i.NInterfaceAlpha().NInterfaceAlpha(";'FG;'-05;'FG0-=")) {
      BInterfaceBravo.NInterfaceAlpha(NInterfaceAlpha.BInterfaceBravo + " " + NInterfaceAlpha.DInterfaceCharlie + " Help");
      BInterfaceBravo.BInterfaceBravo(AiInterfaceDelta.NInterfaceAlpha("/help/learnMore.html"));
    } 
    NInterfaceAlpha().NInterfaceAlpha(BInterfaceBravo, dd.NInterfaceAlpha().DInterfaceCharlie());
  }
  
  public void i(Window paramWindow) {
    Isoptimizeddrawingenabled Isoptimizeddrawingenabled = new Isoptimizeddrawingenabled(this, paramWindow);
    SwingUtilities.invokeLater(Isoptimizeddrawingenabled);
  }
  
  public void NInterfaceAlpha(BInterfaceBravo paramb, Window paramWindow) {
    if (paramb == null || paramb.BInterfaceBravo() == null) {
      bV.AiInterfaceDelta("Invalid help reference.", paramWindow);
      return;
    } 
    if (paramb.BInterfaceBravo() != null && !paramb.BInterfaceBravo().equals("")) {
      ai.f f1 = new ai.f();
      f1.NInterfaceAlpha(AiInterfaceDelta.NInterfaceAlpha("/help/index.html"));
      f1.NInterfaceAlpha((et)new dQ(NInterfaceAlpha.NInterfaceAlpha().AiInterfaceDelta(), "AppHelpViewer"));
      try {
        f1.BInterfaceBravo(paramb.BInterfaceBravo());
      } catch (NInterfaceAlpha NInterfaceAlpha) {
        AcInterfaceDelta.NInterfaceAlpha("Unable to open help:\Isoptimizeddrawingenabled" + paramb.BInterfaceBravo(), (Exception)NInterfaceAlpha, paramWindow);
      } 
      f1.NInterfaceAlpha(paramWindow, paramb.NInterfaceAlpha());
    } 
  }
  
  public void NInterfaceAlpha(String paramString1, String paramString2, Frame paramFrame) {
    T t = T.NInterfaceAlpha();
    R BsInterfaceRomeo = t.DInterfaceCharlie();
    if (paramString1.indexOf(".") != -1) {
      String str = paramString1.substring(0, paramString1.lastIndexOf("."));
      BsInterfaceRomeo = t.DInterfaceCharlie(str);
      if (BsInterfaceRomeo == null) {
        AcInterfaceDelta.AiInterfaceDelta("Configuration " + str + " not found using working configuation to open dialog.");
        BsInterfaceRomeo = t.DInterfaceCharlie();
      } 
      paramString1 = paramString1.substring(paramString1.lastIndexOf(".") + 1);
    } 
    if (BsInterfaceRomeo.Abstract().Abstract()) {
      String str = ExceptionPrintstacktrace.BInterfaceBravo("Attention!!") + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("There is no tune loaded. Before doing any configuration") + ",\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("it is recommended to either load an (" + NInterfaceAlpha.cw + ") or connect to NInterfaceAlpha controller.") + "\Isoptimizeddrawingenabled\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("It is not advised to create NInterfaceAlpha tune (" + NInterfaceAlpha.cw + ") from scratch.");
      bV.AiInterfaceDelta(str, paramFrame);
    } 
    ArrayListExceptionprintstacktraceInGPackage ArrayListExceptionprintstacktraceInGPackage = BsInterfaceRomeo.KInterfaceEcho().DInterfaceCharlie(paramString1);
    if (ArrayListExceptionprintstacktraceInGPackage == null) {
      iL iL = iL.NInterfaceAlpha();
      try {
        if (!iL.NInterfaceAlpha(paramFrame, BsInterfaceRomeo, paramString1, paramString2))
          bV.AiInterfaceDelta(paramString1 + " " + ExceptionPrintstacktrace.BInterfaceBravo("not found in current configuration.") + "\Isoptimizeddrawingenabled" + ExceptionPrintstacktrace.BInterfaceBravo("Perhaps it hasn't been created."), paramFrame); 
      } catch (NInterfaceAlpha NInterfaceAlpha) {
        bV.AiInterfaceDelta("Error showing dialog " + paramString1 + "\Isoptimizeddrawingenabled\Isoptimizeddrawingenabled" + NInterfaceAlpha.getMessage(), paramFrame);
      } 
      return;
    } 
    if (ArrayListExceptionprintstacktraceInGPackage instanceof SerializableImplUsingArrayList) {
      NInterfaceAlpha(BsInterfaceRomeo, (SerializableImplUsingArrayList)ArrayListExceptionprintstacktraceInGPackage, paramFrame);
    } else {
      NInterfaceAlpha(BsInterfaceRomeo, ArrayListExceptionprintstacktraceInGPackage, paramFrame);
    } 
  }
  
  public void v() {
    String str = bV.NInterfaceAlpha("{OutputChannel},{Value}", false, dd.NInterfaceAlpha().DInterfaceCharlie());
    if (str != null && !str.equals("")) {
      StringTokenizer stringTokenizer = new StringTokenizer(str, ",");
      String str1 = stringTokenizer.nextToken();
      double AiInterfaceDelta = Double.parseDouble(stringTokenizer.nextToken());
      R BsInterfaceRomeo = T.NInterfaceAlpha().DInterfaceCharlie();
      if (BsInterfaceRomeo == null) {
        bV.AiInterfaceDelta("No Config open", dd.NInterfaceAlpha().DInterfaceCharlie());
        return;
      } 
      String str2 = BsInterfaceRomeo.DInterfaceCharlie();
      ArrayList arrayList = ManagerUsingArrayList.NInterfaceAlpha().NInterfaceAlpha(str2, str1);
      for (GComponentCq GComponentCq : arrayList)
        GComponentCq.setCurrentOutputChannelValue(str1, AiInterfaceDelta); 
    } 
  }
  
  public void w() {
    File file2;
    String[] arrayOfString = { "jar" };
    JFrame jFrame = dd.NInterfaceAlpha().DInterfaceCharlie();
    String str1 = NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.dm, "");
    String str2 = bV.BInterfaceBravo(jFrame, "Install " + NInterfaceAlpha.BInterfaceBravo + " Plugin", arrayOfString, "", str1);
    if (str2 == null || str2.equals(""))
      return; 
    File file1 = new File(str2);
    NInterfaceAlpha.NInterfaceAlpha().BInterfaceBravo(NInterfaceAlpha.dm, file1.getParentFile().getAbsolutePath());
    ApplicationPlugin applicationPlugin = null;
    boolean bool = false;
    try {
      applicationPlugin = SInterfaceLima.NInterfaceAlpha().NInterfaceAlpha(file1);
      if (SInterfaceLima.NInterfaceAlpha().DInterfaceCharlie(applicationPlugin.getIdName())) {
        String str3 = "A plugin with NInterfaceAlpha matching ID: '" + applicationPlugin.getIdName() + "' is already installed.\Isoptimizeddrawingenabled\nDo you want to replace it with the new one?";
        if (!bV.NInterfaceAlpha(str3, dd.NInterfaceAlpha().DInterfaceCharlie(), true))
          return; 
        bool = true;
      } 
      String str = "<html><body><h2>Install " + NInterfaceAlpha.BInterfaceBravo + " plugin!</h2><BInterfaceBravo>Plugin Name:</BInterfaceBravo> '" + applicationPlugin.getDisplayName() + "'<br><BInterfaceBravo>Plugin ID:</BInterfaceBravo> '" + applicationPlugin.getIdName() + "'<br><BInterfaceBravo>Description:</BInterfaceBravo> <br>" + X.NInterfaceAlpha(applicationPlugin.getDescription(), 60, "<br>") + "<br><br>Do you want to Install this plugin?</body></html>";
      if (!bV.NInterfaceAlpha(str, dd.NInterfaceAlpha().DInterfaceCharlie(), true))
        return; 
    } catch (NInterfaceAlpha NInterfaceAlpha) {
      bV.AiInterfaceDelta("Error loading Plugin:\Isoptimizeddrawingenabled" + NInterfaceAlpha.getMessage(), dd.NInterfaceAlpha().DInterfaceCharlie());
    } catch (Exception exception) {
      bV.AiInterfaceDelta("Unknown Error loading Plugin.\nIs this NInterfaceAlpha valid Plugin file?\nError:\Isoptimizeddrawingenabled" + exception.getMessage(), dd.NInterfaceAlpha().DInterfaceCharlie());
    } catch (UnsupportedClassVersionError unsupportedClassVersionError) {
      bV.AiInterfaceDelta("Unsupported Class Vesion loading Plugin.\nError:\Isoptimizeddrawingenabled" + unsupportedClassVersionError.getMessage(), dd.NInterfaceAlpha().DInterfaceCharlie());
    } catch (Error error) {
      bV.AiInterfaceDelta("Unknown Error loading Plugin.\nIs this NInterfaceAlpha valid Plugin file?\nError:\Isoptimizeddrawingenabled" + error.getMessage(), dd.NInterfaceAlpha().DInterfaceCharlie());
    } 
    try {
      file2 = SInterfaceJuliet.BInterfaceBravo();
    } catch (NInterfaceAlpha NInterfaceAlpha) {
      AcInterfaceDelta.NInterfaceAlpha("Unable to access Plugin Dir", (Exception)NInterfaceAlpha, dd.NInterfaceAlpha().DInterfaceCharlie());
      return;
    } 
    File file3 = null;
    if (SInterfaceLima.NInterfaceAlpha().DInterfaceCharlie(applicationPlugin.getIdName())) {
      file3 = SInterfaceLima.NInterfaceAlpha().KInterfaceEcho(applicationPlugin.getIdName());
    } else {
      file3 = new File(file2, file1.getName());
    } 
    if (file3.exists() && SInterfaceLima.NInterfaceAlpha().KInterfaceEcho(applicationPlugin.getIdName()) == null && SInterfaceLima.NInterfaceAlpha().BInterfaceBravo(file3))
      file3 = new File(file2, applicationPlugin.getIdName() + ".jar"); 
    try {
      t.NInterfaceAlpha(file1, file3);
    } catch (NInterfaceAlpha NInterfaceAlpha) {
      AcInterfaceDelta.NInterfaceAlpha("Unable to copy Plugin to Plugin Dir", (Exception)NInterfaceAlpha, dd.NInterfaceAlpha().DInterfaceCharlie());
      return;
    } 
    if (bool)
      try {
        SInterfaceLima.NInterfaceAlpha().AiInterfaceDelta(applicationPlugin.getIdName());
      } catch (NInterfaceAlpha NInterfaceAlpha) {
        Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, (Throwable)NInterfaceAlpha);
        bool = false;
      }  
    if (bool) {
      String str = "<html><body><h2>" + NInterfaceAlpha.BInterfaceBravo + " plugin Installation</h2>Plugin Name: '" + applicationPlugin.getDisplayName() + "<br>Has successfully Upgraded and should be ready for use.<br></body></html>";
      bV.AiInterfaceDelta(str, jFrame);
    } else {
      String str = "<html><body><h2>" + NInterfaceAlpha.BInterfaceBravo + " plugin Installation</h2>Plugin Name: '" + applicationPlugin.getDisplayName() + "<br>Has successfully Installed.<br>A restart of " + NInterfaceAlpha.BInterfaceBravo + " is required to use this plugin.<br></body></html>";
      bV.AiInterfaceDelta(str, jFrame);
    } 
  }
  
  public void f(R paramR, String paramString) {
    try {
      ApplicationPlugin applicationPlugin = SInterfaceLima.NInterfaceAlpha().NInterfaceAlpha(paramString);
      Abstract Abstract = new Abstract(applicationPlugin);
      bV.NInterfaceAlpha((Component)Abstract, dd.NInterfaceAlpha().DInterfaceCharlie(), applicationPlugin.getDisplayName(), (bc)Abstract);
    } catch (NInterfaceAlpha NInterfaceAlpha) {
      Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, (Throwable)NInterfaceAlpha);
      bV.AiInterfaceDelta(ExceptionPrintstacktrace.BInterfaceBravo("Unable to display Plugin") + "\nError:\Isoptimizeddrawingenabled" + NInterfaceAlpha.getMessage(), dd.NInterfaceAlpha().DInterfaceCharlie());
    } catch (UnsupportedClassVersionError unsupportedClassVersionError) {
      bV.AiInterfaceDelta("Unsupported Class Vesion loading Plugin.\nError:\Isoptimizeddrawingenabled" + unsupportedClassVersionError.getMessage(), dd.NInterfaceAlpha().DInterfaceCharlie());
    } catch (Error error) {
      bV.AiInterfaceDelta("Unknown Error loading Plugin.\nIs this NInterfaceAlpha valid Plugin file?\nError:\Isoptimizeddrawingenabled" + error.getMessage(), dd.NInterfaceAlpha().DInterfaceCharlie());
    } 
  }
  
  public void NInterfaceAlpha(R paramR, ArrayListExceptionprintstacktraceInGPackage parambv, Window paramWindow) {
    if (paramWindow == null)
      paramWindow = dd.NInterfaceAlpha().DInterfaceCharlie(); 
    if (parambv.Y()) {
      String str1 = "Password protected Dialog. Enter the password.";
      String str2 = bV.NInterfaceAlpha(paramWindow, str1);
      String str3 = parambv.X();
      if (str2 == null)
        return; 
      if (!str2.equals(str3)) {
        bV.AiInterfaceDelta("Invalid Password", paramWindow);
        return;
      } 
    } 
    if (!W.NInterfaceAlpha(paramR, parambv, paramWindow))
      return; 
    try {
      hg hg = new hg(paramR, parambv);
      String str1 = X.BInterfaceBravo(parambv.M(), "\"", "");
      if (str1.trim().isEmpty()) {
        str1 = ExceptionprintstacktraceInGPackage.DInterfaceCharlie(paramR, parambv.aL());
        if (str1 == null || str1.equals(parambv.aL()))
          str1 = ExceptionPrintstacktrace.BInterfaceBravo("Settings"); 
      } 
      str1 = ExceptionPrintstacktrace.BInterfaceBravo(str1);
      dF dF = new dF(paramWindow, str1, hg, (parambv.Isoptimizeddrawingenabled() || hg.Abstract()));
      dF.add("Center", (Component)hg);
      hg.NInterfaceAlpha((bc)dF);
      GInterfaceDb GInterfaceDb = parambv.N();
      BsInterfaceOscar BsInterfaceOscar = new BsInterfaceOscar(this, GInterfaceDb, dF);
      try {
        i.NInterfaceAlpha(paramR.DInterfaceCharlie(), GInterfaceDb, BsInterfaceOscar);
      } catch (NInterfaceAlpha NInterfaceAlpha) {
        bV.AiInterfaceDelta("Invalid Title Defined: " + GInterfaceDb.toString() + "\nError: " + NInterfaceAlpha.getLocalizedMessage(), (Component)dF);
      } 
      boolean bool = (parambv instanceof G.bm || parambv instanceof G.bi || parambv instanceof K.NInterfaceAlpha || parambv instanceof K.i || parambv instanceof G.be || ExceptionprintstacktraceInGPackage.NInterfaceAlpha(parambv)) ? true : false;
      String str2 = parambv.aL();
      if (parambv instanceof G.bi)
        str2 = str2 + "3D"; 
      hg.NInterfaceAlpha(new JDialogExtensionInBdPackage(this, (Dialog)dF, str2));
      Rectangle rectangle = NInterfaceAlpha(str2 + str1, dF.getBounds());
      if (rectangle.height == 0) {
        dF.pack();
        bV.NInterfaceAlpha(paramWindow, (Component)dF);
        rectangle = dF.getBounds();
      } 
      if (bool) {
        rectangle = bV.NInterfaceAlpha(rectangle);
        if (rectangle.height < dF.getHeight())
          rectangle.height = dF.getHeight(); 
        if (rectangle.width < dF.getWidth())
          rectangle.width = dF.getWidth(); 
        dF.setBounds(rectangle);
      } else {
        dF.pack();
        dF.setLocation(rectangle.AvInterfaceXray, rectangle.AcInterfaceYankee);
        rectangle = bV.NInterfaceAlpha(dF.getBounds());
        dF.setBounds(rectangle);
      } 
      Dimension dimension = Toolkit.getDefaultToolkit().getScreenSize();
      dimension.height -= 30;
      if (dF.getWidth() > dimension.width) {
        dF.setSize(dimension.width, dF.getHeight());
        dF.setLocation(0, (dF.getLocation()).AcInterfaceYankee);
        dF.doLayout();
      } 
      if (dF.getHeight() > dimension.height) {
        dF.setSize(dF.getWidth(), dimension.height);
        dF.setLocation((dF.getLocation()).AvInterfaceXray, 0);
        dF.doLayout();
      } 
      if ((dF.getX() > dimension.width || dF.getY() > dimension.height) && !bV.Abstract())
        bV.NInterfaceAlpha(paramWindow, (Component)dF); 
      if (paramR.O().GComponentAj()) {
        GComponentCj[] arrayOfCj = ExceptionprintstacktraceInGPackage.BInterfaceBravo(paramR, parambv);
        NInterfaceAlpha(paramR, arrayOfCj);
      } 
      hg.ThreadedInIPackage();
      try {
        dF.setVisible(true);
      } finally {
        dd.NInterfaceAlpha().BInterfaceBravo().DInterfaceCharlie(true);
      } 
    } catch (Exception exception) {
      AcInterfaceDelta.NInterfaceAlpha("Error showing Dialog", exception, dd.NInterfaceAlpha().DInterfaceCharlie());
    } 
  }
  
  public void NInterfaceAlpha(R paramR, GComponentCj[] paramArrayOfcj) {
    try {
      if (paramArrayOfcj != null) {
        ArrayList<Integer> arrayList = new ArrayList();
        for (byte BInterfaceBravo = 0; BInterfaceBravo < paramArrayOfcj.length; BInterfaceBravo++) {
          if (paramArrayOfcj[BInterfaceBravo].NInterfaceAlpha() >= 0)
            if (paramR.O().PComponentBravo(paramArrayOfcj[BInterfaceBravo].NInterfaceAlpha())) {
              NInterfaceAlpha(paramR, paramArrayOfcj[BInterfaceBravo]);
              AcInterfaceDelta.AiInterfaceDelta("Initiating read page " + (paramArrayOfcj[BInterfaceBravo].NInterfaceAlpha() + 1) + " : " + paramArrayOfcj[BInterfaceBravo].BInterfaceBravo() + ":" + paramArrayOfcj[BInterfaceBravo].DInterfaceCharlie());
            } else if (!arrayList.contains(Integer.valueOf(paramArrayOfcj[BInterfaceBravo].NInterfaceAlpha()))) {
              NInterfaceAlpha(paramR, paramArrayOfcj[BInterfaceBravo].NInterfaceAlpha());
              arrayList.add(Integer.valueOf(paramArrayOfcj[BInterfaceBravo].NInterfaceAlpha()));
              AcInterfaceDelta.AiInterfaceDelta("Initiating read page " + (paramArrayOfcj[BInterfaceBravo].NInterfaceAlpha() + 1));
            }  
        } 
      } 
    } catch (Exception exception) {
      exception.printStackTrace();
    } 
  }
  
  public void NInterfaceAlpha(R paramR, SerializableImplUsingArrayList paramaX, Frame paramFrame) {
    JDialog jDialog1 = SInterfaceJuliet(paramaX.M());
    if (jDialog1 != null && jDialog1.isDisplayable()) {
      jDialog1.requestFocus();
      return;
    } 
    if (paramR == null) {
      bV.AiInterfaceDelta(ExceptionPrintstacktrace.BInterfaceBravo("You must have NInterfaceAlpha working configuration open."), paramFrame);
      return;
    } 
    UICloseInPPackage SInterfaceJuliet = new UICloseInPPackage(paramR, paramaX);
    JDialog jDialog2 = bV.NInterfaceAlpha((Component)SInterfaceJuliet, paramFrame, ExceptionPrintstacktrace.BInterfaceBravo(paramaX.M()), null);
    jDialog2.setDefaultCloseOperation(2);
    this.ExceptionPrintstacktrace.put(paramaX.M(), jDialog2);
  }
  
  private JDialog SInterfaceJuliet(String paramString) {
    for (JDialog jDialog : this.ExceptionPrintstacktrace.values()) {
      if (!jDialog.isDisplayable())
        this.ExceptionPrintstacktrace.remove(jDialog.getTitle()); 
    } 
    return (JDialog)this.ExceptionPrintstacktrace.get(paramString);
  }
  
  public void NInterfaceAlpha(Frame paramFrame, String paramString) {
    String str = NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie("lookAndFeelClass", "defaultLookAndFeelClass");
    NInterfaceAlpha.NInterfaceAlpha().BInterfaceBravo("lookAndFeelClass", paramString);
    if (paramString.contains("TinyLookAndFeel") || str.contains("TinyLookAndFeel")) {
      String str1 = ExceptionPrintstacktrace.BInterfaceBravo("You must restart for changes to take effect. Restart Now?");
      if (bV.NInterfaceAlpha(str1, paramFrame, true)) {
        try {
          NInterfaceAlpha.NInterfaceAlpha().KInterfaceEcho();
        } catch (NInterfaceAlpha NInterfaceAlpha) {
          Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, (Throwable)NInterfaceAlpha);
        } 
        AiInterfaceDelta(paramFrame);
      } 
    } else {
      try {
        UIManager.setLookAndFeel(paramString);
        if (paramString.contains("Nimbus")) {
          UIDefaults uIDefaults = UIManager.getLookAndFeel().getDefaults();
          uIDefaults.put("Table.cellNoFocusBorder", new Insets(0, 0, 0, 0));
          uIDefaults.put("Table.focusCellHighlightBorder", new Insets(0, 0, 0, 0));
          UIManager.getLookAndFeelDefaults().put("Table.cellNoFocusBorder", new Insets(0, 0, 0, 0));
          UIManager.getLookAndFeelDefaults().put("Table.focusCellHighlightBorder", new Insets(0, 0, 0, 0));
        } 
        AvInterfaceXray();
        SwingUtilities.updateComponentTreeUI(paramFrame);
        dd.NInterfaceAlpha().ExceptionPrintstacktrace().DInterfaceCharlie();
        bV.KInterfaceEcho();
        bV.NInterfaceAlpha(new id());
      } catch (Exception exception) {
        AcInterfaceDelta.DInterfaceCharlie("Exception setting look to " + paramString);
      } 
    } 
  }
  
  public void AvInterfaceXray() {
    boolean bool = (UICloseInPPackage.NInterfaceAlpha() && UIManager.getLookAndFeel().isNativeLookAndFeel()) ? true : false;
    try {
      UIManager.setLookAndFeel(UIManager.getLookAndFeel());
    } catch (UnsupportedLookAndFeelException unsupportedLookAndFeelException) {
      Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, unsupportedLookAndFeelException);
    } 
    Font font1 = UIManager.getFont("Label.font");
    if (font1 != null && font1.getSize() < 14)
      eJ.DInterfaceCharlie(font1.getSize()); 
    int i = eJ.NInterfaceAlpha();
    int SInterfaceJuliet = NInterfaceAlpha.NInterfaceAlpha().NInterfaceAlpha(NInterfaceAlpha.aH, NInterfaceAlpha.NInterfaceAlpha().BsInterfaceOscar());
    float f1 = SInterfaceJuliet / i;
    Set set = UIManager.getLookAndFeelDefaults().keySet();
    Object[] arrayOfObject1 = set.toArray(new Object[set.size()]);
    Object[] arrayOfObject2 = new Object[arrayOfObject1.length + 1];
    System.arraycopy(arrayOfObject1, 0, arrayOfObject2, 0, arrayOfObject1.length);
    arrayOfObject2[arrayOfObject2.length - 1] = "defaultFont";
    arrayOfObject1 = arrayOfObject2;
    Font font2 = UIManager.getFont("defaultFont");
    for (Object object : arrayOfObject1) {
      if (object != null && object.toString().toLowerCase().contains("font")) {
        Font font = UIManager.getFont(object);
        if (font != null && !bool) {
          Float float_ = (Float)this.ThreadedInIPackage.get(object);
          if (float_ == null) {
            this.ThreadedInIPackage.put(object, Float.valueOf(font.getSize2D()));
            float_ = Float.valueOf(font.getSize2D());
          } 
          Font font3 = new Font(font.getFamily(), font.getStyle(), Math.round(eJ.NInterfaceAlpha(float_.floatValue() * f1)));
          UIManager.put(object, font3);
        } else if (font == null) {
          AcInterfaceDelta.DInterfaceCharlie("no update:" + object);
        } 
      } else if (object != null && object.toString().equals("ScrollBar.width")) {
        System.out.println(object);
        if (UIManager.getInt(object) < 20)
          UIManager.put(object, Integer.valueOf(eJ.NInterfaceAlpha(UIManager.getInt(object)))); 
      } else if (UIManager.get(object) instanceof Font) {
        AcInterfaceDelta.DInterfaceCharlie("no update:" + object);
      } 
    } 
    if (font2 != null) {
      Font font = new Font(font2.getFamily(), font2.getStyle(), eJ.NInterfaceAlpha(12));
      UIManager.getLookAndFeel().getDefaults().put("defaultFont", font);
    } 
    if (dd.NInterfaceAlpha().DInterfaceCharlie() != null) {
      SwingUtilities.updateComponentTreeUI(dd.NInterfaceAlpha().DInterfaceCharlie());
      dd.NInterfaceAlpha().ExceptionPrintstacktrace().DInterfaceCharlie();
      bV.KInterfaceEcho();
      bV.NInterfaceAlpha(new id());
    } 
  }
  
  public void NInterfaceAlpha(BInterfaceBravo paramb) {
    this.AiInterfaceDelta.add(paramb);
  }
  
  protected void AcInterfaceYankee() {
    AvInterfaceXray AvInterfaceXray = dd.NInterfaceAlpha().BInterfaceBravo();
    try {
      if (AvInterfaceXray.isVisible()) {
        AvInterfaceXray.ThreadedInIPackage(NInterfaceAlpha.NInterfaceAlpha().BInterfaceBravo() + " " + ExceptionPrintstacktrace.BInterfaceBravo("Shut down...."));
        AvInterfaceXray.paint(AvInterfaceXray.getGraphics());
      } 
    } catch (Exception exception) {}
    Isoptimizeddrawingenabled();
    Thread.yield();
    for (BInterfaceBravo BInterfaceBravo : this.AiInterfaceDelta) {
      if (!BInterfaceBravo.BInterfaceBravo()) {
        AcInterfaceDelta.BInterfaceBravo("App shut down has been asked to stop.\nI will kill event thread. Ignore stack trace.");
        if (AvInterfaceXray != null)
          AvInterfaceXray.GInterfaceAb(); 
        dd.NInterfaceAlpha().DInterfaceCharlie().setVisible(true);
        ((String)null).toString();
      } 
    } 
    AcInterfaceDelta.AiInterfaceDelta("Finalizing Sensors");
    AvInterfaceXray.NInterfaceAlpha().f();
  }
  
  private Rectangle NInterfaceAlpha(String paramString, Rectangle paramRectangle) {
    Properties properties;
    Rectangle rectangle = new Rectangle();
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    if (NInterfaceAlpha == null)
      properties = NInterfaceAlpha.NInterfaceAlpha().AiInterfaceDelta(); 
    try {
      rectangle.AvInterfaceXray = Integer.parseInt(properties.getProperty(paramString + "_X", "0"));
      if (rectangle.AvInterfaceXray == 0) {
        rectangle.AvInterfaceXray = paramRectangle.AvInterfaceXray;
      } else {
        rectangle.AvInterfaceXray = eJ.NInterfaceAlpha(rectangle.AvInterfaceXray);
      } 
      rectangle.AcInterfaceYankee = Integer.parseInt(properties.getProperty(paramString + "_Y", "0"));
      if (rectangle.AcInterfaceYankee == 0) {
        rectangle.AcInterfaceYankee = paramRectangle.AcInterfaceYankee;
      } else {
        rectangle.AcInterfaceYankee = eJ.NInterfaceAlpha(rectangle.AcInterfaceYankee);
      } 
      rectangle.width = Integer.parseInt(properties.getProperty(paramString + "_width", "0"));
      if (rectangle.width == 0) {
        rectangle.width = paramRectangle.width;
      } else {
        rectangle.width = eJ.NInterfaceAlpha(rectangle.width);
      } 
      rectangle.height = Integer.parseInt(properties.getProperty(paramString + "_height", "0"));
      if (rectangle.height == 0) {
        rectangle.height = paramRectangle.height;
      } else {
        rectangle.height = eJ.NInterfaceAlpha(rectangle.height);
      } 
    } catch (Exception exception) {
      return paramRectangle;
    } 
    return rectangle;
  }
  
  public void ThreadedInIPackage(Frame paramFrame) {
    if (!i.NInterfaceAlpha().NInterfaceAlpha("09fewlkm309glkfds09"))
      return; 
    String str = NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie("lastProjectPath", "");
    if (!str.equals("") && !NInterfaceAlpha.AcInterfaceUniform(str))
      NInterfaceAlpha(paramFrame, str); 
  }
  
  public ig SInterfaceJuliet(Window paramWindow) {
    Isoptimizeddrawingenabled Isoptimizeddrawingenabled = dd.NInterfaceAlpha().NetworkInBPackage();
    if (Isoptimizeddrawingenabled == null || !Isoptimizeddrawingenabled.getTitleAt(Isoptimizeddrawingenabled.getSelectedIndex()).equals(hb.BsInterfaceRomeo)) {
      NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
      if (NInterfaceAlpha != null) {
        ig ig = new ig(paramWindow);
        try {
          ig.NInterfaceAlpha(NInterfaceAlpha);
        } catch (NInterfaceAlpha a1) {
          AcInterfaceDelta.NInterfaceAlpha("Error setting current project.", (Exception)a1, paramWindow);
        } 
        ig.NInterfaceAlpha();
        ig.NInterfaceAlpha(new p(this));
        return ig;
      } 
      bV.AiInterfaceDelta("There must be an open project to show Project Properties.", paramWindow);
      return null;
    } 
    return null;
  }
  
  public void PInterfaceZulu() {
    this.SInterfaceJuliet.run();
  }
  
  public void ThreadedInIPackage(Window paramWindow) {
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    if (NInterfaceAlpha == null)
      return; 
    String str = "" + NInterfaceAlpha.DInterfaceCharlie(T.NInterfaceAlpha().DInterfaceCharlie().O().as());
    SInterfaceJuliet SInterfaceJuliet = new SInterfaceJuliet(str);
    SInterfaceJuliet.NInterfaceAlpha(paramWindow);
  }
  
  public void NInterfaceAlpha(bW parambW) {
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    if (NInterfaceAlpha == null) {
      bV.AiInterfaceDelta("There must be NInterfaceAlpha project open to add additional Gauge Clusters.", (Component)parambW);
      return;
    } 
    bW bW1 = dd.NInterfaceAlpha().Abstract();
    String str = "";
    boolean bool = false;
    while (true) {
      if (str == null || str.trim().length() == 0) {
        str = JOptionPane.showInputDialog((Component)parambW, ExceptionPrintstacktrace.BInterfaceBravo("New Gauge Cluster Name"), ExceptionPrintstacktrace.BInterfaceBravo("Add New Gauge Cluster Tab"), 3);
      } else {
        str = JOptionPane.showInputDialog((Component)parambW, ExceptionPrintstacktrace.BInterfaceBravo("New Gauge Cluster Name"), str);
      } 
      if (str == null || str.trim().equals(""))
        return; 
      if (bW1.AiInterfaceDelta(str)) {
        bV.AiInterfaceDelta(ExceptionPrintstacktrace.BInterfaceBravo("Name Already In Use."), (Component)bW1);
        bool = true;
      } else if (!t.NInterfaceAlpha(str)) {
        bV.AiInterfaceDelta(ExceptionPrintstacktrace.BInterfaceBravo("Invalid Characters in gauge cluster name."), (Component)bW1);
        bool = true;
      } else {
        bool = false;
      } 
      if (!bool) {
        AvInterfaceXray AvInterfaceXray = new AvInterfaceXray(T.NInterfaceAlpha().DInterfaceCharlie());
        AvInterfaceXray.setName(str);
        AvInterfaceXray.SInterfaceLima(true);
        T t = AvInterfaceXray.X();
        KeyboardFocusManager.getCurrentKeyboardFocusManager().addKeyEventDispatcher((KeyEventDispatcher)t);
        AvInterfaceXray.setBackground(Color.DARK_GRAY);
        aE.f f1 = new aE.f();
        f1.NInterfaceAlpha(str);
        f1.BInterfaceBravo(str + "." + NInterfaceAlpha.co);
        AvInterfaceXray.NetworkInBPackage(f1.NInterfaceAlpha(NInterfaceAlpha));
        bW1.NInterfaceAlpha(AvInterfaceXray, str);
        bW1.ExceptionPrintstacktrace(str);
        NInterfaceAlpha.NInterfaceAlpha(f1);
        AvInterfaceXray.NInterfaceAlpha(new E(this, str));
        return;
      } 
    } 
  }
  
  public void A() {
    boolean bool = bV.NInterfaceAlpha("The application will be closed after removing the Registration.\Isoptimizeddrawingenabled \nThis computer will be removed from the count of active computers using \nyour registration within 30-60 days.\Isoptimizeddrawingenabled\Isoptimizeddrawingenabled Are you sure you want to remove the registration information Now?", dd.NInterfaceAlpha().DInterfaceCharlie(), true);
    if (!bool)
      return; 
    NInterfaceAlpha.NInterfaceAlpha().AiInterfaceDelta(NInterfaceAlpha.cC, "");
    NInterfaceAlpha.NInterfaceAlpha().AiInterfaceDelta(NInterfaceAlpha.cD, "");
    NInterfaceAlpha.NInterfaceAlpha().AiInterfaceDelta(NInterfaceAlpha.cF, "");
    NInterfaceAlpha.NInterfaceAlpha().AiInterfaceDelta(NInterfaceAlpha.cE, "");
    NInterfaceAlpha.NInterfaceAlpha().AiInterfaceDelta(NInterfaceAlpha.SInterfaceJuliet, "");
    NInterfaceAlpha.NInterfaceAlpha().AiInterfaceDelta(NInterfaceAlpha.Isoptimizeddrawingenabled, "");
    NInterfaceAlpha.NInterfaceAlpha().BInterfaceBravo(NInterfaceAlpha.cL, "false");
    try {
      NInterfaceAlpha.NInterfaceAlpha().i();
    } catch (NInterfaceAlpha NInterfaceAlpha) {
      AcInterfaceDelta.NInterfaceAlpha("Failed to save registration file.", (Exception)NInterfaceAlpha, dd.NInterfaceAlpha().DInterfaceCharlie());
    } 
    bV.AiInterfaceDelta(NInterfaceAlpha.BInterfaceBravo + " " + NInterfaceAlpha.DInterfaceCharlie + " registration has been removed.\Isoptimizeddrawingenabled" + NInterfaceAlpha.BInterfaceBravo + " will now close.", dd.NInterfaceAlpha().DInterfaceCharlie());
    Exception();
  }
  
  public void SInterfaceLima(Frame paramFrame) {
    String str = NInterfaceAlpha.NInterfaceAlpha().NInterfaceAlpha(NInterfaceAlpha.cF, null);
    if (str != null)
      bG.NInterfaceAlpha(paramFrame); 
  }
  
  public void BInterfaceBravo(Frame paramFrame, String paramString) {
    NInterfaceAlpha.NInterfaceAlpha().BInterfaceBravo("viewLanguageCode", paramString);
    boolean bool = bV.NInterfaceAlpha(ExceptionPrintstacktrace.BInterfaceBravo("You must restart for changes to take effect. Restart Now?"), paramFrame, true);
    if (bool)
      AiInterfaceDelta(paramFrame); 
  }
  
  public void NetworkInBPackage(Frame paramFrame) {
    NInterfaceAlpha NInterfaceAlpha = NInterfaceAlpha.A();
    if (NInterfaceAlpha == null) {
      bV.AiInterfaceDelta("You must have NInterfaceAlpha Project Open for Restore Points.", paramFrame);
      return;
    } 
    Exception Exception = new Exception(NInterfaceAlpha);
    Exception.NInterfaceAlpha(paramFrame);
  }
  
  public void PComponentBravo() {
    NInterfaceAlpha NInterfaceAlpha = new NInterfaceAlpha(NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.aN, ""), NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.cE, ""), "", NInterfaceAlpha.BInterfaceBravo, NInterfaceAlpha.DInterfaceCharlie, NInterfaceAlpha.NInterfaceAlpha);
    NInterfaceAlpha.NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie());
  }
  
  public void UIInBePackage() {
    R BsInterfaceRomeo = T.NInterfaceAlpha().DInterfaceCharlie();
    if (BsInterfaceRomeo == null) {
      bV.AiInterfaceDelta("There are no Active Protocol Stats.", dd.NInterfaceAlpha().DInterfaceCharlie());
      return;
    } 
    Abstract Abstract = BsInterfaceRomeo.UIInBePackage().AcInterfaceDelta();
    if (Abstract == null) {
      bV.AiInterfaceDelta("There are no Active Protocol Stats.", dd.NInterfaceAlpha().DInterfaceCharlie());
      return;
    } 
    F f1 = new F(Abstract);
    f1.NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie(), ExceptionPrintstacktrace.BInterfaceBravo("Protocol Stats"), (bc)f1);
  }
  
  public void AcInterfaceDelta() {
    JFrame jFrame = dd.NInterfaceAlpha().DInterfaceCharlie();
    NInterfaceAlpha NInterfaceAlpha = new NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie());
    NInterfaceAlpha.setSize(eJ.NInterfaceAlpha(600), eJ.NInterfaceAlpha(280));
    bV.NInterfaceAlpha(jFrame, (Component)NInterfaceAlpha);
    NInterfaceAlpha.setVisible(true);
  }
  
  public void NInterfaceAlpha(R paramR, EqualsInGPackage parambI, Component paramComponent) {
    try {
      NInterfaceAlpha NInterfaceAlpha = DInterfaceCharlie.NInterfaceAlpha().NInterfaceAlpha(paramR, parambI);
      NInterfaceAlpha.NInterfaceAlpha(paramComponent);
    } catch (KInterfaceEcho KInterfaceEcho) {
      bV.AiInterfaceDelta(KInterfaceEcho.getMessage(), paramComponent);
      Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, (Throwable)KInterfaceEcho);
    } 
  }
  
  public void E() {
    NInterfaceAlpha NInterfaceAlpha = new NInterfaceAlpha(AvInterfaceXray.NInterfaceAlpha().BInterfaceBravo());
    NInterfaceAlpha.NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie());
  }
  
  public void F() {
    ai.f f1 = new ai.f();
    String str = AiInterfaceDelta.NInterfaceAlpha("/help/learnMore.html");
    try {
      bV.NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie(), (Component)f1);
      f1.BInterfaceBravo(str);
    } catch (NInterfaceAlpha NInterfaceAlpha) {
      AcInterfaceDelta.NInterfaceAlpha("Unable to open help:\Isoptimizeddrawingenabled" + str, (Exception)NInterfaceAlpha, dd.NInterfaceAlpha().DInterfaceCharlie());
    } 
    f1.setPreferredSize(eJ.NInterfaceAlpha(1050, 800));
    f1.NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie(), ExceptionPrintstacktrace.BInterfaceBravo("Upgrade Now!!"));
  }
  
  public void G() {
    if (i.NInterfaceAlpha().NInterfaceAlpha("Abstract-=ds[]gdsgds[p"))
      try {
        iP.NInterfaceAlpha().NInterfaceAlpha(dd.NInterfaceAlpha().BInterfaceBravo());
      } catch (NInterfaceAlpha NInterfaceAlpha) {
        hq.NInterfaceAlpha().AiInterfaceDelta("Error: " + NInterfaceAlpha.getMessage());
      }  
  }
  
  public void SInterfaceLima(Window paramWindow) {
    R BsInterfaceRomeo = T.NInterfaceAlpha().DInterfaceCharlie();
    if (BsInterfaceRomeo == null) {
      AcInterfaceDelta.BInterfaceBravo("EcuConfig is null, not showing DataLogEvent");
      return;
    } 
    ExceptionPrintstacktrace ExceptionPrintstacktrace = new ExceptionPrintstacktrace(BsInterfaceRomeo);
    ExceptionPrintstacktrace.NInterfaceAlpha(paramWindow);
  }
  
  public void NetworkInBPackage(Window paramWindow) {
    ExceptionPrintstacktrace ExceptionPrintstacktrace = new ExceptionPrintstacktrace(NInterfaceAlpha.A());
    ExceptionPrintstacktrace.NInterfaceAlpha(paramWindow);
  }
  
  public void Isoptimizeddrawingenabled(Frame paramFrame) {
    NInterfaceAlpha NInterfaceAlpha = new NInterfaceAlpha(paramFrame, (WInterfaceAp)new Properties(NInterfaceAlpha.NInterfaceAlpha().AiInterfaceDelta(), "BinaryDiff"));
    NInterfaceAlpha.setSize(eJ.NInterfaceAlpha(1000), eJ.NInterfaceAlpha(600));
    bV.NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie(), (Component)NInterfaceAlpha);
    NInterfaceAlpha.setVisible(true);
  }
  
  public void H() {
    if (NInterfaceAlpha.A() == null)
      bV.AiInterfaceDelta("A Project must be loaded to add NInterfaceAlpha channel", dd.NInterfaceAlpha().DInterfaceCharlie()); 
    NInterfaceAlpha NInterfaceAlpha = new NInterfaceAlpha();
    NInterfaceAlpha.NInterfaceAlpha();
  }
  
  public void BsInterfaceOscar(Frame paramFrame) {
    R BsInterfaceRomeo = T.NInterfaceAlpha().DInterfaceCharlie();
    if (BsInterfaceRomeo != null) {
      if (IOInWPackage.BInterfaceBravo(NInterfaceAlpha.A().SInterfaceJuliet())) {
        IOInWPackage IOInWPackage = new IOInWPackage();
        String str = null;
        str = bV.NInterfaceAlpha(paramFrame, "ECU Definition Password: ");
        if (str == null)
          return; 
        try {
          IOInWPackage.NInterfaceAlpha(NInterfaceAlpha.A().SInterfaceJuliet(), str);
        } catch (FileNotFoundException fileNotFoundException) {
          Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, fileNotFoundException);
          bV.AiInterfaceDelta("File Not Found!", paramFrame);
          return;
        } catch (IOException iOException) {
          Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, iOException);
          bV.AiInterfaceDelta("Unable to read file.", paramFrame);
          return;
        } catch (GComponentAj GComponentAj) {
          bV.AiInterfaceDelta("Invalid Password!", paramFrame);
          return;
        } 
      } 
      KInterfaceEcho KInterfaceEcho = new KInterfaceEcho(paramFrame);
      KInterfaceEcho.setSize(eJ.NInterfaceAlpha(1000), eJ.NInterfaceAlpha(600));
      bV.NInterfaceAlpha(paramFrame, (Component)KInterfaceEcho);
      KInterfaceEcho.setVisible(true);
      KInterfaceEcho.NInterfaceAlpha(BsInterfaceRomeo);
    } 
  }
  
  public void DInterfaceCharlie(boolean paramBoolean) {
    this.i = paramBoolean;
  }
  
  public boolean JDialogExtensionInBdPackage() {
    R BsInterfaceRomeo = T.NInterfaceAlpha().DInterfaceCharlie();
    return (BsInterfaceRomeo == null) ? false : ((BsInterfaceRomeo.UIInBePackage() instanceof SInterfaceLima && ((SInterfaceLima)BsInterfaceRomeo.UIInBePackage()).Abstract()));
  }
  
  public void UICloseInPPackage() {
    byte BInterfaceBravo = 0;
    for (String str : T.NInterfaceAlpha().AiInterfaceDelta()) {
      R BsInterfaceRomeo = T.NInterfaceAlpha().DInterfaceCharlie(str);
      if (i.NInterfaceAlpha().NInterfaceAlpha("98fg54lklk") && !JDialogExtensionInBdPackage() && !NInterfaceAlpha.NInterfaceAlpha(BsInterfaceRomeo).KInterfaceEcho() && NInterfaceAlpha.NInterfaceAlpha(BsInterfaceRomeo).BInterfaceBravo() == 0 && T.NInterfaceAlpha().DInterfaceCharlie() != null) {
        boolean bool = true;
        if (bool) {
          NetworkInBPackage NetworkInBPackage = new NetworkInBPackage(BsInterfaceRomeo);
          try {
            NetworkInBPackage.NInterfaceAlpha(NetworkInBPackage.ThreadedInIPackage, Integer.valueOf(21848 + BInterfaceBravo++));
          } catch (Exception Exception) {
            Logger.getLogger(f.class.getName()).log(Level.WARNING, "Failed to set ECU Hub Port on TCP", (Throwable)Exception);
          } 
          AcInterfaceDelta.AiInterfaceDelta("Starting TCP Slave Server");
          NInterfaceAlpha.NInterfaceAlpha(BsInterfaceRomeo).NInterfaceAlpha((BsInterfaceRomeo)NetworkInBPackage);
        } else {
          Exception Exception = new Exception(BsInterfaceRomeo);
          try {
            Exception.NInterfaceAlpha(NetworkInBPackage.ThreadedInIPackage, Integer.valueOf(21848 + BInterfaceBravo++));
          } catch (Exception s1) {
            Logger.getLogger(f.class.getName()).log(Level.WARNING, "Failed to set ECU Hub Port on UDP", (Throwable)s1);
          } 
          NInterfaceAlpha.NInterfaceAlpha(BsInterfaceRomeo).NInterfaceAlpha((BsInterfaceRomeo)Exception);
          AcInterfaceDelta.AiInterfaceDelta("Starting UDP Slave Server");
        } 
      } 
      NInterfaceAlpha.NInterfaceAlpha(BsInterfaceRomeo).NInterfaceAlpha();
    } 
  }
  
  public void K() {
    if (i.NInterfaceAlpha().NInterfaceAlpha("98fg54lklk"))
      NInterfaceAlpha.DInterfaceCharlie(); 
  }
  
  public void AiInterfaceDelta(boolean paramBoolean) {
    NInterfaceAlpha.NInterfaceAlpha().BInterfaceBravo(NInterfaceAlpha.ci, Boolean.toString(paramBoolean));
    BtInterfaceBh.NInterfaceAlpha().NInterfaceAlpha(paramBoolean);
  }
  
  public void L() {
    q q = new q(this);
    q.start();
  }
  
  public void Isoptimizeddrawingenabled(Window paramWindow) {
    NInterfaceAlpha NInterfaceAlpha = new NInterfaceAlpha(new jz(), ExceptionPrintstacktrace.AiInterfaceDelta());
    NInterfaceAlpha.NInterfaceAlpha(paramWindow);
  }
  
  public void M() {
    if (Desktop.isDesktopSupported())
      try {
        if (NInterfaceAlpha.A() != null) {
          Desktop.getDesktop().open(new File(NInterfaceAlpha.A().t()));
        } else {
          Desktop.getDesktop().open(new File(SInterfaceJuliet.AcInterfaceUniform()));
        } 
      } catch (IOException iOException) {
        Logger.getLogger(f.class.getName()).log(Level.INFO, "Failed to open Project folder", iOException);
      }  
  }
  
  public void N() {
    if (i.NInterfaceAlpha().NInterfaceAlpha("poij  fdsz poi9ure895 ms7("))
      try {
        UICloseInPPackage SInterfaceJuliet = new UICloseInPPackage((PComponentBravo)PInterfaceZulu.NInterfaceAlpha(), bV.NInterfaceAlpha());
        SInterfaceJuliet.NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie());
      } catch (NInterfaceAlpha NInterfaceAlpha) {
        bV.AiInterfaceDelta(ExceptionPrintstacktrace.BInterfaceBravo(NInterfaceAlpha.getLocalizedMessage()), dd.NInterfaceAlpha().DInterfaceCharlie());
      }  
  }
  
  public void O() {
    if (i.NInterfaceAlpha().NInterfaceAlpha("poij  fdsz poi9ure895 ms7("))
      try {
        NInterfaceAlpha NInterfaceAlpha = new NInterfaceAlpha((SInterfaceLima)AvInterfaceXray.NInterfaceAlpha(), (PComponentBravo)PInterfaceZulu.NInterfaceAlpha(), bV.NInterfaceAlpha());
        NInterfaceAlpha.NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie());
      } catch (NInterfaceAlpha NInterfaceAlpha) {
        bV.AiInterfaceDelta(ExceptionPrintstacktrace.BInterfaceBravo(NInterfaceAlpha.getLocalizedMessage()), dd.NInterfaceAlpha().DInterfaceCharlie());
      }  
  }
  
  public void P() {
    if (Desktop.isDesktopSupported() && NInterfaceAlpha.A() != null)
      try {
        Desktop.getDesktop().open(NInterfaceAlpha.A().L());
      } catch (IOException iOException) {
        Logger.getLogger(f.class.getName()).log(Level.INFO, "Failed to open Data Log folder", iOException);
      }  
  }
  
  public void Q() {
    if (i.NInterfaceAlpha().NInterfaceAlpha("kjlkgoi098")) {
      dd.NInterfaceAlpha().NetworkInBPackage().ExceptionPrintstacktrace(hb.AcInterfaceUniform);
    } else {
      dd.NInterfaceAlpha().NetworkInBPackage().setSelectedIndex(0);
    } 
  }
  
  public void R() {
    if (dd.NInterfaceAlpha().NetworkInBPackage() != null)
      dd.NInterfaceAlpha().NetworkInBPackage().setSelectedIndex(0); 
  }
  
  public void S() {
    if (T.NInterfaceAlpha().DInterfaceCharlie() == null)
      bV.AiInterfaceDelta("No EcuConfiguration Loaded!", bV.DInterfaceCharlie()); 
    NInterfaceAlpha NInterfaceAlpha = new NInterfaceAlpha(T.NInterfaceAlpha().DInterfaceCharlie());
    NInterfaceAlpha.NInterfaceAlpha(bV.DInterfaceCharlie());
  }
  
  public void i(String paramString) {
    NInterfaceAlpha.NInterfaceAlpha(dd.NInterfaceAlpha().DInterfaceCharlie(), paramString);
  }
  
  public void T() {
    AcInterfaceUniform AcInterfaceUniform = new AcInterfaceUniform(this);
    AcInterfaceUniform.BInterfaceBravo("userParameter_Timeout in Minutes", NInterfaceAlpha.NInterfaceAlpha().DInterfaceCharlie(NInterfaceAlpha.ag, NInterfaceAlpha.ah));
    String str1 = "Once you enter NInterfaceAlpha password for NInterfaceAlpha password protected dialog\nit will be cached for the set number of minutes without\nthe need to re-enter for any dialog using the same password.\Isoptimizeddrawingenabled\nNote: The Cache is cleared when closing the project.";
    String str2 = bV.NInterfaceAlpha("{Timeout in Minutes}", true, str1, true, dd.NInterfaceAlpha().DInterfaceCharlie(), AcInterfaceUniform, null);
    if (str2 != null && !str2.isEmpty())
      try {
        int i = Integer.parseInt(str2);
        NInterfaceAlpha.NInterfaceAlpha().BInterfaceBravo(NInterfaceAlpha.ag, str2);
        W.NInterfaceAlpha(i);
      } catch (NumberFormatException numberFormatException) {
        bV.AiInterfaceDelta("Time must be NInterfaceAlpha valid integer.", dd.NInterfaceAlpha().DInterfaceCharlie());
      }  
  }
  
  void NInterfaceAlpha(String[] paramArrayOfString) {
    if (paramArrayOfString.length < 4) {
      AcInterfaceDelta.NInterfaceAlpha(UIInBePackage.f.ThreadedInIPackage);
      System.exit(0);
    } 
    String str1 = paramArrayOfString[1];
    String str2 = paramArrayOfString[2];
    String str3 = paramArrayOfString[3];
    v v = new v(this, str1, str2, str3);
    try {
      SwingUtilities.invokeAndWait(v);
    } catch (InterruptedException interruptedException) {
      Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, interruptedException);
    } catch (InvocationTargetException invocationTargetException) {
      Logger.getLogger(f.class.getName()).log(Level.SEVERE, (String)null, invocationTargetException);
    } 
    System.exit(0);
  }
  
  public void NInterfaceAlpha(R paramR, GComponentCj paramcj) {
    NetworkInBPackage NetworkInBPackage = NetworkInBPackage.BInterfaceBravo(paramR.O(), paramcj.NInterfaceAlpha(), paramcj.BInterfaceBravo(), paramcj.DInterfaceCharlie());
    GComponentCx GComponentCx = new GComponentCx(paramR);
    GComponentCx.BInterfaceBravo(paramcj.BInterfaceBravo());
    NetworkInBPackage.BInterfaceBravo((Isoptimizeddrawingenabled)GComponentCx);
    paramR.UIInBePackage().BInterfaceBravo(NetworkInBPackage);
  }
  
  public void NInterfaceAlpha(R paramR, int paramInt) {
    NetworkInBPackage NetworkInBPackage = NetworkInBPackage.AiInterfaceDelta(paramR.O(), paramInt);
    GComponentCx GComponentCx = new GComponentCx(paramR);
    NetworkInBPackage.BInterfaceBravo((Isoptimizeddrawingenabled)GComponentCx);
    paramR.UIInBePackage().BInterfaceBravo(NetworkInBPackage);
  }
}


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