import java.applet.Applet;
import java.awt.*;
import java.io.*;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.Properties;

public class DataVisualizerJ extends Applet implements DIV, LD2
{
	private boolean l1l1I;
	private short l1IllI[][][];
	private int I1lI11[][][];
	private int IllIl1[][];
	private int lIlll1[][];
	private int lI1lI1[];
	private int Il1Ill[];
	private float I11I1l[];
	private float llIl1I[] = {
		1.0F, 0.76F, 0.45F
	};
	private float l11lII[] = {
		0.0F, 0.0F, 0.0F
	};
	private byte l1llll[] = {
		67, 67, 66, 65, 64, 62, 60, 58, 55, 52, 
		49, 46, 44, 42, 40, 38, 38, 37, 37, 37, 
		38, 38, 40, 42, 44, 46, 49, 52, 55, 58, 
		60, 62, 64, 65, 66, 67
	};
	private int II1IIl;
	private int l1I1Il;
	private int I1lIII;
	private int IlllII;
	private int lIllll;
	private int Il1IlI;
	private int I1ll1I;
	private int l1II1l;
	private int lIIl1I;
	private int lllI1I;
	private int lIII1l;
	double IlIIl1;
	private String string_a;
	private String string_b;
	private String string_c;
	private String string_d;
	private Color I11llI;
	private final Color IIII11 = Color.getHSBColor(0.8F, 0.1F, 0.4F);
	private static final float l11Il1 = 0.78F;
	private III l1lll1[];
	private DataBall II1lI1;
	private Rectangle IlIlIl[];
	private Rectangle I1IIll;
	private Rectangle IIlI1l;
	private Rectangle Ill11;
	private Rectangle llll1I;
	private String stringArray_a[];
	private String stringArray_b[];
	private volatile int ll111;
	private volatile int Il111;
	private boolean I111l;
	private boolean lIIIll;
	private volatile boolean II1II;
	private boolean IlIlI[];
	private final int I1Ill = 460;
	private final int IIlII = 230;
	private final int l1Ill1 = 800;
	private final int I1llI1 = 545;
	private final int lIlIll = 7;
	private final int lI1I1l = 80;
	private final int ll1l1I = 14;
	private final int IIII1l = 12;
	private final int III1lI = 140;
	private final int IIl1lI = 95;
	private final int IIlII1 = 70;
	private final int I1IIlI = 105;
	private final int IlII1I = 310;
	private final int lI1IIl = 430;

	private String string_e;
	//------------------------------------------------------------------
	public DataVisualizerJ()
	{
		string_e = "win";
	}

	private boolean 	boolean_a;
	private String 		stringFont;// font
	private Font 		font_xTitle;
	private Font 		font_bTitle;
	private Font 		jTitle;
	private Color 		color_a;
	private Color 		color_b;
	private Starter 	class_Starter;
	private SD 		class_SD;
	private TD2 		class_TD2;
		LX 		class_LX;
	//------------------------------------------------------------------
	public void init()
	{
		boolean_a = true;
		stringFont = "Serif";
		String stest[] = getToolkit().getFontList();
		for(int ft = 0; ft < stest.length; ft++)
		{
			String nom = stest[ft];
			if("Serif".equals(nom))
				stringFont = stest[ft];
		}
		font_xTitle = new Font(stringFont, 0, 10);
		font_bTitle = new Font(stringFont, 1, 15);
		jTitle = new Font(stringFont, 1, 12);
		
		color_a = Color.getHSBColor(0.2F, 0.8F, 0.99F);
		color_b = Color.getHSBColor(0.3F, 0.8F, 0.8F);
		class_TD2 = null;
		class_SD = null;
		class_Starter = null;
		method_a();
		class_LX = new LX();
	}

