erga: agg cosmetix

[iv.d.git] / egra / gfx / aggmini.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;
private:
nothrow @safe @nogc:

private enum DisableCopyingMixin = "@disable this (this); void opAssign() (in auto ref typeof(this)) { static assert(0, `assigning disabled`); }";

import iv.egra.gfx.base;
import iv.egra.gfx.lowlevel;

/* Bezier curve rasterizer.
 *
 * De Casteljau Bezier rasterizer is faster, but currently rasterizing curves with cusps sligtly wrong.
 * It doesn't really matter in practice.
 *
 * AFD tesselator is somewhat slower, but does cusps better.
 *
 * McSeem rasterizer should have the best quality, bit it is the slowest method. Basically, you will
 * never notice any visial difference (and this code is not really debugged), so you probably should
 * not use it. It is there for further experiments.
 */
public enum AGGTesselation {
  DeCasteljau, /// default: standard well-known tesselation algorithm
  AFD, /// adaptive forward differencing
  DeCasteljauMcSeem, /// standard well-known tesselation algorithm, with improvements from Maxim Shemanarev; slowest one, but should give best results
}


// ////////////////////////////////////////////////////////////////////////// //
// a pixel cell
align(1) struct Cell {
align(1):
public:
  static uint packCoord (in int x, in int y) pure nothrow @safe @nogc { pragma(inline, true); return (y<<16)|(x&0xffff); }

public:
  uint packedCoord;
  int cover;
  int area;

public nothrow @trusted @nogc:
  this (in int cx, in int cy, in int c, in int a) pure { pragma(inline, true); packedCoord = packCoord(cx, cy); cover = c; area = a; }

  @property int x () const pure { pragma(inline, true); return cast(short)(packedCoord&0xffff); }
  @property int y () const pure { pragma(inline, true); return cast(short)(packedCoord>>16); }

  void setCover (in int c, in int a) { pragma(inline, true); cover = c; area = a; }
  void addCover (in int c, in int a) { pragma(inline, true); cover += c; area += a; }

  void setCoord (in int cx, in int cy) { pragma(inline, true); packedCoord = packCoord(cx, cy); }

  void set (in int cx, in int cy, in int c, in int a) { pragma(inline, true); packedCoord = packCoord(cx, cy); cover = c; area = a; }
}


// ////////////////////////////////////////////////////////////////////////// //
/* An internal class that implements the main rasterization algorithm.
  Used in the rasterizer. Should not be used direcly.
*/
struct Outline {
private nothrow @trusted @nogc:
  enum : uint {
    CellBlockShift = 12U,
    CellBlockSize = cast(uint)(1<<CellBlockShift),
    CellBlockMask = cast(uint)(CellBlockSize-1),
    CellBlockPool = 256U,
    CellBlockLimit = 1024U,
  }

  enum QSortThreshold = 9;

  enum : uint {
    NotClosed = 1U,
    SortRequired = 2U,
  }

private:
  uint mNumBlocks;
  uint mMaxBlocks;
  uint mCurBlock;
  uint mNumCells;
  Cell** mCells;
  Cell* mCurCellPtr;
  Cell** mSortedCells;
  uint mSortedSize;
  Cell mCurCell = Cell(0x7fff, 0x7fff, 0, 0);
  int mCurX;
  int mCurY;
  int mCloseX;
  int mCloseY;
  int mMinX = 0x7fffffff;
  int mMinY = 0x7fffffff;
  int mMaxX = -0x7fffffff;
  int mMaxY = -0x7fffffff;
  uint mFlags = SortRequired;

private:
  void allocateBlock () {
    import core.stdc.stdlib : realloc;
    if (mCurBlock >= mNumBlocks) {
      import core.stdc.string : memset;
      if (mNumBlocks >= mMaxBlocks) {
        Cell** newCells = cast(Cell**)realloc(mCells, (mMaxBlocks+CellBlockPool)*(Cell*).sizeof);
        if (newCells is null) assert(0, "out of memory");
        mCells = newCells;
        mMaxBlocks += CellBlockPool;
      }
      auto cc = cast(Cell*)realloc(null, Cell.sizeof*CellBlockSize);
      if (cc is null) assert(0, "out of memory");
      memset(cc, 0, Cell.sizeof*CellBlockSize);
      //foreach (ref c; cc[0..CellBlockSize]) c = Cell.init;
      mCells[mNumBlocks++] = cc;
    }
    mCurCellPtr = mCells[mCurBlock++];
  }

public:
  mixin(DisableCopyingMixin);

  ~this () {
    import core.stdc.stdlib : free;
    free(mSortedCells);
    if (mNumBlocks) {
      Cell** ptr = mCells+mNumBlocks-1;
      while (mNumBlocks--) {
        free(*ptr);
        --ptr;
      }
      free(mCells);
    }
  }

  void reset () {
    mNumCells = 0;
    mCurBlock = 0;
    mCurCell.set(0x7fff, 0x7fff, 0, 0);
    mFlags |= SortRequired;
    mFlags &= ~NotClosed;
    mMinX = 0x7fffffff;
    mMinY = 0x7fffffff;
    mMaxX = -0x7fffffff;
    mMaxY = -0x7fffffff;
  }

  void moveTo (in int x, in int y) {
    if ((mFlags&SortRequired) == 0) reset();
    if (mFlags&NotClosed) lineTo(mCloseX, mCloseY);
    setCurCell(x>>PolyBaseShift, y>>PolyBaseShift);
    mCloseX = mCurX = x;
    mCloseY = mCurY = y;
  }

  void lineTo (in int x, in int y) {
    if ((mFlags&SortRequired) && ((mCurX^x)|(mCurY^y))) {
      int c = mCurX>>PolyBaseShift;
      if (c < mMinX) mMinX = c;
      ++c;
      if (c > mMaxX) mMaxX = c;

      c = x>>PolyBaseShift;
      if (c < mMinX) mMinX = c;
      ++c;
      if (c > mMaxX) mMaxX = c;

      renderLine(mCurX, mCurY, x, y);
      mCurX = x;
      mCurY = y;
      mFlags |= NotClosed;
    }
  }

  @property float currX () const pure { pragma(inline, true); return cast(float)mCurX/cast(float)PolyBaseSize; }
  @property float currY () const pure { pragma(inline, true); return cast(float)mCurY/cast(float)PolyBaseSize; }

  @property int minX () const pure { pragma(inline, true); return mMinX; }
  @property int minY () const pure { pragma(inline, true); return mMinY; }
  @property int maxX () const pure { pragma(inline, true); return mMaxX; }
  @property int maxY () const pure { pragma(inline, true); return mMaxY; }

  @property uint numCells () const pure { pragma(inline, true); return mNumCells; }

  const(Cell)** cells () {
    if (mFlags&NotClosed) {
      lineTo(mCloseX, mCloseY);
      mFlags &= ~NotClosed;
    }
    // perform sort only the first time
    if (mFlags&SortRequired) {
      addCurCell();
      if (mNumCells == 0) return null;
      sortCells();
      mFlags &= ~SortRequired;
    }
    return cast(const(Cell)**)mSortedCells;
  }

private:
  void addCurCell () {
    if (mCurCell.area|mCurCell.cover) {
      if ((mNumCells&CellBlockMask) == 0) {
        if (mNumBlocks >= CellBlockLimit) return;
        allocateBlock();
      }
      *mCurCellPtr++ = mCurCell;
      ++mNumCells;
    }
  }

  void setCurCell (in int x, in int y) {
    if (mCurCell.packedCoord != Cell.packCoord(x, y)) {
      addCurCell();
      mCurCell.set(x, y, 0, 0);
    }
  }

  void renderScanLine (in int ey, in int x1, int y1, in int x2, in int y2) {
    immutable int ex2 = x2>>PolyBaseShift;

    // trivial case; happens often
    if (y1 == y2) {
      setCurCell(ex2, ey);
      return;
    }

    int ex1 = x1>>PolyBaseShift;
    immutable int fx1 = x1&PolyBaseMask;
    immutable int fx2 = x2&PolyBaseMask;

    // everything is located in a single cell: that is easy!
    if (ex1 == ex2) {
      immutable int delta = y2-y1;
      mCurCell.addCover(delta, (fx1+fx2)*delta);
      return;
    }

    // ok, we'll have to render a run of adjacent cells on the same scanline...
    int p = (PolyBaseSize-fx1)*(y2-y1);
    int first = PolyBaseSize;
    int incr = 1;

    int dx = x2-x1;

    if (dx < 0) {
      p = fx1*(y2-y1);
      first = 0;
      incr = -1;
      dx = -dx;
    }

    int delta = p/dx;
    int mod = p%dx;
    if (mod < 0) { --delta; mod += dx; }

    mCurCell.addCover(delta, (fx1+first)*delta);

    ex1 += incr;
    setCurCell(ex1, ey);
    y1 += delta;

    if (ex1 != ex2) {
      p = PolyBaseSize*(y2-y1+delta);
      int lift = p/dx;
      int rem = p%dx;
      if (rem < 0) { --lift; rem += dx; }
      mod -= dx;
      while (ex1 != ex2) {
        delta = lift;
        mod += rem;
        if (mod >= 0) { mod -= dx; ++delta; }
        mCurCell.addCover(delta, PolyBaseSize*delta);
        y1 += delta;
        ex1 += incr;
        setCurCell(ex1, ey);
      }
    }

    delta = y2-y1;
    mCurCell.addCover(delta, (fx2+PolyBaseSize-first)*delta);
  }

  void renderLine (in int x1, in int y1, in int x2, in int y2) {
    int ey1 = y1>>PolyBaseShift;
    immutable int ey2 = y2>>PolyBaseShift;

    if (ey1 < mMinY) mMinY = ey1;
    if (ey1+1 > mMaxY) mMaxY = ey1+1;
    if (ey2 < mMinY) mMinY = ey2;
    if (ey2+1 > mMaxY) mMaxY = ey2+1;

    immutable int fy1 = y1&PolyBaseMask;
    immutable int fy2 = y2&PolyBaseMask;

    // everything is on a single scanline
    if (ey1 == ey2) {
      renderScanLine(ey1, x1, fy1, x2, fy2);
      return;
    }

    int dx = x2-x1;
    int dy = y2-y1;

    //int xFrom, xTo;
    //int p, rem, mod, lift, delta, first, incr;

    // vertical line: we have to calculate start and end cells,
    // and then the common values of the area and coverage for
    // all cells of the line. we know exactly there's only one
    // cell, so, we don't have to call renderScanLine().
    int incr = 1;
    if (dx == 0) {
      int ex = x1>>PolyBaseShift;
      int twoFx = (x1-(ex<<PolyBaseShift))<<1;
      int area;

      int first = PolyBaseSize;
      if (dy < 0) { first = 0; incr = -1; }

      immutable int xFrom = x1;

      //renderScanLine(ey1, xFrom, fy1, xFrom, first);
      int delta = first-fy1;
      mCurCell.addCover(delta, twoFx*delta);

      ey1 += incr;
      setCurCell(ex, ey1);

      delta = first+first-PolyBaseSize;
      area = twoFx*delta;
      while (ey1 != ey2) {
        //renderScanLine(ey1, xFrom, PolyBaseSize - first, xFrom, first);
        mCurCell.setCover(delta, area);
        ey1 += incr;
        setCurCell(ex, ey1);
      }
      //renderScanLine(ey1, xFrom, PolyBaseSize - first, xFrom, fy2);
      delta = fy2-PolyBaseSize+first;
      mCurCell.addCover(delta, twoFx*delta);
      return;
    }

    // ok, we have to render several scanlines
    int p = (PolyBaseSize-fy1)*dx;
    int first = PolyBaseSize;

    if (dy < 0) {
      p = fy1*dx;
      first = 0;
      incr = -1;
      dy = -dy;
    }

    int delta = p/dy;
    int mod = p%dy;

    if (mod < 0) { --delta; mod += dy; }

    int xFrom = x1+delta;
    renderScanLine(ey1, x1, fy1, xFrom, first);

    ey1 += incr;
    setCurCell(xFrom>>PolyBaseShift, ey1);

    if (ey1 != ey2) {
      p = PolyBaseSize*dx;
      int lift = p/dy;
      int rem = p%dy;

      if (rem < 0) { --lift; rem += dy; }
      mod -= dy;

      while (ey1 != ey2) {
        delta = lift;
        mod += rem;
        if (mod >= 0) { mod -= dy; ++delta; }

        immutable int xTo = xFrom+delta;
        renderScanLine(ey1, xFrom, PolyBaseSize-first, xTo, first);
        xFrom = xTo;

        ey1 += incr;
        setCurCell(xFrom>>PolyBaseShift, ey1);
      }
    }

    renderScanLine(ey1, xFrom, PolyBaseSize-first, x2, fy2);
  }

private:
  static void qsortCells (Cell** start, uint num) {
    static void swapCells (Cell** a, Cell** b) nothrow @trusted @nogc {
      pragma(inline, true);
      auto temp = *a;
      *a = *b;
      *b = temp;
    }

    static bool lessThan (Cell** a, Cell** b) nothrow @trusted @nogc pure { pragma(inline, true); return ((**a).packedCoord < (**b).packedCoord); }

    Cell**[80] stack = void;
    Cell*** top;
    Cell** limit;
    Cell** base;

    limit = start+num;
    base = start;
    top = stack.ptr;

    for (;;) {
      immutable int len = cast(int)(limit-base);

      if (len > QSortThreshold) {
        // we use base + len/2 as the pivot
        //auto pivot = base+len/2;
        auto pivot = base+(len>>1);
        swapCells(base, pivot);

        auto i = base+1;
        auto j = limit-1;

        // now ensure that *i <= *base <= *j
        if (lessThan(j, i)) swapCells(i, j);
        if (lessThan(base, i)) swapCells(base, i);
        if (lessThan(j, base)) swapCells(base, j);

        for (;;) {
          do { ++i; } while (lessThan(i, base));
          do { --j; } while (lessThan(base, j));
          if (i > j) break;
          swapCells(i, j);
        }

        swapCells(base, j);

        // now, push the largest sub-array
        if (j-base > limit-i) {
          top[0] = base;
          top[1] = j;
          base = i;
        } else {
          top[0] = i;
          top[1] = limit;
          limit = j;
        }
        top += 2;
      } else {
        // the sub-array is small, perform insertion sort
        auto j = base;
        auto i = j+1;
        for (; i < limit; j = i, ++i) {
          for (; lessThan(j+1, j); --j) {
            swapCells(j+1, j);
            if (j == base) break;
          }
        }
        if (top > stack.ptr) {
          top -= 2;
          base = top[0];
          limit = top[1];
        } else {
          break;
        }
      }
    }
  }

