From ffbf9af5edf89e60938e85772b9e5acd5e56ea5b Mon Sep 17 00:00:00 2001
From: codeanticode <andres.colubri@gmail.com>
Date: Mon, 12 Dec 2011 04:20:41 +0000
Subject: [PATCH] Added new P3D examples

---
 .../examples/Animation/Yellowtail/Gesture.pde | 256 ++++++++++++++++++
 .../examples/Animation/Yellowtail/Vec3f.pde   |  19 ++
 .../Animation/Yellowtail/Yellowtail.pde       | 189 +++++++++++++
 .../examples/Camera/MoveEye/MoveEye.pde       |  31 +++
 .../OrthoVSPerspective/OrthoVSPerspective.pde |  44 +++
 .../Camera/Perspective/Perspective.pde        |  41 +++
 .../examples/Form/BrickTower/BrickTower.pde   |  59 ++++
 .../opengl/examples/Form/BrickTower/Cube.pde  |  60 ++++
 .../examples/Form/CubicGrid/CubicGrid.pde     |  47 ++++
 .../examples/Form/Geometry/Geometry.pde       | 162 +++++++++++
 .../examples/Form/Icosahedra/Dimension3D.pde  |  10 +
 .../examples/Form/Icosahedra/Icosahedra.pde   |  52 ++++
 .../examples/Form/Icosahedra/Icosahedron.pde  | 159 +++++++++++
 .../examples/Form/Icosahedra/Shape3D.pde      |  82 ++++++
 .../Form/Primitives3D/Primitives3D.pde        |  30 ++
 .../opengl/examples/Form/RGBCube/RGBCube.pde  |  74 +++++
 .../opengl/examples/Form/RunAmuck/Legs.pde    | 162 +++++++++++
 .../examples/Form/RunAmuck/RunAmuck.pde       |  45 +++
 .../Form/ShapeTransform/ShapeTransform.pde    | 116 ++++++++
 .../opengl/examples/Form/SpaceJunk/Cube.pde   |  73 +++++
 .../examples/Form/SpaceJunk/SpaceJunk.pde     |  63 +++++
 .../Form/TexturedSphere/TexturedSphere.pde    | 172 ++++++++++++
 .../opengl/examples/Form/Toroid/Toroid.pde    | 182 +++++++++++++
 .../examples/Form/Vertices/Vertices.pde       |  67 +++++
 .../examples/Image/Blending/Blending.pde      |  80 ++++++
 .../opengl/examples/Image/Explode/Explode.pde |  43 +++
 .../examples/Image/Explode/data/eames.jpg.tmp | Bin 0 -> 44496 bytes
 .../examples/Image/Extrusion/Extrusion.pde    |  46 ++++
 .../Image/ExtrusionGL/ExtrusionGL.pde         |  49 ++++
 .../opengl/examples/Image/Zoom/Zoom.pde       |  89 ++++++
 .../examples/Immediate/Bezier/Bezier.pde      |  22 ++
 .../Immediate/Robot1_Draw/Robot1_Draw.pde     |  41 +++
 .../ShapePrimitives/ShapePrimitives.pde       |  32 +++
 .../Immediate/TriangleStrip/TriangleStrip.pde |  44 +++
 .../Lights/CameraLight/CameraLight.pde        |  42 +++
 .../Lights/Directional/Directional.pde        |  28 ++
 .../examples/Lights/Lights1/Lights1.pde       |  29 ++
 .../examples/Lights/Lights2/Lights2.pde       |  36 +++
 .../examples/Lights/LightsGL/LightsGL.pde     |  45 +++
 .../examples/Lights/Reflection/Reflection.pde |  25 ++
 .../opengl/examples/Lights/Spot/Spot.pde      |  35 +++
 .../opengl/examples/LowLevel/Nehe/Bitmap.pde  | 147 ++++++++++
 .../opengl/examples/LowLevel/Nehe/Nehe.pde    | 235 ++++++++++++++++
 .../opengl/examples/LowLevel/Nehe/Texture.pde |  82 ++++++
 .../examples/LowLevel/Nehe/VertData.pde       | 147 ++++++++++
 .../examples/LowLevel/Nehe/data/glass.bmp     | Bin 0 -> 49220 bytes
 .../Performance/CubicGrid/CubicGrid.pde       |  53 ++++
 .../examples/Performance/Esfera/Esfera.pde    |  89 ++++++
 .../LineRendering/LineRendering.pde           |  25 ++
 .../QuadRendering/QuadRendering.pde           |  18 ++
 .../TextRendering/TextRendering.pde           |  16 ++
 .../Retained/PolyImmediate/PolyImmediate.pde  |  18 ++
 .../Retained/PolyRetain/PolyRetain.pde        |  19 ++
 .../examples/Retained/Shape2_18/Shape2_18.pde |  15 +
 .../examples/Textures/Texture1/Texture1.pde   |  28 ++
 .../examples/Textures/Texture2/Texture2.pde   |  25 ++
 .../examples/Textures/Texture3/Texture3.pde   |  46 ++++
 .../Textures/TextureCube/TextureCube.pde      |  91 +++++++
 .../opengl/examples/Transform/Bird/Bird.pde   |  63 +++++
 .../opengl/examples/Transform/Birds/Bird.pde  |  99 +++++++
 .../opengl/examples/Transform/Birds/Birds.pde |  53 ++++
 .../Transform/CubesWithinCube/Cube.pde        |  72 +++++
 .../CubesWithinCube/CubesWithinCube.pde       | 117 ++++++++
 .../Transform/PushPopCubes/PushPopCubes.pde   | 144 ++++++++++
 .../examples/Transform/Rotate1/Rotate1.pde    |  38 +++
 .../examples/Transform/Rotate2/Rotate2.pde    |  42 +++
 .../Typography/KineticType/KineticType.pde    |  64 +++++
 .../Typography/KineticType/Letter.pde         |  13 +
 .../examples/Typography/KineticType/Line.pde  |  28 ++
 .../examples/Typography/KineticType/Word.pde  |  10 +
 .../KineticType/data/Univers-66.vlw           | Bin 0 -> 116537 bytes
 .../examples/Typography/LetterK/LetterK.pde   | 125 +++++++++
 .../examples/Typography/Typing/Typing.pde     |  82 ++++++
 .../Typography/Typing/data/Univers45.vlw      | Bin 0 -> 95193 bytes
 74 files changed, 4885 insertions(+)
 create mode 100755 java/libraries/opengl/examples/Animation/Yellowtail/Gesture.pde
 create mode 100755 java/libraries/opengl/examples/Animation/Yellowtail/Vec3f.pde
 create mode 100755 java/libraries/opengl/examples/Animation/Yellowtail/Yellowtail.pde
 create mode 100755 java/libraries/opengl/examples/Camera/MoveEye/MoveEye.pde
 create mode 100755 java/libraries/opengl/examples/Camera/OrthoVSPerspective/OrthoVSPerspective.pde
 create mode 100755 java/libraries/opengl/examples/Camera/Perspective/Perspective.pde
 create mode 100755 java/libraries/opengl/examples/Form/BrickTower/BrickTower.pde
 create mode 100755 java/libraries/opengl/examples/Form/BrickTower/Cube.pde
 create mode 100755 java/libraries/opengl/examples/Form/CubicGrid/CubicGrid.pde
 create mode 100755 java/libraries/opengl/examples/Form/Geometry/Geometry.pde
 create mode 100755 java/libraries/opengl/examples/Form/Icosahedra/Dimension3D.pde
 create mode 100755 java/libraries/opengl/examples/Form/Icosahedra/Icosahedra.pde
 create mode 100755 java/libraries/opengl/examples/Form/Icosahedra/Icosahedron.pde
 create mode 100755 java/libraries/opengl/examples/Form/Icosahedra/Shape3D.pde
 create mode 100755 java/libraries/opengl/examples/Form/Primitives3D/Primitives3D.pde
 create mode 100755 java/libraries/opengl/examples/Form/RGBCube/RGBCube.pde
 create mode 100755 java/libraries/opengl/examples/Form/RunAmuck/Legs.pde
 create mode 100755 java/libraries/opengl/examples/Form/RunAmuck/RunAmuck.pde
 create mode 100755 java/libraries/opengl/examples/Form/ShapeTransform/ShapeTransform.pde
 create mode 100755 java/libraries/opengl/examples/Form/SpaceJunk/Cube.pde
 create mode 100755 java/libraries/opengl/examples/Form/SpaceJunk/SpaceJunk.pde
 create mode 100755 java/libraries/opengl/examples/Form/TexturedSphere/TexturedSphere.pde
 create mode 100755 java/libraries/opengl/examples/Form/Toroid/Toroid.pde
 create mode 100755 java/libraries/opengl/examples/Form/Vertices/Vertices.pde
 create mode 100755 java/libraries/opengl/examples/Image/Blending/Blending.pde
 create mode 100755 java/libraries/opengl/examples/Image/Explode/Explode.pde
 create mode 100755 java/libraries/opengl/examples/Image/Explode/data/eames.jpg.tmp
 create mode 100755 java/libraries/opengl/examples/Image/Extrusion/Extrusion.pde
 create mode 100755 java/libraries/opengl/examples/Image/ExtrusionGL/ExtrusionGL.pde
 create mode 100755 java/libraries/opengl/examples/Image/Zoom/Zoom.pde
 create mode 100755 java/libraries/opengl/examples/Immediate/Bezier/Bezier.pde
 create mode 100755 java/libraries/opengl/examples/Immediate/Robot1_Draw/Robot1_Draw.pde
 create mode 100755 java/libraries/opengl/examples/Immediate/ShapePrimitives/ShapePrimitives.pde
 create mode 100755 java/libraries/opengl/examples/Immediate/TriangleStrip/TriangleStrip.pde
 create mode 100755 java/libraries/opengl/examples/Lights/CameraLight/CameraLight.pde
 create mode 100755 java/libraries/opengl/examples/Lights/Directional/Directional.pde
 create mode 100755 java/libraries/opengl/examples/Lights/Lights1/Lights1.pde
 create mode 100755 java/libraries/opengl/examples/Lights/Lights2/Lights2.pde
 create mode 100755 java/libraries/opengl/examples/Lights/LightsGL/LightsGL.pde
 create mode 100755 java/libraries/opengl/examples/Lights/Reflection/Reflection.pde
 create mode 100755 java/libraries/opengl/examples/Lights/Spot/Spot.pde
 create mode 100755 java/libraries/opengl/examples/LowLevel/Nehe/Bitmap.pde
 create mode 100755 java/libraries/opengl/examples/LowLevel/Nehe/Nehe.pde
 create mode 100755 java/libraries/opengl/examples/LowLevel/Nehe/Texture.pde
 create mode 100755 java/libraries/opengl/examples/LowLevel/Nehe/VertData.pde
 create mode 100755 java/libraries/opengl/examples/LowLevel/Nehe/data/glass.bmp
 create mode 100755 java/libraries/opengl/examples/Performance/CubicGrid/CubicGrid.pde
 create mode 100755 java/libraries/opengl/examples/Performance/Esfera/Esfera.pde
 create mode 100755 java/libraries/opengl/examples/Performance/LineRendering/LineRendering.pde
 create mode 100755 java/libraries/opengl/examples/Performance/QuadRendering/QuadRendering.pde
 create mode 100755 java/libraries/opengl/examples/Performance/TextRendering/TextRendering.pde
 create mode 100755 java/libraries/opengl/examples/Retained/PolyImmediate/PolyImmediate.pde
 create mode 100755 java/libraries/opengl/examples/Retained/PolyRetain/PolyRetain.pde
 create mode 100755 java/libraries/opengl/examples/Retained/Shape2_18/Shape2_18.pde
 create mode 100755 java/libraries/opengl/examples/Textures/Texture1/Texture1.pde
 create mode 100755 java/libraries/opengl/examples/Textures/Texture2/Texture2.pde
 create mode 100755 java/libraries/opengl/examples/Textures/Texture3/Texture3.pde
 create mode 100755 java/libraries/opengl/examples/Textures/TextureCube/TextureCube.pde
 create mode 100755 java/libraries/opengl/examples/Transform/Bird/Bird.pde
 create mode 100755 java/libraries/opengl/examples/Transform/Birds/Bird.pde
 create mode 100755 java/libraries/opengl/examples/Transform/Birds/Birds.pde
 create mode 100755 java/libraries/opengl/examples/Transform/CubesWithinCube/Cube.pde
 create mode 100755 java/libraries/opengl/examples/Transform/CubesWithinCube/CubesWithinCube.pde
 create mode 100755 java/libraries/opengl/examples/Transform/PushPopCubes/PushPopCubes.pde
 create mode 100755 java/libraries/opengl/examples/Transform/Rotate1/Rotate1.pde
 create mode 100755 java/libraries/opengl/examples/Transform/Rotate2/Rotate2.pde
 create mode 100755 java/libraries/opengl/examples/Typography/KineticType/KineticType.pde
 create mode 100755 java/libraries/opengl/examples/Typography/KineticType/Letter.pde
 create mode 100755 java/libraries/opengl/examples/Typography/KineticType/Line.pde
 create mode 100755 java/libraries/opengl/examples/Typography/KineticType/Word.pde
 create mode 100755 java/libraries/opengl/examples/Typography/KineticType/data/Univers-66.vlw
 create mode 100755 java/libraries/opengl/examples/Typography/LetterK/LetterK.pde
 create mode 100755 java/libraries/opengl/examples/Typography/Typing/Typing.pde
 create mode 100755 java/libraries/opengl/examples/Typography/Typing/data/Univers45.vlw

diff --git a/java/libraries/opengl/examples/Animation/Yellowtail/Gesture.pde b/java/libraries/opengl/examples/Animation/Yellowtail/Gesture.pde
new file mode 100755
index 000000000..64382e9bb
--- /dev/null
+++ b/java/libraries/opengl/examples/Animation/Yellowtail/Gesture.pde
@@ -0,0 +1,256 @@
+class Gesture {
+
+  float  damp = 5.0;
+  float  dampInv = 1.0 / damp;
+  float  damp1 = damp - 1;
+
+  int w;
+  int h;
+  int capacity;
+
+  Vec3f path[];
+  int crosses[];
+  Polygon polygons[];
+  int nPoints;
+  int nPolys;
+
+  float jumpDx, jumpDy;
+  boolean exists;
+  float INIT_TH = 14;
+  float thickness = INIT_TH;
+
+  Gesture(int mw, int mh) {
+    w = mw;
+    h = mh;
+    capacity = 600;
+    path = new Vec3f[capacity];
+    polygons = new Polygon[capacity];
+    crosses  = new int[capacity];
+    for (int i=0;i<capacity;i++) {
+      polygons[i] = new Polygon();
+      polygons[i].npoints = 4;
+      path[i] = new Vec3f();
+      crosses[i] = 0;
+    }
+    nPoints = 0;
+    nPolys = 0;
+
+    exists = false;
+    jumpDx = 0;
+    jumpDy = 0;
+  }
+
+  void clear() {
+    nPoints = 0;
+    exists = false;
+    thickness = INIT_TH;
+  }
+
+  void clearPolys() {
+    nPolys = 0;
+  }
+
+  void addPoint(float x, float y) {
+
+    if (nPoints >= capacity) {
+      // there are all sorts of possible solutions here,
+      // but for abject simplicity, I don't do anything.
+    } 
+    else {
+      float v = distToLast(x, y);
+      float p = getPressureFromVelocity(v);
+      path[nPoints++].set(x,y,p);
+
+      if (nPoints > 1) {
+        exists = true;
+        jumpDx = path[nPoints-1].x - path[0].x;
+        jumpDy = path[nPoints-1].y - path[0].y;
+      }
+    }
+
+  }
+
+  float getPressureFromVelocity(float v) {
+    final float scale = 18;
+    final float minP = 0.02;
+    final float oldP = (nPoints > 0) ? path[nPoints-1].p : 0;
+    return ((minP + max(0, 1.0 - v/scale)) + (damp1*oldP))*dampInv;
+  }
+
+  void setPressures() {
+    // pressures vary from 0...1
+    float pressure;
+    Vec3f tmp;
+    float t = 0;
+    float u = 1.0 / (nPoints - 1)*TWO_PI;
+    for (int i = 0; i < nPoints; i++) {
+      pressure = sqrt((1.0 - cos(t))*0.5);
+      path[i].p = pressure;
+      t += u;
+    }
+  }
+
+  float distToLast(float ix, float iy) {
+    if (nPoints > 0) {
+      Vec3f v = path[nPoints-1];
+      float dx = v.x - ix;
+      float dy = v.y - iy;
+      return mag(dx, dy);
+    } 
+    else {
+      return 30;
+    }
+  }
+
+  void compile() {
+    // compute the polygons from the path of Vec3f's
+    if (exists) {
+      clearPolys();
+
+      Vec3f p0, p1, p2;
+      float radius0, radius1;
+      float ax, bx, cx, dx;
+      float ay, by, cy, dy;
+      int   axi, bxi, cxi, dxi, axip, axid;
+      int   ayi, byi, cyi, dyi, ayip, ayid;
+      float p1x, p1y;
+      float dx01, dy01, hp01, si01, co01;
+      float dx02, dy02, hp02, si02, co02;
+      float dx13, dy13, hp13, si13, co13;
+      float taper = 1.0;
+
+      int  nPathPoints = nPoints - 1;
+      int  lastPolyIndex = nPathPoints - 1;
+      float npm1finv =  1.0 / max(1, nPathPoints - 1);
+
+      // handle the first point
+      p0 = path[0];
+      p1 = path[1];
+      radius0 = p0.p * thickness;
+      dx01 = p1.x - p0.x;
+      dy01 = p1.y - p0.y;
+      hp01 = sqrt(dx01*dx01 + dy01*dy01);
+      if (hp01 == 0) {
+        hp02 = 0.0001;
+      }
+      co01 = radius0 * dx01 / hp01;
+      si01 = radius0 * dy01 / hp01;
+      ax = p0.x - si01; 
+      ay = p0.y + co01;
+      bx = p0.x + si01; 
+      by = p0.y - co01;
+
+      int xpts[];
+      int ypts[];
+
+      int LC = 20;
+      int RC = w-LC;
+      int TC = 20;
+      int BC = h-TC;
+      float mint = 0.618;
+      float tapow = 0.4;
+
+      // handle the middle points
+      int i = 1;
+      Polygon apoly;
+      for (i = 1; i < nPathPoints; i++) {
+        taper = pow((lastPolyIndex-i)*npm1finv,tapow);
+
+        p0 = path[i-1];
+        p1 = path[i  ];
+        p2 = path[i+1];
+        p1x = p1.x;
+        p1y = p1.y;
+        radius1 = Math.max(mint,taper*p1.p*thickness);
+
+        // assumes all segments are roughly the same length...
+        dx02 = p2.x - p0.x;
+        dy02 = p2.y - p0.y;
+        hp02 = (float) Math.sqrt(dx02*dx02 + dy02*dy02);
+        if (hp02 != 0) {
+          hp02 = radius1/hp02;
+        }
+        co02 = dx02 * hp02;
+        si02 = dy02 * hp02;
+
+        // translate the integer coordinates to the viewing rectangle
+        axi = axip = (int)ax;
+        ayi = ayip = (int)ay;
+        axi=(axi<0)?(w-((-axi)%w)):axi%w;
+        axid = axi-axip;
+        ayi=(ayi<0)?(h-((-ayi)%h)):ayi%h;
+        ayid = ayi-ayip;
+
+        // set the vertices of the polygon
+        apoly = polygons[nPolys++];
+        xpts = apoly.xpoints;
+        ypts = apoly.ypoints;
+        xpts[0] = axi = axid + axip;
+        xpts[1] = bxi = axid + (int) bx;
+        xpts[2] = cxi = axid + (int)(cx = p1x + si02);
+        xpts[3] = dxi = axid + (int)(dx = p1x - si02);
+        ypts[0] = ayi = ayid + ayip;
+        ypts[1] = byi = ayid + (int) by;
+        ypts[2] = cyi = ayid + (int)(cy = p1y - co02);
+        ypts[3] = dyi = ayid + (int)(dy = p1y + co02);
+
+        // keep a record of where we cross the edge of the screen
+        crosses[i] = 0;
+        if ((axi<=LC)||(bxi<=LC)||(cxi<=LC)||(dxi<=LC)) { 
+          crosses[i]|=1; 
+        }
+        if ((axi>=RC)||(bxi>=RC)||(cxi>=RC)||(dxi>=RC)) { 
+          crosses[i]|=2; 
+        }
+        if ((ayi<=TC)||(byi<=TC)||(cyi<=TC)||(dyi<=TC)) { 
+          crosses[i]|=4; 
+        }
+        if ((ayi>=BC)||(byi>=BC)||(cyi>=BC)||(dyi>=BC)) { 
+          crosses[i]|=8; 
+        }
+
+        //swap data for next time
+        ax = dx; 
+        ay = dy;
+        bx = cx; 
+        by = cy;
+      }
+
+      // handle the last point
+      p2 = path[nPathPoints];
+      apoly = polygons[nPolys++];
+      xpts = apoly.xpoints;
+      ypts = apoly.ypoints;
+
+      xpts[0] = (int)ax;
+      xpts[1] = (int)bx;
+      xpts[2] = (int)(p2.x);
+      xpts[3] = (int)(p2.x);
+
+      ypts[0] = (int)ay;
+      ypts[1] = (int)by;
+      ypts[2] = (int)(p2.y);
+      ypts[3] = (int)(p2.y);
+
+    }
+  }
+
+  void smooth() {
+    // average neighboring points
+
+    final float weight = 18;
+    final float scale  = 1.0 / (weight + 2);
+    int nPointsMinusTwo = nPoints - 2;
+    Vec3f lower, upper, center;
+
+    for (int i = 1; i < nPointsMinusTwo; i++) {
+      lower = path[i-1];
+      center = path[i];
+      upper = path[i+1];
+
+      center.x = (lower.x + weight*center.x + upper.x)*scale;
+      center.y = (lower.y + weight*center.y + upper.y)*scale;
+    }
+  }
+}
+
diff --git a/java/libraries/opengl/examples/Animation/Yellowtail/Vec3f.pde b/java/libraries/opengl/examples/Animation/Yellowtail/Vec3f.pde
new file mode 100755
index 000000000..865d3c32f
--- /dev/null
+++ b/java/libraries/opengl/examples/Animation/Yellowtail/Vec3f.pde
@@ -0,0 +1,19 @@
+class Vec3f {
+  float x;
+  float y;
+  float p;  // Pressure
+
+  Vec3f() {
+    set(0, 0, 0);
+  }
+  
+  Vec3f(float ix, float iy, float ip) {
+    set(ix, iy, ip);
+  }
+
+  void set(float ix, float iy, float ip) {
+    x = ix;
+    y = iy;
+    p = ip;
+  }
+}
diff --git a/java/libraries/opengl/examples/Animation/Yellowtail/Yellowtail.pde b/java/libraries/opengl/examples/Animation/Yellowtail/Yellowtail.pde
new file mode 100755
index 000000000..86ab51271
--- /dev/null
+++ b/java/libraries/opengl/examples/Animation/Yellowtail/Yellowtail.pde
@@ -0,0 +1,189 @@
+/**
+ * Yellowtail
+ * by Golan Levin (www.flong.com). 
+ * 
+ * Click, drag, and release to create a kinetic gesture.
+ * 
+ * Yellowtail (1998-2000) is an interactive software system for the gestural 
+ * creation and performance of real-time abstract animation. Yellowtail repeats 
+ * a user's strokes end-over-end, enabling simultaneous specification of a 
+ * line's shape and quality of movement. Each line repeats according to its 
+ * own period, producing an ever-changing and responsive display of lively, 
+ * worm-like textures.
+ */
+
+
+import java.awt.Polygon;
+
+Gesture gestureArray[];
+final int nGestures = 36;  // Number of gestures
+final int minMove = 3;     // Minimum travel for a new point
+int currentGestureID;
+
+Polygon tempP;
+int tmpXp[];
+int tmpYp[];
+
+
+void setup() {
+  size(1024, 768, P3D);
+  background(0, 0, 0);
+  noStroke();
+
+  currentGestureID = -1;
+  gestureArray = new Gesture[nGestures];
+  for (int i = 0; i < nGestures; i++) {
+    gestureArray[i] = new Gesture(width, height);
+  }
+  clearGestures();
+}
+
+
+void draw() {
+  background(0);
+
+  updateGeometry();
+  fill(255, 255, 245);
+  for (int i = 0; i < nGestures; i++) {
+    renderGesture(gestureArray[i], width, height);
+  }
+}
+
+void mousePressed() {
+  currentGestureID = (currentGestureID+1) % nGestures;
+  Gesture G = gestureArray[currentGestureID];
+  G.clear();
+  G.clearPolys();
+  G.addPoint(mouseX, mouseY);
+}
+
+
+void mouseDragged() {
+  if (currentGestureID >= 0) {
+    Gesture G = gestureArray[currentGestureID];
+    if (G.distToLast(mouseX, mouseY) > minMove) {
+      G.addPoint(mouseX, mouseY);
+      G.smooth();
+      G.compile();
+    }
+  }
+}
+
+
+void keyPressed() {
+  if (key == '+' || key == '=') {
+    if (currentGestureID >= 0) {
+      float th = gestureArray[currentGestureID].thickness;
+      gestureArray[currentGestureID].thickness = min(96, th+1);
+      gestureArray[currentGestureID].compile();
+    }
+  } else if (key == '-') {
+    if (currentGestureID >= 0) {
+      float th = gestureArray[currentGestureID].thickness;
+      gestureArray[currentGestureID].thickness = max(2, th-1);
+      gestureArray[currentGestureID].compile();
+    }
+  } else if (key == ' ') {
+    clearGestures();
+  }
+}
+
+
+void renderGesture(Gesture gesture, int w, int h) {
+  if (gesture.exists) {
+    if (gesture.nPolys > 0) {
+      Polygon polygons[] = gesture.polygons;
+      int crosses[] = gesture.crosses;
+
+      int xpts[];
+      int ypts[];
+      Polygon p;
+      int cr;
+
+      beginShape(QUADS);
+      int gnp = gesture.nPolys;
+      for (int i=0; i<gnp; i++) {
+
+        p = polygons[i];
+        xpts = p.xpoints;
+        ypts = p.ypoints;
+
+        vertex(xpts[0], ypts[0]);
+        vertex(xpts[1], ypts[1]);
+        vertex(xpts[2], ypts[2]);
+        vertex(xpts[3], ypts[3]);
+
+        if ((cr = crosses[i]) > 0) {
+          if ((cr & 3)>0) {
+            vertex(xpts[0]+w, ypts[0]);
+            vertex(xpts[1]+w, ypts[1]);
+            vertex(xpts[2]+w, ypts[2]);
+            vertex(xpts[3]+w, ypts[3]);
+
+            vertex(xpts[0]-w, ypts[0]);
+            vertex(xpts[1]-w, ypts[1]);
+            vertex(xpts[2]-w, ypts[2]);
+            vertex(xpts[3]-w, ypts[3]);
+          }
+          if ((cr & 12)>0) {
+            vertex(xpts[0], ypts[0]+h);
+            vertex(xpts[1], ypts[1]+h);
+            vertex(xpts[2], ypts[2]+h);
+            vertex(xpts[3], ypts[3]+h);
+
+            vertex(xpts[0], ypts[0]-h);
+            vertex(xpts[1], ypts[1]-h);
+            vertex(xpts[2], ypts[2]-h);
+            vertex(xpts[3], ypts[3]-h);
+          }
+
+          // I have knowingly retained the small flaw of not
+          // completely dealing with the corner conditions
+          // (the case in which both of the above are true).
+        }
+      }
+      endShape();
+    }
+  }
+}
+
+void updateGeometry() {
+  Gesture J;
+  for (int g=0; g<nGestures; g++) {
+    if ((J=gestureArray[g]).exists) {
+      if (g!=currentGestureID) {
+        advanceGesture(J);
+      } else if (!mousePressed) {
+        advanceGesture(J);
+      }
+    }
+  }
+}
+
+void advanceGesture(Gesture gesture) {
+  // Move a Gesture one step
+  if (gesture.exists) { // check
+    int nPts = gesture.nPoints;
+    int nPts1 = nPts-1;
+    Vec3f path[];
+    float jx = gesture.jumpDx;
+    float jy = gesture.jumpDy;
+
+    if (nPts > 0) {
+      path = gesture.path;
+      for (int i = nPts1; i > 0; i--) {
+        path[i].x = path[i-1].x;
+        path[i].y = path[i-1].y;
+      }
+      path[0].x = path[nPts1].x - jx;
+      path[0].y = path[nPts1].y - jy;
+      gesture.compile();
+    }
+  }
+}
+
+void clearGestures() {
+  for (int i = 0; i < nGestures; i++) {
+    gestureArray[i].clear();
+  }
+}
diff --git a/java/libraries/opengl/examples/Camera/MoveEye/MoveEye.pde b/java/libraries/opengl/examples/Camera/MoveEye/MoveEye.pde
new file mode 100755
index 000000000..af6bd9b75
--- /dev/null
+++ b/java/libraries/opengl/examples/Camera/MoveEye/MoveEye.pde
@@ -0,0 +1,31 @@
+// Status: Renders with issues
+// Problem: Lights don't work
+
+/**
+ * Move Eye. 
+ * by Simon Greenwold.
+ * 
+ * The camera lifts up (controlled by mouseY) while looking at the same point.
+ */
+
+void setup() {
+  size(640, 360, P3D);
+  fill(204);
+}
+
+void draw() {
+  lights();
+  background(0);
+  
+  // Change height of the camera with mouseY
+  camera(30.0, mouseY, 220.0, // eyeX, eyeY, eyeZ
+         0.0, 0.0, 0.0, // centerX, centerY, centerZ
+         0.0, 1.0, 0.0); // upX, upY, upZ
+  
+  noStroke();
+  box(90);
+  stroke(255);
+  line(-100, 0, 0, 100, 0, 0);
+  line(0, -100, 0, 0, 100, 0);
+  line(0, 0, -100, 0, 0, 100);
+}
diff --git a/java/libraries/opengl/examples/Camera/OrthoVSPerspective/OrthoVSPerspective.pde b/java/libraries/opengl/examples/Camera/OrthoVSPerspective/OrthoVSPerspective.pde
new file mode 100755
index 000000000..9589c51c0
--- /dev/null
+++ b/java/libraries/opengl/examples/Camera/OrthoVSPerspective/OrthoVSPerspective.pde
@@ -0,0 +1,44 @@
+// Status: Wrong rendering
+
+/** 
+ * Ortho vs Perspective. 
+ * 
+ * Click to see the difference between orthographic projection
+ * and perspective projection as applied to a simple box.
+ * The ortho() function sets an orthographic projection and 
+ * defines a parallel clipping volume. All objects with the 
+ * same dimension appear the same size, regardless of whether 
+ * they are near or far from the camera. The parameters to this 
+ * function specify the clipping volume where left and right 
+ * are the minimum and maximum x values, top and bottom are the 
+ * minimum and maximum y values, and near and far are the minimum 
+ * and maximum z values.
+ */
+
+void setup() 
+{
+  size(640, 360, P3D);
+  noStroke();
+  fill(204);
+}
+
+void draw() 
+{
+  background(0);
+  lights();
+ 
+  if(mousePressed) {
+    float fov = PI/3.0; 
+    float cameraZ = (height/2.0) / tan(PI * fov / 360.0); 
+    perspective(fov, float(width)/float(height), 
+                cameraZ/2.0, cameraZ*2.0); 
+  } else {
+    ortho(-width/2, width/2, -height/2, height/2, -10, 10); 
+  }
+  
+  translate(width/2, height/2, 0);
+  rotateX(-PI/6); 
+  rotateY(PI/3); 
+  box(160); 
+}
+
diff --git a/java/libraries/opengl/examples/Camera/Perspective/Perspective.pde b/java/libraries/opengl/examples/Camera/Perspective/Perspective.pde
new file mode 100755
index 000000000..46695397d
--- /dev/null
+++ b/java/libraries/opengl/examples/Camera/Perspective/Perspective.pde
@@ -0,0 +1,41 @@
+/**
+ * Perspective. 
+ * 
+ * Move the mouse left and right to change the field of view (fov).
+ * Click to modify the aspect ratio. The perspective() function
+ * sets a perspective projection applying foreshortening, making 
+ * distant objects appear smaller than closer ones. The parameters 
+ * define a viewing volume with the shape of truncated pyramid. 
+ * Objects near to the front of the volume appear their actual size, 
+ * while farther objects appear smaller. This projection simulates 
+ * the perspective of the world more accurately than orthographic projection. 
+ * The version of perspective without parameters sets the default 
+ * perspective and the version with four parameters allows the programmer 
+ * to set the area precisely.
+ */
+
+void setup() {
+  size(640, 360, P3D);
+  noStroke();
+}
+
+void draw() {
+  lights();
+  background(204);
+  float cameraY = height/2.0;
+  float fov = mouseX/float(width) * PI/2;
+  float cameraZ = cameraY / tan(fov / 2.0);
+  float aspect = float(width)/float(height);
+  if (mousePressed) {
+    aspect = aspect / 2.0;
+  }
+  perspective(fov, aspect, cameraZ/10.0, cameraZ*10.0);
+  
+  translate(width/2+30, height/2, 0);
+  rotateX(-PI/6);
+  rotateY(PI/3 + mouseY/float(height) * PI);
+  box(45);
+  translate(0, 0, -50);
+  box(30);
+}
+
diff --git a/java/libraries/opengl/examples/Form/BrickTower/BrickTower.pde b/java/libraries/opengl/examples/Form/BrickTower/BrickTower.pde
new file mode 100755
index 000000000..c40186498
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/BrickTower/BrickTower.pde
@@ -0,0 +1,59 @@
+/**
+ * Brick Tower
+ * by Ira Greenberg. 
+ * 
+ * 3D castle tower constructed out of individual bricks.
+ * Uses the PVector and Cube classes. 
+ */
+
+float bricksPerLayer = 16.0;
+float brickLayers = 18.0;
+Cube brick;
+float brickWidth = 60, brickHeight = 25, brickDepth = 25;
+float radius = 175.0;
+float angle = 0;
+
+void setup(){
+  size(640, 360, P3D);
+  brick = new Cube(brickWidth, brickHeight, brickDepth);
+}
+
+void draw(){
+  background(0);
+  float tempX = 0, tempY = 0, tempZ = 0;
+  fill(182, 62, 29);
+  noStroke();
+  // Add basic light setup
+  lights();
+  translate(width/2, height*1.2, -380);
+  // Tip tower to see inside
+  rotateX(radians(-45));
+  // Slowly rotate tower
+  rotateY(frameCount * PI/600);
+  for (int i = 0; i < brickLayers; i++){
+    // Increment rows
+    tempY-=brickHeight;
+    // Alternate brick seams
+    angle = 360.0 / bricksPerLayer * i/2;
+    for (int j = 0; j < bricksPerLayer; j++){
+      tempZ = cos(radians(angle))*radius;
+      tempX = sin(radians(angle))*radius;
+      pushMatrix();
+      translate(tempX, tempY, tempZ);
+      rotateY(radians(angle));
+      // Add crenelation
+      if (i==brickLayers-1){
+        if (j%2 == 0){
+          brick.create();
+        }
+      }
+      // Create main tower
+      else {
+        brick.create();
+      }
+      popMatrix();
+      angle += 360.0/bricksPerLayer;
+    }
+  }
+}
+
diff --git a/java/libraries/opengl/examples/Form/BrickTower/Cube.pde b/java/libraries/opengl/examples/Form/BrickTower/Cube.pde
new file mode 100755
index 000000000..ba4fdb361
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/BrickTower/Cube.pde
@@ -0,0 +1,60 @@
+class Cube {
+
+  PVector[] vertices = new PVector[24];
+  float w, h, d;
+
+  Cube(){ }
+
+  Cube(float w, float h, float d){
+    this.w = w;
+    this.h = h;
+    this.d = d;
+
+    // Cube composed of 6 quads
+    // Front
+    vertices[0] = new PVector(-w/2, -h/2, d/2);
+    vertices[1] = new PVector(w/2, -h/2, d/2);
+    vertices[2] = new PVector(w/2, h/2, d/2);
+    vertices[3] = new PVector(-w/2, h/2, d/2);
+
+    // Left
+    vertices[4] = new PVector(-w/2, -h/2, d/2);
+    vertices[5] = new PVector(-w/2, -h/2, -d/2);
+    vertices[6] = new PVector(-w/2, h/2, -d/2);
+    vertices[7] = new PVector(-w/2, h/2, d/2);
+
+    // Right
+    vertices[8] = new PVector(w/2, -h/2, d/2);
+    vertices[9] = new PVector(w/2, -h/2, -d/2);
+    vertices[10] = new PVector(w/2, h/2, -d/2);
+    vertices[11] = new PVector(w/2, h/2, d/2);
+
+    // Back
+    vertices[12] = new PVector(-w/2, -h/2, -d/2);  
+    vertices[13] = new PVector(w/2, -h/2, -d/2);
+    vertices[14] = new PVector(w/2, h/2, -d/2);
+    vertices[15] = new PVector(-w/2, h/2, -d/2);
+
+    // Top
+    vertices[16] = new PVector(-w/2, -h/2, d/2);
+    vertices[17] = new PVector(-w/2, -h/2, -d/2);
+    vertices[18] = new PVector(w/2, -h/2, -d/2);
+    vertices[19] = new PVector(w/2, -h/2, d/2);
+
+    // Bottom
+    vertices[20] = new PVector(-w/2, h/2, d/2);
+    vertices[21] = new PVector(-w/2, h/2, -d/2);
+    vertices[22] = new PVector(w/2, h/2, -d/2);
+    vertices[23] = new PVector(w/2, h/2, d/2);
+  }
+
+  void create(){
+    for (int i=0; i<6; i++){
+      beginShape(QUADS);
+      for (int j = 0; j < 4; j++){
+        vertex(vertices[j+4*i].x, vertices[j+4*i].y, vertices[j+4*i].z);
+      }
+      endShape();
+    }
+  }
+} 
diff --git a/java/libraries/opengl/examples/Form/CubicGrid/CubicGrid.pde b/java/libraries/opengl/examples/Form/CubicGrid/CubicGrid.pde
new file mode 100755
index 000000000..111cd3f3f
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/CubicGrid/CubicGrid.pde
@@ -0,0 +1,47 @@
+/**
+ * Cubic Grid 
+ * by Ira Greenberg. 
+ * 
+ * 3D translucent colored grid uses nested pushMatrix()
+ * and popMatrix() functions. 
+ */
+
+float boxSize = 40;
+float margin = boxSize*2;
+float depth = 400;
+color boxFill;
+
+void setup() {
+  size(640, 360, P3D);
+  noStroke();
+}
+
+void draw() {
+  background(255);
+  
+  // Center and spin grid
+  translate(width/2, height/2, -depth);
+  rotateY(frameCount * 0.01);
+  rotateX(frameCount * 0.01);
+
+  // Build grid using multiple translations 
+  for (float i =- depth/2+margin; i <= depth/2-margin; i += boxSize){
+    pushMatrix();
+    for (float j =- height+margin; j <= height-margin; j += boxSize){
+      pushMatrix();
+      for (float k =- width+margin; k <= width-margin; k += boxSize){
+        // Base fill color on counter values, abs function 
+        // ensures values stay within legal range
+        boxFill = color(abs(i), abs(j), abs(k), 50);
+        pushMatrix();
+        translate(k, j, i);
+        fill(boxFill);
+        box(boxSize, boxSize, boxSize);
+        popMatrix();
+      }
+      popMatrix();
+    }
+    popMatrix();
+  }
+}
+
diff --git a/java/libraries/opengl/examples/Form/Geometry/Geometry.pde b/java/libraries/opengl/examples/Form/Geometry/Geometry.pde
new file mode 100755
index 000000000..8bbb32bd3
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/Geometry/Geometry.pde
@@ -0,0 +1,162 @@
+/**
+ * Geometry 
+ * by Marius Watz. 
+ * 
+ * Using sin/cos lookup tables, blends colors, and draws a series of 
+ * rotating arcs on the screen.
+*/
+ 
+// Trig lookup tables borrowed from Toxi; cryptic but effective.
+float sinLUT[];
+float cosLUT[];
+float SINCOS_PRECISION=1.0;
+int SINCOS_LENGTH= int((360.0/SINCOS_PRECISION));
+ 
+// System data
+boolean dosave=false;
+int num;
+float pt[];
+int style[];
+
+ 
+void setup() {
+  size(1024, 768, P3D);
+  background(255);
+  
+  // Fill the tables
+  sinLUT=new float[SINCOS_LENGTH];
+  cosLUT=new float[SINCOS_LENGTH];
+  for (int i = 0; i < SINCOS_LENGTH; i++) {
+    sinLUT[i]= (float)Math.sin(i*DEG_TO_RAD*SINCOS_PRECISION);
+    cosLUT[i]= (float)Math.cos(i*DEG_TO_RAD*SINCOS_PRECISION);
+  }
+ 
+  num = 150;
+  pt = new float[6*num]; // rotx, roty, deg, rad, w, speed
+  style = new int[2*num]; // color, render style
+ 
+  // Set up arc shapes
+  int index=0;
+  float prob;
+  for (int i=0; i<num; i++) {
+    pt[index++] = random(PI*2); // Random X axis rotation
+    pt[index++] = random(PI*2); // Random Y axis rotation
+ 
+    pt[index++] = random(60,80); // Short to quarter-circle arcs
+    if(random(100)>90) pt[index]=(int)random(8,27)*10;
+ 
+    pt[index++] = int(random(2,50)*5); // Radius. Space them out nicely
+ 
+    pt[index++] = random(4,32); // Width of band
+    if(random(100)>90) pt[index]=random(40,60); // Width of band
+ 
+    pt[index++] = radians(random(5,30))/5; // Speed of rotation
+ 
+    // get colors
+    prob = random(100);
+    if(prob<30) style[i*2]=colorBlended(random(1), 255,0,100, 255,0,0, 210);
+    else if(prob<70) style[i*2]=colorBlended(random(1), 0,153,255, 170,225,255, 210);
+    else if(prob<90) style[i*2]=colorBlended(random(1), 200,255,0, 150,255,0, 210);
+    else style[i*2]=color(255,255,255, 220);
+
+    if(prob<50) style[i*2]=colorBlended(random(1), 200,255,0, 50,120,0, 210);
+    else if(prob<90) style[i*2]=colorBlended(random(1), 255,100,0, 255,255,0, 210);
+    else style[i*2]=color(255,255,255, 220);
+
+    style[i*2+1]=(int)(random(100))%3;
+  }
+}
+ 
+void draw() {
+ 
+  background(0);
+ 
+  int index=0;
+  translate(width/2, height/2, 0);
+  rotateX(PI/6);
+  rotateY(PI/6);
+ 
+  for (int i = 0; i < num; i++) {
+    pushMatrix();
+ 
+    rotateX(pt[index++]);
+    rotateY(pt[index++]);
+ 
+    if(style[i*2+1]==0) {
+      stroke(style[i*2]);
+      noFill();
+      strokeWeight(1);
+      arcLine(0,0, pt[index++],pt[index++],pt[index++]);
+    }
+    else if(style[i*2+1]==1) {
+      fill(style[i*2]);
+      noStroke();
+      arcLineBars(0,0, pt[index++],pt[index++],pt[index++]);
+    }
+    else {
+      fill(style[i*2]);
+      noStroke();
+      arc(0,0, pt[index++],pt[index++],pt[index++]);
+    }
+ 
+    // increase rotation
+    pt[index-5]+=pt[index]/10;
+    pt[index-4]+=pt[index++]/20;
+ 
+    popMatrix();
+  }
+}
+ 
+ 
+// Get blend of two colors
+int colorBlended(float fract,
+float r, float g, float b,
+float r2, float g2, float b2, float a) {
+ 
+  r2 = (r2 - r);
+  g2 = (g2 - g);
+  b2 = (b2 - b);
+  return color(r + r2 * fract, g + g2 * fract, b + b2 * fract, a);
+}
+ 
+ 
+// Draw arc line
+void arcLine(float x,float y,float deg,float rad,float w) {
+  int a=(int)(min (deg/SINCOS_PRECISION,SINCOS_LENGTH-1));
+  int numlines=(int)(w/2);
+ 
+  for (int j=0; j<numlines; j++) {
+    beginShape();
+    for (int i=0; i<a; i++) { 
+      vertex(cosLUT[i]*rad+x,sinLUT[i]*rad+y);
+    }
+    endShape();
+    rad += 2;
+  }
+}
+ 
+// Draw arc line with bars
+void arcLineBars(float x,float y,float deg,float rad,float w) {
+  int a = int((min (deg/SINCOS_PRECISION,SINCOS_LENGTH-1)));
+  a /= 4;
+ 
+  beginShape(QUADS);
+  for (int i=0; i<a; i+=4) {
+    vertex(cosLUT[i]*(rad)+x,sinLUT[i]*(rad)+y);
+    vertex(cosLUT[i]*(rad+w)+x,sinLUT[i]*(rad+w)+y);
+    vertex(cosLUT[i+2]*(rad+w)+x,sinLUT[i+2]*(rad+w)+y);
+    vertex(cosLUT[i+2]*(rad)+x,sinLUT[i+2]*(rad)+y);
+  }
+  endShape();
+}
+ 
+// Draw solid arc
+void arc(float x,float y,float deg,float rad,float w) {
+  int a = int(min (deg/SINCOS_PRECISION,SINCOS_LENGTH-1));
+  beginShape(QUAD_STRIP);
+  for (int i = 0; i < a; i++) {
+    vertex(cosLUT[i]*(rad)+x,sinLUT[i]*(rad)+y);
+    vertex(cosLUT[i]*(rad+w)+x,sinLUT[i]*(rad+w)+y);
+  }
+  endShape();
+}
diff --git a/java/libraries/opengl/examples/Form/Icosahedra/Dimension3D.pde b/java/libraries/opengl/examples/Form/Icosahedra/Dimension3D.pde
new file mode 100755
index 000000000..90c949967
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/Icosahedra/Dimension3D.pde
@@ -0,0 +1,10 @@
+class Dimension3D{
+   float w, h, d;
+   
+   Dimension3D(float w, float h, float d){
+     this.w=w;
+     this.h=h;
+     this.d=d;
+  }
+}
+
diff --git a/java/libraries/opengl/examples/Form/Icosahedra/Icosahedra.pde b/java/libraries/opengl/examples/Form/Icosahedra/Icosahedra.pde
new file mode 100755
index 000000000..0c046b726
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/Icosahedra/Icosahedra.pde
@@ -0,0 +1,52 @@
+/**
+ * I Like Icosahedra
+ * by Ira Greenberg.
+ * 
+ * This example plots icosahedra. The Icosahdron is a regular
+ * polyhedron composed of twenty equalateral triangles.
+ */
+ 
+Icosahedron ico1;
+Icosahedron ico2;
+Icosahedron ico3;
+
+void setup(){
+  size(640, 360, P3D);
+  ico1 = new Icosahedron(75);
+  ico2 = new Icosahedron(75);
+  ico3 = new Icosahedron(75);
+}
+
+void draw(){
+  background(0);
+  lights();
+  translate(width/2, height/2);
+
+  pushMatrix();
+  translate(-width/3.5, 0);
+  rotateX(frameCount*PI/185);
+  rotateY(frameCount*PI/-200);
+  stroke(170, 0, 0);
+  noFill();
+  ico1.create();
+  popMatrix();
+
+  pushMatrix();
+  rotateX(frameCount*PI/200);
+  rotateY(frameCount*PI/300);
+  stroke(150, 0, 180);
+  fill(170, 170, 0);
+  ico2.create();
+  popMatrix();
+
+  pushMatrix();
+  translate(width/3.5, 0);
+  rotateX(frameCount*PI/-200);
+  rotateY(frameCount*PI/200);
+  noStroke();
+  fill(0, 0, 185);
+  ico3.create();
+  popMatrix();
+}
+
+
diff --git a/java/libraries/opengl/examples/Form/Icosahedra/Icosahedron.pde b/java/libraries/opengl/examples/Form/Icosahedra/Icosahedron.pde
new file mode 100755
index 000000000..3a7f89453
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/Icosahedra/Icosahedron.pde
@@ -0,0 +1,159 @@
+class Icosahedron extends Shape3D{
+
+  // icosahedron
+  PVector topPoint;
+  PVector[] topPent = new PVector[5];
+  PVector bottomPoint;
+  PVector[] bottomPent = new PVector[5];
+  float angle = 0, radius = 150;
+  float triDist;
+  float triHt;
+  float a, b, c;
+
+  // constructor
+  Icosahedron(float radius){
+    this.radius = radius;
+    init();
+  }
+
+  Icosahedron(PVector v, float radius){
+    super(v);
+    this.radius = radius;
+    init();
+  }
+
+  // calculate geometry
+  void init(){
+    c = dist(cos(0)*radius, sin(0)*radius, cos(radians(72))*radius,  sin(radians(72))*radius);
+    b = radius;
+    a = (float)(Math.sqrt(((c*c)-(b*b))));
+
+    triHt = (float)(Math.sqrt((c*c)-((c/2)*(c/2))));
+
+    for (int i=0; i<topPent.length; i++){
+      topPent[i] = new PVector(cos(angle)*radius, sin(angle)*radius, triHt/2.0f);
+      angle+=radians(72);
+    }
+    topPoint = new PVector(0, 0, triHt/2.0f+a);
+    angle = 72.0f/2.0f;
+    for (int i=0; i<topPent.length; i++){
+      bottomPent[i] = new PVector(cos(angle)*radius, sin(angle)*radius, -triHt/2.0f);
+      angle+=radians(72);
+    }
+    bottomPoint = new PVector(0, 0, -(triHt/2.0f+a));
+  }
+
+  // draws icosahedron 
+  void create(){
+    for (int i=0; i<topPent.length; i++){
+      // icosahedron top
+      beginShape();
+      if (i<topPent.length-1){
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+topPoint.x, y+topPoint.y, z+topPoint.z);
+        vertex(x+topPent[i+1].x, y+topPent[i+1].y, z+topPent[i+1].z);
+      } 
+      else {
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+topPoint.x, y+topPoint.y, z+topPoint.z);
+        vertex(x+topPent[0].x, y+topPent[0].y, z+topPent[0].z);
+      }
+      endShape(CLOSE);
+
+      // icosahedron bottom
+      beginShape();
+      if (i<bottomPent.length-1){
+        vertex(x+bottomPent[i].x, y+bottomPent[i].y, z+bottomPent[i].z);
+        vertex(x+bottomPoint.x, y+bottomPoint.y, z+bottomPoint.z);
+        vertex(x+bottomPent[i+1].x, y+bottomPent[i+1].y, z+bottomPent[i+1].z);
+      } 
+      else {
+        vertex(x+bottomPent[i].x, y+bottomPent[i].y, z+bottomPent[i].z);
+        vertex(x+bottomPoint.x, y+bottomPoint.y, z+bottomPoint.z);
+        vertex(x+bottomPent[0].x, y+bottomPent[0].y, z+bottomPent[0].z);
+      }
+      endShape(CLOSE);
+    }
+
+    // icosahedron body
+    for (int i=0; i<topPent.length; i++){
+      if (i<topPent.length-2){
+        beginShape();
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+bottomPent[i+1].x, y+bottomPent[i+1].y, z+bottomPent[i+1].z);
+        vertex(x+bottomPent[i+2].x, y+bottomPent[i+2].y, z+bottomPent[i+2].z);
+        endShape(CLOSE);
+
+        beginShape();
+        vertex(x+bottomPent[i+2].x, y+bottomPent[i+2].y, z+bottomPent[i+2].z);
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+topPent[i+1].x, y+topPent[i+1].y, z+topPent[i+1].z);
+        endShape(CLOSE);
+      } 
+      else if (i==topPent.length-2){
+        beginShape();
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+bottomPent[i+1].x, y+bottomPent[i+1].y, z+bottomPent[i+1].z);
+        vertex(x+bottomPent[0].x, y+bottomPent[0].y, z+bottomPent[0].z);
+        endShape(CLOSE);
+
+        beginShape();
+        vertex(x+bottomPent[0].x, y+bottomPent[0].y, z+bottomPent[0].z);
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+topPent[i+1].x, y+topPent[i+1].y, z+topPent[i+1].z);
+        endShape(CLOSE);
+      }
+      else if (i==topPent.length-1){
+        beginShape();
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+bottomPent[0].x, y+bottomPent[0].y, z+bottomPent[0].z);
+        vertex(x+bottomPent[1].x, y+bottomPent[1].y, z+bottomPent[1].z);
+        endShape(CLOSE);
+
+        beginShape();
+        vertex(x+bottomPent[1].x, y+bottomPent[1].y, z+bottomPent[1].z);
+        vertex(x+topPent[i].x, y+topPent[i].y, z+topPent[i].z);
+        vertex(x+topPent[0].x, y+topPent[0].y, z+topPent[0].z);
+        endShape(CLOSE);
+      }
+    }
+  }
+
+  // overrided methods fom Shape3D
+  void rotZ(float theta){
+    float tx=0, ty=0, tz=0;
+    // top point
+    tx = cos(theta)*topPoint.x+sin(theta)*topPoint.y;
+    ty = sin(theta)*topPoint.x-cos(theta)*topPoint.y;
+    topPoint.x = tx;
+    topPoint.y = ty;
+
+    // bottom point
+    tx = cos(theta)*bottomPoint.x+sin(theta)*bottomPoint.y;
+    ty = sin(theta)*bottomPoint.x-cos(theta)*bottomPoint.y;
+    bottomPoint.x = tx;
+    bottomPoint.y = ty;
+
+    // top and bottom pentagons
+    for (int i=0; i<topPent.length; i++){
+      tx = cos(theta)*topPent[i].x+sin(theta)*topPent[i].y;
+      ty = sin(theta)*topPent[i].x-cos(theta)*topPent[i].y;
+      topPent[i].x = tx;
+      topPent[i].y = ty;
+
+      tx = cos(theta)*bottomPent[i].x+sin(theta)*bottomPent[i].y;
+      ty = sin(theta)*bottomPent[i].x-cos(theta)*bottomPent[i].y;
+      bottomPent[i].x = tx;
+      bottomPent[i].y = ty;
+    }
+  }
+
+  void rotX(float theta){
+  }
+
+  void rotY(float theta){
+  }
+
+
+}
+
diff --git a/java/libraries/opengl/examples/Form/Icosahedra/Shape3D.pde b/java/libraries/opengl/examples/Form/Icosahedra/Shape3D.pde
new file mode 100755
index 000000000..ed063a0f4
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/Icosahedra/Shape3D.pde
@@ -0,0 +1,82 @@
+abstract class Shape3D{
+  float x, y, z;
+  float w, h, d;
+
+  Shape3D(){
+  }
+
+  Shape3D(float x, float y, float z){
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+
+  Shape3D(PVector p){
+    x = p.x;
+    y = p.y;
+    z = p.z;
+  }
+
+
+  Shape3D(Dimension3D dim){
+    w = dim.w;
+    h = dim.h;
+    d = dim.d;
+  }
+
+  Shape3D(float x, float y, float z, float w, float h, float d){
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    this.w = w;
+    this.h = h;
+    this.d = d;
+  }
+
+  Shape3D(float x, float y, float z, Dimension3D dim){
+    this.x = x;
+    this.y = y;
+    this.z = z;
+    w = dim.w;
+    h = dim.h;
+    d = dim.d;
+  }
+
+  Shape3D(PVector p, Dimension3D dim){
+    x = p.x;
+    y = p.y;
+    z = p.z;
+    w = dim.w;
+    h = dim.h;
+    d = dim.d;
+  }
+
+  void setLoc(PVector p){
+    x=p.x;
+    y=p.y;
+    z=p.z;
+  }
+
+  void setLoc(float x, float y, float z){
+    this.x=x;
+    this.y=y;
+    this.z=z;
+  }
+
+
+  // override if you need these
+  void rotX(float theta){
+  }
+
+  void rotY(float theta){
+  }
+
+  void rotZ(float theta){
+  }
+
+
+  // must be implemented in subclasses
+  abstract void init();
+  abstract void create();
+}
+
diff --git a/java/libraries/opengl/examples/Form/Primitives3D/Primitives3D.pde b/java/libraries/opengl/examples/Form/Primitives3D/Primitives3D.pde
new file mode 100755
index 000000000..053301190
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/Primitives3D/Primitives3D.pde
@@ -0,0 +1,30 @@
+/**
+ * Primitives 3D. 
+ * 
+ * Placing mathematically 3D objects in synthetic space.
+ * The lights() method reveals their imagined dimension.
+ * The box() and sphere() functions each have one parameter
+ * which is used to specify their size. These shapes are
+ * positioned using the translate() function.
+ */
+ 
+size(640, 360, P3D); 
+background(0);
+lights();
+
+noStroke();
+pushMatrix();
+translate(130, height/2, 0);
+rotateY(1.25);
+rotateX(-0.4);
+box(100);
+popMatrix();
+
+noFill();
+stroke(255);
+pushMatrix();
+translate(500, height*0.35, -200);
+sphere(280);
+popMatrix();
+
+
diff --git a/java/libraries/opengl/examples/Form/RGBCube/RGBCube.pde b/java/libraries/opengl/examples/Form/RGBCube/RGBCube.pde
new file mode 100755
index 000000000..2040d0c0b
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/RGBCube/RGBCube.pde
@@ -0,0 +1,74 @@
+/**
+ * RGB Cube.
+ * 
+ * The three primary colors of the additive color model are red, green, and blue.
+ * This RGB color cube displays smooth transitions between these colors. 
+ */
+ 
+float xmag, ymag = 0;
+float newXmag, newYmag = 0; 
+ 
+void setup() 
+{ 
+  size(640, 360, P3D); 
+  noStroke(); 
+  colorMode(RGB, 1); 
+} 
+ 
+void draw() 
+{ 
+  background(0.5);
+  
+  pushMatrix(); 
+ 
+  translate(width/2, height/2, -30); 
+  
+  newXmag = mouseX/float(width) * TWO_PI;
+  newYmag = mouseY/float(height) * TWO_PI;
+  
+  float diff = xmag-newXmag;
+  if (abs(diff) >  0.01) { xmag -= diff/4.0; }
+  
+  diff = ymag-newYmag;
+  if (abs(diff) >  0.01) { ymag -= diff/4.0; }
+  
+  rotateX(-ymag); 
+  rotateY(-xmag); 
+  
+  scale(90);
+  beginShape(QUADS);
+
+  fill(0, 1, 1); vertex(-1,  1,  1);
+  fill(1, 1, 1); vertex( 1,  1,  1);
+  fill(1, 0, 1); vertex( 1, -1,  1);
+  fill(0, 0, 1); vertex(-1, -1,  1);
+
+  fill(1, 1, 1); vertex( 1,  1,  1);
+  fill(1, 1, 0); vertex( 1,  1, -1);
+  fill(1, 0, 0); vertex( 1, -1, -1);
+  fill(1, 0, 1); vertex( 1, -1,  1);
+
+  fill(1, 1, 0); vertex( 1,  1, -1);
+  fill(0, 1, 0); vertex(-1,  1, -1);
+  fill(0, 0, 0); vertex(-1, -1, -1);
+  fill(1, 0, 0); vertex( 1, -1, -1);
+
+  fill(0, 1, 0); vertex(-1,  1, -1);
+  fill(0, 1, 1); vertex(-1,  1,  1);
+  fill(0, 0, 1); vertex(-1, -1,  1);
+  fill(0, 0, 0); vertex(-1, -1, -1);
+
+  fill(0, 1, 0); vertex(-1,  1, -1);
+  fill(1, 1, 0); vertex( 1,  1, -1);
+  fill(1, 1, 1); vertex( 1,  1,  1);
+  fill(0, 1, 1); vertex(-1,  1,  1);
+
+  fill(0, 0, 0); vertex(-1, -1, -1);
+  fill(1, 0, 0); vertex( 1, -1, -1);
+  fill(1, 0, 1); vertex( 1, -1,  1);
+  fill(0, 0, 1); vertex(-1, -1,  1);
+
+  endShape();
+  
+  popMatrix(); 
+} 
diff --git a/java/libraries/opengl/examples/Form/RunAmuck/Legs.pde b/java/libraries/opengl/examples/Form/RunAmuck/Legs.pde
new file mode 100755
index 000000000..eb74d7859
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/RunAmuck/Legs.pde
@@ -0,0 +1,162 @@
+/**
+ * Legs class
+ * By Ira Greenberg <br />
+ * Processing for Flash Developers,
+ * Friends of ED, 2009
+ */
+ 
+class Legs {
+  // Instance properties with default values
+  float x = 0, y = 0, z = 0, w = 150, ht = 125;
+  color col = #77AA22;
+  // Advanced properties
+  float detailW = w/6.0;
+  float detailHt = ht/8.0;
+  float shoeBulge = detailHt*2.0;
+  float legGap = w/7.0;
+
+  // Dynamics properties
+  float velocity = .02, stepL, stepR, stepRate = random(10, 50); 
+  float speedX = 1.0, speedZ, spring, damping = .5, theta;
+
+  // Default constructor
+  Legs() {
+  }
+
+  // Standard constructor
+  Legs(float x, float z, float w, float ht, color col) {
+    this.x = x;
+    this.z = z;
+    this.w = w;
+    this.ht = ht;
+    this.col = col;
+    fill(col);
+    detailW = w/6.0;
+    detailHt = ht/8.0;
+    shoeBulge = detailHt*2.0;
+    legGap = w/7.0;
+    speedX = random(-speedX, speedX);
+  }
+
+  // Advanced constructor
+  Legs(float x, float z, float w, float ht, color col, float detailW, 
+        float detailHt, float shoeBulge, float legGap) {
+    this.x = x;
+    this.z = z;
+    this.w = w;
+    this.ht = ht;
+    this.col = col;
+    this.detailW = detailW;
+    this.detailHt = detailHt;
+    this.shoeBulge = shoeBulge;
+    this.legGap = legGap;
+    speedX = random(-speedX, speedX);
+  }
+
+  // Draw legs
+  void create() {
+    fill(col);
+    float footWidth = (w - legGap)/2;
+    beginShape();
+    vertex(x - w/2, y - ht, z);
+    vertex(x - w/2, y - ht + detailHt, z);
+    vertex(x - w/2 + detailW, y - ht + detailHt, z);
+    // left foot
+    vertex(x - w/2 + detailW,  y + stepL, z);
+    curveVertex(x - w/2 + detailW, y + stepL, z);
+    curveVertex(x - w/2 + detailW, y + stepL, z);
+    curveVertex(x - w/2 + detailW - shoeBulge,  y + detailHt/2 + stepL, z);
+    curveVertex(x - w/2,  y + detailHt + stepL, z);
+    curveVertex(x - w/2,  y + detailHt + stepL, z);
+    vertex(x - w/2 + footWidth,  y + detailHt + stepL*.9, z);
+    // end left foot
+    vertex(x - w/2 + footWidth + legGap/2,  y - ht + detailHt, z);
+    vertex(x - w/2 + footWidth + legGap/2,  y - ht + detailHt, z);
+    // right foot
+    vertex(x - w/2 + footWidth + legGap,  y + detailHt + stepR*.9, z);
+    vertex(x + w/2,  y + detailHt + stepR, z);
+    curveVertex(x + w/2,  y + detailHt + stepR, z);
+    curveVertex(x + w/2,  y + detailHt + stepR, z);
+    curveVertex(x + w/2 - detailW + shoeBulge,  y + detailHt/2 + stepR, z);
+    curveVertex(x + w/2 - detailW,  y + stepR, z);
+    vertex(x + w/2 - detailW,  y + stepR, z);
+    // end right foot
+    vertex(x + w/2 - detailW,  y - ht + detailHt, z);
+    vertex(x + w/2,  y - ht + detailHt, z);
+    vertex(x + w/2,  y - ht, z);
+    endShape(CLOSE);
+  }
+
+  // Set advanced property values
+  void setDetails(float detailW, float detailHt, float shoeBulge, float legGap) {
+    this.detailW = detailW;
+    this.detailHt = detailHt;
+    this.shoeBulge = shoeBulge;
+    this.legGap = legGap;
+  }
+
+  // Make the legs step
+  void step(float stepRate) {
+    this.stepRate = stepRate;
+    spring = ht/2.0;
+    stepL = sin(theta)*spring;
+    stepR = cos(theta)*spring;
+    theta += radians(stepRate);
+  }
+  
+  // Alternative overloaded step method
+  void step() {
+    spring = ht/2.0;
+    stepL = sin(theta)*spring;
+    stepR = cos(theta)*spring;
+    theta += radians(stepRate);
+  }
+
+
+  // Moves legs along x, y, z axes
+  void move() {
+    // Move legs along y-axis
+    y = stepR*damping;
+
+    // Move legs along x-axis and
+    // check for collision against frame edge
+    x += speedX;
+    if (screenX(x, y, z) > width) {
+      speedX *= -1;
+    }
+    if (screenX(x, y, z) < 0) {
+      speedX *= -1;
+    }
+
+    // Move legs along z-axis based on speed of stepping 
+    // and check for collision against extremes
+    speedZ = (stepRate*velocity);
+    z += speedZ;
+    if (z > 400) {
+      z = 400;
+      velocity *= -1;
+    }
+    if (z < -100) {
+      z = -100;
+      velocity *= -1;
+    }
+  }
+  
+  void setDynamics(float speedX, float spring, float damping) {
+    this.speedX = speedX;
+    this.spring = spring;
+    this.damping = damping;
+  }
+}
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/java/libraries/opengl/examples/Form/RunAmuck/RunAmuck.pde b/java/libraries/opengl/examples/Form/RunAmuck/RunAmuck.pde
new file mode 100755
index 000000000..7a5b06fc2
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/RunAmuck/RunAmuck.pde
@@ -0,0 +1,45 @@
+/**
+ * Run-Amuck
+ * By Ira Greenberg <br />
+ * Processing for Flash Developers,
+ * Friends of ED, 2009
+ */
+
+int count = 250;
+Legs[] legs = new Legs[count];
+
+void setup() {
+  size(640, 360, P3D);
+  noStroke();
+  for (int i = 0; i < legs.length; i++) {
+    legs[i] = new Legs(random(-10, 10), random(-50, 150), random(.5, 5), 
+                       random(.5, 5), color(random(255), random(255), random(255)));
+  }
+}
+
+void draw() {
+  background(0);
+  translate(width/2, height/2);
+  noStroke();
+  fill(35);
+
+  // Draw ground plane
+  beginShape();
+  vertex(-width*2, 0, -1000);
+  vertex(width*2, 0, -1000);
+  vertex(width/2, height/2, 400);
+  vertex(-width/2, height/2, 400);
+  endShape(CLOSE);
+
+  // Update and draw the legs
+  for (int i = 0; i < legs.length; i++) {
+    legs[i].create();
+    // Set foot step rate
+    legs[i].step(random(10, 50));
+    // Move legs along x, y, z axes
+    // z-movement dependent upon step rate
+    legs[i].move();
+  }
+}
+
+
diff --git a/java/libraries/opengl/examples/Form/ShapeTransform/ShapeTransform.pde b/java/libraries/opengl/examples/Form/ShapeTransform/ShapeTransform.pde
new file mode 100755
index 000000000..c779a3a1a
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/ShapeTransform/ShapeTransform.pde
@@ -0,0 +1,116 @@
+/**
+ * Shape Transform
+ * by Ira Greenberg.  
+ * 
+ * Illustrates the geometric relationship 
+ * between Cube, Pyramid, Cone and 
+ * Cylinder 3D primitives.
+ * 
+ * Instructions:<br />
+ * Up Arrow - increases points<br />
+ * Down Arrow - decreases points<br />
+ * 'p' key toggles between cube/pyramid<br />
+ */
+
+int pts = 4; 
+float angle = 0;
+float radius = 99;
+float cylinderLength = 95;
+
+//vertices
+PVector vertices[][];
+boolean isPyramid = false;
+
+float angleInc;
+
+void setup(){
+  size(640, 360, P3D);
+  noStroke();
+  angleInc = PI/300.0;
+}
+
+void draw(){
+  background(170, 95, 95);
+  lights();
+  fill(255, 200, 200);
+  translate(width/2, height/2);
+  rotateX(frameCount * angleInc);
+  rotateY(frameCount * angleInc);
+  rotateZ(frameCount * angleInc);
+
+  // initialize vertex arrays
+  vertices = new PVector[2][pts+1];
+
+  // fill arrays
+  for (int i = 0; i < 2; i++){
+    angle = 0;
+    for(int j = 0; j <= pts; j++){
+      vertices[i][j] = new PVector();
+      if (isPyramid){
+        if (i==1){
+          vertices[i][j].x = 0;
+          vertices[i][j].y = 0;
+        }
+        else {
+          vertices[i][j].x = cos(radians(angle)) * radius;
+          vertices[i][j].y = sin(radians(angle)) * radius;
+        }
+      } 
+      else {
+        vertices[i][j].x = cos(radians(angle)) * radius;
+        vertices[i][j].y = sin(radians(angle)) * radius;
+      }
+      vertices[i][j].z = cylinderLength; 
+      // the .0 after the 360 is critical
+      angle += 360.0/pts;
+    }
+    cylinderLength *= -1;
+  }
+
+  // draw cylinder tube
+  beginShape(QUAD_STRIP);
+  for(int j = 0; j <= pts; j++){
+    vertex(vertices[0][j].x, vertices[0][j].y, vertices[0][j].z);
+    vertex(vertices[1][j].x, vertices[1][j].y, vertices[1][j].z);
+  }
+  endShape();
+
+  //draw cylinder ends
+  for (int i = 0; i < 2; i++){
+    beginShape();
+    for(int j = 0; j < pts; j++){
+      vertex(vertices[i][j].x, vertices[i][j].y, vertices[i][j].z);
+    }
+    endShape(CLOSE);
+  }
+}
+
+
+/*
+ up/down arrow keys control
+ polygon detail.
+ */
+void keyPressed(){
+  if(key == CODED) { 
+    // pts
+    if (keyCode == UP) { 
+      if (pts < 90){
+        pts++;
+      } 
+    } 
+    else if (keyCode == DOWN) { 
+      if (pts > 4){
+        pts--;
+      }
+    } 
+  }
+  if (key =='p'){
+    if (isPyramid){
+      isPyramid = false;
+    } 
+    else {
+      isPyramid = true;
+    }
+  }
+}
+
diff --git a/java/libraries/opengl/examples/Form/SpaceJunk/Cube.pde b/java/libraries/opengl/examples/Form/SpaceJunk/Cube.pde
new file mode 100755
index 000000000..168ceb5ca
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/SpaceJunk/Cube.pde
@@ -0,0 +1,73 @@
+
+class Cube {
+
+  // Properties
+  int w, h, d;
+  int shiftX, shiftY, shiftZ;
+
+  // Constructor
+  Cube(int w, int h, int d, int shiftX, int shiftY, int shiftZ){
+    this.w = w;
+    this.h = h;
+    this.d = d;
+    this.shiftX = shiftX;
+    this.shiftY = shiftY;
+    this.shiftZ = shiftZ;
+  }
+
+  // Main cube drawing method, which looks 
+  // more confusing than it really is. It's 
+  // just a bunch of rectangles drawn for 
+  // each cube face
+  void drawCube(){
+    beginShape(QUADS);
+    // Front face
+    normal(0, 0, 1);
+    vertex(-w/2 + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, h + shiftY, -d/2 + shiftZ); 
+    vertex(-w/2 + shiftX, h + shiftY, -d/2 + shiftZ); 
+
+    // Back face
+    normal(0, 0, -1);
+    vertex(-w/2 + shiftX, -h/2 + shiftY, d + shiftZ); 
+    vertex(w + shiftX, -h/2 + shiftY, d + shiftZ); 
+    vertex(w + shiftX, h + shiftY, d + shiftZ); 
+    vertex(-w/2 + shiftX, h + shiftY, d + shiftZ);
+
+    // Left face
+    normal(1, 0, 0);
+    vertex(-w/2 + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(-w/2 + shiftX, -h/2 + shiftY, d + shiftZ); 
+    vertex(-w/2 + shiftX, h + shiftY, d + shiftZ); 
+    vertex(-w/2 + shiftX, h + shiftY, -d/2 + shiftZ); 
+
+    // Right face
+    normal(-1, 0, 0);
+    vertex(w + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, -h/2 + shiftY, d + shiftZ); 
+    vertex(w + shiftX, h + shiftY, d + shiftZ); 
+    vertex(w + shiftX, h + shiftY, -d/2 + shiftZ); 
+
+    // Top face
+    normal(0, 1, 0);
+    vertex(-w/2 + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, -h/2 + shiftY, d + shiftZ); 
+    vertex(-w/2 + shiftX, -h/2 + shiftY, d + shiftZ); 
+
+    // Bottom face
+    normal(0, -1, 0);
+    vertex(-w/2 + shiftX, h + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, h + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, h + shiftY, d + shiftZ); 
+    vertex(-w/2 + shiftX, h + shiftY, d + shiftZ);  
+
+    endShape(); 
+
+    // Add some rotation to each box for pizazz.
+    rotateY(radians(1));
+    rotateX(radians(1));
+    rotateZ(radians(1));
+  }
+}
diff --git a/java/libraries/opengl/examples/Form/SpaceJunk/SpaceJunk.pde b/java/libraries/opengl/examples/Form/SpaceJunk/SpaceJunk.pde
new file mode 100755
index 000000000..5fbe45f58
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/SpaceJunk/SpaceJunk.pde
@@ -0,0 +1,63 @@
+/**
+ * Space Junk  
+ * by Ira Greenberg. 
+ * Zoom suggestion 
+ * by Danny Greenberg.
+ * 
+ * Rotating cubes in space using a custom Cube class. 
+ * Color controlled by light sources. Move the mouse left
+ * and right to zoom.
+ */
+
+// Used for oveall rotation
+float ang;
+
+// Cube count-lower/raise to test P3D/OPENGL performance
+int limit = 500;
+
+// Array for all cubes
+Cube[]cubes = new Cube[limit];
+
+void setup() {
+  size(1024, 768, P3D); 
+  background(0); 
+  noStroke();
+
+  // Instantiate cubes, passing in random vals for size and postion
+  for (int i = 0; i< cubes.length; i++){
+    cubes[i] = new Cube(int(random(-10, 10)), int(random(-10, 10)), 
+    int(random(-10, 10)), int(random(-140, 140)), int(random(-140, 140)), 
+    int(random(-140, 140)));
+  }
+}
+
+void draw(){
+  background(0); 
+  fill(200);
+
+  // Set up some different colored lights
+  pointLight(51, 102, 255, 65, 60, 100); 
+  pointLight(200, 40, 60, -65, -60, -150);
+
+  // Raise overall light in scene 
+  ambientLight(70, 70, 10); 
+
+  // Center geometry in display windwow.
+  // you can change 3rd argument ('0')
+  // to move block group closer(+)/further(-)
+  translate(width/2, height/2, -200 + mouseX * 0.65);
+
+  // Rotate around y and x axes
+  rotateY(radians(ang));
+  rotateX(radians(ang));
+
+  // Draw cubes
+  for (int i = 0; i < cubes.length; i++){
+    cubes[i].drawCube();
+  }
+  
+  // Used in rotate function calls above
+  ang++;
+}
+
+
diff --git a/java/libraries/opengl/examples/Form/TexturedSphere/TexturedSphere.pde b/java/libraries/opengl/examples/Form/TexturedSphere/TexturedSphere.pde
new file mode 100755
index 000000000..734838469
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/TexturedSphere/TexturedSphere.pde
@@ -0,0 +1,172 @@
+/**
+ * Textured Sphere 
+ * by Mike 'Flux' Chang (cleaned up by Aaron Koblin). 
+ * Based on code by Toxi. 
+ * 
+ * A 3D textured sphere with simple rotation control.
+ * Note: Controls will be inverted when sphere is upside down. 
+ * Use an "arc ball" to deal with this appropriately.
+ */ 
+
+PImage bg;
+PImage texmap;
+
+int sDetail = 35;  // Sphere detail setting
+float rotationX = 0;
+float rotationY = 0;
+float velocityX = 0;
+float velocityY = 0;
+float globeRadius = 450;
+float pushBack = 0;
+
+float[] cx, cz, sphereX, sphereY, sphereZ;
+float sinLUT[];
+float cosLUT[];
+float SINCOS_PRECISION = 0.5;
+int SINCOS_LENGTH = int(360.0 / SINCOS_PRECISION);
+
+
+void setup() {
+  size(1024, 768, P3D);  
+  texmap = loadImage("world32k.jpg");    
+  initializeSphere(sDetail);
+}
+
+void draw() {    
+  background(0);            
+  renderGlobe(); 
+}
+
+void renderGlobe() {
+  pushMatrix();
+  translate(width/2.0, height/2.0, pushBack);
+  pushMatrix();
+  noFill();
+  stroke(255,200);
+  strokeWeight(2);
+  smooth();
+  popMatrix();
+  lights();    
+  pushMatrix();
+  rotateX( radians(-rotationX) );  
+  rotateY( radians(270 - rotationY) );
+  fill(200);
+  noStroke();
+  textureMode(IMAGE);  
+  texturedSphere(globeRadius, texmap);
+  popMatrix();  
+  popMatrix();
+  rotationX += velocityX;
+  rotationY += velocityY;
+  velocityX *= 0.95;
+  velocityY *= 0.95;
+  
+  // Implements mouse control (interaction will be inverse when sphere is  upside down)
+  if(mousePressed){
+    velocityX += (mouseY-pmouseY) * 0.01;
+    velocityY -= (mouseX-pmouseX) * 0.01;
+  }
+}
+
+void initializeSphere(int res)
+{
+  sinLUT = new float[SINCOS_LENGTH];
+  cosLUT = new float[SINCOS_LENGTH];
+
+  for (int i = 0; i < SINCOS_LENGTH; i++) {
+    sinLUT[i] = (float) Math.sin(i * DEG_TO_RAD * SINCOS_PRECISION);
+    cosLUT[i] = (float) Math.cos(i * DEG_TO_RAD * SINCOS_PRECISION);
+  }
+
+  float delta = (float)SINCOS_LENGTH/res;
+  float[] cx = new float[res];
+  float[] cz = new float[res];
+  
+  // Calc unit circle in XZ plane
+  for (int i = 0; i < res; i++) {
+    cx[i] = -cosLUT[(int) (i*delta) % SINCOS_LENGTH];
+    cz[i] = sinLUT[(int) (i*delta) % SINCOS_LENGTH];
+  }
+  
+  // Computing vertexlist vertexlist starts at south pole
+  int vertCount = res * (res-1) + 2;
+  int currVert = 0;
+  
+  // Re-init arrays to store vertices
+  sphereX = new float[vertCount];
+  sphereY = new float[vertCount];
+  sphereZ = new float[vertCount];
+  float angle_step = (SINCOS_LENGTH*0.5f)/res;
+  float angle = angle_step;
+  
+  // Step along Y axis
+  for (int i = 1; i < res; i++) {
+    float curradius = sinLUT[(int) angle % SINCOS_LENGTH];
+    float currY = -cosLUT[(int) angle % SINCOS_LENGTH];
+    for (int j = 0; j < res; j++) {
+      sphereX[currVert] = cx[j] * curradius;
+      sphereY[currVert] = currY;
+      sphereZ[currVert++] = cz[j] * curradius;
+    }
+    angle += angle_step;
+  }
+  sDetail = res;
+}
+
+// Generic routine to draw textured sphere
+void texturedSphere(float r, PImage t) 
+{
+  int v1,v11,v2;
+  r = (r + 240 ) * 0.33;
+  beginShape(TRIANGLE_STRIP);
+  texture(t);
+  float iu=(float)(t.width-1)/(sDetail);
+  float iv=(float)(t.height-1)/(sDetail);
+  float u=0,v=iv;
+  for (int i = 0; i < sDetail; i++) {
+    vertex(0, -r, 0,u,0);
+    vertex(sphereX[i]*r, sphereY[i]*r, sphereZ[i]*r, u, v);
+    u+=iu;
+  }
+  vertex(0, -r, 0,u,0);
+  vertex(sphereX[0]*r, sphereY[0]*r, sphereZ[0]*r, u, v);
+  endShape();   
+  
+  // Middle rings
+  int voff = 0;
+  for(int i = 2; i < sDetail; i++) {
+    v1=v11=voff;
+    voff += sDetail;
+    v2=voff;
+    u=0;
+    beginShape(TRIANGLE_STRIP);
+    texture(t);
+    for (int j = 0; j < sDetail; j++) {
+      vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1++]*r, u, v);
+      vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2++]*r, u, v+iv);
+      u+=iu;
+    }
+  
+    // Close each ring
+    v1=v11;
+    v2=voff;
+    vertex(sphereX[v1]*r, sphereY[v1]*r, sphereZ[v1]*r, u, v);
+    vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v+iv);
+    endShape();
+    v+=iv;
+  }
+  u=0;
+  
+  // Add the northern cap
+  beginShape(TRIANGLE_STRIP);
+  texture(t);
+  for (int i = 0; i < sDetail; i++) {
+    v2 = voff + i;
+    vertex(sphereX[v2]*r, sphereY[v2]*r, sphereZ[v2]*r, u, v);
+    vertex(0, r, 0,u,v+iv);    
+    u+=iu;
+  }
+  vertex(sphereX[voff]*r, sphereY[voff]*r, sphereZ[voff]*r, u, v);
+  endShape();
+  
+}
diff --git a/java/libraries/opengl/examples/Form/Toroid/Toroid.pde b/java/libraries/opengl/examples/Form/Toroid/Toroid.pde
new file mode 100755
index 000000000..f79a8d174
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/Toroid/Toroid.pde
@@ -0,0 +1,182 @@
+/**
+ * Interactive Toroid
+ * by Ira Greenberg. 
+ * 
+ * Illustrates the geometric relationship between Toroid, Sphere, and Helix
+ * 3D primitives, as well as lathing principal.
+ * 
+ * Instructions: <br />
+ * UP arrow key pts++ <br />
+ * DOWN arrow key pts-- <br />
+ * LEFT arrow key segments-- <br />
+ * RIGHT arrow key segments++ <br />
+ * 'a' key toroid radius-- <br />
+ * 's' key toroid radius++ <br />
+ * 'z' key initial polygon radius-- <br />
+ * 'x' key initial polygon radius++ <br />
+ * 'w' key toggle wireframe/solid shading <br />
+ * 'h' key toggle sphere/helix <br />
+ */
+
+int pts = 40; 
+float angle = 0;
+float radius = 60.0;
+
+// lathe segments
+int segments = 60;
+float latheAngle = 0;
+float latheRadius = 100.0;
+
+//vertices
+PVector vertices[], vertices2[];
+
+// for shaded or wireframe rendering 
+boolean isWireFrame = false;
+
+// for optional helix
+boolean isHelix = false;
+float helixOffset = 5.0;
+
+void setup(){
+  size(640, 360, P3D);
+}
+
+void draw(){
+  background(50, 64, 42);
+  // basic lighting setup
+  lights();
+  // 2 rendering styles
+  // wireframe or solid
+  if (isWireFrame){
+    stroke(255, 255, 150);
+    noFill();
+  } 
+  else {
+    noStroke();
+    fill(150, 195, 125);
+  }
+  //center and spin toroid
+  translate(width/2, height/2, -100);
+
+  rotateX(frameCount*PI/150);
+  rotateY(frameCount*PI/170);
+  rotateZ(frameCount*PI/90);
+
+  // initialize point arrays
+  vertices = new PVector[pts+1];
+  vertices2 = new PVector[pts+1];
+
+  // fill arrays
+  for(int i=0; i<=pts; i++){
+    vertices[i] = new PVector();
+    vertices2[i] = new PVector();
+    vertices[i].x = latheRadius + sin(radians(angle))*radius;
+    if (isHelix){
+      vertices[i].z = cos(radians(angle))*radius-(helixOffset* 
+        segments)/2;
+    } 
+    else{
+      vertices[i].z = cos(radians(angle))*radius;
+    }
+    angle+=360.0/pts;
+  }
+
+  // draw toroid
+  latheAngle = 0;
+  for(int i=0; i<=segments; i++){
+    beginShape(QUAD_STRIP);
+    for(int j=0; j<=pts; j++){
+      if (i>0){
+        vertex(vertices2[j].x, vertices2[j].y, vertices2[j].z);
+      }
+      vertices2[j].x = cos(radians(latheAngle))*vertices[j].x;
+      vertices2[j].y = sin(radians(latheAngle))*vertices[j].x;
+      vertices2[j].z = vertices[j].z;
+      // optional helix offset
+      if (isHelix){
+        vertices[j].z+=helixOffset;
+      } 
+      vertex(vertices2[j].x, vertices2[j].y, vertices2[j].z);
+    }
+    // create extra rotation for helix
+    if (isHelix){
+      latheAngle+=720.0/segments;
+    } 
+    else {
+      latheAngle+=360.0/segments;
+    }
+    endShape();
+  }
+}
+
+/*
+ left/right arrow keys control ellipse detail
+ up/down arrow keys control segment detail.
+ 'a','s' keys control lathe radius
+ 'z','x' keys control ellipse radius
+ 'w' key toggles between wireframe and solid
+ 'h' key toggles between toroid and helix
+ */
+void keyPressed(){
+  if(key == CODED) { 
+    // pts
+    if (keyCode == UP) { 
+      if (pts<40){
+        pts++;
+      } 
+    } 
+    else if (keyCode == DOWN) { 
+      if (pts>3){
+        pts--;
+      }
+    } 
+    // extrusion length
+    if (keyCode == LEFT) { 
+      if (segments>3){
+        segments--; 
+      }
+    } 
+    else if (keyCode == RIGHT) { 
+      if (segments<80){
+        segments++; 
+      }
+    } 
+  }
+  // lathe radius
+  if (key =='a'){
+    if (latheRadius>0){
+      latheRadius--; 
+    }
+  } 
+  else if (key == 's'){
+    latheRadius++; 
+  }
+  // ellipse radius
+  if (key =='z'){
+    if (radius>10){
+      radius--;
+    }
+  } 
+  else if (key == 'x'){
+    radius++;
+  }
+  // wireframe
+  if (key =='w'){
+    if (isWireFrame){
+      isWireFrame=false;
+    } 
+    else {
+      isWireFrame=true;
+    }
+  }
+  // helix
+  if (key =='h'){
+    if (isHelix){
+      isHelix=false;
+    } 
+    else {
+      isHelix=true;
+    }
+  }
+}
+
diff --git a/java/libraries/opengl/examples/Form/Vertices/Vertices.pde b/java/libraries/opengl/examples/Form/Vertices/Vertices.pde
new file mode 100755
index 000000000..5609ff94f
--- /dev/null
+++ b/java/libraries/opengl/examples/Form/Vertices/Vertices.pde
@@ -0,0 +1,67 @@
+/**
+ * Vertices 
+ * by Simon Greenwold.
+ * 
+ * Draw a cylinder centered on the y-axis, going down 
+ * from y=0 to y=height. The radius at the top can be 
+ * different from the radius at the bottom, and the 
+ * number of sides drawn is variable.
+ */
+
+void setup() {
+  size(640, 360, P3D);
+}
+
+void draw() {
+  background(0);
+  lights();
+  translate(width / 2, height / 2);
+  rotateY(map(mouseX, 0, width, 0, PI));
+  rotateZ(map(mouseY, 0, height, 0, -PI));
+  noStroke();
+  fill(255, 255, 255);
+  translate(0, -40, 0);
+  drawCylinder(10, 180, 200, 16); // Draw a mix between a cylinder and a cone
+  //drawCylinder(70, 70, 120, 64); // Draw a cylinder
+  //drawCylinder(0, 180, 200, 4); // Draw a pyramid
+}
+
+void drawCylinder(float topRadius, float bottomRadius, float tall, int sides) {
+  float angle = 0;
+  float angleIncrement = TWO_PI / sides;
+  beginShape(QUAD_STRIP);
+  for (int i = 0; i < sides + 1; ++i) {
+    vertex(topRadius*cos(angle), 0, topRadius*sin(angle));
+    vertex(bottomRadius*cos(angle), tall, bottomRadius*sin(angle));
+    angle += angleIncrement;
+  }
+  endShape();
+  
+  // If it is not a cone, draw the circular top cap
+  if (topRadius != 0) {
+    angle = 0;
+    beginShape(TRIANGLE_FAN);
+    
+    // Center point
+    vertex(0, 0, 0);
+    for (int i = 0; i < sides + 1; i++) {
+      vertex(topRadius * cos(angle), 0, topRadius * sin(angle));
+      angle += angleIncrement;
+    }
+    endShape();
+  }
+
+  // If it is not a cone, draw the circular bottom cap
+  if (bottomRadius != 0) {
+    angle = 0;
+    beginShape(TRIANGLE_FAN);
+
+    // Center point
+    vertex(0, tall, 0);
+    for (int i = 0; i < sides + 1; i++) {
+      vertex(bottomRadius * cos(angle), tall, bottomRadius * sin(angle));
+      angle += angleIncrement;
+    }
+    endShape();
+  }
+}
diff --git a/java/libraries/opengl/examples/Image/Blending/Blending.pde b/java/libraries/opengl/examples/Image/Blending/Blending.pde
new file mode 100755
index 000000000..166fdc222
--- /dev/null
+++ b/java/libraries/opengl/examples/Image/Blending/Blending.pde
@@ -0,0 +1,80 @@
+// Blending, by Andres Colubri
+// Images can be blended using one of the 10 blending modes 
+// available in OPENGL2.   
+// Images by Kevin Bjorke.
+
+PImage pic1, pic2;
+int selMode = REPLACE;
+String name = "replace";
+int picAlpha = 255;
+
+void setup() {
+  size(800, 480, P3D);
+  
+  PFont font = createFont(PFont.list()[0], 20);
+  textFont(font, 20);    
+  
+  pic1 = loadImage("bjorke1.jpg");
+  pic2 = loadImage("bjorke2.jpg"); 
+}
+
+void draw() {
+  background(0);
+  
+  tint(255, 255);
+  image(pic1, 0, 0, pic1.width, pic1.height);
+  
+  blendMode(selMode);  
+  tint(255, picAlpha);
+  image(pic2, 0, 0, pic2.width, pic2.height);
+    
+  blendMode(REPLACE);    
+  fill(200, 50, 50);
+  rect(0, height - 50, map(picAlpha, 0, 255, 0, width), 50);
+  fill(255);
+
+  text("Selected blend mode: " + name + ". Click to move to next", 10, pic1.height + 30);
+  text("Drag this bar to change alpha of image", 10, height - 18);
+}
+
+void mousePressed() {
+  if (height - 50 < mouseY) return;
+  
+  if (selMode == REPLACE) { 
+    selMode = BLEND;
+    name = "blend";
+  } else if (selMode == BLEND) { 
+    selMode = ADD;
+    name = "add";
+  } else if (selMode == ADD) { 
+    selMode = SUBTRACT;
+    name = "subtract";
+  } else if (selMode == SUBTRACT) { 
+    selMode = LIGHTEST;
+    name = "lightest";
+  } else if (selMode == LIGHTEST) { 
+    selMode = DARKEST;
+    name = "darkest";
+  } else if (selMode == DARKEST) { 
+    selMode = DIFFERENCE;
+    name = "difference";
+  } else if (selMode == DIFFERENCE) { 
+    selMode = EXCLUSION;  
+    name = "exclusion";
+  } else if (selMode == EXCLUSION) { 
+    selMode = MULTIPLY;  
+    name = "multiply";
+  } else if (selMode == MULTIPLY) { 
+    selMode = SCREEN;
+    name = "screen";
+  } else if (selMode == SCREEN) { 
+    selMode = REPLACE;
+    name = "replace";
+  }
+}
+
+void mouseDragged() {
+  if (height - 50 < mouseY) {
+    picAlpha = int(map(mouseX, 0, width, 0, 255));
+  }
+}
\ No newline at end of file
diff --git a/java/libraries/opengl/examples/Image/Explode/Explode.pde b/java/libraries/opengl/examples/Image/Explode/Explode.pde
new file mode 100755
index 000000000..436f9e8fd
--- /dev/null
+++ b/java/libraries/opengl/examples/Image/Explode/Explode.pde
@@ -0,0 +1,43 @@
+/**
+ * Explode 
+ * by Daniel Shiffman. 
+ * 
+ * Mouse horizontal location controls breaking apart of image and 
+ * Maps pixels from a 2D image into 3D space. Pixel brightness controls 
+ * translation along z axis. 
+ */
+ 
+PImage img;       // The source image
+int cellsize = 2; // Dimensions of each cell in the grid
+int columns, rows;   // Number of columns and rows in our system
+
+void setup() {
+  size(640, 360, P3D); 
+  img = loadImage("eames.jpg");  // Load the image
+  columns = img.width / cellsize;  // Calculate # of columns
+  rows = img.height / cellsize;  // Calculate # of rows
+}
+
+void draw() {
+  background(0);
+  // Begin loop for columns
+  for ( int i = 0; i < columns; i++) {
+    // Begin loop for rows
+    for ( int j = 0; j < rows; j++) {
+      int x = i*cellsize + cellsize/2;  // x position
+      int y = j*cellsize + cellsize/2;  // y position
+      int loc = x + y*img.width;  // Pixel array location
+      color c = img.pixels[loc];  // Grab the color
+      // Calculate a z position as a function of mouseX and pixel brightness
+      float z = (mouseX / float(width)) * brightness(img.pixels[loc]) - 20.0;
+      // Translate to the location, set fill and stroke, and draw the rect
+      pushMatrix();
+      translate(x + 200, y + 100, z);
+      fill(c, 204);
+      noStroke();
+      rectMode(CENTER);
+      rect(0, 0, cellsize, cellsize);
+      popMatrix();
+    }
+  }
+}
diff --git a/java/libraries/opengl/examples/Image/Explode/data/eames.jpg.tmp b/java/libraries/opengl/examples/Image/Explode/data/eames.jpg.tmp
new file mode 100755
index 0000000000000000000000000000000000000000..c89377e40b1ac8538f10112f7d566b5829c6172f
GIT binary patch
literal 44496
zcmb@tWkB5Q);2n5vEuF&cZWfX%is)yOK}E=L5j7wJA+Gcch?H8#T`oVqQ#4rk7w`w
zz5D%j&iQe!N$y-(_mVp+nM^WSd0u+{3BUy@C@TOE5CH(Imk;3i7=S0|Y3bktKmZ^E
z006@m(H5eVvaGC`rnZKHvZ_1)0RaF&<dK$>kw?S@0GymX+_e>DX!Q*YX<tnOPyt9U
zRxdEOgt@AL6?FdL&MwZ@|1AF(UVPjvyu^6HEayMI{#W1s7m8u&>hAHP`1msOSy{s@
z0RRM^7Y_CIaD9;@<h*b~3x|L4`hU2)j<)QJy#Iw`+y0x+{lhK(&3FFc?k^khqI30+
zzU{v_BHBOP;@_O|AMRoO{-3x2Sr=Cycc`tM2Q9CNhzPB;m5YTnE!YR<VeJH?Rd%*?
zad&lbH}|l9$tmF9<NL=7fFtYT=;E$s?qO+1`;xYQ$^L(B{@D-zc6hV)pZtpcSN7jf
zmY(ij|5-yom;eC&-`4-@BiI1|P<Y8Vs?dLB+VlWGxeow9vG`xv8zle$j}ZW9pnX0C
zVE-#Y0IRPrF%h0u0iiF4(f<YF3qeGDX<wRu0|^o71uqTqKR`nH7he4XwEw|B)-T#9
zNJuEJP>@mnSI_^b{6CZDuK+wWz%XDK2>}m)h=+iLhw$7F=y*A}k^VEXf9K~F8VV{p
z1~L*RBEm~T|I_)O)B%uDkWgPCBA@}#aRCU(2uLpz65`8<QD41$r;w0QQ1S3z0q6+O
z2zjO7Xc3|F(VM#k5zFwC6fiK7Vw^R6+thYXvXBJ}Fe%`@82q!Xs3`xqL3)XWhX|lU
zLgtmmN6|7zbqh**LvU8m@Qv@)^rj3w;kh;untL!mu|+ZiiL3xA`tu3^>%|BW4+#(O
z7BJr#+bHB25IDIj=FyV9t@&EKb$gMsUqjo12%;39K30Lf+*-e^f-c%#hEA`(@OoyY
zWj0QsJ$RG$lSp9{?P*Xo8@PB!O@)7`-970ivhKkx_QyBsNfGDjvbHJi8;DBwCEq1l
zc`c8%9U-h<V=}2NPBl=&)Q<kYistGkXkzv&6%?FovdeGKlk(m!(k2ZI{!D$6BR9!o
z0my|Ntv($8j;zez#+al5-*&U@HHq_;s$3AMMo_ssa0!G~4BiAb+qM32)SAL8KMY%p
zt7!`dJIMjq?7v1`N@ecic(JAZfnW|ZaIr*-S>FwvCtDe3%MQP9WtvaEP#KwbhrQz5
zTE$tT(<yCa_?`2?h{e;eR4P8KWUf7;JB;?W%l4!F(Z+nIPqncjRTZT);12ZkMixt#
z+EYzby8q=YBB#ofG8)j1G$^bg;V#U6ra_wHbUz9bkIQHQXC<(2OVuQ1%~xPW<g$QO
z?B%q`?CyW<g+ATi)0Ee!IcUa9Rjqw6%ZTmm?I`m&`Cxsgz-4AZ=5N;><u{O|AfIS8
z`=-rtr<Gxm(zmC7BJv`St7#1<x(s*CslWUXq^*2}+*5cjxbFJ3QVY3B{imDi!?r@P
zk#<Ju2FrMk4Y9FOA1$5R_A|ivfZK(`njPD7V~Gn|Ns)_?PCL>NW663|!>A^-EtYG?
zJXu<zPUJ|hRWsypaAY)yG0&R#Q!a_JYV(IK;SaO9(ko<!2Rw-qB6Y(|mq+M$u_eaW
zt&2g-(WJehqA_>h%QqgRwS<Oa){$<y_&b3JTz7MtUcoEi(%}AwPv>bnVCUA3f&BJ&
zIuod@69j{VtaXqYt{F{HV}h?-P<|lfi%(`6Gb88HU=w?r(0m%o!n)0X^wKwn=+o;k
zWvg<;q$+dTI1dKTs2?ZIal0yM-5n>4a?wHJso*q3Zm)F4EAl=jYxrN2j-f0e#bIO4
z0BfJ4J+%i$FIig?OULr}+g>E|bTQ3pUV}9sNYDbxh>7UZRxu0}-zk2mT_>4K_qwiZ
z2#Vv%D_-OnCF(;AVU=;3v@bABF?@1QX5&Vo!|)?@xG?3~1@|t^nX2!QufgI(<XtZ$
zMMr;rh2AZ4l*-4F@zPhn5fAM#{++ZaqpcHo37xXb?G*as>89c0SJ_iiKvktWrGW*T
z4-J-4A)XOjA*ZUe1dV{-2Ih=&%mAxyPDw{j_AH#-1w+NdYp3;UM>%_}&Ey3~{}eL3
zr2@s9#qbVa>a5J=mxR?I7qjYr9{Yn4!Wktnp)0bII>UfIqSNeVJiayW)&iVE(zL)r
zRm=nY@s<%|5|72$Bu+iox5<->Vbnc;3gH^%5VRtuIODr8!bF(=L>{?buKenA0oTYv
zT3a2_HzK<Tkt{a{W&wO{U|6pLQ&mg1&Xj*0Ezx-1`@)C9qG<O;x-)FuKaAUMl?;}N
z$;Vcz9d&V5<sJ)@9k{KJdg7s6vg}|xLuo^q7G!9<oe9InmT~9aj}#hp7>h!(>UZ<?
z2DNpTj$<s?+M;{XF=fHx)zOMGNAahDjHlZ+@HJ%+`F(Ez)QPBkFm2|TwC-IdwcRP1
zmUbvGwV192P?!%=OE2}!8%>LL_A!I>Q}NB{#PMrMj-c)J#CbP-2Lw>s6vZZnhHtMr
zyPB~)NPwx+4!G_Q^b#TaOV@ZGIIJp(%`hZ(qFyJ5y;6x6+coqmFBj5G_?s8nT=Dp{
z#Jdk6S7+?N()hX$m%1Sr%F9nx1W2rZ9%SxGDBG=``6Dh=t2RtJ#FpX5!ncBVq%KB`
zZxYy=&RV!d)0kD#O{U2u3a2?BcPR3dT>FW+A#^Zcm3!B|9~G9ZCcq+D81M{8JPmZI
zSx99W8gsIBwN@Ocw2}~-ue_uhZsqQLWL1-ovFxxNOh@Ai#t*}9ei8ucNqh9*b?Df^
z)X3lYq)<u40jkG7wr|7jAL_sdt1HYkqXL@|hxD}X<w=s<1qB~{>B-BoZq!t(w|Ux|
zMr;Q$Qy6cSLe7aRT;hI#6&tfbqaf_gQ!PZ2#wCon;x)=3xn}_5dFah`-WjDe7vD)j
zLTT!C!oa?+we8X~07t<VA?f^%gg&%C(rt!g3j|tmmz{{5R9;C-JX48Q(v6a4)+%{w
zZA6$4q$}pZ*TVN90(cMDmY?>qHcwzCi8WD*poyA1D2B`Z?98JaWcs_<J4$?=wzg@h
za9s7+3W0}puK_t&S|5mTgPdx1m5r*<XB|F9PTa@%HLP))*v$Y+iN4E7Gt(+CuetWR
z9yztu$plvJG7cc=nD>V;{1iJ6g&d8C#Fp;rM~+(BBtchIV?UJb98vLG0*z#vp^LKL
ziRo`=#O(9oc2d71oIUMLB<8AEploF*E*yb)9swXMT5SR(F1KfZ4UY@QCGlyakVRh<
z3?&nPOSkz~#htQKI+d(8k~3o;<LgA386j@z+ARF6_(!MDiPQ@PimF8ondg*65i>Y!
zyCPgv&j6OW&#b-dRqd(GTfpP<{_X;yE+)vFm7<M2czkJo;d>0d!cfvMdd`J<772wR
zq#3EaV{H{2z%)DmApdpvO$rAe8E$05F5d+tkOi6SEYH{t4{!K3ceE#IYc=YRE)T7A
zU6-pB$jI$jON?cNn~#`0z9kfO9WR~K$3sc!_cH)jxl{kxVy7_$-ChX_c>hkUNs@<g
z;9HUMB#`@~`J?&DpAg#3C0$C!aetRoVYr2Utx1CJg)=|SUg06Vn(0W3{TtQ(iaoEA
zfp#5JWobij?LaY3zG&ys?Vo1*di&R|P(T6;|NJ?n_Im}}SqO?k;+Zs^v>b9^DE0S8
z;9!r1aZuc{75bheeS%u1Wjf@#(fLl0w&4w@qo8tCy}Np?fE92`h20H9?@^ic)wzW6
z%AvD!V3r2&N@b?}hpM$h`z@)*ddxvym$gU4!Y}D}NGTmLq>Tf&!Z&wqkYvjdchDlf
zN0d45^seizH7JJ=7rQ_-7@SXKLvcE$);8~849a5l;*%*$&Z++@U+1`HqCOpzXFH70
zzw?$bY@g_RJ=<sF{9S6<=7!;-3q=~!WnhyedExxBMf+3g`=J70aXuR-EGc=6ZPE7`
zP-E>3^qug9x!Ybq?<=R%5CBZZ3E$mdYj!$>#?bM?l<4GWKRzT{Km_*v1LGL*cUXs=
zLf6)34zDea^7hxpwibHo_TTMu?zFl)h1yTrFF!!VFbKDXm1iw{7erI%f3twg7l~IB
zrLi#d@bbjfDYueZ?mf6D+2|`7;>q3zeYK4xbNBC^#O<%C`pn}cxJxfmlIFj%ko>SG
zgMUb7I5R_3gdf9Zprp)&98%_7Me#S<YXTeXhK}oWvMHU^#X){liEWnQWDpmdaL}b(
zBwD~ePdY_NV)PmC-Z^|_X*fO;Qc#6fZl0Fypb<HxxYdZRTlGrYce2ySuj?=DhiNqw
z8KqyDF$)W(&$Tt0O-gPUhPI_A?rKcCf2@IHO}*f5oeos*eFk`5pSJC+t<Dc8m#9?@
zZ)=Ko4lFz>;!!mNwzB*#*wAI#7;Z3@xwxy0tKeCHN@c5ANh`S72VR5brZOq(LnsTx
zjb0L9zD}kbdG726?}b>Kl6S4@8D%|P&tQ2F@{Jl@eg~`n3M6xug3^&Y+%n75i;jr8
z54Hs8Jn`2QR~0kBRC_5q<VRZ+>eapql=;vIhF^y14cwv%>&0v>yluK%&k<A3z;+(c
zS$+nPxh-W{WA1WtHHM~BM;G%5DtxQmsWa)Z_cF@Oo7PYxj(|8=$M){U2!2(G3MKLK
z{B4hTjRhR`>uNd+%O>9aVX>E$r(3_Z<`#<+cQ$7D7(&!X4;+JYY%D8&kdNy|mi);R
zyVJaxME%AKs7xm|<5_YYf6{fzRqRAjnvF4MeqTx?`=te9v=U6})Cw<e?ySh}F4%a(
zFTNH0o6B<EBP8Cn#pFUrS?Hu9C6#rENb{JeK4RU1!Dj>w4P$L<MU#0H!L-6OgrQ;G
zZf+Hm?TB&GRUr!3<ZU@O54K1sucgrUzhL7zyVnH3a{L=ouc4+e_YC8(iOG%S?YAA8
z&4;Uldj+gziRR<xT+MAieA!RO-Jqa^xb;yqP#5$06kfAXnAz59+utK4d%@z#=sY$B
z%KZC3q0Jq;0%VmBDXXyoJ|t5{3Fh3K?2YJnu3|I&2kj3WBCOY{1vd0IP6P3?YN3oj
zkI>%<9hpl@zY8r#nomC|Q$7{5t!SHNJmqkE%{TMYsylZhmi>n}8&QZuw~A)Q_y^Nl
zEgy|2yuLMvbu>hKEIVT;72lL$H`HvkRD3;<vsR!DjtlP&t^euNQbB*Aw@&NHT7D={
z{`nUUWbYkfvZkLl>`waH@m2Y~4rL93OdkFIo%|P`B%@*f>4A2Lr(@>Q2Ib}wvQZm*
zfwJ*J#?b9)>5u8_!T1^YmVTz-6h3N!SR~-JLQoU$wLRFAf9D-G14on2IBb-SA|!y#
zR<l1bZ|5W~YM-NuWiO_ES;}_^BO-RQmBdGsgms{MH%?9ZwcfbbL|Sq-;a3nPINpxj
z$v0Q09<}BVlD}u)N2e7dQ051WB0it(<s996`_bGk^h%_d++tR_$BzBbcRF5tX&3jg
z(OCPYQOe#-{%MPhgV{zmIIWjwd7jOH!(uq$2@4&=r@Fbv4Nz6hlS;H)PpyLqE&mul
zhXxisNWczmo=nC?>KZ5BzHLvLeS29l@cs`w%g2;Dn8!J%4wFIJ5muLI&0V7{pLnIJ
zZsDLdabZwV79%qxFzLqOXmsIIJAQ#1Jg|SVU0tMn^&?pGUXz<ewZ~_ZT6kCd8|gm#
zo{s;=;H_5k(#y5fF|_9TYQ|n8Pc;w(jPEg3zaNL85m|wNLC0JJF21?<CV?7P%m#WT
zZnF|4Z6)hhI6s7xYr<9-%ijs&^#?Nl;29Jq@0#wU#_oUrB@RZR@<C=N9t>5p=#HI3
zc;IBrfeS=eU_@T3a|onzuyBZL2aAOPL|eeW*m-Mn&7J}Ft%a0RO3<&k?q5|<Le2I!
z4kEPQHqU9QPEu~Oc8D!FHpMqqrzbSFO{l9`+V{a{CE4G2#{No(h;P(|7ig|>7Snx<
z1`*vR`(0mn>#lr(x><W6>T6_dDFDjEM+f8D^oSxk+?(TnQ~J>#WteZi|NAO(GH*8^
zOg=W(Qr>!}%|xDUkYhj3$&qezM-tL3R9vMURIXlBS=;BPzLilShY`;#g<MFaiN+@-
zF%wQ?P*M!MG^LkxE0gScN0jlgit?NqRSRks{Btb7!xWDRjNz`X#-<`TAwvIPu4E79
z5;sw%jmvGB7KNTJ3A2^v4lG1_T~XuJ+(+?=rr^5W${0BfhS+z&=X$<Az(e=ph(1T$
z<*CPe8sTQTy`KVx+R|L#C`KBC`Day#QGBz(&IRb_jpp4(ucQh+G#?YxkK2S+A{OXJ
zln{ZL72?)(s3roUDT;^gf0US`qOiVT>=?z<?%n!)63Dqb@G%wGU7!;ZpW0zIOxIsC
zm@ZZbp7UP8HW-QbP9|JJI@eSZ+t)t1J~Z+*-=25F4BXSfYM`VCuGodo*#U}_2}~Jm
zVDj6&!VjU9w?%PTz3um-Eith+9^Gl3R>TFvxAXXnzphpykB?<~3E1f1!*sS5X$b>r
zWkx0gDNc6b&8R^fDNCE;bS_z4IibnPd!LXuH!v6Z?prXkFS%ZC8T-s_<yE<HHjn%8
zGjv*Uvrhh;U)HD!M|bf)X}+*(A8U-S^fg#5jZK-MIvtGLMUoyVy0&RQK%zvO^9xsC
zsIM_deQg_H=pX1VwV$_9QWV@_Lod|f64KzJ-QJXQR%=~Qo9!|Hi5_p4|HTfPrQT;-
z9l9t`^>h*{vrslVfK!kY)}WiYLlzAGCO-qHbod&a6o`*Rl9NBZ$)}Ae;k;d2{X0cB
zR%|7{^d}V9Z%gtJ)=%B*Y6BS%k%9=;VxQQ5T#CXOA6x~e^AvShgs*@(LR;Gl2D&w+
z!2QL{K2*jVbGqIX;9v6<2lMY}K&5<qNMGoPRw!gw+xc2k=U`*$&EtIj6Jx@UtlwsD
zzp(6p{5o$vf6skyi!C0`#V=*dsgnB!U#10)MO)XGR9IE8V@y>^v2;BHv~}B>J=spJ
zrGA&Gv&P;%nm?7akSt)AQufaBxNdSg-%h+uNQGPqlUxWT^Zwu%HnTo(9J2ZLa@p+R
zmilT(gidQJmHV&u%KZ8!Ly>%(cFs(?hHk!WG1E+ObweIn0RhYVhqL>pj4c1B^Qyn;
ze)66;Nn8Q;6Zm|T){mYeOM=~fsFj}&b;Nyc-as;GRy8bsa-^1X+In@SLKntnsEj~|
z*9-Y=V4EQ1dMO~`z$?na+%Bh6>xRlOk<`f*lc`8^@oaCJ<mx6RC7Vx_sO)MwqJ4Gx
zGRAuhtd*sU9Cj2a2<Afyr+v;5_JIPT6*u#ghjBB(R*1&aiBh<K`uN-UssIk~ystPe
zXf>d*248H@x3D$Tt%V)o7B!i`wYLONm6B(GNbDtY&7f|kvR`K;CfiC<ITEY)8r4kC
zpYu3AQXLWif@TztRV7uHd`lW3D;OJ^adtB*L8{08GqHiJImu0QDJSi^n&#d<12Z5B
zmT#Hylzq7zZ>XN6yJhW2&JC%cQIl5cItfs7(S9m^O;jO($Skgh7dmY&I6wl0VJ%&N
z*KZX(+;3RjAS1~;TE?~5f{AJ|*unlPENWv`2E=P#91$g?BYY<Bi9~0IL94UcXc9+a
zr{fQx?>_7bRW0^tJ6u_`Y#6%?yVNtEOSce<ve0B{Lo#npBDq9{*&Avl2Y)Y0h!BI5
zvk$9##nV5%n}|LR6-L?jA6u<@^ERrbUhB5PPCKQ5iK@u^FFzDgzELtjRUT%*@-tYL
z%k^DznU>5J3HIOHbsXiVvY(Wn<DDWncGz5AZQ1K<nO`v2{;*I5dQC>(sbq~qT2-`c
zYQ=UP48PRavl=QbY~CzZAFP-`+H17FqaY@hF`^(az<%#zh{pF89eXt7C%bMg_wxO@
zBN^i2Q}u&i)RH=N{h-`dv9(>czvHu<6||V|7USI(eFkh+8K%|LBpL-6{!%Ednl~!q
z5=L?y!tX5!w9PbCTr>Z>A=eOGG<3>vC&ygnPhpb0D_)Ul`FC7q@LYwA8~o)Xwh_J!
ztJXYv8*?*Bap0jPW652j;c9o8R*Rv{y2|IpmbD5kaA_2B2SX?m5EsadfO#559>?jP
zs-4I;-oY&#C7W&8nsXJq9533^)zh?lBtp9*biN}&-M}ff$DN5!8U3T5Ghiyrp@ZIp
z^V40x`uDAU6sEd4O+s@7H?kJAq{u2K-Ppoe)jOlBcnf!Rx4*Um-C$TO#Oe{8Jw6T`
zw5&IDZ=7f1-1Xa_s#5VWuTKkch+grK`O=Oshl207)Yf2e_;tC%u8EmN`;#UBrz{8z
zaPk%g&f5cT$he8V3-bpDxNS=c|E2LE$!#B9{Nw*S>HXc2A9}LwkW6JoX0z`gqupf%
zx)ssy6bWVI_WL=p(0q>%%Ps9`3k>N=eSn^&E#*5|znHTNeNCJw^+&$*cs~iTR{JK@
zNryUiIxFuEIm7X$SA(^>>1@Xr;s&c^!%=kVU&uI_RQRY}xrY&T@deC0a%oPU)`fpa
zw2-%uV`k0Xr_kyVW<)1wHG_*OXG==RRf{|Fo&iS`4kMCZch-_VS*8<dL%wF%fcfH0
znS)3^SwryH4=qK@z!W>5GsZt(=%#Hzn;G9BEtM!8K72lHVKLFXI?QrpL^9!&C19o7
z3&kUfYn|#$$+?LTVUp6s*0($lOJ66p_(`Tnx@w)YH)VB$YrElYn00%KF#@YLw(lVP
zJs@?_#3vSMD05RG7AWepB5CvRWJh5()0VQa=O)4>bv6{$D<GLz1D<9m0OaqFpYgQ2
zJxM}8?P+cFS2NTS9VHblPK~CKXERkAl5mI-JDk!vi?@MBpr9YcHz!v|jK9>Dw0eq%
z8URp+!m1z{jdm<u4&mk}kk#e}*LPz}uO8POXVPB&$LRDVzWxhg;yqv!j_DFV0)J^=
zS2|;*Xe)UwXLsu7xcG*0420g)+$v_X3Soz6lDR4Y5@D6BS~`EkpY4?57O4(ebCtYb
zeM$)gPHy1V&j99a{m{ocygk0d9W!?$pFzk7R;5krxunJ$3DrI{JE8nB7H6>e=ON$G
zgsJ!@Ok$(fiyE<10j1Z^fD)!CaoFRV--aoND@dyJ@a@~a2EP*$Qfq&9he1le<S*$X
z!y?pidHS8*&fKR2>?E1IqV(f}ohn%_KAg9SjWQmqr9ExA8`a0znwpj|l@S^lnv5df
zwQ^4UIN#k!^r;Y_Okj)1XRoM#?3XYOgQ`$q3_FO7rCiueZ2A;ek-;3;%A}i}dpp1F
z@NM_XY!0PGNQ&w%V>lMbUg*|{HdQ(54{6PLcIvB;u>w*0ZRofbElqwqCr*8fnnc8a
zjkscx-}T*j$lt@1U50UZRZ{NjuiQq0LJ7zPa;&kIL?5_>yE~&=CQGIK+}Obbaw&Ck
z%Oc06v-*G?<l_F|lsq$*({1T?U9NN%%%8a-EZ;SD%yNK@>6!0?s=7qTCTSM^Ra02L
z1kMuB*ET4F-#>Ps>=Rx^j)O8TM`aBUDb`zj?T~wZ9A~$KufO7_p-11cl6rrqIKCly
z-3l{`PTB~k)TANpbMfwRDZ1tx;~8&InqDOS$#+TinlPf@5_{CQRD5PzdY-OLNt7X#
z0lBz<j@h*0qpPU-iJQQh;ZO?#6hI%_7f6l!VX-SZ&Oz$3{^gzuS(2v{mfj@78LuKe
zO7?**d*O~8Po#0?z{s_D1;WO+(?Bey8rIh0)J4_7><vE^#TOX5k0~(&)%z*w1_Ct7
zaRXDLvEQHJSruu0XPdIA%A%ZY<HCJ7C!swzX$5AH8RW(Z*og{;Ti#Lru~4cdp#7Fq
zxml7AGN5Axsc+vAp)kZ(cL`2-RdG|}z?<JqKLg4}nK@#m9!%6xf-q_^f8R-egtw>0
zvpYmxa2$H>zwwy|Gn0LF3pqm$cg#wnb5U2RFfDN5s~G_WC;pgc{yc+TFtw_?*wxyV
z^+&f-Fc+8-{$7x=n41*!^QLZ3RT5qa#t!e;_BsX)wf=a~_sdu?d1q5eU*qlWN*9qp
z)OWtJnYG}pY$K4{b!+dV+v3JMI*?eiW|RKfw38ux$#`0mqqi`Y2^$n5$wP1eY$%IB
zI{U+#5FVg4%+|MOV#AkFTU_n`3~1K3N5tP*%vyfE_knAU6S?t7TdV$kZ+rzUL2bZi
zk69<DzC-+<{haQ!@=|3zT5rZ$*E>sOD77F`k{hHH?jGcHX_h`FIJ8Sv+@ONK9h;P_
z*MdTyA&>KlX5TnjB}J@Tr&h8s=I$`0X`nT&e;mAm^8;(~X}J`$YzM_UIg!Tm%SpGn
zvmS~(+f!x|Ogi2ObMqf#%M&DC#PdaQlc~#dRS<m=YK#_3F=*E4^Qe@sx96WOPNj2@
zlE%<2p|7dzD?a(niNBklJjcr5<t%PYLg^NJ^9=ANzW!(jhhT(*6L&1(FWLF=j>kx5
ztOdxqC(Sb@NZ9-UeC#bGDz|23<WANl*IJpGD->jaUi3JG8}(d46K`f|!_c>ET-h?{
zGUAk0b>2J4UD{;O91L=qHeUqnQ+=GX)8?wWQ(NZz{M~c#1~+B1Ei6&w8Q`ZeEL*{5
zG)z~2NSG>ggkWhB#CG)?A)ON@<s>YS58?V|J)&SR<QGsQ)2nl*?(;!YWn3bblAmuZ
zp0~3^V@RYE$#K!J$Kdsxn1+K1I^G{po%V2ET8_I|EDQV=PRXjQdGMq{ZvG4yDMctp
zgvkbF_C-XE0(;tFRj4Vu;v&}JBHMsZCT{o9NXg7dWvbncm}pMb;YN`O<h@w%vFM0?
zTN?E`o-olwTxC%9eW3DT=A1AIPUWbeu@)KtL1aQ1S^6r*UQiSIXCNY*hr_UqJ^!2i
z=Axl>Yocsx@`jspFSbUwqugTl3SP%mwZO9DCo<$yEm4Ll2m98N8kkZBC&JgUDEg})
zI9Es8Yj=S=Lz~7k<J;bao3{?(=O08z`D_?w_6Sb5zUb7^^CecEjeFF}^lIa;HX3Vd
zYE|fk-jGw*LY$4<bnGy~IwOa72w1<rD&J7D_hOPU{p+^OE$OC968;RpH~lQVMWJJ2
zQ8~bNxD8hFd9^3#r$sHF0z#)-#*Sf?bx>t~?*x*fmz}?9it8eF?)9ky%7fa=ufIOL
zqtBAW%a)Iay``Sh7&5obkY~uUBlBW=pkXD@Z){LAE>6=e9f56sZYiKh_MH8tD1T+G
z+vZhl&+7>ciAQGcL|k7|EBeZ!rRcGBG-5imdF9^p+mvVI0_u3~J35RFN<t`wo>UcB
zaVr_Q8o_gSgo0<<+QUj5FqO#}QY9ZgnWpCI_6YK+(M@PF6`*fUAdKQ46VYge0%;kg
zQSBp>AAcq!T^6sB-iE(TvgW-D=2&#7sBy_mJF>H-k;#cN?m+1)Oj{w=PKF1H*?q)S
z9GB4QS~ol8sxxlqOW|W<sE94ey3Od)HvpF?s!=K%3{O%o)t~$8+Vw<Md~0y1P@NaS
z##+i;)$+$uH1R7~C|1C(a8iKwx2JVS)5{0vYM4)(xv>6N`=RYRqZ0KB3msXFA>#}P
z68}L-+Iw)YJxY!JYS1_;#aiSfC;Ed{+t;SM<0_8WOuQ}Q#c7M=^?>28j83;P=cXVG
zLuA@l-T>(%i}n_w#abNShRQkS!<;}$1(QTUwyhFcLnh7O3^#r3hmJn44;}8mtAXP&
ztUTp>;=)vvRVIuycmreR;at`{Lp#RW$YBNbr$19gzSynBH%zSD_mI!8O&RYi!yI%i
zKAe*{FbS39iU*EZ*^*tysm5{Bf6k5@CcJBz4<Y?47KYB75quSXoS9Y!fQp&MizA>L
z1~EhMN_!&Pz7#!1Omo39pn+)pz))IIYi+BY?tBaqtQivg_f~`tXo43T^!tKqW%S8S
zY^1HN`p&HJkPcfq$Ke<ZQ)Rj_Gcm1WF&>6eBQ61967AwZ)Xh2&^wb$zs&9NTNOH&q
zqpQ@QW4!Bqw-@n6MGD)M^6aKp7#8&uJ>WjBm;3&{@{l7k^BF*@T-=^ub<`5&@}{in
z!<$TSGG>JjPW^?rI*UW040fmI6^-1}^a^(y&QHmTYc?=GAHso9$b|o!?9L_KGNqnE
zN8c!pFV!|DUwEw~2eEm|bd<usVD{Jh`iX|?^xG_jD93i_8Yixn^n!A9FJ>g8CBl2|
zRpz`uj@K^GLhS${!#Vt_vyGgNh0q9bqB-SV9xVR6k%{eY;l;m#*L8Uuq@F1ngl;yT
zMU(T^g0a2aLm}@TutKPRU>G}<luVwa&83sGY3Ira=GCrqa<=lUgcbmlSao!y@0cBR
zybhf!+S3Cu2)Lbjb4|zGShtPo5r^x28zj81iFEJmOK2!?2I_{FOLdgWSy5VNtSZ^Z
z7)q4va21^^)}<R~%k0LY*#Z<a@ZAWgS$yPE9KUdPdNL0SBoG2`xkKseY|TzPhm4^+
z+hiYJ>9^88!s{;=XAd7o+!ogS8DGEOs*z&E<oZC)kgIeU=A&d{j6da>?~cVNQXP06
zaa?EzW#47KFqTLYcm~Az2(#|yz_2GT9;2Oh(3J8kAWisGvENF|eHQTvw}TpcY3vO(
z6GO`&-gFX%+;zF$0ScQMC*jRWE1vH7$&skxYb(U_q(;}t;7*hF{*Nfup2o^!{vkB{
zqwG!2^c@kfzk_vfGf0V`U`#xT<17(I02e57{N3zv^{L7`yrr_zG!x6V>1rqhCh^8N
z+9u_aObwuFj(L;yH*gB4ic$KMl5iiX&YJ%L$K3teT0gYRYOvU-MOiI2eauB*oH$=W
zDqdTLD&<MOxCEj3SD||7b@a>gHP?aNUBl*2hf`{tSyAXv$5QuQeqyH-=a~)lB3Uzj
z*3=0Nj=SE)Y^9Fgj%?zQ^Df|d2`>^xk1zRJbSJVH1_4ncp+$E|{ZCMGONlZl{zNBN
zkd?dBr95L4e$YU^PdCfJ$~wuROSi`9DKe{rYBh;7N|6WIIcVpgemC%b#l)YqyX@T~
zyQEo){TDWNWUIlCH$A7~p+2*$A1u;Aa1esN@<|DQ&8oHZoc^MNZ}64|oSH28{eWAx
zyjXgKc#tXr-F-@w9Kipb+DTOPcUS#e3COsZ9X>rsZmqEp39rnD)k-Nqmw-aW!Gl9Z
zT08o!AYmLq>D=|@qGreGT9AX`yi1uNCOsb@Yfr->Kc=K-Ueq3eYZ7l0ErEK?va$X+
zB>DV;YLfd?D_I`*Pjr?F-XbxoFkor2_HD`@*g5ZzApl2q)o_*s+c|kfz-ZS^&b@6s
zq!|Y;tE4-#mlS(v$s!EXB}v!a>c$(sfUa)a)lAkTSq=?mn(<+k;hy+;x$TG_7mr)-
zA8vr6r&0wlgqfYEXta9@+-zRs%mJ_oK8Y7caos*nYPFF6QFf<E{zOV{VKauiW9Vp6
zY6&U|NnR!M;h+8nFa2%nuZuYvZK!F^7NAaNq#k2%UnWI#D%fKbVt;e!_U1kIskw!b
zx3~xdaPw&t&8O9KScGw(wMX^I`sVe1s|zIom8=>sIYanT0vTtxUK=!)FfH4(z*emf
zf}-K=XRXlCVm_@I$0awHoRuog5ee+qBW__!()zB6u?5>jFf|zhTaI+w_Fr5)fF3BF
z3lSYRYdO%hOj`v<JJK#MXf#zQN`?bk*rDg4@uOO^Wve!;GAkirwz-^nfM>v<Rn*Nc
z;8gI(ALOqpWVedC)TM5)_vz>6gU(%^+|1oD;`#~Kwmo4Ywe8kxnC)y0&&GNWUh|w#
zVc^y>y$PmCb8b&>PmeHDzRWnYMK#NZG>LB|d_&Y9;V{88bAvrb$k?4zbGc7Tnyfe5
z2MUYwYH2V}L7!Y`fjOO$q2`ueQ$3@^6_spjd+XW!8%LOol`UVgRK~YOu6ZSdpjYk1
z*2E?-7a;}V4}9hNFm3A^SMtzQ;Gn?7Sg~Yl;^>;b#?5Gm??Gvn9gc3#Xf9YaIu6^8
zT9+)Ibu5inzh$O!CP!(g8O`h0Q`jIc`SC}*UKgA<gN60Z5}^mK%FXHep@El4-Bmu)
zT%7C%2&@XT?IC6UPV4xG$FQ}jg+TCwCy|s=KT4X^KyB(2y}Y2dO~-?4M0RLTO8?zu
zvfKOj16Jak@WPo^Pd-DP4E}ePxHRKLxDkE9B0gHWrQuzWHZ_GFqG>AOzxZo24ouU`
zURyGLy^6wZGBt9&{=nV4KHGy0#@@_de|SrT>s`Am7oLDGH51zecpPGUt8C7uVuTf1
znRIAg0u?yoJ>Yx?d4P<z!;`RU+jWdRd2?Tu+-Th)fXm?B8~fDewh7v(Wt{Yj>q(#n
z(68mN3>6f(`w2zchWD3G8-La9*=H|9feMR8!mTjzgBsuWo>IY62Iwog*l|uAM&1Fi
zH?rMDh{~kj&531T2<A;`i!P<cHk~O9$NQutD#vDMevA{qI?SKvMZ?`O+H;QE0(Djm
zqH^WGB2e1w3x}{25=?tN0vKC+Z|IP#E95-Q>SkMRCVEoMltQ$nl6H}!kO9z4<w>Hj
zR+8YooscWU?(<CMCOVE#fDg_JHu5;r1!WmOW5wgbjKHx)K8kEjWr)swxutLmlc>f}
z*lSwkD)%20a~|jir<XJ7HtX}R5!DkB5p{&X2<}-HR<y$FQ!EIX?kV4FqK1cE@lLm0
z9L};#6>W*jTGB<v#?Yn*`8agL=)!FYIe4zF?1B%CejFu;2ExPe1zC<5yB^H^4r3D3
z#vM>gyH#@-d~%RW2H$FT=rMHc0QTIGC~s}Ct;?E?tyLi00t0;H{aa~#+p+_V`k1m>
zZPWT)`Y-nZ0hk_LJF1#nh(_ouN!N4uM>Vav*K-H0nRGk!iBwWbsX8(WEMoMXdg`xt
zY$_P~nlEpqio|Y^i1r>`IEFYGOD_h$`g>WZAP=OQ_EN|?I4L~_Yv&W~8j5-8X6220
zjpZ(+VwhiJ7q+veN$iaHNMCVeY9dCej=u(SuVP#KZu4BvvJFpXzB8a^Wheb+qu;$f
zvpuiW7Gtr)v~DhD?Ad_^o$F{u+MasSFf0+PsuUo<>G)w@T>o=k#^V`amxf30m8I^+
ze5kprs-^YLA^j~z$JV$v8<b9^Iu0tYdpXfKYnD~iY2x)#r(H53t)03Q>^WN*!g-`q
zJI_eDMM6OT$p(=E7}z-;OufYu;$3IlBF6YL(rGy7h=*@2@3gYe2;b^;tmUomUh9?D
z3Z^3~&agEt{Dfvf;Mms*1~pBY;M*#gaJ<yqMRD7r6~(?rjK>z=iCUh7gWnfr@cZ{A
zO8TQ|6)4BIeM)zshV_bs&me~}$+fD~)vy`jScKUn6})PL<du~?+M|$wgK05NEywX~
z@1=>Qzn2?p5p=ETZM^PpJ7^gD_DRtPvIa>}a9kM*<AQY>%VCe`DC02^k`-DO*kgcX
zjAXn*ZeMqJeukT4sxcYj<`d8sAeaPWp|Vov3XEvhj)Lztqch5_M$*kO!+BepC?qC)
z2&kHJKN?`O*IVfcl3SI^`xA(?unt;=uW~ptIBKCVyk3{6Q;Lc9MgVw8GhhS~ZgXh<
z=@;r;dj_Z?s<T;j`*=x5&^PzHQBw_BZ+mcj&3<?7Zr|_#Jd+e??va1ZKg+7b<&y<(
z^WqfC-snKrKdmV_>aZTEUa3VHx0}*=E%n{bga^6*))Lv&SQu<jg6F4s(KpC0uBAK(
zS(>hC=-aW3o!Z5Wij^}SS-@wM9>%@0E<nR(93qdsz#tVRzCz=I=VHJ;B`}(++FN$O
z%%DvX`<zkBaJtzrRr@=oS7)OLFyN?vbxKwZYr~b>+DcR_UZdz;?QM3uPgLv>%#T_q
z8<b-_bC}$h71W|A_auM7{;<MLyt#5<XC|VfD#dsF6&`+dN)Gi2M1m*yRujTvYTu7A
zoeQB1;})1N4-!7iKU%-*ALe?u9E#@Pd?>E_N&Q+Ol}sC#(%Jz)xA0X-iu{+?yxl_n
zsxQ{-(uJh5SN8n;lSJ^l%C9Z0bMJjqU&VGYM$m`ina?*_M_lZA!eWIXBbV+Z_6=-R
z`lXhdjUsOvtv%AIYe4u*p^-B=S}>iLlZYTg=%2J}v(JLpL0F}O2k%&l+dv|GG@4oG
zJZj`FfALtd@}wsPnPZuKOmaj#Ne7{V;lCOk%Ewy=ad<$+-QhZ~Y~ETO@#a^6oY~bG
zDTpaSx${sYx$;ufC7t3S$<5{oT4U8jw*dx({{5st6UcbteKZy`hlrOPHbkZ}Cq1e|
zWJ$w#hkpe|$IW-;-i{V!e@`pS#ikujCL7GPBT(}th-z43WVJ0OChN4+RDxD66;g!9
z!IW>w@lLp<*dDXO1{VM2ZM>1AM*7?6S6n1<lp&mb#$)B~V;-$|jvga6Bk&9*Zo6hd
z>NP;^h%)S#dj7G;CrzV>`lJ#xaJr3Mdnr$2hGi9#BKKqtEb~|$FJ05(jBAHWp3pIR
zM#mSexUpm)gq)8m@iL4ZtX|CdHH@)dN#b+A$IOrOyzIQGDsf_4F5U@Wb<05ilufcv
zlg6A;Q|_$<Lz%i9-84)U9fe_efonjls@=vYQBX9cv{Q@o>xi!)nKYu>Q0%7Mjq*Ac
zr#2EbDA&}E9YiZzkB2EmziDm-iZQnWYQ|MIh5;@3208NPHQjdpoaG5@kpr*RdQewD
z`NEn-J2G%Y@yHMK%76ka1{Y5yR;^>ml4ssidQI01cIW4EwFdjD=y)01HiQ*qu?=TV
z=K~BW)b>o3txrG;pm#`hMZ@?s@mi4XB2TpP{Jaaege{!QX{$kz+<519N>a&w;<s2F
zowCN36dSvQF{kAAy2QK#xO8u|nV`5RXD8#eOi=Nr<Wl*MlXs~1p#(|Pv$uWea9uYp
zgMsDT>kFeOr}%BXR-GAEefLsT<7~><T$>7-<)yyX#$YLslHs~(5GyjqZ?$FP#;f(Z
zQcRVrkRTDladg!@eYxu&)l+9g1n4)959YIfYEil4&YuBA#wQVO1e%o30O&SJ^Z=v4
zPKIaG!Dp2Evl43+RGADX>{0EpXmr*!1U<d=(p#{$Y#@r}`DBi_>u4%xU=omWH^RzI
z_y~u-2yfI$BrCY$%|1$gCzrnPQ(cHP%<vk^yRCqMs&)cfC^Z1&@!<LKkn?koXm899
z6V)zFDDZ%NEsRd0Mxiw&Z<=AITTta^1M9#drB$q+pc%bhw68Z!BuRSo((Gq8BTq1d
zn%o2dns^xD8ivrEyMk1w>`m}Rr@hq4KG_i8nFS#^kzp$X39)Ocbfj(UH!t(itWMsF
zAKk#`j_E~g>aAL7_*1~3v|*oyl~801`ZDx`V-%ygR7F8c=&z;4cJ1)fmKgGuYA2%a
z*Hwsw?Z}s8frtPxadW6-0sF4wFj5+3|IHr+iYVBl_)g{a;dhq4fcg}@;2CvDsx{WJ
zOvmQsLMWrU=#`I>VQ(~I>!*GyB_!}nmA%(-<$ZkVqG*A(vP2{hzz~c?f^nvjgD(r$
z=5^WT{!vSu%4bV*X-mHUg{7t1KRW2FgfYw>!1o5U+Vz)*r10|-j$4b9;LxciC(>&!
zjb4h?-))2|asC}ac(J|>k0It{D?Zp8^R=S8K6p#+bQME<v$7=H;-MuwO;mr#(7@TA
zY~<AYQlds5XLTXaUuC*AT=>|T`}|nt*AlKX*b&@BG;od|z2_u7#?k$eKHP;OOw7_m
znVesvV%bodlyQ{q5QY}9YP5+_cPc=l@Lbd%_kET#4*|Irhn{<&Tqo}#mPqG#KN|$r
zp-n_}!QHj7MGhRCZx_GKVD~D~4wS9(yP=hsO1RrYBNlpK(Zp1q1AjI`MeXLlqO8ia
zxi|`^RKTOG`-4S`SBTN*iR#-49$qfPrR3y41rjx&%x8hv1jk2&nd<C1b9Omy5VB@o
z_k61GwK65^{Eo1>Ft}a9DMN0hXfA4}2g);Gb!rs*V^%|+eXu)0e7Q424-vgb!_lK9
zRc-zNl#^znv?ET;48E&rncsm&?5g`aydxD~e9Yb=F_l@iG7((1SO<RwWLrXAN1MlF
zjd|DvwumqeS${_?LhOU}QPV;(+Tnf4XCXtPeGolr-!21{?5YWZ1a>w~E53|f!S5|@
z7UNgS9-_wBtcj~u$W<3}_6Tzu-eTEaE868V>!Kj<mqJj}VYYd6Q*+y4e^u0{f+|yq
zlqvPn{`I1Q+64dGp+XekHutb6|C_(s;Zc5LG!KEyatz3fhJi(L2PX4>AZ7{$3=PAW
zp(*vsU~IDUa4Lnqx|fO;gf!bN@CGIqIB9{cE#Zy{RVT~OKjBT70V+Q8xQz!}g!#ZF
zig>ZZPwU0RGp-t1b_l|1QJa|Iyu5DnU5>It6lqYe{;k)5)1+NB=_dauQ=N|@hBsYE
zfZm7sp@%Pm?t*`Y;iaUiuee(Wu}WoK7&sSjgWE>qqm`!EWoqG$6zZFvT37anE9w{w
z2nP77)9A^t{*2QSUk)i7UDz2qocaQ5;4viL=&M`1eQQVOc&b*o8%G#p@Z4$%q<JP=
z-${d)F15Azj<BdodA(2}T3GG-#6rlO;3M2Fcps19VvH<_V0HaIUaC0LkGYMMd8h+M
zvVHsv0PY;_yWG9y%J%$l6+z~Mm)z}JxqL7RE-^(G-M)}jauOv9WvP?GCtiJDrd{?7
zVD;oHM+WdnOOlR=DMdkz1)Jk|K5ME=&W0`myI>6a*cRQRPTRJEJX=#MbGwysRB$PS
z(%AMm9xI{7G<_Q=ltm$m6~)r-_q=c=XDwSADxqI66Ow9iXmM#{7KiI-g(^Iq8hSE{
z;@@zL>DB&PaD#F(#Ka`_!;kNJ26!dt*yAeEW@(OP1UvfRibvEF^taoy*wM>bqb-Iv
ziHF5^Ino!kQr63oyat{th|<X#tC#WpAFsA;=O05JeJ_cb*+-nbNs?{5EXk$8B}jDn
zRX!*K49u=5W$Gsa$PQQJ*Uigs6&9eGi6?wN_11IbRU>q<QI+Z&o&kcuCVgA3vmaEi
zs4U8;3WthIYg@`J1*(*pq#H9gW7Q);X@`DQ&Sly)VjdfotxlM>vspY334<bQRiagW
zQJHs&g3o|q#*;R#``<&<-wn4eNn3&(o&hRPQIWH8HNQv%8jRcW>)i&mF$P-ji#XM3
z?aD}9sr0Te?N^M{Z#%*ul{1Qef9B}L<1W<nO*8_zLU=kTaYixQhp2k5FA)ny-X09(
z{$|~I|0HhMH5r271qrKm!nZD|Ib8bbw3wVqn5bJLZJ<xPxi0PL0&DMFuX|nCuUR`|
zyj6xh8wq#6PvFEBXS|3KA0pkeee$l`V|En+?tMv`7TXiG{j_H6-XqvJ^)S+k)kQPH
z_;r@m3E3G#lMzYN>zkXkdb_{~2XeE0COjvK0eDHd8B-}*f>#}=*p&mRkO&>W`#nEC
z%QwlG^GTv8LN@Tc6m|~plSzshym)zfTSMO**2pgHc#164g1zH4)fpdDh-tMh#qtVI
z<gaVv=;zXKU~=dr@2IHt%`Bp>*yB6bu+%4`R1vFDHr>otod~*d8-`MAP<-#EDE^kg
z?Fqe`{;aoEnA0zEp=~39<fu$Y-^$BRu0os>DGsG&;3?g;^FsIs1LaQ_a>hsrnQ`PU
z3_CUAhegp@CkuR|WcpGmtj&Ur?6g$BYiOwiCF~cwzOGYFOPA^MF}(Xi7j>+pFsr^E
zG0!Z;Ce>dGfH4FO<C|;leb@O2-#IC$dbt{KGsWKM+xDkp+c;-mgO>zfb|OBegQ9mN
zYfpiGc8T!PiIx@ZR@c%sP{nP^_(N!Dfjp?i{_aN%Z3uu5De=#EW}n!jKJeF{KMO-<
zuIXRA(h_0?(4cQyMyB6B4OO&>nx~cU=#~+PTQ0Pxh``^XowAADi@sI!q|vC&ed9w<
zs%ogswCp1nAWi>E!z?6v=vRtkT-7{^?bXROjcJj4f1q3yK8EyEt^nX~=k-vfTsZF`
zh%qzmAr?*o%6bOez&**K_tar-mJRVM7s#=Y3u@qY^|!Dx)@`<zHwxZ91IRrY15)C1
z-{v#!8EZ$~+lgJF*vyp9YzLBoUYD3wBr>_B{vCDg_lJeuC8Psq3YEtiu7<rDI|be!
zqgHMSte6YGp;ywFD;FJ$Yc&RG;(x@?=UM#`Wj!ygn<?*AV~73@nf=vcY&xkotX*fm
z)PQ?i{4(}t{KVl5=vn(ypm1pqc&$U9xh!n4#YbY3W?k!#z}<iUm^^c+kys;D{D<B&
z9a5xSa%8NMtAwZ%!0F|{A(oh$_4669I1});L<*^0Me_D$TKhs*??_^ZXk?6r?3$0G
zn)Ud1HEybbjNkU6vW=_HP7R;=Z<#lu%^zV>KdM;C1w9q?x~<1DNc0(NXjX`D_Y{B}
z5opmh<W>kZXat{tBV{60pMZx8L5m`I)!{;T7ROoET^N{y9O(<IG1_06WuimS=h+tz
z%GRzs`5jlBwc^`eyJe`ep0KEH>)^{qA(H3Vo2rGVg^|x!Vr^3tC&^pm5N13^@kBZn
z+TjzAy%uS4D$g%53W36;l&KnHs#L`MS{G~z4{9;#gIUkXwh~86NO;TJH&<`_hz5=O
z^HjPWP}+ZH8syfU{vI3SHs3RAek^~}D<4~iPwg-oHe~LiV9trU<|!}5Z9*`8b;?Pl
zG*_b;XRjG(8;mPMOOV7G&+|FVH@2KYt%hDape$mLQquB95n)_^|CFM!B-PV9LAE;G
zWLW2{)Ut()Q!Dg@AquyEDxvX^QZ>L*qD9HE0{L~1r#UFjNSIMqLKz7Z$~kVIm&_wh
zm%6S<GEvM-{XPnWkNI7_eCGr8&G%7Mb^;1tQ!&$WqK0WEz8^61B;qQCqKeI}^M0y1
znYQYaS@mS6E=ZrZ1h;oiqCg_94emDYlDOqquv&w13u96`Y206-PuE+M2zxPqy~iu^
zWs2%X2vkDG-5Ml4`a%tQw2KR7#3P*t#a`*4Kx-q^MyMpaevOU#oxv);%n<&~7w?4U
z)QhMgggvOuv+3mQl7}M^i1-y1<2<pgO=Z0NC)nQY-e00x7eawC`qOeX%Me1gO403Z
z^ZA`unZ0F=oSlafRS<nuKutsGloFslY#;tq9~NDFLo>+qCF5~W$l%05PXJ_p+S!<=
zFP|X`(n}qp<SZ3oGngF=rIT}L55^9n^)QJc>{uH;+dT>O^me6C#hTrxyz@0VCc*ic
z*Y|*Ml-@$3b<|F>Z14<d+R$h(OHEpswsJcuT;0}-g3<z4*xP_BGlYWBU53|!RLpA!
zYjdp(P={dLUAa*oT$pkp2MN^IZecDolr~84Ra;O-xY?cKh=|y%sZr~ec;V;Io7Ky|
zqKEiMO_eLUDqF+bk}O}ZM?1M0W3oAw!c)4Df1!!)OT3-N63pX@7EPSn!obqO%c6wf
zlWwd9sfv72#!nw&j5e!T8ls=ETx-!dRtIxa4?5JZKBy{UrXAZ{*l8X1JBYGs<3DH{
zId=ZO$z?UYG0-0DiUf3ZJ-n)q26V(Dm%G4ou=y$5&mw<`&z46rpDBfJIy>r8!O!z7
zkG~rZnuTm!Bp=vDojd$Rru-l&j9uY1EX!GtUOb?7=M$kTT;W6y&KLdgVL<VgumWso
zJpqeOR`S9(PUm3Kmay(CUl26bLGG{Bno+!<IijKa5;8h^1S?9j>=uikmaA@0J~|)B
zbp$4VYRg-(1XzRIMygqd*0roq2-}_{mYh_vIPGML*;KY@|L80#l>#5U6)7JFqNexk
zM$cBs9O`V}AX2$4TI8g)psqRwG|wG=c(UsebGMt<x{CckgI2y+dKmnEN8;rjv;J&d
zE2*m1s>IPEP=)II)*$6)K-vTLZCcRAAt82I)kG@d>L-E8O#0E{EPEcf$d`egmtu~~
z-$xh}nkx3g)YJsETSNv7&e{ocpJr?Sv=Xn1xan$q;Tpc!7~jgl=@pBO&(}>V&C31w
ze*mLET))%n+p5}~aGNNwN7{Squm1o(q!mdq8UYh5oq<I?f%^W3sNGe>szi*Bdpn8z
zmE+gwK>q*_@c#flp?Z+9D`HiID1JUo#17<+g$_X|`~>6YX=wE$F{G8HmK;*j?BgIa
z;?V>GfB{m8Q3JN0U3KX$>f%6Q3ez(*?(K#aL^aC`A2UIliTc~@l!R4Q$gcQPCgYF0
zDJ6?$icvlEN*c4Hd(!e$JfD+b_Z=$Rs8{r#O%czNP|UA1J@Gwyt@Rq>><G$Ij(#e#
z<>pwXC2I4S<V(BSDEIaf;Lb#d>GDjOA&AZ{Ivo%K8-K)z+5(U?Py`O1{lC~>Z*^6*
z7+j>F2_~K`!4!Ke7rkCF?E_G00AevcxUBJoH!S4Gu^f{+g;dhowB@=<%}15{#DJ=`
zxp3Uz+8vPE)~4NYpzfz{*Kj?7=?>ktnzt^gP!N?|*|aJkM-jw{d?F!N_VkPhA0HSc
zVSFQf%lI{KIoz=Uk6>7{va7wrtRhBCd;1E8gUwkv8Rem&WQKyAbvt%R(|8_4s4Z6I
z*Vb*nt7B2ctfm@uha!i5mE=NpN-P%Eas|gryA*cAKXZj+_@)HJ+=7wtMGx-_yDd#(
zH2V`1!W~hR#*!IRs?%#q{EyfTM^zp7bhoc=-{NU{$c)fU0SC%J;|)CrFrQLjVepTq
zr}-W^3NBQXQ_(9V$7dnh?1DVA7ITs;-&B8(GDL)_9s&tddZ%&<#)?km1D@|U7dEAg
z(B*m->W~C}kT675Gnj<bD^#UWxF8Ci*~G^ze%li@eTy2jIf7-6;}NaZT_r+l<W6x^
z$Y(_dhUGfbPAgQYOWUrxlheCuRjSecMK3Kt(m*PJ4mr=BSVW?ug>o_|oxdmm*ySu?
zQMr2`t*CC=7bwsoCH>u^9g$%P3S5MtrV`*uY&h&vrK3;*NF*eEKBMV<vh#4Kv)|Ux
z+P}y&PLu_}BY||BsJdn_gf;FROxC0c0Jl<e68z&f=VN%{pFj9>G7yuh9u0WU*S4W2
zvHt)fdj7T4`*pKj(bZnnjByhKF7~8j4c;yq;#%X6u#TJm0Q9lBO;_$Ovbe|+6mza7
zv55|ixh_X;Q_*bMvkLO7@oB_-Z|$tCXbO*h`g{xi#q_P7(Y;fpYQ(1MWyrs%a3ri~
zT`zrBy#i_(hhxja9AD*E4LIj9VQofkTs9DkNj0%Ix8y+o0B=7RK(<t*sfQNeEHA!;
zMCwX<`Ri-FP)lT1EO*qv#$cz$Io{__PBW}>IrcUdbxO>OJ8XQxqHxJv`1UW@N2V`2
ztqKZLAwj|j)TEx>x`5tWJUY_7GDepd5bSX{Wx@)lX3C7#(uab6ai%`SR&)OVH~#<^
zSoU$rnAHw>&7O{A?osEIC359Mw&J{n=PjzNcQ~-)Yp%CLk(89E0*4Sa0PQI4c5Slt
z?DVQtrW)M<$hdOD0yBaQ3e?)_WeNJZ9wX-&*@ad664h6;GkuGpwc|WmClK7gcPeR?
zCMr+vd4&_mVYw|A9b2WcJYmN*8%ZiiI(0Ckw$P;7HV<p+2ZD}P_~VJ;;U3a$%bc|W
zwGIfFLZj@}4pj%&4_CO~ktF1B?vV!~vZTD73CGhlnVB_;BA3G4O2cLv8QJ11&;S4<
zryFhEtxdtzSQ=Ou(3oQ~o#7!(S|zlADvD#dUI6wcCpUlT{J`=XSyYxhr+{LX7%h^V
zl&d)tZLo;ni%z*MmKN-VL}{4`Ly6nGB}0GUN}a~R+M4+(CSYkKE+hr)?!ph*YLK+a
z!d$sy$~e{K9E%E<n^{vXa*A<vy<uY&qOh>zem@FZbz17ACFLmp0QTy2>E^{v&2F?p
z>GxtKoG!QoI&(>UmNP5ZdPq?6Zb){R36=7HZ=NR&QiP^<*Ur1ZB}Ga-wEcR#?bQRW
z7*=Ey{Nfil`UjB$F5kuqyng)px}bLd0R4>vUizKTq$gkddMl|Me}?YX_I*M-wM9LS
z_(yaR+#A3oD1r6;3F@R>H4vx(1Wz#FAs`ZU`<*rFV(%D%-sqc-y+|9h2e=(YQ&LBC
z(kCPB02cux?4jGJzNqM!n_)-@)9gQ|@BaYedWNA{N2?xtI%e-7sw<M6i=cDF<4Vwl
zt)(^;K?N%b-MA$~O+Y8;I#qvW+U=RZ#H=Jh3))<Am7i06i;I!iOS7qsi{%rYn&4$p
zA;(k)o^dS%rL>eVg0C7#CqMz$uA8?yvzpcoPgQCt0Of?xVrMY1)mp7<Rns4wav_z%
zqvOsq!>n-YSum_4#;d+}2Ck0da~`3-c~e*x^3b<as-rZA65nMF<8V%$*z~2P{l4c?
z=@--hII52<k)!m2XE<Yi#*i5KrUh^(F3_+N_75|$<Sbi_@A3AeJyTB})(m+qq1Dfl
zsaFN(b#2kuZ5kyZY8{9KXh%&b-8QZDW;_Met!4oQs5{1S9V=R`0Anwov4)QV<y?<C
z!5YmfE!@PXVAQIJ>aAagB45vq5<6;{6f~5q_|nKzpnz4qDFs?9PoH;wlx3~&qo>yf
zpl|?42QMx-Ork7U{dW>|c}N(1{{Sf4I*TkPKmI<eGC0@q@$V)TV%9{&mtU1q%=ooy
zlU~d%rD}@OBqb_B3rYz(q$~rcOTWR;wyje`G=k!?Oi2XcGGwM1Th*lIqe>^n7LFpx
zGEBRkc_I!~i9xEva@<=PyO6eG#E#N#OVOf9eGWeytd?8x>e5PsWQ88eI;-l=o1y*^
z*_6wLMw);ZOo=ScOF7FJ;_9=_XU;_+8|~DpTDGib$N03lg+@&V;kpQJwz#za02*VD
zq2(b89uS!dZCf^MDB7?1iRiDl4y<jM=aA>P7J-V$C<(<SpEHCmsdMEn#mzXt*PFQy
z9?ecmlH)SlEnZ2RX<)=8IOI0w*~CSv;;qLLg?<l6k_r#iB<>xDUqJn<+%At%*jcz1
zrFQ@bn_T9mq7GpdIEWv6w>2zkR%FR&GQ*5#te07N?<{!fh~Cr%G!(Uhu$>fjSJ0^H
zbRCD#b^WuYLG7jkov86ZBj?9fYo8#V-;8b7{+_;7yyKtbw~eYRS&uHOkZWvfawtxq
z7afXWNo0nWTtG^IkV(`XN9pzJ;LrBT+L*qe@718EjA%U`3#rr`2q&^P!}$n)O{N2u
z)#a7Sv*b)Q)vp+s#0HZI%4bs|%_(feW%j~kzVcR;I;|3~$4x;8<9({1{{SIm8}Ko6
zy+5{u&N<!p3SE1ixm#UH<1Y&8?lI{SGM3(q+tHs?*peNFK?!kVy24JsU3+%ut4*eh
zuU^ndE@ObjF!stlqjvVukQl?C==Zcd7oGBcJH;2+zDJ4izq9od_@k8srsFz@@v@&K
zdsaIflJhArrMA?hxKXNndV{GQFWb6W_&K#Hxut=*61s%f0Kc3Ub-L50?=YA?<B0H!
zKQm(0usvn|MmWCvC9sQ}`so6yn=w_zW8?`<<WAMdQx2*kL%ZCHKQygL+J3r_dZ~2v
zkz<RBIO}d>kGR7(jSm3`2yo8`%THz5x#v7f)r%7a3ggZp<LnL&eJkcPxsA)0R^{}S
zrL~<D-jn=ANl*U(NImsEB7NOEYv<5uA>~77EPgqr5UQmwQj1dnK5@RE#SbfDIG^!j
z{Fmb}EB^r8c&-ILrrRH7=*fK&CuFqlRlFG~-h8pdX7;2H!$gFqU#+Ub>{GK1tX2BJ
z!-)1+p2FO^@5p~o!a01!YO11PJa>^ysu%a1p>h8Jh|gQHR#>a2YvH=32+K*;PrahI
z5<Z_{)!wB#o{Qcbh;)I+kFd%YRIWW%gh8Z}@`caY=Hpo7&t!iAY(dDWVJVLrV0hxg
zw0Wl8aHIr<DGEU&w{xHxcj?x|-`%IAOa}?)0aqtM87MyJuKxfUc-_bTa(!jYU{X(&
ziNMVu*4bsIE26!r^5MyGn8p320o9?Us5h><0(*heZTh%2?`nk_N@hIRpOjB(*8|9h
zA>x8@+nZCPvmnMXpOX83)P~wo2_$QwTK1qFKHIhGp<bbDq%|xjXi*d1S*4I;!fm(v
zXw%N<H0`L>q_3iBmk_2PdKpEIBmIyxPW5Tz15yD4xCc(SbwpU{ixZ4F<WSLDLF@<p
zop2mtO;T8#XK?^1Yumrm{{V+j5g&w0vUEsEMt~0A<J3gN&6t3Pwaf`#s{1s-{DZuG
zn1v_l{{Z><eKP5?f5=nq`51=z4HCS*F~+Vpj3RduLd!7x(N{8&j!SC(q2`)dEU;4B
z3^dvbLK24B8tbXtHy^J{`WF83rr~<Z?DW{pI!;a+W_gwOL;dl(bR@yR{9=ub`u#3m
zA;#A-E}Wvex?Gv1OfAQX;xjF;5>Vn$wwPKL*$PS3L@!-C9SgXw_NyFPX;mIk`lTln
z#V||}BZGLA6}Yi7?~M|m;JW%=HOcOAD9lvm2!i~iU!mgb($gj;t}wRN&?-r3E+mwt
zASmhdI`vZ7Ho9NVW9gRw3I*Z}^PEY$?$xduT~N=L4iL%WICH$S>rWH$-~BeUh;BIk
znni8I88wVD{NzDUhN9$YBjhyl*#Y*JLXZ#SH+B@xq^w(WR+w@rc34l?L#j22Ac2sA
zgxMHYaZ3X!#;}=``MwuMUCL`=qFpt5EMUow^pK|^sf9ELkulb#Eg<L#3Q0#;wf5~%
z_hPL_5X}Sz%+5kU0!Sl{J<;vOxp;92BkX@DO}UX+mGy3Ckwkt~Tx(X`Z!C48A;&E2
z9hw?LE=X|;^2cGRO*bXLcDNEq)3`UDkF4q^)Nh<>4hBO^<);Kr0t9et0s=?QUiet7
zVOmvTxr|y%M&x4ERaTAS(jXwX!jx<qMAf17Bq(o=v<0M{cKwE@ueds9){W=gTN>4v
zbkq%hm;g)tG!6s)K|#(cmsiQORBbmX1c_xeA`{?rR)e_LL;8I`$FJ(i0x{22k*O79
zYCnJ+ZlfvwO*oRC>4x5~v8%OV<*&#cZ_NBwcd(|^ke5F_x~LJfp4#^x&wuwy&>OwJ
zpmvmVm%I@^Q&`nL-(Ch%uD}7*2XYbJlys&1oMBnE1Bd0DXOCu67(@1LRzk~LLkV_8
za@q1t3T{wSW#$`J)D(lXok%)^*U1}IQeNQSh6jvUuUa&M><_X>CjRAS^w>uX<+wIy
z9&GHhlCGh($JPvK;E1|-(G?*xRF@e`iFe4Iiwz#&_8N6=*=bdM+nf)TxQxuaAYky?
zBiSIHJvjDavSr1dKZ&Z6%HF;!^{&=kMVKO5q6iA{YcZARr<-kCk8bDjJ;y-oJA+um
zN$%2hN?9%v;}dQa+ff_>l%K*h4?g7VpEcobP3B%qtel(AZ}_rhHJqklt@vx@iuWny
z*cTgNCDgc;BhJbRC~!Oib<p*m?$!dG!_7H>RG~}^zXRD1_WQJBb!9Ji^n@RqF*+_g
z<g5PxTPW4ydWwe~q{VDqlJu7*ON)-z!BaMjLUC;}+IIO|TD!0oq^OdT1v_}Kt8seE
zrVlQotr2H1gyuL5W17wM!U8>nbnpCpa9tM@aeSUKw8kP14~~eI8I#oramTGp7lo?j
zI?F;pl=(^?2qS0+A#2=p30t>r46SgFamHZ?P6B@!!FzcuT`8$0^Ntp(YO>l4Q!j;f
z^NdHsB)wMvFI4y?xp>HZln_BdaayT=atG<x(A3I3;9%7!+niJw;8@aeBzR63JQ(oS
zdC17Yy`_@<ZwAmsfhxwLsV}DD^}{Kq(N_^MNqJ65bt6E^O8j8$8;H?c>fJok^bwfq
zc1;<c9D?@2n|&%e9OsQr7!U3^j_y7XDdf+8U%Y!4<L(~8<9hwa+)0$DB;y`Gi3z{^
zrKM~s5F1p&vKFPb%kFkpa-w&YE2i|V9YK{^&pTY2iNv8$p34#Xb!$D3s8PTW20#!O
z+>m|5Ka^i{q|auRoWmNN`wq6yOsrZGkl<RwdIiUk7$<I{LQaSL`WnLGk$7uqt4<Rk
zJaLHbcC>NxDnTkQ^4aZT-=u|KOM%-gszh7aQ)%wvX)-J~XRNZ+OA@fo#)=YDJD&dl
zO+c_(ZH%c+&#0{c%3}<&$BZhgXj=SaM+wBQ6#oD+KGSl4Ay#p%Hwy9e+xs@8yBX&u
z<dB&uh|1(I`d0dZ+JZ-8(rc>Ll&FUz%9NI$nn7RU--#dq7Xu7y{{YH|vG~U=x5JkH
zvSJw)R;s3MJk^<{tT=`ft4m`=*;W!33dX71{=Ij1M$Ux+S?+LaieL%&qzgukO0FTP
zD8KRt^9Paee2Qq?!|Gerj$EUBL{n##c120l1KrxzQ>fRtD(jnVzJ+F&GND1mv+xEz
zG@c4dA?yDDpUwa(@mp{PZC3J5ib5>0nL6lz=i|ClTe}h5bVW{^Q~v;Qsn|qz8&KdP
zN1MNy-(2!e3*~HL%ZRxf6qlajw{=u=Ce_g{Kc42ER7mbD$F*C5t;ba?Hgp4D)2a53
zovlLcl?$3cE1IW-4{%)e7N^2FzYwmmN?M4Smk3>B%;Zrcrlxx}&c|*`VkmUD%9&UW
z?g|S!opjTrwCj46OR3znp_o(0n2Rj5qnKwrr3BnRl5lwV<{O92#4;#x;y+<wYhcVf
zpFF3>g@kw&4e+qq5ViRdp4yc5*Qn@h8;HJj)k>{%NDOFDfKA5{^%L%ZYgDH1C~6Qq
zPvH$^FR&axMTcBc$j!4nL5~FG*Ugm+CEDD%Q2Ze!>5<<X6k9;rrEU8C&b?WvZBO-E
zQ^-ipSa(9ok0c~M-o3NyUN?dI=@%^bR`-Byv7AaHGuyC-Ub7bVe5J@+5#wCIbSepL
z^%NASr)qUNok+*8_UaWcHNBdgbrOn*N=+mu?}x0tEh+)w1e-Wj@HtN5$v(zLdaIqW
z>FmmX<X4EQv6mt+X>!#C9~}vCm~F{qp<yLkQmr)CtY3Ywwywi&!l*%!M|Kp&qDS2g
zjeS75!9EdE<}NeLvK~0**sA8<JgTURLzX!zO~e-9TUcX}%Twcs33758Zo&5>sIt*Y
zlp6!GyDP0TqpcZQ-JXL*cQ9mhf}B7FFybcxUbwc24p0}`a53YrRUyFike74ZcI%Vx
zbHCa#7?n1S%8tz@WrsWARhm)cEv*vkbXh`F5*MNTfE`?${?Aa{H_BVT@ZWAW)-|S>
z1zZ@UmaNdMmpGgM00MQrr=r@8cdX@Az?mUV5SB##JbkmVb0|$lIgH)4hsaE8sZ8Xa
z5EiQDEP|4mP}?OwH`Ddd>!{POp{V}={;Bk3KS<WKxM!^0KxqbAi+ISZOem}NBXJIQ
zr%{A9M5*^iqkj#at$QKsxALRumA58wLSn+n<z5J`v2#@?!x4zl*^?}UyRM8GP3ny|
zC@b*?L)Bxff7))C`<mKL+I>K6o;B)jk><b-I37_q{{Uaz>}%^5kntouBd$N?I|0DC
zTi46$JaZ>!9nA6PEb=U7Q=&6(n-c48%Z~b9R+~(C!8-?a5;fH54o73TQT0REK@Q}Z
z;oZUweU(Q7#|%FYoN)W>2N+jpb=<IdX8^j)a;$e9nLCdu>0wyfIgj4G8bOaS&)Cp3
zhqf{ctB@3y%Cuir8*0}LylbhvHH3u)0V9O-?1l8h12hn(HE)l-oArnOopH^kU6tn;
z)r0i3s=Bb7h2{PP%T;?SeQ0;~C!1Od_Y|!vDI>Tf9)NYN=&E!U8S!tva*kN=7zqXx
zuUB)KoZIU6JYv+GgBry=9@Q3kc^byOF+XQwCRpAo>!|ZF9Hmm3nH-%}s)Jg7qokMH
zedBH(T}%dQk{nkY&ulidt4y;<B}n1I82l#`p}zL_nSGIuij1R*^O}o4-!iLMK4~!&
zw6k2`W-LdY++?Yjp3_u?q<~Lt2hP8BI`-Pk{{RYxqg+1*gPIYj<P`IRXwxr8<EQYP
zbZz{8<~W^)EgGC=TNANt>m8d8@?>RvHX1(}GumN>o7=1D5nWRB{*a|=0X<m0){6GG
zuVug}_7&qI4mtPb5bg-z9LXX_=hN?o0C68{{j8>{Xi?&7zq^$q4vg4pBQL{LhGRYf
z@4aQj6?fBB9=?Lwx8LPl`UnP;Q<(^{Uv)h+Nx?7~38bQ_!!qPk@_()Tn^kEM#_)Um
zHdtmt3yF@UWRO8{I)5~+D?_R-kaqpM4v*dFHTHEWkW)!Lq$H2UAkC`aGV!ElQF}pw
zf3<i|A9AO$-ojktvKqzb*XNh<>g$rVt}T<UTDYfPU&lh+j@e6!bf_ex>?s?5y+qCO
z;?k*QL8*>vmtcyBCnLb{l%Sz%(`d&D5$)VzWaGH6!($+mbq&eLZA*z2r`GIt!kE@f
zht;@_=_pDz>Io{->(QXRTvGsm+|dfIUK7dzsad6fwRL;t`NT#;mAf`YYl6k*qzQ8i
zX?JIwp>f?oN|xS)?j(cy>#t1eI^p7=MQn=q&)pEyEhwbwoV%jY>OJ&m{>t&I_8AGp
z#JM&R=3W=0v=|RpNN-;(q^-1t5)-O{9r}lOv#e<O1_WjDj|JFpOwg=pjN5q2_nQ&7
ztI7WW-Nl?DQ*$j={dAxc9?2}F3H`aY&<4}=I+OMNI;{1La@~@e{Xyp>nqrX_)Bvpf
zln4a>03|t8n%k};aj3~uR^nPVrdAHpcd@Sj0L&iy^zHWT(O+yHe~SFhyd$mApwvUc
zGKU+mTJNF>ZJDipS~N#;Qk_%SgQ*8VJAa2-Tj(^kNF>0luHX@2-sSEU<s37FD6;(W
zrT6J>ps;B22PC$)VzQ{tEJIT%Dkx5_jS7$GG#csBYYUxqfu^nnCUWE>n$-f4Abv3S
z`!RiEiu(QQw<6!hi6)}F<LG5k*^re4%f?E<aJ=yvB`xX-eySP))@9S1Ywta3Y?4lA
z6mjJi3!1`>R-P(85VrCTcggk^I3_K}RBTpdIL$q@h?BetZ8nf6A{~MRbUY6C!dOpW
zpQziZJ!+dfXkYE^Xdt0JA`)(vZ=rBYgo;9yBQfNxr#q*E$aZ&kl#^_rM6*n>CMaA9
zGFolLwug41y<2dUtFY6#=q=vKjJA82?JjFc5(h3A6WR=OPLLHi!&}X(uH<~Q(3;<c
zkMX5+db+)~5!R_JZg;^I)xKX1xVK!_R1!k`iS4M<8R;$Jt(CZIi=R@dE^2}Z8LA*7
zjDQfq&2c3}hX{wrxeF_IJcW)w79?Idb#21Or#Tr+M=sUXw1${)zVS;%EvW@)+)v~Q
z*Fm6f>8nefvDaV`b0X%C(hH9zAkKNs0E6vr9?F_OM--V(FxLBB%J~)l0Iha;jzf#Z
zlbF(Hv>qGfEs5|`BEt^3g4KhOrI&)FIEe2C$VyxCHXK4m)DD^bmFf1|R(pe%l}3jF
zJzARL9J~UMlbFUlzYc98-VQ$qXTOfV7nd{9?{F=$9A+jOjC$LPtm}iwRA(+C%~hQ{
z@sJXoj;Y_0+Vl(DpBjpQAZjh<^=oy%=%Z6x+QOw(JklOKK!%UDeJ#Jt5nMhP$}w8P
z=M>{i!yuxunDq;-I>WWBN3phy5`!JF*->6kZBl-}`?|YU+wQNe>C|8j2tih`;7Z~l
zUBjC~sT1Wh!ZpMA!{(eSpWn|!@|tc<$ZzIC%3-R<7Ou6wwRM#{X9={h>ux&wlNs%H
zzBg=AK-@G>N^Q3Ls|$BH(`_|-aBEt=052$F>g~9u0+LYTr6cr(_M-sCsrY}`T&i2~
zT(5f{zGgN$;+qjti4}pxl2o(?l&MWA#jC&KH0%dyX>By<RXS5haY4hg-vA4;;0AnS
z^ZoWekU0~Halc`5ygQa8V)+G4bd=4@pv13rR#D}&q`h0RV^20BtiR(zz}|Ll)DzW;
zkpiVQ=?(?S+0V8Xv^DQ>Tmdi(;ct8W(rb?}IMhDPGTc}d^-$}n>@i$oTXCZ`5vG}I
z$b>NB!)QoOt2&)KoptJox^)XF-M*Wxnm}=yye#}D22isGo~=Z3lxbI`-p2b?$i9$!
zL4?1PW477zlPIpJ=QobVX1$DhhcL5l<(qbxoQ23?b0)-f0j;GWJ^ug{>V3ZI3u9ib
zHqt88P#yII2!x3d-yPXoI2>|4yx~FNjJDpjQm~fuD>)b~i}T^+n1xM*b{=XQ6WnDH
zqZJ|3=5fg@a5S}{D@Z-S0Y?_yeIb7JV;JXY^A@Qj1XJ))$_=)wtddWP`%XF*_2ZRm
z`1hB+WUHZ7mQ7JQ?qaQSSL@qpOZe6DJg`Q>*i3@MB?@sU2uIxNtvVy4{{VM+V~PM8
zh}ROiD&dY%-RoRg%|vnO?c0(w&UMdnJgQ=9A@XFaTO37dcs>@XFTVVC9(j_a?@2$B
zRrwTwu7vfm^u5hT-1@DQkn+pr3vR82Cl=zX*^j;!>`RZVYAyKPY~*iRD#_-RX8{OL
z$3=RcWeH{Nr|{VDUfp&4zS{L_x!tP1o0>q=hdy%VV0ulaUO?g8xqGACYUd8nSlvhE
z8jC7!KxX!2D>?PH4LKfbvR3lMxlKsb!?C3}fFqQj$S4!`LtUG#S3J-ya}h$~m>@ZE
zn!__%o9VHpKzkGNgALwo>z*@B8fDf*yDuBh$F9#IqI{bQnC?5|aaHwi2DT(DDWK!7
zC<EAb*HqhX&$*X5)CdRr3IRSjlgETjcXL67uOxyn<1c_PyYoF46>>Dnd(HrpVVFit
zR7fvBA=KK{zL)+xik8F5{80K`2UKoK2GBGB>txw?3!7?gW$HC#i6WB(B)hXhusus}
zS>B~7^HfE|MK9HyLTyj69AdnKj~>Zcec1_#LnFdVi*=V!+LRtr5S67`5#`VwJC3b)
zw^XWII0q;tGoNH84bo&({!sN^R2UxnVyxHV$->>c<Mlfxs3IFm)Awf*9dJQXo7_@>
z58t<bm32j{PRB_~`N{VgN1J1v>%9&`i~>KB_^n8=;z#}<l8`K0SLUPz6*n0~uj{7m
zI)m-SaNBnQFEGclJG}(eUQmkgzDtSXoPgctWrTmcV#i1JYgu*Fc;qC98agD9w1NRT
zgWIiUh2vO3AzE=Chv5sWQ1vO0sO*p98fEO~BVY3utW_|pu4?M(nrX@JRK#&_C4UV_
z1&3V;+RKSsqeQJhsDO~4uSU|fwhdZRQoWqHLWi1-tOJDogaf(0vl5-?j}c$SsIrTG
z+VSCOYU-ydBcV~BVbvfw>f8FK@!FBwT{_JAMzh<yR%4u_%`f`D2((`X4Iq0Y2JtKR
zGOB(tn(QC<#kD1U^aoPFvjOjb(-LF0NIIqFTMAfHV2w7CJ9TT?EqyDB)Y^!lz)LWA
zWKS5Eaj)vpV~VOLfq;&1>TfS@nWmFII_$+{r=FgrwxFa%Q%hvFpC+eO4;cz4Z~EzB
zrsj$uyC2RGRtZpn@%P93QI<->^E!O3xDl=-&^-=gb(7mKM0x1!p+n4#M(q!N{{TbZ
z?b6HLrj^C9r0Fz*2^gk*i<}zj$n{11VVKIRS>#LX;`1wr>uaG*D}1J=8l7RC^CNt+
zrWreeUz4b1@~-Xd@^?>RM(Nj4vbUw_6l0aTu_&kkJhJ|=)14=KP7R#rVRy(Ll5rO&
z!<7*=)<HEn=06Q30h@e6-o~yYi%N;wTd%N;goNp;SGiiKl2r8K+VwqaVu7w{dwJ?Y
zed`V`>Id1djB|}3{tdYf-z@d7`7rg3*ev8v<eYIqneqK(qXhya{BtXY#OK(RVz$u2
zi!)HAD|&yYw|}axsoO2+?k44+3Xg7*Q9hER!gJ>YSlzy*zJh$ME8-)cUuHt2b5=zi
z{f;WSQ}D__PQme{I?xFz>{2w)AHUbF8>N`adwW{Yf`8T*ZcbXW;32dAD>GTVTkq$r
z`K$&TnEfVAMzzDx=;KaXu*%RhBe_b*8ur)f4^{rVt)p$!m_5G{II#3y*2~-9NzT#>
zTvxHAi2ZB7kb3&L{;qN*WsEkaCVLVLNNxtz<dED)-EZ+(0FNLW&u|h+P$OMY?#*ow
z(ut|Z^Za2(+8pYV;UAr!zm#^g_@A~|n^N0deO^8X?$TOs$tF_(%AS;j5R{b=pBl9M
zK?A<MH??^6=*b4C2sI11p@a|D+_#M_;Ntj43|$<C*0UaiFFc8mA#vSi)t1}y7;29k
zg-1%1Pyy79H6-iROYRQ9C_L4u90Sae2>8k++iC)h25B12{BH7<eQkdvM9m;qQDONk
z9$3aQdqyNXA?A#x?4&ZF*TqiZ^4n)_s~=)V+p2X+45PZtlc|lw1o}ba$_t|Ns%eRZ
z<JNX5t!g=+kg{v1<zuv0GZRCHuDzJhp;#>t-&?A%VPVxg@Id~_KuS^xQi6LNPwy91
zGTP$Og}VO$A^J<mKcaI^{Abw&(lmj1Q;r;^oNG@Va$god>^BSF*5o$W?3wcEt8vV2
zl~u&Dj^*Pn(po;ab*<PkmAx9xA-&qR90fp?B#yY~?dsya>#I;{6r4*|cwvFS6vrPJ
zJ==vBJLx%hkr@%~m9rV&ALRT~gyHai+B376`Ft5mb~0p9*{+wvEh0>pQ{rMm057&y
zP!@z1^!xAKBX()h4S7DJwCV{mKq!6l$stDM32+3-nv<}Qque>HAzW#bWf<;HLtT_W
zVOTC-TB&pv5tvJlOP^O_)Fi|UNBlwN(zP9R*rG}9Pg;ewoia6pIfKb2JYiLOgG!&O
zN5}AmN8Jjlc-+ltUmwcdllCwkeGWcdE+WC7DwN0K5|+W!KvmfP0EbL=YbutetBPnX
zP=N+H^Nz(v)S})xk_7p6Cm~fgkGFRrb<JN$lAKoFORS~>;X_}EK?-yL15bh!Rr>z`
zkAHS6s~XykARHQifC_?VKIAdo%{sap>L}DCsen=O2?E;ek1)k&vbe52O#3BTzSi`O
zTm?JAn<MTw4*F^V9atS_XIwczcgGl4Z&lQt<tdafd;>WZ{L#mmgq)UT8f6u^dy+*{
z5+$=G#++qtf8JYDYSl|gDNsLi^&KSYjmFm6j*=8GjEu9C);+XywVbix8U(zZ%CBZI
z?n}MN+|8#Pa%>}zOpP7^Vmqr>i3^VmAf>>3iw9x*Yt|#weScc5i@h)^QxEdB3Y>}I
ziIm{_6q`-Sfg&e;ho8q;@-e8Hoqx=t`3hxMjjBo=fVH&Ri;Z|f`zbB|08vVT>4(~G
zucdQRtpd=;Ni|HFktENSS;t$ADT31}!gphU;@Eb6TH~7ORLsYNAl6t+akrmtOD%~F
zyyAn3Nd)K!)EyP6NCQs3ilMn%fJ<fslyQaj_SGt=67Ue%PiC7l;e6{Uv8agk)ubuI
zk*H#_$|5^H9Bt5S6eGH{A=0FwWT9mwli5HXxvN^UYBsw9>PEe*B>v&dXM&7lp=iRw
z*G;V|*Kj}E*m4jl<s5r8Px1N3Y8iVIv7a6`^c;Wo#@Lq9rAm^Nr{$&6rR`G4AAr}Y
ze@|9xcPft3pH$~L!FLT*Y2=;|qw%I8e~;m~ersFEP-)v$g_Qhn;mIGn)m}hpQPi0Y
z6q1xU7;Q*U)DU}t-=`a<;3!lz8W5{No=b@Ff^DfVvrFA9d+<nu&EoQWeAcs+rP8rS
zWpNwM+~};wZaQZCWi;Z@!d9?{Kvv|P2j%%BbuFh_Syu(DdtCOJfN-3N_T>uArk4;V
zBge<C+qcNrOqwcK7x!s$E3jZ&pg&q&ZLQ_$VZstxWF)$>y;1^oP#_Rk-`WeSQpY&8
za|U?f-yAlhSx`A3ua9!=MNWQRg;1QGxRciPWu%5u{CRR_OG53Y$%g6L@?|iW8bTI-
z28u^zZapCC9h#%8z^3rVFk!{OBWI8YEaFNPSV>Te@b=CwIKEnIFy2GsDhY1O<32<e
zRv0y8r6E!(?jc4BmkvQc{;J|K(t#bFN)Sios1=T;+H1PKw&2nG)JSX7FzFIGFN7as
zRlaI@6-dzk0N~>UnUs4U%Y0QSuihwmSAuymH_nR?&TP99rJRN#*(<`{^t)O%lCiZz
zU$;y8ilx2zX$z}bX*kOmmcSM~gMkr@zQ)eDw&a9c+qRY^-`CXHGZ`A8q_<%OxnMRH
zR7n2keN;}m>UzHPy((?8M$bx)aw#|)b17L2<ROOsHSMR<d%Nqj=zb<<HIPFs2a1bC
zA>^q+TN0!FAm~6n`U|Y6G5d3u07MnEy!!GPN9-N#)mXOU!t8JR!|>+At}%#Z32a-*
zjKbbij*tQn*;c>j{vBr>Rc6N)ytx|5C;Wh%8?-&ZkObZGkIX;$2j+SCuQ&UB#nkee
zosL!`E^alGPW+#q{{YBbzbD8b`7~)E2q@4I^dDZFZPkf&8mH+ez$8JqQ4M>zq**bK
zLHJvZeMI%+n_b84+4i3)Zy(64C!*!lMfkIzIXCv_V}?}AY&!^{#}nc!3OaAlooSoD
zU+x!M)oUW)ZG%Yqa3FvPDyqHEZ7sHtvlU235+Wnk+eT>B$hf9QNddUF*I8q(NMdWC
z#!RF(Ru!>^l$50}D5XJTT|Sz0!j**!jnbKOikd=QffSW6vGrf+x!_=9{q`q_GG9?W
z%I92vjicCdB@HC{t6n|FBuR|jYUwgsO81$$f5fnt{z8_J+;W||C-T)v)2y@ZO`hAh
z(WgS;?V_z9xB^`51;jC@^nfvNoX{job!ZsyMqnP*6NZP?Doooq<^C7KGJL{5OUldS
z997(Q;wy<magj38I}Aly%V}v#YxC79>;cpD=|4vQ01~~se}_%fsi_F>d6`r>EE{Z|
zlY_7m?DjCQdpqmAPB``!itCGI%F8%)p#q09l^NLfZ?j<!7-k%)j{ei<V`HzCsxnqm
zqNdy(fY+_M*5-{%5I_8&HF>PhbkcBD%?E!a((;{2-ShcEz}{(UF{yOwhKaa_F(uW+
z@-n1JaL(S-jj0OJ#>=5ZBp`wcKtFNQjk9^Rp;R!uYb_@)(kI-UVxxN0O;VgGzRY9N
z^ZfQ5+r#0BG2^zm%Nn32Bd@aHP)bQU008gX{Caxssi$T<r&%pB99B>RYY^f9CSd!b
z4%#gx<z5F=!!_n!JlnBDt_EO-QtY>7r^;Gvc@#XGOOAe8cGp4G7KZm$-_;{n)^!wD
zWCWDU3<Q=Wz1~G|*0^cX0K<e@E~utU#OyKqYI=~D9&Oeoq0|&aj)f&!HQ+$iS}SUl
zzo6^~RoWdw!MOhbCX1>C1R)rc#ZQ14&0xA+PfC@esJ@e2P7We%%|Qnfgw{NkTw9S@
z<O3wev8dK{aU;oG*6ZXUww!5b8zgMiB?@W6H6bHj+VuNx`;Tg9npciG&-XTD;D;kD
zBg=i#+0_k4`C6GbJf-oAG|oQd4q4><a@q7e<3gdh*>$7HjS<!yi5>S=mX#e^IN3{M
zY5I}aj>Av~P;|!Ew6=u;S5kp86~=h{Bgz}K3YP`-7eU}BAq0rLCCxmg2AYQst7`tU
z8FZ`2^|WZOcpV-M>k8TcNl?_N{XV@?YyHOQeUv@*T;^1H1#}V=WD$L^f^IM9*LV#2
zMtS$cKA+;N-KK;Khj7|#$;Ot$m38X1i7C_}<p)wm!{Jg8l8~YgeL(I8y-=(_-R_R2
z^F_5PQ_`pnGKBn8;ukLnB83`ZuJsyAvQL~5>A#Bq0C%e<TT<W{rEPU?SQd<eh3nYh
zsdfym3f*m>6r~{^T~q)&d-v0&cK-nHM@|>|udP&7YW+0)qysQPD5hXUmbMLbG6^8%
z!w-)%i?qMuOWSA|h{Tgej@~A!IwK{>)~z(j@u}pUvL!SY7D7PK5Jtaqrj=`7_dlj8
zU;2%$S&c4LEh*p%agt3TZCg6}6l3m%h<^`0?k)t&3|9ndwiR00ZXP`%;<V3_wINLh
z5|l4))REmzl${2@UbH{|0JS<UqrE$d?s|#1HQGlmJ^+Z4+RCGfy>QFj-Nq~Pzlr|<
z<O0@HBIAT7I$BJ&r^;28Qrkk~g)kl(NGfxBflFj+NFS$8_WuC(+n{MMHl5R0*<ja&
z7@<03nXYhsJ9fQ*6%JCN6$dDgzy3LW#lmqP_WVCiGYZ9BMyz7mOEOV?1#Yt5vZS)M
zmNp_!i&xv<v;navZlkM6{{UxtO6|h#o#i$(0t)JBbmSC|2}FP57KtikMo}q;e->Wg
zNU)h*H`beWV=g=*naw*22yGK&H2dlEyCgKHJ~|b-8^H?D9W?{0KTv<Qoi<w6Hu<E2
z=@4Bo3P?8vMCCYHPST)pl%l_!e;hvgN6O!{<G)@qY^Ya0)c6e|7s}BPBqf-I#k5w_
zr6>hw#-pN1M!mXm(%<aAMbx0tad^s4L^CsznH&PjV<m(C0LHzpF9b;nPJQ`G86V=0
zCBeUs?|I%&y<*pZrenC})pc|$7F|RUU6o_f;;p$2FkalInwU&x^dV|c3n<&(?R(U0
z-mK}}?C)*GH<`J!z|4*~P9E)4sXDHwl<mO(07y+aPtz}DeaqyGkC=D^g<sA1S-UGb
z%wH_V)4H`#Yiu21l`_lA@}QQ=0-7KcXn#Y~$9?bVUYmKcytr)}i8;-1IfYpS{9tX;
zgB@6q6cHrloEd#n{vbWw$8!2EY2=<Pu;RQc4wBrcc6Ki@vUAP2lG6!O59$N%ZEJc|
zcIryDfv;Kr0Nh{p{{W<@+qRVop0IfuoEqc}IFLvHo?Z|orKM^$1KiS)`d@n=lTcjn
zC5_$NGIFdwo`I+GI92W;$&ucTNV#RyI9=M=20p2EUvLx@Gz8rDE$*Gw2GphdjXF|t
zT_FkO54Nj9*P%K|&y;>$Ny~Bk^V!<`igq|)W890HwEe|Qf`(Q5ZKbLe;nlK|hMaBU
z+hmZh7zbSry*KL1Ys1sk{Re5R+D_6!NPuPm#Dm=mHyVxpOOk8GI?%nH!<o!E_)MG%
ziuW9eHK>*p(P2Ex1K=!I$4HjYVQv2a$qXk>+Y`8}Vbp&lZ*4lyYN#$Bc~O-I>Qbme
zoK!k_5P3wGF1Tw$UJ4|kQ1=st{a@j}4Cbu&5aP^#jd=x_%D9<o!|u$G;ylqINQlBD
zEyj@CmLn;!+H}x@LEfTz*nYwF&sE%YEgBd1RVvYSC$mZn!O}?rXijBDc|bKD%_U{u
z6s%+UO7usbujmt%aSVJHCQdz1S!ZW^4z|j<)^XV8JU0{M1hN~B3n<lE5R{!Y)O2Uv
zf3+QK`V{Ih?sMp~LeqPOr8trO$cr;L4yN@+qgo8KjB+sV@Rob&Wj8bNFE?Y{Nr~K5
zVYc-57B~3pXeo9p$(EUkb!^9$(?#SZqOR?dpQ-My`R7CRCsFM?l@YjBtLZhtSm$B^
zLnI{l&x8=#<>EzSEbjRK04tHmu{j@zrdDHi)pqE=$uY|Mw<6cs%Vn0U5Vzn*M~JBm
zrANv%+^*#s>Q0fef3lZ0cEX+5CB*=7EkUF!LgzeJjxh0^M#BA4IH<sRq<a<vJe9<_
z!yInrH;UmZsm$!|q}t@P@*A;TORPAuwqd}JEGxtk6Sc)H?aES$kW;RK#b3D;cMZ^P
zCbL-G8g#IQ23}%E408uCkdt<0vzQB94k{0}9{5NzFG0Po<Y&>4;apVPb!%;s-VoEu
z6PXUAIHj#m2HIIGSqV#O?0^C82|6Ct{>pTA)&&cTqo^<L8MOE*7-B{-To$(tojIRx
z6ASCyA(i8E#a}7a+woQHdw@91%1P3rgeBh#ig*FNvXh`1B|!bO>i$09T3yriEF8<K
zZWxM<2L%a{@d*lUE7UL4@<AMZy|}{%S?cd6N3xA!#<TIxRjRj7g)kMmtK>vlKv$YQ
z<1sWn`|VL9PTgjAUw1Z_QY^l0Yge*s^`YeIW!~{P9gVN48bJr!H1|Pb2c|hgbJ?e{
z;e3j%r@(ehtV<)HeG}rLYSn%VFE*O!q>Zj5AJCmTt2^&~tJ$ud-4~I7txBLRJT)~t
zW(kJuE^E>BwE@77oER~`R`^#DgED?;2bgiFHw}n!C7L*I#R=3pV}(U8w&trplJ!Uf
zw^i-O?zZ=M=04n6J*{yiDiBPOMxfFPWjHugv}=L%+}`B}@`HXAb?A;2YY9<R$oO>E
z5|cMRW}FJv)|G@U9}&{>v@85df{IiRbo7sYZ&6-b=`^kG2lkq%>4nH*GAg1cwBEMr
zXI6sI#%bXW-w$2-xyUxw!wBZv%$3NAZdKklE!5RUlv+;4-(i**Z(#@{P|`<nsVBEs
zZ&_8k+bC0Y-r1zg1E@RxlHojf_eGY+c-u;rvr!X5We2BP;Yl;0N@eRt=2HYbn6UC$
zB0l0k0HN@gv^#ez`-H1f4{pOhrPVqDy2YS7iqGUbV2AG3pocb+cbJICIWq{xBQVrV
znN<n1OKr-NI_1`*r3CLKfXY&~`zY=wdHMiA>1A6=*VT)y?Lz=0qd{?A^Y}tr{pOpU
z<pH4ck4`Pk+(l;On6WHm<g(V3Hp>xbt$`UEl1V|7ga=z#*KsRRApJqm^&RHLxLdFq
zw#;WTzW_=V$s%iRqM@frXeWxrmPfOELfyP<az!JqDybvjI&R#pj+d10kzw}Kz1z2L
z*J`x;e~(k``xfU;gQ|*5I`Q(C6iFgW-5pcvN+6c$3-F5l{{XkR12wUb!jS@KZ{j^F
z4Ag9N7l<lS-f`d;pwNw=5!{Zaq0#%TS!j?L5ac5q6hKvajfDVc_V0;&BbxE9LW<is
z)#u4Wjt><za@t&!KG`Kp{J>C3`vMcDpmsfbadCCC0^6%fZ%Kmi;624Z2x(!|EO7c7
z?{3&VMXSx5q;YIlG#j6y{Oc=jLyJqB&ttn`+u27^+d-$-s=nd(cWtRv8EH*~NT#Fj
zCK^=UT=w~Bur4^llkJbH7)P^eVg5$I<3*PavC7!e6%K1Ip$nF&NPp)rvQp}IDJefq
ziqlW&(?;k&_G<HFb6IKRq6(HZz^Tv5;XIf6!fnpu)Cr|Mvf&FquY4oyAEmhMZVQ3)
zb}^7~C3>X1tW~HjLbtC}sedW?NcoFCWhAKfQ>hvg+pR}>{{UjP?f&K0PPC~`>FGCl
z>A4z>X+W*+207X{>zf`99{6mt&u_Taii)nH+nNSn5o&2uajE#r?X=6SBVFY+&pO|Y
zDpHg*`=6(Nlk8W!<->>;Of6MWP=P#vdWG(bEBfNytR7~&k`SL5{{XY^<YSmKULno+
zqY<&kEU;|K3v5rwBS~f~)|qZQEtaEv#{mHeKuHb)H2Np4W2gS|@4It-3XJsHqsZ!R
zdT>%W@*VJ|^RB76!OW)F1O-fUZOT5pWz#ZC9G(XY&B!r}geFy{Qsz?Yi+yM!F6B#x
z-;Fvpl%*`817HJBzh6M~@83^Shox5etgfk}(Hs>txUYFLiY@n0Tt1<xrbd3oG{b~_
zw9oj52E(u%mg>@dRworGso}+CHP%lsls2g03Y9XkGhA%8;+5k}#A&XBtYfOTecy3$
z6lyWlb${G_x;L={&~RNQCb#Q4{+MHi8874bzytXg<$QP9Y!8lF<C=`a7EO9fc~(C%
zjzx<W&xaJ_a@ny}f{8#=ib|SDDN*mJBTlY=Wj6=yS9L#^PTV*NIhBukwar$NIs1$a
zy>FCiG!`_2!y_4Y2h{x5wz(Hgay<=2<H>L<6}M)_y3H<^fIvidVXdWp1fAjHkTusr
zJN+|b_b+L`X={d-gY^dj2<-=sNDN7~?X>PGYY%Hl{VphcAc4kMPq4gOnI^*z<cvnD
z)z^M4>GMpLOC~<lyW^6Ni{e{nZq<~7`3*aCv#XiXJDr$i$#a4$Q8fd^6;OCCP|ce&
zSyNA}z<8>U6z-0stfetPhhx{ss=l&lc_YS`HY(J%K`JTU;AO+EgI~*CeuuB(MV&WX
z5a)-nhZJeYuqgLLk5)(_C!Boo3v6@uITlke$67?Qq^Kg%{{V>NpIrkEzWPE^p{P&*
zk@x7$){SPgH&}2Oc~GbPfCsr_nn>J6Jm8ICb7aJYyAqy3X(P(a#79|S1xW*NQd>`A
zGyo{|P`0wBS~WN?0%!4wZXHp9Q6K@D^2R3Q$k_f_lNC1J_WuB9pHJqBrj~aQQz^Zq
z1s!!KL8tn4r|i8kerWoX8HNR~LO=GEg;lSb;sc7O5#az{P2;$^tE^b@)6j8MON!uy
zlT%2xtaX=LK`2V2L@z{fCr;@o1pffp)$^q~nbrW)ybh|43d(_x1RQ+MM~>BiF6kPM
zRutwJ;em#ai=bsuc)E_WC7VNMleE%XpKh4YS&KQPwf(iJsHlqK96%(gO91QLCtZ4}
z?_EzqmD}5F`qZeG6QB}G9A<Sa`Jy5uS?P!RA*u<?Ne_fovaAM12RTb)jwi#muPgE~
zjpPSvR^a&y*1Ge`+6uMQZ9hUk&#s-k*1G+g^%}qsC2B}{dDug{%q+NJrc+4-a6cmo
zFCg-MM@1SwU1}%iI6sku&%q5uyn6kjRur=7d8rWA8c@?zB|E;lj<sHz=<9oeZRu&H
zT?zFA#aeuk3tktQDGDxcola-W-cmjJN-bDM0qYk!G@Q#2OL%T*>#VrtCQ${r35=#1
z(N4A?mYH~w^&?TQ=ub*F{-^5BpLd~feOe)W)J~;Sfz+kFnD)f>l&$Ld>6ARi9^Mgr
znd>%L7GSZ)Ij*9vBy_wUks8LrJI%4GLN=u`-A<bKP#;6|>agFtc9mPA;?kqZL{_wg
z&-9MyBlz{2Wcdzf2#JBfSMc(-^7}qm$GIZ*ZphXXZKtB^;zng3f@3CRW%#t;qO|X?
z-=i*m<J-Q^`0Tc;Z%ioxjnJgxT#gINDDs`V!?h9|PAfkMVeD~VU?f%{%Iv<G>WC+6
z39oX#D@hx-Z$chnD$_%+*Xyt8)_gbKoiFoIcs#?2J*eY2F6s5$h=Djlp~##U%yx1{
zM6Ow`ku}2GPs5XAOk=je-KrGSkHK5_k*V+2tJ5EF_DW6ke~R$Xq!8DsJXB6mUAeTa
zt5&~+FS0#(=SNb^T0B1+xzLcrw!9_RoY%6)z;)oQ0sTMIPPDooarOmTm1{SVR2;m(
zduIYWZ?1nx<?T3*t;GG5;^|P{lYy$>GT~gOp~kU}wg~zHrV!fp>OP}hh`Qc7TX$oF
zYv`1<7M1QKi10e%i39^LZwNWZ_TQ3x5x;Z6F5tZcc-Qf4?wbiZ1t>4%Z)rfN_XRrX
z_3DFL?B3R=MQUyaerB-vA`#;Z>2LKK*@B~=;|)G9?2Z+Cg_PQH-PS=a5{u43ivH&k
z=^&&iw8;nQ^!jP_?bbuP{jk2bzWuuN*w;x&l6RPUM|@+MFicXe^G*QGYo}Yi#CJ6a
zinM;<iPGGQA&{Ll@ghV`i%zGoM{l;B`mtGTT}5S4wAph_$|a;~2egMMC!7mftqP4$
z)E%)zhlcPbRV9T~<TCP{e1(hJ8ymPVEGvg#pN|pcGvyknYLJBK`u&T`jq9ka*nLWE
zrBn2|wA|*q{!Rd=YM73ll^3>7QNd;-%J&BP`G51}S7DP{ZX1OLmP>U-FBXytUDfGo
zQVNgJAf10rI+4F{dY0cyUsb9{)C=UfNvL~ZZ{X8;@`xNtkB(sSB~Ve@Qe$u}nJua5
z5?2;WjxTTxzUwmFLck+I_-Whhdb821b+|NEs@jzt(y|Hw;sIzQ#e1M9e$%wzquF3%
zmp@Swy|ywqbhpMK-}~C=tF71x(CkWNFvBYU08-~~^y=BNQ>^-{MATybkx|S%{G^fY
zfG#dTVifHmeh@RN<s2^yv3AU+Gx8R9v0YwdL@|L+)t00pLt2sb8}$3=e!W`ndPe^K
zm!~i|xeE4>T7BK{BX=rbsgWEd@sB1^mhs+lhGo=T+SI!tX>!IIp+sc?PAKZ7Jf#$=
z#R1st)2Viin{(UAZALNRNF7c%a>Ne!oz<z;YP6Bs2gW@#934TJ&S~cI>liewvK1Co
z*Pt--`VAJ8r7k*@g#Evyp8+o`(A3kY_a48wvZg_#$5dH{hY&bq6?^0L3pUg;anqI)
ziX?Ai^NX^=>}e}yKzT|^AC!kYY5;_*YQP<V9rQov)rPOy?Y`Y~J>kQGFN99p`-d5}
zN81>^z~wxf%JZ-(A<Bx@ijf(W%Vhv1I`>+ZLHdrXw>=?ffIaR6;7*h7NaBrZ(=7@F
zSx>Yar-@06BBp|Mb7)ShX{j?GhpGq#E@<Y8(_Y6-I#vGw)VoFNOKMbWyF){}r6}&>
zb*jm<s`knVANlNFQ6ZFP_-xkgS!n^eFeE?y-P?3ZT6tO(e}M1RdB5ww@mha}S*3*F
z;65TGX6$R?3XU1}MHbuH+&)yv3ayoGNVL4A2&jyv)}`(M>ZaW6fA$?dv-?ea#sN?<
z^2C++h!OYd^=gQ@R(p>Uo+kP6t*$~hp>4Y<Zbw?29lU^&b?#1pgVI}%vNbC|$XL$6
zhr8Ip^mlUJD-~IO%-zhfYTFx?b&oi*RNNSn*7R^$J(c5<mFc(j+<(ufbiUWpV|3T_
z>JXl11b2ud;RAn`sp@KKt|AF2_gj>q(6EOi3#M(tlO9{~0DeJO@sz8^rEgB5TBQ9?
zRj>Y%+g)6vixUtXFPA7SyQRaL6{^1Y0!#KcljyDNAFqG?r~~OXRc5`lLtCmJid7y$
zU1$^k0Od$0?oU_RUu(9S^jg=CR#G~Sr2hbrL*hsfz4uoPG6kq-DSLKD_iOG4GF-}T
zzE|z;!_`W55ACtz@6{)89yEfU+W!ErT-tq<*yyypYYyYApKrn<e*19hx(h(=NczOM
zxxXw+v7v7qD0Kt(cOrzg>f9j!EX8prYKQ>;0Q2j|*ip7RX}s0{0MfX4h%$vYxg6#r
zOt6W0*nU@UHOiP*a9fa-EIydavW(e676DIyKdzbr0aA7Sb<p+0cS}kR)cS4{z=o7P
zq<rCncDK}d2%UuC**F-##aUblii-5;ksFjsS^0N<B`rIKiBHOG0#)_yLHlXdlm7rL
zv~yH7#JBrtuY8Z=3huTV)WOmuvYh-3K`#KasGBChScN|w3sbvn7L+;@{YXNPNZz7!
zPJj>c>5UGcqj1d#0OsG4d|+A>T}&&o=a&rP-g8XZxN_&>Hg|ArV(MIk#iA?_&<C(+
zt<Nd~5=Ny&_aF}aBpV*yY6jdknQ6?kO7_VLo*6@+=DC`whc(^0fcO~kLFI0B!{q+&
z{_46@_AYs3yEXULi7q;ge=zQ$YSU7!M!NMi-$?8`fGjlW%lkl4;e;#xP2Ibd(<XV%
zdt&Et?Vmec78$g<L{N_cfJ{j0)Up(W>Q>sdCvpC*bo*)2nm=kbHVHJl5jP*lC_2AY
zT~r!gzyz=#lwEOeWBr||ZOb~WiW|_Rx)Zj1TGrbi@dPDJ_|MTN>88E@omTgMwf!qt
zrAlrN8MM6qFc<T$KqZ47ASYxRBKy0`<~p0ou`DwEZl_|b<x%|5q=b>7N+dW+Pt#pK
zy;4uut(a8RZ(8D?AyGap#u-}gHI`wDb3c@N<9px5>VoA~Z|kiCUQMDxn5tS3w-K(Y
zB0AKtKTSFculn`7ik_vd{ZqkTKX^!vk5bYLseoj;EE4PaztgOn6LqJtRN~WKZC-l#
zbF#QhZYtiA+F5bX75e@FeuJvj-$Qk^t<XpMfFG!~i;sGN@rNwk?Q|o6!-?*JHQgVn
z9ID$f{{Y+{0##@!iYHmjQdET`{XEKuwH-*;u_x=*vcqueJ)D<%dV{gj#{7eTh1ZlU
zu7C#~-{}Fk{7J`4n_&&ROm^Nonj)e=vX=9TAJMe7m(ZjUr)^c(^?0e)o0z887FB8e
zUO)$mPr?VGZ9%BtDr9jn?;K-i6>%d}Q&bq}bxuW5vy~B%y<eJ1YGa4C&&OY(Jq~)V
zi@|kA)Ko*{4m`1F?}A0615v4uXUxHhZV8!Y)%4P1*3?p1)iT^)12dUgT49F3WyB-O
z%Dk%7l@$}I`+l^VJx60>RpHL4_PDItLX(J8Avh!#R64T)28T9Zf$fZ>YR({>=rxY1
z5F&Wg%v4EAN`emJw%b@hO3!^y`RaQ68l|O2vQ85#G{dzOL?2ssw*Z3DJW?a1<(3I{
z0@w1RB3jhf?5S;g)WcwCq<~g5&;V8R{{SAQp|jFM^pu{Z%;l6<>)tu!0^i%<7F-r4
zV#=26^A;;p;kPh{phQB7n>*H0cN93CnrI3}r=V+5V`=Jkl0=FAqI}GtYBcE@h*fd|
zef&pcUl@Tk<-=3#N~u$+bIz4X3M)fH@^qm|S^AOsfAQ+OQo9-o5ai{@C6p2VJdB*u
zc>H4j09B4vt^%anM|xw9?L>)j-Ds)6@`sHI)kjbikNA7{@A`CtuH#qM(!>oDLJX4<
zCC@(SWoNV1sNFhdcze6zO%&M08F6;sBAuv?y3(JJV=|8_H7iJM(V_xApOTM4y0!Je
zN?<sUs1(bzV!VVfqp&rMR<NkVnDo-*m~?ggdT8%T@-pMH9CS9dmf3MA(O(sPfKfX_
zQc2XGrkY24x8Ig6LI5NQaqk{80vOoZ(4`<IMsRzs<l3lM`z*DF)uO_orzF=gCFQLx
zCDiOw+LR}{n{)079lqnLJ?Bl<{zTsGFF;5b<_0GY*l%9)n?Tb{0y)RZE>mA%)O>12
zEW{?^M`^~TSG?q<ZCZckt#2hs?7zV6`xExi_0#rhwCS46s9fSohcyrm&LSff-1eiG
ziNb#<5?$i;X}FO6wm`@4DMD8kwlG3e(o1Rx1uIIzKnmVYnxDVa^=Pr&Yx-e~r0p4#
zpTT%SO7|3vZ#WvfOn4yDx8sxWoSA6>$2^wGOtrVZNKVu^KwBS*4!R&|^w;ar6}JG_
z4PZ6EAeLE-49uqxvgXth5$Llx`*%duUCb;pbV(`69%3TcMvSeeR^tx>wQA~Fkm42j
zXfz;`_d9zLE-hVp)8tnJjHV@mfPLXRVpeXnC^<vO2anG#__edh_^pk^6ia9K+V>-=
zhgq1Y(7=?A$#YL0<rcn(1fe>8k3rh(wXN9V_N?Rqb_bX}`N4nWt?J3fUET3V$}$XL
zcC#bMW%NLl67&uGopEShp|moh$pJc!$|Q|7+x6+qrqywzIiN7`ngPygeU=e!Ot#cU
z2QGf-@=|4(U0bfhr^nw!*$g(~=b`3Ouu6a{LR)pBNKq;7kJn9py+wbs-&Ag@k7;Nm
zA|IGJbATw<rAQM<Oz>0f?~4<*u_U<j&Rto+xM?pm(@Bu~C|<jrNg`8VckQZ)`u_l-
z>0K*VumBpu$s7UXo>K-?x^Zd;I6vA`9{7%TjxoCSCfiHNjM=UbOb28;B`e(6QkF|<
z2rC+qsTu*VM^Wl4s>Cs@01VI!@ZykW-P6U+CZm)QH8O}OF)FIQEO?5AaQ^_E4T(if
z01{E<(IMm@DCkdeKg+jFD;ky5yHf%xPl{xz<L`rQI)2%uF(WnibC0B_qkhiYyPKJ~
zDG=7v4J*j46uk=2l&5NR+BS~*eR_eE2(CsPRG(?%I8}YKTT%tur|pmB5tWpdX|`dR
z7~_sVC@4fJOMW)hp()y=?;0rnB&+S;qHA8!btzN;3{;<f7-J}_w%9VRl9Tv*N^x{z
zmz4J<%9>}RHw|P*aWUeAm5>IdZlwoJ2j9O)Yu@bOkx}8x&EDjWD%;cqhL5KM%>1L@
zHlvkpP@!pC@!XIC0$fBCy0oWW;V4RidylTY2}1X0pnq-32MtLQ(x*|tf)m07c^4V-
zBngP{E;M)a4mh-;Go?dskR%rO9Y(#t@733B>YcId^C=yqa)mc`7Y%qs{C%^CYRa7I
z1j37$tXwGW3P@9tltM=1peiXpU#6eo(YJS-eMWxKEbu=i_s8pc6+tdVOqD&mqTv&j
zVPm2A&EYYS<is|a$y<+r=D-hhv9tlW1E3#Yrky6O(lstXCb2<;hs|K~y6GNP2H>+P
z3!PGJYh0TG4U8o&T1#@!1B+CKSWt0DUh<@%oumR)->pu)#W%N8gMjXm@XYr`p2nph
zt#TE|8TPDQYAYc-IhoU_#f!}9<2D97CV^1?<4mi>P~c@GXrK>%l3eZvoS5Wl{Uo^d
zo&=a>Lgv(xOF=ngJ3AnTt~E2HPhL4o9+By&ZEVn1Hv6gAfE-$iSyGp^K_u(DL-jo+
zx9SS_H3L!ANLi=CS#~InX;IP%rocZ4{%6vzh~w|cwRDK!yOBU`4yC8qK~XWoszLFB
zj>PObf7#R)+oP-NXkZ5hlZZS~XFhRZv%PZ*L&6X<&yu9PAhlV^)a*X<Srs}URzgZ2
zn9D3Y%PcEu{xXb>s4nQ25Eb1z{Xo?AuD@cabh?RGDg_{u#!D%$;|}O=EF}mHaL0o7
z=L9T!lQ_b*xXHSGFHU{6h?Q|X>kqpiID&V-xSi$1>O5mk<5CD6Biy!~<@Ld!txwg0
zCt`EXI<LAVGN2K{EfF$KB*=`}4MMJF&RZ!$99URkrel`hQkH}^P?DWTZGR=5PJ>Vp
zT-tA8?bJ#Pa8gW{iI*t>3SVy9f}j9<Wfm9fc=h~!P$<_`8I@?I{ALTXUJPmD4}#iM
zq_zRtcNFWOJtuul#*Kg7bBYvPF~ukH1}3YtEg>+YFg`rQ3N5f}DN(LfNcJ}>tv(gS
zu3NGT&8@AkZGBPMZ+HZiHWCRcBT?1T#`&##OPy3af(ZzPWhEyZ4*>wTWW8V^t{QO@
z_{;jhhSth<BLa1!Q(?e*eAUO4^MCimKIV!pGPA0SNJ&PDC;EPe>(#c?ZvI34Hv)9E
zXCgWCFsAC#y)mdgp~r|`<rsXRO#Df=&b1Y*BRX59D;_V9ho5g$yb`rBuHUYj54U1E
ze@>$<!8%ZLLIJ`{6?>|eTC_9`U6{oEZU>au+dj8ijVTgN)?9tbDpXZ8&f<5i8x^!4
z>FuD`UWBi|S<<&ea3g{MRPe@s(g<a<>$x7%U6%na&zv3b{vE_zxvpM%^gB8juw<=Y
zAI#FFmVrJrnA;W=tDAz=-$D8g^$pLfZk<Sra$5BXB~KYen{Me^P9Rk>10|dj-s8Rr
z@uEe1Wx|~)KiHP*DRMd?xV13W;L6!^%#aiL?$hh_*QB=lmhMiMxRKkK#}GnhkmLUV
z7_m<&n2!cSLBR1X;3~RUOOeONxyFNPOX_{4t>(dKZwK)SCw97z)arVQ!lv;0L^zVO
z4oM~wKZn8rsj=G!0jPYUk#U9K7Bdxc<@2?bt&}B}5iKcO&ATH&;B99_poM4xb<<DN
zw@hsJ9l?||wSmqUsKdWA#sjOgQGC@hf%Vn_g(>?N7dCsb?Gjr`L*R!4L173=hQHcC
zCtXvgZ8g_kpV@T<;A>>nZ!Rf5(*Rf6gIg!MeB!$rMJqAbaLIKwwJKsY3m*}uS|N~L
zQCqLR+PA13nx(A>9Xx$CpyF57aZ@=@iUNs<3kyAVwW=K^lvH1Oh_+A7ShANIWyFZm
zYuiwAzNNU4(IqXZ;_+<ATDBnw*YP0-y1N28uT$IVHM&|3tjd(`2&#K>i0fT4qopzL
z?BO3;td2W++&@y>bQHMiR`QhMlG~qwC6u6o0(2<}9sZ-B?)JAi-k!6<L*~43_rSKQ
zTwX#m$K4XnWO8J)HXK;cq&E$tBBEO?DmYk9g$s2gqjG{%s+%Wvz4raO_LkVqK+iQ&
zJ>MhTv1_4sZi%6)0`{hH<(q_7PKj4N)Xs$_&8Jf`&6O=^U5kz=wi`;%_FL2r$~uv+
z>)Z7W`OT>2Gy)rdmL3y5kgoRH)~j_jq#h#$Kc5j63ces}-NeF~a_w|f0Q*l(OTl3w
zAzzD(omP;Z%G#X)?WpNK;nkIGhM`SK;fH~c@xm2R*{ZlBlp)U%-|>Pn{dvaVA*pN0
z>?I}gosKYtDYO!;6{_BKIwXC78ueCZ+&k*B6q+)geghaRY$jSsD;_%@HRBjDB8Fuy
z>RSQ8vW2M+C3>S_bT{N^fKH$!YBc(4dT`C(dwC$RFi4bA5b*ZSaN^^q2xuBY`(hwi
z{{R=$F?QvRHPFColH!9==F;5j9l(vKYtHjd>Q8-CqJLlT>co1|qv!^@m#Xk4TTz91
z=}?`57c!*5Z<RhVcaOm~_Fh=DGive(j=0N{>=7l2Pwjjs`>r8n4`@_IiP_x!dPX|&
zj()nq?0OjxMi~r2Jk}jpS{Iq86~-WE@!gd+MG#wZhCNLw#VKKlB3wrvWF>4QHl;Fv
zO41aOujAjh_`cfuj-7jR=~AnuCR#>QLq7iij5^d9Rn7pMl?nHIWd<nxO=)FDfm?l9
zE%|F`!;YCLP+_HOxVQ3K8ie-O@$dIPUZ_=i@`Vb%X1pS-kG&2)!X$p}Oi}<D^PGCE
z_<xfcwT-SzO)nI7Ps(~aV!<wj_*!pkKOyGSh3GW$Z2+sd)and}?pD=s&0dR}R5Uh4
zz!X`O1y>XDh$`Myaq^>^#XlJN&h;CTY@lD?&||SJtugZ!H7u55FzkyYS;<UhkUXv_
zZ8^6>vZN0E^-tXUAGuaw>2sVI;I5pSoMbb>Bcr$6mb##5E)oecS2!0|`nSz+@_Cp)
z><z`q0CAS-;@8NYUr8>u9S^DEhD&89Z`D6jroFnb*87#Sx}T^V=K+}@A|iwnE1q!!
zZY%!)+YR#!li4ESn)+SsH9(DhJ|s!gO>8z|Hn*g>TRMe;Qy4TtkPxLfr0O-(RSgL0
z4Y%%>PrL@{au*XVGsI@S%i#pvy6ubvQ}*tUbsq?3cTuC-%eZx{qNZGR$)|0%oUU>s
z(E?nVCDx&(wow{R#Hk}vN`WMhNoY5HwYE+zsL<kM)FHqHS(jpxoVX+rO76Fp05b#Q
z5?Oz%HmhM)tu-#X6>ADF-?YmwFkX2(qz{cWD5H5%N^}8Q{ReT?XKnj{1HCc>oMwta
zL4ua{c1IhA+)T(Lf%wPHZ>tux)o)J3@_CUcV6C)7u2XEtn>KuuI;5$;hPA2YQlx<3
zN(fGaao4$FN3ST<q-xa-P>V1VDF-KyIN_F;G=MBVKbBA-wc{IVD)=y^XK%S>D6UG(
z7UWB5s`m;Ju|c$lP_ncsJ=65m5!`g*hf`9l?=3N;gqj1Zo=1$Z@rY|a>Oj0NAil?%
zM6G8N#X&4&5M)_MlkwGDS0R|G+#FKeZ^gN_c$-iB&Hc{5Z8{3`smmA*Bp9j3zXLLG
ziK*E*wH``{o~Xs^;vwgwO%feQaV0F4+GrHMt*o@7kV#Nb8-Xe8Pt*>Fy1#j*j%n>2
z^E{XEj>VhW4AhvH9C1vAqC?ClAemt&<jJvSLGs2ZX=zf-nEM?%?n(+l><4{x=sRAZ
zezF`(KxqL+J%Ff|D+7(OrP`n4!Uvh7lA+0sIr^9KHp@@It*c9M8HNIaQisZA67f&~
zBSG6yuAMg8jS|w<xHOWwl+To<%;y8$wTcVWgCvM%@w<%u@m*J03k`zWpWI4R!Wwlj
zoqTUYiExm$C17nj>!;IR=8LL!v`tqyyaZX}G?c{0WGK6~Wy3u>US4M|Q8@>S-^b~l
zH<%L^lIAzzX6Z8=5|Edi@ul=Kv$Ie_k~IK;4xn@$PO23g3tgp%WJHQ$7mvCjv)I_i
zrA89tC0Y1KsN>k>&MW((u?bKrYNa~c(i;p%l_lb$78pX%(At1DgrJ>Af4@trZdK`B
z3QedBoYg9%4%wf6an;t`+LRMYG#q3PceLPHY@AXsQ&jXW*U5Em_{!u?E<#cQke15S
zpp?2)HQ1rMQZ((=%G!<E4R33SLZK$PAj_YODyy}zjs37eR1-4!EJ8PlPK?{kK=H+$
zG=T-#lH@jCN>oDRGK7}4p#eL0D5!SnwMvs7qf{pW?Kt9>PgV07>gIk464L4U3Ym3P
za&qN9nN1}$s?oO+RN|JWHB0OIf=W_I9sZ;ZbysP7Wc^heNJ!0P*_VEPFy_o$TaeO0
zDZ?H)_($_9yEv(6mx8QT&W^*4@|i2%_<bc_GUAZ5tfO*DNC_kEIx^b+(y&AUxy!RZ
zh%sWe+-p1PZ?<{F#C(I5X0iKawR=(7XsM@UCR!YDIM`a8X$%z|p&)^-;i7wuPJ^Oa
z&9#MTl?GuNJBsJvu)?0>QA0yh!XTvPP%2)ydY-rDOs9EXC@we)sU^15ceb|^w0;|u
zkQAbx<vI?Ir)#JH=>wX3FAfWwej9}*0z}Bi`bO)!c~+@)ONBAy$}cU&PLSLWhZ(b?
z+frKy{-B~k8#L?)>-pl%ve}a=3Y--Pl4QNVD4vC_BK0ZXlw2$1W3X9qyXn;vq+Kni
zr^{3Z(umQTdv=bz=+J64R)BUI5Af-og~i380j^DQl*kM7>@dxil*4qtNLlxDfzD4i
zfSZVzl6dkJ<(*=Dwl@fZg5*{jj*<&5?D36Mbs-8m>NL~0M}G%&1NQ2?Db2(K{{T#v
zzEH0A+QrN=)aHzMd!SQi#<T^f78Do^XQ{6pGFYCACD#v=C8ZT4c-=;hXg}q4@Amp?
zO^)%n8P=<**d~zdFki>t6~EyCBorCQ`*=sTZU=K`Uk$uc?d%?M)`$EWHsU~Rg(baG
z%B1R`6n`}+eKgSZCfU?<sXzDH974=U_TrGzotw!9pOpJ|#c~rK&B0Zj^`2UC2O;Yf
zmRnpo6Qsves%$cp2GOsHDg`91Bq$EUL#4{D<F#GZ4FHECAzzB01Tw-V^*0J+mrue8
z_&+dbnC0bsTP%q96CA{r#e*)7ii9Y57F%iL6|JWnKZqn~b<iH-fql~!mDo!dbpomi
zs+p(BV2fAR#OK=)x&Ht+XPEq5(=!;-q0S6O$*ZFw))|*ppj28@{%1%It8!dhf0l|V
z+zHfLIx}XaO5@dIY81$#s?9sFgFl^KlKPlQeo;om{e!hlEZf+KRMx!DMQSZW@6L|~
zAa$UlCMepLk+rfA=D$UE)aZJ#RN0o`(k()Sg=hq?12XJ$B**7oQb6D__MdECsXd5e
zklt?F6tzq5T70G<#f+H032r3@SA|X;$nvE+YLU5R0Cv>$9^tW7uyK7xmZ1|MuLMa;
zz(I94l2|mM9_WzctXlgk$dN|%A+Ad@*5g#xl@B429?7DmDQ!bb0G(J04j_V^NBH!s
ze%@HxK)24ns1RqELbIL+ghxj7JWaFk=Mi@~O`d5#AgZs%5W%ApQyvl^Hua;gh8>n4
z19)3(mG(;3cW6=ybv+S6;L~e0yU2lj!~hAIITAPwILB|hYr#g#vIiMo7v=XY*0O6|
zjLY@tHZa&*>y*UxAiU~aY=)B3)7?lzWnZb+ZoM0_@7B~6>o&Nei5BERnvN&k9aII)
zmT~DEV`Y!k&#}lLjI3>bJ2=^7GbSs~>VWR3ePJ&Uk)Zs$l1cjX-rK3Iu513=h`~zB
z<f$~vlub#kbG-aA_V+-=N~gL-RaMMu7Iu$`2B+gFB4UUtTZKtNipGgni5jU&Mw;k*
z9O{OHoa$sgYpeT47;)nyh1WM!n$iJN*%S<e0%|KUCbdTTtXgTNs!48ZAyI@-hgS2B
zZb(`VsT!W@R-;bcJKJ}=XHY9qCP_iW@dw~Ag%#S;K|>z-mv)%E7|x-g4p)u0QxGVf
zsBc%)*^pGF??KSGHToXf>(F#k>Bzt|CR5Kb@cBX1>iI$hirl={AgPmkO@CPA$o434
z$|@O+xZ~0l@;rdH!jfJDqyf9}?Wj=$PKY}Qs>VK=gfk*QOO753$zU73z_vt5Rs}FQ
zUOi?xlR>|uMmH@MO@Fs(T4{2S>q}FG(E7uKc^XMVQ?zOIIudp2&vVl(t8&_mcE2q0
z9oeBhr?MBfd8Y6|8czc?fm~RyY!UwFmKd0}(i~Ha#ar((fYQc_apwXPpkH?gBprK?
zr&d>7R%=ZLsLEzo@DuL9@XiresZqq7LU??;;;f8<BnVEoV`dcwpUk)ADg*0fOcf<8
z>~+T-)hST`t4*Yy{aV;6R%i^T<|85$N@^qrxc0zK+~13cKrzlgxY;aMo1J4G$nB2N
z6!OrB%aZAAf{=f<q7;%!m8WsvUX#CV((uOu0mLau=Dy36M0a|#B;|@uKe!n+9Q!LK
zmSw#X{vq2XExLxwiFj$-YIRC>oeH~Y*q*(sWnPmMhL<#?%*3&g$CUV_O=r6YRMH9a
zVZmUk&N-9WE!nl15woqXZ82P~jU6pRhWynp{%Tk%bAIO3qo_$wVtaP!Eh_Y08&5$M
z2~{OzICAk=v0Dq0;pQF~FC1c{CF>R*saheyl7|%IZ?=f7YNFbHGM_?USM;e!BVWs2
z<4)ZW>MUlZE)Ek4Pih`G$2Uk1>0fVUkF{?#a$|B#HyCZ&NKO`hd}aY#pYiNzO(k1@
zr$mH}H0e#(LhWU`!6KuAp)wt-?^p$wmDuS83y<Lj3{#l-RW#+ik=i$s^UILzDF{op
z0xyqXOTdBLX{gt~eE|FQRNeYFXmwB76(uDS3&`;Pu;KUBA5Zra=N8Oo*y_u;b?8k@
z3FwNaM5H*22=5h#N|dIOT0q*6k*Oy`+fJ+dzuP*r2^!qhM4L#M&S&uu9UHnYr^PYF
zV24}IEIP~euel*X5?3N6SDDw!6qdqFf?Go<WGE7lm8Vmv>`sTFfABUixD<0y6ev@~
z0;S2@gf_Oiw=F;s3>0iRk*Ly_DzX9-5i!0*d*>dH@@5v8S{CzgoO8+K->4h66@Dj9
z-PhgpmA9%JN#*E)G@!#WL^fsJI!;mJ#wgaDmyo05Jy~BeC6m!oWU0kG&v%ODzo&s8
z+(}SU76~7b1a&<vj@(Y61quQ&Q7+>jow@?q0#*X~R$X4?i3ZB*ReMm~i~E!YBDUPL
zKH+fqntjJYwzlFl+&2)P>hIOVY1`i<U~obLnIK7!n30i5;R62v<SpVPczop->Nf5s
zN1011-N#r!N~P06RDclNh=_DW^QZA%yVRwDpwqDW9-`bjh4g&%m88jVTtO&21~6mq
z#ZYy9G55uJ4$7JN@L*Xnis2Q7$J180vEfRTU1%lcBru?j#5SMH>$GdzQ>s1RZWX{f
zOY0PvB<V~ikLL@hZj{L_2pTydhWmy2&xjnfuc%urRohU<Y3jR&DWRdNb;+2@yy;>T
zG?Klm&?y=zNg!%K>WjK`h5MVT;l;GvPwI1*wsRe_${yKPv_IO?45U6-L&(o2U^#nF
zKMq7{=359|U6Q4xgs#b@sZF{(t~l$A=v0k>08kF8(?W6gSl!dObvC?-l^_tD#E^Vu
zkW1XjhWmaZ6%3m?<GfEGu9*>sWZn|b&uTkls5l=`OH4NQ!KTHH#eK9$1Z&%?Ud?HJ
zcTLTyHgPAH5G96OVO2|!Ny-fPN1|nJWy<keMkSQ97G0dSo<#8b(IK`OGS?}+!8=sb
zX-Fr?N!+3kG|(0n^eNh?dr4{{5jkLSmx4z%s@ABUoc*WmjCye&RIM*XEG|IGETKiC
zw-4KL9d!4VA^O)^T2#VWun0?15VW>|p!`y!+fYYd-Sv$tXSvK{bUBHnfhT1!XC*0_
z&O2t`UFaU{4kL%-lpAY!Z;!F7T&nAjG9R0h$%A8OUyL~^i14BR0Ly8nTzE-aflV^7
zhRT!@R-muB0d-!ktx|<LjgSQlk2NX4p7g>Gb%&(gOggzjr#p(X?Aoe2WM)mruaN16
zBE@`INeEKJxXm=8{A0C9SWAgki9%7JUZYN}mK|4TN{rj6w<JlV<-l>{3hHhya}b30
zpJVQVhx-$Wc=rj*aTXxQHx<h^>A7|~XHWUD%youa4m}~a8(NuIDBfEMQgjMYI-wnP
zd3Aor(rFA$C=dkVPaY>eKtL4gv5G{Jd|^p*hAyvfZh1PoY)9=UGN`V?Q*qRp49JeA
zoMbg6Orf+i7r$r#ZvgE*TI&7GrrLkStP6CN7~&2xS)Yb*w(9bwQ>mdc<KcoNR`~<g
z{y3eB#)F4qwphgFYbIOf!YhU|t6CSaxvm$TTV+Yn2vSMadTs$FT{7vfx>s(xCgIF*
z0WfgY!^#3LK1y+cYVG#5m;yPj$Jo!|1IZi-2EILvtb>xG!N1ttXDOOna-c|UsSbrY
z@?a<-5A7`>DM?a6O3Cg*dbs}p=cU9_rAfqNB~?M?2QaEvvL-e`r^@M~5tca1;S1hV
zjL;hyE#YhU5fL58wh>s6;9AnXTw7;)H!VM63ctfnz;$fe_v^MXYp5jf{Qgm1y{V<h
zz=J>Q5_FaDsVM5(wqQ8I9d)XUX;C&b!pJTx1jtLRsO~xvJL#xBy5hBJ_3D>0K;n+a
zyiPo|wk`l*GFb)fG31dRj5{con5&%)EFx8tfu<jo=O{v3ON<01NF%yZbV&h35>?cm
zrO9rR6{<)RDdRr=&Jp^pyISG^N1`bCL1!K0%KkK_GM8G_voNPUCHT#<nC;74hE*L8
zI$QFEttwXS$G2^J0(wsUu-{cICBV6;2{<N5Q}N0OrF-cGOg-tw8LlnPI9~QnLz{9$
zX;ircW|R9h8|<+vxky_pWCS|$%jLwZ6(DGkLC~J#S`PEG?sVE2ZRQ+7o>;f~!@EoB
zFRAK0qDc~7G0oEX-ogxdDQ+Q<%EH`cBxhu@;t3&20oI;7lc^)=u9|)N{)SQeb55(k
z{anB!z==gsok2;A0I$3!#x9UOgl2VoW}~$0EBrN7mz~};Pnoo-)&6TJR*3`j9r{aq
z_Q0~CBn)yA;f4W3asFkbXa~>joL_OSNmQEqH9L1AWP2yU5S-Xl9YI+}idwrPRVWXx
zzv<O)aOt;Gc&DT^02GY>06z#C+-hn#nVd8Jk$A@Qi$^383W3@~Bjh2;(PZsgp(#k!
zFFJ<O9XgPp5>A8x-=#O*JlZT3bvS^NBMu^2clOE;u&xdPz!8jpj$CCp)Pz~gy=EfZ
zTG%o?t-Pq49058qd}{$ZY7|G?LEoU;wpv`$MzKN50%e{!$5rc8rc|9E%N!#7bKznl
zsx7;D3tN(z)@>C;b;2G>ln>^xg*XAwD3A)ZKc`4r)2yRW+L%BX13v!m=>>|cdJuIU
zMk8)A1kAIY9qeson-JfIYf{2YW>%!H!MG<vq7U~JKsuAB>(LZ!8iCZ_fD`2*RPkAN
zd*T|EDZTnj4Ee(cj%84oppTD3wEqBTSCUq}9hQOsXrLr0Iu;T^)A1wq(_Z~&x0ZDc
za`!jXa^e6z=!jy+PUf2%qYnHd`fHP_sN%B{K2mKJRHZu=rXjeErR5|j?eh%^hQ0M!
z(CPr{D~*Qc?fR-x4G!W*$WJaDCj+|eiVL0z_R2l?9QSc^S2k4HX^Py(8~xrMttq86
z+EUn3mZGH<>;MC=Z9mIMExI9;>i_|9NgvAuk1jV6%bZlAb8M<;O@7ZRL+n+<EkcV4
z=EQYxaFXalsw)Lxr7P81oe9)^3!0r4%Fg}J6uErB_!O69qxG)n?F0-5hs99ErawI7
zk16T#;K6OWZy&&Qh^(o@B}Gmxu(zB};iqpRb<^vvy)UcL7R9<8pt*3AvN8%Yk%>RZ
zmpNP$vLu=J4$ieF6p>#x<{b75ms24;+j3Hbt;cpDO*G2VMyX1I!3R#=x*h)jXsz8y
zR;EK9CFYnWNJc0-&vL{yI*ync6~nR$bl%5QhFE^%BD<ueFq?}i6O!31C4di%2=4_t
zrvcY;!AUykN{+ozFMi$JxR$Y$-u+7;SDeBCI0^Shly`q2)lh+gAII5Zc5k+rH7yM4
zYzGqk?%qlR7njyDC3xh7v`|#@Ejkhg{WR2sfHWZM)E1v=FP&6A=BAbctqlMtA>HC)
zTAR%}REueyT*)GT7!peM+cLS63NyJAP!~|xVzvxO<~(4+6jiu<M4+g&TpB4vk@r7M
zE^Yf$Pe1{Vb53}b@8cD(<khO|LrCrsMb9}OHq6<L7I?akDVMYs?@C({7QKj8scUl7
zLKXRfKVP=JI@!89*K2tttU^AWK5p_r9KRUyyIxufxUT~*oZ@2uyRF6LEqQMvt?06g
zTOzWj8ZWG<6%-V@K-80<17H39B<fwhwc9`V_TV@y$`l;sAFU`kuk*M87VF&aj%_Uw
zCZ?KAy4hGvSt8j@tS^4;Qp$IgD_usPU{6YRjgxk^XPNC`;pv0#GKNg4Z?9C!bNN7a
zMTP@eX(q_Qu7Kv`p)Wl)beRDv@-TEuYdcCxPVU1|_3HC&XSr0Q8?F7#XyAB!<q$sN
zlV7N#Pi*3?Q_2t7TDumlhC}rU35Ny>5aE^<y`+V>kiCe}N>YK)Xm#!1rnfyFDbd#Q
zeAt&1PV5xOctW~Y;m$1y<>86!j}`uJbA38o>C+s3JB^PdLE~ut0YN)MK`BxD9>-6q
z>U%wwl_r1y)VTgW!Xmx7eQJtNb{`C2b7f^&VG4UvQ+ZoqDW=11DJ?qGjmkZoB}-6f
zBfn(#{{SJ?;=<OIHiE4#93%(LVo>JkE^FM!=AlQ9UJ+e|e*78IR~_c0TBQ+F5U}j0
z43?0cifKtsi91k`0=}p22UFhdbezBxmQ7Rugy+W?2IlB7h@g>>{ImJQOuX+al<Joj
z$=779DlRNKrk3y<R+hX?r66b%-0sx<{{Y0gJ0+VMg`f`++P{=>Qtg^XEj(8)#P`Sl
E+2};vKL7v#

literal 0
HcmV?d00001

diff --git a/java/libraries/opengl/examples/Image/Extrusion/Extrusion.pde b/java/libraries/opengl/examples/Image/Extrusion/Extrusion.pde
new file mode 100755
index 000000000..637ac6689
--- /dev/null
+++ b/java/libraries/opengl/examples/Image/Extrusion/Extrusion.pde
@@ -0,0 +1,46 @@
+/**
+ * Extrusion. 
+ * 
+ * Converts a flat image into spatial data points and rotates the points
+ * around the center.
+ */
+
+PImage extrude;
+int[][] values;
+float angle = 0;
+
+void setup() {
+  size(640, 360, P3D);
+  
+  // Load the image into a new array
+  extrude = loadImage("ystone08.jpg");
+  extrude.loadPixels();
+  values = new int[extrude.width][extrude.height];
+  for (int y = 0; y < extrude.height; y++) {
+    for (int x = 0; x < extrude.width; x++) {
+      color pixel = extrude.get(x, y);
+      values[x][y] = int(brightness(pixel));
+    }
+  }
+}
+
+void draw() {
+  background(0);
+  
+  // Update the angle
+  angle += 0.005;
+  
+  // Rotate around the center axis
+  translate(width/2, 0, -128);
+  rotateY(angle);  
+  translate(-extrude.width/2, 100, -128);
+  
+  // Display the image mass
+  for (int y = 0; y < extrude.height; y++) {
+    for (int x = 0; x < extrude.width; x++) {
+      stroke(values[x][y]);
+      point(x, y, -values[x][y]);
+    }
+  }
+
+}
diff --git a/java/libraries/opengl/examples/Image/ExtrusionGL/ExtrusionGL.pde b/java/libraries/opengl/examples/Image/ExtrusionGL/ExtrusionGL.pde
new file mode 100755
index 000000000..b779d590b
--- /dev/null
+++ b/java/libraries/opengl/examples/Image/ExtrusionGL/ExtrusionGL.pde
@@ -0,0 +1,49 @@
+/**
+ * Extrusion. 
+ * 
+ * Converts a flat image into spatial data points and rotates the points
+ * around the center.
+ */
+
+PImage a;
+boolean onetime = true;
+int[][] aPixels;
+int[][] values;
+float angle;
+
+void setup() {
+  size(1024, 768, P3D);
+  
+  aPixels = new int[width][height];
+  values = new int[width][height];
+  noFill();
+
+  // Load the image into a new array
+  // Extract the values and store in an array
+  a = loadImage("ystone08.jpg");
+  a.loadPixels();
+  for (int i = 0; i < a.height; i++) {
+    for (int j = 0; j < a.width; j++) {
+      aPixels[j][i] = a.pixels[i*a.width + j];
+      values[j][i] = int(blue(aPixels[j][i]));
+    }
+  }
+}
+
+void draw() {
+  background(255);
+  translate(width/2, height/2, 0);
+  scale(2.0);
+  
+  // Update and constrain the angle
+  angle += 0.005;
+  rotateY(angle);  
+  
+  // Display the image mass
+  for (int i = 0; i < a.height; i += 2) {
+    for (int j = 0; j < a.width; j += 2) {
+      stroke(values[j][i], 153);
+      line(j-a.width/2, i-a.height/2, -values[j][i], j-a.width/2, i-a.height/2, -values[j][i]-10);
+    }
+  }
+}
diff --git a/java/libraries/opengl/examples/Image/Zoom/Zoom.pde b/java/libraries/opengl/examples/Image/Zoom/Zoom.pde
new file mode 100755
index 000000000..d80e842a3
--- /dev/null
+++ b/java/libraries/opengl/examples/Image/Zoom/Zoom.pde
@@ -0,0 +1,89 @@
+/**
+ * Zoom. 
+ * 
+ * Move the cursor over the image to alter its position. Click and press
+ * the mouse to zoom and set the density of the matrix by typing numbers 1-5.
+ * This program displays a series of lines with their heights corresponding to 
+ * a color value read from an image. 
+ */
+
+PImage img;
+//boolean onetime = true;
+int[][] imgPixels;
+float sval = 1.0;
+float nmx, nmy;
+int res = 5;
+
+void setup() 
+{
+  size(640, 360, P3D);
+  noFill();
+  stroke(255);
+  img = loadImage("ystone08.jpg");
+  imgPixels = new int[img.width][img.height];
+  for (int i = 0; i < img.height; i++) {
+    for (int j = 0; j < img.width; j++) {
+      imgPixels[j][i] = img.get(j, i);
+    }
+  }
+}
+
+void draw() 
+{
+  background(0);
+
+  nmx = nmx + (mouseX-nmx)/20; 
+  nmy += (mouseY-nmy)/20; 
+
+  if(mousePressed) { 
+    sval += 0.005; 
+  } 
+  else {
+    sval -= 0.01; 
+  }
+
+  sval = constrain(sval, 1.0, 2.5);
+
+  translate(width/2 + nmx * sval-100, height/2 + nmy*sval - 200, -50);
+  scale(sval);
+  rotateZ(PI/9 - sval + 1.0);
+  rotateX(PI/sval/8 - 0.125);
+  rotateY(sval/8 - 0.125);
+
+  translate(-width/2, -height/2, 0);
+
+  for (int i = 0; i < img.height; i += res) {
+    for (int j = 0; j < img.width; j += res) {
+      float rr = red(imgPixels[j][i]); 
+      float gg = green(imgPixels[j][i]);
+      float bb = blue(imgPixels[j][i]);
+      float tt = rr+gg+bb;
+      stroke(rr, gg, gg);
+      line(i, j, tt/10-20, i, j, tt/10 );
+    }
+  }
+}
+
+void keyPressed() {
+  if(key == '1') {
+    res = 1;
+  } 
+  else if (key == '2') {
+    res = 2; 
+  } 
+  else if (key == '3') {
+    res = 3;
+  } 
+  else if (key == '4') {
+    res = 4;
+  } 
+  else if (key == '5') {
+    res = 5;
+  }
+}
+
+
+
+
+
+
diff --git a/java/libraries/opengl/examples/Immediate/Bezier/Bezier.pde b/java/libraries/opengl/examples/Immediate/Bezier/Bezier.pde
new file mode 100755
index 000000000..8e0d082a9
--- /dev/null
+++ b/java/libraries/opengl/examples/Immediate/Bezier/Bezier.pde
@@ -0,0 +1,22 @@
+/**
+ * Bezier. 
+ * 
+ * The first two parameters for the bezier() function specify the 
+ * first point in the curve and the last two parameters specify 
+ * the last point. The middle parameters set the control points
+ * that define the shape of the curve. 
+ */
+
+void setup() {
+  size(640, 360, P3D); 
+  stroke(255);
+  noFill();
+}
+
+void draw() {
+  background(0);
+  for (int i = 0; i < 200; i += 20) {
+    bezier(mouseX-(i/2.0), 40+i, 410, 20, 440, 300, 240-(i/16.0), 300+(i/8.0));
+  }
+}
+
diff --git a/java/libraries/opengl/examples/Immediate/Robot1_Draw/Robot1_Draw.pde b/java/libraries/opengl/examples/Immediate/Robot1_Draw/Robot1_Draw.pde
new file mode 100755
index 000000000..43dc0cc57
--- /dev/null
+++ b/java/libraries/opengl/examples/Immediate/Robot1_Draw/Robot1_Draw.pde
@@ -0,0 +1,41 @@
+// Robot 1: Draw from "Getting Started with Processing" 
+// by Reas & Fry. O'Reilly / Make 2010
+
+size(720, 480, P3D);
+smooth();
+strokeWeight(2);
+background(204);
+ellipseMode(RADIUS);
+
+// Neck
+stroke(102);                // Set stroke to gray
+line(266, 257, 266, 162);   // Left
+line(276, 257, 276, 162);   // Middle
+line(286, 257, 286, 162);   // Right
+
+// Antennae
+line(276, 155, 246, 112);   // Small
+line(276, 155, 306, 56);    // Tall
+line(276, 155, 342, 170);   // Medium
+
+// Body
+noStroke();                 // Disable stroke
+fill(102);                  // Set fill to gray
+ellipse(264, 377, 33, 33);  // Antigravity orb 
+fill(0);                    // Set fill to black
+rect(219, 257, 90, 120);    // Main body
+fill(102);                  // Set fill to gray
+rect(219, 274, 90, 6);      // Gray stripe
+
+// Head
+fill(0);                    // Set fill to black
+ellipse(276, 155, 45, 45);  // Head
+fill(255);                  // Set fill to white
+ellipse(288, 150, 14, 14);  // Large eye
+fill(0);                    // Set fill to black
+ellipse(288, 150, 3, 3);    // Pupil
+fill(153);                  // Set fill to light gray
+ellipse(263, 148, 5, 5);    // Small eye 1
+ellipse(296, 130, 4, 4);    // Small eye 2
+ellipse(305, 162, 3, 3);    // Small eye 3
+
diff --git a/java/libraries/opengl/examples/Immediate/ShapePrimitives/ShapePrimitives.pde b/java/libraries/opengl/examples/Immediate/ShapePrimitives/ShapePrimitives.pde
new file mode 100755
index 000000000..9c39c1f2a
--- /dev/null
+++ b/java/libraries/opengl/examples/Immediate/ShapePrimitives/ShapePrimitives.pde
@@ -0,0 +1,32 @@
+/**
+ * Shape Primitives. 
+ * 
+ * The basic shape primitive functions are triangle(),
+ * rect(), quad(), ellipse(), and arc(). Squares are made
+ * with rect() and circles are made with ellipse(). Each 
+ * of these functions requires a number of parameters to 
+ * determine the shape's position and size. 
+ */
+
+size(640, 360, P3D);
+background(0);
+noStroke();
+
+fill(204);
+triangle(18, 18, 18, 360, 81, 360);
+
+fill(102);
+rect(81, 81, 63, 63);
+
+fill(204);
+quad(189, 18, 216, 18, 216, 360, 144, 360);
+
+fill(255);
+ellipse(252, 144, 72, 72);
+
+fill(204);
+triangle(288, 18, 351, 360, 288, 360); 
+
+fill(255);
+arc(479, 300, 280, 280, PI, TWO_PI);
+
diff --git a/java/libraries/opengl/examples/Immediate/TriangleStrip/TriangleStrip.pde b/java/libraries/opengl/examples/Immediate/TriangleStrip/TriangleStrip.pde
new file mode 100755
index 000000000..307d842a5
--- /dev/null
+++ b/java/libraries/opengl/examples/Immediate/TriangleStrip/TriangleStrip.pde
@@ -0,0 +1,44 @@
+/**
+ * TRIANGLE_STRIP Mode
+ * by Ira Greenberg. 
+ * 
+ * Generate a closed ring using the vertex() function and 
+ * beginShape(TRIANGLE_STRIP) mode. The outerRad and innerRad 
+ * variables control ring's radii respectively.
+ */
+
+int x;
+int y;
+float outerRad;
+float innerRad;
+
+void setup() {
+  size(640, 360, P3D);
+  background(204);
+  x = width/2;
+  y = height/2;
+  outerRad = min(width, height) * 0.4;
+  innerRad = outerRad * 0.6;
+}
+
+void draw() {
+  background(204);
+  
+  int pts = int(map(mouseX, 0, width, 6, 60));
+  float rot = 180.0/pts;
+  float angle = 0;
+  
+  beginShape(TRIANGLE_STRIP); 
+  for (int i = 0; i <= pts; i++) {
+    float px = x + cos(radians(angle)) * outerRad;
+    float py = y + sin(radians(angle)) * outerRad;
+    angle += rot;
+    vertex(px, py);
+    px = x + cos(radians(angle)) * innerRad;
+    py = y + sin(radians(angle)) * innerRad;
+    vertex(px, py); 
+    angle += rot;
+  }
+  endShape();
+}
+
diff --git a/java/libraries/opengl/examples/Lights/CameraLight/CameraLight.pde b/java/libraries/opengl/examples/Lights/CameraLight/CameraLight.pde
new file mode 100755
index 000000000..551eb20b0
--- /dev/null
+++ b/java/libraries/opengl/examples/Lights/CameraLight/CameraLight.pde
@@ -0,0 +1,42 @@
+// CameraLight, by Andres Colubri
+// Simple example showing a lit rotating cube. The projection
+// is set to orthographic if the mouse is pressed.
+
+float spin = 0.0;
+
+void setup() {
+  size(400, 400, P3D);
+  
+  noStroke();
+}
+
+void draw() {
+  background(51);
+
+  lights();
+  
+  if (mousePressed) {
+    // The arguments of ortho are specified in screen coordinates, where (0,0)
+    // is the upper left corner of the screen
+    ortho(0, width, 0, height);     
+  } else {
+
+    float fov = PI/3.0; 
+    float cameraZ = (height/2.0) / tan(fov/2.0); 
+    perspective(fov, float(width)/float(height), 
+                cameraZ/2.0, cameraZ*2.0); 
+  }  
+  
+  spin += 0.01;
+  
+  pushMatrix();
+  translate(width/2, height/2, 0);
+  rotateX(PI/9);
+  rotateY(PI/5 + spin);
+  box(100);
+  popMatrix();
+}
+
+
+
+
diff --git a/java/libraries/opengl/examples/Lights/Directional/Directional.pde b/java/libraries/opengl/examples/Lights/Directional/Directional.pde
new file mode 100755
index 000000000..6a1af3008
--- /dev/null
+++ b/java/libraries/opengl/examples/Lights/Directional/Directional.pde
@@ -0,0 +1,28 @@
+/**
+ * Directional. 
+ * 
+ * Move the mouse the change the direction of the light.
+ * Directional light comes from one direction and is stronger 
+ * when hitting a surface squarely and weaker if it hits at a 
+ * a gentle angle. After hitting a surface, a directional lights 
+ * scatters in all directions. 
+ */
+
+void setup() {
+  size(640, 360, P3D);
+  noStroke();
+  fill(204);
+}
+
+void draw() {
+  noStroke(); 
+  background(0); 
+  float dirY = (mouseY / float(height) - 0.5) * 2;
+  float dirX = (mouseX / float(width) - 0.5) * 2;
+  directionalLight(204, 204, 204, -dirX, -dirY, -1); 
+  translate(width/2 - 100, height/2, 0); 
+  sphere(80); 
+  translate(200, 0, 0); 
+  sphere(80); 
+}
+
diff --git a/java/libraries/opengl/examples/Lights/Lights1/Lights1.pde b/java/libraries/opengl/examples/Lights/Lights1/Lights1.pde
new file mode 100755
index 000000000..bf7a36edc
--- /dev/null
+++ b/java/libraries/opengl/examples/Lights/Lights1/Lights1.pde
@@ -0,0 +1,29 @@
+/**
+ * Lights 1. 
+ * 
+ * Uses the default lights to show a simple box. The lights() function
+ * is used to turn on the default lighting.
+ */
+ 
+float spin = 0.0;
+
+void setup() 
+{
+  size(640, 360, P3D);
+  noStroke();
+}
+
+void draw() 
+{
+  background(51);
+  lights();
+  
+  spin += 0.01;
+  
+  pushMatrix();
+  translate(width/2, height/2, 0);
+  rotateX(PI/9);
+  rotateY(PI/5 + spin);
+  box(150);
+  popMatrix();
+}
diff --git a/java/libraries/opengl/examples/Lights/Lights2/Lights2.pde b/java/libraries/opengl/examples/Lights/Lights2/Lights2.pde
new file mode 100755
index 000000000..e1693e590
--- /dev/null
+++ b/java/libraries/opengl/examples/Lights/Lights2/Lights2.pde
@@ -0,0 +1,36 @@
+/**
+ * Lights 2 
+ * by Simon Greenwold. 
+ * 
+ * Display a box with three different kinds of lights. 
+ */
+
+void setup() 
+{
+  size(640, 360, P3D);
+  noStroke();
+}
+
+void draw() 
+{
+  background(0);
+  translate(width / 2, height / 2);
+  
+  // Orange point light on the right
+  pointLight(150, 100, 0, // Color
+             200, -150, 0); // Position
+
+  // Blue directional light from the left
+  directionalLight(0, 102, 255, // Color
+                   1, 0, 0); // The x-, y-, z-axis direction
+
+  // Yellow spotlight from the front
+  spotLight(255, 255, 109, // Color
+            0, 40, 200, // Position
+            0, -0.5, -0.5, // Direction
+            PI / 2, 2); // Angle, concentration
+  
+  rotateY(map(mouseX, 0, width, 0, PI));
+  rotateX(map(mouseY, 0, height, 0, PI));
+  box(150);
+}
diff --git a/java/libraries/opengl/examples/Lights/LightsGL/LightsGL.pde b/java/libraries/opengl/examples/Lights/LightsGL/LightsGL.pde
new file mode 100755
index 000000000..157ce4216
--- /dev/null
+++ b/java/libraries/opengl/examples/Lights/LightsGL/LightsGL.pde
@@ -0,0 +1,45 @@
+/**
+ * LightsGL. 
+ * Modified from an example by Simon Greenwold. 
+ * 
+ * Display a box with three different kinds of lights. 
+ */
+
+void setup() 
+{
+  size(1024, 768, P3D);
+  noStroke();
+}
+
+void draw() 
+{
+  defineLights();
+  background(0);
+  
+  for (int x = 0; x <= width; x += 100) {
+    for (int y = 0; y <= height; y += 100) {
+      pushMatrix();
+      translate(x, y);
+      rotateY(map(mouseX, 0, width, 0, PI));
+      rotateX(map(mouseY, 0, height, 0, PI));
+      box(90);
+      popMatrix();
+    }
+  }
+}
+
+void defineLights() {
+  // Orange point light on the right
+  pointLight(150, 100, 0,   // Color
+             200, -150, 0); // Position
+
+  // Blue directional light from the left
+  directionalLight(0, 102, 255, // Color
+                   1, 0, 0);    // The x-, y-, z-axis direction
+
+  // Yellow spotlight from the front
+  spotLight(255, 255, 109,  // Color
+            0, 40, 200,     // Position
+            0, -0.5, -0.5,  // Direction
+            PI / 2, 2);     // Angle, concentration
+}
diff --git a/java/libraries/opengl/examples/Lights/Reflection/Reflection.pde b/java/libraries/opengl/examples/Lights/Reflection/Reflection.pde
new file mode 100755
index 000000000..f6a3d7a94
--- /dev/null
+++ b/java/libraries/opengl/examples/Lights/Reflection/Reflection.pde
@@ -0,0 +1,25 @@
+/**
+ * Reflection 
+ * by Simon Greenwold. 
+ * 
+ * Vary the specular reflection component of a material
+ * with the horizontal position of the mouse. 
+ */
+
+void setup() {
+  size(640, 360, P3D);
+  noStroke();
+  colorMode(RGB, 1);
+  fill(0.4);
+}
+
+void draw() {
+  background(0);
+  translate(width / 2, height / 2);
+  // Set the specular color of lights that follow
+  lightSpecular(1, 1, 1);
+  directionalLight(0.8, 0.8, 0.8, 0, 0, -1);
+  float s = mouseX / float(width);
+  specular(s, s, s);
+  sphere(120);
+}
diff --git a/java/libraries/opengl/examples/Lights/Spot/Spot.pde b/java/libraries/opengl/examples/Lights/Spot/Spot.pde
new file mode 100755
index 000000000..ce25c4bee
--- /dev/null
+++ b/java/libraries/opengl/examples/Lights/Spot/Spot.pde
@@ -0,0 +1,35 @@
+/**
+ * Spot. 
+ * 
+ * Move the mouse the change the position and concentation
+ * of a blue spot light. 
+ */
+ 
+int concentration = 600; // Try values 1 -> 10000
+
+void setup() 
+{
+  //size(200, 200, P3D);
+  size(640, 360, P3D);
+  noStroke();
+  fill(204);
+  sphereDetail(60);
+}
+
+void draw() 
+{
+  background(0); 
+  
+  // Light the bottom of the sphere
+  directionalLight(51, 102, 126, 0, -1, 0);
+  
+  // Orange light on the upper-right of the sphere
+  spotLight(204, 153, 0, 360, 160, 600, 0, 0, -1, PI/2, 600); 
+  
+  // Moving spotlight that follows the mouse
+  spotLight(102, 153, 204, 360, mouseY, 600, 0, 0, -1, PI/2, 600); 
+  
+  translate(width/2, height/2, 0); 
+  sphere(120); 
+}
+
diff --git a/java/libraries/opengl/examples/LowLevel/Nehe/Bitmap.pde b/java/libraries/opengl/examples/LowLevel/Nehe/Bitmap.pde
new file mode 100755
index 000000000..f9179e16a
--- /dev/null
+++ b/java/libraries/opengl/examples/LowLevel/Nehe/Bitmap.pde
@@ -0,0 +1,147 @@
+import java.awt.image.BufferedImage;
+import java.awt.image.DataBufferByte;
+import java.awt.image.DataBufferInt;
+import java.io.IOException;
+import java.io.InputStream;
+
+BufferedImage loadBitmap(String file) throws IOException {
+  BufferedImage image;
+  InputStream input = null;
+  try {
+    input = createInput(file);
+
+    int bitmapFileHeaderLength = 14;
+    int bitmapInfoHeaderLength = 40;
+
+    byte bitmapFileHeader[] = new byte[bitmapFileHeaderLength];
+    byte bitmapInfoHeader[] = new byte[bitmapInfoHeaderLength];
+
+    input.read(bitmapFileHeader, 0, bitmapFileHeaderLength);
+    input.read(bitmapInfoHeader, 0, bitmapInfoHeaderLength);
+
+    int nSize = bytesToInt(bitmapFileHeader, 2);
+    int nWidth = bytesToInt(bitmapInfoHeader, 4);
+    int nHeight = bytesToInt(bitmapInfoHeader, 8);
+    int nBiSize = bytesToInt(bitmapInfoHeader, 0);
+    int nPlanes = bytesToShort(bitmapInfoHeader, 12);
+    int nBitCount = bytesToShort(bitmapInfoHeader, 14);
+    int nSizeImage = bytesToInt(bitmapInfoHeader, 20);
+    int nCompression = bytesToInt(bitmapInfoHeader, 16);
+    int nColoursUsed = bytesToInt(bitmapInfoHeader, 32);
+    int nXPixelsMeter = bytesToInt(bitmapInfoHeader, 24);
+    int nYPixelsMeter = bytesToInt(bitmapInfoHeader, 28);
+    int nImportantColours = bytesToInt(bitmapInfoHeader, 36);
+
+    if (nBitCount == 24) {
+      image = read24BitBitmap(nSizeImage, nHeight, nWidth, input);
+    } 
+    else if (nBitCount == 8) {
+      image = read8BitBitmap(nColoursUsed, nBitCount, nSizeImage, nWidth, nHeight, input);
+    } 
+    else {
+      System.out.println("Not a 24-bit or 8-bit Windows Bitmap, aborting...");
+      image = null;
+    }
+  } 
+  finally {
+    try {
+      if (input != null)
+        input.close();
+    } 
+    catch (IOException e) {
+    }
+  }
+  return image;
+}
+
+BufferedImage read8BitBitmap(int nColoursUsed, int nBitCount, int nSizeImage, int nWidth, int nHeight, InputStream input) throws IOException {
+  int nNumColors = (nColoursUsed > 0) ? nColoursUsed : (1 & 0xff) << nBitCount;
+
+  if (nSizeImage == 0) {
+    nSizeImage = ((((nWidth * nBitCount) + 31) & ~31) >> 3);
+    nSizeImage *= nHeight;
+  }
+
+  int npalette[] = new int[nNumColors];
+  byte bpalette[] = new byte[nNumColors * 4];
+  readBuffer(input, bpalette);
+  int nindex8 = 0;
+
+  for (int n = 0; n < nNumColors; n++) {
+    npalette[n] = (255 & 0xff) << 24 |
+      (bpalette[nindex8 + 2] & 0xff) << 16 |
+      (bpalette[nindex8 + 1] & 0xff) << 8 |
+      (bpalette[nindex8 + 0] & 0xff);
+
+    nindex8 += 4;
+  }
+
+  int npad8 = (nSizeImage / nHeight) - nWidth;
+  BufferedImage bufferedImage = new BufferedImage(nWidth, nHeight, BufferedImage.TYPE_INT_ARGB);
+  DataBufferInt dataBufferByte = ((DataBufferInt) bufferedImage.getRaster().getDataBuffer());
+  int[][] bankData = dataBufferByte.getBankData();
+  byte bdata[] = new byte[(nWidth + npad8) * nHeight];
+
+  readBuffer(input, bdata);
+  nindex8 = 0;
+
+  for (int j8 = nHeight - 1; j8 >= 0; j8--) {
+    for (int i8 = 0; i8 < nWidth; i8++) {
+      bankData[0][j8 * nWidth + i8] = npalette[((int) bdata[nindex8] & 0xff)];
+      nindex8++;
+    }
+    nindex8 += npad8;
+  }
+
+  return bufferedImage;
+}
+
+BufferedImage read24BitBitmap(int nSizeImage, int nHeight, int nWidth, InputStream input) throws IOException {
+  int npad = (nSizeImage / nHeight) - nWidth * 3;
+  if (npad == 4 || npad < 0)
+    npad = 0;
+  int nindex = 0;
+  BufferedImage bufferedImage = new BufferedImage(nWidth, nHeight, BufferedImage.TYPE_4BYTE_ABGR);
+  DataBufferByte dataBufferByte = ((DataBufferByte) bufferedImage.getRaster().getDataBuffer());
+  byte[][] bankData = dataBufferByte.getBankData();
+  byte brgb[] = new byte[(nWidth + npad) * 3 * nHeight];
+
+  readBuffer(input, brgb);
+
+  for (int j = nHeight - 1; j >= 0; j--) {
+    for (int i = 0; i < nWidth; i++) {
+      int base = (j * nWidth + i) * 4;
+      bankData[0][base] = (byte) 255;
+      bankData[0][base + 1] = brgb[nindex];
+      bankData[0][base + 2] = brgb[nindex + 1];
+      bankData[0][base + 3] = brgb[nindex + 2];
+      nindex += 3;
+    }
+    nindex += npad;
+  }
+
+  return bufferedImage;
+}
+
+int bytesToInt(byte[] bytes, int index) {
+  return (bytes[index + 3] & 0xff) << 24 |
+    (bytes[index + 2] & 0xff) << 16 |
+    (bytes[index + 1] & 0xff) << 8 |
+    bytes[index + 0] & 0xff;
+}
+
+short bytesToShort(byte[] bytes, int index) {
+  return (short) (((bytes[index + 1] & 0xff) << 8) |
+    (bytes[index + 0] & 0xff));
+}
+
+void readBuffer(InputStream in, byte[] buffer) throws IOException {
+  int bytesRead = 0;
+  int bytesToRead = buffer.length;
+  while (bytesToRead > 0) {
+    int read = in.read(buffer, bytesRead, bytesToRead);
+    bytesRead += read;
+    bytesToRead -= read;
+  }
+}
+
diff --git a/java/libraries/opengl/examples/LowLevel/Nehe/Nehe.pde b/java/libraries/opengl/examples/LowLevel/Nehe/Nehe.pde
new file mode 100755
index 000000000..2c7f873f4
--- /dev/null
+++ b/java/libraries/opengl/examples/LowLevel/Nehe/Nehe.pde
@@ -0,0 +1,235 @@
+// Nehe by Andres Colubri
+// Example of direct OpenGL use inside Processing with the 
+// OPENGL2 renderer.
+// Ported from NeHe tutorial 8:
+// http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=08
+
+import javax.media.opengl.*;
+import java.nio.*;
+import javax.media.opengl.glu.gl2.GLUgl2;
+
+boolean lighting = true;
+boolean blending = true;
+boolean depthTest = true;
+boolean depthMask = false;
+boolean texturing = true;
+
+int selBlend = 1;
+int selFilter = 0;
+float transparency = 0.5f;
+
+// The color depth of the sketch can be set with this
+// method. The 6 numbers separated by colons correspond 
+// to the red, green, blue, alpha, depth and stencil bits.
+// If this method is not defined, then Processing will let
+// OpenGL to automatically choose the color depth.
+String sketchColordepth() {
+  return "8:8:8:8:16:0";
+}
+
+// Whether the sketch surface supports translucenty or not.
+boolean sketchTranslucency() {
+  return true;
+} 
+
+FloatBuffer[] cubeVertexBfr;
+FloatBuffer[] cubeNormalBfr;
+FloatBuffer[] cubeTextureBfr;
+
+FloatBuffer lightAmbBfr;
+FloatBuffer lightDifBfr;
+FloatBuffer lightPosBfr;
+
+private IntBuffer texturesBuffer;
+
+private float xRot;
+private float yRot;
+float xSpeed = 0.2f;
+float ySpeed = 0.2f;  
+
+GLUgl2 glu;
+
+void setup() {
+  size(400, 400, P3D);
+
+  glu = new GLUgl2();
+
+  int SIZEOF_FLOAT = Float.SIZE / 8;
+
+  cubeVertexBfr = new FloatBuffer[6];
+  cubeNormalBfr = new FloatBuffer[6];
+  cubeTextureBfr = new FloatBuffer[6];
+  for (int i = 0; i < 6; i++) {
+    ByteBuffer vbb = ByteBuffer.allocateDirect(4 * 3 * SIZEOF_FLOAT);
+    vbb.order(ByteOrder.nativeOrder());
+    cubeVertexBfr[i] = vbb.asFloatBuffer(); 
+    cubeVertexBfr[i].put(cubeVertexCoords[i]);
+    cubeVertexBfr[i].flip();
+
+    ByteBuffer nbb = ByteBuffer.allocateDirect(4 * 3 * SIZEOF_FLOAT);
+    nbb.order(ByteOrder.nativeOrder());
+    cubeNormalBfr[i] = nbb.asFloatBuffer(); 
+    cubeNormalBfr[i].put(cubeNormalCoords[i]);
+    cubeNormalBfr[i].flip();
+
+    ByteBuffer tbb = ByteBuffer.allocateDirect(4 * 2 * SIZEOF_FLOAT);
+    tbb.order(ByteOrder.nativeOrder());      
+    cubeTextureBfr[i] = tbb.asFloatBuffer();
+    cubeTextureBfr[i].put(cubeTextureCoords[i]);
+    cubeTextureBfr[i].flip();
+  }
+
+  lightAmbBfr = FloatBuffer.wrap(lightAmb);
+  lightDifBfr = FloatBuffer.wrap(lightDif);
+  lightPosBfr = FloatBuffer.wrap(lightPos);    
+
+  PGraphicsOpenGL pgl = (PGraphicsOpenGL)g;
+  GL gl = pgl.beginGL();
+
+  Texture teximage = null;
+  try {
+    teximage = readTexture("glass.bmp");
+  } catch (IOException e) {
+    e.printStackTrace();
+    throw new RuntimeException(e);
+  }
+
+  texturesBuffer = IntBuffer.allocate(3);
+  gl.glGenTextures(3, texturesBuffer);
+
+  gl.glEnable(GL.GL_TEXTURE_2D);
+  // setup texture 0 with nearest filtering
+  gl.glBindTexture(GL.GL_TEXTURE_2D, texturesBuffer.get(0));
+  gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_NEAREST);
+  gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_NEAREST);
+  gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
+  gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);
+  makeRGBTexture(gl, glu, teximage, GL.GL_TEXTURE_2D, false);
+
+  // setup texture 1 with linear filtering for both minification and magnification, 
+  // this is usually called bilinear sampling
+  gl.glBindTexture(GL.GL_TEXTURE_2D, texturesBuffer.get(1));
+  gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
+  gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR);
+  gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
+  gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);
+  makeRGBTexture(gl, glu, teximage, GL.GL_TEXTURE_2D, false);
+
+  // setup texture 2 with linear filtering for magnification and linear-linear mipmapping
+  // (trilinear sampling)
+  gl.glBindTexture(GL.GL_TEXTURE_2D, texturesBuffer.get(2));
+  gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MAG_FILTER, GL.GL_LINEAR);
+  gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_MIN_FILTER, GL.GL_LINEAR_MIPMAP_NEAREST);
+  gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_S, GL.GL_CLAMP_TO_EDGE);
+  gl.glTexParameteri(GL.GL_TEXTURE_2D, GL.GL_TEXTURE_WRAP_T, GL.GL_CLAMP_TO_EDGE);
+  makeRGBTexture(gl, glu, teximage, GL.GL_TEXTURE_2D, true);
+  gl.glDisable(GL.GL_TEXTURE_2D);
+
+  pgl.endGL();
+}
+
+public void draw() {
+  background(0);
+
+  PGraphicsOpenGL pgl = (PGraphicsOpenGL)g;
+  GL gl = pgl.beginGL();
+
+  pgl.gl2f.glShadeModel(GL2.GL_SMOOTH);
+  gl.glClearColor(0, 0, 0, 0);
+
+  if (depthTest) {
+    gl.glClearDepthf(1.0f);
+    gl.glEnable(GL.GL_DEPTH_TEST);
+    gl.glDepthFunc(GL.GL_LEQUAL);
+  } 
+  else {
+    gl.glDisable(GL.GL_DEPTH_TEST);
+  }
+  gl.glDepthMask(depthMask);
+
+  gl.glHint(GL2.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
+
+  // lighting
+  gl.glEnable(GL2.GL_LIGHT0);
+  pgl.gl2f.glLightfv(GL2.GL_LIGHT0, GL2.GL_AMBIENT, lightAmbBfr);
+  pgl.gl2f.glLightfv(GL2.GL_LIGHT0, GL2.GL_DIFFUSE, lightDifBfr);
+  pgl.gl2f.glLightfv(GL2.GL_LIGHT0, GL2.GL_POSITION, lightPosBfr);
+
+  // blending
+  gl.glEnable(GL2.GL_COLOR_MATERIAL);
+  pgl.gl2f.glColor4f(1.0f, 1.0f, 1.0f, transparency);
+  if (selBlend == 0) {
+    gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE);
+  } 
+  else if (selBlend == 1) {
+    gl.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA);
+  }
+
+  gl.glViewport(0, 0, width, height);
+  // setup projection matrix
+  pgl.gl2f.glMatrixMode(GL2.GL_PROJECTION);
+  pgl.gl2f.glLoadIdentity();
+  glu.gluPerspective(45.0f, (float)width / (float)height, 1.0f, 100.0f);    
+
+  gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
+  pgl.gl2f.glMatrixMode(GL2.GL_MODELVIEW);
+  pgl.gl2f.glLoadIdentity(); 
+
+  // update lighting
+  if (lighting) {
+    gl.glEnable(GL2.GL_LIGHTING);
+  } 
+  else {
+    gl.glDisable(GL2.GL_LIGHTING);
+  }
+
+  // update blending
+  if (blending) {
+    gl.glEnable(GL.GL_BLEND);
+    gl.glDisable(GL.GL_CULL_FACE);
+  } 
+  else {
+    gl.glDisable(GL.GL_BLEND);
+    gl.glEnable(GL.GL_CULL_FACE);
+  }
+
+  pgl.gl2f.glTranslatef(0, 0, -6);
+  pgl.gl2f.glRotatef(xRot, 1, 0, 0);
+  pgl.gl2f.glRotatef(yRot, 0, 1, 0);
+
+  if (texturing) {
+    gl.glEnable(GL.GL_TEXTURE_2D);
+    gl.glBindTexture(GL.GL_TEXTURE_2D, texturesBuffer.get(selFilter));
+  }
+  pgl.gl2f.glEnableClientState(GL2.GL_VERTEX_ARRAY);
+  pgl.gl2f.glEnableClientState(GL2.GL_NORMAL_ARRAY);
+  if (texturing) pgl.gl2f.glEnableClientState(GL2.GL_TEXTURE_COORD_ARRAY);
+  for (int i = 0; i < 6; i++) // draw each face
+  {
+    pgl.gl2f.glVertexPointer(3, GL.GL_FLOAT, 0, cubeVertexBfr[i]);
+    if (texturing) pgl.gl2f.glTexCoordPointer(2, GL.GL_FLOAT, 0, cubeTextureBfr[i]);
+    pgl.gl2f.glNormalPointer(GL.GL_FLOAT, 0, cubeNormalBfr[i]);
+    pgl.gl2f.glDrawArrays(GL.GL_TRIANGLE_FAN, 0, 4);
+  }
+  pgl.gl2f.glDisableClientState(GL2.GL_VERTEX_ARRAY);
+  pgl.gl2f.glDisableClientState(GL2.GL_NORMAL_ARRAY);
+  if (texturing) {
+    pgl.gl2f.glDisableClientState(GL2.GL_TEXTURE_COORD_ARRAY);
+    gl.glDisable(GL.GL_TEXTURE_2D);
+  }
+
+  // update rotations
+  xRot += xSpeed;
+  yRot += ySpeed;
+
+  pgl.endGL();
+}
+
+void makeRGBTexture(GL gl, GLUgl2 glu, Texture img, int target, boolean mipmapped) {
+  if (mipmapped) {
+    glu.gluBuild2DMipmaps(target, GL.GL_RGB8, img.getWidth(), img.getHeight(), GL.GL_RGB, GL.GL_UNSIGNED_BYTE, img.getPixels());
+  } else {
+    gl.glTexImage2D(target, 0, GL.GL_RGB, img.getWidth(), img.getHeight(), 0, GL.GL_RGB, GL.GL_UNSIGNED_BYTE, img.getPixels());
+  }
+}
+
diff --git a/java/libraries/opengl/examples/LowLevel/Nehe/Texture.pde b/java/libraries/opengl/examples/LowLevel/Nehe/Texture.pde
new file mode 100755
index 000000000..67b09712c
--- /dev/null
+++ b/java/libraries/opengl/examples/LowLevel/Nehe/Texture.pde
@@ -0,0 +1,82 @@
+import javax.imageio.ImageIO;
+import java.awt.image.BufferedImage;
+import java.awt.image.PixelGrabber;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
+Texture readTexture(String filename) throws IOException {
+  return readTexture(filename, false);
+}
+
+Texture readTexture(String filename, boolean storeAlphaChannel) throws IOException {
+  BufferedImage bufferedImage;
+  if (filename.endsWith(".bmp")) {
+    bufferedImage = loadBitmap(filename);
+  } 
+  else {
+    bufferedImage = readImage(filename);
+  }
+  return readPixels(bufferedImage, storeAlphaChannel);
+}
+
+BufferedImage readImage(String resourceName) throws IOException {
+  return ImageIO.read(createInput(resourceName));
+}
+
+Texture readPixels(BufferedImage img, boolean storeAlphaChannel) {
+  int[] packedPixels = new int[img.getWidth() * img.getHeight()];
+
+  PixelGrabber pixelgrabber = new PixelGrabber(img, 0, 0, img.getWidth(), img.getHeight(), packedPixels, 0, img.getWidth());
+  try {
+    pixelgrabber.grabPixels();
+  } 
+  catch (InterruptedException e) {
+    throw new RuntimeException();
+  }
+
+  int bytesPerPixel = storeAlphaChannel ? 4 : 3;
+  //ByteBuffer unpackedPixels = BufferUtil.newByteBuffer(packedPixels.length * bytesPerPixel);
+  ByteBuffer unpackedPixels = ByteBuffer.allocate(packedPixels.length * bytesPerPixel);
+
+  for (int row = img.getHeight() - 1; row >= 0; row--) {
+    for (int col = 0; col < img.getWidth(); col++) {
+      int packedPixel = packedPixels[row * img.getWidth() + col];
+      unpackedPixels.put((byte) ((packedPixel >> 16) & 0xFF));
+      unpackedPixels.put((byte) ((packedPixel >> 8) & 0xFF));
+      unpackedPixels.put((byte) ((packedPixel >> 0) & 0xFF));
+      if (storeAlphaChannel) {
+        unpackedPixels.put((byte) ((packedPixel >> 24) & 0xFF));
+      }
+    }
+  }
+
+  unpackedPixels.flip();
+
+
+  return new Texture(unpackedPixels, img.getWidth(), img.getHeight());
+}
+
+class Texture {
+  ByteBuffer pixels;
+  int width;
+  int height;
+
+  public Texture(ByteBuffer pixels, int width, int height) {
+    this.height = height;
+    this.pixels = pixels;
+    this.width = width;
+  }
+
+  public int getHeight() {
+    return height;
+  }
+
+  public ByteBuffer getPixels() {
+    return pixels;
+  }
+
+  public int getWidth() {
+    return width;
+  }
+}
+
diff --git a/java/libraries/opengl/examples/LowLevel/Nehe/VertData.pde b/java/libraries/opengl/examples/LowLevel/Nehe/VertData.pde
new file mode 100755
index 000000000..f6f813b4d
--- /dev/null
+++ b/java/libraries/opengl/examples/LowLevel/Nehe/VertData.pde
@@ -0,0 +1,147 @@
+float[][] cubeVertexCoords = new float[][] {
+  new float[] { // top
+    1, 1,-1,
+    -1, 1,-1,
+    -1, 1, 1,
+    1, 1, 1
+  }
+  ,
+  new float[] { // bottom
+    1,-1, 1,
+    -1,-1, 1,
+    -1,-1,-1,
+    1,-1,-1
+  }
+  ,
+  new float[] { // front
+    1, 1, 1,
+    -1, 1, 1,
+    -1,-1, 1,
+    1,-1, 1
+  }
+  ,
+  new float[] { // back
+    1,-1,-1,
+    -1,-1,-1,
+    -1, 1,-1,
+    1, 1,-1
+  }
+  ,
+  new float[] { // left
+    -1, 1, 1,
+    -1, 1,-1,
+    -1,-1,-1,
+    -1,-1, 1
+  }
+  ,
+  new float[] { // right
+    1, 1,-1,
+    1, 1, 1,
+    1,-1, 1,
+    1,-1,-1
+  }
+  ,
+};
+
+float[][] cubeNormalCoords = new float[][] {
+  new float[] { // top
+    0, 1, 0,
+    0, 1, 0,
+    0, 1, 0,
+    0, 1, 0
+  }
+  ,
+  new float[] { // bottom
+    0,-1, 0,
+    0,-1, 0,
+    0,-1, 0,
+    0,-1, 0
+  }
+  ,
+  new float[] { // front
+    0, 0, 1,
+    0, 0, 1,
+    0, 0, 1,
+    0, 0, 1
+  }
+  ,
+  new float[] { // back
+    0, 0,-1,
+    0, 0,-1,
+    0, 0,-1,
+    0, 0,-1
+  }
+  ,
+  new float[] { // left
+    -1, 0, 0,
+    -1, 0, 0,
+    -1, 0, 0,
+    -1, 0, 0
+  }
+  ,
+  new float[] { // right
+    1, 0, 0,
+    1, 0, 0,
+    1, 0, 0,
+    1, 0, 0
+  }
+  ,
+};
+
+float[][] cubeTextureCoords = new float[][] {
+  new float[] { // top
+    1, 0,
+    1, 1,
+    0, 1,
+    0, 0
+  }
+  ,
+  new float[] { // bottom
+    0, 0,
+    1, 0,
+    1, 1,
+    0, 1
+  }
+  ,
+  new float[] { // front
+    1, 1,
+    0, 1,
+    0, 0,
+    1, 0
+  }
+  ,
+  new float[] { // back
+    0, 1,
+    0, 0,
+    1, 0,
+    1, 1
+  }
+  ,
+  new float[] { // left
+    1, 1,
+    0, 1,
+    0, 0,
+    1, 0
+  }
+  ,
+  new float[] { // right
+    0, 1,
+    0, 0,
+    1, 0,
+    1, 1
+  }
+  ,
+};  
+
+float lightAmb[]= {
+  0.5f, 0.5f, 0.5f, 1.0f
+};
+
+float lightDif[]= {
+  1.0f, 1.0f, 1.0f, 1.0f
+};
+
+float lightPos[]= {
+  0.0f, 0.0f, 2.0f, 1.0f
+};
+
diff --git a/java/libraries/opengl/examples/LowLevel/Nehe/data/glass.bmp b/java/libraries/opengl/examples/LowLevel/Nehe/data/glass.bmp
new file mode 100755
index 0000000000000000000000000000000000000000..1acf064255835c7f81bb3d15a4271612ce3b6df3
GIT binary patch
literal 49220
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
N&!LW3o_pcB{|_*>WrF|!

literal 0
HcmV?d00001

diff --git a/java/libraries/opengl/examples/Performance/CubicGrid/CubicGrid.pde b/java/libraries/opengl/examples/Performance/CubicGrid/CubicGrid.pde
new file mode 100755
index 000000000..df8c0ea0a
--- /dev/null
+++ b/java/libraries/opengl/examples/Performance/CubicGrid/CubicGrid.pde
@@ -0,0 +1,53 @@
+/**
+ * Cubic Grid 
+ * by Ira Greenberg. 
+ * 
+ * 3D translucent colored grid uses nested pushMatrix()
+ * and popMatrix() functions. 
+ */
+
+float boxSize = 40;
+float margin = boxSize*2;
+float depth = 400;
+color boxFill;
+
+void setup() {
+  size(640, 360, P3D);
+  frameRate(120);
+  noStroke();
+}
+
+void draw() {
+  background(255);
+  
+  hint(DISABLE_DEPTH_TEST);
+  
+  // Center and spin grid
+  translate(width/2, height/2, -depth);
+  rotateY(frameCount * 0.01);
+  rotateX(frameCount * 0.01);
+
+  // Build grid using multiple translations 
+  for (float i =- depth/2+margin; i <= depth/2-margin; i += boxSize){
+    pushMatrix();
+    for (float j =- height+margin; j <= height-margin; j += boxSize){
+      pushMatrix();
+      for (float k =- width+margin; k <= width-margin; k += boxSize){
+        // Base fill color on counter values, abs function 
+        // ensures values stay within legal range
+        boxFill = color(abs(i), abs(j), abs(k), 50);
+        pushMatrix();
+        translate(k, j, i);
+        fill(boxFill);
+        box(boxSize, boxSize, boxSize);
+        popMatrix();
+      }
+      popMatrix();
+    }
+    popMatrix();
+  }
+  if (frameCount % 10 == 0) {
+    println(frameRate);
+  }
+}
+
diff --git a/java/libraries/opengl/examples/Performance/Esfera/Esfera.pde b/java/libraries/opengl/examples/Performance/Esfera/Esfera.pde
new file mode 100755
index 000000000..f418792c2
--- /dev/null
+++ b/java/libraries/opengl/examples/Performance/Esfera/Esfera.pde
@@ -0,0 +1,89 @@
+/**
+ * Esfera
+ * by David Pena.  
+ * 
+ * Distribucion aleatoria uniforme sobre la superficie de una esfera. 
+ */
+
+int cuantos = 16000;
+pelo[] lista ;
+float[] z = new float[cuantos]; 
+float[] phi = new float[cuantos]; 
+float[] largos = new float[cuantos]; 
+float radio = 200;
+float rx = 0;
+float ry =0;
+
+void setup() {
+  size(1024, 768, P3D);
+  radio = height/3.5;
+  
+  lista = new pelo[cuantos];
+  for (int i=0; i<cuantos; i++){
+    lista[i] = new pelo();
+  }
+  noiseDetail(3);
+
+}
+
+void draw() {
+  background(0);
+  translate(width/2,height/2);
+
+  float rxp = ((mouseX-(width/2))*0.005);
+  float ryp = ((mouseY-(height/2))*0.005);
+  rx = (rx*0.9)+(rxp*0.1);
+  ry = (ry*0.9)+(ryp*0.1);
+  rotateY(rx);
+  rotateX(ry);
+  fill(0);
+  noStroke();
+  sphere(radio);
+
+  for (int i=0;i<cuantos;i++){
+    lista[i].dibujar();
+
+  }
+  if (frameCount % 10 == 0) {
+    println(frameRate);
+  }  
+}
+
+
+class pelo
+{
+  float z = random(-radio,radio);
+  float phi = random(TWO_PI);
+  float largo = random(1.15,1.2);
+  float theta = asin(z/radio);
+
+    void dibujar(){
+
+    float off = (noise(millis() * 0.0005,sin(phi))-0.5) * 0.3;
+    float offb = (noise(millis() * 0.0007,sin(z) * 0.01)-0.5) * 0.3;
+
+    float thetaff = theta+off;
+    float phff = phi+offb;
+    float x = radio * cos(theta) * cos(phi);
+    float y = radio * cos(theta) * sin(phi);
+    float z = radio * sin(theta);
+    float msx= screenX(x,y,z);
+    float msy= screenY(x,y,z);
+
+    float xo = radio * cos(thetaff) * cos(phff);
+    float yo = radio * cos(thetaff) * sin(phff);
+    float zo = radio * sin(thetaff);
+
+    float xb = xo * largo;
+    float yb = yo * largo;
+    float zb = zo * largo;
+    
+    strokeWeight(1);
+    beginShape(LINES);
+    stroke(0);
+    vertex(x,y,z);
+    stroke(200,150);
+    vertex(xb,yb,zb);
+    endShape();
+  }
+}
diff --git a/java/libraries/opengl/examples/Performance/LineRendering/LineRendering.pde b/java/libraries/opengl/examples/Performance/LineRendering/LineRendering.pde
new file mode 100755
index 000000000..465f4a557
--- /dev/null
+++ b/java/libraries/opengl/examples/Performance/LineRendering/LineRendering.pde
@@ -0,0 +1,25 @@
+import processing.opengl.*;
+
+public void setup() {
+  size(800, 600, OPENGL);  
+}
+  
+public void draw() {    
+  background(255);
+  stroke(0, 10);
+  for (int i = 0; i < 50000; i++) {
+    float x0 = random(width);
+    float y0 = random(height);
+    float z0 = random(-100, 100);
+    float x1 = random(width);
+    float y1 = random(height);
+    float z1 = random(-100, 100);    
+    
+    // purely 2D lines will trigger the GLU 
+    // tessellator to add accurate line caps,
+    // but performance will be substantially
+    // lower.
+    line(x0, y0, z0, x1, y1, z1);
+  }
+  if (frameCount % 10 == 0) println(frameRate);
+}
diff --git a/java/libraries/opengl/examples/Performance/QuadRendering/QuadRendering.pde b/java/libraries/opengl/examples/Performance/QuadRendering/QuadRendering.pde
new file mode 100755
index 000000000..7b3fba0e1
--- /dev/null
+++ b/java/libraries/opengl/examples/Performance/QuadRendering/QuadRendering.pde
@@ -0,0 +1,18 @@
+import processing.opengl.*;
+
+public void setup() {
+  size(800, 600, OPENGL);
+  
+  noStroke();
+  fill(0, 1);  
+}
+  
+public void draw() {    
+  background(255);
+  for (int i = 0; i < 50000; i++) {
+    float x = random(width);
+    float y = random(height);
+    rect(x, y, 30, 30);
+  }
+  if (frameCount % 10 == 0) println(frameRate);
+}
diff --git a/java/libraries/opengl/examples/Performance/TextRendering/TextRendering.pde b/java/libraries/opengl/examples/Performance/TextRendering/TextRendering.pde
new file mode 100755
index 000000000..b0d4cb5a4
--- /dev/null
+++ b/java/libraries/opengl/examples/Performance/TextRendering/TextRendering.pde
@@ -0,0 +1,16 @@
+import processing.opengl.*;
+
+public void setup() {
+  size(800, 600, OPENGL);
+  fill(0);
+}
+  
+public void draw() {    
+  background(255);
+  for (int i = 0; i < 10000; i++) {
+    float x = random(width);
+    float y = random(height);
+    text("HELLO", x, y);
+  }
+  if (frameCount % 10 == 0) println(frameRate);
+}
diff --git a/java/libraries/opengl/examples/Retained/PolyImmediate/PolyImmediate.pde b/java/libraries/opengl/examples/Retained/PolyImmediate/PolyImmediate.pde
new file mode 100755
index 000000000..ecf02efa2
--- /dev/null
+++ b/java/libraries/opengl/examples/Retained/PolyImmediate/PolyImmediate.pde
@@ -0,0 +1,18 @@
+size(100, 100, P3D);
+
+beginShape(POLYGON);
+fill(0, 255, 0, 255);
+stroke(0, 0, 255, 255);
+strokeWeight(10);
+strokeJoin(ROUND);
+vertex(10, 10);
+vertex(10, 90);
+vertex(90, 90);
+vertex(90, 10);  
+breakShape();
+vertex(40, 40);
+vertex(70, 40);
+vertex(70, 70);
+vertex(40, 70);
+endShape(CLOSE);
+
diff --git a/java/libraries/opengl/examples/Retained/PolyRetain/PolyRetain.pde b/java/libraries/opengl/examples/Retained/PolyRetain/PolyRetain.pde
new file mode 100755
index 000000000..3fc7961a8
--- /dev/null
+++ b/java/libraries/opengl/examples/Retained/PolyRetain/PolyRetain.pde
@@ -0,0 +1,19 @@
+size(100, 100, P3D);
+
+PShape3D obj = (PShape3D)createShape(POLYGON);
+obj.fill(0, 255, 0, 255);
+obj.stroke(0, 0, 255, 255);
+obj.strokeWeight(10);
+obj.strokeJoin(ROUND);
+obj.vertex(10, 10);
+obj.vertex(10, 90);
+obj.vertex(90, 90);
+obj.vertex(90, 10);  
+obj.breakShape();
+obj.vertex(40, 40);
+obj.vertex(70, 40);
+obj.vertex(70, 70);
+obj.vertex(40, 70);
+obj.end(CLOSE);
+
+shape(obj);
diff --git a/java/libraries/opengl/examples/Retained/Shape2_18/Shape2_18.pde b/java/libraries/opengl/examples/Retained/Shape2_18/Shape2_18.pde
new file mode 100755
index 000000000..8403caa95
--- /dev/null
+++ b/java/libraries/opengl/examples/Retained/Shape2_18/Shape2_18.pde
@@ -0,0 +1,15 @@
+size(100, 100, P3D);
+smooth();
+
+PShape3D obj = (PShape3D)createShape();
+obj.noFill();
+obj.stroke(0);
+obj.strokeWeight(1);
+obj.vertex(15, 40); // V1 (see p.76)
+obj.bezierVertex(5, 0, 80, 0, 50, 55); // C1, C2, V2
+obj.vertex(30, 45); // V3
+obj.vertex(25, 75); // V4
+obj.bezierVertex(50, 70, 75, 90, 80, 70); // C3, C4, V5
+obj.end();  
+
+shape(obj);
diff --git a/java/libraries/opengl/examples/Textures/Texture1/Texture1.pde b/java/libraries/opengl/examples/Textures/Texture1/Texture1.pde
new file mode 100755
index 000000000..7eb36310a
--- /dev/null
+++ b/java/libraries/opengl/examples/Textures/Texture1/Texture1.pde
@@ -0,0 +1,28 @@
+/**
+ * Texture 1. 
+ * 
+ * Load an image and draw it onto a quad. The texture() function sets
+ * the texture image. The vertex() function maps the image to the geometry.
+ */
+
+PImage img;
+
+void setup() {
+  size(640, 360, P3D);
+  img = loadImage("berlin-1.jpg");
+  noStroke();
+}
+
+void draw() {
+  background(0);
+  translate(width / 2, height / 2);
+  rotateY(map(mouseX, 0, width, -PI, PI));
+  rotateZ(PI/6);
+  beginShape();
+  texture(img);
+  vertex(-100, -100, 0, 0, 0);
+  vertex(100, -100, 0, 400, 0);
+  vertex(100, 100, 0, 400, 400);
+  vertex(-100, 100, 0, 0, 400);
+  endShape();
+}
diff --git a/java/libraries/opengl/examples/Textures/Texture2/Texture2.pde b/java/libraries/opengl/examples/Textures/Texture2/Texture2.pde
new file mode 100755
index 000000000..1398fd3e5
--- /dev/null
+++ b/java/libraries/opengl/examples/Textures/Texture2/Texture2.pde
@@ -0,0 +1,25 @@
+/**
+ * Texture 2. 
+ * 
+ * Using a rectangular image to map a texture onto a triangle.
+ */
+
+PImage img;
+
+void setup() {
+  size(640, 360, P3D);
+  img = loadImage("berlin-1.jpg");
+  noStroke();
+}
+
+void draw() {
+  background(0);
+  translate(width / 2, height / 2);
+  rotateY(map(mouseX, 0, width, -PI, PI));
+  beginShape();
+  texture(img);
+  vertex(-100, -100, 0, 0, 0);
+  vertex(100, -40, 0, 400, 120);
+  vertex(0, 100, 0, 200, 400);
+  endShape();
+}
diff --git a/java/libraries/opengl/examples/Textures/Texture3/Texture3.pde b/java/libraries/opengl/examples/Textures/Texture3/Texture3.pde
new file mode 100755
index 000000000..66130f1e5
--- /dev/null
+++ b/java/libraries/opengl/examples/Textures/Texture3/Texture3.pde
@@ -0,0 +1,46 @@
+/**
+ * Texture 3. 
+ * 
+ * Load an image and draw it onto a cylinder and a quad. 
+ */
+
+
+int tubeRes = 32;
+float[] tubeX = new float[tubeRes];
+float[] tubeY = new float[tubeRes];
+PImage img;
+
+void setup() {
+  size(640, 360, P3D);
+  img = loadImage("berlin-1.jpg");
+  float angle = 270.0 / tubeRes;
+  for (int i = 0; i < tubeRes; i++) {
+    tubeX[i] = cos(radians(i * angle));
+    tubeY[i] = sin(radians(i * angle));
+  }
+  noStroke();
+}
+
+void draw() {
+  background(0);
+  translate(width / 2, height / 2);
+  rotateX(map(mouseY, 0, height, -PI, PI));
+  rotateY(map(mouseX, 0, width, -PI, PI));
+  beginShape(QUAD_STRIP);
+  texture(img);
+  for (int i = 0; i < tubeRes; i++) {
+    float x = tubeX[i] * 100;
+    float z = tubeY[i] * 100;
+    float u = img.width / tubeRes * i;
+    vertex(x, -100, z, u, 0);
+    vertex(x, 100, z, u, img.height);
+  }
+  endShape();
+  beginShape(QUADS);
+  texture(img);
+  vertex(0, -100, 0, 0, 0);
+  vertex(100, -100, 0, 100, 0);
+  vertex(100, 100, 0, 100, 100);
+  vertex(0, 100, 0, 0, 100);
+  endShape();
+}
diff --git a/java/libraries/opengl/examples/Textures/TextureCube/TextureCube.pde b/java/libraries/opengl/examples/Textures/TextureCube/TextureCube.pde
new file mode 100755
index 000000000..38df04997
--- /dev/null
+++ b/java/libraries/opengl/examples/Textures/TextureCube/TextureCube.pde
@@ -0,0 +1,91 @@
+/**
+ * TexturedCube
+ * by Dave Bollinger.
+ * 
+ * Drag mouse to rotate cube. Demonstrates use of u/v coords in 
+ * vertex() and effect on texture(). The textures get distorted using
+ * the P3D renderer as you can see, but they look great using OPENGL.
+*/
+
+
+PImage tex;
+float rotx = PI/4;
+float roty = PI/4;
+
+void setup() 
+{
+  size(640, 360, P3D);
+  tex = loadImage("berlin-1.jpg");
+  textureMode(NORMALIZED);
+  fill(255);
+  stroke(color(44,48,32));
+}
+
+void draw() 
+{
+  background(0);
+  noStroke();
+  translate(width/2.0, height/2.0, -100);
+  rotateX(rotx);
+  rotateY(roty);
+  scale(90);
+  TexturedCube(tex);
+}
+
+void TexturedCube(PImage tex) {
+  beginShape(QUADS);
+  texture(tex);
+
+  // Given one texture and six faces, we can easily set up the uv coordinates
+  // such that four of the faces tile "perfectly" along either u or v, but the other
+  // two faces cannot be so aligned.  This code tiles "along" u, "around" the X/Z faces
+  // and fudges the Y faces - the Y faces are arbitrarily aligned such that a
+  // rotation along the X axis will put the "top" of either texture at the "top"
+  // of the screen, but is not otherwised aligned with the X/Z faces. (This
+  // just affects what type of symmetry is required if you need seamless
+  // tiling all the way around the cube)
+  
+  // +Z "front" face
+  vertex(-1, -1,  1, 0, 0);
+  vertex( 1, -1,  1, 1, 0);
+  vertex( 1,  1,  1, 1, 1);
+  vertex(-1,  1,  1, 0, 1);
+
+  // -Z "back" face
+  vertex( 1, -1, -1, 0, 0);
+  vertex(-1, -1, -1, 1, 0);
+  vertex(-1,  1, -1, 1, 1);
+  vertex( 1,  1, -1, 0, 1);
+
+  // +Y "bottom" face
+  vertex(-1,  1,  1, 0, 0);
+  vertex( 1,  1,  1, 1, 0);
+  vertex( 1,  1, -1, 1, 1);
+  vertex(-1,  1, -1, 0, 1);
+
+  // -Y "top" face
+  vertex(-1, -1, -1, 0, 0);
+  vertex( 1, -1, -1, 1, 0);
+  vertex( 1, -1,  1, 1, 1);
+  vertex(-1, -1,  1, 0, 1);
+
+  // +X "right" face
+  vertex( 1, -1,  1, 0, 0);
+  vertex( 1, -1, -1, 1, 0);
+  vertex( 1,  1, -1, 1, 1);
+  vertex( 1,  1,  1, 0, 1);
+
+  // -X "left" face
+  vertex(-1, -1, -1, 0, 0);
+  vertex(-1, -1,  1, 1, 0);
+  vertex(-1,  1,  1, 1, 1);
+  vertex(-1,  1, -1, 0, 1);
+
+  endShape();
+}
+
+void mouseDragged() {
+  float rate = 0.01;
+  rotx += (pmouseY-mouseY) * rate;
+  roty += (mouseX-pmouseX) * rate;
+}
diff --git a/java/libraries/opengl/examples/Transform/Bird/Bird.pde b/java/libraries/opengl/examples/Transform/Bird/Bird.pde
new file mode 100755
index 000000000..dacd405d1
--- /dev/null
+++ b/java/libraries/opengl/examples/Transform/Bird/Bird.pde
@@ -0,0 +1,63 @@
+/**
+ * Simple 3D Bird 
+ * by Ira Greenberg.  
+ * 
+ * Using a box and 2 rects to simulate a flying bird. 
+ * Trig functions handle the flapping and sinuous movement.
+ */
+
+float ang = 0, ang2 = 0, ang3 = 0, ang4 = 0;
+float px = 0, py = 0, pz = 0;
+float flapSpeed = 0.2;
+
+void setup(){
+  size(640, 360, P3D);
+  noStroke();
+}
+
+void draw(){
+  background(0);
+  lights();
+
+  // Flight
+  px = sin(radians(ang3)) * 170;
+  py = cos(radians(ang3)) * 300;
+  pz = sin(radians(ang4)) * 500;
+  translate(width/2 + px, height/2 + py, -700+pz);
+  rotateX(sin(radians(ang2)) * 120);
+  rotateY(sin(radians(ang2)) * 50);
+  rotateZ(sin(radians(ang2)) * 65);
+  
+  // Body
+  fill(153);
+  box(20, 100, 20);
+
+  
+  // Left wing
+  fill(204);
+  pushMatrix();
+  rotateY(sin(radians(ang)) * -20);
+  rect(-75, -50, 75, 100);
+  popMatrix();
+
+  // Right wing
+  pushMatrix();
+  rotateY(sin(radians(ang)) * 20);
+  rect(0, -50, 75, 100);
+  popMatrix();
+
+  // Wing flap
+  ang += flapSpeed;
+  if (ang > 3) {
+    flapSpeed *= -1;
+  } 
+  if (ang < -3) {
+    flapSpeed *= -1;
+  }
+
+  // Increment angles
+  ang2 += 0.01;
+  ang3 += 2.0;
+  ang4 += 0.75;
+}
+
diff --git a/java/libraries/opengl/examples/Transform/Birds/Bird.pde b/java/libraries/opengl/examples/Transform/Birds/Bird.pde
new file mode 100755
index 000000000..84ada2603
--- /dev/null
+++ b/java/libraries/opengl/examples/Transform/Birds/Bird.pde
@@ -0,0 +1,99 @@
+class Bird {
+  
+  // Properties
+  float offsetX, offsetY, offsetZ;
+  float w, h;
+  int bodyFill;
+  int wingFill;
+  float ang = 0, ang2 = 0, ang3 = 0, ang4 = 0;
+  float radiusX = 120, radiusY = 200, radiusZ = 700;
+  float rotX = 15, rotY = 10, rotZ = 5;
+  float flapSpeed = 0.4;
+  float rotSpeed = 0.1;
+
+  // Constructors
+  Bird(){
+    this(0, 0, 0, 60, 80);
+  }
+
+  Bird(float offsetX, float offsetY, float offsetZ, 
+  float w, float h){
+    this.offsetX = offsetX;
+    this.offsetY = offsetY;
+    this.offsetZ = offsetZ;
+    this.h = h;
+    this.w = w;
+    bodyFill = color(153);
+    wingFill = color(204);
+  }
+
+  void setFlight(float radiusX, float radiusY, float radiusZ, 
+    float rotX, float rotY, float rotZ){
+    this.radiusX = radiusX;
+    this.radiusY = radiusY;
+    this.radiusZ = radiusZ;
+
+    this.rotX = rotX;
+    this.rotY = rotY;
+    this.rotZ = rotZ;
+  }
+
+  void setWingSpeed(float flapSpeed){
+    this.flapSpeed = flapSpeed;
+  }
+
+  void setRotSpeed(float rotSpeed){
+    this.rotSpeed = rotSpeed;
+  }
+
+  void fly() {
+    pushMatrix();
+    float px, py, pz;
+    
+    // Flight
+    px = sin(radians(ang3)) * radiusX;
+    py = cos(radians(ang3)) * radiusY;
+    pz = sin(radians(ang4)) * radiusZ;
+    
+    translate(width/2 + offsetX + px, height/2 + offsetY+py, -700 + offsetZ+pz);
+
+    rotateX(sin(radians(ang2)) * rotX);
+    rotateY(sin(radians(ang2)) * rotY);
+    rotateZ(sin(radians(ang2)) * rotZ);
+
+    // Body
+    fill(bodyFill);
+    box(w/5, h, w/5);
+
+    // Left wing
+    fill(wingFill);
+    pushMatrix();
+    rotateY(sin(radians(ang)) * 20);
+    rect(0, -h/2, w, h);
+    popMatrix();
+
+    // Right wing
+    pushMatrix();
+    rotateY(sin(radians(ang)) * -20);
+    rect(-w, -h/2, w, h);
+    popMatrix();
+
+    // Wing flap
+    ang += flapSpeed;
+    if (ang > 3) {
+      flapSpeed*=-1;
+    } 
+    if (ang < -3) {
+      flapSpeed*=-1;
+    }
+
+    // Ang's run trig functions
+    ang2 += rotSpeed;
+    ang3 += 1.25;
+    ang4 += 0.55;
+    popMatrix();
+  }
+}
+
+
+
diff --git a/java/libraries/opengl/examples/Transform/Birds/Birds.pde b/java/libraries/opengl/examples/Transform/Birds/Birds.pde
new file mode 100755
index 000000000..5026bd2ae
--- /dev/null
+++ b/java/libraries/opengl/examples/Transform/Birds/Birds.pde
@@ -0,0 +1,53 @@
+/**
+ * Crazy Flocking 3D Birds 
+ * by Ira Greenberg. 
+ * 
+ * Simulates a flock of birds using a Bird class and nested
+ * pushMatrix() / popMatrix() functions. 
+ * Trigonometry functions handle the flapping and sinuous movement.
+ */
+
+// Flock array
+int birdCount = 200;
+Bird[]birds = new Bird[birdCount];
+float[]x = new float[birdCount];
+float[]y = new float[birdCount];
+float[]z = new float[birdCount];
+float[]rx = new float[birdCount];
+float[]ry = new float[birdCount];
+float[]rz = new float[birdCount];
+float[]spd = new float[birdCount];
+float[]rot = new float[birdCount];
+
+void setup() {
+  size(640, 360, P3D);
+  noStroke();
+
+  // Initialize arrays with random values
+  for (int i = 0; i < birdCount; i++){
+    birds[i] = new Bird(random(-300, 300), random(-300, 300), 
+               random(-500, -2500), random(5, 30), random(5, 30)); 
+
+    x[i] = random(20, 340);
+    y[i] = random(30, 350);
+    z[i] = random(1000, 4800);
+    rx[i] = random(-160, 160);
+    ry[i] = random(-55, 55);
+    rz[i] = random(-20, 20);
+    spd[i] = random(.1, 3.75);
+    rot[i] = random(.025, .15);
+  }
+}
+
+void draw() {
+  background(0);
+  lights();
+  for (int i = 0; i < birdCount; i++){
+    birds[i].setFlight(x[i], y[i], z[i], rx[i], ry[i], rz[i]);
+    birds[i].setWingSpeed(spd[i]);
+    birds[i].setRotSpeed(rot[i]);
+    birds[i].fly();
+  }
+}
+
+
diff --git a/java/libraries/opengl/examples/Transform/CubesWithinCube/Cube.pde b/java/libraries/opengl/examples/Transform/CubesWithinCube/Cube.pde
new file mode 100755
index 000000000..271792623
--- /dev/null
+++ b/java/libraries/opengl/examples/Transform/CubesWithinCube/Cube.pde
@@ -0,0 +1,72 @@
+
+// Custom Cube Class
+
+class Cube{
+  PVector[] vertices = new PVector[24];
+  float w, h, d;
+
+  // Default constructor
+  Cube(){ }
+
+  // Constructor 2
+  Cube(float w, float h, float d) {
+    this.w = w;
+    this.h = h;
+    this.d = d;
+
+    // cube composed of 6 quads
+    //front
+    vertices[0] = new PVector(-w/2,-h/2,d/2);
+    vertices[1] = new PVector(w/2,-h/2,d/2);
+    vertices[2] = new PVector(w/2,h/2,d/2);
+    vertices[3] = new PVector(-w/2,h/2,d/2);
+    //left
+    vertices[4] = new PVector(-w/2,-h/2,d/2);
+    vertices[5] = new PVector(-w/2,-h/2,-d/2);
+    vertices[6] = new PVector(-w/2,h/2,-d/2);
+    vertices[7] = new PVector(-w/2,h/2,d/2);
+    //right
+    vertices[8] = new PVector(w/2,-h/2,d/2);
+    vertices[9] = new PVector(w/2,-h/2,-d/2);
+    vertices[10] = new PVector(w/2,h/2,-d/2);
+    vertices[11] = new PVector(w/2,h/2,d/2);
+    //back
+    vertices[12] = new PVector(-w/2,-h/2,-d/2); 
+    vertices[13] = new PVector(w/2,-h/2,-d/2);
+    vertices[14] = new PVector(w/2,h/2,-d/2);
+    vertices[15] = new PVector(-w/2,h/2,-d/2);
+    //top
+    vertices[16] = new PVector(-w/2,-h/2,d/2);
+    vertices[17] = new PVector(-w/2,-h/2,-d/2);
+    vertices[18] = new PVector(w/2,-h/2,-d/2);
+    vertices[19] = new PVector(w/2,-h/2,d/2);
+    //bottom
+    vertices[20] = new PVector(-w/2,h/2,d/2);
+    vertices[21] = new PVector(-w/2,h/2,-d/2);
+    vertices[22] = new PVector(w/2,h/2,-d/2);
+    vertices[23] = new PVector(w/2,h/2,d/2);
+  }
+  void create(){
+    // Draw cube
+    for (int i=0; i<6; i++){
+      beginShape(QUADS);
+      for (int j=0; j<4; j++){
+        vertex(vertices[j+4*i].x, vertices[j+4*i].y, vertices[j+4*i].z);
+      }
+      endShape();
+    }
+  }
+  void create(color[]quadBG){
+    // Draw cube
+    for (int i=0; i<6; i++){
+      fill(quadBG[i]);
+      beginShape(QUADS);
+      for (int j=0; j<4; j++){
+        vertex(vertices[j+4*i].x, vertices[j+4*i].y, vertices[j+4*i].z);
+      }
+      endShape();
+    }
+  }
+}
+
+
diff --git a/java/libraries/opengl/examples/Transform/CubesWithinCube/CubesWithinCube.pde b/java/libraries/opengl/examples/Transform/CubesWithinCube/CubesWithinCube.pde
new file mode 100755
index 000000000..b20420fcc
--- /dev/null
+++ b/java/libraries/opengl/examples/Transform/CubesWithinCube/CubesWithinCube.pde
@@ -0,0 +1,117 @@
+/**
+ * Cubes Contained Within a Cube 
+ * by Ira Greenberg.  
+ * 
+ * Collision detection against all
+ * outer cube's surfaces. 
+ * Uses the Point3D and Cube classes. 
+ */
+
+Cube stage; // external large cube
+int cubies = 20;
+Cube[]c = new Cube[cubies]; // internal little cubes
+color[][]quadBG = new color[cubies][6];
+
+// Controls cubie's movement
+float[]x = new float[cubies];
+float[]y = new float[cubies];
+float[]z = new float[cubies];
+float[]xSpeed = new float[cubies];
+float[]ySpeed = new float[cubies];
+float[]zSpeed = new float[cubies];
+
+// Controls cubie's rotation
+float[]xRot = new float[cubies];
+float[]yRot = new float[cubies];
+float[]zRot = new float[cubies];
+
+// Size of external cube
+float bounds = 300;
+
+void setup() {
+  size(640, 360, P3D);
+  
+  for (int i = 0; i < cubies; i++){
+    // Each cube face has a random color component
+    float colorShift = random(-75, 75);
+    quadBG[i][0] = color(0);
+    quadBG[i][1] = color(51);
+    quadBG[i][2] = color(102);
+    quadBG[i][3] = color(153);
+    quadBG[i][4] = color(204);
+    quadBG[i][5] = color(255);
+
+    // Cubies are randomly sized
+    float cubieSize = random(5, 15);
+    c[i] =  new Cube(cubieSize, cubieSize, cubieSize);
+
+    // Initialize cubie's position, speed and rotation
+    x[i] = 0;
+    y[i] = 0; 
+    z[i] = 0;
+
+    xSpeed[i] = random(-1, 1);
+    ySpeed[i] = random(-1, 1); 
+    zSpeed[i] = random(-1, 1); 
+
+    xRot[i] = random(40, 100);
+    yRot[i] = random(40, 100);
+    zRot[i] = random(40, 100);
+  }
+  
+  // Instantiate external large cube
+  stage =  new Cube(bounds, bounds, bounds);
+}
+
+void draw(){
+  background(50);
+  lights();
+  
+  // Center in display window
+  translate(width/2, height/2, -130);
+  
+  // Outer transparent cube
+  noFill(); 
+  
+  // Rotate everything, including external large cube
+  rotateX(frameCount * 0.001);
+  rotateY(frameCount * 0.002);
+  rotateZ(frameCount * 0.001);
+  stroke(255);
+  
+  // Draw external large cube
+  stage.create();
+
+  // Move and rotate cubies
+  for (int i = 0; i < cubies; i++){
+    pushMatrix();
+    translate(x[i], y[i], z[i]);
+    rotateX(frameCount*PI/xRot[i]);
+    rotateY(frameCount*PI/yRot[i]);
+    rotateX(frameCount*PI/zRot[i]);
+    noStroke();
+    c[i].create(quadBG[i]);
+    x[i] += xSpeed[i];
+    y[i] += ySpeed[i];
+    z[i] += zSpeed[i];
+    popMatrix();
+
+    // Draw lines connecting cubbies
+    stroke(0);
+    if (i < cubies-1){
+      line(x[i], y[i], z[i], x[i+1], y[i+1], z[i+1]);
+    }
+
+    // Check wall collisions
+    if (x[i] > bounds/2 || x[i] < -bounds/2){
+      xSpeed[i]*=-1;
+    }
+    if (y[i] > bounds/2 || y[i] < -bounds/2){
+      ySpeed[i]*=-1;
+    }
+    if (z[i] > bounds/2 || z[i] < -bounds/2){
+      zSpeed[i]*=-1;
+    }
+  }
+}
+
diff --git a/java/libraries/opengl/examples/Transform/PushPopCubes/PushPopCubes.pde b/java/libraries/opengl/examples/Transform/PushPopCubes/PushPopCubes.pde
new file mode 100755
index 000000000..52ae70fdc
--- /dev/null
+++ b/java/libraries/opengl/examples/Transform/PushPopCubes/PushPopCubes.pde
@@ -0,0 +1,144 @@
+/**
+ * PushPop Cubes  
+ * by Ira Greenberg.  
+ * 
+ * Array of rotating cubes creates
+ * dynamic field patterns. Color
+ * controlled by light sources. Example 
+ * of pushMatrix() and popMatrix().
+ */
+
+// Cube class required
+float ang;
+int rows = 21;
+int cols = 21;
+int cubeCount = rows*cols;
+int colSpan, rowSpan;
+float rotspd = 2.0;
+Cube[] cubes = new Cube[cubeCount];
+float[] angs = new float[cubeCount];
+float[] rotvals = new float[cubeCount];
+
+void setup(){
+  size(640, 360, P3D);
+
+  colSpan = width/(cols-1);
+  rowSpan = height/(rows-1);
+  noStroke(); 
+
+  // instantiate cubes
+  for (int i = 0; i < cubeCount; i++){
+    cubes[i] = new Cube(12, 12, 6, 0, 0, 0);
+    /* 3 different rotation options
+       - 1st option: cubes each rotate uniformly
+       - 2nd option: cubes each rotate randomly
+       - 3rd option: cube columns rotate as waves
+       To try the different rotations, leave one 
+       of the rotVals[i] lines uncommented below
+       and the other 2 commented out. */
+    
+    //rotvals[i] = rotspd;
+    //rotvals[i] = random(-rotspd * 2, rotspd * 2);
+    rotvals[i] = rotspd += .01;
+  }
+}
+
+void draw(){
+  int cubeCounter = 0;
+  background(0);
+  fill(200);
+  
+  // Set up some different colored lights
+  pointLight(51, 102, 255, width/3, height/2, 100); 
+  pointLight(200, 40, 60,  width/1.5, height/2, -150);
+
+  // Raise overall light in scene 
+  ambientLight(170, 170, 100); 
+
+  // Translate, rotate and draw cubes
+  for (int i = 0; i < cols; i++){
+    for (int j = 0; j < rows; j++){
+      pushMatrix();
+      /* Translate each block.
+         pushmatix and popmatrix add each cube
+         translation to matrix, but restore
+         original, so each cube rotates around its
+         owns center */
+      translate(i * colSpan, j * rowSpan, -20);
+      //rotate each cube around y and x axes
+      rotateY(radians(angs[cubeCounter]));
+      rotateX(radians(angs[cubeCounter]));
+      cubes[cubeCounter].drawCube();
+      popMatrix();
+      cubeCounter++;
+    }
+  }
+  // Angs used in rotate function calls above
+  for (int i = 0; i < cubeCount; i++){
+    angs[i] += rotvals[i];
+  }
+}
+
+// Simple Cube class, based on Quads
+class Cube {
+
+  // Properties
+  int w, h, d;
+  int shiftX, shiftY, shiftZ;
+
+  // Constructor
+  Cube(int w, int h, int d, int shiftX, int shiftY, int shiftZ){
+    this.w = w;
+    this.h = h;
+    this.d = d;
+    this.shiftX = shiftX;
+    this.shiftY = shiftY;
+    this.shiftZ = shiftZ;
+  }
+
+  /* Main cube drawing method, which looks 
+     more confusing than it really is. It's 
+     just a bunch of rectangles drawn for 
+     each cube face */
+  void drawCube(){
+    
+    // Front face
+    beginShape(QUADS);
+    vertex(-w/2 + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, h + shiftY, -d/2 + shiftZ); 
+    vertex(-w/2 + shiftX, h + shiftY, -d/2 + shiftZ); 
+
+    // Back face
+    vertex(-w/2 + shiftX, -h/2 + shiftY, d + shiftZ); 
+    vertex(w + shiftX, -h/2 + shiftY, d + shiftZ); 
+    vertex(w + shiftX, h + shiftY, d + shiftZ); 
+    vertex(-w/2 + shiftX, h + shiftY, d + shiftZ);
+
+    // Left face
+    vertex(-w/2 + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(-w/2 + shiftX, -h/2 + shiftY, d + shiftZ); 
+    vertex(-w/2 + shiftX, h + shiftY, d + shiftZ); 
+    vertex(-w/2 + shiftX, h + shiftY, -d/2 + shiftZ); 
+
+    // Right face
+    vertex(w + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, -h/2 + shiftY, d + shiftZ); 
+    vertex(w + shiftX, h + shiftY, d + shiftZ); 
+    vertex(w + shiftX, h + shiftY, -d/2 + shiftZ); 
+
+    // Top face
+    vertex(-w/2 + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, -h/2 + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, -h/2 + shiftY, d + shiftZ); 
+    vertex(-w/2 + shiftX, -h/2 + shiftY, d + shiftZ); 
+
+    // Bottom face
+    vertex(-w/2 + shiftX, h + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, h + shiftY, -d/2 + shiftZ); 
+    vertex(w + shiftX, h + shiftY, d + shiftZ); 
+    vertex(-w/2 + shiftX, h + shiftY, d + shiftZ); 
+    endShape(); 
+  }
+}
+
diff --git a/java/libraries/opengl/examples/Transform/Rotate1/Rotate1.pde b/java/libraries/opengl/examples/Transform/Rotate1/Rotate1.pde
new file mode 100755
index 000000000..7aafc250a
--- /dev/null
+++ b/java/libraries/opengl/examples/Transform/Rotate1/Rotate1.pde
@@ -0,0 +1,38 @@
+/**
+ * Rotate 1. 
+ * 
+ * Rotating simultaneously in the X and Y axis. 
+ * Transformation functions such as rotate() are additive.
+ * Successively calling rotate(1.0) and rotate(2.0)
+ * is equivalent to calling rotate(3.0). 
+ */
+ 
+float a = 0.0;
+float rSize;  // rectangle size
+
+void setup() {
+  size(640, 360, P3D);
+  rSize = width / 6;  
+  noStroke();
+  fill(204, 204);
+}
+
+void draw() {
+  background(0);
+  
+  a += 0.005;
+  if(a > TWO_PI) { 
+    a = 0.0; 
+  }
+  
+  translate(width/2, height/2);
+  
+  rotateX(a);
+  rotateY(a * 2.0);
+  rect(-rSize, -rSize, rSize*2, rSize*2);
+  
+  rotateX(a * 1.001);
+  rotateY(a * 2.002);
+  rect(-rSize, -rSize, rSize*2, rSize*2);
+
+}
diff --git a/java/libraries/opengl/examples/Transform/Rotate2/Rotate2.pde b/java/libraries/opengl/examples/Transform/Rotate2/Rotate2.pde
new file mode 100755
index 000000000..1d5af0d49
--- /dev/null
+++ b/java/libraries/opengl/examples/Transform/Rotate2/Rotate2.pde
@@ -0,0 +1,42 @@
+/**
+ * Rotate 2. 
+ * 
+ * The push() and pop() functions allow for more control over transformations.
+ * The push function saves the current coordinate system to the stack 
+ * and pop() restores the prior coordinate system. 
+ */
+ 
+float a;                          // Angle of rotation
+float offset = PI/24.0;             // Angle offset between boxes
+int num = 12;                     // Number of boxes
+color[] colors = new color[num];  // Colors of each box
+color safecolor;
+
+boolean pink = true;
+
+void setup() 
+{ 
+  size(640, 360, P3D);
+  noStroke();  
+  for(int i=0; i<num; i++) {
+    colors[i] = color(255 * (i+1)/num);
+  }
+  lights();
+} 
+ 
+
+void draw() 
+{     
+  background(0, 0, 26);
+  translate(width/2, height/2);
+  a += 0.01;   
+  
+  for(int i = 0; i < num; i++) {
+    pushMatrix();
+    fill(colors[i]);
+    rotateY(a + offset*i);
+    rotateX(a/2 + offset*i);
+    box(200);
+    popMatrix();
+  }
+} 
diff --git a/java/libraries/opengl/examples/Typography/KineticType/KineticType.pde b/java/libraries/opengl/examples/Typography/KineticType/KineticType.pde
new file mode 100755
index 000000000..7be49dfb5
--- /dev/null
+++ b/java/libraries/opengl/examples/Typography/KineticType/KineticType.pde
@@ -0,0 +1,64 @@
+/**
+ * Kinetic Type 
+ * by Zach Lieberman. 
+ * 
+ * Using push() and pop() to define the curves of the lines of type. 
+ */
+ 
+Line ln;
+Line lns[];
+
+String words[] = {
+  "sometimes it's like", "the lines of text", "are so happy", "that they want to dance",
+  "or leave the page or jump", "can you blame them?", "living on the page like that",
+  "waiting to be read..."
+};
+
+void setup() {
+  size(640, 360, P3D);
+  
+  // Array of line objects
+  lns = new Line[8];
+
+  // Load the font from the sketch's data directory
+  textFont(loadFont("Univers-66.vlw"), 1.0);
+
+  // White type
+  fill(255);
+
+  // Creating the line objects
+  for(int i = 0; i < 8; i++) {
+    // For every line in the array, create a Line object to animate
+    // i * 70 is the spacing
+    ln = new Line(words[i], 0, i * 70);
+    lns[i] = ln;
+  }
+}
+
+void draw() {
+  background(0);
+  
+  translate(-200, -50, -450);
+  rotateY(0.3);
+
+  // Now animate every line object & draw it...
+  for(int i = 0; i < 8; i++) {
+    float f1 = sin((i + 1.0) * (millis() / 10000.0) * TWO_PI);
+    float f2 = sin((8.0 - i) * (millis() / 10000.0) * TWO_PI);
+    Line line = lns[i];
+    pushMatrix();
+    translate(0.0, line.yPosition, 0.0);
+    for(int j = 0; j < line.myLetters.length; j++) {
+      if(j != 0) {
+        translate(textWidth(line.myLetters[j - 1].myChar) * 75, 0.0, 0.0);
+      }
+      rotateY(f1 * 0.005 * f2);
+      pushMatrix();
+      scale(75.0);
+      text(line.myLetters[j].myChar, 0.0, 0.0);
+      popMatrix();
+    }
+    popMatrix();
+  }
+}
+
diff --git a/java/libraries/opengl/examples/Typography/KineticType/Letter.pde b/java/libraries/opengl/examples/Typography/KineticType/Letter.pde
new file mode 100755
index 000000000..d12a9a78d
--- /dev/null
+++ b/java/libraries/opengl/examples/Typography/KineticType/Letter.pde
@@ -0,0 +1,13 @@
+class Letter
+{
+  char myChar;
+  float x;
+  float y;
+  
+  Letter(char c, float f, float f1)
+  {
+    myChar = c;
+    x = f;
+    y = f1;
+  }
+}
diff --git a/java/libraries/opengl/examples/Typography/KineticType/Line.pde b/java/libraries/opengl/examples/Typography/KineticType/Line.pde
new file mode 100755
index 000000000..f01b9cdc8
--- /dev/null
+++ b/java/libraries/opengl/examples/Typography/KineticType/Line.pde
@@ -0,0 +1,28 @@
+class Line
+{
+  String myString;
+  int xPosition;
+  int yPosition;
+  int highlightNum;
+  float speed;
+  float curlInX;
+  Letter myLetters[];
+  
+  Line(String s, int i, int j) 
+  {
+    myString = s;
+    xPosition = i;
+    yPosition = j;
+    myLetters = new Letter[s.length()];
+    float f1 = 0.0;
+    for(int k = 0; k < s.length(); k++)
+    {
+      char c = s.charAt(k);
+      f1 += textWidth(c);
+      Letter letter = new Letter(c, f1, 0.0);
+      myLetters[k] = letter;
+    }
+
+    curlInX = 0.1;
+  }
+}
diff --git a/java/libraries/opengl/examples/Typography/KineticType/Word.pde b/java/libraries/opengl/examples/Typography/KineticType/Word.pde
new file mode 100755
index 000000000..6bc2f2deb
--- /dev/null
+++ b/java/libraries/opengl/examples/Typography/KineticType/Word.pde
@@ -0,0 +1,10 @@
+class Word
+{
+  String myName;
+  int x;
+  
+  Word(String s)
+  {
+    myName = s;
+  }
+}
diff --git a/java/libraries/opengl/examples/Typography/KineticType/data/Univers-66.vlw b/java/libraries/opengl/examples/Typography/KineticType/data/Univers-66.vlw
new file mode 100755
index 0000000000000000000000000000000000000000..d2d08c24749c2e3da957da256b80585a31514ddf
GIT binary patch
literal 116537
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
F{6Cf9$N&HU

literal 0
HcmV?d00001

diff --git a/java/libraries/opengl/examples/Typography/LetterK/LetterK.pde b/java/libraries/opengl/examples/Typography/LetterK/LetterK.pde
new file mode 100755
index 000000000..f2284d9a6
--- /dev/null
+++ b/java/libraries/opengl/examples/Typography/LetterK/LetterK.pde
@@ -0,0 +1,125 @@
+/**
+ * Letter K 
+ * by Peter Cho. 
+ * 
+ * Move the mouse across the screen to fold the "K". 
+ */
+ 
+color backgroundColor;
+color foregroundColor;
+color foregroundColor2;
+
+float px, py;
+float pfx, pfy;
+float pv2, pvx, pvy;
+float pa2, pax, pay;
+float pMass, pDrag;
+
+void setup() {
+  size(640, 360, P3D);
+  noStroke();
+  backgroundColor = color(134, 144, 154);
+  foregroundColor = color(235, 235, 30);
+  foregroundColor2 = color(240, 130, 20);
+  initParticle(0.6, 0.9,  width/2, height/2);
+}
+
+void draw() {
+  background(backgroundColor);
+  pushMatrix();
+
+  iterateParticle(0.15*(-px+mouseX), 0.15*(-py+(height-mouseY)));
+
+  translate(width/2, height/2, 0);
+  fill(foregroundColor);
+  drawK();
+ 
+  pushMatrix();
+  translate(0, 0, 1);
+  translate(0.75 * (px-width/2), -0.75 * (py-height/2), 0);
+  translate(0.75 * (px-width/2), -0.75 * (py-height/2), 0);
+  rotateZ(atan2(-(py-height/2), (px-width/2)) + PI/2);
+  rotateX(PI);
+  rotateZ(-(atan2(-(py-height/2), (px-width/2)) + PI/2));
+  
+  fill(foregroundColor2);
+  drawK();
+  popMatrix();
+
+  translate(0.75 * (px-width/2), -0.75 * (py-height/2), 2);
+  rotateZ(atan2(-(py-height/2), (px-width/2)) + PI/2);
+  
+  fill(backgroundColor);
+  beginShape(QUADS);
+  vertex(-640, 0);
+  vertex( 640, 0);
+  vertex( 640, -360);
+  vertex(-640, -360);
+  endShape();
+  
+  popMatrix();
+ 
+}
+
+void initParticle(float _mass, float _drag, float ox, float oy) {
+  px = ox;
+  py = oy;
+  pv2 = 0.0;
+  pvx = 0.0;
+  pvy = 0.0;
+  pa2 = 0.0;
+  pax = 0.0;
+  pay = 0.0;
+  pMass = _mass;
+  pDrag = _drag;
+}
+
+void iterateParticle(float fkx, float fky) {
+  // iterate for a single force acting on the particle
+  pfx = fkx;
+  pfy = fky;
+  pa2 = pfx*pfx + pfy*pfy;
+  if (pa2 < 0.0000001) {
+    return;
+  }
+  pax = pfx/pMass;
+  pay = pfy/pMass;
+  pvx += pax;
+  pvy += pay;
+  pv2 = pvx*pvx + pvy*pvy;
+  if (pv2 < 0.0000001) {
+    return;
+  }
+  pvx *= (1.0 - pDrag);
+  pvy *= (1.0 - pDrag);
+  px += pvx;
+  py += pvy;
+}
+
+void drawK() {
+  pushMatrix();
+  
+  scale(1.5);
+  translate(-63, 71);
+  beginShape(QUADS);
+  vertex(0, 0, 0);
+  vertex(0, -142.7979, 0);
+  vertex(37.1992, -142.7979, 0);
+  vertex(37.1992, 0, 0);
+  
+  vertex(37.1992, -87.9990, 0);
+  vertex(84.1987, -142.7979, 0);
+  vertex(130.3979, -142.7979, 0);
+  vertex(37.1992, -43.999, 0);
+
+  vertex(77.5986-.2, -86.5986-.3, 0);
+  vertex(136.998, 0, 0);
+  vertex(90.7988, 0, 0);
+  vertex(52.3994-.2, -59.999-.3, 0);
+  endShape();
+  //translate(63, -71);
+  popMatrix();
+}
+
+
+
diff --git a/java/libraries/opengl/examples/Typography/Typing/Typing.pde b/java/libraries/opengl/examples/Typography/Typing/Typing.pde
new file mode 100755
index 000000000..cc889531b
--- /dev/null
+++ b/java/libraries/opengl/examples/Typography/Typing/Typing.pde
@@ -0,0 +1,82 @@
+/**
+ * Typing (Excerpt from the piece Textension) 
+ * by Josh Nimoy.  
+ * 
+ * Click in the window to give it focus.
+ * Type to add letters and press backspace or delete to remove them. 
+ */
+
+
+int leftmargin = 10;
+int rightmargin = 20;
+String buff = "";
+boolean didntTypeYet = true;
+
+void setup()
+{
+  size(640, 360, P3D);
+  textFont(loadFont("Univers45.vlw"), 25);
+}
+
+void draw()
+{
+  background(176);
+
+  if((millis() % 500) < 250){  // Only fill cursor half the time
+    noFill();
+  }
+  else {
+    fill(255);
+    stroke(0);
+  }
+  float rPos;
+  // Store the cursor rectangle's position
+  rPos = textWidth(buff) + leftmargin;
+  rect(rPos+1, 19, 10, 21);
+
+  // Some instructions at first
+  if(didntTypeYet) {
+    fill(0);
+    //text("Use the keyboard.", 22, 40);
+  }
+
+  fill(0);
+  pushMatrix();
+  translate(rPos,10+25);
+  char k;
+  for(int i = 0;i < buff.length(); i++) {
+    k = buff.charAt(i);
+    translate(-textWidth(k),0);
+    rotateY(-textWidth(k)/70.0); 
+    rotateX(textWidth(k)/70.0);
+    scale(1.1);
+    text(k,0,0);
+  }
+  popMatrix();
+}
+
+void keyPressed()
+{
+  char k;
+  k = (char)key;
+  switch(k){
+  case 8:
+    if(buff.length()>0){
+      buff = buff.substring(1);
+    }
+    break;
+  case 13:  // Avoid special keys
+  case 10:
+  case 65535:
+  case 127:
+  case 27:
+    break;
+  default:
+    if(textWidth(buff+k)+leftmargin < width-rightmargin){
+      didntTypeYet = false;
+      buff=k+buff;
+    }
+    break;
+  }
+}
+
diff --git a/java/libraries/opengl/examples/Typography/Typing/data/Univers45.vlw b/java/libraries/opengl/examples/Typography/Typing/data/Univers45.vlw
new file mode 100755
index 0000000000000000000000000000000000000000..040e02170efb50dbce4576b305e0b6b4f53de200
GIT binary patch
literal 95193
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
DZ}dO_

literal 0
HcmV?d00001