jfxrt

oolean bool = false;
    int k = 0;
    int m = 0;
    for (int i = 0; i < paramArrayOfVec3f.length; i++)
    {
      if (i != paramArrayOfVec3f.length - 1) {
        m = i + 1;
      } else {
        m = 0;
      }
      vec0.sub(paramArrayOfVec3f[m], paramArrayOfVec3f[i]);
      if (vec0.length() > 0.0D) {
        break;
      }
    }
    for (int j = m; j < paramArrayOfVec3f.length; j++)
    {
      if (j != paramArrayOfVec3f.length - 1) {
        k = j + 1;
      } else {
        k = 0;
      }
      vec1.sub(paramArrayOfVec3f[k], paramArrayOfVec3f[j]);
      if (vec1.length() > 0.0D) {
        break;
      }
    }
    pNrm.cross(vec0, vec1);
    if ((vec1.length() == 0.0F) || (pNrm.length() == 0.0F)) {
      return false;
    }
    d5 = pNrm.dot(paramVec3d2);
    if (d5 == 0.0D) {
      return false;
    }
    tempV3d.set(paramArrayOfVec3f[0]);
    d4 = pNrm.dot(tempV3d);
    tempV3d.set(paramVec3d1);
    paramArrayOfDouble[0] = ((d4 - pNrm.dot(tempV3d)) / d5);
    if ((paramArrayOfDouble[0] < -9.999999747378752E-6D) || ((paramBoolean) && (paramArrayOfDouble[0] > 1.0000099999997474D))) {
      return false;
    }
    if (paramVec3d3 == null) {
      paramVec3d3 = new Vec3d();
    }
    x += x * paramArrayOfDouble[0];
    y += y * paramArrayOfDouble[0];
    z += z * paramArrayOfDouble[0];
    double d1 = Math.abs(pNrm.x);
    double d2 = Math.abs(pNrm.y);
    double d3 = Math.abs(pNrm.z);
    double d8 = 0.0D;
    Vec3f localVec3f1 = paramArrayOfVec3f[(paramArrayOfVec3f.length - 1)];
    Vec3f localVec3f2 = paramArrayOfVec3f[0];
    bool = true;
    double d6;
    double d7;
    if (d1 > d2)
    {
      if (d1 < d3) {
        for (i = 0; i < paramArrayOfVec3f.length; i++)
        {
          localVec3f1 = paramArrayOfVec3f[i];
          localVec3f2 = i != paramArrayOfVec3f.length - 1 ? paramArrayOfVec3f[(i + 1)] : paramArrayOfVec3f[0];
          d6 = (y - y) * (x - x) - (x - x) * (y - y);
          if (isNonZero(d6))
          {
            if (d6 * d8 < 0.0D)
            {
              bool = false;
              break;
            }
            d8 = d6;
          }
          else
          {
            d7 = y - y;
            if (isNonZero(d7))
            {
              d7 = (y - y) / d7;
              bool = (d7 > -9.999999747378752E-6D) && (d7 < 1.0000099999997474D);
              break;
            }
            d7 = x - x;
            if (isNonZero(d7))
            {
              d7 = (x - x) / d7;
              bool = (d7 > -9.999999747378752E-6D) && (d7 < 1.0000099999997474D);
              break;
            }
          }
        }
      }
      for (i = 0; i < paramArrayOfVec3f.length; i++)
      {
        localVec3f1 = paramArrayOfVec3f[i];
        localVec3f2 = i != paramArrayOfVec3f.length - 1 ? paramArrayOfVec3f[(i + 1)] : paramArrayOfVec3f[0];
        d6 = (y - y) * (z - z) - (z - z) * (y - y);
        if (isNonZero(d6))
        {
          if (d6 * d8 < 0.0D)
          {
            bool = false;
            break;
          }
          d8 = d6;
        }
        else
        {
          d7 = y - y;
          if (isNonZero(d7))
          {
            d7 = (y - y) / d7;
            bool = (d7 > -9.999999747378752E-6D) && (d7 < 1.0000099999997474D);
            break;
          }
          d7 = z - z;
          if (isNonZero(d7))
          {
            d7 = (z - z) / d7;
            bool = (d7 > -9.999999747378752E-6D) && (d7 < 1.0000099999997474D);
            break;
          }
        }
      }
    }
    if (d2 < d3) {
      for (i = 0; i < paramArrayOfVec3f.length; i++)
      {
        localVec3f1 = paramArrayOfVec3f[i];
        localVec3f2 = i != paramArrayOfVec3f.length - 1 ? paramArrayOfVec3f[(i + 1)] : paramArrayOfVec3f[0];
        d6 = (y - y) * (x - x) - (x - x) * (y - y);
        if (isNonZero(d6))
        {
          if (d6 * d8 < 0.0D)
          {
            bool = false;
            break;
          }
          d8 = d6;
        }
        else
        {
          d7 = y - y;
          if (isNonZero(d7))
          {
            d7 = (y - y) / d7;
            bool = (d7 > -9.999999747378752E-6D) && (d7 < 1.0000099999997474D);
            break;
          }
          d7 = x - x;
          if (isNonZero(d7))
          {
            d7 = (x - x) / d7;
            bool = (d7 > -9.999999747378752E-6D) && (d7 < 1.0000099999997474D);
            break;
          }
        }
      }
    }
    for (i = 0; i < paramArrayOfVec3f.length; i++)
    {
      localVec3f1 = paramArrayOfVec3f[i];
      localVec3f2 = i != paramArrayOfVec3f.length - 1 ? paramArrayOfVec3f[(i + 1)] : paramArrayOfVec3f[0];
      d6 = (x - x) * (z - z) - (z - z) * (x - x);
      if (isNonZero(d6))
      {
        if (d6 * d8 < 0.0D)
        {
          bool = false;
          break;
        }
        d8 = d6;
      }
      else
      {
        d7 = x - x;
        if (isNonZero(d7))
        {
          d7 = (x - x) / d7;
          bool = (d7 > -9.999999747378752E-6D) && (d7 < 1.0000099999997474D);
          break;
        }
        d7 = z - z;
        if (isNonZero(d7))
        {
          d7 = (z - z) / d7;
          bool = (d7 > -9.999999747378752E-6D) && (d7 < 1.0000099999997474D);
          break;
        }
      }
    }
    if (bool) {
      paramArrayOfDouble[0] *= paramVec3d2.length();
    }
    return bool;
  }
  
  private static boolean isNonZero(double paramDouble)
  {
    return (paramDouble > 9.999999747378752E-6D) || (paramDouble < -9.999999747378752E-6D);
  }
  
  public void transform(BaseTransform paramBaseTransform)
  {
    endPt.add(origin, direction);
    paramBaseTransform.transform(origin, origin);
    paramBaseTransform.transform(endPt, endPt);
    direction.sub(endPt, origin);
    direction.normalize();
  }
  
  public PickRay project(BaseTransform paramBaseTransform, boolean paramBoolean, Vec3d paramVec3d, Point2D paramPoint2D)
  {
    if (paramVec3d == null) {
      paramVec3d = new Vec3d();
    }
    paramBaseTransform.transform(origin, paramVec3d);
    double d1 = x;
    double d2 = y;
    double d3 = z;
    paramVec3d.add(origin, direction);
    paramBaseTransform.transform(paramVec3d, paramVec3d);
    double d4 = x - d1;
    double d5 = y - d2;
    double d6 = z - d3;
    PickRay localPickRay = new PickRay();
    origin.x = d1;
    origin.y = d2;
    origin.z = d3;
    direction.x = d4;
    direction.y = d5;
    direction.z = d6;
    return localPickRay;
  }
  
  public String toString()
  {
    return "origin: " + origin + "  direction: " + direction;
  }
}