  void sortCells () {
    if (mNumCells == 0) return;

    if (mNumCells > mSortedSize) {
      import core.stdc.stdlib: realloc;
      mSortedSize = mNumCells;
      mSortedCells = cast(Cell**)realloc(mSortedCells, (mNumCells+1)*(Cell*).sizeof);
    }

    Cell** sortedPtr = mSortedCells;
    Cell** blockPtr = mCells;
    Cell* cellPtr;

    uint nb = mNumCells>>CellBlockShift;

    while (nb--) {
      cellPtr = *blockPtr++;
      uint i = CellBlockSize;
      while (i--) *sortedPtr++ = cellPtr++;
    }

    cellPtr = *blockPtr++;
    uint i = mNumCells&CellBlockMask;
    while (i--) *sortedPtr++ = cellPtr++;
    mSortedCells[mNumCells] = null;
    qsortCells(mSortedCells, mNumCells);
  }
}


// ////////////////////////////////////////////////////////////////////////// //
/*This class is used to transfer data from class outline (or a similar one)
  to the rendering buffer. It's organized very simple. The class stores
  information of horizontal spans to render it into a pixel-map buffer.
  Each span has initial X, length, and an array of bytes that determine the
  alpha-values for each pixel. So, the restriction of using this class is 256
  levels of Anti-Aliasing, which is quite enough for any practical purpose.
  Before using this class you should know the minimal and maximal pixel
  coordinates of your scanline. The protocol of using is:
  1. reset(minX, maxX)
  2. addCell() / addSpan() - accumulate scanline. You pass Y-coordinate
     into these functions in order to make scanline know the last Y. Before
     calling addCell() / addSpan() you should check with method isReady(y)
     if the last Y has changed. It also checks if the scanline is not empty.
     When forming one scanline the next X coordinate must be always greater
     than the last stored one, i.e. it works only with ordered coordinates.
  3. If the current scanline isReady() you should render it and then call
     resetSpans() before adding new cells/spans.

  4. Rendering:

  Scanline provides an iterator class that allows you to extract
  the spans and the cover values for each pixel. Be aware that clipping
  has not been done yet, so you should perform it yourself.

 -------------------------------------------------------------------------
  int baseX = sl.baseX; // base X. Should be added to the span's X
                        // "sl" is a const reference to the
                        // scanline passed in.

  int y = sl.y; // Y-coordinate of the scanline

  ************************************
  ...Perform vertical clipping here...
  ************************************

  ubyte* row = mRBuf[y]; // the the address of the beginning of the current row

  auto span = scanline.iterator;

  uint spanCount = scanline.spanCount(); // number of spans; it's guaranteed that
                                         // spanCount is always greater than 0

  do {
    int x = span.next+baseX; // the beginning X of the span

    const(ubyte)* covers = span.covers; // the array of the cover values

    int pixelCount = span.pixelCount; // number of pixels of the span;
                                      // always greater than 0, still we
                                      // shoud use "int" instead of "uint"
                                      // because it's more convenient for clipping

    **************************************
    ...Perform horizontal clipping here...
    ...you have x, covers, and pixCount..
    **************************************

    ubyte* dst = row+x; // calculate the start address of the row;
                        // in this case we assume a simple
                        // grayscale image 1-byte per pixel
    do {
      *dst++ = *covers++; // hypotetical rendering
    } while (--pixelCount);
  } while (--spanCount); // spanCount cannot be 0, so this loop is quite safe
 ------------------------------------------------------------------------

  The question is: why should we accumulate the whole scanline when we
  could render just separate spans when they're ready?
  That's because using the scaline is in general faster. When is consists
  of more than one span the conditions for the processor cash system
  are better, because switching between two different areas of memory
  (that can be large ones) occures less frequently.
*/
struct ScanLine {
private:
  int mMinX;
  uint mMaxLen;
  int mDX;
  int mDY;
  int mLastX = 0x7fff;
  int mLastY = 0x7fff;
  ubyte* mCovers;
  ubyte** mStartPtrs;
  ushort* mCounts;
  uint mNumSpans;
  ubyte** mCurStartPtr;
  ushort* mCurCount;

public:
  enum AAShift = 8;

  static struct Iterator {
  private:
    const(ubyte)* mCovers;
    const(ushort)* mCurCount;
    const(ubyte*)* mCurStartPtr;

  public nothrow @trusted @nogc:
    mixin(DisableCopyingMixin);

    this (in ref ScanLine sl) pure {
      pragma(inline, true);
      mCovers = sl.mCovers;
      mCurCount = sl.mCounts;
      mCurStartPtr = sl.mStartPtrs;
    }

    int next () {
      pragma(inline, true);
      ++mCurCount;
      ++mCurStartPtr;
      return cast(int)(*mCurStartPtr-mCovers);
    }

    @property int pixelCount () const pure { pragma(inline, true); return cast(int)(*mCurCount); }
    @property const(ubyte)* covers () const pure { pragma(inline, true); return *mCurStartPtr; }
  }

public nothrow @trusted @nogc:
  mixin(DisableCopyingMixin);

  ~this () {
    import core.stdc.stdlib : free;
    if (mCounts !is null) free(mCounts);
    if (mStartPtrs !is null) free(mStartPtrs);
    if (mCovers !is null) free(mCovers);
  }

  auto iterator () const pure { pragma(inline, true); return Iterator(this); }

  void reset (int minX, int maxX, int dx=0, int dy=0) {
    uint maxLen = maxX-minX+2;
    if (maxLen > mMaxLen) {
      import core.stdc.stdlib : realloc;
      mCovers = cast(ubyte*)realloc(mCovers, maxLen*mCovers[0].sizeof);
      if (mCovers is null) assert(0, "out of memory");
      mStartPtrs = cast(ubyte**)realloc(mStartPtrs, mStartPtrs[0].sizeof*maxLen);
      if (mStartPtrs is null) assert(0, "out of memory");
      mCounts = cast(ushort*)realloc(mCounts, mCounts[0].sizeof*maxLen);
      if (mCounts is null) assert(0, "out of memory");
      mMaxLen = maxLen;
    }
    mDX = dx;
    mDY = dy;
    mLastX = 0x7fff;
    mLastY = 0x7fff;
    mMinX = minX;
    mCurCount = mCounts;
    mCurStartPtr = mStartPtrs;
    mNumSpans = 0;
  }

  void resetSpans () {
    pragma(inline, true);
    mLastX = 0x7fff;
    mLastY = 0x7fff;
    mCurCount = mCounts;
    mCurStartPtr = mStartPtrs;
    mNumSpans = 0;
  }

  void addSpan (int x, int y, uint num, uint cover) {
    import core.stdc.string : memset;
    x -= mMinX;
    memset(mCovers+x, cover, num);
    if (x == mLastX+1) {
      (*mCurCount) += cast(ushort)num;
    } else {
      *++mCurCount = cast(ushort)num;
      *++mCurStartPtr = mCovers+x;
      ++mNumSpans;
    }
    mLastX = x+num-1;
    mLastY = y;
  }

  void addCell (int x, int y, uint cover) {
    x -= mMinX;
    mCovers[x] = cast(ubyte)cover;
    if (x == mLastX+1) {
      ++(*mCurCount);
    } else {
      *++mCurCount = 1;
      *++mCurStartPtr = mCovers+x;
      ++mNumSpans;
    }
    mLastX = x;
    mLastY = y;
  }

  @property bool isReady (int y) const pure { pragma(inline, true); return (mNumSpans && (y^mLastY)); }
  @property int baseX () const pure { pragma(inline, true); return mMinX+mDX; }
  @property int y () const pure { pragma(inline, true); return mLastY+mDY; }
  @property uint spanCount () const pure { pragma(inline, true); return mNumSpans; }
}


// ////////////////////////////////////////////////////////////////////////// //
/* This class template is used basically for rendering scanlines.
  Usage:
    auto ras = Rasterizer();

    // Making polygon
    // ras.moveTo(...);
    // ras.lineTo(...);
    // ...

    // Rendering
    ras.render(ren, Color(255, 127, 0));
*/
public struct Renderer {
public nothrow @trusted @nogc:
  mixin(DisableCopyingMixin);

  static void render (in ref ScanLine sl, in GxColor clr, in ref GxRect clipRect) {
    if (clipRect.size.h < 1 || clipRect.size.w < 1 || sl.y < clipRect.pos.y || sl.y >= clipRect.pos.y+clipRect.size.h) return;
    immutable GxColorU c = GxColorU(clr);
    uint spanCount = sl.spanCount;
    immutable int baseX = sl.baseX;
    uint* row = vglTexBuf+cast(uint)sl.y*cast(uint)VBufWidth;
    auto span = sl.iterator;
    do {
      int x = span.next+baseX;
      int pixelCount = span.pixelCount;
      int leftSkip = void;
      if (clipRect.clipHStripe(ref x, sl.y, ref pixelCount, &leftSkip)) {
        const(ubyte)* covers = span.covers+leftSkip;
        memBlendColorCoverage(row+x, covers, clr, pixelCount);
      }
    } while (--spanCount);
  }
}


// ////////////////////////////////////////////////////////////////////////// //
/* These constants determine the subpixel accuracy, to be more precise,
  the number of bits of the fractional part of the coordinates.
  The possible coordinate capacity in bits can be calculated by formula:
  sizeof(int) * 8 - PolyBaseShift * 2, i.e, for 32-bit integers and
  8-bits fractional part the capacity is 16 bits or [-32768...32767].
*/
enum : uint {
  PolyBaseShift = 8U,
  PolyBaseSize = cast(uint)(1<<PolyBaseShift),
  PolyBaseMask = cast(uint)(PolyBaseSize-1),
}


int polyCoord (in float c) pure nothrow @safe @nogc { pragma(inline, true); return (cast(int)(c*(PolyBaseSize*2))+1)/2; }

int dbl2fix (in float c) pure nothrow @safe @nogc { pragma(inline, true); return cast(int)(c*PolyBaseSize); }
float fix2dbl (in int c) pure nothrow @safe @nogc { pragma(inline, true); return cast(float)c/cast(float)PolyBaseSize; }


// ////////////////////////////////////////////////////////////////////////// //
/* Polygon rasterizer that is used to render filled polygons with
  high-quality Anti-Aliasing. Internally, by default, the class uses
  integer coordinates in format 24.8, i.e. 24 bits for integer part
  and 8 bits for fractional - see PolyBaseShift. This class can be
  used in the following  way:

  1. fillRule = FillRule.EvenOdd; // optional
  2. gamma() - optional.
  3. reset()
  4. moveTo(x, y) / lineTo(x, y) - make the polygon. One can create
     more than one contour, but each contour must consist of at least 3
     vertices, i.e. moveTo(x1, y1); lineTo(x2, y2); lineTo(x3, y3);
     is the absolute minimum of vertices that define a triangle.
     The algorithm does not check either the number of vertices nor
     coincidence of their coordinates, but in the worst case it just
     won't draw anything.
     The orger of the vertices (clockwise or counterclockwise)
     is important when using the non-zero filling rule (FillNonZero).
     In this case the vertex order of all the contours must be the same
     if you want your intersecting polygons to be without "holes".
     You actually can use different vertices order. If the contours do not
     intersect each other the order is not important anyway. If they do,
     contours with the same vertex order will be rendered without "holes"
     while the intersecting contours with different orders will have "holes".

  fillRule() and gamma() can be called anytime before "sweeping".
*/
public struct Rasterizer {
public nothrow @trusted @nogc:
  enum : uint {
    AAShift = ScanLine.AAShift,
    AANum = 1<<AAShift,
    AAMask = AANum-1,
    AA2Num = AANum*2,
    AA2Mask = AA2Num-1,
  }

private:
  Outline mOutline;
  ScanLine mScanline;
  FillRule mFillingRule = FillRule.NonZero;
  ubyte[256] mGamma = DefaultGamma[];

public:
  mixin(DisableCopyingMixin);

