Bug fix.
Switch to resizing at a coarser granularity.
Instrument individual passes to isolate where time is going.
Attempting to prevent such frequent bailout.

Dropping Math.min (and instead doing inline comparison and
reassignment) seemed like most important change here to make code stop
bailing out from ParallelDo.
A quick note
Fix semantic bug; the sequential version was not doing the resize properly.
Help the JIT + ParallelArray analysis have a better shot at optimizing the code.

  1. Lifted 'buf.data' access out from expression 'buf.data[i]'
     because 'buf.data' is a DOM access and thus cannot be compiled
     into a ParallelArray kernel.

  2. Lifted relative-array access ePAs[y-1] out into a dedicated
     variable `above`, so that the JIT has a better chance to
     inferring the access of `above.get(x)` (== `ePAs[y-1].get(x)`) is
     always to a ParallelArray.
Trim empty zeroth elem off instrumentation array to refine output.
Added another alternative (and much smaller) input file for when I am instrumenting JIT.
Trim empty zeroth elem off instrumentation in sequential code to match dp code.
Various changes to try to get performance results to be competitive.

I took out some branching in an attempt to eliminate bailouts (mostly
when I was just guessing at what might be wrong).  But the crucial
thing was making the functions monomorphic by "cloning them" (here, by
the brute-force method of cut-and-paste and renaming the clones, and
then making each callsite call a distinct clone).

The necessity of doing this in the first place is quite disappointing,
but I think we are in discussions to try to improve matters, so
hopefully this sort of hack will not be necessary in the future.
Revised instrumentation; just present the accumulated time for each pass.