// Decompiled by DJ v3.12.12.96 Copyright 2011 Atanas Neshkov  Date: 20.08.2014 12:44:25
// Home Page: http://members.fortunecity.com/neshkov/dj.html  http://www.neshkov.com/dj.html - Check often for new version!
// Decompiler options: packimports(3) 

package uk.co.sundroid.b.b;

import java.util.Calendar;
import java.util.TimeZone;
import uk.co.sundroid.a.n;
import uk.co.sundroid.b.a.a;
import uk.co.sundroid.b.a.e;
import uk.co.sundroid.b.a.f;
import uk.co.sundroid.b.a.g;
import uk.co.sundroid.b.a.h;
import uk.co.sundroid.b.a.j;
import uk.co.sundroid.c.a.b;
import uk.co.sundroid.c.a.c;

// Referenced classes of package uk.co.sundroid.b.b:
//            b, c, a

public final class d
{

    public d()
    {
    }

    private static double a(Calendar calendar)
    {
        int i = calendar.get(1);
        int k = 1 + calendar.get(2);
        int l = calendar.get(5);
        return (double)calendar.get(11) / 24D + (double)calendar.get(12) / 1440D + (double)calendar.get(13) / 86400D + (double)((l + ((i * 367 - (7 * (i + (k + 9) / 12)) / 4) + (k * 275) / 9)) - 0xb25a2);
    }

    private static int a(double d1)
    {
        return d1 < 0.0D || d1 >= 180D ? 2 : 1;
    }

    private static int a(double d1, double d2)
    {
        return d1 + d2 >= 0.0D ? 1 : -1;
    }