	private Image images_a;
	private Graphics graphics_a;
	private Font font_nTitle;
	private int int_a;
	private int int_b;
	private Graphics graphics_b;
	private int int_c;
	private Graphics graphics_c;
	//------------------------------------------------------------------
	private synchronized void method_a()
	{
		resize(545, 430);
		images_a = createImage(545, 430);
		graphics_a = images_a.getGraphics();
		font_nTitle = new Font(stringFont, 0, 12);
		FontMetrics fm = getFontMetrics(font_nTitle);
		int_a = fm.charWidth('0');
		int_b = fm.charWidth(',');
		graphics_b = graphics_a.create(460, 0, 85, 310);
		graphics_b.clipRect(0, 0, 85, 310);
		graphics_b.setFont(font_nTitle);
		int_c = 329;
		int cff = 120;
		graphics_c = graphics_a.create(0, 310, 545, cff);
		graphics_c.clipRect(0, 0, 545, cff);
		graphics_c.setFont(font_nTitle);
		graphics_a.clipRect(0, 0, 460, 310);
		graphics_a.setFont(font_xTitle);
		int_c++;
	}
	private boolean l111l;
	//------------------------------------------------------------------
	public void start()
	{
		boolean_a = true;
		String string_DocumentBase = getDocumentBase().toString();
		boolean boolean_b = false;
		for(int i = 0; (i = string_DocumentBase.indexOf(".")) != -1; string_DocumentBase = string_DocumentBase.substring(i + 1))
		{
			if(!string_e.equals(string_DocumentBase.substring(0, i)))
				continue;
			boolean_b = true;
			break;
		}
		l111l = true;
		II1II = true;
		l1l1I = true;
		l1I1Il = -1;
		Il1IlI = -1;
		lIIl1I = -1;
		String targ = getParameter("datFile");
		String targName = getParameter("Title");
		try
		{
			readFile(targ);
		}
		catch(Exception _ex)
		{
		}
		graphics_a.setColor(Color.black);
		graphics_a.fillRect(0, 0, 460, 310);
		graphics_b.setColor(Color.black);
		graphics_b.fillRect(0, 0, 85, 310);
		graphics_c.setColor(Color.darkGray);
		graphics_c.fillRect(0, 0, 545, 120);
		Ill1lI(graphics_a, Color.green, targName);
		int IlI1Il = lllI1I;
		for(int lI = 1; lI < IlI1Il; lI++)
			IlIlI[lI] = false;

		try
		{
			class_Starter = new Starter(this);
			class_Starter.start();
			return;
		}
		catch(Exception _ex)
		{
		}
	}
	void method_b()
	{
		Font tR = new Font("Serif", 1, 15);
		graphics_a.setFont(tR);
		graphics_a.setColor(Color.white);
		graphics_a.drawString("System error !", 180, 200);
		graphics_a.setFont(font_xTitle);
		repaint();
	}
	//------------------------------------------------------------------
	synchronized boolean readFile(String IIlll1) throws Exception
	{
		String I11IlI[] = llI1II(IIlll1);
		if(I11IlI == null)
		{
			method_b();
			return false;
		}
		FontMetrics fm = getFontMetrics(font_xTitle);
		int nlen = fm.charWidth('0');
		int IIlIII = int_a;
		int ll1IIl = int_b;
		int l1Il11 = 75 / IIlIII;
		int I11I = Integer.parseInt(I11IlI[0]);
		int l1ll = I1lIII;
		IlllII = I11I;
		int I1lllI[] = lI11ll(I11I, l1ll, nlen);
		int l11l1I = I1lllI[0];
		int ll1111 = I1lllI[1];
		String IllI11 = I11IlI[1];
		string_b = I11IlI[2];
		string_c = I11IlI[3];
		String I1IlII = I11IlI[4];
		I1IlII = llIlll(I1IlII, l1Il11, false);
		string_d = I11IlI[6];
		string_d = llIlll(string_d, l1Il11 + 1, false);
		II1IIl = I11I * l1ll;
		int lI1ll1 = 70;
		String l1I1ll[] = new String[I11I];
		String I1l1Il[] = new String[l1ll];
		int II1I = l1II1l = l1ll + I11I + 3;
		II1I += 2;
		IlIlI = new boolean[II1I];
		for(int j = 0; j < II1I; j++)
			IlIlI[j] = false;

		lllI1I = II1I;
		II1I++;
		lIllll = II1I;
		String IllIII[] = new String[++II1I];
		float lIlIl1[] = new float[l1ll];
		int IlII = 0;
		IllIII[IlII] = "\u53CD\u8EE2";
		IlII++;
		IllIII[IlII] = "\u5E73\u5747\u5024";
		IlII++;
		IllIII[IlII] = "\u6BD4\u7387";
		IlII++;
		int IIlI = 0;
		int Il1I = 0;
		int l11l1l[] = new int[II1IIl];
		int Il1lIl = 0;
		int I11Ill = 0;
		int I1II = 0;
		lIIIll = "VERTICAL".equals(I11IlI[7]);
		if(lIIIll)
			II1lI1 = new DataBall(10, 1, I11I);
		else
			II1lI1 = new DataBall(19, 1, I11I);
		int llIII1 = 8;
		for(int llll = 0; llll < l1ll; llll++)
		{
			String llI11l = I11IlI[llIII1];
			llIII1++;
			IllIII[IlII] = llIlll(llI11l, l1Il11, false);
			I1l1Il[llll] = llIlll(llI11l, l11l1I, true);
			int I111l1 = I1l1Il[llll].length();
			Il1lIl = I111l1 <= Il1lIl ? Il1lIl : I111l1;
			IlII++;
			lIlIl1[llll] = (float)Integer.parseInt(I11IlI[llIII1]) / 100F;
			llIII1++;
			String l1111I = I11IlI[llIII1];
			llIII1++;
			int lIIl = 0;
			for(int j = 0; j < I11I; j++)
			{
				l1111I = l1111I.substring(lIIl);
				int I1lI = l1111I.indexOf(",");
				if(I1lI == -1)
					throw new Exception();
				int Il11II = Integer.parseInt(l1111I.substring(0, I1lI));
				IIlI = IIlI <= Il11II ? Il11II : IIlI;
				I1II += Il11II;
				l11l1l[Il1I] = Il11II;
				Il1I++;
				lIIl = I1lI + 1;
			}

		}

		I11I1l = lIlIl1;
		IlIIl1 = I1II;
		String l1l1lI = I11IlI[5];
		int lIll = 0;
		for(int lI1l = 0; lI1l < I11I; lI1l++)
		{
			l1l1lI = l1l1lI.substring(lIll);
			int l1Il = l1l1lI.indexOf(",");
			if(l1Il == -1)
				throw new Exception();
			String IlI1ll = l1l1lI.substring(0, l1Il);
			IllIII[IlII] = llIlll(IlI1ll, l1Il11, false);
			l1I1ll[lI1l] = llIlll(IlI1ll, ll1111, true);
			int II11I1 = l1I1ll[lI1l].length();
			I11Ill = II11I1 <= I11Ill ? I11Ill : II11I1;
			IlII++;
			lIll = l1Il + 1;
		}

		IllIII[IlII] = "\u5168\u30B0\u30E9\u30D5";
		IlII++;
		int llII1l;
		if("auto".equals(IllI11))
			llII1l = IIlI;
		else
			llII1l = Integer.parseInt(IllI11);
		Il1Ill = new int[3];
		if(llII1l < 100)
		{
			Il1Ill[0] = 60;
			Il1Ill[1] = 10;
			Il1Ill[2] = 100;
		} else
		{
			String IlII11 = "" + llII1l;
			int lI1lll = (int)Math.pow(10D, IlII11.length() - 1);
			Il1Ill[1] = llII1l <= lI1lll * 2 ? lI1lll / 10 : lI1lll / 2;
			int ll1l = LX.lIll((float)llII1l / (float)Il1Ill[1]);
			Il1Ill[2] = (ll1l + 1) * Il1Ill[1];
			Il1Ill[0] = (ll1l / 2 + 1) * Il1Ill[1];
		}
		IllIII[IlII] = "" + Il1Ill[0];
		IlII++;
		IllIII[IlII] = "plus " + Il1Ill[1];
		IlII++;
		IllIII[IlII] = I1IlII;
		int I1I1Il = lIIIll ? 445 / l1ll : 445 / I11I;
		if(I1I1Il > 150)
			I1I1Il = 150;
		int Il1I1I = I1I1Il / IIlIII;
		I1ll1I = I1I1Il;
		int I1IIl1 = 0;
		l1lll1 = new III[II1IIl];
		int llllI1 = I1I1Il + 80 + 10;
		int lIIlIl = 31;
		int l1ll1I = llllI1;
		int l11I1l = lIIlIl;
		int IIIIll;
		int llllII;
		if(lIIIll)
		{
			llllII = 14;
			IIIIll = 0;
		} else
		{
			llllII = 0;
			IIIIll = I1I1Il;
		}
		for(int l1ll11 = 0; l1ll11 < l1ll; l1ll11++)
		{
			for(int jj = 0; jj < I11I; jj++)
			{
				int l1Il1l = l11l1l[I1IIl1];
				String II11ll;
				if(l1Il1l == -1)
					II11ll = "--";
				else
					II11ll = "" + l1Il1l;
				if(l1Il1l > llII1l || II11ll.length() > Il1I1I)
					II11ll = "EX";
				int II1llI = l1ll1I - II11ll.length() * IIlIII;
				l1lll1[I1IIl1] = new III(II11ll, l1Il1l, llII1l, lI1ll1, l1ll11, II1llI, l11I1l, ll1IIl);
				l11I1l += llllII;
				l1ll1I += IIIIll;
				I1IIl1++;
			}

			if(lIIIll)
			{
				l1ll1I += I1I1Il;
				l11I1l = lIIlIl;
			} else
			{
				l1ll1I = llllI1;
				l11I1l += 14;
			}
		}

		l1IllI = new short[6][36][II1IIl];
		I1lI11 = new int[6][36][3];
		lI1lI1 = LX.Ill(lIlll1[1], IllIl1[1], I1lI11, lI1ll1, 800, 230, 105, I11Ill * nlen, Il1lIl * nlen, 20);
		stringArray_a = I1l1Il;
		II1lI1.Il = l1I1ll;
		stringArray_b = IllIII;
		IlIlIl = new Rectangle[II1I];
		for(int i = 0; i < II1I; i++)
			IlIlIl[i] = new Rectangle(460, 7 + i * 14, 80, 14);

		if(lIIIll)
			II1lI1.l1();
		return true;
	}

	//------------------------------------------------------------------
	public void stop()
	{
		boolean_a = true;
		if(class_TD2 != null)
			class_TD2.stop();
		if(class_SD != null)
			class_SD.stop();
		if(class_Starter != null)
			class_Starter.stop();
		class_TD2 = null;
		class_SD = null;
		class_Starter = null;
		l1lll1 = new III[1];
		l1lll1 = null;
		System.gc();
	}
	//------------------------------------------------------------------
	public void paint(Graphics g)
	{
		if(images_a != null)
			g.drawImage(images_a, 0, 0, this);
	}
	//------------------------------------------------------------------
	public void update(Graphics g)
	{
		boolean painted = false;
		synchronized(this)
		{
			painted = I111l;
		}
		if(painted)
			paint(g);
	}
	//------------------------------------------------------------------
	String[] llI1II(String targ)
	{
		String cheq = getParameter("type");
		String vst = getParameter("v");
		int v = Integer.parseInt(vst);
		String res[] = new String[8 + v * 3];
			I1lIII = v;
			lIII1l = v + 3;
			res[0] = getParameter("h");
			res[1] = getParameter("max");
			res[2] = getParameter("upper");
			res[3] = getParameter("child");
			res[4] = getParameter("upperName");
			res[5] = getParameter("hItems");
			res[6] = getParameter("title");
			res[7] = getParameter("dir");
			int c = 8;
			for(int i = 0; i < v; i++)
			{
				res[c] = getParameter("vNam" + i);
				c++;
				res[c] = getParameter("vcolor" + i);
				c++;
				res[c] = getParameter("vVal" + i);
				c++;
			}

			return res;
	}

