egra: agg mini code cleanups

[iv.d.git] / egra / gfx / aggmini / core.d

/*
 * Simple Framebuffer Gfx/GUI lib
 *
 * coded by Ketmar // Invisible Vector <ketmar@ketmar.no-ip.org>
 * Understanding is not required. Only obedience.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, version 3 of the License ONLY.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */
/* *****************************************************************************
  Anti-Grain Geometry - Version 2.1 Lite
  Copyright (C) 2002-2003 Maxim Shemanarev (McSeem)
  D port, additional work: Ketmar Dark

  Permission to copy, use, modify, sell and distribute this software
  is granted provided this copyright notice appears in all copies.
  This software is provided "as is" without express or implied
  warranty, and with no claim as to its suitability for any purpose.

  The author gratefully acknowleges the support of David Turner,
  Robert Wilhelm, and Werner Lemberg - the authors of the FreeType
  libray - in producing this work. See http://www.freetype.org for details.

  Initially the rendering algorithm was designed by David Turner and the
  other authors of the FreeType library - see the above notice. I nearly
  created a similar renderer, but still I was far from David's work.
  I completely redesigned the original code and adapted it for Anti-Grain
  ideas. Two functions - renderLine and renderScanLine are the core of
  the algorithm - they calculate the exact coverage of each pixel cell
  of the polygon. I left these functions almost as is, because there's
  no way to improve the perfection - hats off to David and his group!

  All other code is very different from the original.
***************************************************************************** */
module iv.egra.gfx.aggmini.core;
private:
//nothrow @safe @nogc:

private import iv.egra.gfx.aggmini : DisableCopyingMixin;
private import iv.egra.gfx.aggmini.enums;
private import iv.egra.gfx.aggmini.supmath;
private import iv.egra.gfx.aggmini.render;
private import iv.egra.gfx.aggmini.stroker;

private import iv.egra.gfx.base;

//debug private import iv.cmdcon;

//version = egra_aggmini_debug_rasta;


// ////////////////////////////////////////////////////////////////////////// //
// some "fastgfx" backend
public struct AGGDrawer {
protected:
  // added vertex will contain "end poly" command only when `closePoly()`/`endPoly()` was called
  static struct Vertex {
    float x, y;
    uint cmd; // path command

    this (in float ax, in float ay, in uint acmd) pure nothrow @safe @nogc {
      pragma(inline, true);
      x = ax;
      y = ay;
      cmd = acmd;
    }
  }

protected:
  Rasterizer rast;
  SimpleVector!Vertex vtx; // reset by `beginPath()`

  float lastStartX = 0.0f, lastStartY = 0.0f; // first point of the current poly
  float lastX = 0.0f, lastY = 0.0f;
  float utlastX = 0.0f, utlastY = 0.0f;

  // for vertex producer
  uint vpIdx;

  // for rasterising vertex consumer
  static struct ConsumerState {
    float startX = 0.0f, startY = 0.0f;
    float lastX = 0.0f, lastY = 0.0f;
    uint lineCmdCount = 0;
      // 0: poly just started
      // 1: last command was "move to"
      // 2 and more: number of sequential "line to" commands minus 1
  }
  ConsumerState rcsm;


  AGGMatrix tmatrix;
  bool dotransform = false;

public:
  float tessTol = 0.25f;
  float angleTol = 0.0f; // 0.0f -- angle tolerance for McSeem Bezier rasterizer
  float cuspLimit = 0.0f; // 0 -- cusp limit for McSeem Bezier rasterizer (0: real cusps)
  int bezierLimit = 20; // bezier recursion limit for non-AFD tesselators

  // default tesselator for Bezier curves
  AGGTesselation tesselator = AGGTesselation.DeCasteljauMcSeem;
  //AGGTesselation tesselator = AGGTesselation.DeCasteljau;
  //AGGTesselation tesselator = AGGTesselation.AFD;

  mixin(DisableCopyingMixin);

public:
  ref AGGDrawer withTransform(DG) (in auto ref AGGMatrix tmt, scope DG dg)
  if (is(typeof((inout int=0) { DG vp = void; dg(); })))
  {
    immutable AGGMatrix old = tmatrix;
    tmatrix = tmt;
    dotransform = !tmt.isIdentity;
    scope(exit) tmatrix = old;
    dg();
    return this;
  }

nothrow @trusted @nogc:
protected:
  enum distTol = cast(float)(1.0f/256.0f);
  enum KAPPA90 = 0.5522847493f; // length proportional to radius of a cubic bezier handle for 90deg arcs

  // this does some fancy logic
  void addVtx (float fx, float fy, uint cmd) {
    pragma(inline, true);
    assert(isLineTo(cmd) || isMoveTo(cmd) || isEndPoly(cmd));

    if (isEndPoly(cmd) && (fx != fx || fy != fy)) {
      fx = lastX;
      fy = lastY;
    } else {
      assert(fx == fx && fy == fy); // reject infs and nans
      if (!isEndPoly(cmd)) {
        utlastX = fx;
        utlastY = fy;
      }
      // transform coords
      if (dotransform) {
        tmatrix.point(&fx, &fy, fx, fy);
        assert(fx == fx && fy == fy); // reject infs and nans
      }
    }

    // moveto?
    if (isMoveTo(cmd)) {
      // if we just end the poly, record new coords, but don't emit any command
      if (vtx.isEmpty || isEndPoly(vtx[$-1u].cmd)) {
        // postpone it
        lastStartX = lastX = fx;
        lastStartY = lastY = fy;
        return;
      }
      // if prev was moveto, just fix it
      if (isMoveTo(vtx[$-1u].cmd)) {
        vtx[$-1u].x = lastX = fx;
        vtx[$-1u].y = lastY = fy;
        return;
      }
      // prev should be a line, emit move
      assert(isLineTo(vtx[$-1u].cmd));
      vtx.add(Vertex(fx, fy, cmd));
      lastX = fx;
      lastY = fy;
      return;
    }

    // lineto?
    if (isLineTo(cmd)) {
      // if we just end the poly, move to the new start
      // (we may have postponed "move to" here, and this will "flush" it)
      if (vtx.isEmpty || isEndPoly(vtx[$-1u].cmd)) {
        vtx.add(Vertex(lastX, lastY, PathCommand.MoveTo));
      }
      // if prev is "line to", reject duplicate points
      // we cannot have empty vertex array here
      if (isLineTo(vtx[$-1u].cmd) && ptEquals(fx, fy, vtx[$-1u].x, vtx[$-1u].y)) return;
      vtx.add(Vertex(fx, fy, cmd));
      lastX = fx;
      lastY = fy;
      return;
    }

    // end poly
    assert(isEndPoly(cmd));
    // do not emit if if we haven't any poly points yet
    if (vtx.isEmpty || isEndPoly(vtx[$-1u].cmd)) return;
    // we cannot have polys with "move only", no need to check for that
    // need to close the poly?
    if (isClose(cmd)) {
      // we can have "move to" recorded, take it back
      if (isMoveTo(vtx[$-1u].cmd)) {
        immutable float mx = vtx[$-1u].x;
        immutable float my = vtx[$-1u].y;
        vtx.removeLast();
        assert(!vtx.isEmpty && isLineTo(vtx[$-1u].cmd));
        if (!ptEquals(lastStartX, lastStartY, vtx[$-1u].x, vtx[$-1u].y)) {
          // close contour
          vtx.add(Vertex(lastStartX, lastStartY, PathCommand.LineTo));
        }
        // no need to put close command back
        vtx.add(Vertex(fx, fy, cmd));
        assert(lastX == mx && lastY == my);
        lastStartX = mx;
        lastStartY = my;
      } else {
        // we should have "line to" recorded
        assert(!vtx.isEmpty && isLineTo(vtx[$-1u].cmd));
        if (!ptEquals(lastStartX, lastStartY, vtx[$-1u].x, vtx[$-1u].y)) {
          // close contour
          vtx.add(Vertex(lastStartX, lastStartY, PathCommand.LineTo));
        }
        vtx.add(Vertex(fx, fy, cmd));
        // fix current coords
        lastStartX = lastX = fx;
        lastStartY = lastY = fy;
      }
      return;
    }

    // end poly w/o closing
    // do nothing (do not take back last "move to")
    assert(!vtx.isEmpty);
    vtx.add(Vertex(fx, fy, cmd));
  }

  @property bool hasPolyPoints () const pure {
    pragma(inline, true);
    return (!vtx.isEmpty && isMoveTo(vtx[$-1u].cmd));
  }

public:
  void dumpVertices () {
    import core.stdc.stdio : stderr, fprintf;
    fprintf(stderr, "=== VERTEX COUNT: %u ===\n", vtx.length);
    foreach (immutable uint idx; 0..vtx.length) {
      fprintf(stderr, "  %u: (%g, %g) : 0x%02x\n", idx, vtx[idx].x, vtx[idx].y, vtx[idx].cmd);
    }
    fprintf(stderr, "-------\n");
  }

protected:
  Stroker mStroker;
  Contourer mContourer;
  Dasher mDasher;

public:
  @property void lineCap (in LineCap lc) { pragma(inline, true); mStroker.lineCap(lc); }
  @property void lineJoin (in LineJoin lj) { pragma(inline, true); mStroker.lineJoin(lj); }
  @property void innerJoin (in InnerJoin ij) { pragma(inline, true); mStroker.innerJoin(ij); }

  @property LineCap lineCap () const pure { pragma(inline, true); return mStroker.lineCap(); }
  @property LineJoin lineJoin () const pure { pragma(inline, true); return mStroker.lineJoin(); }
  @property InnerJoin innerJoin () const pure { pragma(inline, true); return mStroker.innerJoin(); }

  @property void width (in float w) { pragma(inline, true); mStroker.width(w); }
  @property void miterLimit (in float ml) { pragma(inline, true); mStroker.miterLimit(ml); }
  @property void miterLimitTheta (in float t) { pragma(inline, true); mStroker.miterLimitTheta(t); }
  @property void innerMiterLimit (in float ml) { pragma(inline, true); mStroker.innerMiterLimit(ml); }
  @property void approximationScale (in float as) { pragma(inline, true); mStroker.approximationScale(as); }

  @property float width () const pure { pragma(inline, true); return mStroker.width(); }
  @property float miterLimit () const pure { pragma(inline, true); return mStroker.miterLimit(); }
  @property float innerMiterLimit () const pure { pragma(inline, true); return mStroker.innerMiterLimit(); }
  @property float approximationScale () const pure { pragma(inline, true); return mStroker.approximationScale(); }

  // for contourer
  @property void autoDetectOrientation (bool v) { pragma(inline, true); mContourer.autoDetectOrientation(v); }
  @property bool autoDetectOrientation () const pure { pragma(inline, true); return mContourer.autoDetectOrientation; }

  @property void shorten (in float s) { pragma(inline, true); mStroker.shorten = s; }
  @property float shorten () const pure { pragma(inline, true); return mStroker.shorten; }

  void resetDashes () { pragma(inline, true); mDasher.removeAllDashes(); }
  void addDash (in float dashLen, in float gapLen) { pragma(inline, true); mDasher.addDash(dashLen, gapLen); }
  void dashStart (in float ds) { pragma(inline, true); mDasher.dashStart(ds); }

  @property FillRule fillRule () const pure { pragma(inline, true); return rast.fillRule; }
  @property void fillRule (FillRule v) { pragma(inline, true); rast.fillRule = v; }

  // untransformed
  @property float currX () const pure { pragma(inline, true); return utlastX; }
  @property float currY () const pure { pragma(inline, true); return utlastY; }

  // transformed
  @property float realCurrX () const pure { pragma(inline, true); return lastX; }
  @property float realCurrY () const pure { pragma(inline, true); return lastY; }

  @property AGGMatrix getTransform () const pure { pragma(inline, true); return tmatrix; }

  @property void transform() (in auto ref AGGMatrix tmt) {
    tmatrix = tmt;
    dotransform = !tmt.isIdentity;
  }

  void resetTransform () {
    if (dotransform) {
      tmatrix.identity();
      dotransform = false;
    }
  }


  // ////////////////////////////////////////////////////////////////////////// //
  // Vetex Producer API
  void rewind () {
    pragma(inline, true);
    vpIdx = 0;
  }

  uint vertex (float* x, float* y) {
    if (vpIdx >= vtx.length) return PathCommand.Stop;
    *x = vtx[vpIdx].x;
    *y = vtx[vpIdx].y;
    return vtx[vpIdx++].cmd;
  }


  // ////////////////////////////////////////////////////////////////////////// //
  // Vetex Consumer API does rasterising
  void removeAll () {
    pragma(inline, true);
    rcsm = rcsm.init;
    version(egra_aggmini_debug_rasta) { import core.stdc.stdio : stderr, fprintf; fprintf(stderr, "=== DRAWER: RENDER RESET ===\n"); }
  }

  void addVertex (float x, float y, uint cmd) {
    // stop?
    if (isStop(cmd)) {
      //removeAll();
      version(egra_aggmini_debug_rasta) { import core.stdc.stdio : stderr, fprintf; fprintf(stderr, "=== DRAWER: RENDER STOP ===\n"); }
      rcsm = rcsm.init;
      return;
    }

    // line/move?
    if (isLineTo(cmd) || isMoveTo(cmd)) {
      version(egra_aggmini_debug_rasta) {
        import core.stdc.stdio : stderr, fprintf; fprintf(stderr, "  pre*: %s: (%g, %g)  lineCmdCount=%u; start=(%g,%g); last=(%g,%g)\n",
          (isLineTo(cmd) ? "lineto".ptr : "moveto".ptr), x, y, rcsm.lineCmdCount, rcsm.startX, rcsm.startY, rcsm.lastX, rcsm.lastY);
      }
      if (!rcsm.lineCmdCount) { rcsm.startX = x; rcsm.startY = y; rcsm.lineCmdCount = 1; }
      if (isLineTo(cmd)) {
        // do not add duplicate points
        if (rcsm.lineCmdCount < 2 || !ptEquals(x, y, rcsm.lastX, rcsm.lastY)) rast.lineTo(x, y);
        ++rcsm.lineCmdCount;
      } else {
        rast.moveTo(x, y);
        rcsm.lineCmdCount = 1;
      }
      rcsm.lastX = x;
      rcsm.lastY = y;
      version(egra_aggmini_debug_rasta) {
        import core.stdc.stdio : stderr, fprintf; fprintf(stderr, "  post: %s: (%g, %g)  lineCmdCount=%u; start=(%g,%g); last=(%g,%g)\n",
          (isLineTo(cmd) ? "lineto".ptr : "moveto".ptr), x, y, rcsm.lineCmdCount, rcsm.startX, rcsm.startY, rcsm.lastX, rcsm.lastY);
      }
      return;
    }

    // end poly?
    if (isEndPoly(cmd)) {
      version(egra_aggmini_debug_rasta) {
        import core.stdc.stdio : stderr, fprintf; fprintf(stderr, "  pre*: %s: (%g, %g)  lineCmdCount=%u; start=(%g,%g); last=(%g,%g)\n",
          (isClose(cmd) ? "close".ptr : "end".ptr), x, y, rcsm.lineCmdCount, rcsm.startX, rcsm.startY, rcsm.lastX, rcsm.lastY);
      }
      // close poly?
      if (rcsm.lineCmdCount > 2 && isClose(cmd) && !ptEquals(rcsm.startX, rcsm.startY, rcsm.lastX, rcsm.lastY)) {
        rast.lineTo(rcsm.startX, rcsm.startY);
        rcsm.lastX = rcsm.startX;
        rcsm.lastY = rcsm.startY;
      }
      rcsm.lineCmdCount = 0;
      // don't do "move to" here, it breaks rendering
      version(egra_aggmini_debug_rasta) {
        import core.stdc.stdio : stderr, fprintf; fprintf(stderr, "  post: %s: (%g, %g)  lineCmdCount=%u; start=(%g,%g); last=(%g,%g)\n",
          (isClose(cmd) ? "close".ptr : "end".ptr), x, y, rcsm.lineCmdCount, rcsm.startX, rcsm.startY, rcsm.lastX, rcsm.lastY);
      }
      return;
    }

    assert(0, "invalid path command");
  }


  // ////////////////////////////////////////////////////////////////////////// //
  ref AGGDrawer resetParams () {
    width = 1.5f;
    miterLimit = 4.0f;
    innerMiterLimit = 1.01f;
    approximationScale = 1.0f;
    lineCap = LineCap.Butt;
    lineJoin = LineJoin.Miter;
    innerJoin = InnerJoin.Miter;
    return this;
  }