/* Location:
 * Qualified Name:     com.sun.javafx.geom.PickRay
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.geom;

public class Point2D
{
  public float x;
  public float y;
  
  public Point2D() {}
  
  public Point2D(float paramFloat1, float paramFloat2)
  {
    x = paramFloat1;
    y = paramFloat2;
  }
  
  public void setLocation(float paramFloat1, float paramFloat2)
  {
    x = paramFloat1;
    y = paramFloat2;
  }
  
  public void setLocation(Point2D paramPoint2D)
  {
    setLocation(x, y);
  }
  
  public static float distanceSq(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
  {
    paramFloat1 -= paramFloat3;
    paramFloat2 -= paramFloat4;
    return paramFloat1 * paramFloat1 + paramFloat2 * paramFloat2;
  }
  
  public static float distance(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
  {
    paramFloat1 -= paramFloat3;
    paramFloat2 -= paramFloat4;
    return (float)Math.sqrt(paramFloat1 * paramFloat1 + paramFloat2 * paramFloat2);
  }
  
  public float distanceSq(float paramFloat1, float paramFloat2)
  {
    paramFloat1 -= x;
    paramFloat2 -= y;
    return paramFloat1 * paramFloat1 + paramFloat2 * paramFloat2;
  }
  
  public float distanceSq(Point2D paramPoint2D)
  {
    float f1 = x - x;
    float f2 = y - y;
    return f1 * f1 + f2 * f2;
  }
  
  public float distance(float paramFloat1, float paramFloat2)
  {
    paramFloat1 -= x;
    paramFloat2 -= y;
    return (float)Math.sqrt(paramFloat1 * paramFloat1 + paramFloat2 * paramFloat2);
  }
  
  public float distance(Point2D paramPoint2D)
  {
    float f1 = x - x;
    float f2 = y - y;
    return (float)Math.sqrt(f1 * f1 + f2 * f2);
  }
  
  public int hashCode()
  {
    int i = Float.floatToIntBits(x);
    i ^= Float.floatToIntBits(y) * 31;
    return i ^ i >> 32;
  }
  
  public boolean equals(Object paramObject)
  {
    if (paramObject == this) {
      return true;
    }
    if ((paramObject instanceof Point2D))
    {
      Point2D localPoint2D = (Point2D)paramObject;
      return (x == x) && (y == y);
    }
    return false;
  }
  
  public String toString()
  {
    return "Point2D[" + x + ", " + y + "]";
  }
}

/* Location:
 * Qualified Name:     com.sun.javafx.geom.Point2D
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.geom;

import com.sun.javafx.geom.transform.BaseTransform;

public class QuadCurve2D
  extends Shape
{
  public float x1;
  public float y1;
  public float ctrlx;
  public float ctrly;
  public float x2;
  public float y2;
  private static final int BELOW = -2;
  private static final int LOWEDGE = -1;
  private static final int INSIDE = 0;
  private static final int HIGHEDGE = 1;
  private static final int ABOVE = 2;
  
  public QuadCurve2D() {}
  
  public QuadCurve2D(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4, float paramFloat5, float paramFloat6)
  {
    setCurve(paramFloat1, paramFloat2, paramFloat3, paramFloat4, paramFloat5, paramFloat6);
  }
  
  public void setCurve(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4, float paramFloat5, float paramFloat6)
  {
    x1 = paramFloat1;
    y1 = paramFloat2;
    ctrlx = paramFloat3;
    ctrly = paramFloat4;
    x2 = paramFloat5;
    y2 = paramFloat6;
  }
  
  public RectBounds getBounds()
  {
    float f1 = Math.min(Math.min(x1, x2), ctrlx);
    float f2 = Math.min(Math.min(y1, y2), ctrly);
    float f3 = Math.max(Math.max(x1, x2), ctrlx);
    float f4 = Math.max(Math.max(y1, y2), ctrly);
    return new RectBounds(f1, f2, f3, f4);
  }
  
  public CubicCurve2D toCubic()
  {
    return new CubicCurve2D(x1, y1, (x1 + 2.0F * ctrlx) / 3.0F, (y1 + 2.0F * ctrly) / 3.0F, (2.0F * ctrlx + x2) / 3.0F, (2.0F * ctrly + y2) / 3.0F, x2, y2);
  }
  
  public void setCurve(float[] paramArrayOfFloat, int paramInt)
  {
    setCurve(paramArrayOfFloat[(paramInt + 0)], paramArrayOfFloat[(paramInt + 1)], paramArrayOfFloat[(paramInt + 2)], paramArrayOfFloat[(paramInt + 3)], paramArrayOfFloat[(paramInt + 4)], paramArrayOfFloat[(paramInt + 5)]);
  }
  
  public void setCurve(Point2D paramPoint2D1, Point2D paramPoint2D2, Point2D paramPoint2D3)
  {
    setCurve(x, y, x, y, x, y);
  }
  
  public void setCurve(Point2D[] paramArrayOfPoint2D, int paramInt)
  {
    setCurve(0x, 0y, 1x, 1y, 2x, 2y);
  }
  
  public void setCurve(QuadCurve2D paramQuadCurve2D)
  {
    setCurve(x1, y1, ctrlx, ctrly, x2, y2);
  }
  
  public static float getFlatnessSq(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4, float paramFloat5, float paramFloat6)
  {
    return Line2D.ptSegDistSq(paramFloat1, paramFloat2, paramFloat5, paramFloat6, paramFloat3, paramFloat4);
  }
  
  public static float getFlatness(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4, float paramFloat5, float paramFloat6)
  {
    return Line2D.ptSegDist(paramFloat1, paramFloat2, paramFloat5, paramFloat6, paramFloat3, paramFloat4);
  }
  
  public static float getFlatnessSq(float[] paramArrayOfFloat, int paramInt)
  {
    return Line2D.ptSegDistSq(paramArrayOfFloat[(paramInt + 0)], paramArrayOfFloat[(paramInt + 1)], paramArrayOfFloat[(paramInt + 4)], paramArrayOfFloat[(paramInt + 5)], paramArrayOfFloat[(paramInt + 2)], paramArrayOfFloat[(paramInt + 3)]);
  }
  
  public static float getFlatness(float[] paramArrayOfFloat, int paramInt)
  {
    return Line2D.ptSegDist(paramArrayOfFloat[(paramInt + 0)], paramArrayOfFloat[(paramInt + 1)], paramArrayOfFloat[(paramInt + 4)], paramArrayOfFloat[(paramInt + 5)], paramArrayOfFloat[(paramInt + 2)], paramArrayOfFloat[(paramInt + 3)]);
  }
  
  public float getFlatnessSq()
  {
    return Line2D.ptSegDistSq(x1, y1, x2, y2, ctrlx, ctrly);
  }
  
  public float getFlatness()
  {
    return Line2D.ptSegDist(x1, y1, x2, y2, ctrlx, ctrly);
  }
  
  public void subdivide(QuadCurve2D paramQuadCurve2D1, QuadCurve2D paramQuadCurve2D2)
  {
    subdivide(this, paramQuadCurve2D1, paramQuadCurve2D2);
  }
  
  public static void subdivide(QuadCurve2D paramQuadCurve2D1, QuadCurve2D paramQuadCurve2D2, QuadCurve2D paramQuadCurve2D3)
  {
    float f1 = x1;
    float f2 = y1;
    float f3 = ctrlx;
    float f4 = ctrly;
    float f5 = x2;
    float f6 = y2;
    float f7 = (f1 + f3) / 2.0F;
    float f8 = (f2 + f4) / 2.0F;
    float f9 = (f5 + f3) / 2.0F;
    float f10 = (f6 + f4) / 2.0F;
    f3 = (f7 + f9) / 2.0F;
    f4 = (f8 + f10) / 2.0F;
    if (paramQuadCurve2D2 != null) {
      paramQuadCurve2D2.setCurve(f1, f2, f7, f8, f3, f4);
    }
    if (paramQuadCurve2D3 != null) {
      paramQuadCurve2D3.setCurve(f3, f4, f9, f10, f5, f6);
    }
  }
  
  public static void subdivide(float[] paramArrayOfFloat1, int paramInt1, float[] paramArrayOfFloat2, int paramInt2, float[] paramArrayOfFloat3, int paramInt3)
  {
    float f1 = paramArrayOfFloat1[(paramInt1 + 0)];
    float f2 = paramArrayOfFloat1[(paramInt1 + 1)];
    float f3 = paramArrayOfFloat1[(paramInt1 + 2)];
    float f4 = paramArrayOfFloat1[(paramInt1 + 3)];
    float f5 = paramArrayOfFloat1[(paramInt1 + 4)];
    float f6 = paramArrayOfFloat1[(paramInt1 + 5)];
    if (paramArrayOfFloat2 != null)
    {
      paramArrayOfFloat2[(paramInt2 + 0)] = f1;
      paramArrayOfFloat2[(paramInt2 + 1)] = f2;
    }
    if (paramArrayOfFloat3 != null)
    {
      paramArrayOfFloat3[(paramInt3 + 4)] = f5;
      paramArrayOfFloat3[(paramInt3 + 5)] = f6;
    }
    f1 = (f1 + f3) / 2.0F;
    f2 = (f2 + f4) / 2.0F;
    f5 = (f5 + f3) / 2.0F;
    f6 = (f6 + f4) / 2.0F;
    f3 = (f1 + f5) / 2.0F;
    f4 = (f2 + f6) / 2.0F;
    if (paramArrayOfFloat2 != null)
    {
      paramArrayOfFloat2[(paramInt2 + 2)] = f1;
      paramArrayOfFloat2[(paramInt2 + 3)] = f2;
      paramArrayOfFloat2[(paramInt2 + 4)] = f3;
      paramArrayOfFloat2[(paramInt2 + 5)] = f4;
    }
    if (paramArrayOfFloat3 != null)
    {
      paramArrayOfFloat3[(paramInt3 + 0)] = f3;
      paramArrayOfFloat3[(paramInt3 + 1)] = f4;
      paramArrayOfFloat3[(paramInt3 + 2)] = f5;
      paramArrayOfFloat3[(paramInt3 + 3)] = f6;
    }
  }
  
  public static int solveQuadratic(float[] paramArrayOfFloat)
  {
    return solveQuadratic(paramArrayOfFloat, paramArrayOfFloat);
  }
  
  public static int solveQuadratic(float[] paramArrayOfFloat1, float[] paramArrayOfFloat2)
  {
    float f1 = paramArrayOfFloat1[2];
    float f2 = paramArrayOfFloat1[1];
    float f3 = paramArrayOfFloat1[0];
    int i = 0;
    if (f1 == 0.0F)
    {
      if (f2 == 0.0F) {
        return -1;
      }
      paramArrayOfFloat2[(i++)] = (-f3 / f2);
    }
    else
    {
      float f4 = f2 * f2 - 4.0F * f1 * f3;
      if (f4 < 0.0F) {
        return 0;
      }
      f4 = (float)Math.sqrt(f4);
      if (f2 < 0.0F) {
        f4 = -f4;
      }
      float f5 = (f2 + f4) / -2.0F;
      paramArrayOfFloat2[(i++)] = (f5 / f1);
      if (f5 != 0.0F) {
        paramArrayOfFloat2[(i++)] = (f3 / f5);
      }
    }
    return i;
  }
  
  public boolean contains(float paramFloat1, float paramFloat2)
  {
    float f1 = x1;
    float f2 = y1;
    float f3 = ctrlx;
    float f4 = ctrly;
    float f5 = x2;
    float f6 = y2;
    float f7 = f1 - 2.0F * f3 + f5;
    float f8 = f2 - 2.0F * f4 + f6;
    float f9 = paramFloat1 - f1;
    float f10 = paramFloat2 - f2;
    float f11 = f5 - f1;
    float f12 = f6 - f2;
    float f13 = (f9 * f8 - f10 * f7) / (f11 * f8 - f12 * f7);
    if ((f13 < 0.0F) || (f13 > 1.0F) || (f13 != f13)) {
      return false;
    }
    float f14 = f7 * f13 * f13 + 2.0F * (f3 - f1) * f13 + f1;
    float f15 = f8 * f13 * f13 + 2.0F * (f4 - f2) * f13 + f2;
    float f16 = f11 * f13 + f1;
    float f17 = f12 * f13 + f2;
    return ((paramFloat1 >= f14) && (paramFloat1 < f16)) || ((paramFloat1 >= f16) && (paramFloat1 < f14)) || ((paramFloat2 >= f15) && (paramFloat2 < f17)) || ((paramFloat2 >= f17) && (paramFloat2 < f15));
  }
  
  public boolean contains(Point2D paramPoint2D)
  {
    return contains(x, y);
  }
  
  private static void fillEqn(float[] paramArrayOfFloat, float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
  {
    paramArrayOfFloat[0] = (paramFloat2 - paramFloat1);
    paramArrayOfFloat[1] = (paramFloat3 + paramFloat3 - paramFloat2 - paramFloat2);
    paramArrayOfFloat[2] = (paramFloat2 - paramFloat3 - paramFloat3 + paramFloat4);
  }
  
  private static int evalQuadratic(float[] paramArrayOfFloat1, int paramInt, boolean paramBoolean1, boolean paramBoolean2, float[] paramArrayOfFloat2, float paramFloat1, float paramFloat2, float paramFloat3)
  {
    int i = 0;
    for (int j = 0; j < paramInt; j++)
    {
      float f1 = paramArrayOfFloat1[j];
      if ((paramBoolean1 ? f1 >= 0.0F : f1 > 0.0F) && (paramBoolean2 ? f1 <= 1.0F : f1 < 1.0F) && ((paramArrayOfFloat2 == null) || (paramArrayOfFloat2[1] + 2.0F * paramArrayOfFloat2[2] * f1 != 0.0F)))
      {
        float f2 = 1.0F - f1;
        paramArrayOfFloat1[(i++)] = (paramFloat1 * f2 * f2 + 2.0F * paramFloat2 * f1 * f2 + paramFloat3 * f1 * f1);
      }
    }
    return i;
  }
  
  private static int getTag(float paramFloat1, float paramFloat2, float paramFloat3)
  {
    if (paramFloat1 <= paramFloat2) {
      return paramFloat1 < paramFloat2 ? -2 : -1;
    }
    if (paramFloat1 >= paramFloat3) {
      return paramFloat1 > paramFloat3 ? 2 : 1;
    }
    return 0;
  }
  
  private static boolean inwards(int paramInt1, int paramInt2, int paramInt3)
  {
    switch (paramInt1)
    {
    case -2: 
    case 2: 
    default: 
      return false;
    case -1: 
      return (paramInt2 >= 0) || (paramInt3 >= 0);
    case 0: 
      return true;
    }
    return (paramInt2 <= 0) || (paramInt3 <= 0);
  }
  
  public boolean intersects(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
  {
    if ((paramFloat3 <= 0.0F) || (paramFloat4 <= 0.0F)) {
      return false;
    }
    float f1 = x1;
    float f2 = y1;
    int i = getTag(f1, paramFloat1, paramFloat1 + paramFloat3);
    int j = getTag(f2, paramFloat2, paramFloat2 + paramFloat4);
    if ((i == 0) && (j == 0)) {
      return true;
    }
    float f3 = x2;
    float f4 = y2;
    int k = getTag(f3, paramFloat1, paramFloat1 + paramFloat3);
    int m = getTag(f4, paramFloat2, paramFloat2 + paramFloat4);
    if ((k == 0) && (m == 0)) {
      return true;
    }
    float f5 = ctrlx;
    float f6 = ctrly;
    int n = getTag(f5, paramFloat1, paramFloat1 + paramFloat3);
    int i1 = getTag(f6, paramFloat2, paramFloat2 + paramFloat4);
    if ((i < 0) && (k < 0) && (n < 0)) {
      return false;
    }
    if ((j < 0) && (m < 0) && (i1 < 0)) {
      return false;
    }
    if ((i > 0) && (k > 0) && (n > 0)) {
      return false;
    }
    if ((j > 0) && (m > 0) && (i1 > 0)) {
      return false;
    }
    if ((inwards(i, k, n)) && (inwards(j, m, i1))) {
      return true;
    }
    if ((inwards(k, i, n)) && (inwards(m, j, i1))) {
      return true;
    }
    int i2 = i * k <= 0 ? 1 : 0;
    int i3 = j * m <= 0 ? 1 : 0;
    if ((i == 0) && (k == 0) && (i3 != 0)) {
      return true;
    }
    if ((j == 0) && (m == 0) && (i2 != 0)) {
      return true;
    }
    float[] arrayOfFloat1 = new float[3];
    float[] arrayOfFloat2 = new float[3];
    if (i3 == 0)
    {
      fillEqn(arrayOfFloat1, j < 0 ? paramFloat2 : paramFloat2 + paramFloat4, f2, f6, f4);
      return (solveQuadratic(arrayOfFloat1, arrayOfFloat2) == 2) && (evalQuadratic(arrayOfFloat2, 2, true, true, null, f1, f5, f3) == 2) && (getTag(arrayOfFloat2[0], paramFloat1, paramFloat1 + paramFloat3) * getTag(arrayOfFloat2[1], paramFloat1, paramFloat1 + paramFloat3) <= 0);
    }
    if (i2 == 0)
    {
      fillEqn(arrayOfFloat1, i < 0 ? paramFloat1 : paramFloat1 + paramFloat3, f1, f5, f3);
      return (solveQuadratic(arrayOfFloat1, arrayOfFloat2) == 2) && (evalQuadratic(arrayOfFloat2, 2, true, true, null, f2, f6, f4) == 2) && (getTag(arrayOfFloat2[0], paramFloat2, paramFloat2 + paramFloat4) * getTag(arrayOfFloat2[1], paramFloat2, paramFloat2 + paramFloat4) <= 0);
    }
    float f7 = f3 - f1;
    float f8 = f4 - f2;
    float f9 = f4 * f1 - f3 * f2;
    if (j == 0) {
      i4 = i;
    } else {
      i4 = getTag((f9 + f7 * (j < 0 ? paramFloat2 : paramFloat2 + paramFloat4)) / f8, paramFloat1, paramFloat1 + paramFloat3);
    }
    if (m == 0) {
      i5 = k;
    } else {
      i5 = getTag((f9 + f7 * (m < 0 ? paramFloat2 : paramFloat2 + paramFloat4)) / f8, paramFloat1, paramFloat1 + paramFloat3);
    }
    if (i4 * i5 <= 0) {
      return true;
    }
    int i4 = i4 * i <= 0 ? j : m;
    fillEqn(arrayOfFloat1, i5 < 0 ? paramFloat1 : paramFloat1 + paramFloat3, f1, f5, f3);
    int i6 = solveQuadratic(arrayOfFloat1, arrayOfFloat2);
    evalQuadratic(arrayOfFloat2, i6, true, true, null, f2, f6, f4);
    int i5 = getTag(arrayOfFloat2[0], paramFloat2, paramFloat2 + paramFloat4);
    return i4 * i5 <= 0;
  }
  
  public boolean contains(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
  {
    if ((paramFloat3 <= 0.0F) || (paramFloat4 <= 0.0F)) {
      return false;
    }
    return (contains(paramFloat1, paramFloat2)) && (contains(paramFloat1 + paramFloat3, paramFloat2)) && (contains(paramFloat1 + paramFloat3, paramFloat2 + paramFloat4)) && (contains(paramFloat1, paramFloat2 + paramFloat4));
  }
  
  public PathIterator getPathIterator(BaseTransform paramBaseTransform)
  {
    return new QuadIterator(this, paramBaseTransform);
  }
  
  public PathIterator getPathIterator(BaseTransform paramBaseTransform, float paramFloat)
  {
    return new FlatteningPathIterator(getPathIterator(paramBaseTransform), paramFloat);
  }
  
  public QuadCurve2D copy()
  {
    return new QuadCurve2D(x1, y1, ctrlx, ctrly, x2, y2);
  }
  
  public int hashCode()
  {
    int i = Float.floatToIntBits(x1);
    i += Float.floatToIntBits(y1) * 37;
    i += Float.floatToIntBits(x2) * 43;
    i += Float.floatToIntBits(y2) * 47;
    i += Float.floatToIntBits(ctrlx) * 53;
    i += Float.floatToIntBits(ctrly) * 59;
    return i ^ i >> 32;
  }
  
  public boolean equals(Object paramObject)
  {
    if (paramObject == this) {
      return true;
    }
    if ((paramObject instanceof QuadCurve2D))
    {
      QuadCurve2D localQuadCurve2D = (QuadCurve2D)paramObject;
      return (x1 == x1) && (y1 == y1) && (x2 == x2) && (y2 == y2) && (ctrlx == ctrlx) && (ctrly == ctrly);
    }
    return false;
  }
}

/* Location:
 * Qualified Name:     com.sun.javafx.geom.QuadCurve2D
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.geom;

import com.sun.javafx.geom.transform.BaseTransform;
import java.util.NoSuchElementException;

class QuadIterator
  implements PathIterator
{
  QuadCurve2D quad;
  BaseTransform transform;
  int index;
  
  QuadIterator(QuadCurve2D paramQuadCurve2D, BaseTransform paramBaseTransform)
  {
    quad = paramQuadCurve2D;
    transform = paramBaseTransform;
  }
  
  public int getWindingRule()
  {
    return 1;
  }
  
  public boolean isDone()
  {
    return index > 1;
  }
  
  public void next()
  {
    index += 1;
  }
  
  public int currentSegment(float[] paramArrayOfFloat)
  {
    if (isDone()) {
      throw new NoSuchElementException("quad iterator iterator out of bounds");
    }
    int i;
    if (index == 0)
    {
      paramArrayOfFloat[0] = quad.x1;
      paramArrayOfFloat[1] = quad.y1;
      i = 0;
    }
    else
    {
      paramArrayOfFloat[0] = quad.ctrlx;
      paramArrayOfFloat[1] = quad.ctrly;
      paramArrayOfFloat[2] = quad.x2;
      paramArrayOfFloat[3] = quad.y2;
      i = 2;
    }
    if (transform != null) {
      transform.transform(paramArrayOfFloat, 0, paramArrayOfFloat, 0, index == 0 ? 1 : 2);
    }
    return i;
  }
}

/* Location:
 * Qualified Name:     com.sun.javafx.geom.QuadIterator
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.geom;

public class RectBounds
  extends BaseBounds
{
  private float minX;
  private float maxX;
  private float minY;
  private float maxY;
  
  public RectBounds()
  {
    minX = (minY = 0.0F);
    maxX = (maxY = -1.0F);
  }
  
  public BaseBounds copy()
  {
    return new RectBounds(minX, minY, maxX, maxY);
  }
  
  public RectBounds(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
  {
    setBounds(paramFloat1, paramFloat2, paramFloat3, paramFloat4);
  }
  
  public RectBounds(RectBounds paramRectBounds)
  {
    setBounds(paramRectBounds);
  }
  
  public RectBounds(Rectangle paramRectangle)
  {
    setBounds(x, y, x + width, y + height);
  }
  
  public BaseBounds.BoundsType getBoundsType()
  {
    return BaseBounds.BoundsType.RECTANGLE;
  }
  
  public boolean is2D()
  {
    return true;
  }
  
  public float getWidth()
  {
    return maxX - minX;
  }
  
  public float getHeight()
  {
    return maxY - minY;
  }
  
  public float getDepth()
  {
    return 0.0F;
  }
  
  public float getMinX()
  {
    return minX;
  }
  
  public void setMinX(float paramFloat)
  {
    minX = paramFloat;
  }
  
  public float getMinY()
  {
    return minY;
  }
  
  public void setMinY(float paramFloat)
  {
    minY = paramFloat;
  }
  
  public float getMinZ()
  {
    return 0.0F;
  }
  
  public float getMaxX()
  {
    return maxX;
  }
  
  public void setMaxX(float paramFloat)
  {
    maxX = paramFloat;
  }
  
  public float getMaxY()
  {
    return maxY;
  }
  
  public void setMaxY(float paramFloat)
  {
    maxY = paramFloat;
  }
  
  public float getMaxZ()
  {
    return 0.0F;
  }
  
  public Vec2f getMin(Vec2f paramVec2f)
  {
    if (paramVec2f == null) {
      paramVec2f = new Vec2f();
    }
    x = minX;
    y = minY;
    return paramVec2f;
  }
  
  public Vec2f getMax(Vec2f paramVec2f)
  {
    if (paramVec2f == null) {
      paramVec2f = new Vec2f();
    }
    x = maxX;
    y = maxY;
    return paramVec2f;
  }
  
  public Vec3f getMin(Vec3f paramVec3f)
  {
    if (paramVec3f == null) {
      paramVec3f = new Vec3f();
    }
    x = minX;
    y = minY;
    z = 0.0F;
    return paramVec3f;
  }
  
  public Vec3f getMax(Vec3f paramVec3f)
  {
    if (paramVec3f == null) {
      paramVec3f = new Vec3f();
    }
    x = maxX;
    y = maxY;
    z = 0.0F;
    return paramVec3f;
  }
  
  public BaseBounds deriveWithUnion(BaseBounds paramBaseBounds)
  {
    Object localObject;
    if (paramBaseBounds.getBoundsType() == BaseBounds.BoundsType.RECTANGLE)
    {
      localObject = (RectBounds)paramBaseBounds;
      unionWith((RectBounds)localObject);
    }
    else
    {
      if (paramBaseBounds.getBoundsType() == BaseBounds.BoundsType.BOX)
      {
        localObject = new BoxBounds((BoxBounds)paramBaseBounds);
        ((BoxBounds)localObject).unionWith(this);
        return (BaseBounds)localObject;
      }
      throw new UnsupportedOperationException("Unknown BoundsType");
    }
    return this;
  }
  
  public BaseBounds deriveWithNewBounds(Rectangle paramRectangle)
  {
    if ((width < 0) || (height < 0)) {
      return makeEmpty();
    }
    setBounds(x, y, x + width, y + height);
    return this;
  }
  
  public BaseBounds deriveWithNewBounds(BaseBounds paramBaseBounds)
  {
    if (paramBaseBounds.isEmpty()) {
      return makeEmpty();
    }
    if (paramBaseBounds.getBoundsType() == BaseBounds.BoundsType.RECTANGLE)
    {
      RectBounds localRectBounds = (RectBounds)paramBaseBounds;
      minX = localRectBounds.getMinX();
      minY = localRectBounds.getMinY();
      maxX = localRectBounds.getMaxX();
      maxY = localRectBounds.getMaxY();
    }
    else
    {
      if (paramBaseBounds.getBoundsType() == BaseBounds.BoundsType.BOX) {
        return new BoxBounds((BoxBounds)paramBaseBounds);
      }
      throw new UnsupportedOperationException("Unknown BoundsType");
    }
    return this;
  }
  
  public BaseBounds deriveWithNewBounds(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4, float paramFloat5, float paramFloat6)
  {
    if ((paramFloat4 < paramFloat1) || (paramFloat5 < paramFloat2) || (paramFloat6 < paramFloat3)) {
      return makeEmpty();
    }
    if ((paramFloat3 == 0.0F) && (paramFloat6 == 0.0F))
    {
      minX = paramFloat1;
      minY = paramFloat2;
      maxX = paramFloat4;
      maxY = paramFloat5;
      return this;
    }
    return new BoxBounds(paramFloat1, paramFloat2, paramFloat3, paramFloat4, paramFloat5, paramFloat6);
  }
  
  public BaseBounds deriveWithNewBoundsAndSort(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4, float paramFloat5, float paramFloat6)
  {
    if ((paramFloat3 == 0.0F) && (paramFloat6 == 0.0F))
    {
      setBoundsAndSort(paramFloat1, paramFloat2, paramFloat3, paramFloat4, paramFloat5, paramFloat6);
      return this;
    }
    BoxBounds localBoxBounds = new BoxBounds();
    localBoxBounds.setBoundsAndSort(paramFloat1, paramFloat2, paramFloat3, paramFloat4, paramFloat5, paramFloat6);
    return localBoxBounds;
  }
  
  public final void setBounds(RectBounds paramRectBounds)
  {
    minX = paramRectBounds.getMinX();
    minY = paramRectBounds.getMinY();
    maxX = paramRectBounds.getMaxX();
    maxY = paramRectBounds.getMaxY();
  }
  
  public final void setBounds(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
  {
    minX = paramFloat1;
    minY = paramFloat2;
    maxX = paramFloat3;
    maxY = paramFloat4;
  }
  
  public void setBoundsAndSort(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
  {
    setBounds(paramFloat1, paramFloat2, paramFloat3, paramFloat4);
    sortMinMax();
  }
  
  public void setBoundsAndSort(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4, float paramFloat5, float paramFloat6)
  {
    if ((paramFloat3 != 0.0F) || (paramFloat6 != 0.0F)) {
      throw new UnsupportedOperationException("Unknown BoundsType");
    }
    setBounds(paramFloat1, paramFloat2, paramFloat4, paramFloat5);
    sortMinMax();
  }
  
  public void setBoundsAndSort(Point2D paramPoint2D1, Point2D paramPoint2D2)
  {
    setBoundsAndSort(x, y, x, y);
  }
  
  public void unionWith(RectBounds paramRectBounds)
  {
    if (paramRectBounds.isEmpty()) {
      return;
    }
    if (isEmpty())
    {
      setBounds(paramRectBounds);
      return;
    }
    minX = Math.min(minX, paramRectBounds.getMinX());
    minY = Math.min(minY, paramRectBounds.getMinY());
    maxX = Math.max(maxX, paramRectBounds.getMaxX());
    maxY = Math.max(maxY, paramRectBounds.getMaxY());
  }
  
  public void unionWith(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
  {
    if ((paramFloat3 < paramFloat1) || (paramFloat4 < paramFloat2)) {
      return;
    }
    if (isEmpty())
    {
      setBounds(paramFloat1, paramFloat2, paramFloat3, paramFloat4);
      return;
    }
    minX = Math.min(minX, paramFloat1);
    minY = Math.min(minY, paramFloat2);
    maxX = Math.max(maxX, paramFloat3);
    maxY = Math.max(maxY, paramFloat4);
  }
  
  public void add(float paramFloat1, float paramFloat2, float paramFloat3)
  {
    if (paramFloat3 != 0.0F) {
      throw new UnsupportedOperationException("Unknown BoundsType");
    }
    unionWith(paramFloat1, paramFloat2, paramFloat1, paramFloat2);
  }
  
  public void add(float paramFloat1, float paramFloat2)
  {
    unionWith(paramFloat1, paramFloat2, paramFloat1, paramFloat2);
  }
  
  public void add(Point2D paramPoint2D)
  {
    add(x, y);
  }
  
  public void intersectWith(BaseBounds paramBaseBounds)
  {
    if (isEmpty()) {
      return;
    }
    if (paramBaseBounds.isEmpty())
    {
      makeEmpty();
      return;
    }
    minX = Math.max(minX, paramBaseBounds.getMinX());
    minY = Math.max(minY, paramBaseBounds.getMinY());
    maxX = Math.min(maxX, paramBaseBounds.getMaxX());
    maxY = Math.min(maxY, paramBaseBounds.getMaxY());
  }
  
  public void intersectWith(Rectangle paramRectangle)
  {
    float f1 = x;
    float f2 = y;
    intersectWith(f1, f2, f1 + width, f2 + height);
  }
  
  public void intersectWith(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
  {
    if (isEmpty()) {
      return;
    }
    if ((paramFloat3 < paramFloat1) || (paramFloat4 < paramFloat2))
    {
      makeEmpty();
      return;
    }
    minX = Math.max(minX, paramFloat1);
    minY = Math.max(minY, paramFloat2);
    maxX = Math.min(maxX, paramFloat3);
    maxY = Math.min(maxY, paramFloat4);
  }
  
  public void intersectWith(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4, float paramFloat5, float paramFloat6)
  {
    if (isEmpty()) {
      return;
    }
    if ((paramFloat4 < paramFloat1) || (paramFloat5 < paramFloat2) || (paramFloat6 < paramFloat3))
    {
      makeEmpty();
      return;
    }
    minX = Math.max(minX, paramFloat1);
    minY = Math.max(minY, paramFloat2);
    maxX = Math.min(maxX, paramFloat4);
    maxY = Math.min(maxY, paramFloat5);
  }
  
  public boolean contains(Point2D paramPoint2D)
  {
    if ((paramPoint2D == null) || (isEmpty())) {
      return false;
    }
    return (x >= minX) && (x <= maxX) && (y >= minY) && (y <= maxY);
  }
  
  public boolean contains(float paramFloat1, float paramFloat2)
  {
    if (isEmpty()) {
      return false;
    }
    return (paramFloat1 >= minX) && (paramFloat1 <= maxX) && (paramFloat2 >= minY) && (paramFloat2 <= maxY);
  }
  
  public boolean contains(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
  {
    if (isEmpty()) {
      return false;
    }
    return (contains(paramFloat1, paramFloat2)) && (contains(paramFloat1 + paramFloat3, paramFloat2 + paramFloat4));
  }
  
  public boolean intersects(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
  {
    if (isEmpty()) {
      return false;
    }
    return (paramFloat1 + paramFloat3 >= minX) && (paramFloat2 + paramFloat4 >= minY) && (paramFloat1 <= maxX) && (paramFloat2 <= maxY);
  }
  
  public boolean intersects(BaseBounds paramBaseBounds)
  {
    if ((paramBaseBounds == null) || (paramBaseBounds.isEmpty()) || (isEmpty())) {
      return false;
    }
    return (paramBaseBounds.getMaxX() >= minX) && (paramBaseBounds.getMaxY() >= minY) && (paramBaseBounds.getMaxZ() >= getMinZ()) && (paramBaseBounds.getMinX() <= maxX) && (paramBaseBounds.getMinY() <= maxY) && (paramBaseBounds.getMinZ() <= getMaxZ());
  }
  
  public boolean disjoint(float paramFloat1, float paramFloat2, float paramFloat3, float paramFloat4)
  {
    if (isEmpty()) {
      return true;
    }
    return (paramFloat1 + paramFloat3 < minX) || (paramFloat2 + paramFloat4 < minY) || (paramFloat1 > maxX) || (paramFloat2 > maxY);
  }
  
  public boolean disjoint(RectBounds paramRectBounds)
  {
    if ((paramRectBounds == null) || (paramRectBounds.isEmpty()) || (isEmpty())) {
      return true;
    }
    return (paramRectBounds.getMaxX() < minX) || (paramRectBounds.getMaxY() < minY) || (paramRectBounds.getMinX() > maxX) || (paramRectBounds.getMinY() > maxY);
  }
  
  public boolean isEmpty()
  {
    return (maxX < minX) || (maxY < minY);
  }
  
  public void roundOut()
  {
    minX = ((float)Math.floor(minX));
    minY = ((float)Math.floor(minY));
    maxX = ((float)Math.ceil(maxX));
    maxY = ((float)Math.ceil(maxY));
  }
  
  public void grow(float paramFloat1, float paramFloat2)
  {
    minX -= paramFloat1;
    maxX += paramFloat1;
    minY -= paramFloat2;
    maxY += paramFloat2;
  }
  
  public BaseBounds deriveWithPadding(float paramFloat1, float paramFloat2, float paramFloat3)
  {
    if (paramFloat3 == 0.0F)
    {
      grow(paramFloat1, paramFloat2);
      return this;
    }
    BoxBounds localBoxBounds = new BoxBounds(minX, minY, 0.0F, maxX, maxY, 0.0F);
    localBoxBounds.grow(paramFloat1, paramFloat2, paramFloat3);
    return localBoxBounds;
  }
  
  public RectBounds makeEmpty()
  {
    minX = (minY = 0.0F);
    maxX = (maxY = -1.0F);
    return this;
  }
  
  protected void sortMinMax()
  {
    float f;
    if (minX > maxX)
    {
      f = maxX;
      maxX = minX;
      minX = f;
    }
    if (minY > maxY)
    {
      f = maxY;
      maxY = minY;
      minY = f;
    }
  }
  
  public boolean equals(Object paramObject)
  {
    if (paramObject == null) {
      return false;
    }
    if (getClass() != paramObject.getClass()) {
      return false;
    }
    RectBounds localRectBounds = (RectBounds)paramObject;
    if (minX != localRectBounds.getMinX()) {
      return false;
    }
    if (minY != localRectBounds.getMinY()) {
      return false;
    }
    if (maxX != localRectBounds.getMaxX()) {
      return false;
    }
    return maxY == localRectBounds.getMaxY();
  }
  
  public int hashCode()
  {
    int i = 7;
    i = 79 * i + Float.floatToIntBits(minX);
    i = 79 * i + Float.floatToIntBits(minY);
    i = 79 * i + Float.floatToIntBits(maxX);
    i = 79 * i + Float.floatToIntBits(maxY);
    return i;
  }
  
  public String toString()
  {
    return "RectBounds { minX:" + minX + ", minY:" + minY + ", maxX:" + maxX + ", maxY:" + maxY + "}";
  }
}

/* Location:
 * Qualified Name:     com.sun.javafx.geom.RectBounds
 * Java Class Version: 6 (50.0)
 * JD-Core Version:    0.7.1
 */