	final int IlI1lI(float Ill1Il, int comp)
	{
		int l1I1I1 = (int)(Ill1Il * 10000F);
		int I1l1ll = l1I1I1 % 100;
		l1I1I1 -= I1l1ll;
		if(Ill1Il > 0.0F && I1l1ll > comp)
			l1I1I1 += 100;
		return l1I1I1 / 100;
	}

	final String llIlll(String ss, int m, boolean trm)
	{
		String s = ss;
		int ml = m;
/*		for(int ex = -1; (ex = s.indexOf("_")) != -1;)
			s = s.substring(0, ex) + " " + s.substring(ex + 1);

		for(int ex = 0; (ex = s.indexOf("{")) != -1;)
		{
			if(ex + 2 > ml)
			{
				s = s.substring(0, ex);
				break;
			}
			ml--;
			int ed = s.substring(ex + 1).indexOf("}");
			if(ed == -1)
				return "unknown";
			ed += ex + 1;
			String sx = s.substring(ex + 1, ed);
			int res;
			try
			{
				res = Integer.parseInt(sx);
			}
			catch(Exception _ex)
			{
				return "unknown";
			}
			int rH = res >> 8 & 0xff;
			byte rL[] = {
				(byte)(res & 0xff)
			};
			String lt = new String(rL, rH);
			s = s.substring(0, ex) + lt + s.substring(ed + 1);
		}
		if(s.length() > ml)
			s = s.substring(0, ml);
		if(ml != m && trm)
		{
			int countM = m - ml;
			for(int cxx = 0; cxx < countM; cxx++)
				s = s + " ";

		}
*/		return s;
	}

	int[] lI11ll(int l1lIIl, int II1I1I, int l1IlII)
	{
		int l1I111;
		int I1l1II;
		if(l1lIIl >= II1I1I)
		{
			l1I111 = l1lIIl;
			I1l1II = II1I1I;
		} else
		{
			l1I111 = II1I1I;
			I1l1II = l1lIIl;
		}
		int Ill1l1 = l1I111 * 2 - 1;
		int lIl11l = 140 / Ill1l1;
		if(lIl11l > 12)
			lIl11l = 12;
		int ll11lI = lIl11l * Ill1l1;
		int Il11I1 = lIl11l * 2;
		int I111ll[][] = new int[2][l1I111];
		int IlIIIl = Il11I1 * 2;
		for(int i = 0; i < l1I111; i++)
		{
			int IIlIlI = ll11lI - IlIIIl * i;
			I111ll[0][i] = IIlIlI;
			I111ll[1][i] = IIlIlI - Il11I1;
		}

		int l11III = 140 - I1l1II * lIl11l;
		int lI111I = I1l1II != 1 ? l11III / (I1l1II - 1) : 0;
		if(lI111I > Il11I1)
			lI111I = Il11I1;
		int l1llII = lIl11l * I1l1II + lI111I * (I1l1II - 1);
		int II1lll = lI111I * 2;
		int llI1Il[][] = new int[2][I1l1II];
		int I1II1I = Il11I1 + II1lll;
		for(int i = 0; i < I1l1II; i++)
		{
			int IIlIlI = l1llII - I1II1I * i;
			llI1Il[0][i] = IIlIlI;
			llI1Il[1][i] = IIlIlI - Il11I1;
		}

		if(IlIIIl > 80)
			IlIIIl = 80;
		if(I1II1I > 80)
			I1II1I = 80;
		if(l1lIIl >= II1I1I)
		{
			lIlll1 = I111ll;
			IllIl1 = llI1Il;
			int I1llll[] = {
				I1II1I / l1IlII - 1, IlIIIl / l1IlII - 1
			};
			return I1llll;
		} else
		{
			lIlll1 = llI1Il;
			IllIl1 = I111ll;
			int I1llll[] = {
				IlIIIl / l1IlII - 1, I1II1I / l1IlII - 1
			};
			return I1llll;
		}
	}

/*	void Il1III()
	{
		images_a = createImage(545, 430);
		graphics_a = images_a.getGraphics();
		graphics_a.setColor(Color.black);
		graphics_a.fillRect(0, 0, 545, 430);
		Font tR = new Font("Courier", 1, 15);
		graphics_a.setFont(tR);
		graphics_a.setColor(Color.green);
		graphics_a.drawString("Format Error", 150, 120);
		graphics_a.drawString("Please submit bug report to nvl", 150, 140);
	}
*/

	private final synchronized void II111I()
	{
		l1I1Il = -1;
	}

	private final synchronized void lll1Il()
	{
		I111l = false;
	}

	private final synchronized void IIIlII()
	{
		I111l = true;
	}

	private final synchronized void IlIII1(int Il1I)
	{
		Graphics nD = graphics_b;
		int I11I = (Il1I - 7) / 14;
		l1I1Il = I11I;
		nD.setColor(Color.red);
		if(I11I != -1)
			nD.drawString(stringArray_b[I11I], 5, IlIlIl[I11I].y + 12);
		repaint();
	}

	private final synchronized void l1l11l(int I1III1)
	{
		Graphics nD = graphics_c;
		int lI11I1 = (I1III1 - int_c) / 14;
		lIIl1I = lI11I1;
		int yy = 14 * lIIl1I + 31;
		nD.setColor(Color.red);
		if(lI11I1 != -1)
			nD.drawString(stringArray_b[lI11I1 + lIII1l], 15, yy);
		repaint();
	}

	void lII1ll(int I1III1, int x, int y)
	{
		if(llll1I.inside(x, y) && I1III1 == (y - int_c) / 14)
		{
			boolean_a = true;
			if(class_SD != null)
				class_SD.stop();
			class_SD = null;
			class_TD2 = new TD2(this, I1III1, stringArray_b[I1III1 + lIII1l]);
			class_TD2.start();
			return;
		} else
		{
			Graphics nD = graphics_c;
			int yy = 14 * I1III1 + 31;
			nD.setColor(Color.white);
			nD.drawString(stringArray_b[I1III1 + lIII1l], 15, yy);
			repaint();
			lIIl1I = -1;
			return;
		}
	}