  void reset () { mOutline.reset(); }

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

  void gamma (in float g) {
    foreach (immutable uint i; 0..256) {
      //import std.math : pow;
      import core.stdc.math : powf;
      mGamma.ptr[i] = cast(ubyte)(powf(cast(float)i/255.0f, g)*255.0f);
    }
  }

  void gamma (const(ubyte)[] g) {
    if (g.length != 256) assert(0, "invalid gamma array");
    mGamma[] = g[0..256];
  }

  @property float currX () const pure { pragma(inline, true); return mOutline.currX; }
  @property float currY () const pure { pragma(inline, true); return mOutline.currY; }

  void moveToFixed (int x, int y) {
    if ((x>>PolyBaseShift) <= short.min+8 || (x>>PolyBaseShift) >= short.max-8 ||
        (y>>PolyBaseShift) <= short.min+8 || (y>>PolyBaseShift) >= short.max-8) assert(0, "coordinates out of bounds");
    mOutline.moveTo(x, y);
  }

  void lineToFixed (int x, int y) {
    if ((x>>PolyBaseShift) <= short.min+8 || (x>>PolyBaseShift) >= short.max-8 ||
        (y>>PolyBaseShift) <= short.min+8 || (y>>PolyBaseShift) >= short.max-8) assert(0, "coordinates out of bounds");
    mOutline.lineTo(x, y);
  }

  void moveTo (in float x, in float y) { mOutline.moveTo(polyCoord(x), polyCoord(y)); }
  void lineTo (in float x, in float y) { mOutline.lineTo(polyCoord(x), polyCoord(y)); }

  @property int minX () const pure { pragma(inline, true); return mOutline.minX; }
  @property int minY () const pure { pragma(inline, true); return mOutline.minY; }
  @property int maxX () const pure { pragma(inline, true); return mOutline.maxX; }
  @property int maxY () const pure { pragma(inline, true); return mOutline.maxY; }

  private uint calculateAlpha (int area) const pure {
    int cover = area>>(PolyBaseShift*2+1-AAShift);
    if (cover < 0) cover = -cover;
    if (mFillingRule == FillRule.EvenOdd) {
      cover &= AA2Mask;
      if (cover > AANum) cover = AA2Num-cover;
    }
    if (cover > AAMask) cover = AAMask;
    return cover;
  }

  void render (in ref GxRect clipRect, in GxColor c, int dx=0, int dy=0) {
    const(Cell)** cells = mOutline.cells();
    if (mOutline.numCells() == 0) return;

    mScanline.reset(mOutline.minX, mOutline.maxX, dx, dy);

    int cover = 0;
    const(Cell)* curCell = *cells++;

    for (;;) {
      const(Cell)* startCell = curCell;

      int coord = curCell.packedCoord;
      int x = curCell.x;
      int y = curCell.y;

      int area = startCell.area;
      cover += startCell.cover;

      // accumulate all start cells
      while ((curCell = *cells++) !is null) {
        if (curCell.packedCoord != coord) break;
        area += curCell.area;
        cover += curCell.cover;
      }

      if (area) {
        int alpha = calculateAlpha((cover<<(PolyBaseShift+1))-area);
        if (alpha) {
          if (mScanline.isReady(y)) {
            Renderer.render(mScanline, c, clipRect);
            mScanline.resetSpans();
          }
          mScanline.addCell(x, y, mGamma[alpha]);
        }
        ++x;
      }

      if (!curCell) break;

      if (curCell.x > x) {
        int alpha = calculateAlpha(cover<<(PolyBaseShift+1));
        if (alpha) {
          if (mScanline.isReady(y)) {
            Renderer.render(mScanline, c, clipRect);
            mScanline.resetSpans();
          }
          mScanline.addSpan(x, y, curCell.x-x, mGamma[alpha]);
        }
      }
    }

    if (mScanline.spanCount) Renderer.render(mScanline, c, clipRect);
  }

  bool hitTest (int tx, int ty) {
    const(Cell)** cells = mOutline.cells();
    if (mOutline.numCells == 0) return false;

    int cover = 0;
    const(Cell)* curCell = *cells++;

    for (;;) {
      const(Cell)* startCell = curCell;

      int coord = curCell.packedCoord;
      int x = curCell.x;
      int y = curCell.y;

      if (y > ty) return false;

      int area = startCell.area;
      cover += startCell.cover;

      while ((curCell = *cells++) !is null) {
        if (curCell.packedCoord != coord) break;
        area += curCell.area;
        cover += curCell.cover;
      }

      if (area) {
        int alpha = calculateAlpha((cover<<(PolyBaseShift+1))-area);
        if (alpha) {
          if (tx == x && ty == y) return true;
        }
        ++x;
      }

      if (curCell is null) break;

      if (curCell.x > x) {
        int alpha = calculateAlpha(cover<<(PolyBaseShift+1));
        if (alpha) {
          if (ty == y && tx >= x && tx <= curCell.x) return true;
        }
      }
    }
    return false;
  }

private:
  static immutable ubyte[256] DefaultGamma = [
      0,  0,  1,  1,  2,  2,  3,  4,  4,  5,  5,  6,  7,  7,  8,  8,
      9, 10, 10, 11, 11, 12, 13, 13, 14, 14, 15, 16, 16, 17, 18, 18,
     19, 19, 20, 21, 21, 22, 22, 23, 24, 24, 25, 25, 26, 27, 27, 28,
     29, 29, 30, 30, 31, 32, 32, 33, 34, 34, 35, 36, 36, 37, 37, 38,
     39, 39, 40, 41, 41, 42, 43, 43, 44, 45, 45, 46, 47, 47, 48, 49,
     49, 50, 51, 51, 52, 53, 53, 54, 55, 55, 56, 57, 57, 58, 59, 60,
     60, 61, 62, 62, 63, 64, 65, 65, 66, 67, 68, 68, 69, 70, 71, 71,
     72, 73, 74, 74, 75, 76, 77, 78, 78, 79, 80, 81, 82, 83, 83, 84,
     85, 86, 87, 88, 89, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99,
    100,101,101,102,103,104,105,106,107,108,109,110,111,112,114,115,
    116,117,118,119,120,121,122,123,124,126,127,128,129,130,131,132,
    134,135,136,137,139,140,141,142,144,145,146,147,149,150,151,153,
    154,155,157,158,159,161,162,164,165,166,168,169,171,172,174,175,
    177,178,180,181,183,184,186,188,189,191,192,194,195,197,199,200,
    202,204,205,207,209,210,212,214,215,217,219,220,222,224,225,227,
    229,230,232,234,236,237,239,241,242,244,246,248,249,251,253,255
  ];
}


// ////////////////////////////////////////////////////////////////////////// //
public alias AGGPoint = AGGPointImpl!float;

public struct AGGPointImpl(T) if (__traits(isIntegral, T) || __traits(isFloating, T)) {
public nothrow @trusted @nogc:
  alias ValueT = T;
  alias Me = AGGPointImpl!T;

public:
  static if (__traits(isFloating, T)) {
    T x, y;
  } else {
    T x=T.min, y=T.min;
  }
}


// ////////////////////////////////////////////////////////////////////////// //
public enum FillRule {
  NonZero,
  EvenOdd,
}

public enum LineCap {
  Butt,
  Square,
  Round,
}

public enum LineJoin {
  Miter,
  MiterRevert,
  Round,
  Bevel,
  MiterRound,
}

public enum InnerJoin {
  Bevel,
  Miter,
  Jag,
  Round,
}


// ////////////////////////////////////////////////////////////////////////// //
// some "fastgfx" backend
public struct AGGDrawer {
protected:
  static struct Vertex {
    float x, y; // fixed point
    bool asmove;
  }

protected:
  Rasterizer rast;
  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)
  Vertex* vtx;
  uint vtxcount, vtxsize;

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

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

  static bool ptEquals (in float x0, in float y0, in float x1, in float y1) pure {
    enum EPS = cast(float)(1.0f/256.0f);
    static bool eq (in float a, in float b) pure nothrow @safe @nogc { immutable float df = a-b; return (df < 0.0f ? (-df < EPS) : (df < EPS)); }
    return (eq(x0, x1) && eq(y0, y1));
  }

  static float distPtSeg (in float x, in float y, in float px, in float py, in float qx, in float qy) pure nothrow @safe @nogc {
    immutable float pqx = qx-px;
    immutable float pqy = qy-py;
    float dx = x-px;
    float dy = y-py;
    immutable float d = pqx*pqx+pqy*pqy;
    float t = pqx*dx+pqy*dy;
    if (d > 0) t /= d;
    if (t < 0) t = 0; else if (t > 1) t = 1;
    dx = px+t*pqx-x;
    dy = py+t*pqy-y;
    return dx*dx+dy*dy;
  }

  static float cross() (in float dx0, in float dy0, in float dx1, in float dy1) pure { pragma(inline, true); return (dx1*dy0-dx0*dy1); }
  static T min(T) (in T a, in T b) pure { pragma(inline, true); return (a < b ? a : b); }
  static T max(T) (in T a, in T b) pure { pragma(inline, true); return (a > b ? a : b); }
  static T sign(T) (in T a) pure { pragma(inline, true); return (a >= cast(T)0 ? cast(T)1 : cast(T)(-1)); }

  static float normalize (float* x, float* y) nothrow @safe @nogc {
    import core.stdc.math : sqrtf;
    float d = sqrtf((*x)*(*x)+(*y)*(*y));
    if (d > 1e-6f) {
      immutable float id = 1.0f/d;
      *x *= id;
      *y *= id;
    }
    return d;
  }

  void addVertexIntr (float fx, float fy, bool asMove=false) {
    //static bool eq (in float a, in float b) pure nothrow @safe @nogc { import std.math : abs; return (abs(a-b) < EPS); }
    // it is important to reject pixels that are too close!
    if (vtxcount > 0 && ptEquals(fx, fy, vtx[vtxcount-1].x, vtx[vtxcount-1].y)) {
      if (asMove != vtx[vtxcount-1].asmove) return;
    }
    if (vtxcount+1 > vtxsize) {
      import core.stdc.stdlib : realloc;
      uint newsz = (vtxsize|0xfff)+1;
      vtx = cast(Vertex*)realloc(vtx, newsz*Vertex.sizeof);
      if (vtx is null) assert(0, "out of memory");
      vtxsize = newsz;
    }
    if (asMove && vtxcount > 0 && vtx[vtxcount-1].asmove) --vtxcount;
    vtx[vtxcount++] = Vertex(fx, fy, asMove);
  }

  void addVertex (in float fx, in float fy, bool asMove=false) {
    pragma(inline, true);
    if (vtxcount == 0 && !asMove) addVertexIntr(0, 0, true);
    addVertexIntr(fx, fy, asMove);
  }