    public static uk.co.sundroid.b.a.d a(f f1, b b1, Calendar calendar, boolean flag)
    {
        if(f1 == f.a)
        {
            uk.co.sundroid.b.b.b ab[] = new uk.co.sundroid.b.b.b[1];
            ab[0] = uk.co.sundroid.b.b.b.a;
            return uk.co.sundroid.b.b.c.a(b1, calendar, ab);
        }
        if(f1 == f.b)
        {
            a a1 = new a();
            a a2 = (a)a1;
            a2.a(uk.co.sundroid.b.b.a.b(calendar));
            a2.a(uk.co.sundroid.b.b.a.a(a2.c()));
            h h1;
            Object obj;
            Calendar calendar1;
            byte byte0;
            double ad[];
            double ad1[];
            double d1;
            int i;
            j j1;
            if(a2.c() < 0.25D)
                a2.a(e.b);
            else
            if(a2.c() < 0.5D)
                a2.a(e.d);
            else
            if(a2.c() < 0.75D)
                a2.a(e.f);
            else
                a2.a(e.h);
            h1 = uk.co.sundroid.b.b.a.a(calendar);
            g g1;
            double d2;
            double d3;
            int k;
            g g2;
            double d4;
            byte byte1;
            int l;
            g g3;
            double d5;
            g g4;
            double d6;
            double d7;
            double d8;
            double d9;
            int i1;
            long l1;
            int k1;
            int i2;
            long l2;
            int j2;
            int k2;
            Calendar calendar2;
            g g5;
            int i3;
            Calendar calendar3;
            if(h1 != null)
            {
                a2.a(h1.b());
                a2.a(h1);
                obj = a1;
            } else
            {
                obj = a1;
            }
        } else
        {
            obj = new uk.co.sundroid.b.a.d();
        }
        calendar1 = n.a(calendar);
        if(flag)
            byte0 = 48;
        else
            byte0 = 24;
        ad = new double[50];
        ad1 = new double[50];
        if(f1 == f.b)
            d1 = 0.5D;
        else
            d1 = 0.0D;
        i = 0;
        if(i <= byte0) goto _L2; else goto _L1
_L1:
        if(((uk.co.sundroid.b.a.d) (obj)).m() == null && ((uk.co.sundroid.b.a.d) (obj)).n() == null)
        {
            if(ad[12] > 0.0D)
                j1 = j.a;
            else
                j1 = j.b;
            ((uk.co.sundroid.b.a.d) (obj)).a(j1);
        }
        return ((uk.co.sundroid.b.a.d) (obj));
_L2:
        calendar1.setTimeInMillis(calendar.getTimeInMillis());
        calendar1.add(11, i);
        g1 = a(f1, b1, calendar1);
        ad[i] = g1.c();
        ad1[i] = g1.b();
        if(!flag || i <= 0 || i > 24 || a(ad1[i]) == a(ad1[i - 1])) goto _L4; else goto _L3
_L3:
        i1 = a(ad1[i]);
        l1 = calendar1.getTimeInMillis();
        k1 = 0x1b7740;
        i2 = -1;
        l2 = l1;
        j2 = 0;
        k2 = i1;
_L9:
        l2 += i2 * k1;
        calendar2 = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
        calendar2.setTimeInMillis(l2);
        calendar2.getTimeInMillis();
        if(f1 == f.b)
            g5 = a(b1, calendar2);
        else
            g5 = b(f1, b1, calendar2);
        i3 = a(g5.b());
        if(k1 >= 15000 && j2 <= 10) goto _L6; else goto _L5
_L5:
        if(((uk.co.sundroid.b.a.d) (obj)).o() == null || g5.c() > ((uk.co.sundroid.b.a.d) (obj)).s())
        {
            calendar3 = Calendar.getInstance(calendar.getTimeZone());
            calendar3.setTimeInMillis(g5.a());
            ((uk.co.sundroid.b.a.d) (obj)).k(calendar3);
            ((uk.co.sundroid.b.a.d) (obj)).g(g5.c());
        }
_L4:
        if(i <= 0 || a(ad[i], d1) == a(ad[i - 1], d1)) goto _L8; else goto _L7
_L7:
        d3 = ad[i] - ad[i - 1];
        k = (int)Math.round(60D * Math.abs(ad[i - 1] / d3));
        calendar1.add(11, -1);
        calendar1.set(12, k);
        g2 = a(f1, b1, calendar1);
        d4 = g2.c();
        if(a(d4, d1) == a(ad[i - 1], d1))
            byte1 = 1;
        else
            byte1 = -1;
        l = 0;
        g3 = g2;
        d5 = d4;
_L11:
        if(l < 60)
        {
            calendar1.add(12, byte1);
            g4 = a(f1, b1, calendar1);
            d6 = g4.c();
            if(a(d6, d1) == a(d5, d1))
                break MISSING_BLOCK_LABEL_1060;
            d7 = g4.b();
            if(Math.abs(d6 + d1) > Math.abs(d5 + d1))
            {
                calendar1.add(12, -byte1);
                d8 = g3.b();
            } else
            {
                d8 = d7;
            }
            if(a(ad[i - 1], d1) < 0)
            {
                if(i <= 24 && calendar1.get(6) == calendar.get(6))
                {
                    ((uk.co.sundroid.b.a.d) (obj)).i(n.a(calendar1));
                    ((uk.co.sundroid.b.a.d) (obj)).e(d8);
                }
            } else
            {
                if(i > 24 || calendar1.get(6) != calendar.get(6))
                    continue; /* Loop/switch isn't completed */
                ((uk.co.sundroid.b.a.d) (obj)).j(n.a(calendar1));
                ((uk.co.sundroid.b.a.d) (obj)).f(d8);
            }
        }
_L8:
        if(((uk.co.sundroid.b.a.d) (obj)).m() == null || ((uk.co.sundroid.b.a.d) (obj)).n() == null || ((uk.co.sundroid.b.a.d) (obj)).m().getTimeInMillis() >= ((uk.co.sundroid.b.a.d) (obj)).n().getTimeInMillis() && flag)
            continue; /* Loop/switch isn't completed */
        d2 = (double)(((uk.co.sundroid.b.a.d) (obj)).n().getTimeInMillis() - ((uk.co.sundroid.b.a.d) (obj)).m().getTimeInMillis()) / 3600000D;
        ((uk.co.sundroid.b.a.d) (obj)).h(d2);
          goto _L1
_L6:
        if(i3 == k2)
        {
            k1 /= 2;
            j2++;
            k2 = i3;
        } else
        {
            k1 /= 2;
            i2 = -i2;
            j2++;
            k2 = i3;
        }
          goto _L9
        if(i <= 24 || ((uk.co.sundroid.b.a.d) (obj)).m() == null) goto _L8; else goto _L10
_L10:
        d9 = (double)(calendar1.getTimeInMillis() - ((uk.co.sundroid.b.a.d) (obj)).m().getTimeInMillis()) / 3600000D;
        ((uk.co.sundroid.b.a.d) (obj)).h(d9);
          goto _L1
        l++;
        g3 = g4;
        d5 = d6;
          goto _L11
        if(((uk.co.sundroid.b.a.d) (obj)).m() == null && i == 24) goto _L1; else goto _L12
_L12:
        i++;
        if(false)
            ;
        else
            break MISSING_BLOCK_LABEL_166;
    }