	synchronized void lIII11(int I1II, int llll, int lIIl, III I1l1lI[], Rectangle ll1III[], Graphics l1lIlI, Graphics II1II1, 
			String lI11Il[], boolean l1I11I[], int lIl1ll)
	{
		if(!ll1III[I1II].inside(llll, lIIl))
		{
			Color ll;
			if(I1II < 3 || I1II >= lIl1ll)
				ll = Color.white;
			else
				ll = l1I11I[I1II] ? color_b : Color.white;
			II1II1.setColor(ll);
		} else
		{
			if(I1II > lIl1ll)
			{
				boolean_a = true;
				if(class_SD != null)
					class_SD.stop();
				class_SD = null;
				class_TD2 = new TD2(this, -1, lI11Il[I1II]);
				class_TD2.start();
				return;
			}
			if(I1II == lIl1ll)
			{
				int llIIIl[] = Il1Ill;
				llIIIl[0] = (llIIIl[0] + llIIIl[1]) % llIIIl[2];
				int IlII = I1II - 1;
				lI11Il[IlII] = "" + llIIIl[0];
				II1II1.setColor(I11llI);
				II1II1.fillRect(0, ll1III[IlII].y, ll1III[IlII].width, ll1III[IlII].height);
				l1I11I[IlII] = false;
				II1II1.setColor(Color.white);
				II1II1.drawString(lI11Il[IlII], 5, ll1III[IlII].y + 12);
			} else
			if(I1II == 1)
			{
				if(IIll11(l1I11I[1], I1l1lI))
					l1I11I[1] = !l1I11I[1];
				l1I11I[2] = false;
				II1II1.setColor(Color.white);
			} else
			if(I1II == 2)
			{
				if(lllllI(l1I11I[2], I1l1lI))
					l1I11I[2] = !l1I11I[2];
				l1I11I[1] = false;
				II1II1.setColor(Color.white);
			} else
			if(I1II == 0)
			{
				Graphics nB = graphics_a;
				try
				{
					synchronized(II1lI1)
					{
						II1lI1.l1();
						int I1lI = II1lI1.ll;
						int IllI = II1lI1.lI;
						lIIIII(l1IllI[IllI][I1lI], lI1lI1, I1lI11[IllI][I1lI], l1lll1, nB, stringArray_a, I1lIII, Il1IlI, II1lI1, I11I1l, llIl1I);
					}
				}
				catch(Exception _ex)
				{
					brg();
				}
				l1I11I[2] = false;
				if(l1I11I[1])
				{
					nB.setColor(Color.white);
					nB.setFont(jTitle);
					nB.drawString(string_a, 45, 160);
					nB.setFont(font_xTitle);
				}
				II1II1.setColor(Color.white);
			} else
			{
				int l1Il = II1IIl;
				int Ill1I1 = l1II1l;
				if(I1II < Ill1I1)
				{
					if(l1l1I)
					{
						l1lIlI.setColor(Color.white);
						for(int i = 0; i < l1Il; i++)
							if(I1l1lI[i].IIl)
							{
								I1l1lI[i].IIl = false;
								l1lIlI.drawString(I1l1lI[i].I1I, I1l1lI[i].l1l, I1l1lI[i].II1);
							}

						II1II1.setColor(Color.white);
						II1II1.drawString(lI11Il[Ill1I1], 5, ll1III[Ill1I1].y + 12);
						l1I11I[Ill1I1] = false;
						int II1I = Ill1I1 + 1;
						II1II1.drawString(lI11Il[II1I], 5, ll1III[II1I].y + 12);
						l1I11I[II1I] = false;
						Il1IlI = -1;
						l1l1I = false;
					}
					int lI1l = I1II - 3;
					int ll1l = I1lIII;
					int Il1I = IlllII;
					int lIll;
					int I11I;
					int l1ll;
					if(lI1l < ll1l)
					{
						lIll = lI1l * Il1I;
						I11I = 1;
						l1ll = Il1I;
					} else
					{
						lIll = lI1l - ll1l;
						I11I = Il1I;
						l1ll = ll1l;
					}
					boolean Il1lII = l1I11I[I1II];
					Color IIlI = Il1lII ? Color.white : color_b;
					l1lIlI.setColor(IIlI);
					for(int i = 0; i < l1ll; i++)
					{
						if(I1l1lI[lIll].setSt(Il1lII))
							l1lIlI.drawString(I1l1lI[lIll].I1I, I1l1lI[lIll].l1l, I1l1lI[lIll].II1);
						lIll += I11I;
					}

					II1II1.setColor(IIlI);
					l1I11I[I1II] = !Il1lII;
					if(Il1IlI != -1 && !I1l1lI[Il1IlI].IIl)
						Il1IlI = -1;
					l111l = false;
				} else
				if(I1II == Ill1I1)
				{
					l1lIlI.setColor(Color.white);
					for(int i = 0; i < l1Il; i++)
					{
						if(I1l1lI[i].IIl)
							l1lIlI.drawString(I1l1lI[i].I1I, I1l1lI[i].l1l, I1l1lI[i].II1);
						else
							I1l1lI[i].IlIl();
						if(I1l1lI[i].lll)
							I1l1lI[i].lll = false;
					}

					l111l = true;
					l1l1I = true;
					Il1IlI = -1;
				} else
				if(I1II == Ill1I1 + 1)
				{
					int l11I1I = Il1Ill[0];
					for(int i = 0; i < l1Il; i++)
					{
						if(I1l1lI[i].lll)
							I1l1lI[i].lll = false;
						if(I1l1lI[i].l11 >= l11I1I)
						{
							I1l1lI[i].IlIl();
							l1lIlI.setColor(color_b);
							l1lIlI.drawString(I1l1lI[i].I1I, I1l1lI[i].l1l, I1l1lI[i].II1);
						} else
						if(I1l1lI[i].IIl)
						{
							I1l1lI[i].IIl = false;
							l1lIlI.setColor(Color.white);
							l1lIlI.drawString(I1l1lI[i].I1I, I1l1lI[i].l1l, I1l1lI[i].II1);
						}
					}

					l1l1I = true;
					l111l = false;
					Il1IlI = -1;
				}
				if(l1l1I)
				{
					II1II1.setColor(Color.white);
					int l1 = lIl1ll;
					for(int i = 3; i < l1; i++)
					{
						II1II1.drawString(lI11Il[i], 5, ll1III[i].y + 12);
						l1I11I[i] = false;
					}

					l1I11I[I1II] = true;
					II1II1.setColor(color_b);
				}
				l1I11I[1] = l1I11I[2] = false;
				int I1lI = II1lI1.ll;
				int IllI = II1lI1.lI;
				try
				{
					lIIIII(l1IllI[IllI][I1lI], lI1lI1, I1lI11[IllI][I1lI], l1lll1, graphics_a, stringArray_a, I1lIII, Il1IlI, II1lI1, I11I1l, llIl1I);
				}
				catch(Exception _ex) { }
			}
		}
		II1II1.drawString(lI11Il[I1II], 5, ll1III[I1II].y + 12);
		II111I();
		repaint();
	}

	void brg()
	{
		System.out.println("This must be VM's bug. Please switch your VM to the other one !");
		Graphics nD = graphics_a;
		nD.setColor(Color.black);
		nD.fillRect(0, 0, 460, 310);
		nD.setColor(Color.white);
		nD.drawString("Your current JVM is not capable to use this function", 40, 40);
		nD.drawString("To restart this Applet, please drag the mouse on this window.", 40, 55);
		repaint();
	}

	private synchronized void IIl1ll(int IlIIlI, int I1III1)
	{
		Graphics llIlII = graphics_c;
		Graphics l11lll = graphics_a;
		int lI11I1;
		int ll11ll;
		if(lIIIll)
		{
			lI11I1 = (IlIIlI - 95) / I1ll1I;
			ll11ll = (I1III1 - int_c) / 14;
		} else
		{
			lI11I1 = (I1III1 - int_c) / 14;
			ll11ll = (IlIIlI - 95) / I1ll1I;
		}
		int II1I = Il1IlI;
		int l1I1l1 = lI11I1 * IlllII + ll11ll;
		III I1l11l = l1lll1[l1I1l1];
		if(!I1l11l.IIl)
			return;
		Color l1ll = l111l ? Color.white : color_b;
		llIlII.setColor(l1ll);
		if(II1I == l1I1l1)
		{
			llIlII.drawString(I1l11l.I1I, I1l11l.l1l, I1l11l.II1);
			Il1IlI = -1;
		} else
		{
			if(II1I != -1)
			{
				III Ill11I = l1lll1[II1I];
				llIlII.drawString(Ill11I.I1I, Ill11I.l1l, Ill11I.II1);
			}
			llIlII.setColor(color_a);
			llIlII.drawString(I1l11l.I1I, I1l11l.l1l, I1l11l.II1);
			Il1IlI = l1I1l1;
		}
		int Il11Il = II1lI1.ll;
		int I11III = II1lI1.lI;
		try
		{
			lIIIII(l1IllI[I11III][Il11Il], lI1lI1, I1lI11[I11III][Il11Il], l1lll1, l11lll, stringArray_a, I1lIII, Il1IlI, II1lI1, I11I1l, llIl1I);
		}
		catch(Exception _ex) { }
		if(IlIlI[1])
		{
			l11lll.setColor(Color.white);
			l11lll.setFont(jTitle);
			l11lll.drawString(string_a, 45, 160);
			l11lll.setFont(font_xTitle);
		}
		IlIlI[2] = false;
		repaint();
	}