  ref AGGDrawer beginFrame () {
    resetTransform();
    vtx.removeAll();
    vpIdx = 0;
    lastStartX = lastX = utlastX = 0.0f;
    lastStartY = lastY = utlastY = 0.0f;
    rast.reset();
    return resetParams();
  }

  ref AGGDrawer cancelFrame () {
    return beginFrame();
  }

  // this doesn't reset params or transform
  ref AGGDrawer resetFrame () {
    vtx.removeAll();
    vpIdx = 0;
    lastStartX = lastX = utlastX = 0.0f;
    lastStartY = lastY = utlastY = 0.0f;
    rast.reset();
    return this;
  }

  // input coords are unaffected by transform
  // returns alpha (0 means "no hit")
  ubyte hitTest (in int x, in int y) { pragma(inline, true); return rast.hitTest(x, y); }

  // doesn't reset pathes
  ref AGGDrawer render (in GxColor c, in bool doReset=true) {
    if (!gxIsTransparent(c)) {
      GxRect clipRect = gxClipRect;
      if (clipRect.intersect(0, 0, VBufWidth, VBufHeight)) {
        rast.render(clipRect, c);
      }
      if (doReset) rast.reset();
    }
    return this;
  }

  ref AGGDrawer renderNoReset (in GxColor c) { pragma(inline, true); return render(c, doReset:false); }

  ref AGGDrawer endFrame (in GxColor c=gxTransparent) {
    render(c);
    return beginFrame();
  }

  ref AGGDrawer beginPath () {
    pragma(inline, true);
    vtx.removeAll();
    return this;
  }

  ref AGGDrawer endPoly () {
    addVtx(lastX, lastY, PathCommand.EndPoly);
    return this;
  }

  ref AGGDrawer closePoly () {
    addVtx(lastX, lastY, PathCommand.EndPoly|PathFlag.Close);
    return this;
  }

  // starts new sub-path with specified point as first point
  ref AGGDrawer moveTo (in float x, in float y) { pragma(inline, true); addVtx(x, y, PathCommand.MoveTo); return this; }

  // adds line segment from the last point in the path to the specified point
  ref AGGDrawer lineTo (in float x, in float y) { pragma(inline, true); addVtx(x, y, PathCommand.LineTo); return this; }

  // adds cubic bezier segment from last point in the path via two control points to the specified point
  ref AGGDrawer bezierTo (in float x2, in float y2, in float x3, in float y3, in float x4, in float y4) {
    pragma(inline, true);
    //tesselateBezierMcSeem(currX, currY, x2, y2, x3, y3, x4, y4, 0);
    tesselateBezier(currX, currY, x2, y2, x3, y3, x4, y4);
    return this;
  }

  // adds quadratic bezier segment from last point in the path via a control point to the specified point
  void quadTo (in float cx, in float cy, in float x, in float y) {
    immutable float x0 = currX;
    immutable float y0 = currY;
    bezierTo(
      x0+2.0f/3.0f*(cx-x0), y0+2.0f/3.0f*(cy-y0),
      x+2.0f/3.0f*(cx-x), y+2.0f/3.0f*(cy-y),
      x, y,
    );
  }

  // adds an arc segment at the corner defined by the last path point, and two specified points
  ref AGGDrawer arcTo (in float x1, in float y1, in float x2, in float y2, in float radius) {
    import core.stdc.math : acosf, tanf, atan2f;

    immutable float x0 = currX;
    immutable float y0 = currY;

    // handle degenerate cases
    if (ptEquals(x0, y0, x1, y1) ||
        ptEquals(x1, y1, x2, y2) ||
        distPtSegSq(x1, y1, x0, y0, x2, y2) < distTol*distTol ||
        radius < distTol)
    {
      lineTo(x1, y1);
      return this;
    }

    // calculate tangential circle to lines (x0, y0)-(x1, y1) and (x1, y1)-(x2, y2)
    float dx0 = x0-x1;
    float dy0 = y0-y1;
    float dx1 = x2-x1;
    float dy1 = y2-y1;
    normalize(ref dx0, ref dy0);
    normalize(ref dx1, ref dy1);
    immutable float a = acosf(dx0*dx1+dy0*dy1);
    immutable float d = radius/tanf(a*0.5f);

    if (d > 10000.0f) {
      lineTo(x1, y1);
      return this;
    }

    float cx = void, cy = void, a0 = void, a1 = void;
    Winding dir = void;
    if (cross2(dx0, dy0, dx1, dy1) > 0.0f) {
      cx = x1+dx0*d+dy0*radius;
      cy = y1+dy0*d+-dx0*radius;
      a0 = atan2f(dx0, -dy0);
      a1 = atan2f(-dx1, dy1);
      dir = Winding.CW;
      //printf("CW c=(%f, %f) a0=%f° a1=%f°\n", cx, cy, a0/NVG_PI*180.0f, a1/NVG_PI*180.0f);
    } else {
      cx = x1+dx0*d+-dy0*radius;
      cy = y1+dy0*d+dx0*radius;
      a0 = atan2f(-dx0, dy0);
      a1 = atan2f(dx1, -dy1);
      dir = Winding.CCW;
      //printf("CCW c=(%f, %f) a0=%f° a1=%f°\n", cx, cy, a0/NVG_PI*180.0f, a1/NVG_PI*180.0f);
    }

    return arc(dir, cx, cy, radius, a0, a1); // first is line
  }


  // ////////////////////////////////////////////////////////////////////////// //
  protected void streamFromStroker () {
    // no need to close polys, our consumer will do it
    streamAllVertices!false(mStroker, this);
    mStroker.removeAll();
  }

  protected void streamToStrokerAndRender(VS) (ref VS vs) if (IsGoodVertexProducer!VS) {
    streamAllVertices(vs, mStroker, &streamFromStroker);
  }


  // ////////////////////////////////////////////////////////////////////////// //
  // fill pathes
  ref AGGDrawer fill () {
    streamAllVertices!false(this, this); // no need to close polys, our consumer will do it
    removeAll();
    return this;
  }

  // stroke pathes
  ref AGGDrawer stroke () {
    if (vtx.isEmpty) return this;
    streamAllVertices(this, mStroker, &streamFromStroker);
    return this;
  }

  // set parameters, and then call this
  ref AGGDrawer setupContour (in float ctrwidth) {
    mContourer.lineCap = mStroker.lineCap;
    mContourer.lineJoin = mStroker.lineJoin;
    mContourer.innerJoin = mStroker.innerJoin;

    mContourer.width = /*mStroker.width*/ctrwidth;
    mContourer.miterLimit = mStroker.miterLimit;
    mContourer.innerMiterLimit = mStroker.innerMiterLimit;
    mContourer.approximationScale = mStroker.approximationScale;
    return this;
  }

  // contour pathes
  ref AGGDrawer contour () {
    if (vtx.isEmpty) return this;
    streamAllVertices(this, mContourer, &streamToStrokerAndRender!(typeof(mContourer)));
    return this;
  }

  // dash pathes
  ref AGGDrawer dashStroke () {
    if (vtx.isEmpty) return this;
    if (!mDasher.hasDashes) return stroke();
    mDasher.shorten = mStroker.shorten;
    streamAllVertices(this, mDasher, &streamToStrokerAndRender!(typeof(mDasher)));
    return this;
  }


  // ////////////////////////////////////////////////////////////////////////// //
  /* Creates new circle arc shaped sub-path. The arc center is at (cx, cy), the arc radius is r,
   * and the arc is drawn from angle a0 to a1, and swept in direction dir (NVGWinding.CCW, or NVGWinding.CW).
   * Angles are specified in radians.
   *
   * [mode] is: "original", "move", "line" -- first command will be like original NanoVega, MoveTo, or LineTo
   */
  ref AGGDrawer arc(string mode="original") (Winding dir, in float cx, in float cy, in float r,
                                             in float a0, in float a1)
  {
    static assert(mode == "original" || mode == "move" || mode == "line");
    import core.stdc.math : fabsf, cosf, sinf;

    //int move = (ctx.ncommands > 0 ? Command.LineTo : Command.MoveTo);
    static if (mode == "original") {
      bool asMove = !hasPolyPoints;
    } else static if (mode == "move") {
      enum asMove = true;
    } else static if (mode == "line") {
      enum asMove = false;
    } else {
      static assert(0, "wtf?!");
    }

    // clamp angles
    float da = a1-a0;
    if (dir == Winding.CW) {
      if (fabsf(da) >= FLT_PI*2.0f) {
        da = FLT_PI*2.0f;
      } else {
        while (da < 0.0f) da += FLT_PI*2.0f;
      }
    } else {
      if (fabsf(da) >= FLT_PI*2.0f) {
        da = -FLT_PI*2.0f;
      } else {
        while (da > 0.0f) da -= FLT_PI*2.0f;
      }
    }

    // split arc into max 90 degree segments
    immutable int ndivs = max(1, min(cast(int)(fabsf(da)/(FLT_PI*0.5f)+0.5f), 5));
    immutable float hda = (da/cast(float)ndivs)*0.5f;
    float kappa = fabsf(4.0f/3.0f*(1.0f-cosf(hda))/sinf(hda));
    if (dir == Winding.CCW) kappa = -kappa;

    int nvals = 0;
    float px = 0, py = 0, ptanx = 0, ptany = 0;
    foreach (int i; 0..ndivs+1) {
      immutable float a = a0+da*(i/cast(float)ndivs);
      immutable float dx = cosf(a);
      immutable float dy = sinf(a);
      immutable float x = cx+dx*r;
      immutable float y = cy+dy*r;
      immutable float tanx = -dy*r*kappa;
      immutable float tany = dx*r*kappa;

      if (i == 0) {
        if (asMove) moveTo(x, y); else lineTo(x, y);
      } else {
        bezierTo(px+ptanx, py+ptany, x-tanx, y-tany, x, y);
      }
      px = x;
      py = y;
      ptanx = tanx;
      ptany = tany;
    }

    return this;
  }

  // creates new rectangle shaped sub-path
  ref AGGDrawer rect (in float x, in float y, in float w, in float h) {
    if (w && h) {
      moveTo(x, y);
      lineTo(x, y+h);
      lineTo(x+w, y+h);
      lineTo(x+w, y);
      lineTo(x, y); // close it
    }
    return this;
  }

  // creates new rounded rectangle shaped sub-path
  ref AGGDrawer roundedRect (in float x, in float y, in float w, in float h, in float radius) {
    return roundedRectVarying(x, y, w, h, radius, radius, radius, radius);
  }

  // creates new rounded rectangle shaped sub-path
  // specify ellipse width and height to round corners according to it
  ref AGGDrawer roundedRectEllipse (in float x, in float y, in float w, in float h, in float rw, in float rh) {
    if (rw < 0.1f || rh < 0.1f) return rect(x, y, w, h);
    moveTo(x+rw, y);
    lineTo(x+w-rw, y);
    bezierTo(x+w-rw*(1.0f-KAPPA90), y, x+w, y+rh*(1.0f-KAPPA90), x+w, y+rh);
    lineTo(x+w, y+h-rh);
    bezierTo(x+w, y+h-rh*(1.0f-KAPPA90), x+w-rw*(1.0f-KAPPA90), y+h, x+w-rw, y+h);
    lineTo(x+rw, y+h);
    bezierTo(x+rw*(1.0f-KAPPA90), y+h, x, y+h-rh*(1.0f-KAPPA90), x, y+h-rh);
    lineTo(x, y+rh);
    bezierTo(x, y+rh*(1.0f-KAPPA90), x+rw*(1.0f-KAPPA90), y, x+rw, y);
    return closePoly();
  }

  // creates new rounded rectangle shaped sub-path
  // this one allows you to specify different rounding radii for each corner
  ref AGGDrawer roundedRectVarying (in float x, in float y, in float w, in float h,
                                    in float radTopLeft, in float radTopRight,
                                    in float radBottomRight, in float radBottomLeft)
  {
    import core.stdc.math : fabsf;
    if (radTopLeft < 0.1f && radTopRight < 0.1f && radBottomRight < 0.1f && radBottomLeft < 0.1f) return rect(x, y, w, h);
    immutable float halfw = fabsf(w)*0.5f;
    immutable float halfh = fabsf(h)*0.5f;
    immutable float rxBL = min(radBottomLeft, halfw)*sign(w), ryBL = min(radBottomLeft, halfh)*sign(h);
    immutable float rxBR = min(radBottomRight, halfw)*sign(w), ryBR = min(radBottomRight, halfh)*sign(h);
    immutable float rxTR = min(radTopRight, halfw)*sign(w), ryTR = min(radTopRight, halfh)*sign(h);
    immutable float rxTL = min(radTopLeft, halfw)*sign(w), ryTL = min(radTopLeft, halfh)*sign(h);
    moveTo(x, y+ryTL);
    lineTo(x, y+h-ryBL);
    bezierTo(x, y+h-ryBL*(1.0f-KAPPA90), x+rxBL*(1.0f-KAPPA90), y+h, x+rxBL, y+h);
    lineTo(x+w-rxBR, y+h);
    bezierTo(x+w-rxBR*(1.0f-KAPPA90), y+h, x+w, y+h-ryBR*(1.0f-KAPPA90), x+w, y+h-ryBR);
    lineTo(x+w, y+ryTR);
    bezierTo(x+w, y+ryTR*(1.0f-KAPPA90), x+w-rxTR*(1.0f-KAPPA90), y, x+w-rxTR, y);
    lineTo(x+rxTL, y);
    bezierTo(x+rxTL*(1.0f-KAPPA90), y, x, y+ryTL*(1.0f-KAPPA90), x, y+ryTL);
    return closePoly();
  }

  // creates new ellipse shaped sub-path
  ref AGGDrawer ellipse (in float cx, in float cy, in float rx, in float ry) {
    moveTo(cx-rx, cy);
    bezierTo(cx-rx, cy+ry*KAPPA90, cx-rx*KAPPA90, cy+ry, cx, cy+ry);
    bezierTo(cx+rx*KAPPA90, cy+ry, cx+rx, cy+ry*KAPPA90, cx+rx, cy);
    bezierTo(cx+rx, cy-ry*KAPPA90, cx+rx*KAPPA90, cy-ry, cx, cy-ry);
    bezierTo(cx-rx*KAPPA90, cy-ry, cx-rx, cy-ry*KAPPA90, cx-rx, cy);
    return closePoly();
  }

  // creates new circle shaped sub-path
  ref AGGDrawer circle (in float cx, in float cy, in float r) {
    return ellipse(cx, cy, r, r);
  }

private:
  // ////////////////////////////////////////////////////////////////////////// //
  void tesselateBezierDCj (in float x1, in float y1, in float x2, in float y2,
                           in float x3, in float y3, in float x4, in float y4, in int level)
  {
    import core.stdc.math : fabsf;
    if (level > bezierLimit) return;

    immutable float x12 = (x1+x2)*0.5f;
    immutable float y12 = (y1+y2)*0.5f;
    immutable float x23 = (x2+x3)*0.5f;
    immutable float y23 = (y2+y3)*0.5f;
    immutable float x34 = (x3+x4)*0.5f;
    immutable float y34 = (y3+y4)*0.5f;
    immutable float x123 = (x12+x23)*0.5f;
    immutable float y123 = (y12+y23)*0.5f;

    immutable float dx = x4-x1;
    immutable float dy = y4-y1;
    immutable float d2 = fabsf(((x2-x4)*dy-(y2-y4)*dx));
    immutable float d3 = fabsf(((x3-x4)*dy-(y3-y4)*dx));

    if ((d2+d3)*(d2+d3) < tessTol*(dx*dx+dy*dy)) {
      lineTo(x4, y4);
      return;
    }

    immutable float x234 = (x23+x34)*0.5f;
    immutable float y234 = (y23+y34)*0.5f;
    immutable float x1234 = (x123+x234)*0.5f;
    immutable float y1234 = (y123+y234)*0.5f;

    // "taxicab" / "manhattan" check for flat curves
    if (fabsf(x1+x3-x2-x2)+fabsf(y1+y3-y2-y2)+fabsf(x2+x4-x3-x3)+fabsf(y2+y4-y3-y3) < tessTol*0.25f) {
      lineTo(x1234, y1234);
      return;
    }

    tesselateBezierDCj(x1, y1, x12, y12, x123, y123, x1234, y1234, level+1);
    tesselateBezierDCj(x1234, y1234, x234, y234, x34, y34, x4, y4, level+1);
  }