package com.sun.javafx.geom;

public class Rectangle
{
  public int x;
  public int y;
  public int width;
  public int height;
  
  public Rectangle()
  {
    this(0, 0, 0, 0);
  }
  
  public Rectangle(BaseBounds paramBaseBounds)
  {
    setBounds(paramBaseBounds);
  }
  
  public Rectangle(Rectangle paramRectangle)
  {
    this(x, y, width, height);
  }
  
  public Rectangle(int paramInt1, int paramInt2, int paramInt3, int paramInt4)
  {
    x = paramInt1;
    y = paramInt2;
    width = paramInt3;
    height = paramInt4;
  }
  
  public Rectangle(int paramInt1, int paramInt2)
  {
    this(0, 0, paramInt1, paramInt2);
  }
  
  public void setBounds(Rectangle paramRectangle)
  {
    setBounds(x, y, width, height);
  }
  
  public void setBounds(int paramInt1, int paramInt2, int paramInt3, int paramInt4)
  {
    reshape(paramInt1, paramInt2, paramInt3, paramInt4);
  }
  
  public void setBounds(BaseBounds paramBaseBounds)
  {
    x = ((int)Math.floor(paramBaseBounds.getMinX()));
    y = ((int)Math.floor(paramBaseBounds.getMinY()));
    int i = (int)Math.ceil(paramBaseBounds.getMaxX());
    int j = (int)Math.ceil(paramBaseBounds.getMaxY());
    width = (i - x);
    height = (j - y);
  }
  