	boolean IIll11(boolean l11II1, III l1I1I1[])
	{
		Graphics IlIllI = graphics_a;
		int ll1lll = II1lI1.ll;
		int Il1IIl = II1lI1.lI;
		try
		{
			lIIIII(l1IllI[Il1IIl][ll1lll], lI1lI1, I1lI11[Il1IIl][ll1lll], l1I1I1, IlIllI, stringArray_a, I1lIII, Il1IlI, II1lI1, I11I1l, llIl1I);
		}
		catch(Exception _ex) { }
		if(l11II1)
			return true;
		int I11I1I = 0;
		int I1l1ll = 0;
		int II1l11 = II1IIl;
		for(int lI = 0; lI < II1l11; lI++)
			if(l1I1I1[lI].IIl)
			{
				I11I1I += l1I1I1[lI].l11;
				I1l1ll++;
			}

		if(I1l1ll == 0)
			return false;
		I1l1ll = LX.lIll((float)I11I1I / (float)I1l1ll);
		int llIIlI = IlI1lI((float)I11I1I / (float)IlIIl1, 45);
		String Ill1Il = "" + I11I1I;
		int l1ll1l = Ill1Il.length();
		int IIlIl1 = (l1ll1l - 1) / 3;
		int I1II11 = l1ll1l - IIlIl1 * 3;
		try
		{
			for(int qq = 0; qq < IIlIl1; qq++)
			{
				Ill1Il = Ill1Il.substring(0, I1II11) + "," + Ill1Il.substring(I1II11);
				I1II11 += 4;
			}

		}
		catch(Exception _ex) { }
		String lIlIII = "" + I1l1ll;
		l1ll1l = lIlIII.length();
		IIlIl1 = (l1ll1l - 1) / 3;
		I1II11 = l1ll1l - IIlIl1 * 3;
		try
		{
			for(int qq = 0; qq < IIlIl1; qq++)
			{
				lIlIII = lIlIII.substring(0, I1II11) + "," + lIlIII.substring(I1II11);
				I1II11 += 4;
			}

		}
		catch(Exception _ex) { }
		String lI1lII = "\u9078\u629E\u3055\u308C\u305F\u30C7\u30FC\u30BF\u306E\u5408\u8A08 : " + Ill1Il + " (" + llIIlI + "%)\uFF0F \u5E73\u5747\u5024 : " + lIlIII;
		IlIllI.setColor(Color.white);
		IlIllI.setFont(jTitle);
		IlIllI.drawString(lI1lII, 45, 160);
		IlIllI.setFont(font_xTitle);
		string_a = lI1lII;
		return true;
	}

	boolean lllllI(boolean IlIl11, III Ill1ll[])
	{
		Graphics IIlI11 = graphics_a;
		float Il1lll[] = I11I1l;
		int lI1III = II1lI1.ll;
		int ll1lII = II1lI1.lI;
		if(IlIl11)
		{
			try
			{
				lIIIII(l1IllI[ll1lII][lI1III], lI1lI1, I1lI11[ll1lII][lI1III], Ill1ll, IIlI11, stringArray_a, I1lIII, Il1IlI, II1lI1, Il1lll, llIl1I);
			}
			catch(Exception _ex) { }
		} else
		{
			int llII1I = I1lIII;
			int l1I1lI[][] = new int[3][llII1I];
			for(int j = 0; j < llII1I; j++)
				l1I1lI[1][j] = j;

			int I1IllI = II1IIl;
			int I11IIl = 0;
			for(int lI = 0; lI < I1IllI; lI++)
				if(Ill1ll[lI].IIl)
				{
					l1I1lI[0][Ill1ll[lI].IlI] += Ill1ll[lI].l11;
					I11IIl += Ill1ll[lI].l11;
				}

			if(I11IIl == 0)
				return false;
			try
			{
				lIIIII(l1IllI[ll1lII][lI1III], lI1lI1, I1lI11[ll1lII][lI1III], Ill1ll, IIlI11, stringArray_a, llII1I, Il1IlI, II1lI1, Il1lll, l11lII);
			}
			catch(Exception _ex) { }
			for(int lI = 0; lI < llII1I; lI++)
				l1I1lI[2][lI] = IlI1lI((float)(l1I1lI[0][lI] * 10) / (float)I11IIl, 66);

			try
			{
				LX.Il1I(l1I1lI, 0, l1I1lI[0].length - 1);
			}
			catch(Exception _ex) { }
			int l1lII1 = 345;
			int II1l1l = 130;
			int l11IlI = 0;
			String lIl1Il[] = stringArray_b;
			IIlI11.setFont(font_nTitle);
			for(int lI = 0; lI < llII1I; lI++)
				if(l1I1lI[0][lI] != 0)
				{
					l11IlI = (int)(0.3F * (float)l1I1lI[2][lI]);
					l1lII1 -= l11IlI;
					IIlI11.setColor(Color.getHSBColor(Il1lll[l1I1lI[1][lI]], 0.78F, 0.65F));
					IIlI11.drawLine(l1lII1, II1l1l, l1lII1, 160);
					IIlI11.fillRect(l1lII1, 160, l11IlI, 30);
					IIlI11.fillRect(l1lII1, II1l1l, 115, 14);
					IIlI11.setColor(Color.white);
					String I1l1I1 = "  " + (float)l1I1lI[2][lI] / 10F;
					if((l11IlI = I1l1I1.indexOf(".")) != -1)
						I1l1I1 = I1l1I1.substring(0, l11IlI + 2);
					IIlI11.drawString(lIl1Il[l1I1lI[1][lI] + 3] + I1l1I1 + " %", l1lII1 + 2, II1l1l + 12);
					II1l1l -= 15;
				}

			IIlI11.setFont(font_xTitle);
		}
		return true;
	}

	public boolean handleEvent(Event e)
	{
		if(boolean_a)
			return false;
		int x = e.x;
		int y = e.y;
		int et = e.id;
		switch(et)
		{
		case 503: 
		case 504: 
		default:
			break;

		case 501: 
			if(IIlI1l.inside(x, y))
			{
				ll111 = x / 12;
				Il111 = y / 12;
				synchronized(this)
				{
					II1II = false;
				}
			} else
			if(I1IIll.inside(x, y))
				IlIII1(y);
			else
			if(llll1I.inside(x, y))
				l1l11l(y);
			else
			if(Ill11.inside(x, y))
				IIl1ll(x, y);
			return true;

		case 506: 
			ll111 = x / 12;
			Il111 = y / 12;
			return true;

		case 502: 
		case 505: 
			if(II1II)
			{
				if(l1I1Il > -1)
				{
					lIII11(l1I1Il, x, y, l1lll1, IlIlIl, graphics_c, graphics_b, stringArray_b, IlIlI, lllI1I);
					return true;
				}
				if(lIIl1I > -1)
				{
					lII1ll(lIIl1I, x, y);
					return true;
				}
				break;
			}
			synchronized(this)
			{
				II1II = true;
			}
			return true;
		}
		return false;
	}

	public void IIll11()
	{
		boolean_a = false;
		do
			try
			{
				I1I1I1(stringArray_a, lI1lI1, graphics_a, l1IllI, I1lI11, l1lll1, I11I1l, llIl1I);
			}
			catch(InterruptedException _ex) { }
		while(true);
	}