protected:
  Stroker mStroker;

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(); }

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

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

  @property float currX () const pure { pragma(inline, true); return (vtxcount > 0 ? vtx[vtxcount-1].x : 0.0f); }
  @property float currY () const pure { pragma(inline, true); return (vtxcount > 0 ? vtx[vtxcount-1].y : 0.0f); }

  // ////////////////////////////////////////////////////////////////////////// //
  ref AGGDrawer beginFrame () {
    vtxcount = 0;
    //addVertex(0, 0, true);
    mStroker.width = 1.5f;
    rast.reset();
    return this;
  }

  ref AGGDrawer cancelFrame () {
    vtxcount = 0;
    //addVertex(0, 0, true);
    rast.reset();
    return this;
  }

  ref AGGDrawer endFrame (in GxColor c) {
    GxRect clipRect = gxClipRect;
    if (clipRect.intersect(0, 0, VBufWidth, VBufHeight)) {
      rast.render(clipRect, c);
    }
    return beginFrame();
  }

  ref AGGDrawer beginPath () {
    pragma(inline, true);
    vtxcount = 0;
    return this;
  }

  ref AGGDrawer closePath () {
    if (vtxcount > 1 && !vtx[vtxcount-1].asmove) {
      uint vp = vtxcount;
      while (vp > 0 && !vtx[vp-1].asmove) --vp;
      addVertex(vtx[vp].x, vtx[vp].y); // close it
      addVertex(vtx[vp].x, vtx[vp].y, true); // and open new one
    }
    return this;
  }

  // starts new sub-path with specified point as first point
  ref AGGDrawer moveTo (in float x, in float y) { pragma(inline, true); addVertex(x, y, true); 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); addVertex(x, y); 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) ||
        distPtSeg(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(&dx0, &dy0);
    normalize(&dx1, &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 (cross(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
  }


  // ////////////////////////////////////////////////////////////////////////// //
  // fill pathes
  void fill () {
    //pragma(inline, true);
    foreach (const ref Vertex vt; vtx[0..vtxcount]) {
      if (vt.asmove) rast.moveTo(vt.x, vt.y); else rast.lineTo(vt.x, vt.y);
    }
  }

  // stroke pathes
  void stroke () {
    //if (mStroker.width <= 1.0) { contour(); return; }
    mStroker.removeAll();

    bool waitingLine = true;
    foreach (const ref Vertex vt; vtx[0..vtxcount]) {
      mStroker.addVertex(vt.x, vt.y, (vt.asmove ? PathCommand.MoveTo : PathCommand.LineTo));
    }
    mStroker.addVertex(0, 0, PathCommand.Stop);

    float x, y;
    mStroker.rewind();
    for (;;) {
      auto cmd = mStroker.vertex(&x, &y);
      if (isStop(cmd)) break;
      if (isMoveTo(cmd)) { rast.moveTo(x, y); continue; }
      if (isLineTo(cmd)) { rast.lineTo(x, y); continue; }
      if (isEndPoly(cmd)) {
        /*
        if (is_close(cmd) && !first) {
          //writeln("s=(", sx, ",", sy, "); c=(", x, ",", y, ")");
          pts.add(PathPoint(sx, sy, false));
        }
        */
      }
    }
  }

  // contour pathes
  void contour () {
    Contourer ctr;
    ctr.removeAll();

    ctr.lineCap = mStroker.lineCap;
    ctr.lineJoin = mStroker.lineJoin;
    ctr.innerJoin = mStroker.innerJoin;

    ctr.width = mStroker.width;
    ctr.miterLimit = mStroker.miterLimit;
    ctr.innerMiterLimit = mStroker.innerMiterLimit;
    ctr.approximationScale = mStroker.approximationScale;

    bool waitingLine = true;
    foreach (const ref Vertex vt; vtx[0..vtxcount]) {
      ctr.addVertex(vt.x, vt.y, (vt.asmove ? PathCommand.MoveTo : PathCommand.LineTo));
    }
    ctr.addVertex(0, 0, PathCommand.Stop);

    float x, y;
    ctr.rewind();
    for (;;) {
      auto cmd = ctr.vertex(&x, &y);
      if (isStop(cmd)) break;
      if (isMoveTo(cmd)) { rast.moveTo(x, y); continue; }
      if (isLineTo(cmd)) { rast.lineTo(x, y); continue; }
    }
  }


  // ////////////////////////////////////////////////////////////////////////// //
  enum Winding { CW, CCW }

  /* 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 = (vtxcount == 0);
    } 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) {
        addVertex(x, y, asMove);
      } 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 closePath();
  }

  // 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 closePath();
  }

  // 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 closePath();
  }

  // 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/*, in int type*/) {
    import core.stdc.math : fabsf;
    if (level > 10) return;

    // check for collinear points, and use AFD tesselator on such curves (it is WAY faster for this case)
    /*
    if (level == 0 && ctx.tesselatortype == NVGTesselation.Combined) {
      static bool collinear (in float v0x, in float v0y, in float v1x, in float v1y, in float v2x, in float v2y) nothrow @trusted @nogc {
        immutable float cz = (v1x-v0x)*(v2y-v0y)-(v2x-v0x)*(v1y-v0y);
        return (fabsf(cz*cz) <= 0.01f); // arbitrary number, seems to work ok with NanoSVG output
      }
      if (collinear(x1, y1, x2, y2, x3, y3) && collinear(x2, y2, x3, y3, x3, y4)) {
        //{ import core.stdc.stdio; printf("AFD fallback!\n"); }
        ctx.tesselateBezierAFD(x1, y1, x2, y2, x3, y3, x4, y4, type);
        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)) {
      addVertex(x4, y4/*, type*/);
      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) {
      addVertex(x1234, y1234/*, type*/);
      return;
    }

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

  // ////////////////////////////////////////////////////////////////////////// //
  // 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/*, in int type*/) {
    //import std.math : atan2, PI;
    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) {
      addVertex(x1, y1/*, 0*/);
      tesselateBezierMcSeem(x1, y1, x2, y2, x3, y3, x4, y4, 1/*, type*/);
      addVertex(x4, y4/*, type*/);
      return;
    }
    +/

    if (level >= 32) 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) {
          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) d2 = distSquared(x2, y2, x1, y1);
          else if (d2 >= 1) d2 = distSquared(x2, y2, x4, y4);
          else d2 = distSquared(x2, y2, x1+d2*dx, y1+d2*dy);

               if (d3 <= 0) d3 = distSquared(x3, y3, x1, y1);
          else if (d3 >= 1) d3 = distSquared(x3, y3, x4, y4);
          else d3 = distSquared(x3, y3, x1+d3*dx, y1+d3*dy);
        }
        if (d2 > d3) {
          if (d2 < tessTol) {
            addVertex(x2, y2/*, type*/);
            return;
          }
        } if (d3 < tessTol) {
          addVertex(x3, y3/*, type*/);
          return;
        }
        break;
      case 1:
        // p1,p2,p4 are collinear, p3 is significant
        if (d3*d3 <= tessTol*(dx*dx+dy*dy)) {
          if (angleTol < AngleTolEPS) {
            addVertex(x23, y23/*, type*/);
            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) {
              addVertex(x2, y2/*, type*/);
              addVertex(x3, y3/*, type*/);
              return;
            }
            if (cuspLimit != 0.0f) {
              if (da1 > cuspLimit) {
                addVertex(x3, y3/*, type*/);
                return;
              }
            }
          }
        }
        break;
      case 2:
        // p1,p3,p4 are collinear, p2 is significant
        if (d2*d2 <= tessTol*(dx*dx+dy*dy)) {
          if (angleTol < AngleTolEPS) {
            addVertex(x23, y23/*, type*/);
            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) {
              addVertex(x2, y2/*, type*/);
              addVertex(x3, y3/*, type*/);
              return;
            }
            if (cuspLimit != 0.0f) {
              if (da1 > cuspLimit) {
                addVertex(x2, y2/*, type*/);
                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) {
            addVertex(x23, y23/*, type*/);
            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
              addVertex(x23, y23/*, type*/);
              return;
            }
            if (cuspLimit != 0.0f) {
              if (da1 > cuspLimit) {
                addVertex(x2, y2/*, type*/);
                return;
              }
              if (da2 > cuspLimit) {
                addVertex(x3, y3/*, type*/);
                return;
              }
            }
          }
        }
        break;
    }

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

  // 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/*, in int type*/) nothrow @trusted @nogc {
    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.
      addVertex(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/*, type*/);
        break;
      case AFD:
        tesselateBezierAFD(x1, y1, x2, y2, x3, y3, x4, y4/*, type*/);
        break;
      case DeCasteljauMcSeem:
        addVertex(x1, y1/*, 0*/);
        tesselateBezierMcSeem(x1, y1, x2, y2, x3, y3, x4, y4, 1/*, type*/);
        addVertex(x4, y4/*, type*/);
        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);
      }
    }
    static if (baph_debug_time) {
      immutable estt = clockMicro()-tstt;
      import core.stdc.stdio; printf("total 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);
      }
    }
    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,];
}


//----------------------------------------------------------------------------
// Anti-Grain Geometry (AGG) - Version 2.5
// A high quality rendering engine for C++
// Copyright (C) 2002-2006 Maxim Shemanarev
// Contact: mcseem@antigrain.com
//          mcseemagg@yahoo.com
//          http://antigrain.com
//
// AGG 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; either version 2
// of the License, or (at your option) any later version.
//
// AGG 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 AGG; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
// MA 02110-1301, USA.
//----------------------------------------------------------------------------
private nothrow @trusted @nogc:


enum PathCommand : ubyte {
  Stop = 0,
  MoveTo = 1,
  LineTo = 2,
  EndPoly = 0x0F,
  Mask = 0x0F,
}

enum PathFlag : ubyte {
  None = 0x00,
  CCW = 0x10,
  CW = 0x20,
  Close = 0x40,
  Mask = 0xF0,
}


bool isVertex (in uint c) pure { pragma(inline, true); return (c >= PathCommand.MoveTo && c < PathCommand.EndPoly); }
bool isDrawing (in uint c) pure { pragma(inline, true); return (c >= PathCommand.LineTo && c < PathCommand.EndPoly); }
bool isStop (in uint c) pure { pragma(inline, true); return (c == PathCommand.Stop); }
bool isMoveTo (in uint c) pure { pragma(inline, true); return (c == PathCommand.MoveTo); }
bool isLineTo (in uint c) pure { pragma(inline, true); return (c == PathCommand.LineTo); }
bool isEndPoly (in uint c) pure { pragma(inline, true); return ((c&PathCommand.Mask) == PathCommand.EndPoly); }
bool isClose (in uint c) pure { pragma(inline, true); return (c&~cast(uint)(PathFlag.CW|PathFlag.CCW)) == (PathCommand.EndPoly|PathFlag.Close); }
bool isCW (in uint c) pure { pragma(inline, true); return ((c&PathFlag.CW) != 0); }
bool isCCW (in uint c) pure { pragma(inline, true); return ((c&PathFlag.CCW) != 0); }
bool isOriented (in uint c) pure { pragma(inline, true); return ((c&(PathFlag.CW|PathFlag.CCW)) != 0); }
bool isClosed (in uint c) pure { pragma(inline, true); return ((c&PathFlag.Close) != 0); }
uint getCloseFlag (in uint c) pure { pragma(inline, true); return (c&PathFlag.Close); }
uint clearOrientation (in uint c) pure { pragma(inline, true); return (c&~cast(uint)(PathFlag.CW|PathFlag.CCW)); }
uint getOrientation (in uint c) pure { pragma(inline, true); return (c&(PathFlag.CW|PathFlag.CCW)); }
uint setOrientation (in uint c, uint o) pure { pragma(inline, true); return (clearOrientation(c)|o); }

//enum PI = 3.14159265358979323846;
//enum DBL_PI = cast(double)(0x1.921fb54442d18p+1);
enum FLT_PI = cast(float)(0x1.921fb54442d18p+1);

enum DEG2RAD_MULT_D = cast(double)(0x1.1df46a2529d39p-6);
enum RAD2DEG_MULT_D = cast(double)(0x1.ca5dc1a63c1f8p+5);

enum DEG2RAD_MULT_F = cast(float)(0x1.1df46ap-6f);
enum RAD2DEG_MULT_F = cast(float)(0x1.ca5dc2p+5f);

//float deg2rad (in float deg) pure nothrow @safe @nogc { pragma(inline, true); return deg*cast(float)(PI/180.0f); }
//float rad2deg (in float rad) pure nothrow @safe @nogc { pragma(inline, true); return rad*cast(float)(180.0f/PI); }
public T deg2rad(T) (in T deg) if (__traits(isFloating, T) && (T.sizeof == 4 || T.sizeof == 8)) {
  pragma(inline, true);
  static if (T.sizeof == 4) {
    return deg*DEG2RAD_MULT_F;
  } else {
    return deg*DEG2RAD_MULT_D;
  }
}

public T rad2deg(T) (in T rad) if (__traits(isFloating, T) && (T.sizeof == 4 || T.sizeof == 8)) {
  pragma(inline, true);
  static if (T.sizeof == 4) {
    return rad*RAD2DEG_MULT_F;
  } else {
    return rad*RAD2DEG_MULT_D;
  }
}


float calcPolygonArea(Storage) (in ref Storage st) {
  float sum = 0;
  float x = st[0].x;
  float y = st[0].y;
  float xs = x;
  float ys = y;
  foreach (immutable uint i; 1..st.length) {
    auto v = &st[i];
    sum += x*v.y-y*v.x;
    x = v.x;
    y = v.y;
  }
  return (sum+x*ys-y*xs)*0.5f;
}


