// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   Quant2d.java

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.util.Random;
import javax.swing.*;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;

public class Quant2d extends JApplet
    implements Runnable, ActionListener, ChangeListener
{
    class DrawingArea extends JPanel
    {

        public void repaint(Graphics g)
        {
            paintComponent(g);
        }

        public void paintComponent(Graphics g)
        {
            super.paintComponent(g);
            Z0092(g);
        }

        DrawingArea()
        {
        }
    }

    class MouseAction extends MouseAdapter
        implements MouseMotionListener
    {

        public void mousePressed(MouseEvent mouseevent)
        {
            Z0091(mouseevent.getX(), mouseevent.getY(), 1);
        }

        public void mouseDragged(MouseEvent mouseevent)
        {
            Z0091(mouseevent.getX(), mouseevent.getY(), 0);
        }

        public void mouseReleased(MouseEvent mouseevent)
        {
            Z0091(mouseevent.getX(), mouseevent.getY(), -1);
        }

        public void mouseMoved(MouseEvent mouseevent)
        {
        }

        MouseAction()
        {
        }
    }


    public Quant2d()
    {
    }

    public void init()
    {
        Z0093();
        Z0063 = new Random();
        Z0005 = new Color(204, 255, 255);
        Container container = getContentPane();
        container.add(Z0089(), "East");
        Z0020 = new DrawingArea();
        Z0020.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createMatteBorder(5, 5, 5, 5, Z0005), BorderFactory.createRaisedBevelBorder()));
        container.add(Z0020, "Center");
        Z0048 = new MouseAction();
        Z0020.addMouseListener(Z0048);
        Z0020.addMouseMotionListener(Z0048);
        Z0004 = null;
    }

    JPanel Z0089()
    {
        JPanel jpanel = new JPanel();
        jpanel.setLayout(new BoxLayout(jpanel, 1));
        jpanel.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createRaisedBevelBorder(), BorderFactory.createEmptyBorder(15, 15, 15, 15)));
        jpanel.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createMatteBorder(5, 0, 5, 5, Z0005), jpanel.getBorder()));
        Z0006 = new JButton[2];
        JPanel jpanel1 = new JPanel();
        jpanel1.setLayout(new BoxLayout(jpanel1, 0));
        Z0076(0, jpanel1, "Restart");
        Z0078(jpanel1, 10, 0);
        Z0076(1, jpanel1, "Start");
        jpanel.add(jpanel1);
        Z0078(jpanel, 0, 10);
        Z0099 = new JSlider[8];
        Z0079(0, jpanel, (int)(100D * Z0067), 10, 200, "Rel Height");
        Z0079(1, jpanel, (int)(100D * Z0023), 1, 200, "Energy");
        Z0079(2, jpanel, Z0104, 1, 20, "Update");
        Z0079(3, jpanel, Z0031, 40, 100, "Grid");
        Z0078(jpanel, 0, 20);
        jpanel1 = new JPanel();
        jpanel1.setLayout(new BoxLayout(jpanel1, 0));
        jpanel1.setAlignmentX(0.5F);
        jpanel1.setBorder(BorderFactory.createEtchedBorder());
        Z0062 = new JRadioButton[2];
        ButtonGroup buttongroup = new ButtonGroup();
        Z0077(0, jpanel1, buttongroup, "Cylinder", true);
        Z0077(1, jpanel1, buttongroup, "Slits", false);
        jpanel.add(jpanel1);
        Z0078(jpanel, 0, 10);
        Z0079(4, jpanel, (int)(100D * Z0058), -90, 90, "Potential");
        Z0079(5, jpanel, (int)(100D * Z0059), 2, 20, "Radius");
        Z0079(6, jpanel, (int)(100D * Z0102), 5, 20, "Width");
        Z0079(7, jpanel, (int)(100D * Z0101), 5, 30, "Space");
        return jpanel;
    }

    void Z0076(int i, JPanel jpanel, String s)
    {
        Z0006[i] = new JButton(s);
        Z0006[i].setPreferredSize(Z0006[i].getPreferredSize());
        Z0006[i].addActionListener(this);
        jpanel.add(Z0006[i]);
    }

    void Z0077(int i, JPanel jpanel, ButtonGroup buttongroup, String s, boolean flag)
    {
        Z0062[i] = new JRadioButton(s);
        Z0062[i].setAlignmentX(0.0F);
        Z0062[i].addActionListener(this);
        Z0062[i].setSelected(flag);
        buttongroup.add(Z0062[i]);
        jpanel.add(Z0062[i]);
    }

    void Z0079(int i, JPanel jpanel, int j, int k, int l, String s)
    {
        JLabel jlabel = new JLabel(s, 0);
        jlabel.setAlignmentX(0.5F);
        jpanel.add(jlabel);
        Z0078(jpanel, 0, 2);
        Z0099[i] = new JSlider(k, l, j);
        Z0099[i].setAlignmentX(0.5F);
        Dimension dimension = Z0099[i].getPreferredSize();
        dimension.width = 100;
        Z0099[i].setPreferredSize(dimension);
        Z0099[i].setMajorTickSpacing(l - k);
        Z0099[i].setMinorTickSpacing((l - k) / 5);
        Z0099[i].setPaintLabels(true);
        Z0099[i].setPaintTicks(true);
        Z0099[i].addChangeListener(this);
        jpanel.add(Z0099[i]);
    }

    void Z0078(JPanel jpanel, int i, int j)
    {
        jpanel.add(Box.createRigidArea(new Dimension(i, j)));
    }

    public void stateChanged(ChangeEvent changeevent)
    {
        boolean flag = false;
        JSlider jslider = (JSlider)changeevent.getSource();
        if(!jslider.getValueIsAdjusting())
        {
            int i = jslider.getValue();
            if(jslider == Z0099[0])
                Z0067 = 0.01D * (double)i;
            else
            if(jslider == Z0099[1])
            {
                Z0023 = 0.01D * (double)i;
                flag = true;
            } else
            if(jslider == Z0099[2])
                Z0104 = i;
            else
            if(jslider == Z0099[3])
            {
                Z0031 = ((i + 5) / 10) * 10;
                Z0081();
            } else
            if(jslider == Z0099[4])
            {
                Z0058 = 0.01D * (double)i;
                flag = true;
            } else
            if(jslider == Z0099[5])
            {
                Z0059 = 0.01D * (double)i;
                flag = true;
            } else
            if(jslider == Z0099[6])
            {
                Z0102 = 0.01D * (double)i;
                flag = true;
            } else
            if(jslider == Z0099[7])
            {
                Z0101 = 0.01D * (double)i;
                flag = true;
            }
            if(flag)
            {
                Z0086();
                Z0084();
                Z0087();
            }
            Z0066 = true;
        }
    }

    public void actionPerformed(ActionEvent actionevent)
    {
        boolean flag = false;
        Object obj = actionevent.getSource();
        if(obj == Z0006[0])
        {
            Z0087();
            Z0066 = true;
        } else
        if(obj == Z0006[1])
        {
            Z0070 = !Z0070;
            Z0006[1].setText(Z0070 ? "Stop" : "Start");
            Z0062[0].setEnabled(!Z0070);
            Z0062[1].setEnabled(!Z0070);
            Z0099[3].setEnabled(!Z0070);
        } else
        if(obj == Z0062[0])
        {
            if(Z0062[0].isSelected())
            {
                Z0111 = false;
                flag = true;
            }
        } else
        if(obj == Z0062[1] && Z0062[1].isSelected())
        {
            Z0111 = true;
            flag = true;
        }
        if(flag)
            Z0081();
    }

    public void start()
    {
        if(Z0004 == null)
        {
            Z0004 = new Thread(this);
            Z0004.setPriority(1);
            Z0004.start();
        }
        Dimension dimension = Z0020.getSize();
        int i = dimension.width - dimension.height;
        Z0020.setBorder(BorderFactory.createCompoundBorder(BorderFactory.createMatteBorder(5, 5 + Math.max(i, 0), 5 + Math.max(-i, 0), 5, Z0005), BorderFactory.createRaisedBevelBorder()));
        Z0081();
    }

    public void stop()
    {
        Z0004 = null;
    }

    public void run()
    {
        while(Thread.currentThread() == Z0004) 
        {
            long l = System.currentTimeMillis();
            if(Z0070)
            {
                Z0096();
                if(Z0103 % Z0104 == 0)
                    Z0066 = true;
            }
            if(Z0066)
            {
                Z0066 = false;
                Z0020.repaint();
                Z0020.getToolkit().sync();
                long l1 = System.currentTimeMillis();
                if(!Z0097(Math.max(5L, 40L - (l1 - l))))
                    break;
                continue;
            }
            if(Z0066)
            {
                Z0066 = false;
                Z0020.repaint();
            }
            if(!Z0097(5L))
                break;
        }
    }

    boolean Z0097(long l)
    {

       try {

        Thread.sleep(l);
        return true;
        } catch (InterruptedException e) {  return false;  }

//        InterruptedException interruptedexception;
//        interruptedexception;
//        return false;
    }

    void Z0091(int i, int j, int k)
    {
        switch(k)
        {
        default:
            break;

        case 1: // '\001'
            Z0049 = i;
            Z0050 = j;
            break;

        case 0: // '\0'
            Z0002 += (30D * (double)(i - Z0049)) / (double)Z0011;
            if(Z0002 < -180D)
                Z0002 += 360D;
            else
            if(Z0002 >= 180D)
                Z0002 -= 360D;
            Z0003 += (20D * (double)(j - Z0050)) / (double)Z0011;
            Z0049 = i;
            Z0050 = j;
            if(Z0003 > 60D)
            {
                Z0003 = 60D;
                break;
            }
            if(Z0003 < 5D)
                Z0003 = 5D;
            break;
        }
        Z0066 = true;
    }

    void Z0093()
    {
        Z0031 = 60;
        Z0111 = false;
        Z0067 = 0.80000000000000004D;
        Z0023 = 1.0D;
        Z0043 = 40D;
        Z0057 = 0.050000000000000003D;
        Z0059 = 0.10000000000000001D;
        Z0058 = 0.40000000000000002D;
        Z0102 = 0.10000000000000001D;
        Z0101 = 0.14999999999999999D;
        Z0104 = 2;
        Z0003 = 30D;
        Z0002 = 250D;
        Z0114 = 2.7000000000000002D;
    }

    void Z0081()
    {
        Z0086();
        Z0031 = (Z0031 / 10) * 10 + 1;
        Z0088();
        Z0084();
        Z0087();
        Z0070 = false;
        Z0099[4].setEnabled(!Z0111);
        Z0099[5].setEnabled(!Z0111);
        Z0099[6].setEnabled(Z0111);
        Z0099[7].setEnabled(Z0111);
    }

    void Z0088()
    {
        int i = Z0031 * Z0031;
        Z0027 = new double[i];
        Z0026 = new double[i];
        Z0028 = new double[i];
        Z0025 = new double[i];
        Z0024 = new double[i];
        Z0056 = new double[i];
        Z0060 = new double[i];
        Z0061 = new double[i];
    }

    void Z0086()
    {
        Z0031 = (Z0031 / 2) * 2;
        if(Z0111)
        {
            Z0118 = 0.20000000000000001D;
            Z0119 = 0.5D;
        } else
        {
            Z0118 = 0.20000000000000001D;
            Z0119 = 0.20000000000000001D;
        }
        Z0017 = 1.0D / (double)(Z0031 - 1);
        Z0016 = (2D * Z0017 * Z0017) / Z0043;
        Z0040 = 100D;
    }

    void Z0084()
    {
        for(int i1 = Z0031 * Z0031 - 1; i1 >= 0; i1--)
            Z0056[i1] = 0.0D;

        if(Z0111)
        {
            for(int k = 0; k < Z0031; k++)
            {
                double d1 = Math.abs(k - Z0031 / 2) / (double)Z0031;
                for(int i = 0; i < Z0031; i++)
                    if(Math.abs(i - Z0031 / 2) <= 1 && (d1 < 0.5D * Z0101 || d1 > 0.5D * Z0101 + Z0102))
                        Z0056[k * Z0031 + i] = Z0016 * 3D * Z0040 * Z0040;

            }

        } else
        {
            double d3 = Z0059 * (double)Z0031;
            for(int l = 0; l < Z0031; l++)
            {
                for(int j = 0; j < Z0031; j++)
                {
                    double d = j - Z0031 / 2;
                    double d2 = l - Z0031 / 2;
                    if(d * d + d2 * d2 < d3 * d3)
                        Z0056[l * Z0031 + j] = Z0016 * Z0058 * Z0040 * Z0040;
                }

            }

        }
        for(int j1 = Z0031 * Z0031 - 1; j1 >= 0; j1--)
        {
            Z0025[j1] = Math.cos(Z0056[j1]);
            Z0024[j1] = Math.sin(Z0056[j1]);
        }

    }

    void Z0087()
    {
        Z0039 = Math.sqrt(Z0023) * Z0040;
        double d4;
        double d5;
        if(Z0111)
        {
            d4 = Z0039;
            d5 = 0.0D;
        } else
        {
            d4 = Z0039 / Math.sqrt(2D);
            d5 = Z0039 / Math.sqrt(2D);
        }
        for(int i = Z0031 * Z0031 - 1; i >= 0; i--)
        {
            Z0028[i] = Z0027[i] = 9.9999999999999995E-07D * Z0063.nextDouble();
            Z0026[i] = 0.0D;
        }

        double d1 = 0.0D;
        for(int l = 1; l < Z0031 - 1; l++)
        {
            d1 += Z0017;
            double d = 0.0D;
            for(int k = 1; k < Z0031 - 1; k++)
            {
                d += Z0017;
                int j = l * Z0031 + k;
                double d2 = (0.5D * ((d - Z0118) * (d - Z0118) + (d1 - Z0119) * (d1 - Z0119))) / (Z0057 * Z0057);
                if(d2 < 10D)
                {
                    double d3 = Math.exp(-d2);
                    d2 = d4 * d + d5 * d1;
                    Z0027[j] = d3 * Math.cos(d2);
                    Z0026[j] = d3 * Math.sin(d2);
                    Z0028[j] = Z0027[j] * Z0027[j] + Z0026[j] * Z0026[j];
                }
            }

        }

        Z0103 = 0;
        Z0066 = true;
    }

    void Z0096()
    {
        Z0103++;
        double d = Math.cos(1.0D / Z0043);
        double d1 = -Math.sin(1.0D / Z0043);
        double d2 = Math.cos(2D / Z0043);
        double d3 = -Math.sin(2D / Z0043);
        Z0090(0, 0, 0, d, d1);
        Z0090(1, 0, 0, d2, d3);
        Z0090(0, 0, 0, d, d1);
        Z0090(0, 0, 1, d, d1);
        Z0090(0, 1, 1, d2, d3);
        Z0090(0, 0, 1, d, d1);
        for(int i = Z0031 * Z0031 - 1; i >= 0; i--)
        {
            double d4 = Z0027[i];
            double d5 = Z0026[i];
            Z0027[i] = Z0025[i] * d4 + Z0024[i] * d5;
            Z0026[i] = Z0025[i] * d5 - Z0024[i] * d4;
        }

        for(int j = Z0031 * Z0031 - 1; j >= 0; j--)
            Z0028[j] = Z0027[j] * Z0027[j] + Z0026[j] * Z0026[j];

    }

    void Z0090(int i, int j, int k, double d, double d1)
    {
        byte byte0;
        byte byte1;
        if(k == 0)
        {
            byte0 = 2;
            byte1 = 1;
        } else
        {
            byte0 = 1;
            byte1 = 2;
        }
        for(int i1 = j; i1 < Z0031; i1 += byte1)
        {
            for(int l = i; l < Z0031; l += byte0)
            {
                int j1 = i1 * Z0031 + l;
                int k1;
                if(k == 0)
                {
                    k1 = j1 + 1;
                    if(l == Z0031 - 1)
                        k1 -= Z0031;
                } else
                {
                    k1 = j1 + Z0031;
                    if(i1 == Z0031 - 1)
                        k1 -= Z0031 * Z0031;
                }
                double d2 = Z0027[j1];
                double d3 = Z0026[j1];
                double d4 = Z0027[k1];
                double d5 = Z0026[k1];
                Z0027[j1] = d * d2 + d1 * d5;
                Z0026[j1] = d * d3 - d1 * d4;
                Z0027[k1] = d * d4 + d1 * d3;
                Z0026[k1] = d * d5 - d1 * d2;
            }

        }

    }

    void Z0092(Graphics g)
    {
        if(g == null)
            return;
        Graphics2D graphics2d = (Graphics2D)g;
        Dimension dimension = Z0020.getSize();
        Insets insets = Z0020.getInsets();
        int i = dimension.width - insets.left - insets.right;
        int j = dimension.height - insets.top - insets.bottom;
        Z0011 = Math.min(i, j);
        int k = insets.left + (i - Z0011) / 2;
        int l = insets.top + (j - Z0011) / 2;
        java.awt.geom.Rectangle2D.Double double1 = new java.awt.geom.Rectangle2D.Double(k, l, Z0011, Z0011);
        java.awt.Shape shape = graphics2d.getClip();
        graphics2d.setClip(double1);
        graphics2d.setPaint(Color.black);
        graphics2d.fill(double1);
        Z0053 = 3D;
        Z0054 = 3D;
        scale = 2.1000000000000001D * (double)Z0011;
        Z0015 = 0.017453292519943295D;
        Z0010 = Math.cos(Z0015 * Z0003);
        Z0083 = Math.sin(Z0015 * Z0003);
        Z0009 = Math.cos(Z0015 * Z0002);
        Z0080 = Math.sin(Z0015 * Z0002);
        Z0045 = Z0011 / 2 + k;
        Z0046 = Z0011 / 2 + l;
        if(!Z0111 && Z0058 < 0.0D)
        {
            graphics2d.setStroke(new BasicStroke(2.0F));
            graphics2d.setPaint(Color.orange);
            Z0094(graphics2d);
            graphics2d.setStroke(new BasicStroke(0.0F));
        }
        graphics2d.setPaint(Color.green);
        Z0082(graphics2d);
        graphics2d.setStroke(new BasicStroke(2.0F));
        if(Z0111)
        {
            graphics2d.setPaint(Color.red);
            Z0095(graphics2d);
        } else
        if(Z0058 >= 0.0D)
        {
            graphics2d.setPaint(Color.red);
            Z0094(graphics2d);
        }
        graphics2d.setStroke(new BasicStroke(0.0F));
        graphics2d.setClip(shape);
    }

    void Z0094(Graphics2D graphics2d)
    {
        int i1 = 16;
        double d16 = 0.20000000000000001D * Math.abs(Z0058);
        for(int i = 0; i < i1; i++)
        {
            double d14 = (6.2831853071795862D * (double)i) / (double)i1;
            double d2 = Z0059 * Math.cos(d14);
            double d4 = Z0059 * Math.sin(d14);
            double d6 = 0.0D;
            double d = Z0080 * d2 + Z0009 * d4;
            double d8 = Z0009 * d2 - Z0080 * d4;
            double d10 = Z0010 * d - Z0083 * d6;
            double d12 = Z0083 * d + Z0010 * d6;
            Z0060[0] = (double)Z0045 + (Z0053 + (scale * d8) / (Z0114 + d10));
            Z0061[0] = (double)Z0046 - (Z0054 + (scale * d12) / (Z0114 + d10));
            d6 = d16;
            d = Z0080 * d2 + Z0009 * d4;
            d8 = Z0009 * d2 - Z0080 * d4;
            d10 = Z0010 * d - Z0083 * d6;
            d12 = Z0083 * d + Z0010 * d6;
            Z0060[1] = Z0045 + (int)(Z0053 + (scale * d8) / (Z0114 + d10));
            Z0061[1] = Z0046 - (int)(Z0054 + (scale * d12) / (Z0114 + d10));
            graphics2d.draw(new java.awt.geom.Line2D.Double(Z0060[0], Z0061[0], Z0060[1], Z0061[1]));
        }

        for(int l = 0; l < 2; l++)
        {
            for(int j = 0; j < i1; j++)
            {
                double d15 = (6.2831853071795862D * (double)j) / (double)i1;
                double d3 = Z0059 * Math.cos(d15);
                double d5 = Z0059 * Math.sin(d15);
                double d7 = (double)l * d16;
                double d1 = Z0080 * d3 + Z0009 * d5;
                double d9 = Z0009 * d3 - Z0080 * d5;
                double d11 = Z0010 * d1 - Z0083 * d7;
                double d13 = Z0083 * d1 + Z0010 * d7;
                Z0060[j] = (double)Z0045 + (Z0053 + (scale * d9) / (Z0114 + d11));
                Z0061[j] = (double)Z0046 - (Z0054 + (scale * d13) / (Z0114 + d11));
            }

            for(int k = 0; k < i1; k++)
                graphics2d.draw(new java.awt.geom.Line2D.Double(Z0060[k], Z0061[k], Z0060[(k + 1) % i1], Z0061[(k + 1) % i1]));

        }

    }

    void Z0095(Graphics2D graphics2d)
    {
        double d7 = 0.0D;
        double d8 = 0.0D;
        for(int i = 0; i < 3; i++)
        {
            if(i == 0)
            {
                d7 = -0.5D;
                d8 = -0.5D * Z0101 - Z0102;
            } else
            if(i == 1)
            {
                d7 = -0.5D * Z0101;
                d8 = 0.5D * Z0101;
            } else
            if(i == 2)
            {
                d7 = 0.5D * Z0101 + Z0102;
                d8 = 0.5D;
            }
            for(int j = 0; j < 4; j++)
            {
                double d1 = 0.0D;
                double d2 = j != 1 && j != 2 ? d7 : d8;
                double d3 = j != 0 && j != 1 ? 0.25D : 0.0D;
                double d = Z0080 * d1 + Z0009 * d2;
                double d4 = Z0009 * d1 - Z0080 * d2;
                double d5 = Z0010 * d - Z0083 * d3;
                double d6 = Z0083 * d + Z0010 * d3;
                Z0060[j] = (double)Z0045 + (Z0053 + (scale * d4) / (Z0114 + d5));
                Z0061[j] = (double)Z0046 - (Z0054 + (scale * d6) / (Z0114 + d5));
            }

            for(int k = 0; k < 4; k++)
                graphics2d.draw(new java.awt.geom.Line2D.Double(Z0060[k], Z0061[k], Z0060[(k + 1) % 4], Z0061[(k + 1) % 4]));

        }

    }

    void Z0082(Graphics2D graphics2d)
    {
        for(int l = 0; l < Z0031; l++)
        {
            for(int i = 0; i < Z0031; i++)
            {
                int k1 = l * Z0031 + i;
                double d1 = (double)i / (double)(Z0031 - 1) - 0.5D;
                double d2 = (double)l / (double)(Z0031 - 1) - 0.5D;
                double d3 = Z0028[k1] * Z0067;
                double d = Z0080 * d1 + Z0009 * d2;
                double d4 = Z0009 * d1 - Z0080 * d2;
                double d5 = Z0010 * d - Z0083 * d3;
                double d6 = Z0083 * d + Z0010 * d3;
                Z0060[k1] = (double)Z0045 + (Z0053 + (scale * d4) / (Z0114 + d5));
                Z0061[k1] = (double)Z0046 - (Z0054 + (scale * d6) / (Z0114 + d5));
            }

        }

        for(int i1 = 0; i1 < Z0031; i1++)
        {
            for(int j = 0; j < Z0031 - 1; j++)
            {
                int l1 = i1 * Z0031 + j;
                graphics2d.draw(new java.awt.geom.Line2D.Double(Z0060[l1], Z0061[l1], Z0060[l1 + 1], Z0061[l1 + 1]));
            }

        }

        for(int k = 0; k < Z0031; k++)
        {
            for(int j1 = 0; j1 < Z0031 - 1; j1++)
            {
                int i2 = j1 * Z0031 + k;
                graphics2d.draw(new java.awt.geom.Line2D.Double(Z0060[i2], Z0061[i2], Z0060[i2 + Z0031], Z0061[i2 + Z0031]));
            }

        }

    }

    Thread Z0004;
    JButton Z0006[];
    JSlider Z0099[];
    JRadioButton Z0062[];
    DrawingArea Z0020;
    Color Z0005;
    Random Z0063;
    MouseAction Z0048;
    double Z0056[];
    double Z0025[];
    double Z0024[];
    double Z0027[];
    double Z0026[];
    double Z0028[];
    double Z0060[];
    double Z0061[];
    double Z0057;
    double Z0039;
    double Z0040;
    double Z0023;
    double Z0043;
    double Z0059;
    double Z0118;
    double Z0017;
    double Z0119;
    double Z0016;
    double Z0058;
    double Z0067;
    double Z0102;
    double Z0101;
    double Z0003;
    double Z0002;
    double Z0114;
    double Z0015;
    double Z0010;
    double Z0083;
    double Z0009;
    double Z0080;
    double Z0053;
    double Z0054;
    double scale;
    int Z0011;
    int Z0049;
    int Z0050;
    int Z0031;
    int Z0104;
    int Z0103;
    int Z0045;
    int Z0046;
    boolean Z0070;
    boolean Z0111;
    boolean Z0066;
}