  // ////////////////////////////////////////////////////////////////////////// //
  // based on the ideas and code of Maxim Shemanarev. Rest in Peace, bro!
  // see http://www.antigrain.com/research/adaptive_bezier/index.html
  void tesselateBezierMcSeem (in float x1, in float y1, in float x2, in float y2,
                              in float x3, in float y3, in float x4, in float y4, in int level)
  {
    import core.stdc.math : fabsf, atan2f;

    enum CollinearEPS = 0.00000001f; // 0.00001f;
    enum AngleTolEPS = 0.01f;

    static float distSquared (in float x1, in float y1, in float x2, in float y2) pure nothrow @safe @nogc {
      pragma(inline, true);
      immutable float dx = x2-x1;
      immutable float dy = y2-y1;
      return dx*dx+dy*dy;
    }

    /+
    if (level == 0) {
      lineTo(x1, y1/*, 0*/);
      tesselateBezierMcSeem(x1, y1, x2, y2, x3, y3, x4, y4, 1/*, type*/);
      lineTo(x4, y4/*, type*/);
      return;
    }
    +/

    if (level > bezierLimit) return; // recurse limit; practically, it should be never reached, but...

    // calculate all the mid-points of the line segments
    immutable float x12 = (x1+x2)*0.5f;
    immutable float y12 = (y1+y2)*0.5f;
    immutable float x23 = (x2+x3)*0.5f;
    immutable float y23 = (y2+y3)*0.5f;
    immutable float x34 = (x3+x4)*0.5f;
    immutable float y34 = (y3+y4)*0.5f;
    immutable float x123 = (x12+x23)*0.5f;
    immutable float y123 = (y12+y23)*0.5f;
    immutable float x234 = (x23+x34)*0.5f;
    immutable float y234 = (y23+y34)*0.5f;
    immutable float x1234 = (x123+x234)*0.5f;
    immutable float y1234 = (y123+y234)*0.5f;

    // try to approximate the full cubic curve by a single straight line
    immutable float dx = x4-x1;
    immutable float dy = y4-y1;

    float d2 = fabsf(((x2-x4)*dy-(y2-y4)*dx));
    float d3 = fabsf(((x3-x4)*dy-(y3-y4)*dx));

    final switch ((cast(int)(d2 > CollinearEPS)<<1)+cast(int)(d3 > CollinearEPS)) {
      case 0:
        // all collinear or p1 == p4
        float k = dx*dx+dy*dy;
        if (k == 0.0f) {
          d2 = distSquared(x1, y1, x2, y2);
          d3 = distSquared(x4, y4, x3, y3);
        } else {
          k = 1.0f/k;
          float da1 = x2-x1;
          float da2 = y2-y1;
          d2 = k*(da1*dx+da2*dy);
          da1 = x3-x1;
          da2 = y3-y1;
          d3 = k*(da1*dx+da2*dy);
          if (d2 > 0 && d2 < 1 && d3 > 0 && d3 < 1) {
            // Simple collinear case, 1---2---3---4
            // We can leave just two endpoints
            return;
          }
               if (d2 <= 0.0f) d2 = distSquared(x2, y2, x1, y1);
          else if (d2 >= 1.0f) d2 = distSquared(x2, y2, x4, y4);
          else d2 = distSquared(x2, y2, x1+d2*dx, y1+d2*dy);

               if (d3 <= 0.0f) d3 = distSquared(x3, y3, x1, y1);
          else if (d3 >= 1.0f) d3 = distSquared(x3, y3, x4, y4);
          else d3 = distSquared(x3, y3, x1+d3*dx, y1+d3*dy);
        }
        if (d2 > d3) {
          if (d2 < tessTol) {
            lineTo(x2, y2);
            return;
          }
        } if (d3 < tessTol) {
          lineTo(x3, y3);
          return;
        }
        break;
      case 1:
        // p1,p2,p4 are collinear, p3 is significant
        if (d3*d3 <= tessTol*(dx*dx+dy*dy)) {
          if (angleTol < AngleTolEPS) {
            lineTo(x23, y23);
            return;
          } else {
            // angle condition
            float da1 = fabsf(atan2f(y4-y3, x4-x3)-atan2f(y3-y2, x3-x2));
            if (da1 >= FLT_PI) da1 = 2.0f*FLT_PI-da1;
            if (da1 < angleTol) {
              lineTo(x2, y2);
              lineTo(x3, y3);
              return;
            }
            if (cuspLimit != 0.0f) {
              if (da1 > cuspLimit) {
                lineTo(x3, y3);
                return;
              }
            }
          }
        }
        break;
      case 2:
        // p1,p3,p4 are collinear, p2 is significant
        if (d2*d2 <= tessTol*(dx*dx+dy*dy)) {
          if (angleTol < AngleTolEPS) {
            lineTo(x23, y23);
            return;
          } else {
            // angle condition
            float da1 = fabsf(atan2f(y3-y2, x3-x2)-atan2f(y2-y1, x2-x1));
            if (da1 >= FLT_PI) da1 = 2.0f*FLT_PI-da1;
            if (da1 < angleTol) {
              lineTo(x2, y2);
              lineTo(x3, y3);
              return;
            }
            if (cuspLimit != 0.0f) {
              if (da1 > cuspLimit) {
                lineTo(x2, y2);
                return;
              }
            }
          }
        }
        break;
      case 3:
        // regular case
        if ((d2+d3)*(d2+d3) <= tessTol*(dx*dx+dy*dy)) {
          // if the curvature doesn't exceed the distance tolerance value, we tend to finish subdivisions
          if (angleTol < AngleTolEPS) {
            lineTo(x23, y23);
            return;
          } else {
            // angle and cusp condition
            immutable float k = atan2f(y3-y2, x3-x2);
            float da1 = fabsf(k-atan2f(y2-y1, x2-x1));
            float da2 = fabsf(atan2f(y4-y3, x4-x3)-k);
            if (da1 >= FLT_PI) da1 = 2.0f*FLT_PI-da1;
            if (da2 >= FLT_PI) da2 = 2.0f*FLT_PI-da2;
            if (da1+da2 < angleTol) {
              // finally we can stop the recursion
              lineTo(x23, y23);
              return;
            }
            if (cuspLimit != 0.0f) {
              if (da1 > cuspLimit) {
                lineTo(x2, y2);
                return;
              }
              if (da2 > cuspLimit) {
                lineTo(x3, y3);
                return;
              }
            }
          }
        }
        break;
    }

    // continue subdivision
    tesselateBezierMcSeem(x1, y1, x12, y12, x123, y123, x1234, y1234, level+1);
    tesselateBezierMcSeem(x1234, y1234, x234, y234, x34, y34, x4, y4, level+1);
  }

  // Adaptive forward differencing for bezier tesselation.
  // See Lien, Sheue-Ling, Michael Shantz, and Vaughan Pratt.
  // "Adaptive forward differencing for rendering curves and surfaces."
  // ACM SIGGRAPH Computer Graphics. Vol. 21. No. 4. ACM, 1987.
  // original code by Taylor Holliday <taylor@audulus.com>
  void tesselateBezierAFD (in float x1, in float y1, in float x2, in float y2,
                           in float x3, in float y3, in float x4, in float y4)
  {
    enum AFD_ONE = (1<<10);

    // power basis
    immutable float ax = -x1+3*x2-3*x3+x4;
    immutable float ay = -y1+3*y2-3*y3+y4;
    immutable float bx = 3*x1-6*x2+3*x3;
    immutable float by = 3*y1-6*y2+3*y3;
    immutable float cx = -3*x1+3*x2;
    immutable float cy = -3*y1+3*y2;

    // Transform to forward difference basis (stepsize 1)
    float px = x1;
    float py = y1;
    float dx = ax+bx+cx;
    float dy = ay+by+cy;
    float ddx = 6*ax+2*bx;
    float ddy = 6*ay+2*by;
    float dddx = 6*ax;
    float dddy = 6*ay;

    //printf("dx: %f, dy: %f\n", dx, dy);
    //printf("ddx: %f, ddy: %f\n", ddx, ddy);
    //printf("dddx: %f, dddy: %f\n", dddx, dddy);

    int t = 0;
    int dt = AFD_ONE;

    immutable float tol = tessTol*4.0f;

    while (t < AFD_ONE) {
      // Flatness measure.
      float d = ddx*ddx+ddy*ddy+dddx*dddx+dddy*dddy;

      // printf("d: %f, th: %f\n", d, th);

      // Go to higher resolution if we're moving a lot or overshooting the end.
      while ((d > tol && dt > 1) || (t+dt > AFD_ONE)) {
        // printf("up\n");

        // Apply L to the curve. Increase curve resolution.
        dx = 0.5f*dx-(1.0f/8.0f)*ddx+(1.0f/16.0f)*dddx;
        dy = 0.5f*dy-(1.0f/8.0f)*ddy+(1.0f/16.0f)*dddy;
        ddx = (1.0f/4.0f)*ddx-(1.0f/8.0f)*dddx;
        ddy = (1.0f/4.0f)*ddy-(1.0f/8.0f)*dddy;
        dddx = (1.0f/8.0f)*dddx;
        dddy = (1.0f/8.0f)*dddy;

        // Half the stepsize.
        dt >>= 1;

        // Recompute d
        d = ddx*ddx+ddy*ddy+dddx*dddx+dddy*dddy;
      }

      // Go to lower resolution if we're really flat
      // and we aren't going to overshoot the end.
      // XXX: tol/32 is just a guess for when we are too flat.
      while ((d > 0 && d < tol/32.0f && dt < AFD_ONE) && (t+2*dt <= AFD_ONE)) {
        // printf("down\n");

        // Apply L^(-1) to the curve. Decrease curve resolution.
        dx = 2*dx+ddx;
        dy = 2*dy+ddy;
        ddx = 4*ddx+4*dddx;
        ddy = 4*ddy+4*dddy;
        dddx = 8*dddx;
        dddy = 8*dddy;

        // Double the stepsize.
        dt <<= 1;

        // Recompute d
        d = ddx*ddx+ddy*ddy+dddx*dddx+dddy*dddy;
      }

      // Forward differencing.
      px += dx;
      py += dy;
      dx += ddx;
      dy += ddy;
      ddx += dddx;
      ddy += dddy;

      // Output a point.
      lineTo(px, py/*, (t > 0 ? type : 0)*/);

      // Advance along the curve.
      t += dt;

      // Ensure we don't overshoot.
      assert(t <= AFD_ONE);
    }
  }


  public void tesselateBezier (in float x1, in float y1, in float x2, in float y2,
                               in float x3, in float y3, in float x4, in float y4)
  {
    final switch (tesselator) with (AGGTesselation) {
      case DeCasteljau:
        tesselateBezierDCj(x1, y1, x2, y2, x3, y3, x4, y4, 0);
        break;
      case AFD:
        tesselateBezierAFD(x1, y1, x2, y2, x3, y3, x4, y4);
        break;
      case DeCasteljauMcSeem:
        lineTo(x1, y1);
        tesselateBezierMcSeem(x1, y1, x2, y2, x3, y3, x4, y4, 1);
        lineTo(x4, y4);
        break;
    }
  }

  // ////////////////////////////////////////////////////////////////////////// //
  public enum BaphometDims = 512; // [0..511]
  private enum baph_debug_time = false;
  private enum baph_debug_dump = false;
  public void renderBaphomet (float ofsx=0.0f, float ofsy=0.0f, float scalex=1.0f, float scaley=1.0f) {
    auto path = cast(const(ubyte)[])baphometPath;
    immutable plen = path.length;
    uint ppos = 0;

    enum Command {
      Bounds, // always first, has 4 args (x0, y0, x1, y1)
      StrokeMode,
      FillMode,
      StrokeFillMode,
      NormalStroke,
      ThinStroke,
      MoveTo,
      LineTo,
      CubicTo, // cubic bezier
      EndPath,
    }

    Command getCommand () nothrow @trusted @nogc {
      if (ppos >= plen) assert(0, "invalid path");
      return cast(Command)(path.ptr[ppos++]);
    }

    float getFloat () nothrow @trusted @nogc {
      if (ppos >= plen || plen-ppos < float.sizeof) assert(0, "invalid path");
      version(LittleEndian) {
        float res = *cast(const(float)*)(&path.ptr[ppos]);
        ppos += cast(uint)float.sizeof;
        return res;
      } else {
        static assert(float.sizeof == 4);
        uint xp = path.ptr[ppos]|(path.ptr[ppos+1]<<8)|(path.ptr[ppos+2]<<16)|(path.ptr[ppos+3]<<24);
        ppos += cast(uint)float.sizeof;
        return *cast(const(float)*)(&xp);
      }
    }

    float scaleX (in float v) nothrow @trusted @nogc { pragma(inline, true); return ofsx+cast(float)v*scalex; }
    float scaleY (in float v) nothrow @trusted @nogc { pragma(inline, true); return ofsy+cast(float)v*scaley; }

    static if (baph_debug_time) {
      import iv.pxclock;
      immutable tstt = clockMicro();
    }

    beginPath();
    float cx = 0.0f, cy = 0.0f;
    bool doStroke = false, doFill = false;
    while (ppos < plen) {
      auto cmd = getCommand();
      static if (baph_debug_dump) {
        foreach (string mn; __traits(allMembers, Command)) {
          if (__traits(getMember, Command, mn) == cmd) {
            import core.stdc.stdio;
            static if (baph_debug_time) {
              printf("cmd=%s ... ", mn.ptr);
            } else {
              printf("cmd=%s\n", mn.ptr);
            }
          }
        }
        static if (baph_debug_time) {
          immutable cstt = clockMicro();
        }
      }
      final switch (cmd) {
        case Command.Bounds: ppos += 4*cast(uint)float.sizeof; break;
        case Command.StrokeMode: doStroke = true; doFill = false; break;
        case Command.FillMode: doStroke = false; doFill = true; break;
        case Command.StrokeFillMode: doStroke = true; doFill = true; break;
        case Command.NormalStroke: case Command.ThinStroke: break;
        case Command.MoveTo:
          cx = scaleX(getFloat());
          cy = scaleY(getFloat());
          moveTo(cx, cy);
          break;
        case Command.LineTo:
          immutable float ex = scaleX(getFloat());
          immutable float ey = scaleY(getFloat());
          lineTo(ex, ey);
          cx = ex;
          cy = ey;
          break;
        case Command.CubicTo: // cubic bezier
          immutable float x1 = scaleX(getFloat());
          immutable float y1 = scaleY(getFloat());
          immutable float x2 = scaleX(getFloat());
          immutable float y2 = scaleY(getFloat());
          immutable float ex = scaleX(getFloat());
          immutable float ey = scaleY(getFloat());
          bezierTo(x1, y1, x2, y2, ex, ey);
          cx = ex;
          cy = ey;
          break;
        case Command.EndPath: // don't close this path
          if (doFill) fill();
          if (doStroke) stroke();
          //doFill = doStroke = false;
          beginPath();
          break;
      }
      static if (baph_debug_dump && baph_debug_time) {
        immutable estt = clockMicro()-cstt;
        import core.stdc.stdio; printf("microsecs: %u\n", cast(uint)estt);
      }
    }
    if (doFill) {
      static if (baph_debug_time) {
        immutable fstt = clockMicro();
      }
      fill();
      static if (baph_debug_time) {
        immutable t = clockMicro()-fstt;
        import core.stdc.stdio; printf("fill microsecs: %u\n", cast(uint)t);
      }
    }
    if (doStroke) {
      static if (baph_debug_time) {
        immutable sstt = clockMicro();
      }
      stroke();
      static if (baph_debug_time) {
        immutable t = clockMicro()-sstt;
        import core.stdc.stdio; printf("stroke microsecs: %u\n", cast(uint)t);
      }
    }
    static if (baph_debug_time) {
      immutable estt = clockMicro()-tstt;
      import core.stdc.stdio; printf("total microsecs: %u\n", cast(uint)estt);
    }
    beginPath();
  }