    public static g a(f f1, b b1, Calendar calendar)
    {
        if(f1 == f.a)
            return uk.co.sundroid.b.b.c.a(b1, calendar);
        Calendar calendar1 = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
        calendar1.setTimeInMillis(calendar.getTimeInMillis());
        calendar1.getTimeInMillis();
        if(f1 == f.b)
            return a(b1, calendar1);
        else
            return b(f1, b1, calendar1);
    }

    private static g a(b b1, Calendar calendar)
    {
        double d1 = a(calendar);
        double d2 = c(b(calendar));
        double d3 = d(125.1228D - 0.052953808300000002D * d1);
        double d4 = d(5.1454000000000004D);
        double d5 = d(318.0634D + 0.1643573223D * d1);
        double d6 = d(115.36539999999999D + 13.064992950900001D * d1);
        double d7 = d6 + 3.1455382952682194D * Math.sin(Math.toRadians(d6)) * (1.0D + 0.054899999999999997D * Math.cos(Math.toRadians(d6)));
        double d8 = 1.7976931348623157E+308D;
        int i = 0;
        do
        {
            if(Math.abs(d8 - d7) <= 0.0050000000000000001D || i >= 10)
            {
                double d9 = 60.266599999999997D * (Math.cos(Math.toRadians(d8)) - 0.054899999999999997D);
                double d10 = 60.266599999999997D * Math.sqrt(0.99698598999999999D) * Math.sin(Math.toRadians(d8));
                double d11 = Math.sqrt(d9 * d9 + d10 * d10);
                double d12 = d(Math.toDegrees(Math.atan2(Math.toRadians(d10), Math.toRadians(d9))));
                double ad[] = new double[3];
                ad[0] = d11 * (Math.cos(Math.toRadians(d3)) * Math.cos(Math.toRadians(d12 + d5)) - Math.sin(Math.toRadians(d3)) * Math.sin(Math.toRadians(d12 + d5)) * Math.cos(Math.toRadians(d4)));
                ad[1] = d11 * (Math.sin(Math.toRadians(d3)) * Math.cos(Math.toRadians(d12 + d5)) + Math.cos(Math.toRadians(d3)) * Math.sin(Math.toRadians(d12 + d5)) * Math.cos(Math.toRadians(d4)));
                ad[2] = d11 * Math.sin(Math.toRadians(d12 + d5)) * Math.sin(Math.toRadians(d4));
                double ad1[] = a(ad);
                double d13 = d(282.94040000000001D + 4.7093499999999999E-005D * d1);
                double d14 = d(356.04700000000003D + d1 * 0.98560025849999999D);
                double d15 = d(d13 + d14);
                double d16 = d(d6 + (d3 + d5));
                double d17 = d(d16 - d15);
                double d18 = d(d16 - d3);
                ad1[1] = (((((ad1[1] - 1.274D * Math.sin(Math.toRadians(d6 - 2D * d17))) + 0.65800000000000003D * Math.sin(Math.toRadians(2D * d17))) - 0.186D * Math.sin(Math.toRadians(d14)) - 0.058999999999999997D * Math.sin(Math.toRadians(2D * d6 - 2D * d17)) - 0.057000000000000002D * Math.sin(Math.toRadians(d14 + (d6 - 2D * d17)))) + 0.052999999999999999D * Math.sin(Math.toRadians(d6 + 2D * d17)) + 0.045999999999999999D * Math.sin(Math.toRadians(2D * d17 - d14)) + 0.041000000000000002D * Math.sin(Math.toRadians(d6 - d14))) - 0.035000000000000003D * Math.sin(Math.toRadians(d17)) - 0.031D * Math.sin(Math.toRadians(d14 + d6)) - 0.014999999999999999D * Math.sin(Math.toRadians(2D * d18 - 2D * d17))) + 0.010999999999999999D * Math.sin(Math.toRadians(d6 - 4D * d17));
                ad1[2] = (ad1[2] - 0.17299999999999999D * Math.sin(Math.toRadians(d18 - 2D * d17)) - 0.055D * Math.sin(Math.toRadians(d6 - d18 - 2D * d17)) - 0.045999999999999999D * Math.sin(Math.toRadians((d6 + d18) - 2D * d17))) + 0.033000000000000002D * Math.sin(Math.toRadians(d18 + 2D * d17)) + 0.017000000000000001D * Math.sin(Math.toRadians(d18 + 2D * d6));
                ad1[0] = ad1[0] - 0.57999999999999996D * Math.cos(Math.toRadians(d6 - 2D * d17)) - 0.46000000000000002D * Math.cos(Math.toRadians(2D * d17));
                double ad2[] = a(a(b(ad1), d2));
                double d19 = b1.a().a();
                double d20 = d19 - 0.19239999999999999D * Math.sin(Math.toRadians(2D * d19));
                double d21 = 0.99833000000000005D + 0.00167D * Math.cos(Math.toRadians(d19 * 2D));
                double d22 = Math.toDegrees(Math.asin(1.0D / ad2[0]));
                double d23 = d(15D * b(b1, calendar) - ad2[1]);
                double d24 = Math.toDegrees(Math.atan(Math.tan(Math.toRadians(d20)) / Math.cos(Math.toRadians(d23))));
                double d25 = ad2[1] - (d22 * d21 * Math.cos(Math.toRadians(d20)) * Math.sin(Math.toRadians(d23))) / Math.cos(Math.toRadians(ad2[2]));
                double d26 = ad2[2] - (d21 * d22 * Math.sin(Math.toRadians(d20)) * Math.sin(Math.toRadians(d24 - ad2[2]))) / Math.sin(Math.toRadians(d24));
                double ad3[] = new double[3];
                ad3[0] = ad2[0];
                ad3[1] = d25;
                ad3[2] = d26;
                double ad4[] = a(ad3, b1, calendar);
                g g1 = new g();
                g1.a(calendar.getTimeInMillis());
                g1.j(ad1[0]);
                g1.b(6378.1369999999997D * ad1[0]);
                g1.h(ad1[1]);
                g1.i(ad1[2]);
                g1.f(ad2[1]);
                g1.g(ad2[2]);
                g1.n(ad3[1]);
                g1.o(ad3[2]);
                g1.k(ad4[0]);
                g1.m(b(ad4[1]));
                g1.l(ad4[1]);
                return g1;
            }
            d8 = d7 - (d7 - 3.1455382952682194D * Math.sin(Math.toRadians(d7)) - d6) / (1.0D - 0.054899999999999997D * Math.cos(Math.toRadians(d7)));
            i++;
        } while(true);
    }