	void I1I1I1(String I1II[], int lIll[], Graphics IIlI, short llll[][][], int lIIl[][][], III l1Il[], float I1lI[], 
			float IllI[])
		throws InterruptedException
	{
		int I1l111;
		int Ill1II;
		do
		{
			if(!II1II)
			{
				I1l111 = ll111;
				Ill1II = Il111;
				break;
			}
			Thread.currentThread();
			Thread.sleep(100L);
		} while(true);
		IIlI.clipRect(0, 0, 460, 310);
		IlIlI[1] = IlIlI[2] = false;
		DataBall IlII = II1lI1;
		int ll1l = Il1IlI;
		int l1ll = IlII.ll;
		int II1I = IlII.lI;
		int lI1l = I1lIII;
		int Il1I[][] = new int[4][2];
label0:
		while(!II1II) 
		{
			Il1I[0][0] = ll111;
			Il1I[0][1] = Il111;
			Il1I[1][0] = Il1I[0][0] - I1l111;
			Il1I[1][1] = Il1I[0][1] - Ill1II;
			Il1I[2][0] = Math.abs(Il1I[1][0]);
			Il1I[2][1] = Math.abs(Il1I[1][1]);
			if(Il1I[2][0] * 2 < Il1I[2][1])
				Il1I[2][0] = 0;
			if(Il1I[2][1] * 2 < Il1I[2][0])
				Il1I[2][1] = 0;
			if(Il1I[2][0] != 0)
				Il1I[3][0] = (Il1I[1][0] * IlII.II) / Il1I[2][0];
			else
				Il1I[3][0] = 0;
			if(Il1I[2][1] != 0)
				Il1I[3][1] = Il1I[1][1] / Il1I[2][1];
			else
				Il1I[3][1] = 0;
			if(Il1I[3][1] == 0 && Il1I[3][0] == 0)
			{
				Thread.currentThread();
				Thread.sleep(20L);
				continue;
			}
			do
			{
				if(II1I == 0 && Il1I[3][1] < 0 || II1I == 5 && Il1I[3][1] > 0)
					Il1I[3][1] = 0;
				if(Il1I[2][1] <= 0)
					Il1I[3][1] = 0;
				Il1I[2][1] = Il1I[2][1] - 1;
				if(II1II)
					break label0;
				l1ll = (l1ll + 36 + Il1I[3][0]) % 36;
				II1I += Il1I[3][1];
				lll1Il();
				synchronized(IlII)
				{
					try
					{
						lIIIII(llll[II1I][l1ll], lIll, lIIl[II1I][l1ll], l1Il, IIlI, I1II, lI1l, ll1l, IlII, I1lI, IllI);
					}
					catch(Exception _ex) { }
					IlII.ll = l1ll;
					IlII.lI = II1I;
				}
				repaint();
				Thread.currentThread();
				Thread.sleep(40L);
				I1l111 = Il1I[0][1] - Il111;
				Ill1II = (ll111 - Il1I[0][0]) * IlII.II;
			} while((I1l111 * Il1I[3][1] > 0 || I1l111 == 0) && (Ill1II * Il1I[3][0] > 0 || Ill1II == 0));
			I1l111 = Il1I[0][0];
			Ill1II = Il1I[0][1];
		}
	}

	private final synchronized void lIIIII(short I1IIII[], int I1111l[], int Il11l1[], III l11I1l[], Graphics nD, String l111lI[], int lIll, 
			int lIlI11, DataBall IlII, float ll11II[], float string_DocumentBase[])
		throws Exception
	{
		int ll1ll1 = II1IIl;
		int l1Il = IlII.II;
		Color IIIIl1 = IIII11;
		nD.setColor(Color.black);
		nD.fillRect(0, 0, 460, 310);
		int I1lI = Il11l1[IlII.I];
		do
		{
			int IllI = I1111l[I1lI];
			if(IllI == -30)
				break;
			String llI11I;
			if(IllI >= 0)
				llI11I = IlII.Il[IllI];
			else
				llI11I = l111lI[lIll + IllI];
			I1lI++;
			int I1ll11 = I1111l[I1lI];
			I1lI++;
			int llll = I1111l[I1lI];
			I1lI++;
			int lIIl = I1111l[I1lI];
			nD.setColor(Color.getHSBColor(0.3F, ((float)I1ll11 * string_DocumentBase[0]) / 160F, (float)I1ll11 / 100F));
			nD.drawString(llI11I, llll, lIIl);
			I1lI++;
		} while(true);
		for(int IIlI = 0; IIlI < ll1ll1; IIlI++)
		{
			int l1ll1I = I1IIII[IIlI];
			float lI1Il1 = l1ll1I != lIlI11 ? 0.0F : 0.2F;
			III I1II = l11I1l[l1ll1I];
			int lI1l = Il11l1[0];
			float I11I = ll11II[I1II.IlI];
			boolean IlI1Il = I1II.IIl;
			short Il1lI1[][] = I1II.lI;
			boolean l1l1I1 = false;
			int I11lIl[] = new int[4];
			int llIIll[] = new int[4];
			int Il1I[] = {
				lI1l + 5, lI1l + 8, lI1l + 11, lI1l + 2
			};
			for(int l1ll = 0; l1ll < 4; l1ll++)
			{
				int II11ll = Il1lI1[0][lI1l];
				int II1I = Il1lI1[1][lI1l];
				int ll1l = ++lI1l + 1;
				int IIIl11 = (l1ll + 1) % 4;
				I11lIl[IIIl11] = Il1lI1[0][ll1l] * l1Il + 230;
				llIIll[IIIl11] = Il1lI1[1][ll1l];
				if(II11ll == 0 && IlI1Il)
					lI1l += 2;
				else
				if(II11ll == -1 && IlI1Il)
				{
					l1l1I1 = true;
					lI1l += 2;
				} else
				{
					int IIllII[] = {
						Il1lI1[0][lI1l] * l1Il + 230, Il1lI1[0][ll1l] * l1Il + 230, Il1lI1[0][Il1I[l1ll]] * l1Il + 230, Il1lI1[0][Il1I[l1ll] - 1] * l1Il + 230
					};
					int llllll[] = {
						Il1lI1[1][lI1l], Il1lI1[1][ll1l], Il1lI1[1][Il1I[l1ll]], Il1lI1[1][Il1I[l1ll] - 1]
					};
					if(IlI1Il)
					{
						Color l1Il1l = Color.getHSBColor(I11I, string_DocumentBase[1], (float)II1I / 100F + lI1Il1);
						nD.setColor(l1Il1l);
						nD.fillPolygon(IIllII, llllll, 4);
						nD.setColor(IIIIl1);
						nD.drawPolygon(IIllII, llllll, 4);
					} else
					{
						Color l1Il1l = Color.getHSBColor(I11I, string_DocumentBase[2], 0.5F);
						nD.setColor(l1Il1l);
						nD.drawPolygon(IIllII, llllll, 4);
					}
					lI1l += 2;
				}
			}

			if(l1l1I1)
			{
				Color IllllI = Color.getHSBColor(I11I, string_DocumentBase[2], 0.78F + lI1Il1);
				nD.setColor(IllllI);
				nD.fillPolygon(I11lIl, llIIll, 4);
				nD.setColor(IIIIl1);
				nD.drawPolygon(I11lIl, llIIll, 4);
			}
		}

		IIIlII();
	}


	public void l111l1(int IIlIl1, String lI1lII)
	{
		boolean l1ll1l = IIlIl1 != -1;
		boolean II1l11 = string_c.equals("non") && l1ll1l || string_b.equals("non") && !l1ll1l;
		IIIlII();
		try
		{
			if(II1l11)
			{
				Graphics nD = graphics_a;
				nD.setColor(Color.white);
				nD.setFont(font_bTitle);
				nD.drawString("\u767B\u9332\u3055\u308C\u3066\u307E\u305B\u3093", 150, 130);
				nD.setFont(font_xTitle);
				if(l1ll1l)
				{
					int I1II11 = 14 * lIIl1I + 31;
					graphics_c.setColor(Color.white);
					graphics_c.drawString(stringArray_b[lIIl1I + lIII1l], 15, I1II11);
				} else
				{
					graphics_b.setColor(Color.white);
					graphics_b.drawString(stringArray_b[l1I1Il], 5, IlIlIl[l1I1Il].y + 12);
				}
				repaint();
				Thread.currentThread();
				Thread.sleep(250L);
			} else
			{
				if(IlIlI[1] || IlIlI[2])
				{
					int IlIllI = II1lI1.ll;
					int I1II11 = II1lI1.lI;
					lIIIII(l1IllI[I1II11][IlIllI], lI1lI1, I1lI11[I1II11][IlIllI], l1lll1, graphics_a, stringArray_a, I1lIII, Il1IlI, II1lI1, I11I1l, llIl1I);
				}
				Ill1lI(graphics_a, Color.white, lI1lII);
				repaint();
				Thread.currentThread();
				Thread.sleep(50L);
				String tarSt = l1ll1l ? string_c + lIIl1I : string_b;
				if(readFile(tarSt))
				{
					graphics_a.setColor(Color.white);
					I1l11I(I1lIII, IlllII, IllIl1, lIlll1, l1lll1, l1IllI, I1lI11, graphics_a);
					graphics_a.fillRect(180, 160, 120, 15);
					graphics_b.setColor(Color.black);
					graphics_b.fillRect(0, 0, 85, 310);
					graphics_c.setColor(Color.darkGray);
					graphics_c.fillRect(0, 0, 545, 120);
					repaint();
					Thread.currentThread();
					Thread.sleep(50L);
					l111l = true;
					II1II = true;
					l1l1I = true;
					Il1IlI = -1;
					ll11Il(l1lll1, graphics_c, graphics_b, I11I1l, I1ll1I);
				} else
				{
					if(l1ll1l)
					{
						int I1II11 = 14 * lIIl1I + 31;
						graphics_c.setColor(Color.white);
						graphics_c.drawString(stringArray_b[lIIl1I + lIII1l], 15, I1II11);
					} else
					{
						graphics_b.setColor(Color.white);
						graphics_b.drawString(stringArray_b[l1I1Il], 5, IlIlIl[l1I1Il].y + 12);
					}
					Thread.currentThread();
					Thread.sleep(500L);
				}
			}
			IlIlI[1] = IlIlI[2] = false;
			int ll1lll = II1lI1.ll;
			int Il1IIl = II1lI1.lI;
			l1I1Il = -1;
			lIIl1I = -1;
			lIIIII(l1IllI[Il1IIl][ll1lll], lI1lI1, I1lI11[Il1IIl][ll1lll], l1lll1, graphics_a, stringArray_a, I1lIII, Il1IlI, II1lI1, I11I1l, llIl1I);
			repaint();
			Thread.currentThread();
			Thread.sleep(100L);
			class_SD = new SD(this);
			class_SD.start();
			return;
		}
		catch(Exception _ex)
		{
			method_b();
		}
	}