  private static immutable ubyte[7641] baphometPath = [
    0x01,0x04,0x06,0x30,0x89,0x7f,0x43,0x00,0x80,0xff,0x43,0x08,0xa0,0x1d,0xc6,0x43,0x00,0x80,0xff,0x43,
    0x00,0x80,0xff,0x43,0xa2,0x1d,0xc6,0x43,0x00,0x80,0xff,0x43,0x30,0x89,0x7f,0x43,0x08,0x00,0x80,0xff,
    0x43,0x7a,0x89,0xe5,0x42,0xa0,0x1d,0xc6,0x43,0x00,0x00,0x00,0x00,0x30,0x89,0x7f,0x43,0x00,0x00,0x00,
    0x00,0x08,0x7a,0x89,0xe5,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x7a,0x89,0xe5,0x42,0x00,0x00,
    0x00,0x00,0x30,0x89,0x7f,0x43,0x08,0x00,0x00,0x00,0x00,0xa2,0x1d,0xc6,0x43,0x7a,0x89,0xe5,0x42,0x00,
    0x80,0xff,0x43,0x30,0x89,0x7f,0x43,0x00,0x80,0xff,0x43,0x09,0x06,0x30,0x89,0x7f,0x43,0x72,0x87,0xdd,
    0x43,0x08,0x16,0x68,0xb3,0x43,0x72,0x87,0xdd,0x43,0x71,0x87,0xdd,0x43,0x17,0x68,0xb3,0x43,0x71,0x87,
    0xdd,0x43,0x30,0x89,0x7f,0x43,0x08,0x71,0x87,0xdd,0x43,0xd2,0x2f,0x18,0x43,0x16,0x68,0xb3,0x43,0x35,
    0xe2,0x87,0x42,0x30,0x89,0x7f,0x43,0x35,0xe2,0x87,0x42,0x08,0xd1,0x2f,0x18,0x43,0x35,0xe2,0x87,0x42,
    0x35,0xe2,0x87,0x42,0xd2,0x2f,0x18,0x43,0x35,0xe2,0x87,0x42,0x30,0x89,0x7f,0x43,0x08,0x35,0xe2,0x87,
    0x42,0x17,0x68,0xb3,0x43,0xd1,0x2f,0x18,0x43,0x72,0x87,0xdd,0x43,0x30,0x89,0x7f,0x43,0x72,0x87,0xdd,
    0x43,0x09,0x06,0x79,0xcb,0x11,0x43,0x62,0xbf,0xd7,0x42,0x07,0xa4,0x3f,0x7f,0x43,0x0b,0x86,0xdc,0x43,
    0x07,0x6c,0xb9,0xb2,0x43,0xe8,0xd1,0xca,0x42,0x07,0x6e,0x4d,0xa0,0x42,0xa9,0x10,0x9c,0x43,0x07,0xb7,
    0x40,0xd7,0x43,0xa9,0x10,0x9c,0x43,0x07,0x79,0xcb,0x11,0x43,0x62,0xbf,0xd7,0x42,0x09,0x06,0x98,0x42,
    0x74,0x43,0xb1,0x8d,0x68,0x43,0x08,0xd7,0x24,0x79,0x43,0xba,0x83,0x6e,0x43,0xa9,0x16,0x7c,0x43,0x56,
    0xa1,0x76,0x43,0x74,0x2a,0x7d,0x43,0x44,0x73,0x80,0x43,0x08,0x55,0xd1,0x7e,0x43,0xe3,0xea,0x76,0x43,
    0xbc,0x18,0x81,0x43,0x7f,0xa8,0x6e,0x43,0x8f,0x0a,0x84,0x43,0x02,0xfc,0x68,0x43,0x09,0x06,0x92,0x29,
    0x8d,0x43,0x73,0xc3,0x67,0x43,0x08,0xa4,0xd9,0x8e,0x43,0xf2,0xa6,0x7a,0x43,0x8f,0x22,0x88,0x43,0x75,
    0x2a,0x7d,0x43,0x42,0x7f,0x82,0x43,0x08,0xc8,0x88,0x43,0x09,0x06,0xc1,0x79,0x74,0x43,0x50,0x64,0x89,
    0x43,0x08,0x68,0x2d,0x72,0x43,0xee,0x21,0x81,0x43,0xcd,0x97,0x55,0x43,0xe6,0xf1,0x7b,0x43,0x91,0xec,
    0x5d,0x43,0xa8,0xc7,0x6a,0x43,0x09,0x06,0xfa,0xa5,0x52,0x43,0x60,0x97,0x7c,0x43,0x08,0x19,0xff,0x50,
    0x43,0xe9,0x6e,0x8a,0x43,0xb0,0xbd,0x70,0x43,0x4c,0x51,0x82,0x43,0x04,0xeb,0x69,0x43,0x66,0x0f,0x8e,
    0x43,0x09,0x06,0x17,0xbf,0x71,0x43,0x2c,0x58,0x94,0x43,0x08,0x1c,0x96,0x6e,0x43,0x61,0x68,0x99,0x43,
    0x2d,0x3a,0x6e,0x43,0xc8,0x81,0x9e,0x43,0xb7,0x9b,0x72,0x43,0x61,0xa4,0xa3,0x43,0x09,0x06,0x30,0xdb,
    0x82,0x43,0xdb,0xe9,0x93,0x43,0x08,0x11,0x82,0x84,0x43,0x61,0x68,0x99,0x43,0xe8,0x4a,0x84,0x43,0x8e,
    0xa6,0x9e,0x43,0x42,0x7f,0x82,0x43,0x61,0xa4,0xa3,0x43,0x09,0x06,0xc4,0x02,0x85,0x43,0xd1,0x0b,0x92,
    0x43,0x08,0xd6,0xb2,0x86,0x43,0x34,0x1e,0x92,0x43,0x4f,0x58,0x87,0x43,0xa4,0xf1,0x92,0x43,0x03,0xd9,
    0x87,0x43,0x7b,0xc6,0x94,0x43,0x09,0x06,0x87,0x3e,0x64,0x43,0x31,0x3b,0x93,0x43,0x08,0x3b,0xbf,0x64,
    0x43,0x6f,0xf9,0x91,0x43,0x96,0x0b,0x67,0x43,0xc5,0x4a,0x91,0x43,0xcf,0xfe,0x6a,0x43,0x31,0x2f,0x91,
    0x43,0x09,0x06,0x16,0x74,0xb5,0x43,0x08,0xec,0x8e,0x43,0x08,0x1b,0x4b,0xb2,0x43,0xee,0x5d,0x8b,0x43,
    0x48,0x4d,0xad,0x43,0x12,0xa6,0x8a,0x43,0xf3,0xd7,0xa7,0x43,0x74,0xb8,0x8a,0x43,0x08,0x8c,0xb2,0xa0,
    0x43,0xcd,0xf8,0x8a,0x43,0x68,0x46,0x9b,0x43,0x79,0x8f,0x87,0x43,0x49,0xc9,0x96,0x43,0xe9,0x3e,0x82,
    0x43,0x08,0x60,0x5c,0x97,0x43,0xa1,0xde,0x8b,0x43,0x4e,0xa0,0x93,0x43,0x31,0x3b,0x93,0x43,0x9f,0xea,
    0x8d,0x43,0x27,0x8d,0x99,0x43,0x08,0x07,0xe0,0x8c,0x43,0x06,0x34,0x9b,0x43,0x38,0xe9,0x8c,0x43,0x46,
    0x0a,0x9e,0x43,0x3d,0xcc,0x8b,0x43,0xb2,0x06,0xa2,0x43,0x08,0xf1,0x40,0x8a,0x43,0xb0,0x12,0xa4,0x43,
    0x39,0xd1,0x88,0x43,0x76,0x43,0xa6,0x43,0xfa,0x06,0x88,0x43,0xa4,0x75,0xa9,0x43,0x08,0x19,0x6c,0x88,
    0x43,0x9f,0x9e,0xac,0x43,0x66,0xeb,0x87,0x43,0x44,0x76,0xb0,0x43,0x6b,0xce,0x86,0x43,0x3b,0xbc,0xb4,
    0x43,0x08,0xa9,0x8c,0x85,0x43,0x06,0xd0,0xb5,0x43,0xfa,0xee,0x83,0x43,0x74,0xa3,0xb6,0x43,0x3d,0x90,
    0x81,0x43,0x31,0xf6,0xb6,0x43,0x08,0x9d,0x61,0x7d,0x43,0xee,0x48,0xb7,0x43,0x3b,0x1f,0x75,0x43,0xcf,
    0xe3,0xb6,0x43,0xee,0x6f,0x6d,0x43,0x68,0xe2,0xb5,0x43,0x08,0xd4,0xed,0x6b,0x43,0x87,0x2f,0xb2,0x43,
    0x0e,0xc9,0x6b,0x43,0xa7,0x7c,0xae,0x43,0x98,0xfa,0x67,0x43,0xab,0x53,0xab,0x43,0x08,0x25,0x2c,0x64,
    0x43,0x33,0xa2,0xa8,0x43,0x40,0x96,0x61,0x43,0xc3,0xc2,0xa5,0x43,0x64,0xde,0x60,0x43,0xfa,0xa2,0xa2,
    0x43,0x08,0xb0,0x5d,0x60,0x43,0x06,0x4c,0x9f,0x43,0x9a,0xca,0x5f,0x43,0x38,0x3d,0x9b,0x43,0x3b,0x8f,
    0x5c,0x43,0x85,0xb0,0x98,0x43,0x08,0x42,0x36,0x51,0x43,0x3d,0xf0,0x91,0x43,0xcd,0x4f,0x49,0x43,0xdb,
    0xb9,0x8b,0x43,0xe0,0xdb,0x44,0x43,0x42,0x8b,0x84,0x43,0x08,0x7e,0xc9,0x44,0x43,0x8a,0x57,0x8d,0x43,
    0xbc,0x6c,0x0f,0x43,0x23,0x62,0x8e,0x43,0xf5,0x17,0x07,0x43,0xc5,0x3e,0x8f,0x43,0x09,0x06,0xe0,0xea,
    0x76,0x43,0xab,0xef,0xc5,0x43,0x08,0x12,0x00,0x79,0x43,0xab,0xcb,0xbf,0x43,0x79,0xb9,0x6d,0x43,0x7e,
    0x8d,0xba,0x43,0xee,0x6f,0x6d,0x43,0x98,0xeb,0xb5,0x43,0x08,0xe0,0x02,0x7b,0x43,0x5f,0x1c,0xb8,0x43,
    0x85,0x2c,0x82,0x43,0xe9,0x65,0xb8,0x43,0xd6,0xb2,0x86,0x43,0xc6,0x05,0xb5,0x43,0x08,0x03,0xcd,0x85,
    0x43,0x5a,0x39,0xb9,0x43,0xe4,0x4f,0x81,0x43,0xdb,0xd4,0xbf,0x43,0xdf,0x6c,0x82,0x43,0xbc,0x93,0xc5,
    0x43,0x09,0x06,0xf0,0xd0,0x22,0x43,0x5d,0x19,0x08,0x43,0x08,0xbc,0xab,0x49,0x43,0x4a,0x35,0x29,0x43,
    0xcb,0xf7,0x65,0x43,0xce,0x37,0x45,0x43,0x0e,0x99,0x63,0x43,0x67,0xc6,0x5c,0x43,0x09,0x06,0x05,0x94,
    0xab,0x43,0xc2,0x13,0x04,0x43,0x08,0x9f,0x26,0x98,0x43,0x11,0x42,0x25,0x43,0x97,0x00,0x8a,0x43,0x32,
    0x32,0x41,0x43,0xf5,0x2f,0x8b,0x43,0xc7,0xc0,0x58,0x43,0x09,0x06,0x8f,0x85,0x48,0x43,0xe0,0xa8,0x8c,
    0x43,0x08,0x55,0xaa,0x48,0x43,0xe0,0xa8,0x8c,0x43,0x6b,0x3d,0x49,0x43,0xc1,0x43,0x8c,0x43,0x31,0x62,
    0x49,0x43,0xc1,0x43,0x8c,0x43,0x08,0x2f,0xe3,0x2f,0x43,0xad,0xe7,0x98,0x43,0xff,0x0d,0x0d,0x43,0xad,
    0xf3,0x9a,0x43,0xf0,0xaf,0xcc,0x42,0x74,0x00,0x97,0x43,0x08,0xbb,0xa2,0xf7,0x42,0x93,0x4d,0x93,0x43,
    0x5e,0x19,0x08,0x43,0x5a,0x2a,0x87,0x43,0x23,0x6e,0x10,0x43,0x42,0x97,0x86,0x43,0x08,0xca,0xe8,0x33,
    0x43,0x1b,0x3c,0x80,0x43,0x80,0xe8,0x4d,0x43,0xda,0xf4,0x70,0x43,0xae,0x0e,0x4f,0x43,0x2b,0x1b,0x65,
    0x43,0x08,0x66,0x96,0x54,0x43,0xa3,0xe1,0x3b,0x43,0x4e,0xc4,0x19,0x43,0xa0,0x1a,0x16,0x43,0x10,0xe2,
    0x14,0x43,0x26,0x14,0xe0,0x42,0x08,0x5c,0x91,0x1c,0x43,0xcb,0x27,0xee,0x42,0xa9,0x40,0x24,0x43,0x71,
    0x3b,0xfc,0x42,0xf3,0xef,0x2b,0x43,0x8b,0x27,0x05,0x43,0x08,0xe2,0x4b,0x2c,0x43,0x48,0x86,0x07,0x43,
    0x79,0x62,0x2f,0x43,0x05,0xe5,0x09,0x43,0x55,0x32,0x34,0x43,0xa0,0xd2,0x09,0x43,0x08,0x74,0xa3,0x36,
    0x43,0x3a,0xd1,0x08,0x43,0x7e,0x81,0x38,0x43,0x09,0xd4,0x0a,0x43,0x0d,0xba,0x39,0x43,0xa0,0xea,0x0d,
    0x43,0x08,0x6f,0xe4,0x3d,0x43,0x43,0xc7,0x0e,0x43,0xd6,0xe5,0x3e,0x43,0xc4,0x4a,0x11,0x43,0x55,0x7a,
    0x40,0x43,0x59,0x72,0x13,0x43,0x08,0x55,0x92,0x44,0x43,0xbf,0x73,0x14,0x43,0x23,0x95,0x46,0x43,0xa5,
    0x09,0x17,0x43,0xe0,0xf3,0x48,0x43,0xfe,0x55,0x19,0x43,0x08,0xcd,0x4f,0x49,0x43,0xaa,0x10,0x1c,0x43,
    0x61,0x77,0x4b,0x43,0xfe,0x6d,0x1d,0x43,0x80,0xe8,0x4d,0x43,0x2b,0x94,0x1e,0x43,0x08,0x58,0xc9,0x51,
    0x43,0x41,0x27,0x1f,0x43,0x9b,0x82,0x53,0x43,0x35,0x72,0x20,0x43,0x53,0xf2,0x54,0x43,0x88,0xcf,0x21,
    0x43,0x08,0x7b,0x29,0x55,0x43,0xe8,0x0a,0x25,0x43,0xb2,0x2d,0x58,0x43,0xef,0xe8,0x26,0x43,0x9b,0xb2,
    0x5b,0x43,0xd0,0x8f,0x28,0x43,0x08,0x5f,0xef,0x5f,0x43,0xeb,0x11,0x2a,0x43,0xfd,0xdc,0x5f,0x43,0x6e,
    0x95,0x2c,0x43,0x3b,0xa7,0x60,0x43,0x2b,0xf4,0x2e,0x43,0x08,0x06,0xbb,0x61,0x43,0xfd,0xe5,0x31,0x43,
    0xe7,0x61,0x63,0x43,0xef,0x30,0x33,0x43,0x53,0x52,0x65,0x43,0xa3,0xb1,0x33,0x43,0x08,0x12,0xa0,0x68,
    0x43,0x7f,0x69,0x34,0x43,0x40,0xc6,0x69,0x43,0x64,0xff,0x36,0x43,0x7e,0x90,0x6a,0x43,0x71,0xcc,0x39,
    0x43,0x08,0xbc,0x5a,0x6b,0x43,0x51,0x73,0x3b,0x43,0xc1,0x49,0x6c,0x43,0xa5,0xd0,0x3c,0x43,0xe0,0xba,
    0x6e,0x43,0xb8,0x74,0x3c,0x43,0x08,0x6b,0x1c,0x73,0x43,0x13,0xc1,0x3e,0x43,0x40,0xf6,0x71,0x43,0xce,
    0x1f,0x41,0x43,0x55,0x89,0x72,0x43,0x8d,0x7e,0x43,0x43,0x08,0x68,0x2d,0x72,0x43,0x89,0xae,0x4b,0x43,
    0xc1,0x79,0x74,0x43,0xcb,0x78,0x4c,0x43,0x55,0xa1,0x76,0x43,0x5b,0xb1,0x4d,0x43,0x08,0xa2,0x38,0x7a,
    0x43,0xd1,0x56,0x4e,0x43,0x85,0xb6,0x78,0x43,0xb1,0x15,0x54,0x43,0x83,0xc7,0x77,0x43,0x89,0x0e,0x5c,
    0x43,0x08,0xcf,0x46,0x77,0x43,0x0f,0x81,0x5f,0x43,0x1a,0xde,0x7a,0x43,0xce,0xc7,0x5d,0x43,0x42,0x73,
    0x80,0x43,0x99,0xc3,0x5a,0x43,0x08,0x85,0x2c,0x82,0x43,0xf6,0xe6,0x59,0x43,0x81,0x3d,0x81,0x43,0x16,
    0x10,0x50,0x43,0xd6,0x8e,0x80,0x43,0x5b,0x99,0x49,0x43,0x08,0xc4,0xea,0x80,0x43,0x22,0x95,0x46,0x43,
    0xfa,0xe2,0x81,0x43,0xda,0xec,0x43,0x43,0x78,0x77,0x83,0x43,0xe4,0xb2,0x41,0x43,0x08,0x8a,0x27,0x85,
    0x43,0x86,0x77,0x3e,0x43,0x0c,0x9f,0x85,0x43,0x07,0xf4,0x3b,0x43,0x8f,0x16,0x86,0x43,0xe6,0x82,0x39,
    0x43,0x08,0x85,0x44,0x86,0x43,0x37,0xd9,0x35,0x43,0x1e,0x4f,0x87,0x43,0xe1,0x7b,0x34,0x43,0xdf,0x90,
    0x88,0x43,0xb6,0x55,0x33,0x43,0x08,0xae,0x93,0x8a,0x43,0xfd,0xe5,0x31,0x43,0xfa,0x12,0x8a,0x43,0xbf,
    0x03,0x2d,0x43,0x19,0x78,0x8a,0x43,0x45,0x5e,0x2c,0x43,0x08,0x03,0xf1,0x8b,0x43,0xac,0x47,0x29,0x43,
    0x2f,0x17,0x8d,0x43,0x45,0x46,0x28,0x43,0xc8,0x21,0x8e,0x43,0x30,0xb3,0x27,0x43,0x08,0xa9,0xc8,0x8f,
    0x43,0xef,0xe8,0x26,0x43,0xbf,0x5b,0x90,0x43,0x5b,0xc1,0x24,0x43,0x10,0xca,0x90,0x43,0xa0,0x62,0x22,
    0x43,0x08,0x26,0x5d,0x91,0x43,0xbb,0xcc,0x1f,0x43,0xf0,0x70,0x92,0x43,0x78,0x13,0x1e,0x43,0x77,0xd7,
    0x93,0x43,0x73,0x24,0x1d,0x43,0x08,0x65,0x3f,0x96,0x43,0xce,0x58,0x1b,0x43,0xbe,0x7f,0x96,0x43,0xbf,
    0x8b,0x18,0x43,0x60,0x5c,0x97,0x43,0xb6,0xad,0x16,0x43,0x08,0xba,0xa8,0x99,0x43,0x78,0xcb,0x11,0x43,
    0x49,0xe1,0x9a,0x43,0x78,0xcb,0x11,0x43,0x01,0x51,0x9c,0x43,0x73,0xdc,0x10,0x43,0x08,0x72,0x24,0x9d,
    0x43,0xd2,0xff,0x0f,0x43,0x1c,0xd3,0x9d,0x43,0x07,0xec,0x0e,0x43,0xeb,0xc9,0x9d,0x43,0xe8,0x7a,0x0c,
    0x43,0x08,0x60,0x80,0x9d,0x43,0xd7,0xbe,0x08,0x43,0x4d,0xe8,0x9f,0x43,0x86,0x50,0x08,0x43,0x25,0xbd,
    0xa1,0x43,0x5b,0x2a,0x07,0x43,0x08,0x99,0x7f,0xa3,0x43,0xc9,0xf1,0x05,0x43,0x48,0x1d,0xa5,0x43,0x86,
    0x38,0x04,0x43,0x6c,0x71,0xa6,0x43,0x18,0x59,0x01,0x43,0x08,0x32,0x96,0xa6,0x43,0x6e,0x64,0xff,0x42,
    0x48,0x29,0xa7,0x43,0xed,0xcf,0xfd,0x42,0x5f,0xbc,0xa7,0x43,0x71,0x3b,0xfc,0x42,0x08,0xf3,0xe3,0xa9,
    0x43,0xf7,0x7d,0xf7,0x42,0xd8,0x6d,0xaa,0x43,0x45,0xe5,0xf2,0x42,0x48,0x41,0xab,0x43,0xcb,0x27,0xee,
    0x42,0x08,0x24,0xf9,0xab,0x43,0x52,0x6a,0xe9,0x42,0xee,0x0c,0xad,0x43,0x4c,0x8c,0xe7,0x42,0x1b,0x33,
    0xae,0x43,0xcc,0xf7,0xe5,0x42,0x08,0xaa,0x6b,0xaf,0x43,0xe8,0x61,0xe3,0x42,0x90,0xf5,0xaf,0x43,0xc9,
    0xf0,0xe0,0x42,0xe0,0x63,0xb0,0x43,0xe5,0x5a,0xde,0x42,0x08,0xaa,0x83,0xb3,0x43,0x29,0x2d,0x09,0x43,
    0x6a,0xfe,0x8e,0x43,0xb8,0x74,0x3c,0x43,0xd5,0x06,0x95,0x43,0xe6,0x79,0x67,0x43,0x08,0x2f,0x53,0x97,
    0x43,0xe9,0xb0,0x74,0x43,0xa8,0x28,0xa0,0x43,0x43,0xfd,0x76,0x43,0x83,0x28,0xad,0x43,0x17,0x59,0x81,
    0x43,0x08,0x3d,0xe7,0xbf,0x43,0x4b,0x8d,0x8c,0x43,0xae,0x96,0xba,0x43,0x66,0x27,0x92,0x43,0x15,0xe0,
    0xc7,0x43,0x6f,0x11,0x96,0x43,0x08,0x7e,0x5d,0xb2,0x43,0xdb,0x01,0x98,0x43,0x9e,0x56,0xa0,0x43,0x80,
    0xc1,0x97,0x43,0x69,0x2e,0x97,0x43,0x31,0x17,0x8d,0x43,0x09,0x06,0xab,0xa7,0x39,0x43,0x67,0x0f,0x0e,
    0x43,0x08,0xdb,0xbc,0x3b,0x43,0xe8,0x92,0x10,0x43,0xb5,0x85,0x3b,0x43,0x97,0x3c,0x14,0x43,0xab,0xa7,
    0x39,0x43,0x0c,0x0b,0x18,0x43,0x09,0x06,0xca,0x30,0x40,0x43,0x30,0x3b,0x13,0x43,0x08,0x17,0xc8,0x43,
    0x43,0xa5,0x09,0x17,0x43,0x7e,0xc9,0x44,0x43,0x1a,0xd8,0x1a,0x43,0x9d,0x22,0x43,0x43,0x8d,0xa6,0x1e,
    0x43,0x09,0x06,0xc8,0x78,0x4c,0x43,0xed,0xc9,0x1d,0x43,0x08,0x0b,0x32,0x4e,0x43,0x22,0xce,0x20,0x43,
    0x23,0xc5,0x4e,0x43,0x58,0xd2,0x23,0x43,0x0b,0x32,0x4e,0x43,0x2b,0xc4,0x26,0x43,0x09,0x06,0xec,0x08,
    0x58,0x43,0xc7,0xb1,0x26,0x43,0x08,0x02,0x9c,0x58,0x43,0xef,0x00,0x2b,0x43,0xd9,0x64,0x58,0x43,0x02,
    0xbd,0x2e,0x43,0x10,0x51,0x57,0x43,0x37,0xc1,0x31,0x43,0x09,0x06,0xcb,0xdf,0x61,0x43,0x4a,0x65,0x31,
    0x43,0x08,0xbe,0x2a,0x63,0x43,0xbd,0x33,0x35,0x43,0x32,0xe1,0x62,0x43,0x56,0x4a,0x38,0x43,0xde,0x83,
    0x61,0x43,0x3c,0xe0,0x3a,0x43,0x09,0x06,0x1c,0x7e,0x6a,0x43,0x5b,0x39,0x39,0x43,0x08,0x31,0x11,0x6b,
    0x43,0x0c,0xd2,0x3d,0x43,0x1c,0x7e,0x6a,0x43,0x13,0xd9,0x42,0x43,0xd9,0xc4,0x68,0x43,0xcb,0x60,0x48,
    0x43,0x09,0x06,0xe5,0xc1,0x73,0x43,0x16,0xf8,0x4b,0x43,0x08,0xa6,0xf7,0x72,0x43,0xb1,0xfd,0x4f,0x43,
    0x3b,0x07,0x71,0x43,0x4a,0x14,0x53,0x43,0xa2,0xf0,0x6d,0x43,0x7c,0x29,0x55,0x43,0x09,0x06,0x00,0x8d,
    0xa6,0x43,0xef,0x21,0x01,0x43,0x08,0x52,0xfb,0xa6,0x43,0xce,0xc8,0x02,0x43,0xe6,0x16,0xa7,0x43,0x51,
    0x4c,0x05,0x43,0x3b,0x68,0xa6,0x43,0x4c,0x75,0x08,0x43,0x09,0x06,0xde,0x20,0xa1,0x43,0x86,0x50,0x08,
    0x43,0x08,0xd4,0x4e,0xa1,0x43,0xd3,0xe7,0x0b,0x43,0xb5,0xe9,0xa0,0x43,0x59,0x5a,0x0f,0x43,0xba,0xcc,
    0x9f,0x43,0x54,0x83,0x12,0x43,0x09,0x06,0x77,0xfb,0x99,0x43,0x6c,0x16,0x13,0x43,0x08,0xde,0xfc,0x9a,
    0x43,0x4a,0xbd,0x14,0x43,0x06,0x34,0x9b,0x43,0xfe,0x55,0x19,0x43,0x13,0xe9,0x99,0x43,0x41,0x27,0x1f,
    0x43,0x09,0x06,0x46,0xce,0x93,0x43,0x26,0xa5,0x1d,0x43,0x08,0xe7,0xaa,0x94,0x43,0xbb,0xcc,0x1f,0x43,
    0x18,0xb4,0x94,0x43,0xa8,0x40,0x24,0x43,0xe2,0xbb,0x93,0x43,0x21,0xfe,0x28,0x43,0x09,0x06,0xb1,0x8e,
    0x8d,0x43,0xa8,0x58,0x28,0x43,0x08,0x19,0x90,0x8e,0x43,0x54,0x13,0x2b,0x43,0xa4,0xd9,0x8e,0x43,0x84,
    0x40,0x31,0x43,0x46,0xaa,0x8d,0x43,0x29,0x24,0x37,0x43,0x09,0x06,0xd6,0xbe,0x88,0x43,0xef,0x30,0x33,
    0x43,0x08,0x0c,0xb7,0x89,0x43,0x0e,0xa2,0x35,0x43,0xc0,0x37,0x8a,0x43,0x7a,0xaa,0x3b,0x43,0xbb,0x48,
    0x89,0x43,0xbb,0x7b,0x41,0x43,0x09,0x06,0x3a,0xad,0x82,0x43,0xc4,0x59,0x43,0x43,0x08,0xd2,0xb7,0x83,
    0x43,0x2b,0x5b,0x44,0x43,0x35,0xd6,0x85,0x43,0x48,0xf5,0x49,0x43,0x42,0x97,0x86,0x43,0xc4,0xa1,0x4f,
    0x43,0x09,0x06,0x9c,0xb3,0x80,0x43,0x48,0x55,0x5a,0x43,0x08,0xff,0xc5,0x80,0x43,0x09,0x73,0x55,0x43,
    0x93,0xe1,0x80,0x43,0x0f,0x39,0x53,0x43,0xf1,0xbe,0x7e,0x43,0x18,0xe7,0x4c,0x43,0x09,0x06,0xe0,0x02,
    0x7b,0x43,0x92,0xec,0x5d,0x43,0x08,0x09,0x3a,0x7b,0x43,0xf0,0xf7,0x58,0x43,0x09,0x3a,0x7b,0x43,0xe6,
    0x31,0x5b,0x43,0xe0,0x02,0x7b,0x43,0xa8,0x4f,0x56,0x43,0x09,0x06,0x39,0x4f,0x7d,0x43,0x3e,0x8f,0x5c,
    0x43,0x08,0xe9,0xe0,0x7c,0x43,0x03,0x9c,0x58,0x43,0x1e,0x2b,0x81,0x43,0x7f,0x30,0x5a,0x43,0xff,0x73,
    0x7d,0x43,0xf6,0xb6,0x51,0x43,0x09,0x06,0x5c,0xb8,0x52,0x43,0x28,0x21,0x87,0x43,0x08,0xae,0x3e,0x57,
    0x43,0x12,0x9a,0x88,0x43,0x23,0xf5,0x56,0x43,0x04,0xf1,0x8b,0x43,0x25,0xfc,0x5b,0x43,0x85,0x74,0x8e,
    0x43,0x08,0x2f,0xf2,0x61,0x43,0x8e,0x52,0x90,0x43,0xd9,0xdc,0x6c,0x43,0x85,0x74,0x8e,0x43,0xc6,0x20,
    0x69,0x43,0x3d,0xd8,0x8d,0x43,0x08,0x6d,0x8c,0x5a,0x43,0xf5,0x3b,0x8d,0x43,0x3d,0x77,0x58,0x43,0xa1,
    0xc6,0x87,0x43,0xf8,0xed,0x5e,0x43,0x5e,0x0d,0x86,0x43,0x09,0x06,0xde,0xcc,0x92,0x43,0xf7,0x17,0x87,
    0x43,0x08,0xb6,0x89,0x90,0x43,0xae,0x87,0x88,0x43,0x4a,0xa5,0x90,0x43,0xa1,0xde,0x8b,0x43,0xf9,0x2a,
    0x8e,0x43,0x23,0x62,0x8e,0x43,0x08,0xf5,0x2f,0x8b,0x43,0x5c,0x49,0x90,0x43,0x35,0xd6,0x85,0x43,0x8e,
    0x46,0x8e,0x43,0x3d,0xb4,0x87,0x43,0x47,0xaa,0x8d,0x43,0x08,0x6a,0xfe,0x8e,0x43,0xff,0x0d,0x8d,0x43,
    0xbb,0x6c,0x8f,0x43,0xf7,0x17,0x87,0x43,0x5c,0x31,0x8c,0x43,0xb2,0x5e,0x85,0x43,0x09,0x06,0x60,0x38,
    0x91,0x43,0x69,0x5d,0x7a,0x43,0x08,0x34,0x1e,0x92,0x43,0x1e,0x5b,0x89,0x43,0x04,0x63,0x7e,0x43,0x5e,
    0x01,0x84,0x43,0x59,0x2a,0x87,0x43,0x0d,0xcf,0x8d,0x43,0x09,0x03,0x04,0x06,0x5a,0x18,0x63,0x43,0x82,
    0x79,0x8b,0x43,0x08,0x25,0x2c,0x64,0x43,0x82,0x79,0x8b,0x43,0x2a,0x1b,0x65,0x43,0x9d,0xef,0x8a,0x43,
    0x2a,0x1b,0x65,0x43,0xc1,0x37,0x8a,0x43,0x08,0x2a,0x1b,0x65,0x43,0x17,0x89,0x89,0x43,0x25,0x2c,0x64,
    0x43,0x31,0xff,0x88,0x43,0x5a,0x18,0x63,0x43,0x31,0xff,0x88,0x43,0x08,0xf3,0x16,0x62,0x43,0x31,0xff,
    0x88,0x43,0xee,0x27,0x61,0x43,0x17,0x89,0x89,0x43,0xee,0x27,0x61,0x43,0xc1,0x37,0x8a,0x43,0x08,0xee,
    0x27,0x61,0x43,0x9d,0xef,0x8a,0x43,0xf3,0x16,0x62,0x43,0x82,0x79,0x8b,0x43,0x5a,0x18,0x63,0x43,0x82,
    0x79,0x8b,0x43,0x09,0x06,0x4f,0x64,0x89,0x43,0x82,0x79,0x8b,0x43,0x08,0x34,0xee,0x89,0x43,0x82,0x79,
    0x8b,0x43,0x85,0x5c,0x8a,0x43,0x9d,0xef,0x8a,0x43,0x85,0x5c,0x8a,0x43,0xc1,0x37,0x8a,0x43,0x08,0x85,
    0x5c,0x8a,0x43,0x17,0x89,0x89,0x43,0x34,0xee,0x89,0x43,0x31,0xff,0x88,0x43,0x4f,0x64,0x89,0x43,0x31,
    0xff,0x88,0x43,0x08,0x9c,0xe3,0x88,0x43,0x31,0xff,0x88,0x43,0x19,0x6c,0x88,0x43,0x17,0x89,0x89,0x43,
    0x19,0x6c,0x88,0x43,0xc1,0x37,0x8a,0x43,0x08,0x19,0x6c,0x88,0x43,0x9d,0xef,0x8a,0x43,0x9c,0xe3,0x88,
    0x43,0x82,0x79,0x8b,0x43,0x4f,0x64,0x89,0x43,0x82,0x79,0x8b,0x43,0x09,0x02,0x04,0x06,0x19,0x60,0x86,
    0x43,0xec,0xed,0xa3,0x43,0x08,0x35,0xd6,0x85,0x43,0x76,0x43,0xa6,0x43,0x93,0xe1,0x80,0x43,0x57,0x02,
    0xac,0x43,0x61,0xd8,0x80,0x43,0x87,0x17,0xae,0x43,0x08,0xa5,0x85,0x80,0x43,0xc3,0xfe,0xaf,0x43,0xce,
    0xbc,0x80,0x43,0x83,0x40,0xb1,0x43,0xa5,0x91,0x82,0x43,0x79,0x6e,0xb1,0x43,0x08,0x23,0x26,0x84,0x43,
    0x40,0x93,0xb1,0x43,0x30,0xe7,0x84,0x43,0xbe,0x1b,0xb1,0x43,0x11,0x82,0x84,0x43,0xab,0x6b,0xaf,0x43,
    0x08,0xb7,0x41,0x84,0x43,0x3b,0x98,0xae,0x43,0xb7,0x41,0x84,0x43,0xc3,0xf2,0xad,0x43,0xa1,0xae,0x83,
    0x43,0x83,0x28,0xad,0x43,0x08,0xb2,0x52,0x83,0x43,0x80,0x39,0xac,0x43,0x81,0x49,0x83,0x43,0xf0,0x00,
    0xab,0x43,0xe4,0x67,0x85,0x43,0x76,0x4f,0xa8,0x43,0x08,0x9c,0xd7,0x86,0x43,0xd1,0x83,0xa6,0x43,0xec,
    0x45,0x87,0x43,0x01,0x75,0xa2,0x43,0x19,0x60,0x86,0x43,0xec,0xed,0xa3,0x43,0x09,0x06,0xd9,0xdc,0x6c,
    0x43,0x14,0x25,0xa4,0x43,0x08,0xa2,0xf0,0x6d,0x43,0x9f,0x7a,0xa6,0x43,0x47,0xec,0x77,0x43,0x80,0x39,
    0xac,0x43,0xa9,0xfe,0x77,0x43,0xb0,0x4e,0xae,0x43,0x08,0x23,0xa4,0x78,0x43,0xea,0x35,0xb0,0x43,0xd2,
    0x35,0x78,0x43,0xab,0x77,0xb1,0x43,0xc1,0x79,0x74,0x43,0xa2,0xa5,0xb1,0x43,0x08,0xc6,0x50,0x71,0x43,
    0x68,0xca,0xb1,0x43,0xab,0xce,0x6f,0x43,0xe7,0x52,0xb1,0x43,0xea,0x98,0x70,0x43,0xd4,0xa2,0xaf,0x43,
    0x08,0x9d,0x19,0x71,0x43,0x96,0xd8,0xae,0x43,0x9d,0x19,0x71,0x43,0xec,0x29,0xae,0x43,0xca,0x3f,0x72,
    0x43,0xab,0x5f,0xad,0x43,0x08,0xa6,0xf7,0x72,0x43,0xa7,0x70,0xac,0x43,0x09,0x0a,0x73,0x43,0x17,0x38,
    0xab,0x43,0x44,0xcd,0x6e,0x43,0x9f,0x86,0xa8,0x43,0x08,0xd4,0xed,0x6b,0x43,0xf8,0xba,0xa6,0x43,0x31,
    0x11,0x6b,0x43,0x2a,0xac,0xa2,0x43,0xd9,0xdc,0x6c,0x43,0x14,0x25,0xa4,0x43,0x09,0x01,0x05,0x06,0x66,
    0x5d,0x7a,0x43,0x74,0xeb,0xc2,0x43,0x08,0x09,0x22,0x77,0x43,0x50,0xbb,0xc7,0x43,0xe9,0xe0,0x7c,0x43,
    0xf5,0x86,0xc9,0x43,0x8f,0x94,0x7a,0x43,0xc5,0x95,0xcd,0x43,0x09,0x06,0x08,0x98,0x80,0x43,0x6b,0x19,
    0xc3,0x43,0x08,0xb7,0x35,0x82,0x43,0x79,0xf2,0xc7,0x43,0xf1,0xbe,0x7e,0x43,0x1e,0xbe,0xc9,0x43,0x73,
    0x7c,0x80,0x43,0xec,0xcc,0xcd,0x43,0x09,0x06,0x28,0xab,0x7d,0x43,0xae,0xde,0xc6,0x43,0x08,0x1e,0xcd,
    0x7b,0x43,0x8a,0xa2,0xc9,0x43,0x30,0x89,0x7f,0x43,0x5c,0x94,0xcc,0x43,0x28,0xab,0x7d,0x43,0x42,0x2a,
    0xcf,0x43,0x09,0x01,0x05,0x06,0x24,0x14,0xe0,0x42,0xf5,0x77,0x97,0x43,0x08,0xf7,0x1d,0xe7,0x42,0x74,
    0x00,0x97,0x43,0x4d,0x93,0xec,0x42,0xdb,0xf5,0x95,0x43,0x29,0x4b,0xed,0x42,0xcd,0x34,0x95,0x43,0x09,
    0x06,0x29,0x7b,0xf5,0x42,0x6f,0x1d,0x98,0x43,0x08,0xe4,0xf1,0xfb,0x42,0x61,0x5c,0x97,0x43,0xdb,0x7d,
    0x01,0x43,0xb2,0xbe,0x95,0x43,0x55,0x23,0x02,0x43,0xe7,0xaa,0x94,0x43,0x09,0x06,0x98,0xdc,0x03,0x43,
    0xbe,0x8b,0x98,0x43,0x08,0x66,0xdf,0x05,0x43,0x47,0xe6,0x97,0x43,0xae,0x87,0x08,0x43,0x98,0x48,0x96,
    0x43,0x61,0x08,0x09,0x43,0xd6,0x06,0x95,0x43,0x09,0x06,0x31,0x0b,0x0b,0x43,0x8e,0x82,0x98,0x43,0x08,
    0xdb,0xc5,0x0d,0x43,0x80,0xc1,0x97,0x43,0xd6,0xee,0x10,0x43,0xa9,0xec,0x95,0x43,0x79,0xcb,0x11,0x43,
    0x55,0x8f,0x94,0x43,0x09,0x06,0xd1,0x2f,0x18,0x43,0xdb,0x01,0x98,0x43,0x08,0xad,0xe7,0x18,0x43,0x38,
    0x25,0x97,0x43,0x8a,0x9f,0x19,0x43,0x80,0xb5,0x95,0x43,0xd6,0x1e,0x19,0x43,0xe0,0xd8,0x94,0x43,0x09,
    0x06,0x9a,0x5b,0x1d,0x43,0x58,0x8a,0x97,0x43,0x08,0x01,0x5d,0x1e,0x43,0xf1,0x88,0x96,0x43,0x2f,0x83,
    0x1f,0x43,0x19,0xb4,0x94,0x43,0x19,0xf0,0x1e,0x43,0x6f,0x05,0x94,0x43,0x09,0x06,0x0b,0x53,0x24,0x43,
    0xae,0xdb,0x96,0x43,0x08,0x25,0xd5,0x25,0x43,0x50,0xac,0x95,0x43,0x53,0xfb,0x26,0x43,0x8a,0x7b,0x93,
    0x43,0x76,0x43,0x26,0x43,0xb7,0x95,0x92,0x43,0x09,0x06,0x76,0x5b,0x2a,0x43,0x47,0xda,0x95,0x43,0x08,
    0xf3,0xef,0x2b,0x43,0x10,0xe2,0x94,0x43,0x6d,0x95,0x2c,0x43,0xae,0xc3,0x92,0x43,0x68,0xa6,0x2b,0x43,
    0x47,0xc2,0x91,0x43,0x09,0x06,0x36,0xc1,0x31,0x43,0x2c,0x58,0x94,0x43,0x08,0x8c,0x1e,0x33,0x43,0x31,
    0x3b,0x93,0x43,0x79,0x7a,0x33,0x43,0xff,0x25,0x91,0x43,0xd9,0x9d,0x32,0x43,0xc1,0x5b,0x90,0x43,0x09,
    0x06,0x25,0x35,0x36,0x43,0x31,0x3b,0x93,0x43,0x08,0x3f,0xb7,0x37,0x43,0xc1,0x67,0x92,0x43,0xe0,0x93,
    0x38,0x43,0xae,0xb7,0x90,0x43,0x7e,0x81,0x38,0x43,0x0d,0xdb,0x8f,0x43,0x09,0x06,0xb5,0x85,0x3b,0x43,
    0xe4,0xaf,0x91,0x43,0x08,0xcf,0x07,0x3d,0x43,0x9d,0x13,0x91,0x43,0xbc,0x63,0x3d,0x43,0x47,0xb6,0x8f,
    0x43,0xe5,0x9a,0x3d,0x43,0x74,0xd0,0x8e,0x43,0x09,0x06,0xae,0xc6,0x42,0x43,0xa4,0xd9,0x8e,0x43,0x08,
    0xca,0x48,0x44,0x43,0xfa,0x2a,0x8e,0x43,0xa2,0x11,0x44,0x43,0x9d,0xfb,0x8c,0x43,0x55,0x92,0x44,0x43,
    0x0d,0xc3,0x8b,0x43,0x09,0x06,0x39,0x10,0xc3,0x43,0x34,0x36,0x96,0x43,0x08,0x92,0x44,0xc1,0x43,0xe4,
    0xc7,0x95,0x43,0x6f,0xf0,0xbf,0x43,0x4b,0xbd,0x94,0x43,0x47,0xb9,0xbf,0x43,0x0b,0xf3,0x93,0x43,0x09,
    0x06,0x8f,0x49,0xbe,0x43,0xb7,0xad,0x96,0x43,0x08,0x11,0xb5,0xbc,0x43,0x77,0xe3,0x95,0x43,0x9c,0xf2,
    0xba,0x43,0xfa,0x4e,0x94,0x43,0xae,0x96,0xba,0x43,0x31,0x3b,0x93,0x43,0x09,0x06,0xdb,0xb0,0xb9,0x43,
    0x10,0xee,0x96,0x43,0x08,0x42,0xa6,0xb8,0x43,0xc8,0x51,0x96,0x43,0x50,0x5b,0xb7,0x43,0x19,0xb4,0x94,
    0x43,0xf7,0x1a,0xb7,0x43,0x58,0x72,0x93,0x43,0x09,0x06,0xf2,0x2b,0xb6,0x43,0x10,0xee,0x96,0x43,0x08,
    0x9d,0xce,0xb4,0x43,0x04,0x2d,0x96,0x43,0xed,0x30,0xb3,0x43,0x2c,0x58,0x94,0x43,0xce,0xcb,0xb2,0x43,
    0xd6,0xfa,0x92,0x43,0x09,0x06,0x5a,0x09,0xb1,0x43,0x19,0xc0,0x96,0x43,0x08,0x6c,0xad,0xb0,0x43,0x77,
    0xe3,0x95,0x43,0x7e,0x51,0xb0,0x43,0xc0,0x73,0x94,0x43,0xd8,0x91,0xb0,0x43,0x1e,0x97,0x93,0x43,0x09,
    0x06,0x48,0x4d,0xad,0x43,0xbe,0x7f,0x96,0x43,0x08,0x95,0xcc,0xac,0x43,0x58,0x7e,0x95,0x43,0x4d,0x30,
    0xac,0x43,0x80,0xa9,0x93,0x43,0xd8,0x79,0xac,0x43,0xd6,0xfa,0x92,0x43,0x09,0x06,0x90,0xd1,0xa9,0x43,
    0x14,0xd1,0x95,0x43,0x08,0x83,0x10,0xa9,0x43,0xb7,0xa1,0x94,0x43,0x3b,0x74,0xa8,0x43,0xf1,0x70,0x92,
    0x43,0x29,0xd0,0xa8,0x43,0x1e,0x8b,0x91,0x43,0x09,0x06,0x5a,0xcd,0xa6,0x43,0x8a,0x87,0x95,0x43,0x08,
    0x1c,0x03,0xa6,0x43,0x23,0x86,0x94,0x43,0x5f,0xb0,0xa5,0x43,0xc1,0x67,0x92,0x43,0xe1,0x27,0xa6,0x43,
    0x8a,0x6f,0x91,0x43,0x09,0x06,0xd4,0x5a,0xa3,0x43,0x2c,0x58,0x94,0x43,0x08,0x29,0xac,0xa2,0x43,0x31,
    0x3b,0x93,0x43,0x32,0x7e,0xa2,0x43,0xff,0x25,0x91,0x43,0x83,0xec,0xa2,0x43,0x8e,0x52,0x90,0x43,0x09,
    0x06,0xf8,0x96,0xa0,0x43,0x1e,0x97,0x93,0x43,0x08,0xeb,0xd5,0x9f,0x43,0x7b,0xba,0x92,0x43,0x99,0x67,
    0x9f,0x43,0x9d,0x13,0x91,0x43,0x99,0x67,0x9f,0x43,0xfa,0x36,0x90,0x43,0x09,0x06,0xeb,0xc9,0x9d,0x43,
    0xc8,0x39,0x92,0x43,0x08,0xde,0x08,0x9d,0x43,0xb2,0xa6,0x91,0x43,0xe6,0xda,0x9c,0x43,0x2c,0x40,0x90,
    0x43,0x52,0xbf,0x9c,0x43,0x5a,0x5a,0x8f,0x43,0x09,0x06,0x37,0x3d,0x9b,0x43,0x85,0x80,0x90,0x43,0x08,
    0x2a,0x7c,0x9a,0x43,0xdb,0xd1,0x8f,0x43,0xf0,0xa0,0x9a,0x43,0x7d,0xa2,0x8e,0x43,0x65,0x57,0x9a,0x43,
    0xee,0x69,0x8d,0x43,0x09,0x02,0x04,0x06,0x2a,0xf4,0x2e,0x42,0x04,0x21,0x94,0x43,0x08,0x0d,0x8a,0x31,
    0x42,0x9f,0x0e,0x94,0x43,0xf3,0x1f,0x34,0x42,0x3d,0xfc,0x93,0x43,0x63,0xff,0x36,0x42,0xa9,0xe0,0x93,
    0x43,0x08,0xb5,0x34,0x5d,0x42,0x0b,0xf3,0x93,0x43,0x6d,0xa4,0x5e,0x42,0x03,0x39,0x98,0x43,0xe7,0x31,
    0x5b,0x42,0x93,0x89,0x9d,0x43,0x08,0x02,0x9c,0x58,0x42,0xd4,0x5a,0xa3,0x43,0x38,0x70,0x53,0x42,0x14,
    0x49,0xaa,0x43,0xf8,0xed,0x5e,0x42,0x83,0x28,0xad,0x43,0x08,0xea,0x68,0x68,0x42,0x20,0x22,0xaf,0x43,
    0x12,0xb8,0x6c,0x42,0xb5,0x49,0xb1,0x43,0x2a,0x4b,0x6d,0x42,0x0d,0x96,0xb3,0x43,0x07,0x2a,0x4b,0x6d,
    0x42,0xc6,0x05,0xb5,0x43,0x08,0x87,0x6e,0x6c,0x42,0x68,0xee,0xb7,0x43,0x1c,0x66,0x66,0x42,0x31,0x0e,
    0xbb,0x43,0x57,0x11,0x5e,0x42,0x8f,0x49,0xbe,0x43,0x08,0x66,0x96,0x54,0x42,0xb9,0x5c,0xb8,0x43,0x2c,
    0x2b,0x3c,0x42,0x68,0xd6,0xb3,0x43,0x2a,0xf4,0x2e,0x42,0x6d,0xad,0xb0,0x43,0x07,0x2a,0xf4,0x2e,0x42,
    0x61,0xa4,0xa3,0x43,0x08,0x55,0x1a,0x30,0x42,0xf0,0xd0,0xa2,0x43,0xf8,0xf6,0x30,0x42,0xb2,0x06,0xa2,
    0x43,0x98,0xd3,0x31,0x42,0xd6,0x4e,0xa1,0x43,0x08,0x1c,0x6f,0x38,0x42,0x2a,0x94,0x9e,0x43,0xc1,0x22,
    0x36,0x42,0xf5,0x9b,0x9d,0x43,0x2a,0xf4,0x2e,0x42,0x6a,0x52,0x9d,0x43,0x07,0x2a,0xf4,0x2e,0x42,0x57,
    0xa2,0x9b,0x43,0x08,0xab,0x8f,0x35,0x42,0x8a,0xab,0x9b,0x43,0xe9,0x71,0x3a,0x42,0xb2,0xe2,0x9b,0x43,
    0xb7,0x74,0x3c,0x42,0x34,0x5a,0x9c,0x43,0x08,0x23,0x7d,0x42,0x42,0x0b,0x2f,0x9e,0x43,0xe5,0x9a,0x3d,
    0x42,0x38,0x6d,0xa3,0x43,0x36,0xd9,0x35,0x42,0xf3,0xd7,0xa7,0x43,0x08,0x12,0x61,0x2e,0x42,0xb0,0x42,
    0xac,0x43,0x63,0xff,0x36,0x42,0xdd,0x74,0xaf,0x43,0x1e,0xa6,0x45,0x42,0x44,0x82,0xb2,0x43,0x08,0x74,
    0x1b,0x4b,0x42,0x79,0x7a,0xb3,0x43,0x10,0x21,0x4f,0x42,0x2a,0x18,0xb5,0x43,0xdb,0x4c,0x54,0x42,0x91,
    0x19,0xb6,0x43,0x08,0xee,0x3f,0x65,0x42,0x5f,0x28,0xba,0x43,0xa7,0xaf,0x66,0x42,0xb9,0x50,0xb6,0x43,
    0x14,0x58,0x5c,0x42,0xca,0xdc,0xb1,0x43,0x08,0x2c,0x8b,0x4c,0x42,0x4e,0x30,0xac,0x43,0x19,0xcf,0x48,
    0x42,0x2a,0xd0,0xa8,0x43,0xbc,0xab,0x49,0x42,0xa9,0x4c,0xa6,0x43,0x08,0x61,0x5f,0x47,0x42,0xfa,0xa2,
    0xa2,0x43,0xa7,0xaf,0x66,0x42,0x85,0x98,0x94,0x43,0x2a,0xf4,0x2e,0x42,0xc3,0x62,0x95,0x43,0x07,0x2a,
    0xf4,0x2e,0x42,0x04,0x21,0x94,0x43,0x09,0x06,0xd0,0xfe,0xea,0x41,0x9f,0x0e,0x94,0x43,0x08,0xdc,0xe3,
    0xf1,0x41,0xe9,0x9e,0x92,0x43,0xd2,0xe7,0x0b,0x42,0xd6,0x06,0x95,0x43,0x2a,0xf4,0x2e,0x42,0x04,0x21,
    0x94,0x43,0x07,0x2a,0xf4,0x2e,0x42,0xc3,0x62,0x95,0x43,0x08,0x87,0x17,0x2e,0x42,0xc3,0x62,0x95,0x43,
    0xe7,0x3a,0x2d,0x42,0xf5,0x6b,0x95,0x43,0x44,0x5e,0x2c,0x42,0xf5,0x6b,0x95,0x43,0x08,0xd1,0x47,0x1c,
    0x42,0x19,0xc0,0x96,0x43,0x66,0xdf,0x05,0x42,0x38,0x19,0x95,0x43,0x12,0x6a,0x00,0x42,0xb2,0xbe,0x95,
    0x43,0x08,0xbb,0x6b,0xea,0x41,0xd6,0x12,0x97,0x43,0x2d,0x82,0xfa,0x41,0x61,0x74,0x9b,0x43,0x7e,0x72,
    0x06,0x42,0x8a,0xab,0x9b,0x43,0x08,0xc8,0x39,0x12,0x42,0x4e,0xd0,0x9b,0x43,0x53,0xe3,0x22,0x42,0xc3,
    0x86,0x9b,0x43,0x2a,0xf4,0x2e,0x42,0x57,0xa2,0x9b,0x43,0x07,0x2a,0xf4,0x2e,0x42,0x6a,0x52,0x9d,0x43,
    0x08,0x01,0xa5,0x2a,0x42,0xa4,0x2d,0x9d,0x43,0x96,0x9c,0x24,0x42,0x06,0x40,0x9d,0x43,0x8a,0xb7,0x1d,
    0x42,0x9a,0x5b,0x9d,0x43,0x08,0x6b,0x16,0x13,0x42,0xcd,0x64,0x9d,0x43,0x42,0xc7,0x0e,0x42,0x9a,0x5b,
    0x9d,0x43,0x23,0x26,0x04,0x42,0xcd,0x64,0x9d,0x43,0x08,0xe6,0x91,0xeb,0x41,0x38,0x49,0x9d,0x43,0x73,
    0x7b,0xdb,0x41,0xf5,0x83,0x99,0x43,0x7f,0x60,0xe2,0x41,0x0b,0x0b,0x98,0x43,0x08,0x7f,0x60,0xe2,0x41,
    0xec,0x99,0x95,0x43,0xe3,0x5a,0xde,0x41,0xbe,0x7f,0x96,0x43,0xd0,0xfe,0xea,0x41,0x9f,0x0e,0x94,0x43,
    0x07,0xd0,0xfe,0xea,0x41,0x9f,0x0e,0x94,0x43,0x09,0x06,0x2a,0xf4,0x2e,0x42,0x6d,0xad,0xb0,0x43,0x08,
    0xd4,0x7e,0x29,0x42,0xab,0x6b,0xaf,0x43,0x4e,0x0c,0x26,0x42,0x44,0x6a,0xae,0x43,0x38,0x79,0x25,0x42,
    0xd4,0x96,0xad,0x43,0x08,0x25,0xbd,0x21,0x42,0xe2,0x4b,0xac,0x43,0x49,0x35,0x29,0x42,0x9a,0x97,0xa7,
    0x43,0x2a,0xf4,0x2e,0x42,0x61,0xa4,0xa3,0x43,0x07,0x2a,0xf4,0x2e,0x42,0x6d,0xad,0xb0,0x43,0x09,0x06,
    0x1d,0xe5,0x7f,0x43,0x87,0x4a,0xe6,0x43,0x08,0x86,0x20,0x80,0x43,0x57,0x41,0xe6,0x43,0x7d,0x4e,0x80,
    0x43,0x25,0x38,0xe6,0x43,0xa5,0x85,0x80,0x43,0xf3,0x2e,0xe6,0x43,0x08,0x35,0xca,0x83,0x43,0xd4,0xc9,
    0xe5,0x43,0x9c,0xd7,0x86,0x43,0x44,0x91,0xe4,0x43,0xd5,0xca,0x8a,0x43,0x91,0x1c,0xe6,0x43,0x08,0x53,
    0x5f,0x8c,0x43,0xf8,0x1d,0xe7,0x43,0x2f,0x17,0x8d,0x43,0x4e,0x7b,0xe8,0x43,0x92,0x29,0x8d,0x43,0x2f,
    0x22,0xea,0x43,0x07,0x92,0x29,0x8d,0x43,0x44,0xb5,0xea,0x43,0x08,0xfe,0x0d,0x8d,0x43,0x2a,0x4b,0xed,
    0x43,0xe3,0x8b,0x8b,0x43,0x55,0x7d,0xf0,0x43,0xec,0x51,0x89,0x43,0x72,0x0b,0xf4,0x43,0x08,0xcd,0xd4,
    0x84,0x43,0x9d,0x55,0xfb,0x43,0xc9,0xe5,0x83,0x43,0x74,0x1e,0xfb,0x43,0x73,0x94,0x84,0x43,0x5a,0x90,
    0xf7,0x43,0x08,0xe8,0x62,0x88,0x43,0xfd,0x30,0xee,0x43,0x39,0xc5,0x86,0x43,0xdd,0xbf,0xeb,0x43,0x35,
    0xbe,0x81,0x43,0x40,0xde,0xed,0x43,0x08,0x4f,0x34,0x81,0x43,0x36,0x0c,0xee,0x43,0x08,0x98,0x80,0x43,
    0xfd,0x30,0xee,0x43,0x1d,0xe5,0x7f,0x43,0x91,0x4c,0xee,0x43,0x07,0x1d,0xe5,0x7f,0x43,0x91,0x40,0xec,
    0x43,0x08,0x35,0xbe,0x81,0x43,0x06,0xf7,0xeb,0x43,0x15,0x65,0x83,0x43,0x49,0xa4,0xeb,0x43,0x1e,0x43,
    0x85,0x43,0xbe,0x5a,0xeb,0x43,0x08,0xae,0x93,0x8a,0x43,0xfd,0x18,0xea,0x43,0x42,0x97,0x86,0x43,0x5f,
    0x67,0xf4,0x43,0xa9,0x98,0x87,0x43,0xd4,0x1d,0xf4,0x43,0x08,0x5c,0x25,0x8a,0x43,0xcf,0x16,0xef,0x43,
    0x46,0xaa,0x8d,0x43,0x5a,0x3c,0xe9,0x43,0x19,0x6c,0x88,0x43,0x53,0x5e,0xe7,0x43,0x08,0xc4,0x02,0x85,
    0x43,0x96,0x0b,0xe7,0x43,0x85,0x2c,0x82,0x43,0x83,0x67,0xe7,0x43,0x1d,0xe5,0x7f,0x43,0x72,0xc3,0xe7,
    0x43,0x07,0x1d,0xe5,0x7f,0x43,0x87,0x4a,0xe6,0x43,0x09,0x06,0xfd,0x24,0x6c,0x43,0xd9,0x94,0xe0,0x43,
    0x08,0xfa,0x6c,0x78,0x43,0xd1,0xc2,0xe0,0x43,0x25,0x5c,0x6c,0x43,0x25,0x44,0xe8,0x43,0x1d,0xe5,0x7f,
    0x43,0x87,0x4a,0xe6,0x43,0x07,0x1d,0xe5,0x7f,0x43,0x72,0xc3,0xe7,0x43,0x08,0xa6,0x27,0x7b,0x43,0x91,
    0x28,0xe8,0x43,0xbc,0xa2,0x77,0x43,0xb0,0x8d,0xe8,0x43,0xc6,0x68,0x75,0x43,0x57,0x4d,0xe8,0x43,0x08,
    0xe0,0xd2,0x72,0x43,0xab,0x9e,0xe7,0x43,0x50,0x9a,0x71,0x43,0x2a,0x27,0xe7,0x43,0xea,0x98,0x70,0x43,
    0x57,0x35,0xe4,0x43,0x08,0x94,0x3b,0x6f,0x43,0x14,0x7c,0xe2,0x43,0xff,0x13,0x6d,0x43,0x06,0xbb,0xe1,
    0x43,0xcf,0xfe,0x6a,0x43,0x06,0xbb,0xe1,0x43,0x08,0x44,0x9d,0x66,0x43,0x77,0x8e,0xe2,0x43,0x3b,0xef,
    0x6c,0x43,0x91,0x10,0xe4,0x43,0xfd,0x24,0x6c,0x43,0xb0,0x81,0xe6,0x43,0x08,0x96,0x23,0x6b,0x43,0xee,
    0x57,0xe9,0x43,0xca,0x0f,0x6a,0x43,0x5f,0x37,0xec,0x43,0x55,0x71,0x6e,0x43,0x9f,0x01,0xed,0x43,0x08,
    0xdb,0xfb,0x75,0x43,0x3b,0xef,0xec,0x43,0x09,0x3a,0x7b,0x43,0xb0,0xa5,0xec,0x43,0x1d,0xe5,0x7f,0x43,
    0x91,0x40,0xec,0x43,0x07,0x1d,0xe5,0x7f,0x43,0x91,0x4c,0xee,0x43,0x08,0xa9,0x16,0x7c,0x43,0xb0,0xb1,
    0xee,0x43,0x47,0xec,0x77,0x43,0xd9,0xe8,0xee,0x43,0x1e,0x9d,0x73,0x43,0xcf,0x16,0xef,0x43,0x08,0x0e,
    0xc9,0x6b,0x43,0xee,0x7b,0xef,0x43,0x7e,0x90,0x6a,0x43,0xfd,0x30,0xee,0x43,0x01,0xfc,0x68,0x43,0x4e,
    0x93,0xec,0x43,0x08,0x31,0xf9,0x66,0x43,0x4e,0x87,0xea,0x43,0x31,0x11,0x6b,0x43,0xd4,0xd5,0xe7,0x43,
    0xd9,0xc4,0x68,0x43,0xd4,0xc9,0xe5,0x43,0x08,0xe5,0x79,0x67,0x43,0x77,0x9a,0xe4,0x43,0x44,0x9d,0x66,
    0x43,0xab,0x86,0xe3,0x43,0x7e,0x78,0x66,0x43,0x0b,0xaa,0xe2,0x43,0x07,0x7e,0x78,0x66,0x43,0x57,0x29,
    0xe2,0x43,0x08,0xa7,0xaf,0x66,0x43,0xbe,0x1e,0xe1,0x43,0x87,0x56,0x68,0x43,0x77,0x82,0xe0,0x43,0xfd,
    0x24,0x6c,0x43,0xd9,0x94,0xe0,0x43,0x09,0x06,0xc4,0x41,0xbf,0x43,0x85,0xc0,0x72,0x42,0x08,0x73,0xdf,
    0xc0,0x43,0xf4,0x76,0x72,0x42,0x97,0x33,0xc2,0x43,0x85,0xc0,0x72,0x42,0xb2,0xb5,0xc3,0x43,0x64,0x56,
    0x75,0x42,0x08,0x03,0x24,0xc4,0x43,0x5e,0x7f,0x78,0x42,0xfa,0x51,0xc4,0x43,0x01,0x85,0x7c,0x42,0x5c,
    0x64,0xc4,0x43,0xa0,0xb3,0x80,0x42,0x07,0x5c,0x64,0xc4,0x43,0x10,0x93,0x83,0x42,0x08,0xc8,0x48,0xc4,
    0x43,0x1c,0x78,0x8a,0x42,0x27,0x6c,0xc3,0x43,0xaf,0xcf,0x94,0x42,0x23,0x7d,0xc2,0x43,0x99,0x9c,0xa4,
    0x42,0x08,0x3d,0xe7,0xbf,0x43,0xfb,0xfd,0xb5,0x42,0xb3,0x9d,0xbf,0x43,0x88,0x17,0xae,0x42,0xc4,0x41,
    0xbf,0x43,0x69,0x76,0xa3,0x42,0x07,0xc4,0x41,0xbf,0x43,0xac,0xc8,0x8f,0x42,0x08,0x4f,0x8b,0xbf,0x43,
    0xed,0x81,0x91,0x42,0xe4,0xa6,0xbf,0x43,0x5d,0x61,0x94,0x42,0xfa,0x39,0xc0,0x43,0x3b,0x49,0x9d,0x42,
    0x08,0x2b,0x43,0xc0,0x43,0x28,0xed,0xa9,0x42,0x61,0x3b,0xc1,0x43,0x00,0x9e,0xa5,0x42,0xe4,0xb2,0xc1,
    0x43,0x5d,0x91,0x9c,0x42,0x08,0x78,0xce,0xc1,0x43,0xfd,0x36,0x90,0x42,0x22,0x89,0xc4,0x43,0x81,0x72,
    0x86,0x42,0xae,0xc6,0xc2,0x43,0xa0,0xb3,0x80,0x42,0x08,0x54,0x86,0xc2,0x43,0x58,0xd1,0x7e,0x42,0x30,
    0x32,0xc1,0x43,0xce,0x5e,0x7b,0x42,0xc4,0x41,0xbf,0x43,0xe8,0xf1,0x7b,0x42,0x07,0xc4,0x41,0xbf,0x43,
    0x85,0xc0,0x72,0x42,0x09,0x06,0xf6,0x32,0xbb,0x43,0x40,0xa7,0x60,0x42,0x08,0x35,0xfd,0xbb,0x43,0xa4,
    0xa1,0x5c,0x42,0x5e,0x34,0xbc,0x43,0x9d,0x2a,0x70,0x42,0x5e,0x40,0xbe,0x43,0x0e,0x0a,0x73,0x42,0x08,
    0x4c,0x9c,0xbe,0x43,0x0e,0x0a,0x73,0x42,0x08,0xef,0xbe,0x43,0x0e,0x0a,0x73,0x42,0xc4,0x41,0xbf,0x43,
    0x85,0xc0,0x72,0x42,0x07,0xc4,0x41,0xbf,0x43,0xe8,0xf1,0x7b,0x42,0x08,0xcd,0x13,0xbf,0x43,0xe8,0xf1,
    0x7b,0x42,0xd6,0xe5,0xbe,0x43,0x71,0x3b,0x7c,0x42,0xdf,0xb7,0xbe,0x43,0x71,0x3b,0x7c,0x42,0x08,0x08,
    0xe3,0xbc,0x43,0xa4,0x61,0x7d,0x42,0x28,0x3c,0xbb,0x43,0x91,0x45,0x69,0x42,0x28,0x3c,0xbb,0x43,0x58,
    0x71,0x6e,0x42,0x08,0xce,0xfb,0xba,0x43,0xd5,0x35,0x78,0x42,0x59,0x45,0xbb,0x43,0x58,0x23,0x82,0x42,
    0xa1,0xe1,0xbb,0x43,0xd7,0xbe,0x88,0x42,0x08,0xc9,0x18,0xbc,0x43,0xaf,0x9f,0x8c,0x42,0x1e,0x76,0xbd,
    0x43,0x51,0x7c,0x8d,0x42,0xd6,0xe5,0xbe,0x43,0xf4,0x58,0x8e,0x42,0x08,0x9c,0x0a,0xbf,0x43,0x45,0xc7,
    0x8e,0x42,0x30,0x26,0xbf,0x43,0x96,0x35,0x8f,0x42,0xc4,0x41,0xbf,0x43,0xac,0xc8,0x8f,0x42,0x07,0xc4,
    0x41,0xbf,0x43,0x69,0x76,0xa3,0x42,0x08,0x08,0xef,0xbe,0x43,0xb1,0xd6,0x99,0x42,0xe8,0x89,0xbe,0x43,
    0xde,0xc5,0x8d,0x42,0xc0,0x46,0xbc,0x43,0xc2,0x5b,0x90,0x42,0x08,0x9c,0xf2,0xba,0x43,0x86,0x80,0x90,
    0x42,0xf2,0x43,0xba,0x43,0xe8,0x73,0x87,0x42,0x8f,0x31,0xba,0x43,0xb6,0xf4,0x7d,0x42,0x07,0x8f,0x31,
    0xba,0x43,0x21,0xc6,0x76,0x42,0x08,0xc0,0x3a,0xba,0x43,0x5f,0x48,0x6b,0x42,0xae,0x96,0xba,0x43,0xe3,
    0x83,0x61,0x42,0xf6,0x32,0xbb,0x43,0x40,0xa7,0x60,0x42,0x09,0x06,0xea,0x74,0xea,0x43,0x61,0x44,0x93,
    0x43,0x08,0x24,0x5c,0xec,0x43,0x31,0x3b,0x93,0x43,0xfb,0x30,0xee,0x43,0x93,0x4d,0x93,0x43,0x0d,0xe1,
    0xef,0x43,0x80,0xa9,0x93,0x43,0x08,0x8f,0x58,0xf0,0x43,0xd1,0x17,0x94,0x43,0xb7,0x8f,0xf0,0x43,0x10,
    0xe2,0x94,0x43,0xea,0x98,0xf0,0x43,0xa9,0xec,0x95,0x43,0x07,0xea,0x98,0xf0,0x43,0x38,0x25,0x97,0x43,
    0x08,0x23,0x74,0xf0,0x43,0x9f,0x32,0x9a,0x43,0x5a,0x60,0xef,0x43,0x53,0xcb,0x9e,0x43,0x2d,0x3a,0xee,
    0x43,0xfd,0x91,0xa3,0x43,0x08,0xa2,0xf0,0xed,0x43,0xdd,0x38,0xa5,0x43,0x17,0xa7,0xed,0x43,0xbe,0xdf,
    0xa6,0x43,0x5a,0x54,0xed,0x43,0x9f,0x86,0xa8,0x43,0x08,0xfc,0x24,0xec,0x43,0xca,0xc4,0xad,0x43,0x48,
    0xa4,0xeb,0x43,0x40,0x6f,0xab,0x43,0x28,0x3f,0xeb,0x43,0x1c,0x0f,0xa8,0x43,0x08,0x1f,0x6d,0xeb,0x43,
    0x72,0x48,0xa3,0x43,0x67,0x09,0xec,0x43,0xd1,0x53,0x9e,0x43,0xea,0x74,0xea,0x43,0x1e,0xc7,0x9b,0x43,
    0x07,0xea,0x74,0xea,0x43,0x8a,0x9f,0x99,0x43,0x08,0x7e,0x90,0xea,0x43,0x8a,0x9f,0x99,0x43,0x12,0xac,
    0xea,0x43,0xbc,0xa8,0x99,0x43,0xa7,0xc7,0xea,0x43,0xbc,0xa8,0x99,0x43,0x08,0x51,0x76,0xeb,0x43,0x9f,
    0x32,0x9a,0x43,0x5e,0x37,0xec,0x43,0x49,0xed,0x9c,0x43,0xb0,0xa5,0xec,0x43,0x2a,0xa0,0xa0,0x43,0x08,
    0x09,0xe6,0xec,0x43,0xd1,0x77,0xa4,0x43,0x28,0x4b,0xed,0x43,0x61,0xa4,0xa3,0x43,0xab,0xc2,0xed,0x43,
    0x8e,0xb2,0xa0,0x43,0x08,0x70,0xe7,0xed,0x43,0xde,0x08,0x9d,0x43,0x87,0x86,0xf0,0x43,0x2f,0x53,0x97,
    0x43,0x87,0x7a,0xee,0x43,0xec,0x99,0x95,0x43,0x08,0xca,0x27,0xee,0x43,0xff,0x3d,0x95,0x43,0x74,0xca,
    0xec,0x43,0x55,0x8f,0x94,0x43,0xea,0x74,0xea,0x43,0xe7,0xaa,0x94,0x43,0x07,0xea,0x74,0xea,0x43,0x61,
    0x44,0x93,0x43,0x09,0x06,0x05,0xd3,0xe5,0x43,0x19,0x9c,0x90,0x43,0x08,0x09,0xc2,0xe6,0x43,0xd1,0xff,
    0x8f,0x43,0x4d,0x6f,0xe6,0x43,0x74,0xe8,0x92,0x43,0x3b,0xd7,0xe8,0x43,0xc3,0x56,0x93,0x43,0x08,0x1f,
    0x61,0xe9,0x43,0x93,0x4d,0x93,0x43,0x05,0xeb,0xe9,0x43,0x93,0x4d,0x93,0x43,0xea,0x74,0xea,0x43,0x61,
    0x44,0x93,0x43,0x07,0xea,0x74,0xea,0x43,0xe7,0xaa,0x94,0x43,0x08,0x24,0x50,0xea,0x43,0xe7,0xaa,0x94,
    0x43,0x2d,0x22,0xea,0x43,0xe7,0xaa,0x94,0x43,0x36,0xf4,0xe9,0x43,0xe7,0xaa,0x94,0x43,0x08,0xa2,0xcc,
    0xe7,0x43,0xe0,0xd8,0x94,0x43,0xd4,0xc9,0xe5,0x43,0x19,0xa8,0x92,0x43,0xd4,0xc9,0xe5,0x43,0x27,0x69,
    0x93,0x43,0x08,0x17,0x77,0xe5,0x43,0xe0,0xd8,0x94,0x43,0x67,0xe5,0xe5,0x43,0x47,0xda,0x95,0x43,0x43,
    0x9d,0xe6,0x43,0xe2,0xd3,0x97,0x43,0x08,0x9d,0xdd,0xe6,0x43,0xad,0xe7,0x98,0x43,0x09,0xce,0xe8,0x43,
    0xff,0x55,0x99,0x43,0xea,0x74,0xea,0x43,0x8a,0x9f,0x99,0x43,0x07,0xea,0x74,0xea,0x43,0x1e,0xc7,0x9b,
    0x43,0x08,0x71,0xcf,0xe9,0x43,0x53,0xb3,0x9a,0x43,0xa7,0xbb,0xe8,0x43,0xdb,0x0d,0x9a,0x43,0xc6,0x14,
    0xe7,0x43,0xdb,0x0d,0x9a,0x43,0x08,0x48,0x80,0xe5,0x43,0xdb,0x0d,0x9a,0x43,0x0a,0xb6,0xe4,0x43,0xc3,
    0x6e,0x97,0x43,0x76,0x9a,0xe4,0x43,0x74,0xf4,0x94,0x43,0x07,0x76,0x9a,0xe4,0x43,0x79,0xd7,0x93,0x43,
    0x08,0xd8,0xac,0xe4,0x43,0x66,0x27,0x92,0x43,0x29,0x1b,0xe5,0x43,0xe0,0xc0,0x90,0x43,0x05,0xd3,0xe5,
    0x43,0x19,0x9c,0x90,0x43,0x09,0x06,0x1b,0x66,0xe6,0x42,0xe3,0xa3,0x8f,0x42,0x08,0x71,0x0b,0xf4,0x42,
    0x00,0x0e,0x8d,0x42,0x8c,0x0f,0x01,0x43,0x3e,0xc0,0x89,0x42,0xf3,0x28,0x06,0x43,0x48,0x9e,0x8b,0x42,
    0x08,0x15,0x89,0x09,0x43,0x00,0x0e,0x8d,0x42,0xe0,0x9c,0x0a,0x43,0xc1,0x8b,0x98,0x42,0xa6,0xc1,0x0a,
    0x43,0x02,0xa5,0xaa,0x42,0x07,0xa6,0xc1,0x0a,0x43,0xf9,0xf6,0xb0,0x42,0x08,0xa6,0xc1,0x0a,0x43,0x47,
    0x8e,0xb4,0x42,0x42,0xaf,0x0a,0x43,0x1f,0x6f,0xb8,0x42,0xe0,0x9c,0x0a,0x43,0xba,0x74,0xbc,0x42,0x08,
    0xa1,0xd2,0x09,0x43,0x40,0x47,0xd0,0x42,0x0d,0xab,0x07,0x43,0x91,0xb5,0xd0,0x42,0x3b,0xb9,0x04,0x43,
    0xec,0x71,0xba,0x42,0x08,0xe5,0x5b,0x03,0x43,0xe3,0x33,0xa8,0x42,0x63,0xd8,0x00,0x43,0xce,0x70,0x9f,
    0x42,0x1b,0x66,0xe6,0x42,0xae,0x2f,0xa5,0x42,0x07,0x1b,0x66,0xe6,0x42,0xa2,0x4a,0x9e,0x42,0x08,0xed,
    0x6f,0xed,0x42,0x73,0x24,0x9d,0x42,0xd8,0x0c,0xf5,0x42,0x99,0x6c,0x9c,0x42,0x27,0xab,0xfd,0x42,0xea,
    0xda,0x9c,0x42,0x08,0x36,0xca,0x03,0x43,0x2b,0x94,0x9e,0x42,0x68,0xc7,0x01,0x43,0x8f,0xbe,0xa2,0x42,
    0xfa,0x06,0x08,0x43,0x73,0xb4,0xb5,0x42,0x08,0x8e,0x2e,0x0a,0x43,0x1f,0x6f,0xb8,0x42,0x9d,0xe3,0x08,
    0x43,0xd7,0x1e,0x99,0x42,0x28,0x15,0x05,0x43,0x32,0x3b,0x93,0x42,0x08,0x63,0xf0,0x04,0x43,0x70,0xed,
    0x8f,0x42,0x71,0x0b,0xf4,0x42,0x32,0x3b,0x93,0x42,0x1b,0x66,0xe6,0x42,0x73,0xf4,0x94,0x42,0x07,0x1b,
    0x66,0xe6,0x42,0xe3,0xa3,0x8f,0x42,0x09,0x06,0x5e,0x28,0xba,0x42,0x35,0xe2,0x87,0x42,0x08,0x8e,0x55,
    0xc0,0x42,0xb8,0x4d,0x86,0x42,0x60,0xbf,0xd7,0x42,0x3e,0xf0,0x91,0x42,0x63,0xf6,0xe4,0x42,0x70,0xed,
    0x8f,0x42,0x08,0x7a,0x89,0xe5,0x42,0xac,0xc8,0x8f,0x42,0xcc,0xf7,0xe5,0x42,0xac,0xc8,0x8f,0x42,0x1b,
    0x66,0xe6,0x42,0xe3,0xa3,0x8f,0x42,0x07,0x1b,0x66,0xe6,0x42,0x73,0xf4,0x94,0x42,0x08,0x63,0xf6,0xe4,
    0x42,0x3b,0x19,0x95,0x42,0xe6,0x61,0xe3,0x42,0x00,0x3e,0x95,0x42,0xf4,0x16,0xe2,0x42,0xc4,0x62,0x95,
    0x42,0x08,0x6e,0x74,0xd6,0x42,0x15,0xd1,0x95,0x42,0x97,0x63,0xca,0x42,0xaf,0xcf,0x94,0x42,0xfb,0x2d,
    0xbe,0x42,0x86,0x80,0x90,0x42,0x08,0x97,0x03,0xba,0x42,0xce,0x10,0x8f,0x42,0x5e,0x28,0xba,0x42,0x3e,
    0xf0,0x91,0x42,0xf2,0x4f,0xbc,0x42,0x45,0xf7,0x96,0x42,0x08,0x27,0x54,0xbf,0x42,0x73,0x24,0x9d,0x42,
    0xa5,0xe8,0xc0,0x42,0x86,0xe0,0xa0,0x42,0xe4,0xca,0xc5,0x42,0xed,0x11,0xaa,0x42,0x08,0x54,0xaa,0xc8,
    0x42,0x86,0x40,0xb1,0x42,0x59,0x81,0xc5,0x42,0xa1,0x11,0xc4,0x42,0x3e,0xe7,0xbf,0x42,0xfb,0x8d,0xce,
    0x42,0x08,0xb4,0x6d,0xb7,0x42,0x30,0xc2,0xd9,0x42,0x46,0xf5,0xc9,0x42,0xdf,0x53,0xd9,0x42,0x38,0x40,
    0xcb,0x42,0x62,0x8f,0xcf,0x42,0x08,0x7d,0xf9,0xcc,0x42,0xec,0xa1,0xc2,0x42,0x07,0x43,0xcd,0x42,0x6c,
    0xdd,0xb8,0x42,0x2b,0x8b,0xcc,0x42,0x92,0xf5,0xaf,0x42,0x08,0xf9,0x8d,0xce,0x42,0x41,0x57,0xa7,0x42,
    0x5b,0xb8,0xd2,0x42,0xae,0x2f,0xa5,0x42,0x18,0x2f,0xd9,0x42,0x13,0x2a,0xa1,0x42,0x08,0x41,0x7e,0xdd,
    0x42,0xe3,0x03,0xa0,0x42,0x2e,0xf2,0xe1,0x42,0x7c,0x02,0x9f,0x42,0x1b,0x66,0xe6,0x42,0xa2,0x4a,0x9e,
    0x42,0x07,0x1b,0x66,0xe6,0x42,0xae,0x2f,0xa5,0x42,0x08,0x4d,0x63,0xe4,0x42,0x00,0x9e,0xa5,0x42,0xf4,
    0x16,0xe2,0x42,0x15,0x31,0xa6,0x42,0x99,0xca,0xdf,0x42,0x2b,0xc4,0xa6,0x42,0x08,0xc0,0x82,0xc6,0x42,
    0xc4,0xc2,0xa5,0x42,0x57,0xe1,0xd5,0x42,0x91,0xb5,0xd0,0x42,0x54,0xda,0xd0,0x42,0x97,0x93,0xd2,0x42,
    0x08,0x9c,0x3a,0xc7,0x42,0x17,0x58,0xdc,0x42,0x9c,0x0a,0xbf,0x42,0x6e,0xa4,0xde,0x42,0x90,0x25,0xb8,
    0x42,0xdf,0x53,0xd9,0x42,0x08,0x59,0x21,0xb5,0x42,0xf2,0xdf,0xd4,0x42,0x51,0x43,0xb3,0x42,0x91,0xb5,
    0xd0,0x42,0xc5,0x29,0xbb,0x42,0x0e,0x1a,0xca,0x42,0x08,0x65,0x36,0xc4,0x42,0xd0,0x07,0xbd,0x42,0x3e,
    0xe7,0xbf,0x42,0x37,0x09,0xbe,0x42,0x0c,0xea,0xc1,0x42,0xcd,0xd0,0xaf,0x42,0x08,0x2b,0x5b,0xc4,0x42,
    0x18,0x08,0xa3,0x42,0x67,0xa6,0xab,0x42,0x99,0x3c,0x94,0x42,0x5e,0x28,0xba,0x42,0x35,0xe2,0x87,0x42,
    0x09,];
}