    private static double[] a(double ad[])
    {
        return (new double[] {
            Math.sqrt(ad[0] * ad[0] + ad[1] * ad[1] + ad[2] * ad[2]), d(Math.toDegrees(Math.atan2(Math.toRadians(ad[1]), Math.toRadians(ad[0])))), Math.toDegrees(Math.atan2(Math.toRadians(ad[2]), Math.toRadians(Math.sqrt(ad[0] * ad[0] + ad[1] * ad[1]))))
        });
    }

    private static double[] a(double ad[], double d1)
    {
        return (new double[] {
            ad[0], ad[1] * Math.cos(Math.toRadians(d1)) - ad[2] * Math.sin(Math.toRadians(d1)), ad[1] * Math.sin(Math.toRadians(d1)) + ad[2] * Math.cos(Math.toRadians(d1))
        });
    }

    private static double[] a(double ad[], b b1, Calendar calendar)
    {
        double d1 = 15D * e(b(b1, calendar) - ad[1] / 15D);
        double d2 = Math.cos(Math.toRadians(d1)) * Math.cos(Math.toRadians(ad[2]));
        double d3 = Math.sin(Math.toRadians(d1)) * Math.cos(Math.toRadians(ad[2]));
        double d4 = Math.sin(Math.toRadians(ad[2]));
        double d5 = d2 * Math.sin(Math.toRadians(b1.a().a())) - d4 * Math.cos(Math.toRadians(b1.a().a()));
        double d6 = d2 * Math.cos(Math.toRadians(b1.a().a())) + d4 * Math.sin(Math.toRadians(b1.a().a()));
        return (new double[] {
            d(180D + Math.toDegrees(Math.atan2(Math.toRadians(d3), Math.toRadians(d5)))), Math.toDegrees(Math.atan2(Math.toRadians(d6), Math.toRadians(Math.sqrt(d5 * d5 + d3 * d3))))
        });
    }