  public boolean contains(int paramInt1, int paramInt2)
  {
    int i = width;
    int j = height;
    if ((i | j) < 0) {
      return false;
    }
    int k = x;
    int m = y;
    if ((paramInt1 < k) || (paramInt2 < m)) {
      return false;
    }
    i += k;
    j += m;
    return ((i < k) || (i > paramInt1)) && ((j < m) || (j > paramInt2));
  }
  
  public boolean contains(Rectangle paramRectangle)
  {
    return contains(x, y, width, height);
  }
  
  public boolean contains(int paramInt1, int paramInt2, int paramInt3, int paramInt4)
  {
    int i = width;
    int j = height;
    if ((i | j | paramInt3 | paramInt4) < 0) {
      return false;
    }
    int k = x;
    int m = y;
    if ((paramInt1 < k) || (paramInt2 < m)) {
      return false;
    }
    i += k;
    paramInt3 += paramInt1;
    if (paramInt3 <= paramInt1)
    {
      if ((i >= k) || (paramInt3 > i)) {
        return false;
      }
    }
    else if ((i >= k) && (paramInt3 > i)) {
      return false;
    }
    j += m;
    paramInt4 += paramInt2;
    if (paramInt4 <= paramInt2)
    {
      if ((j >= m) || (paramInt4 > j)) {
        return false;
      }
    }
    else if ((j >= m) && (paramInt4 > j)) {
      return false;
    }
    retur
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2017. Infinite Loop Ltd