	public void I1Il1l()
	{
		IIIlII();
		try
		{
			int ll1lll = II1lI1.ll;
			int Il1IIl = II1lI1.lI;
			repaint();
			Thread.currentThread();
			Thread.sleep(50L);
			graphics_a.setColor(Color.green);
			I1l11I(I1lIII, IlllII, IllIl1, lIlll1, l1lll1, l1IllI, I1lI11, graphics_a);
			ll11Il(l1lll1, graphics_c, graphics_b, I11I1l, I1ll1I);
			lIIIII(l1IllI[Il1IIl][ll1lll], lI1lI1, I1lI11[Il1IIl][ll1lll], l1lll1, graphics_a, stringArray_a, I1lIII, Il1IlI, II1lI1, I11I1l, llIl1I);
			repaint();
			Thread.currentThread();
			Thread.sleep(100L);
		}
		catch(Exception _ex) { }
		class_SD = new SD(this);
		class_SD.start();
	}


	void Ill1lI(Graphics nD, Color cl, String tarT)
	{
		Font tR = new Font(stringFont, 1, 15);
		FontMetrics ftR = getFontMetrics(tR);
		int ftLen = ftR.charWidth('0');
		String ttS = "\u30C7\u30FC\u30BF\u540D : " + tarT;
		int fstt = 240 - (ttS.length() / 2 + 3) * ftLen;
		nD.setFont(tR);
		nD.setColor(cl);
		nD.drawString(ttS, fstt, 120);
		nD.drawString(" - Formating -", 190, 140);
		nD.drawRect(180, 160, 120, 15);
		nD.setFont(font_xTitle);
	}

	void ll11Il(III ll1Ill[], Graphics nD, Graphics nL, float lI1lIl[], int Il1I1l)
		throws Exception
	{
		int lIllI1 = I1lIII;
		int Illll1 = IlllII;
		String I1lIl1[] = stringArray_b;
		Rectangle l1II11[] = IlIlIl;
		int I1lI = 0;
		int lI1l = 42;
		nL.setColor(Color.getHSBColor(0.6F, 0.4F, 0.5F));
		nL.fillRect(0, 7, 80, lI1l);
		nL.setColor(Color.white);
		for(int i = 0; i < 3; i++)
		{
			nL.drawString(I1lIl1[I1lI], 5, l1II11[I1lI].y + 12);
			I1lI++;
		}

		repaint();
		Thread.currentThread();
		Thread.sleep(50L);
		int IllI = 14 * lIllI1;
		lI1l += 7;
		nL.setColor(Color.getHSBColor(0.1F, 0.4F, 0.5F));
		nL.fillRect(0, lI1l, 80, IllI);
		nL.setColor(Color.white);
		for(int i = 0; i < lIllI1; i++)
		{
			nL.drawString(I1lIl1[I1lI], 5, l1II11[I1lI].y + 12);
			I1lI++;
		}

		repaint();
		Thread.currentThread();
		Thread.sleep(50L);
		lI1l += IllI;
		IllI = 14 * Illll1;
		nL.setColor(Color.getHSBColor(0.8F, 0.4F, 0.5F));
		nL.fillRect(0, lI1l, 80, IllI);
		nL.setColor(Color.white);
		for(int i = 0; i < Illll1; i++)
		{
			nL.drawString(I1lIl1[I1lI], 5, l1II11[I1lI].y + 12);
			I1lI++;
		}

		repaint();
		Thread.currentThread();
		Thread.sleep(50L);
		lI1l += IllI;
		IllI = 42;
		I11llI = Color.getHSBColor(0.4F, 0.4F, 0.5F);
		nL.setColor(I11llI);
		nL.fillRect(0, lI1l, 80, IllI);
		nL.setColor(Color.white);
		for(int i = 0; i < 3; i++)
		{
			nL.drawString(I1lIl1[I1lI], 5, l1II11[I1lI].y + 12);
			I1lI++;
		}

		repaint();
		Thread.currentThread();
		Thread.sleep(50L);
		lI1l += IllI;
		if(string_b.equals("non"))
			nL.setColor(Color.getHSBColor(0.8F, 0.0F, 0.5F));
		else
			nL.setColor(Color.getHSBColor(0.0F, 0.6F, 0.5F));
		nL.fillRect(0, lI1l, 80, 14);
		nL.setColor(Color.white);
		nL.drawString(I1lIl1[I1lI], 5, l1II11[I1lI].y + 12);
		repaint();
		Thread.currentThread();
		Thread.sleep(50L);
		nD.setColor(Color.white);
		nD.drawString(string_d, 5, 12);
		int Il1I;
		int l1IIl1;
		if(lIIIll)
		{
			Il1I = 3;
			l1IIl1 = lIllI1;
		} else
		{
			Il1I = lIII1l;
			l1IIl1 = Illll1;
		}
		int lIll = 95;
		int I11I = 17;
		int lengTemp = 115;
		for(int i = 0; i < l1IIl1; i++)
		{
			if(lIIIll)
			{
				nD.setColor(Color.getHSBColor(lI1lIl[i], 0.6F, 0.5F));
				nD.fillRect(lIll, 5, Il1I1l, 14);
				nD.setColor(Color.white);
			}
			nD.drawString(I1lIl1[Il1I], lIll + 5, I11I);
			nD.drawLine(lIll, 5, lIll, lengTemp);
			lIll += Il1I1l;
			Il1I++;
		}

		int I11l1I;
		if(!lIIIll)
		{
			Il1I = 3;
			I11l1I = lIllI1;
		} else
		{
			Il1I = lIII1l;
			I11l1I = Illll1;
		}
		I11I = 31;
		int l1ll = 19;
		for(int i = 0; i < I11l1I; i++)
		{
			if(!lIIIll)
			{
				nD.setColor(Color.getHSBColor(lI1lIl[i], 0.6F, 0.5F));
				nD.fillRect(10, l1ll, 80, 14);
				nD.setColor(Color.white);
			}
			String nSt = I1lIl1[Il1I];
			nD.drawString(nSt, 15, I11I);
			I11I += 14;
			l1ll += 14;
			Il1I++;
		}

		int t = II1IIl;
		for(int i = 0; i < t; i++)
		{
			nD.drawString(ll1Ill[i].I1I, ll1Ill[i].l1l, ll1Ill[i].II1);
			if(ll1Ill[i].IlI1)
				ll1Ill[i].I1I = "";
		}

		repaint();
		Thread.currentThread();
		Thread.sleep(50L);
		IIlI1l = new Rectangle(0, 0, 460, 310);
		I1IIll = new Rectangle(460, 7, 80, 14 * (lIllll + 1));
		Ill11 = new Rectangle(95, int_c, Il1I1l * l1IIl1, 14 * I11l1I);
		llll1I = new Rectangle(10, int_c, 80, 14 * I11l1I);
		lIII1l = lIIIll ? lIII1l : 3;
	}