    private static int[] a()
    {
        int ai[] = a;
        if(ai != null)
            return ai;
        int ai1[] = new int[f.values().length];
        try
        {
            ai1[f.f.ordinal()] = 6;
        }
        catch(NoSuchFieldError nosuchfielderror) { }
        try
        {
            ai1[f.e.ordinal()] = 5;
        }
        catch(NoSuchFieldError nosuchfielderror1) { }
        try
        {
            ai1[f.c.ordinal()] = 3;
        }
        catch(NoSuchFieldError nosuchfielderror2) { }
        try
        {
            ai1[f.b.ordinal()] = 2;
        }
        catch(NoSuchFieldError nosuchfielderror3) { }
        try
        {
            ai1[f.i.ordinal()] = 9;
        }
        catch(NoSuchFieldError nosuchfielderror4) { }
        try
        {
            ai1[f.g.ordinal()] = 7;
        }
        catch(NoSuchFieldError nosuchfielderror5) { }
        try
        {
            ai1[f.a.ordinal()] = 1;
        }
        catch(NoSuchFieldError nosuchfielderror6) { }
        try
        {
            ai1[f.h.ordinal()] = 8;
        }
        catch(NoSuchFieldError nosuchfielderror7) { }
        try
        {
            ai1[f.d.ordinal()] = 4;
        }
        catch(NoSuchFieldError nosuchfielderror8) { }
        a = ai1;
        return ai1;
    }

    private static double b(double d1)
    {
        if(d1 <= 85D) goto _L2; else goto _L1
_L1:
        double d4 = 0.0D;
_L4:
        return d4 + d1;
_L2:
        double d2;
        double d3;
        d2 = Math.tan(Math.toRadians(d1));
        if(d1 <= 5D)
            break; /* Loop/switch isn't completed */
        d3 = (58.100000000000001D / d2 - 0.070000000000000007D / (d2 * (d2 * d2))) + 8.6000000000000003E-005D / (d2 * (d2 * (d2 * (d2 * d2))));
_L5:
        d4 = d3 / 3600D;
        if(true) goto _L4; else goto _L3
_L3:
        if(d1 > -0.57499999999999996D)
            d3 = 1735D + d1 * (-518.20000000000005D + d1 * (103.40000000000001D + d1 * (-12.789999999999999D + 0.71099999999999997D * d1)));
        else
            d3 = -20.774000000000001D / d2;
          goto _L5
        if(true) goto _L4; else goto _L6
_L6:
    }

    private static double b(Calendar calendar)
    {
        return ((2451543.5D + a(calendar)) - 2451545D) / 36525D;
    }

    private static double b(b b1, Calendar calendar)
    {
        double d1 = a(calendar);
        return e((double)calendar.get(11) + (double)calendar.get(12) / 60D + (double)calendar.get(13) / 3600D + (12D + d(d(282.94040000000001D + 4.7093499999999999E-005D * d1) + d(356.04700000000003D + d1 * 0.98560025849999999D)) / 15D) + b1.b().a() / 15D);
    }