void shortenPath(VertexSequence) (ref VertexSequence vs, float s, in uint closed=0) {
  alias VertexType = VertexSequence.ValueType;
  if (s > 0 && vs.length > 1) {
    //float d;
    int n = cast(int)(vs.length-2);
    while (n) {
      immutable float d = vs[n].dist;
      if (d > s) break;
      vs.removeLast();
      s -= d;
      --n;
    }
    if (vs.length < 2) {
      vs.removeAll();
    } else {
      n = vs.length-1;
      VertexType* prev = &vs[n-1];
      VertexType* last = &vs[n];
      immutable float d = (prev.dist-s)/prev.dist;
      immutable float x = prev.x+(last.x-prev.x)*d;
      immutable float y = prev.y+(last.y-prev.y)*d;
      last.x = x;
      last.y = y;
      if (!(*prev)(*last)) vs.removeLast();
      vs.close(closed != 0);
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
// Vertex (x, y) with the distance to the next one. The last vertex has
// distance between the last and the first points if the polygon is closed
// and 0.0 if it's a polyline.
struct VertexDist {
public nothrow @trusted @nogc:
  float x = 0.0f;
  float y = 0.0f;
  float dist = 0.0f;

  this (in float ax, in float ay) pure { x = ax; y = ay; /*dist = 0.0f;*/ }

  bool opCall() (in auto ref VertexDist val) {
    //enum VertexDistEPS = cast(double)1e-14; // Coinciding points maximal distance (Epsilon)
    enum VertexDistEPS = cast(float)0.00001f; // Coinciding points maximal distance (Epsilon)
    immutable bool ret = (dist = distance(x, y, val.x, val.y)) > VertexDistEPS;
    if (!ret) dist = 1.0f/VertexDistEPS;
    return ret;
  }
}


// ////////////////////////////////////////////////////////////////////////// //
struct SimpleVector(T) {
public nothrow @trusted @nogc:
  alias ValueType = T;
  T* pvec;
  uint pvecAllot, pvecSize;

  mixin(DisableCopyingMixin);

  ~this () {
    import core.stdc.stdlib : free;
    if (pvec !is null) free(pvec);
    pvec = null;
    pvecAllot = pvecSize = 0;
  }

  @property uint length () const pure { pragma(inline, true); return pvecSize; }

  ref inout(T) opIndex (in uint idx) inout pure { pragma(inline, true);return pvec[idx]; }

  ref inout(T) curr (in uint idx) inout pure { pragma(inline, true);return pvec[idx]; }
  ref inout(T) prev (in uint idx) inout pure { pragma(inline, true);return pvec[(idx+pvecSize-1)%pvecSize]; }
  ref inout(T) next (in uint idx) inout pure { pragma(inline, true);return pvec[(idx+1)%pvecSize]; }

  void removeAll () {
    pragma(inline, true);
    pvecSize = 0;
  }

  void removeLast () {
    pragma(inline, true);
    if (pvecSize > 0 ) --pvecSize;
  }

  void add() (in auto ref T val) {
    import core.stdc.stdlib : realloc;
    import core.stdc.string : memcpy;
    if (pvecSize+1 > pvecAllot) {
      uint newsz = (pvecAllot|0xff)+1;
      pvec = cast(T*)realloc(pvec, T.sizeof*newsz);
      if (pvec is null) assert(0, "out of memory");
      pvecAllot = newsz;
    }
    assert(pvecSize < pvecAllot);
    memcpy(pvec+pvecSize, &val, T.sizeof);
    ++pvecSize;
  }
}


// ////////////////////////////////////////////////////////////////////////// //
struct VertexSequence(T) {
public nothrow @trusted @nogc:
  SimpleVector!T me;
  alias me this;
  alias ValueType = T;

  mixin(DisableCopyingMixin);

  void add() (in auto ref T val) {
    import core.stdc.stdlib : realloc;
    import core.stdc.string : memcpy;
    if (pvecSize > 1) {
      if (!pvec[pvecSize-2](pvec[pvecSize-1])) removeLast();
    }
    me.add(val);
  }

  void modifyLast() (in auto ref T val) {
    if (pvecSize > 0) removeLast();
    add(val);
  }

  // closed aka remove_flag
  void close (in bool closed) {
    while (pvecSize > 1) {
      if (pvec[pvecSize-2](pvec[pvecSize-1])) break;
      T t = pvec[pvecSize-1];
      removeLast();
      modifyLast(t);
    }
    if (closed) {
      while (pvecSize > 1) {
        if (pvec[pvecSize-1](pvec[0])) break;
        removeLast();
      }
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
// process vertex source [src] with generator [dest]
void feedWith(VSD, VSS) (ref VSD dest, ref VSS src) {
  dest.removeAll();
  src.rewind();
  float x, y;
  for (;;) {
    immutable cmd = src.vertex(&x, &y);
    dest.addVertex(x, y, cmd);
    if (isStop(cmd)) break;
  }
}


// ////////////////////////////////////////////////////////////////////////// //
// this connects vertex source to vertex generator
struct PathPoint {
  float x = 0.0f, y = 0.0f;
  bool moveto;
  @property bool lineto () const pure nothrow @safe @nogc { pragma(inline, true); return !moveto; }
}


struct PathPointRange {
private:
  SimpleVector!PathPoint pts;
  uint idx = 0;

public nothrow @trusted @nogc:
  mixin(DisableCopyingMixin);

  this(VG) (ref VG vg) {
    // feed dest
    vg.rewind();
    float x, y;
    float sx, sy;
    bool first = true;
    for (;;) {
      auto cmd = vs.vertex(&x, &y);
      if (isStop(cmd)) break;
      if (isMoveTo(cmd)) {
        sx = x;
        sy = y;
        first = true;
        continue;
      }
      if (isLineTo(cmd)) {
        /*
        import std.math : isNaN;
        assert(!sx.isNaN);
        assert(!sy.isNaN);
        */
        if (first) { pts.add(PathPoint(sx, sy, true)); }
        pts.add(PathPoint(x, y, false));
        continue;
      }
      if (isEndPoly(cmd)) {
        if (isClose(cmd) && !first) {
          //writeln("s=(", sx, ",", sy, "); c=(", x, ",", y, ")");
          pts.add(PathPoint(sx, sy, false));
        }
      }
      first = true;
    }
  }

  void rewind () { pragma(inline, true); idx = 0; }

  @property bool empty () const pure { pragma(inline, true); return (idx >= pts.length); }
  @property ref inout(PathPoint) front () inout pure { pragma(inline, true); return pts[idx]; }
  @property int length () const pure { pragma(inline, true); return pts.length-idx; }
  void popFront () { if (idx < pts.length) ++idx; }
}


// ////////////////////////////////////////////////////////////////////////// //
bool intersection (in float ax, in float ay, in float bx, in float by, in float cx, in float cy, in float dx, in float dy, float* x, float* y) /*pure*/ nothrow @trusted @nogc {
  //enum IntersectionEPS = cast(double)1.0e-30; // See calc_intersection
  enum IntersectionEPS = cast(float)1.0e-16; // See calc_intersection
  //version(aliced) pragma(inline, true);
  //import std.math : abs;
  import core.stdc.math : fabsf;
  immutable float num = (ay-cy)*(dx-cx)-(ax-cx)*(dy-cy);
  immutable float den = (bx-ax)*(dy-cy)-(by-ay)*(dx-cx);
  if (fabsf(den) < IntersectionEPS) return false;
  //if ((den < 0.0f ? (-den < IntersectionEPS) : (den < IntersectionEPS))) return false;
  immutable float r = num/den;
  if (x !is null) *x = ax+r*(bx-ax);
  if (y !is null) *y = ay+r*(by-ay);
  return true;
}

float cross (in float x1, in float y1, in float x2, in float y2, in float x, in float y) pure nothrow @safe @nogc {
  pragma(inline, true);
  return (x-x2)*(y2-y1)-(y-y2)*(x2-x1);
}

float distance (in float x1, in float y1, in float x2, in float y2) /*pure*/ nothrow @safe @nogc {
  pragma(inline, true);
  import core.stdc.math : sqrtf;
  immutable float dx = x2-x1;
  immutable float dy = y2-y1;
  return sqrtf(dx*dx+dy*dy);
}

float distance() (in auto ref VertexDist v0, in auto ref VertexDist v1) /*pure*/ nothrow @safe @nogc {
  pragma(inline, true);
  import core.stdc.math : sqrtf;
  immutable float dx = v1.x-v0.x;
  immutable float dy = v1.y-v0.y;
  return sqrtf(dx*dx+dy*dy);
}


/*
 * VertexConsumer API:
 *   alias value_type = VertexType; // shoud support `VertexType(x, y)`
 *   vc.remove_all(); -- start new polygon
 *   vc.add(VT); -- add point to the current polygon
 */
struct StrokeCalc(VertexConsumer) {
private:
  float mWidth = 0.5f;
  float mWidthAbs = 0.5f;
  float mWidthEps = 0.5f/1024.0f;
  int mWidthSign = 1;
  float mMiterLimit = 4.0f;
  float mInnerMiterLimit = 1.01f;
  float mApproxScale = 1.0f;
  LineCap mLineCap = LineCap.Butt;
  LineJoin mLineJoin = LineJoin.Miter;
  InnerJoin mInnerJoin = InnerJoin.Miter;

public nothrow @trusted @nogc:
  alias CoordType = VertexConsumer.ValueType;

  mixin(DisableCopyingMixin);

  @property void lineCap (in LineCap lc) { pragma(inline, true); mLineCap = lc; }
  @property void lineJoin (in LineJoin lj) { pragma(inline, true); mLineJoin = lj; }
  @property void innerJoin (in InnerJoin ij) { pragma(inline, true); mInnerJoin = ij; }

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

  @property float width () const pure { pragma(inline, true); return mWidth*2.0f; }
  @property void width (in float w) {
    mWidth = w*0.5f;
    if (mWidth < 0.0f) {
      mWidthAbs = -mWidth;
      mWidthSign = -1;
    } else {
      mWidthAbs = mWidth;
      mWidthSign = 1;
    }
    mWidthEps = mWidth/1024.0f;
  }

  @property void miterLimit (in float ml) { pragma(inline, true); mMiterLimit = ml; }
  @property void miterLimitTheta (in float t) { pragma(inline, true); import core.stdc.math : sinf; mMiterLimit = 1.0f/sinf(t*0.5f); }
  @property void innerMiterLimit (in float ml) { pragma(inline, true); mInnerMiterLimit = ml; }
  @property void approximationScale (in float as) { pragma(inline, true); mApproxScale = as; }

  @property float miterLimit () const pure { pragma(inline, true); return mMiterLimit; }
  @property float innerMiterLimit () const pure { pragma(inline, true); return mInnerMiterLimit; }
  @property float approximationScale () const pure { pragma(inline, true); return mApproxScale; }

  void calcCap() (ref VertexConsumer vc, in auto ref VertexDist v0, in auto ref VertexDist v1, in float len) {
    import core.stdc.math : acosf, atan2f, cosf, sinf;

    vc.removeAll();

    float dx1 = (v1.y-v0.y)/len;
    float dy1 = (v1.x-v0.x)/len;
    float dx2 = 0.0f;
    float dy2 = 0.0f;

    dx1 *= mWidth;
    dy1 *= mWidth;

    if (mLineCap != LineCap.Round) {
      if (mLineCap == LineCap.Square) {
        dx2 = dy1*mWidthSign;
        dy2 = dx1*mWidthSign;
      }
      addVertex(vc, v0.x-dx1-dx2, v0.y+dy1-dy2);
      addVertex(vc, v0.x+dx1-dx2, v0.y-dy1-dy2);
    } else {
      float da = acosf(mWidthAbs/(mWidthAbs+0.125f/mApproxScale))*2.0f;
      immutable int n = cast(int)(FLT_PI/da);
      da = FLT_PI/(n+1);
      addVertex(vc, v0.x-dx1, v0.y+dy1);
      if (mWidthSign > 0.0f) {
        float a1 = atan2f(dy1, -dx1);
        a1 += da;
        foreach (immutable int i; 0..n) {
          addVertex(vc, v0.x+cosf(a1)*mWidth, v0.y+sinf(a1)*mWidth);
          a1 += da;
        }
      } else {
        float a1 = atan2f(-dy1, dx1);
        a1 -= da;
        foreach (immutable int i; 0..n) {
          addVertex(vc, v0.x+cosf(a1)*mWidth, v0.y+sinf(a1)*mWidth);
          a1 -= da;
        }
      }
      addVertex(vc, v0.x+dx1, v0.y-dy1);
    }
  }

  void calcJoin() (ref VertexConsumer vc, in auto ref VertexDist v0, in auto ref VertexDist v1, in auto ref VertexDist v2, in float len1, in float len2) {
    import core.stdc.math : sqrtf;

    immutable float dx1 = mWidth*(v1.y-v0.y)/len1;
    immutable float dy1 = mWidth*(v1.x-v0.x)/len1;
    immutable float dx2 = mWidth*(v2.y-v1.y)/len2;
    immutable float dy2 = mWidth*(v2.x-v1.x)/len2;

    vc.removeAll();

    float cp = cross(v0.x, v0.y, v1.x, v1.y, v2.x, v2.y);
    if (cp != 0.0f && (cp > 0.0f) == (mWidth > 0.0f)) {
      // Inner join
      float limit = (len1 < len2 ? len1 : len2)/mWidthAbs;
      if (limit < mInnerMiterLimit) limit = mInnerMiterLimit;

      switch (mInnerJoin) {
        default: // inner_bevel
          addVertex(vc, v1.x+dx1, v1.y-dy1);
          addVertex(vc, v1.x+dx2, v1.y-dy2);
          break;
        case InnerJoin.Miter:
          calcMiter(vc, v0, v1, v2, dx1, dy1, dx2, dy2, LineJoin.MiterRevert, limit, 0.0f);
          break;
        case InnerJoin.Jag:
        case InnerJoin.Round:
          cp = (dx1-dx2)*(dx1-dx2)+(dy1-dy2)*(dy1-dy2);
          if (cp < len1*len1 && cp < len2*len2) {
            calcMiter(vc, v0, v1, v2, dx1, dy1, dx2, dy2, LineJoin.MiterRevert, limit, 0.0f);
          } else {
            if (mInnerJoin == InnerJoin.Jag) {
              addVertex(vc, v1.x+dx1, v1.y-dy1);
              addVertex(vc, v1.x, v1.y);
              addVertex(vc, v1.x+dx2, v1.y-dy2);
            } else {
              addVertex(vc, v1.x+dx1, v1.y-dy1);
              addVertex(vc, v1.x, v1.y);
              calcArc(vc, v1.x, v1.y, dx2, -dy2, dx1, -dy1);
              addVertex(vc, v1.x, v1.y);
              addVertex(vc, v1.x+dx2, v1.y-dy2);
            }
          }
          break;
      }
    } else {
      // Outer join

      // Calculate the distance between v1 and
      // the central point of the bevel line segment
      float dx = (dx1+dx2)*0.5f;
      float dy = (dy1+dy2)*0.5f;
      immutable float dbevel = sqrtf(dx*dx+dy*dy);

      if (mLineJoin == LineJoin.Round || mLineJoin == LineJoin.Bevel) {
        // This is an optimization that reduces the number of points
        // in cases of almost collinear segments. If there's no
        // visible difference between bevel and miter joins we'd rather
        // use miter join because it adds only one point instead of two.
        //
        // Here we calculate the middle point between the bevel points
        // and then, the distance between v1 and this middle point.
        // At outer joins this distance always less than stroke width,
        // because it's actually the height of an isosceles triangle of
        // v1 and its two bevel points. If the difference between this
        // width and this value is small (no visible bevel) we can
        // add just one point.
        //
        // The constant in the expression makes the result approximately
        // the same as in round joins and caps. You can safely comment
        // out this entire "if".
        if (mApproxScale*(mWidthAbs-dbevel) < mWidthEps) {
          if (intersection(v0.x+dx1, v0.y-dy1, v1.x+dx1, v1.y-dy1, v1.x+dx2, v1.y-dy2, v2.x+dx2, v2.y-dy2, &dx, &dy)) {
            addVertex(vc, dx, dy);
          } else {
            addVertex(vc, v1.x+dx1, v1.y-dy1);
          }
          return;
        }
      }

      switch (mLineJoin) {
        case LineJoin.Miter:
        case LineJoin.MiterRevert:
        case LineJoin.MiterRound:
          calcMiter(vc, v0, v1, v2, dx1, dy1, dx2, dy2, mLineJoin, mMiterLimit, dbevel);
          break;
        case LineJoin.Round:
          calcArc(vc, v1.x, v1.y, dx1, -dy1, dx2, -dy2);
          break;
        default: // Bevel join
          addVertex(vc, v1.x+dx1, v1.y-dy1);
          addVertex(vc, v1.x+dx2, v1.y-dy2);
          break;
      }
    }
  }

private:
  void addVertex (ref VertexConsumer vc, in float x, in float y) {
    pragma(inline, true);
    vc.add(CoordType(x, y));
  }

  void calcArc (ref VertexConsumer vc, in float x, in float y, in float dx1, in float dy1, in float dx2, in float dy2) {
    import core.stdc.math : acosf, atan2f, cosf, sinf;

    float a1 = atan2f(dy1*mWidthSign, dx1*mWidthSign);
    float a2 = atan2f(dy2*mWidthSign, dx2*mWidthSign);

    immutable float da = acosf(mWidthAbs/(mWidthAbs+0.125f/mApproxScale))*2.0f;

    addVertex(vc, x+dx1, y+dy1);
    if (mWidthSign > 0.0f) {
      if (a1 > a2) a2 += 2.0f*FLT_PI;
      immutable int n = cast(int)((a2-a1)/da);
      immutable float daa = (a2-a1)/(n+1);
      a1 += daa;
      foreach (immutable int i; 0..n) {
        addVertex(vc, x+cosf(a1)*mWidth, y+sinf(a1)*mWidth);
        a1 += daa;
      }
    } else {
      if (a1 < a2) a2 -= 2.0f*FLT_PI;
      immutable int n = cast(int)((a1-a2)/da);
      immutable float daa = (a1-a2)/(n+1);
      a1 -= daa;
      foreach (immutable int i; 0..n) {
        addVertex(vc, x+cosf(a1)*mWidth, y+sinf(a1)*mWidth);
        a1 -= daa;
      }
    }
    addVertex(vc, x+dx2, y+dy2);
  }

  void calcMiter (ref VertexConsumer vc, in ref VertexDist v0, in ref VertexDist v1, in ref VertexDist v2,
                   in float dx1, in float dy1, in float dx2, in float dy2, in LineJoin lj,
                   in float mlimit, in float dbevel)
  {
    float xi = v1.x;
    float yi = v1.y;
    float di = 1.0f;
    immutable float lim = mWidthAbs*mlimit;
    bool miterLimitExceeded = true; // assume the worst
    bool intersectionFailed = true; // assume the worst

    if (intersection(v0.x+dx1, v0.y-dy1, v1.x+dx1, v1.y-dy1, v1.x+dx2, v1.y-dy2, v2.x+dx2, v2.y-dy2, &xi, &yi)) {
      // Calculation of the intersection succeeded
      di = distance(v1.x, v1.y, xi, yi);
      if (di <= lim) {
        // Inside the miter limit
        addVertex(vc, xi, yi);
        miterLimitExceeded = false;
      }
      intersectionFailed = false;
    } else {
      // Calculation of the intersection failed, most probably
      // the three points lie one straight line.
      // First check if v0 and v2 lie on the opposite sides of vector:
      // (v1.x, v1.y) -> (v1.x+dx1, v1.y-dy1), that is, the perpendicular
      // to the line determined by vertices v0 and v1.
      // This condition determines whether the next line segments continues
      // the previous one or goes back.
      immutable float x2 = v1.x+dx1;
      immutable float y2 = v1.y-dy1;
      if ((cross(v0.x, v0.y, v1.x, v1.y, x2, y2) < 0) == (cross(v1.x, v1.y, v2.x, v2.y, x2, y2) < 0)) {
        // This case means that the next segment continues
        // the previous one (straight line)
        addVertex(vc, v1.x+dx1, v1.y-dy1);
        miterLimitExceeded = false;
      }
    }

    if (miterLimitExceeded) {
      // Miter limit exceeded
      //------------------------
      switch (lj) {
        case LineJoin.MiterRevert:
          // For the compatibility with SVG, PDF, etc,
          // we use a simple bevel join instead of
          // "smart" bevel
          addVertex(vc, v1.x+dx1, v1.y-dy1);
          addVertex(vc, v1.x+dx2, v1.y-dy2);
          break;
        case LineJoin.MiterRound:
          calcArc(vc, v1.x, v1.y, dx1, -dy1, dx2, -dy2);
          break;
        default:
          // If no miter-revert, calculate new dx1, dy1, dx2, dy2
          if (intersectionFailed) {
            immutable float mlimitM = mlimit*mWidthSign;
            addVertex(vc, v1.x+dx1+dy1*mlimitM, v1.y-dy1+dx1*mlimitM);
            addVertex(vc, v1.x+dx2-dy2*mlimitM, v1.y-dy2-dx2*mlimitM);
          } else {
            immutable float x1 = v1.x+dx1;
            immutable float y1 = v1.y-dy1;
            immutable float x2 = v1.x+dx2;
            immutable float y2 = v1.y-dy2;
            di = (lim-dbevel)/(di-dbevel);
            addVertex(vc, x1+(xi-x1)*di, y1+(yi-y1)*di);
            addVertex(vc, x2+(xi-x2)*di, y2+(yi-y2)*di);
          }
          break;
      }
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
struct Stroker {
public nothrow @trusted @nogc:
  alias VertexStorage = VertexSequence!VertexDist;
  alias CoordStorage = SimpleVector!AGGPoint;

private:
  enum State {
    Initial,
    Ready,
    Cap1,
    Cap2,
    Outline1,
    CloseFirst,
    Outline2,
    OutVertices,
    End_poly1,
    End_poly2,
    Stop,
  }

private:
  StrokeCalc!CoordStorage mStroker;
  VertexStorage mSrcVertices;
  CoordStorage mOutVertices;
  float mShorten = 0;
  uint mClosed = 0;
  State mStatus = State.Initial;
  State mPrevStatus;
  uint mSrcVertex = 0;
  uint mOutVertex = 0;

public:
  mixin(DisableCopyingMixin);

  @property void lineCap (LineCap lc) { pragma(inline, true); mStroker.lineCap(lc); }
  @property void lineJoin (LineJoin lj) { pragma(inline, true); mStroker.lineJoin(lj); }
  @property void innerJoin (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 (float w) { pragma(inline, true); mStroker.width(w); }
  @property void miterLimit (float ml) { pragma(inline, true); mStroker.miterLimit(ml); }
  @property void miterLimitTheta (float t) { pragma(inline, true); mStroker.miterLimitTheta(t); }
  @property void innerMiterLimit (float ml) { pragma(inline, true); mStroker.innerMiterLimit(ml); }
  @property void approximationScale (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(); }

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

  // Generator interface
  void removeAll () {
    mSrcVertices.removeAll();
    mClosed = 0;
    mStatus = State.Initial;
  }

  void addVertex (float x, float y, uint cmd) {
    mStatus = State.Initial;
    if (isMoveTo(cmd)) {
      mSrcVertices.modifyLast(VertexDist(x, y));
    } else {
      if (isVertex(cmd)) {
        mSrcVertices.add(VertexDist(x, y));
      } else {
        mClosed = getCloseFlag(cmd);
      }
    }
  }

  // Vertex Source Interface
  void rewind () {
    if (mStatus == State.Initial) {
      mSrcVertices.close(mClosed != 0);
      shortenPath(mSrcVertices, mShorten, mClosed);
      if (mSrcVertices.length < 3) mClosed = 0;
    }
    mStatus = State.Ready;
    mSrcVertex = 0;
    mOutVertex = 0;
  }

  uint vertex (float* x, float* y) {
    uint cmd = PathCommand.LineTo;
    while (!isStop(cmd)) {
      final switch (mStatus) {
        case State.Initial:
          rewind();
          goto case;

        case State.Ready:
          if (mSrcVertices.length < 2+cast(uint)(mClosed != 0)) {
            cmd = PathCommand.Stop;
            break;
          }
          mStatus = (mClosed ? State.Outline1 : State.Cap1);
          cmd = PathCommand.MoveTo;
          mSrcVertex = 0;
          mOutVertex = 0;
          break;

        case State.Cap1:
          mStroker.calcCap(mOutVertices, mSrcVertices[0], mSrcVertices[1], mSrcVertices[0].dist);
          mSrcVertex = 1;
          mPrevStatus = State.Outline1;
          mStatus = State.OutVertices;
          mOutVertex = 0;
          break;

        case State.Cap2:
          mStroker.calcCap(mOutVertices, mSrcVertices[mSrcVertices.length-1], mSrcVertices[mSrcVertices.length-2], mSrcVertices[mSrcVertices.length-2].dist);
          mPrevStatus = State.Outline2;
          mStatus = State.OutVertices;
          mOutVertex = 0;
          break;

        case State.Outline1:
          if (mClosed) {
            if (mSrcVertex >= mSrcVertices.length) {
              mPrevStatus = State.CloseFirst;
              mStatus = State.End_poly1;
              break;
            }
          } else {
            if (mSrcVertex >= mSrcVertices.length-1) {
              mStatus = State.Cap2;
              break;
            }
          }
          mStroker.calcJoin(mOutVertices, mSrcVertices.prev(mSrcVertex), mSrcVertices.curr(mSrcVertex), mSrcVertices.next(mSrcVertex), mSrcVertices.prev(mSrcVertex).dist, mSrcVertices.curr(mSrcVertex).dist);
          ++mSrcVertex;
          mPrevStatus = mStatus;
          mStatus = State.OutVertices;
          mOutVertex = 0;
          break;

        case State.CloseFirst:
          mStatus = State.Outline2;
          cmd = PathCommand.MoveTo;
          goto case;

        case State.Outline2:
          if (mSrcVertex <= uint(mClosed == 0)) {
            mStatus = State.End_poly2;
            mPrevStatus = State.Stop;
            break;
          }

          --mSrcVertex;
          mStroker.calcJoin(mOutVertices, mSrcVertices.next(mSrcVertex), mSrcVertices.curr(mSrcVertex), mSrcVertices.prev(mSrcVertex), mSrcVertices.curr(mSrcVertex).dist, mSrcVertices.prev(mSrcVertex).dist);

          mPrevStatus = mStatus;
          mStatus = State.OutVertices;
          mOutVertex = 0;
          break;

        case State.OutVertices:
          if (mOutVertex >= mOutVertices.length) {
            mStatus = mPrevStatus;
          } else {
            const(AGGPoint)* c = &mOutVertices[mOutVertex++];
            *x = c.x;
            *y = c.y;
            return cmd;
          }
          break;

        case State.End_poly1:
          mStatus = mPrevStatus;
          return PathCommand.EndPoly|PathFlag.Close|PathFlag.CCW;

        case State.End_poly2:
          mStatus = mPrevStatus;
          return PathCommand.EndPoly|PathFlag.Close|PathFlag.CW;

        case State.Stop:
          cmd = PathCommand.Stop;
          break;
      }
    }
    return cmd;
  }
}


// ////////////////////////////////////////////////////////////////////////// //
struct Contourer {
public nothrow @trusted @nogc:
  alias VertexStorage = VertexSequence!VertexDist;
  alias CoordStorage = SimpleVector!AGGPoint;

  enum State {
    Initial,
    Ready,
    Outline,
    OutVertices,
    EndPoly,
    Stop,
  }

private:
  StrokeCalc!CoordStorage mStroker;
  float mWidth = 1;
  VertexStorage mSrcVertices;
  CoordStorage mOutVertices;
  State mStatus;
  uint mSrcVertex = 0;
  uint mOutVertex;
  uint mClosed = 0;
  uint mOrientation = 0;
  bool mAutoDetect = false;

public:
  mixin(DisableCopyingMixin);

  @property void lineCap (LineCap lc) { pragma(inline, true); mStroker.lineCap(lc); }
  @property void lineJoin (LineJoin lj) { pragma(inline, true); mStroker.lineJoin(lj); }
  @property void innerJoin (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 (float w) { pragma(inline, true); mStroker.width(mWidth = w); }
  @property void miterLimit (float ml) { pragma(inline, true); mStroker.miterLimit(ml); }
  @property void miterLimitTheta (float t) { pragma(inline, true); mStroker.miterLimitTheta(t); }
  @property void innerMiterLimit (float ml) { pragma(inline, true); mStroker.innerMiterLimit(ml); }
  @property void approximationScale (float as) { pragma(inline, true); mStroker.approximationScale(as); }

  @property float width () const pure { pragma(inline, true); return mWidth; }
  @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(); }

  @property void autoDetectOrientation (bool v) { pragma(inline, true); mAutoDetect = v; }
  @property bool autoDetectOrientation () const pure { pragma(inline, true); return mAutoDetect; }

  // Generator interface
  void removeAll () {
    mSrcVertices.removeAll();
    mClosed = 0;
    mOrientation = 0;
    mStatus = State.Initial;
  }

  void addVertex (float x, float y, uint cmd) {
    mStatus = State.Initial;
    if (isMoveTo(cmd)) {
      mSrcVertices.modifyLast(VertexDist(x, y));
    } else {
      if (isVertex(cmd)) {
        mSrcVertices.add(VertexDist(x, y));
      } else {
        if (isEndPoly(cmd)) {
          mClosed = getCloseFlag(cmd);
          if (mOrientation == PathFlag.None) {
            mOrientation = getOrientation(cmd);
          }
        }
      }
    }
  }

  // Vertex Source Interface
  void rewind () {
    if (mStatus == State.Initial) {
      mSrcVertices.close(true);
      if (mAutoDetect) {
        if (!isOriented(mOrientation)) {
          mOrientation = (calcPolygonArea(mSrcVertices) > 0 ? PathFlag.CCW : PathFlag.CW);
        }
      }
      if (isOriented(mOrientation)) {
        mStroker.width(isCCW(mOrientation) ? mWidth : -mWidth);
      }
    }
    mStatus = State.Ready;
    mSrcVertex = 0;
  }

  uint vertex (float* x, float* y) {
    uint cmd = PathCommand.LineTo;
    while (!isStop(cmd)) {
      final switch (mStatus) {
        case State.Initial:
          rewind();
          goto case;

        case State.Ready:
          if (mSrcVertices.length < 2+cast(uint)(mClosed != 0)) {
            cmd = PathCommand.Stop;
            break;
          }
          mStatus = State.Outline;
          cmd = PathCommand.MoveTo;
          mSrcVertex = 0;
          mOutVertex = 0;
          goto case;

        case State.Outline:
          if (mSrcVertex >= mSrcVertices.length) {
            mStatus = State.EndPoly;
            break;
          }
          mStroker.calcJoin(mOutVertices, mSrcVertices.prev(mSrcVertex), mSrcVertices.curr(mSrcVertex), mSrcVertices.next(mSrcVertex), mSrcVertices.prev(mSrcVertex).dist, mSrcVertices.curr(mSrcVertex).dist);
          ++mSrcVertex;
          mStatus = State.OutVertices;
          mOutVertex = 0;
          goto case;

        case State.OutVertices:
          if (mOutVertex >= mOutVertices.length) {
            mStatus = State.Outline;
          } else {
            const(AGGPoint)* c = &mOutVertices[mOutVertex++];
            *x = c.x;
            *y = c.y;
            return cmd;
          }
          break;

        case State.EndPoly:
          if (!mClosed) return PathCommand.Stop;
          mStatus = State.Stop;
          return PathCommand.EndPoly|PathFlag.Close|PathFlag.CCW;

        case State.Stop:
          return PathCommand.Stop;
      }
    }
    return cmd;
  }
}


// ////////////////////////////////////////////////////////////////////////// //
struct Dasher {
private nothrow @trusted @nogc:
  alias VertexStorage = VertexSequence!VertexDist;
  enum MaxDashes = 32;

  enum State {
    Initial,
    Ready,
    Polyline,
    Stop,
  }

private:
  float[MaxDashes] mDashes = 0;
  float mTotalDashLen = 0;
  uint mNumDashes = 0;
  float mDashStart = 0;
  float mShorten = 0;
  float mCurrDashStart = 0;
  uint mCurrDash = 0;
  float mCurrRest = 0;
  const(VertexDist)* m_v1 = null;
  const(VertexDist)* m_v2 = null;

  VertexStorage mSrcVertices;
  uint mClosed = 0;
  State mStatus = State.Initial;
  uint mSrcVertex = 0;

public:
  mixin(DisableCopyingMixin);

  @property void shorten (float s) { mShorten = s; }
  @property float shorten () const pure { return mShorten; }

  void removeAllDashes () {
    mTotalDashLen = 0;
    mNumDashes = 0;
    mCurrDashStart = 0;
    mCurrDash = 0;
  }

  void addDash (float dashLen, float gapLen) {
    if (mNumDashes < MaxDashes) {
      mTotalDashLen += dashLen+gapLen;
      mDashes[mNumDashes++] = dashLen;
      mDashes[mNumDashes++] = gapLen;
    }
  }

  void dashStart (float ds) {
    //import std.math : abs;
    import core.stdc.math : fabsf;
    mDashStart = ds;
    calcDashStart(fabsf(ds));
  }

  // Vertex Generator Interface
  void removeAll () {
    mStatus = State.Initial;
    mSrcVertices.removeAll();
    mClosed = 0;
  }

  void addVertex (float x, float y, uint cmd) {
    mStatus = State.Initial;
    if (isMoveTo(cmd)) {
      mSrcVertices.modifyLast(VertexDist(x, y));
    } else {
      if (isVertex(cmd)) {
        mSrcVertices.add(VertexDist(x, y));
      } else {
        mClosed = getCloseFlag(cmd);
      }
    }
  }

  // Vertex Source Interface
  void rewind () {
    if (mStatus == State.Initial) {
      mSrcVertices.close(mClosed != 0);
      shortenPath(mSrcVertices, mShorten, mClosed);
    }
    mStatus = State.Ready;
    mSrcVertex = 0;
  }

  uint vertex (float* x, float* y) {
    uint cmd = PathCommand.MoveTo;

    while (!isStop(cmd)) {
      final switch (mStatus) {
        case State.Initial:
          rewind();
          goto case;

        case State.Ready:
          if (mNumDashes < 2 || mSrcVertices.length < 2) {
            cmd = PathCommand.Stop;
            break;
          }
          mStatus = State.Polyline;
          mSrcVertex = 1;
          m_v1 = &mSrcVertices[0];
          m_v2 = &mSrcVertices[1];
          mCurrRest = m_v1.dist;
          *x = m_v1.x;
          *y = m_v1.y;
          if (mDashStart >= 0) calcDashStart(mDashStart);
          return PathCommand.MoveTo;

        case State.Polyline:
          immutable float dashRest = mDashes[mCurrDash]-mCurrDashStart;
          cmd = (mCurrDash&1 ? PathCommand.MoveTo : PathCommand.LineTo);
          if (mCurrRest > dashRest) {
            mCurrRest -= dashRest;
            ++mCurrDash;
            if (mCurrDash >= mNumDashes) mCurrDash = 0;
            mCurrDashStart = 0;
            *x = m_v2.x-(m_v2.x-m_v1.x)*mCurrRest/m_v1.dist;
            *y = m_v2.y-(m_v2.y-m_v1.y)*mCurrRest/m_v1.dist;
          } else {
            mCurrDashStart += mCurrRest;
            *x = m_v2.x;
            *y = m_v2.y;
            ++mSrcVertex;
            m_v1 = m_v2;
            mCurrRest = m_v1.dist;
            if (mClosed) {
              if (mSrcVertex > mSrcVertices.length) {
                mStatus = State.Stop;
              } else {
                m_v2 = &mSrcVertices[mSrcVertex >= mSrcVertices.length ? 0 :mSrcVertex];
              }
            } else {
              if (mSrcVertex >= mSrcVertices.length) {
                mStatus = State.Stop;
              } else {
                m_v2 = &mSrcVertices[mSrcVertex];
              }
            }
          }
          return cmd;

        case State.Stop:
          cmd = PathCommand.Stop;
          break;
      }
    }
    return PathCommand.Stop;
  }

private:
  void calcDashStart (float ds) {
    mCurrDash = 0;
    mCurrDashStart = 0;
    while (ds > 0) {
      if (ds > mDashes[mCurrDash]) {
        ds -= mDashes[mCurrDash];
        ++mCurrDash;
        mCurrDashStart = 0;
        if (mCurrDash >= mNumDashes) mCurrDash = 0;
      } else {
        mCurrDashStart = ds;
        ds = 0;
      }
    }
  }
}


// ////////////////////////////////////////////////////////////////////////// //
// Matrices and Transformations

// matrix class
public align(1) struct AGGMatrix {
align(1):
private:
  static immutable float[6] IdentityMat = [
    1.0f, 0.0f,
    0.0f, 1.0f,
    0.0f, 0.0f,
  ];

public:
  /// Matrix values. Initial value is identity matrix.
  float[6] mat = [
    1.0f, 0.0f,
    0.0f, 1.0f,
    0.0f, 0.0f,
  ];

public nothrow @trusted @nogc:
  /// Create Matrix with the given values.
  this (const(float)[] amat...) {
    pragma(inline, true);
    if (amat.length >= 6) {
      mat.ptr[0..6] = amat.ptr[0..6];
    } else {
      mat.ptr[0..6] = 0.0f;
      mat.ptr[0..amat.length] = amat[];
    }
  }

  /// Can be used to check validity of [inverted] result
  @property bool valid () const { import core.stdc.math : isfinite; return (isfinite(mat.ptr[0]) != 0); }

  /// Returns `true` if this matrix is identity matrix.
  @property bool isIdentity () const { version(aliced) pragma(inline, true); return (mat[] == IdentityMat[]); }

  /// Returns new inverse matrix.
  /// If inverted matrix cannot be calculated, `res.valid` fill be `false`.
  AGGMatrix inverted () const {
    AGGMatrix res = this;
    res.invert;
    return res;
  }

  /// Inverts this matrix.
  /// If inverted matrix cannot be calculated, `this.valid` fill be `false`.
  ref AGGMatrix invert () {
    float[6] inv = void;
    immutable double det = cast(double)mat.ptr[0]*mat.ptr[3]-cast(double)mat.ptr[2]*mat.ptr[1];
    if (det > -1e-6 && det < 1e-6) {
      inv[] = float.nan;
    } else {
      immutable double invdet = 1.0/det;
      inv.ptr[0] = cast(float)(mat.ptr[3]*invdet);
      inv.ptr[2] = cast(float)(-mat.ptr[2]*invdet);
      inv.ptr[4] = cast(float)((cast(double)mat.ptr[2]*mat.ptr[5]-cast(double)mat.ptr[3]*mat.ptr[4])*invdet);
      inv.ptr[1] = cast(float)(-mat.ptr[1]*invdet);
      inv.ptr[3] = cast(float)(mat.ptr[0]*invdet);
      inv.ptr[5] = cast(float)((cast(double)mat.ptr[1]*mat.ptr[4]-cast(double)mat.ptr[0]*mat.ptr[5])*invdet);
    }
    mat.ptr[0..6] = inv.ptr[0..6];
    return this;
  }

  /// Sets this matrix to identity matrix.
  ref AGGMatrix identity () { version(aliced) pragma(inline, true); mat[] = IdentityMat[]; return this; }

  /// Translate this matrix.
  ref AGGMatrix translate (in float tx, in float ty) {
    version(aliced) pragma(inline, true);
    return this.mul(Translated(tx, ty));
  }

  /// Scale this matrix.
  ref AGGMatrix scale (in float sx, in float sy) {
    version(aliced) pragma(inline, true);
    return this.mul(Scaled(sx, sy));
  }

  /// Rotate this matrix.
  ref AGGMatrix rotate (in float a) {
    version(aliced) pragma(inline, true);
    return this.mul(Rotated(a));
  }

  /// Skew this matrix by X axis.
  ref AGGMatrix skewX (in float a) {
    version(aliced) pragma(inline, true);
    return this.mul(SkewedX(a));
  }

  /// Skew this matrix by Y axis.
  ref AGGMatrix skewY (in float a) {
    version(aliced) pragma(inline, true);
    return this.mul(SkewedY(a));
  }

  /// Skew this matrix by both axes.
  ref AGGMatrix skewY (in float ax, in float ay) {
    version(aliced) pragma(inline, true);
    return this.mul(SkewedXY(ax, ay));
  }

  /// Transform point with this matrix. `null` destinations are allowed.
  /// [sx] and [sy] is the source point. [dx] and [dy] may point to the same variables.
  void point (float* dx, float* dy, float sx, float sy) {
    version(aliced) pragma(inline, true);
    if (dx !is null) *dx = sx*mat.ptr[0]+sy*mat.ptr[2]+mat.ptr[4];
    if (dy !is null) *dy = sx*mat.ptr[1]+sy*mat.ptr[3]+mat.ptr[5];
  }

  /// Transform point with this matrix.
  void point (ref float x, ref float y) {
    version(aliced) pragma(inline, true);
    immutable float nx = x*mat.ptr[0]+y*mat.ptr[2]+mat.ptr[4];
    immutable float ny = x*mat.ptr[1]+y*mat.ptr[3]+mat.ptr[5];
    x = nx;
    y = ny;
  }

  /// Sets this matrix to the result of multiplication of `this` and [s] (this * S).
  ref AGGMatrix mul() (in auto ref AGGMatrix s) {
    immutable float t0 = mat.ptr[0]*s.mat.ptr[0]+mat.ptr[1]*s.mat.ptr[2];
    immutable float t2 = mat.ptr[2]*s.mat.ptr[0]+mat.ptr[3]*s.mat.ptr[2];
    immutable float t4 = mat.ptr[4]*s.mat.ptr[0]+mat.ptr[5]*s.mat.ptr[2]+s.mat.ptr[4];
    mat.ptr[1] = mat.ptr[0]*s.mat.ptr[1]+mat.ptr[1]*s.mat.ptr[3];
    mat.ptr[3] = mat.ptr[2]*s.mat.ptr[1]+mat.ptr[3]*s.mat.ptr[3];
    mat.ptr[5] = mat.ptr[4]*s.mat.ptr[1]+mat.ptr[5]*s.mat.ptr[3]+s.mat.ptr[5];
    mat.ptr[0] = t0;
    mat.ptr[2] = t2;
    mat.ptr[4] = t4;
    return this;
  }

  /// Sets this matrix to the result of multiplication of [s] and `this` (S * this).
  /// Sets the transform to the result of multiplication of two transforms, of A = B*A.
  /// Group: matrices
  ref AGGMatrix premul() (in auto ref AGGMatrix s) {
    AGGMatrix s2 = s;
    s2.mul(this);
    mat[] = s2.mat[];
    return this;
  }

  /// Multiply this matrix by [s], return result as new matrix.
  /// Performs operations in this left-to-right order.
  AGGMatrix opBinary(string op="*") (in auto ref AGGMatrix s) const {
    version(aliced) pragma(inline, true);
    AGGMatrix res = this;
    res.mul(s);
    return res;
  }

  /// Multiply this matrix by [s].
  /// Performs operations in this left-to-right order.
  ref AGGMatrix opOpAssign(string op="*") (in auto ref AGGMatrix s) {
    version(aliced) pragma(inline, true);
    return this.mul(s);
  }

  float scaleX () const { pragma(inline, true); import core.stdc.math : sqrtf; return sqrtf(mat.ptr[0]*mat.ptr[0]+mat.ptr[2]*mat.ptr[2]); } /// Returns x scaling of this matrix.
  float scaleY () const { pragma(inline, true); import core.stdc.math : sqrtf; return sqrtf(mat.ptr[1]*mat.ptr[1]+mat.ptr[3]*mat.ptr[3]); } /// Returns y scaling of this matrix.
  float rotation () const { pragma(inline, true); import core.stdc.math : atan2f; return atan2f(mat.ptr[1], mat.ptr[0]); } /// Returns rotation of this matrix.
  float tx () const { pragma(inline, true); return mat.ptr[4]; } /// Returns x translation of this matrix.
  float ty () const { pragma(inline, true); return mat.ptr[5]; } /// Returns y translation of this matrix.

  ref AGGMatrix scaleX (in float v) { pragma(inline, true); return scaleRotateTransform(v, scaleY, rotation, tx, ty); } /// Sets x scaling of this matrix.
  ref AGGMatrix scaleY (in float v) { pragma(inline, true); return scaleRotateTransform(scaleX, v, rotation, tx, ty); } /// Sets y scaling of this matrix.
  ref AGGMatrix rotation (in float v) { pragma(inline, true); return scaleRotateTransform(scaleX, scaleY, v, tx, ty); } /// Sets rotation of this matrix.
  ref AGGMatrix tx (in float v) { pragma(inline, true); mat.ptr[4] = v; return this; } /// Sets x translation of this matrix.
  ref AGGMatrix ty (in float v) { pragma(inline, true); mat.ptr[5] = v; return this; } /// Sets y translation of this matrix.

  /// Utility function to be used in `setXXX()`.
  /// This is the same as doing: `mat.identity.rotate(a).scale(xs, ys).translate(tx, ty)`, only faster
  ref AGGMatrix scaleRotateTransform (in float xscale, in float yscale, in float a, in float tx, in float ty) {
    import core.stdc.math : sinf, cosf;
    immutable float cs = cosf(a), sn = sinf(a);
    mat.ptr[0] = xscale*cs; mat.ptr[1] = yscale*sn;
    mat.ptr[2] = xscale*-sn; mat.ptr[3] = yscale*cs;
    mat.ptr[4] = tx; mat.ptr[5] = ty;
    return this;
  }

  /// This is the same as doing: `mat.identity.rotate(a).translate(tx, ty)`, only faster
  ref AGGMatrix rotateTransform (in float a, in float tx, in float ty) {
    import core.stdc.math : sinf, cosf;
    immutable float cs = cosf(a), sn = sinf(a);
    mat.ptr[0] = cs; mat.ptr[1] = sn;
    mat.ptr[2] = -sn; mat.ptr[3] = cs;
    mat.ptr[4] = tx; mat.ptr[5] = ty;
    return this;
  }

  /// Returns new identity matrix.
  static AGGMatrix Identity () { pragma(inline, true); return AGGMatrix.init; }

  /// Returns new translation matrix.
  static AGGMatrix Translated (in float tx, in float ty) {
    version(aliced) pragma(inline, true);
    AGGMatrix res = void;
    res.mat.ptr[0] = 1.0f; res.mat.ptr[1] = 0.0f;
    res.mat.ptr[2] = 0.0f; res.mat.ptr[3] = 1.0f;
    res.mat.ptr[4] = tx; res.mat.ptr[5] = ty;
    return res;
  }

  /// Returns new scaling matrix.
  static AGGMatrix Scaled (in float sx, in float sy) {
    version(aliced) pragma(inline, true);
    AGGMatrix res = void;
    res.mat.ptr[0] = sx; res.mat.ptr[1] = 0.0f;
    res.mat.ptr[2] = 0.0f; res.mat.ptr[3] = sy;
    res.mat.ptr[4] = 0.0f; res.mat.ptr[5] = 0.0f;
    return res;
  }

  /// Returns new rotation matrix. Angle is specified in radians.
  static AGGMatrix Rotated (in float a) {
    version(aliced) pragma(inline, true);
    import core.stdc.math : sinf, cosf;
    immutable float cs = cosf(a), sn = sinf(a);
    AGGMatrix res = void;
    res.mat.ptr[0] = cs; res.mat.ptr[1] = sn;
    res.mat.ptr[2] = -sn; res.mat.ptr[3] = cs;
    res.mat.ptr[4] = 0.0f; res.mat.ptr[5] = 0.0f;
    return res;
  }

  /// Returns new x-skewing matrix. Angle is specified in radians.
  static AGGMatrix SkewedX (in float a) {
    version(aliced) pragma(inline, true);
    import core.stdc.math : tanf;
    AGGMatrix res = void;
    res.mat.ptr[0] = 1.0f; res.mat.ptr[1] = 0.0f;
    res.mat.ptr[2] = tanf(a); res.mat.ptr[3] = 1.0f;
    res.mat.ptr[4] = 0.0f; res.mat.ptr[5] = 0.0f;
    return res;
  }

  /// Returns new y-skewing matrix. Angle is specified in radians.
  static AGGMatrix SkewedY (in float a) {
    version(aliced) pragma(inline, true);
    import core.stdc.math : tanf;
    AGGMatrix res = void;
    res.mat.ptr[0] = 1.0f; res.mat.ptr[1] = tanf(a);
    res.mat.ptr[2] = 0.0f; res.mat.ptr[3] = 1.0f;
    res.mat.ptr[4] = 0.0f; res.mat.ptr[5] = 0.0f;
    return res;
  }

  /// Returns new xy-skewing matrix. Angles are specified in radians.
  static AGGMatrix SkewedXY (in float ax, in float ay) {
    version(aliced) pragma(inline, true);
    import core.stdc.math : tanf;
    AGGMatrix res = void;
    res.mat.ptr[0] = 1.0f; res.mat.ptr[1] = tanf(ay);
    res.mat.ptr[2] = tanf(ax); res.mat.ptr[3] = 1.0f;
    res.mat.ptr[4] = 0.0f; res.mat.ptr[5] = 0.0f;
    return res;
  }

  /// Utility function to be used in `setXXX()`.
  /// This is the same as doing: `AGGMatrix.Identity.rotate(a).scale(xs, ys).translate(tx, ty)`, only faster
  static AGGMatrix ScaledRotatedTransformed (in float xscale, in float yscale, in float a, in float tx, in float ty) {
    AGGMatrix res = void;
    res.scaleRotateTransform(xscale, yscale, a, tx, ty);
    return res;
  }

  /// This is the same as doing: `AGGMatrix.Identity.rotate(a).translate(tx, ty)`, only faster
  static AGGMatrix RotatedTransformed (in float a, in float tx, in float ty) {
    AGGMatrix res = void;
    res.rotateTransform(a, tx, ty);
    return res;
  }

public:
  // premultiplies current coordinate system by specified matrix
  ref AGGMatrix transform() (in auto ref AGGMatrix mt) { pragma(inline, true); this *= mt; return this; }

  // translates current coordinate system
  ref AGGMatrix translatePre (in float x, in float y) { pragma(inline, true); return premul(AGGMatrix.Translated(x, y)); }

  // rotates current coordinate system; angle is specified in radians
  ref AGGMatrix rotatePre (in float angle) { pragma(inline, true); return premul(AGGMatrix.Rotated(angle)); }

  // skews the current coordinate system along X axis; angle is specified in radians
  ref AGGMatrix skewXPre (in float angle) { pragma(inline, true); return premul(AGGMatrix.SkewedX(angle)); }

  // skews the current coordinate system along Y axis; angle is specified in radians
  ref AGGMatrix skewYPre (in float angle) { pragma(inline, true); return premul(AGGMatrix.SkewedY(angle)); }

  // scales the current coordinate system
  ref AGGMatrix scalePre (in float x, in float y) { pragma(inline, true); return premul(AGGMatrix.Scaled(x, y)); }
}