	void I1l11I(int lIIll, int lllII, int II11Il[][], int IlIIII[][], III llII1l[], short l1I1ll[][][], int lllIIl[][][], 
			Graphics nD)
		throws InterruptedException
	{
		int Il1I1I = -3;
		int II1llI = lllII;
		int IlII11 = lIIll;
		int I11Ill = 105;
		int lI1ll1 = 70;
		int lIl111 = 0;
		int lIll = II1IIl - 1;
		for(int l1Il = 0; l1Il < 6; l1Il++)
		{
			nD.fillRect(180, 160, l1Il * 20, 15);
			repaint();
			Thread.currentThread();
			Thread.sleep(50L);
			int ll1IIl = 0;
			int I1lI = 0;
			float Il111l = LX.lI1l(Il1I1I);
			float I1111I = LX.ll1l(Il1I1I);
			float I1l1Il = (float)lI1ll1 * I1111I;
			float IllIII = (float)lI1ll1 * Il111l;
			float IIlll1 = 800F * -Il111l;
			for(int IllI = 0; IllI < 10; IllI++)
			{
				float llI1lI = LX.lI1l(ll1IIl);
				float l111I1 = LX.ll1l(ll1IIl);
				boolean l1Il11[][] = new boolean[II1llI][2];
				short I1IlII[] = new short[4];
				short I1lllI[][] = new short[3][IlII11 * II1llI];
				for(int lI1l = 0; lI1l < 4; lI1l++)
				{
					I1IlII[lI1l] = l1llll[I1lI];
					I1lI = (I1lI + 9) % 36;
				}

				float l11l1I[][][] = new float[II1llI][2][3];
				int ll1l = II1llI - 1;
				int IllI11 = LX.lIll(800F * I1111I * -llI1lI);
				for(int Il1I = 0; Il1I < II1llI; Il1I++)
				{
					int ll1lI1 = IlIIII[0][Il1I];
					l11l1I[Il1I][0][1] = (float)ll1lI1 * Il111l * -llI1lI;
					l11l1I[Il1I][0][2] = (float)ll1lI1 * l111I1;
					l11l1I[Il1I][0][0] = (float)ll1lI1 * I1111I * -llI1lI;
					l1Il11[Il1I][0] = ll1lI1 < IllI11;
					l11l1I[ll1l][1][0] = -l11l1I[Il1I][0][0];
					l11l1I[ll1l][1][1] = -l11l1I[Il1I][0][1];
					l11l1I[ll1l][1][2] = -l11l1I[Il1I][0][2];
					l1Il11[ll1l][1] = -ll1lI1 > IllI11;
					ll1l--;
				}

				int l1ll = 0;
				boolean IIllll = IllI == 0 || IllI == 9;
				int l1l1ll = lIl111 + (432 - IllI * 24);
				IllI11 = LX.lIll(800F * I1111I * l111I1);
				float lIlIl1[][] = new float[2][3];
				for(int IlII = 0; IlII < IlII11; IlII++)
				{
					int Il1lIl = II11Il[0][IlII];
					lIlIl1[0][1] = (float)Il1lIl * Il111l * l111I1;
					lIlIl1[0][2] = (float)Il1lIl * llI1lI;
					lIlIl1[0][0] = (float)Il1lIl * I1111I * l111I1;
					boolean lIllII = Il1lIl < IllI11;
					Il1lIl = II11Il[1][IlII];
					lIlIl1[1][1] = (float)Il1lIl * Il111l * l111I1;
					lIlIl1[1][2] = (float)Il1lIl * llI1lI;
					lIlIl1[1][0] = (float)Il1lIl * I1111I * l111I1;
					boolean lI1lll = Il1lIl > IllI11;
					int II1I = l1ll + II1llI;
					for(int I1II = 0; I1II < II1llI; I1II++)
					{
						II1I--;
						III I11IlI = llII1l[l1ll];
						III llIII1 = llII1l[lIll - l1ll];
						III l11l1l = llII1l[II1I];
						III l1ll11 = llII1l[lIll - II1I];
						boolean I1IIl1[] = {
							lIllII, l1Il11[I1II][0], lI1lll, l1Il11[I1II][1]
						};
						if(IIllll)
							LX.I1l(lIlIl1, l11l1I[I1II], I11IlI, llIII1, Il111l, I1111I, IllIII, I1l1Il, I11Ill, 800, lIl111, I1IIl1, I1IlII, IIlll1);
						else
							LX.l1Il(lIlIl1, l11l1I[I1II], I11IlI, llIII1, l11l1l, l1ll11, Il111l, I1111I, IllIII, I1l1Il, I11Ill, 800, lIl111, l1l1ll, I1IIl1, I1IlII, IIlll1);
						float lI11II = lIlIl1[0][2] + l11l1I[I1II][0][2];
						float ll11l1 = lIlIl1[0][0] + l11l1I[I1II][0][0];
						ll11l1 = 800F - ll11l1;
						I1lllI[0][l1ll] = (short)(int)Math.sqrt(lI11II * lI11II + ll11l1 * ll11l1);
						I1lllI[1][l1ll] = (short)l1ll;
						I1lllI[2][l1ll] = (short)II1I;
						l1ll++;
					}

				}

				try
				{
					II1IlI(I1lllI, 0, I1lllI[0].length - 1);
				}
				catch(Exception _ex) { }
				l1I1ll[l1Il][IllI] = I1lllI[1];
				l1I1ll[l1Il][IllI + 18] = l1lI1I(I1lllI[1]);
				lllIIl[l1Il][IllI][0] = lIl111;
				lllIIl[l1Il][IllI + 18][0] = lIl111 + 216;
				if(!IIllll)
				{
					int I11I = 36 - IllI;
					l1I1ll[l1Il][I11I] = I1lllI[2];
					l1I1ll[l1Il][I11I - 18] = l1lI1I(I1lllI[2]);
					lllIIl[l1Il][I11I][0] = l1l1ll;
					lllIIl[l1Il][I11I - 18][0] = l1l1ll - 216;
				}
				lIl111 += 12;
				ll1IIl += 10;
				I1lI++;
			}

			lIl111 += 312;
			Il1I1I += 10;
		}

		l1IllI = l1I1ll;
		I1lI11 = lllIIl;
		System.gc();
	}

	final short[] l1lI1I(short II1I[])
	{
		int IIlI = II1I.length;
		short IlII[] = new short[IIlI];
		int I1II = IIlI - 1;
		for(int i = 0; i < IIlI; i++)
		{
			IlII[i] = II1I[I1II];
			I1II--;
		}

		return IlII;
	}

	final void II1IlI(short ll1l[][], int I1lI, int l1Il)
		throws Exception
	{
		int lI1l = I1lI;
		int lIll = l1Il;
		if(l1Il > I1lI)
		{
			int IllI = ll1l[0][(I1lI + l1Il) / 2];
			while(lI1l <= lIll) 
			{
				while(lI1l < l1Il && ll1l[0][lI1l] > IllI) 
					lI1l++;
				for(; lIll > I1lI && ll1l[0][lIll] < IllI; lIll--);
				if(lI1l <= lIll)
				{
					short Il1I = ll1l[0][lI1l];
					short I11I = ll1l[1][lI1l];
					short l1ll = ll1l[2][lI1l];
					ll1l[0][lI1l] = ll1l[0][lIll];
					ll1l[1][lI1l] = ll1l[1][lIll];
					ll1l[2][lI1l] = ll1l[2][lIll];
					ll1l[0][lIll] = Il1I;
					ll1l[1][lIll] = I11I;
					ll1l[2][lIll] = l1ll;
					lI1l++;
					lIll--;
				}
			}
			if(I1lI < lIll)
				II1IlI(ll1l, I1lI, lIll);
			if(lI1l < l1Il)
				II1IlI(ll1l, lI1l, l1Il);
		}
	}


}