    private static g b(f f1, b b1, Calendar calendar)
    {
        double d1;
        double d2;
        d1 = a(calendar);
        d2 = c(b(calendar));
        a()[f1.ordinal()];
        JVM INSTR tableswitch 3 9: default 64
    //                   3 97
    //                   4 919
    //                   5 1014
    //                   6 1109
    //                   7 1204
    //                   8 1299
    //                   9 1404;
           goto _L1 _L2 _L3 _L4 _L5 _L6 _L7 _L8
_L1:
        StringBuilder stringbuilder = new StringBuilder("Unrecognised body: ");
        IllegalArgumentException illegalargumentexception = new IllegalArgumentException(stringbuilder.append(f1).toString());
        throw illegalargumentexception;
_L2:
        double d9;
        double d10;
        double d11;
        double d12;
        double d13;
        double d14;
        double d60 = d(48.331299999999999D + 3.2458700000000001E-005D * d1);
        double d61 = d(7.0046999999999997D + 4.9999999999999998E-008D * d1);
        double d62 = d(29.124099999999999D + 1.0144400000000001E-005D * d1);
        double d63 = 0.20563500000000001D + 5.5900000000000003E-010D * d1;
        double d64 = d(168.65620000000001D + 4.0923344367999999D * d1);
        d9 = d60;
        d10 = d64;
        d11 = d62;
        d12 = 0.387098D;
        d13 = d63;
        d14 = d61;
_L15:
        double d15;
        double d16;
        int i;
        d15 = d10 + 57.295779513082323D * d13 * Math.sin(Math.toRadians(d10)) * (1.0D + d13 * Math.cos(Math.toRadians(d10)));
        d16 = 1.7976931348623157E+308D;
        i = 0;
_L16:
        if(Math.abs(d16 - d15) > 0.0050000000000000001D && i < 10) goto _L10; else goto _L9
_L9:
        double ad1[];
        double d21;
        double d22;
        double d23;
        double d17 = d12 * (Math.cos(Math.toRadians(d16)) - d13);
        double d18 = d12 * Math.sqrt(1.0D - d13 * d13) * Math.sin(Math.toRadians(d16));
        double d19 = Math.sqrt(d17 * d17 + d18 * d18);
        double d20 = d(Math.toDegrees(Math.atan2(Math.toRadians(d18), Math.toRadians(d17))));
        double ad[] = new double[3];
        ad[0] = d19 * (Math.cos(Math.toRadians(d9)) * Math.cos(Math.toRadians(d20 + d11)) - Math.sin(Math.toRadians(d9)) * Math.sin(Math.toRadians(d20 + d11)) * Math.cos(Math.toRadians(d14)));
        ad[1] = d19 * (Math.sin(Math.toRadians(d9)) * Math.cos(Math.toRadians(d20 + d11)) + Math.cos(Math.toRadians(d9)) * Math.sin(Math.toRadians(d20 + d11)) * Math.cos(Math.toRadians(d14)));
        ad[2] = d19 * Math.sin(Math.toRadians(d20 + d11)) * Math.sin(Math.toRadians(d14));
        ad1 = a(ad);
        d21 = d(19.895D + 0.083085300099999995D * d1);
        d22 = d(316.96699999999998D + 0.033444228200000002D * d1);
        d23 = d(142.59049999999999D + 0.011725806D * d1);
        a()[f1.ordinal()];
        JVM INSTR tableswitch 6 8: default 560
    //                   6 1555
    //                   7 1738
    //                   8 1945;
           goto _L11 _L12 _L13 _L14
_L11:
        break; /* Loop/switch isn't completed */
_L14:
        break MISSING_BLOCK_LABEL_1945;
_L17:
        double ad2[] = b(ad1);
        double d24 = d(282.94040000000001D + 4.7093499999999999E-005D * d1);
        double d25 = 0.016709000000000002D - 1.1510000000000001E-009D * d1;
        double d26 = d(356.04700000000003D + d1 * 0.98560025849999999D);
        double d27 = d26 + 57.295779513082323D * d25 * Math.sin(Math.toRadians(d26)) * (1.0D + d25 * Math.cos(Math.toRadians(d26)));
        double d28 = Math.cos(Math.toRadians(d27)) - d25;
        double d29 = Math.sin(Math.toRadians(d27)) * Math.sqrt(1.0D - d25 * d25);
        double d30 = Math.sqrt(d28 * d28 + d29 * d29);
        double d31 = d(d24 + Math.toDegrees(Math.atan2(d29, d28)));
        double d32 = d30 * Math.cos(Math.toRadians(d31));
        double d33 = d30 * Math.sin(Math.toRadians(d31));
        double ad3[] = new double[3];
        ad3[0] = d32 + ad2[0];
        ad3[1] = d33 + ad2[1];
        ad3[2] = 0.0D + ad2[2];
        double ad4[] = a(a(ad3, d2));
        double ad5[] = a(ad4, b1, calendar);
        g g1 = new g();
        g1.a(calendar.getTimeInMillis());
        g1.e(ad1[0]);
        g1.a(149597870.69999999D * ad1[0]);
        g1.c(ad1[1]);
        g1.d(ad1[2]);
        g1.f(ad4[1]);
        g1.g(ad4[2]);
        g1.n(ad4[1]);
        g1.o(ad4[2]);
        g1.k(ad5[0]);
        g1.l(ad5[1]);
        g1.m(b(ad5[1]));
        return g1;
_L3:
        double d55 = d(76.679900000000004D + 2.4658999999999999E-005D * d1);
        double d56 = d(3.3946000000000001D + 2.7500000000000001E-008D * d1);
        double d57 = d(54.890999999999998D + 1.3837400000000001E-005D * d1);
        double d58 = 0.0067730000000000004D - 1.3020000000000001E-009D * d1;
        double d59 = d(48.005200000000002D + 1.6021302244D * d1);
        d9 = d55;
        d10 = d59;
        d11 = d57;
        d12 = 0.72333000000000003D;
        d13 = d58;
        d14 = d56;
          goto _L15
_L4:
        double d50 = d(49.557400000000001D + 2.1108099999999999E-005D * d1);
        double d51 = d(1.8496999999999999D - 1.7800000000000001E-008D * d1);
        double d52 = d(286.5016D + 2.9296099999999999E-005D * d1);
        double d53 = 0.093405000000000002D + 2.516E-009D * d1;
        double d54 = d(18.6021D + 0.52402077660000002D * d1);
        d9 = d50;
        d10 = d54;
        d11 = d52;
        d12 = 1.5236879999999999D;
        d13 = d53;
        d14 = d51;
          goto _L15
_L5:
        double d45 = d(100.4542D + 2.7685400000000001E-005D * d1);
        double d46 = d(1.3029999999999999D - 1.557E-007D * d1);
        double d47 = d(273.8777D + 1.6450500000000001E-005D * d1);
        double d48 = 0.048497999999999999D + 4.4690000000000002E-009D * d1;
        double d49 = d(19.895D + 0.083085300099999995D * d1);
        d9 = d45;
        d10 = d49;
        d11 = d47;
        d12 = 5.2025600000000001D;
        d13 = d48;
        d14 = d46;
          goto _L15
_L6:
        double d40 = d(113.6634D + 2.3898000000000001E-005D * d1);
        double d41 = d(2.4885999999999999D - 1.081E-007D * d1);
        double d42 = d(339.39389999999997D + 2.9766099999999999E-005D * d1);
        double d43 = 0.055545999999999998D - 9.4989999999999996E-009D * d1;
        double d44 = d(316.96699999999998D + 0.033444228200000002D * d1);
        d9 = d40;
        d10 = d44;
        d11 = d42;
        d12 = 9.5547500000000003D;
        d13 = d43;
        d14 = d41;
          goto _L15
_L7:
        double d34 = d(74.000500000000002D + 1.3978000000000001E-005D * d1);
        double d35 = d(0.77329999999999999D + 1.9000000000000001E-008D * d1);
        double d36 = d(96.661199999999994D + 3.0565000000000003E-005D * d1);
        double d37 = 19.181709999999999D - 1.55E-008D * d1;
        double d38 = 0.047317999999999999D + 7.4499999999999997E-009D * d1;
        double d39 = d(142.59049999999999D + 0.011725806D * d1);
        d9 = d34;
        d10 = d39;
        d11 = d36;
        d12 = d37;
        d13 = d38;
        d14 = d35;
          goto _L15
_L8:
        double d3 = d(131.78059999999999D + 3.0173000000000001E-005D * d1);
        double d4 = d(1.77D - 2.5499999999999999E-007D * d1);
        double d5 = d(272.84609999999998D - 6.0270000000000001E-006D * d1);
        double d6 = 30.058260000000001D + 3.313E-008D * d1;
        double d7 = 0.0086060000000000008D + 2.1499999999999998E-009D * d1;
        double d8 = d(260.24709999999999D + 0.0059951470000000001D * d1);
        d9 = d3;
        d10 = d8;
        d11 = d5;
        d12 = d6;
        d13 = d7;
        d14 = d4;
          goto _L15
_L10:
        d16 = d15 - (d15 - 57.295779513082323D * d13 * Math.sin(Math.toRadians(d15)) - d10) / (1.0D - d13 * Math.cos(Math.toRadians(d15)));
        i++;
          goto _L16
_L12:
        ad1[1] = ((((ad1[1] - 0.33200000000000002D * Math.sin(Math.toRadians(2D * d21 - 5D * d22 - 67.599999999999994D)) - 0.056000000000000001D * Math.sin(Math.toRadians(21D + (2D * d21 - 2D * d22)))) + 0.042000000000000003D * Math.sin(Math.toRadians(21D + (3D * d21 - 5D * d22)))) - 0.035999999999999997D * Math.sin(Math.toRadians(d21 - 2D * d22))) + 0.021999999999999999D * Math.cos(Math.toRadians(d21 - d22)) + 0.023D * Math.sin(Math.toRadians(52D + (2D * d21 - 3D * d22)))) - 0.016D * Math.sin(Math.toRadians(d21 - d22 * 5D - 69D));
          goto _L17
_L13:
        ad1[1] = ((ad1[1] + 0.81200000000000006D * Math.sin(Math.toRadians(2D * d21 - 5D * d22 - 67.599999999999994D))) - 0.22900000000000001D * Math.cos(Math.toRadians(2D * d21 - 4D * d22 - 2D))) + 0.11899999999999999D * Math.sin(Math.toRadians(d21 - 2D * d22 - 3D)) + 0.045999999999999999D * Math.sin(Math.toRadians(2D * d21 - 6D * d22 - 69D)) + 0.014D * Math.sin(Math.toRadians(32D + (d21 - 3D * d22)));
        ad1[2] = (ad1[2] - 0.02D * Math.cos(Math.toRadians(2D * d21 - 4D * d22 - 2D))) + 0.017999999999999999D * Math.sin(Math.toRadians(d21 * 2D - d22 * 6D - 49D));
          goto _L17
        ad1[1] = (ad1[1] + 0.040000000000000001D * Math.sin(Math.toRadians(6D + (d22 - 2D * d23))) + 0.035000000000000003D * Math.sin(Math.toRadians(33D + (d22 - 3D * d23)))) - 0.014999999999999999D * Math.sin(Math.toRadians(20D + (d21 - d23)));
          goto _L17
    }

    private static double[] b(double ad[])
    {
        return (new double[] {
            ad[0] * Math.cos(Math.toRadians(ad[1])) * Math.cos(Math.toRadians(ad[2])), ad[0] * Math.sin(Math.toRadians(ad[1])) * Math.cos(Math.toRadians(ad[2])), ad[0] * Math.sin(Math.toRadians(ad[2]))
        });
    }

    private static double c(double d1)
    {
        return 23D + (26D + (21.448D - d1 * (46.814999999999998D + d1 * (0.00059000000000000003D - 0.0018129999999999999D * d1))) / 60D) / 60D;
    }

    private static double d(double d1)
    {
        double d2 = d1;
_L3:
        if(d2 < 0.0D) goto _L2; else goto _L1
_L1:
        if(d2 <= 360D)
            return d2;
        break MISSING_BLOCK_LABEL_27;
_L2:
        d2 += 360D;
          goto _L3
        d2 -= 360D;
          goto _L1
    }

    private static double e(double d1)
    {
        double d2 = d1;
_L3:
        if(d2 < 0.0D) goto _L2; else goto _L1
_L1:
        if(d2 <= 24D)
            return d2;
        break MISSING_BLOCK_LABEL_27;
_L2:
        d2 += 24D;
          goto _L3
        d2 -= 24D;
          goto _L1
    }

    private static int a[];
}