summaryrefslogtreecommitdiff
path: root/Build/source/utils/asymptote/runtime.cc
diff options
context:
space:
mode:
authorKarl Berry <karl@freefriends.org>2009-05-16 00:19:13 +0000
committerKarl Berry <karl@freefriends.org>2009-05-16 00:19:13 +0000
commitbab45528d65eaafe68a705dbb2a57075c7b7cbd8 (patch)
tree10b4ae2b5195c8dede153ab89359ec00f55f325f /Build/source/utils/asymptote/runtime.cc
parent8643d90372e9c31e0f461c15c596b60a545bd7d3 (diff)
asymptote 1.72 sources (not integrated into build yet)
git-svn-id: svn://tug.org/texlive/trunk@13110 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/utils/asymptote/runtime.cc')
-rw-r--r--Build/source/utils/asymptote/runtime.cc9027
1 files changed, 9027 insertions, 0 deletions
diff --git a/Build/source/utils/asymptote/runtime.cc b/Build/source/utils/asymptote/runtime.cc
new file mode 100644
index 00000000000..90b78b7302c
--- /dev/null
+++ b/Build/source/utils/asymptote/runtime.cc
@@ -0,0 +1,9027 @@
+/***** Autogenerated from runtime.in; changes will be overwritten *****/
+
+#line 1 "runtime.in"
+/*****
+ * runtime.in
+ * Tom Prince 2005/4/15
+ *
+ * Generate the runtime functions used by the vm::stack machine.
+ *
+ *****/
+
+/* Autogenerated routines are specified like this (separated by a formfeed):
+ type asyname:cname(cparams)
+ {
+ C code
+ }
+
+*/
+
+// Use Void f() instead of void f() to force an explicit Stack argument.
+
+
+#line 63 "runtime.in"
+#include <cfloat>
+#include <time.h>
+#include <sys/times.h>
+#include <locale.h>
+
+#include "angle.h"
+#include "pair.h"
+#include "triple.h"
+#include "transform.h"
+#include "path.h"
+#include "path3.h"
+#include "pen.h"
+#include "guide.h"
+#include "picture.h"
+#include "drawpath.h"
+#include "drawpath3.h"
+#include "drawsurface.h"
+#include "drawfill.h"
+#include "drawclipbegin.h"
+#include "drawclipend.h"
+#include "drawlabel.h"
+#include "drawverbatim.h"
+#include "drawgsave.h"
+#include "drawgrestore.h"
+#include "drawlayer.h"
+#include "drawimage.h"
+#include "drawgroup.h"
+#include "fileio.h"
+#include "genv.h"
+#include "builtin.h"
+#include "texfile.h"
+#include "pipestream.h"
+#include "parser.h"
+#include "stack.h"
+#include "util.h"
+#include "locate.h"
+#include "mathop.h"
+#include "callable.h"
+#include "stm.h"
+#include "lexical.h"
+#include "process.h"
+#include "arrayop.h"
+#include "predicates.h"
+#include "Delaunay.h"
+
+#ifdef HAVE_LIBFFTW3
+#include "fftw++.h"
+#endif
+
+#if defined(HAVE_LIBREADLINE) && defined(HAVE_LIBCURSES)
+#include <readline/readline.h>
+#include <readline/history.h>
+#endif
+
+#if defined(USEGC) && defined(GC_DEBUG) && defined(GC_BACKTRACE)
+ extern "C" {
+ void *GC_generate_random_valid_address(void);
+ void GC_debug_print_heap_obj_proc(void *);
+ }
+#endif
+
+using namespace vm;
+using namespace camp;
+using namespace settings;
+
+namespace run {
+using camp::pair;
+using vm::array;
+using vm::frame;
+using vm::stack;
+using camp::transform;
+using absyntax::runnable;
+
+typedef double real;
+
+#define CURRENTPEN processData().currentpen
+
+typedef array boolarray;
+typedef array Intarray;
+typedef array Intarray2;
+typedef array realarray;
+typedef array realarray2;
+typedef array pairarray;
+typedef array pairarray2;
+typedef array triplearray;
+typedef array triplearray2;
+typedef array patharray;
+typedef array patharray2;
+typedef array guidearray;
+typedef array transformarray;
+typedef array penarray;
+typedef array penarray2;
+typedef array stringarray;
+typedef array stringarray2;
+
+typedef callable callableBp;
+typedef callable callableReal;
+typedef callable callableTransform;
+}
+
+using vm::array;
+using types::function;
+
+#define PRIMITIVE(name,Name,asyName) using types::prim##Name;
+#include <primitives.h>
+#undef PRIMITIVE
+
+using types::boolArray;
+using types::IntArray;
+using types::IntArray2;
+using types::realArray;
+using types::realArray2;
+using types::pairArray;
+using types::pairArray2;
+using types::tripleArray;
+using types::tripleArray2;
+using types::pathArray;
+using types::pathArray2;
+using types::guideArray;
+using types::transformArray;
+using types::penArray;
+using types::penArray2;
+using types::stringArray;
+using types::stringArray2;
+using types::formal;
+
+function *voidFunction()
+{
+ return new function(primVoid());
+}
+
+function *breakpointFunction()
+{
+ return new function(primString(),primString(),primInt(),primInt(),
+ primCode());
+}
+
+function *realRealFunction()
+{
+ return new function(primReal(),primReal());
+}
+
+function *transformFunction()
+{
+ return new function(primTransform());
+}
+
+function *realTripleFunction()
+{
+ return new function(primReal(),primTriple());
+}
+
+const size_t camp::ColorComponents[]={0,0,1,3,4,0};
+
+namespace vm {
+}
+
+namespace run {
+
+const char *invalidargument="invalid argument";
+const char *arrayempty="cannot take min or max of empty array";
+
+// Return the factorial of a non-negative integer using a lookup table.
+Int factorial(Int n)
+{
+ static Int *table;
+ static Int size=0;
+ if(size == 0) {
+ Int f=1;
+ size=2;
+ while(f <= Int_MAX/size)
+ f *= (size++);
+ table=new Int[size];
+ table[0]=f=1;
+ for(Int i=1; i < size; ++i) {
+ f *= i;
+ table[i]=f;
+ }
+ }
+ if(n >= size) integeroverflow(0);
+ return table[n];
+}
+
+static inline Int Round(double x)
+{
+ return Int(x+((x >= 0) ? 0.5 : -0.5));
+}
+
+inline Int sgn(double x)
+{
+ return (x > 0.0 ? 1 : (x < 0.0 ? -1 : 0));
+}
+
+void outOfBounds(const char *op, size_t len, Int n)
+{
+ ostringstream buf;
+ buf << op << " array of length " << len << " with out-of-bounds index " << n;
+ error(buf);
+}
+
+inline item& arrayRead(array *a, Int n)
+{
+ size_t len=checkArray(a);
+ bool cyclic=a->cyclic();
+ if(cyclic && len > 0) n=imod(n,len);
+ else if(n < 0 || n >= (Int) len) outOfBounds("reading",len,n);
+ return (*a)[(unsigned) n];
+}
+
+// Helper function to create deep arrays.
+static array* deepArray(Int depth, Int *dims)
+{
+ assert(depth > 0);
+
+ if (depth == 1) {
+ return new array(dims[0]);
+ } else {
+ Int length = dims[0];
+ depth--; dims++;
+
+ array *a = new array(length);
+
+ for (Int index = 0; index < length; index++) {
+ (*a)[index] = deepArray(depth, dims);
+ }
+ return a;
+ }
+}
+
+array *nop(array *a)
+{
+ return a;
+}
+
+array *Identity(Int n)
+{
+ size_t N=(size_t) n;
+ array *c=new array(N);
+ for(size_t i=0; i < N; ++i) {
+ array *ci=new array(N);
+ (*c)[i]=ci;
+ for(size_t j=0; j < N; ++j)
+ (*ci)[j]=0.0;
+ (*ci)[i]=1.0;
+ }
+ return c;
+}
+
+array *copyArray(array *a)
+{
+ size_t size=checkArray(a);
+ array *c=new array(size);
+ for(size_t i=0; i < size; i++)
+ (*c)[i]=(*a)[i];
+ return c;
+}
+
+inline size_t checkdimension(array *a, size_t dim)
+{
+ size_t size=checkArray(a);
+ if(dim && size != dim) {
+ ostringstream buf;
+ buf << "array of length " << dim << " expected" << endl;
+ error(buf);
+ }
+ return size;
+}
+
+double *copyArrayC(array *a, size_t dim=0)
+{
+ size_t size=checkdimension(a,dim);
+ double *c=new double[size];
+ for(size_t i=0; i < size; i++)
+ c[i]=read<double>(a,i);
+ return c;
+}
+
+triple *copyTripleArrayC(array *a, size_t dim=0)
+{
+ size_t size=checkdimension(a,dim);
+ triple *c=new triple[size];
+ for(size_t i=0; i < size; i++)
+ c[i]=read<triple>(a,i);
+ return c;
+}
+
+array *copyArray2(array *a)
+{
+ size_t size=checkArray(a);
+ array *c=new array(size);
+ for(size_t i=0; i < size; i++) {
+ array *ai=read<array*>(a,i);
+ size_t aisize=checkArray(ai);
+ array *ci=new array(aisize);
+ (*c)[i]=ci;
+ for(size_t j=0; j < aisize; j++)
+ (*ci)[j]=(*ai)[j];
+ }
+ return c;
+}
+
+array *copyArray3(array *a)
+{
+ size_t size=checkArray(a);
+ array *c=new array(size);
+ for(size_t i=0; i < size; i++) {
+ array *ai=read<array*>(a,i);
+ size_t aisize=checkArray(ai);
+ array *ci=new array(aisize);
+ (*c)[i]=ci;
+ for(size_t j=0; j < aisize; j++) {
+ array *aij=read<array*>(ai,j);
+ size_t aijsize=checkArray(aij);
+ array *cij=new array(aijsize);
+ (*ci)[j]=cij;
+ for(size_t k=0; k < aijsize; k++)
+ (*cij)[k]=(*aij)[k];
+ }
+ }
+ return c;
+}
+
+double *copyArray2C(array *a, bool square=true, size_t dim2=0)
+{
+ size_t n=checkArray(a);
+ size_t m=(square || n == 0) ? n : checkArray(read<array*>(a,0));
+ if(n > 0 && dim2 && m != dim2) {
+ ostringstream buf;
+ buf << "second matrix dimension must be " << dim2 << endl;
+ error(buf);
+ }
+
+ double *c=new double[n*m];
+ for(size_t i=0; i < n; i++) {
+ array *ai=read<array*>(a,i);
+ size_t aisize=checkArray(ai);
+ if(aisize == m) {
+ double *ci=c+i*m;
+ for(size_t j=0; j < m; j++)
+ ci[j]=read<double>(ai,j);
+ } else
+ error(square ? "matrix must be square" : "matrix must be rectangular");
+ }
+ return c;
+}
+
+static const char *incommensurate="Incommensurate matrices";
+static const char *singular="Singular matrix";
+static size_t *pivot,*Row,*Col;
+
+triple operator *(const array& t, const triple& v)
+{
+ size_t n=checkArray(&t);
+ if(n != 4) error(incommensurate);
+ array *t0=read<array*>(t,0);
+ array *t1=read<array*>(t,1);
+ array *t2=read<array*>(t,2);
+ array *t3=read<array*>(t,3);
+
+ if(checkArray(t0) != 4 || checkArray(t1) != 4 ||
+ checkArray(t2) != 4 || checkArray(t3) != 4)
+ error(incommensurate);
+
+ double x=v.getx();
+ double y=v.gety();
+ double z=v.getz();
+
+ double f=read<real>(t3,0)*x+read<real>(t3,1)*y+read<real>(t3,2)*z+
+ read<real>(t3,3);
+ if(f == 0.0) run::dividebyzero();
+ f=1.0/f;
+
+ return triple((read<real>(t0,0)*x+read<real>(t0,1)*y+read<real>(t0,2)*z+
+ read<real>(t0,3))*f,
+ (read<real>(t1,0)*x+read<real>(t1,1)*y+read<real>(t1,2)*z+
+ read<real>(t1,3))*f,
+ (read<real>(t2,0)*x+read<real>(t2,1)*y+read<real>(t2,2)*z+
+ read<real>(t2,3))*f);
+}
+
+triple multshiftless(const array& t, const triple& v)
+{
+ size_t n=checkArray(&t);
+ if(n != 4) error(incommensurate);
+ array *t0=read<array*>(t,0);
+ array *t1=read<array*>(t,1);
+ array *t2=read<array*>(t,2);
+ array *t3=read<array*>(t,3);
+
+ if(checkArray(t0) != 4 || checkArray(t1) != 4 ||
+ checkArray(t2) != 4 || checkArray(t3) != 4)
+ error(incommensurate);
+
+ double x=v.getx();
+ double y=v.gety();
+ double z=v.getz();
+
+ double f=read<real>(t3,0)*x+read<real>(t3,1)*y+read<real>(t3,2)*z+
+ read<real>(t3,3);
+ if(f == 0.0) run::dividebyzero();
+ f=1.0/f;
+
+ return triple((read<real>(t0,0)*x+read<real>(t0,1)*y+read<real>(t0,2)*z)*f,
+ (read<real>(t1,0)*x+read<real>(t1,1)*y+read<real>(t1,2)*z)*f,
+ (read<real>(t2,0)*x+read<real>(t2,1)*y+read<real>(t2,2)*z)*f);
+}
+
+static inline void inverseAllocate(size_t n)
+{
+ pivot=new size_t[n];
+ Row=new size_t[n];
+ Col=new size_t[n];
+}
+
+static inline void inverseDeallocate()
+{
+ delete[] pivot;
+ delete[] Row;
+ delete[] Col;
+}
+
+void writestring(stack *s)
+{
+ callable *suffix=pop<callable *>(s,NULL);
+ string S=pop<string>(s);
+ vm::item it=pop(s);
+ bool defaultfile=isdefault(it);
+ camp::file *f=defaultfile ? &camp::Stdout : vm::get<camp::file*>(it);
+ if(!f->isOpen()) return;
+ if(S != "") f->write(S);
+ if(f->text()) {
+ if(suffix) {
+ s->push(f);
+ suffix->call(s);
+ } else if(defaultfile) f->writeline();
+ }
+}
+
+void checkSquare(array *a)
+{
+ size_t n=checkArray(a);
+ for(size_t i=0; i < n; i++)
+ if(checkArray(read<array*>(a,i)) != n)
+ error("matrix a must be square");
+}
+
+// Crout's algorithm for computing the LU decomposition of a square matrix.
+// cf. routine ludcmp (Press et al., Numerical Recipes, 1991).
+Int LUdecompose(double *a, size_t n, size_t* index, bool warn=true)
+{
+ double *vv=new double[n];
+ Int swap=1;
+ for(size_t i=0; i < n; ++i) {
+ double big=0.0;
+ double *ai=a+i*n;
+ for(size_t j=0; j < n; ++j) {
+ double temp=fabs(ai[j]);
+ if(temp > big) big=temp;
+ }
+ if(big == 0.0) {
+ delete[] vv;
+ if(warn) error(singular);
+ else return 0;
+ }
+ vv[i]=1.0/big;
+ }
+ for(size_t j=0; j < n; ++j) {
+ for(size_t i=0; i < j; ++i) {
+ double *ai=a+i*n;
+ double sum=ai[j];
+ for(size_t k=0; k < i; ++k) {
+ sum -= ai[k]*a[k*n+j];
+ }
+ ai[j]=sum;
+ }
+ double big=0.0;
+ size_t imax=j;
+ for(size_t i=j; i < n; ++i) {
+ double *ai=a+i*n;
+ double sum=ai[j];
+ for(size_t k=0; k < j; ++k)
+ sum -= ai[k]*a[k*n+j];
+ ai[j]=sum;
+ double temp=vv[i]*fabs(sum);
+ if(temp >= big) {
+ big=temp;
+ imax=i;
+ }
+ }
+ double *aj=a+j*n;
+ double *aimax=a+imax*n;
+ if(j != imax) {
+ for(size_t k=0; k < n; ++k) {
+ double temp=aimax[k];
+ aimax[k]=aj[k];
+ aj[k]=temp;
+ }
+ swap *= -1;
+ vv[imax]=vv[j];
+ }
+ if(index)
+ index[j]=imax;
+ if(j != n) {
+ double denom=aj[j];
+ if(denom == 0.0) {
+ delete[] vv;
+ if(warn) error(singular);
+ else return 0;
+ }
+ for(size_t i=j+1; i < n; ++i)
+ a[i*n+j] /= denom;
+ }
+ }
+ delete[] vv;
+ return swap;
+}
+
+void dividebyzero(size_t i)
+{
+ ostringstream buf;
+ if(i > 0) buf << "array element " << i << ": ";
+ buf << "Divide by zero";
+ error(buf);
+}
+
+void integeroverflow(size_t i)
+{
+ ostringstream buf;
+ if(i > 0) buf << "array element " << i << ": ";
+ buf << "Integer overflow";
+ error(buf);
+}
+
+#if defined(HAVE_LIBREADLINE) && defined(HAVE_LIBCURSES)
+struct historyState {
+ bool store;
+ HISTORY_STATE state;
+};
+
+typedef mem::map<CONST string, historyState> historyMap_t;
+historyMap_t historyMap;
+static HISTORY_STATE history_save;
+
+// Store a deep copy of the current readline history in dest.
+void store_history(HISTORY_STATE *dest)
+{
+ HISTORY_STATE *src=history_get_history_state();
+ if(src) {
+ *dest=*src;
+ for(Int i=0; i < src->length; ++i)
+ dest->entries[i]=src->entries[i];
+ free(src);
+ }
+}
+
+stringarray* get_history(Int n)
+{
+ int N=intcast(n);
+ if(N <= 0) N=history_length;
+ else N=Min(N,history_length);
+ array *a=new array((size_t) N);
+ int offset=history_length-N+1;
+ for(int i=0; i < N; ++i) {
+ HIST_ENTRY *last=history_get(offset+i);
+ string s=last ? last->line : "";
+ (*a)[i]=s;
+ }
+ return a;
+}
+
+string historyfilename(const string &name)
+{
+ return historyname+"_"+name;
+}
+#endif
+
+#if defined(HAVE_LIBREADLINE) && defined(HAVE_LIBCURSES)
+int readline_startup_hook()
+{
+#ifdef __CYGWIN__
+ rl_set_key("\\M-[3~",rl_delete,rl_get_keymap());
+ rl_set_key("\\M-[2~",rl_overwrite_mode,rl_get_keymap());
+#endif
+ return 0;
+}
+
+void init_readline(bool tabcompletion=true)
+{
+ static bool first=true;
+ if(first) {
+ first=false;
+#ifdef __CYGWIN__
+ rl_startup_hook=readline_startup_hook;
+#endif
+ }
+ rl_bind_key('\t',tabcompletion ? rl_complete : rl_insert);
+}
+#endif
+
+void cleanup()
+{
+ processDataStruct &pd=processData();
+ pd.atExitFunction=NULL;
+ pd.atUpdateFunction=NULL;
+ pd.atBreakpointFunction=NULL;
+
+#if defined(HAVE_LIBREADLINE) && defined(HAVE_LIBCURSES)
+ store_history(&history_save);
+ int nlines=intcast(getSetting<Int>("historylines"));
+ for(historyMap_t::iterator h=historyMap.begin(); h != historyMap.end();
+ ++h) {
+ history_set_history_state(&h->second.state);
+ stifle_history(nlines);
+ if(h->second.store) write_history(historyfilename(h->first).c_str());
+ }
+ history_set_history_state(&history_save);
+#endif
+}
+
+void purge(Int divisor=0)
+{
+#ifdef USEGC
+ if(divisor > 0) GC_set_free_space_divisor((GC_word) divisor);
+ GC_gcollect();
+#endif
+}
+
+void updateFunction(stack *Stack)
+{
+ callable *atUpdateFunction=processData().atUpdateFunction;
+ if(atUpdateFunction && !nullfunc::instance()->compare(atUpdateFunction))
+ atUpdateFunction->call(Stack);
+}
+
+void exitFunction(stack *Stack)
+{
+ callable *atExitFunction=processData().atExitFunction;
+ if(atExitFunction && !nullfunc::instance()->compare(atExitFunction))
+ atExitFunction->call(Stack);
+ cleanup();
+}
+
+default_t def;
+string emptystring;
+array *emptyarray=new array(0);
+string commentchar="#";
+pair zero;
+
+void breakpoint(stack *Stack, runnable *r)
+{
+ callable *atBreakpointFunction=processData().atBreakpointFunction;
+ if(atBreakpointFunction &&
+ !nullfunc::instance()->compare(atBreakpointFunction)) {
+ position curPos=getPos();
+ Stack->push<string>(curPos.filename());
+ Stack->push<Int>((Int) curPos.Line());
+ Stack->push<Int>((Int) curPos.Column());
+ Stack->push(r ? r : item(def));
+ atBreakpointFunction->call(Stack); // returns a string
+ } else Stack->push<string>("");
+}
+
+}
+
+namespace types {
+extern const char *names[];
+}
+
+void checkformat(const char *ptr, bool intformat)
+{
+ while(*ptr != '\0') {
+ if(*ptr != '%') /* While we have regular characters, print them. */
+ ptr++;
+ else { /* We've got a format specifier. */
+ ptr++;
+
+ while(*ptr && strchr ("-+ #0'I", *ptr)) /* Move past flags. */
+ *ptr++;
+
+ if(*ptr == '*')
+ ptr++;
+ else while(isdigit(*ptr)) /* Handle explicit numeric value. */
+ ptr++;
+
+ if(*ptr == '.') {
+ *ptr++; /* Go past the period. */
+ if(*ptr == '*') {
+ ptr++;
+ } else
+ while(isdigit(*ptr)) /* Handle explicit numeric value. */
+ *ptr++;
+ }
+ while(*ptr && strchr ("hlL", *ptr))
+ *ptr++;
+
+ if(*ptr == '%') ++ptr;
+ else if(*ptr != '\0') {
+ if(intformat) {
+ switch(*ptr) {
+ case 'd':
+ case 'i':
+ case 'o':
+ case 'u':
+ case 'x':
+ case 'X':
+ case 'c':
+ break;
+ default:
+ ostringstream buf;
+ buf << "Invalid format '" << *ptr << "' for type "
+ << types::names[types::ty_Int];
+ error(buf);
+ break;
+ }
+ } else {
+ switch(*ptr) {
+ case 'f':
+ case 'F':
+ case 'e':
+ case 'E':
+ case 'g':
+ case 'G':
+ break;
+ default:
+ ostringstream buf;
+ buf << "Invalid format '" << *ptr << "' for type "
+ << types::names[types::ty_real];
+ error(buf);
+ break;
+ }
+ }
+ }
+ } /* End of else statement */
+ }
+}
+
+// Return an angle in the interval [0,360).
+inline double principalBranch(double deg)
+{
+ if(deg < 0) deg += 360;
+ return deg;
+}
+
+static string defaulttransparency=string("Compatible");
+
+static const string defaulttimeformat=string("%a %b %d %T %Z %Y");
+#ifdef HAVE_STRFTIME
+static const size_t nTime=256;
+static char Time[nTime];
+#endif
+
+void clear(string file, Int line, bool warn=false)
+{
+ bpinfo bp(file,line);
+ for(mem::list<bpinfo>::iterator p=bplist.begin(); p != bplist.end(); ++p) {
+ if(*p == bp) {
+ cout << "cleared breakpoint at " << file << ": " << line << endl;
+ bplist.remove(bp);
+ return;
+ }
+ }
+ if(warn)
+ cout << "No such breakpoint at " << file << ": " << line << endl;
+}
+
+Int windingnumber(array *p, camp::pair z)
+{
+ size_t size=checkArray(p);
+ Int count=0;
+ for(size_t i=0; i < size; i++)
+ count += read<path *>(p,i)->windingnumber(z);
+ return count;
+}
+
+string convertname(string name, const string& format, bool check=true)
+{
+ if(name.empty())
+ return buildname(outname(),format,"");
+ else
+ if(check) checkLocal(name);
+ return format.empty() ? name : format+":"+name;
+}
+
+callable *Func;
+stack *FuncStack;
+double wrapFunction(double x)
+{
+ FuncStack->push(x);
+ Func->call(FuncStack);
+ return pop<double>(FuncStack);
+}
+
+callable *compareFunc;
+bool compareFunction(const vm::item& i, const vm::item& j)
+{
+ FuncStack->push(i);
+ FuncStack->push(j);
+ compareFunc->call(FuncStack);
+ return pop<bool>(FuncStack);
+}
+
+void unused(void *)
+{
+}
+
+pair readpair(stringstream& s, bool tex)
+{
+ static const double f=12.0/100.0;
+ double x,y;
+ s >> y;
+ s >> x;
+ return tex ? pair(f*x,-f*y) : pair(x,y);
+}
+
+// Ignore unclosed begingroups but not spurious endgroups.
+const char *nobegin="endgroup without matching begingroup";
+
+// Return the component of vector v perpendicular to a unit vector u.
+inline triple perp(triple v, triple u)
+{
+ return v-dot(v,u)*u;
+}
+
+string ASYo="/ASYo {( ) print 12 string cvs print} bind def";
+string pathforall="{(M) print ASYo ASYo} {(L) print ASYo ASYo} {(C) print ASYo ASYo ASYo ASYo ASYo ASYo} {(c) print} pathforall";
+string currentpoint="print currentpoint ASYo ASYo ";
+
+array *readpath(const string& psname, bool tex, bool keep)
+{
+ array *P=new array(0);
+ ostringstream pipe;
+ pipe << "'" << getSetting<string>("gs")
+ << "' -q -dNOPAUSE -dBATCH";
+ if(safe) pipe << " -dSAFER";
+#ifdef __CYGWIN__
+ string null="NUL";
+#else
+ string null="/dev/null";
+#endif
+ pipe << " -sDEVICE=epswrite -sOutputFile="+null+" '" << psname << "'";
+ iopipestream gs(pipe.str().c_str(),"gs","Ghostscript");
+ stringstream buf;
+ while(true) {
+ string out;
+ gs >> out;
+ buf << out;
+ string s=buf.str();
+ if(gs.tailequals(s.c_str(),s.size(),"E",1)) break;
+ }
+ if(verbose > 2) cout << endl;
+
+ mem::vector<solvedKnot> nodes;
+ solvedKnot node;
+ bool cyclic=false;
+ bool active=false;
+
+ pair offset;
+ while(!buf.eof()) {
+ char c;
+ buf >> c;
+ switch(c) {
+ case 'M':
+ {
+ if(active) {
+ if(cyclic) {
+ if(node.point == nodes[0].point)
+ nodes[0].pre=node.pre;
+ else {
+ pair delta=(nodes[0].point-node.point)*third;
+ node.post=node.point+delta;
+ nodes[0].pre=nodes[0].point-delta;
+ node.straight=true;
+ nodes.push_back(node);
+ }
+ } else {
+ node.post=node.point;
+ node.straight=false;
+ nodes.push_back(node);
+ }
+ P->push(path(nodes,nodes.size(),cyclic));
+ nodes.clear();
+ }
+ active=false;
+ cyclic=false;
+ node.pre=node.point=readpair(buf,tex)-offset;
+ node.straight=false;
+ break;
+ }
+ case 'L':
+ {
+ pair point=readpair(buf,tex)-offset;
+ pair delta=(point-node.point)*third;
+ node.post=node.point+delta;
+ node.straight=true;
+ nodes.push_back(node);
+ active=true;
+ node.pre=point-delta;
+ node.point=point;
+ break;
+ }
+ case 'C':
+ {
+ pair point=readpair(buf,tex)-offset;
+ pair pre=readpair(buf,tex)-offset;
+ node.post=readpair(buf,tex)-offset;
+ node.straight=false;
+ nodes.push_back(node);
+ active=true;
+ node.pre=pre;
+ node.point=point;
+ break;
+ }
+ case 'c':
+ {
+ cyclic=true;
+ break;
+ }
+ case 'Z':
+ {
+ offset=readpair(buf,tex);
+ break;
+ }
+ }
+ }
+
+ if(!keep)
+ unlink(psname.c_str());
+ return P;
+}
+
+pair sin(pair z)
+{
+ return pair(sin(z.getx())*cosh(z.gety()),cos(z.getx())*sinh(z.gety()));
+}
+
+pair exp(pair z)
+{
+ return exp(z.getx())*expi(z.gety());
+}
+
+pair gamma(pair z)
+{
+ static double p[]={0.99999999999980993,676.5203681218851,-1259.1392167224028,
+ 771.32342877765313,-176.61502916214059,12.507343278686905,
+ -0.13857109526572012,9.9843695780195716e-6,
+ 1.5056327351493116e-7};
+ static int n=sizeof(p)/sizeof(double);
+ static double root2pi=sqrt(2*PI);
+ if(z.getx() < 0.5)
+ return PI/(sin(PI*z)*gamma(1.0-z));
+ z -= 1.0;
+ pair x=p[0];
+ for(int i=1; i < n; ++i)
+ x += p[i]/(z+i);
+ pair t=n-1.5+z;
+ return root2pi*pow(t,z+0.5)*exp(-t)*x;
+}
+
+// Autogenerated routines:
+
+
+
+namespace run {
+
+// Initializers
+#line 1026 "runtime.in"
+void IntZero(stack *Stack)
+{
+#line 1027 "runtime.in"
+ {Stack->push<Int>(0); return;}
+}
+
+#line 1032 "runtime.in"
+void realZero(stack *Stack)
+{
+#line 1033 "runtime.in"
+ {Stack->push<real>(0.0); return;}
+}
+
+#line 1037 "runtime.in"
+void boolFalse(stack *Stack)
+{
+#line 1038 "runtime.in"
+ {Stack->push<bool>(false); return;}
+}
+
+#line 1042 "runtime.in"
+void pushNullArray(stack *Stack)
+{
+#line 1043 "runtime.in"
+ {Stack->push<array*>(0); return;}
+}
+
+#line 1047 "runtime.in"
+void pushNullRecord(stack *Stack)
+{
+#line 1048 "runtime.in"
+ {Stack->push<frame*>(0); return;}
+}
+
+#line 1052 "runtime.in"
+void pushNullFunction(stack *Stack)
+{
+#line 1053 "runtime.in"
+ {Stack->push(nullfunc::instance()); return;}
+}
+
+
+// Default operations
+
+// Put the default value token on the stack (in place of an argument when
+// making a function call).
+#line 1062 "runtime.in"
+void pushDefault(stack *Stack)
+{
+#line 1063 "runtime.in"
+ {Stack->push(def); return;}
+}
+
+
+// Test if the value on the stack is the default value token.
+#line 1069 "runtime.in"
+void isDefault(stack *Stack)
+{
+ item i=vm::pop(Stack);
+#line 1070 "runtime.in"
+ {Stack->push<bool>(isdefault(i)); return;}
+}
+
+
+// Logical operations
+#line 1076 "runtime.in"
+// bool !(bool b);
+void gen8(stack *Stack)
+{
+ bool b=vm::pop<bool>(Stack);
+#line 1077 "runtime.in"
+ {Stack->push<bool>(!b); return;}
+}
+
+#line 1082 "runtime.in"
+void boolMemEq(stack *Stack)
+{
+ frame * b=vm::pop<frame *>(Stack);
+ frame * a=vm::pop<frame *>(Stack);
+#line 1083 "runtime.in"
+ {Stack->push<bool>(a == b); return;}
+}
+
+#line 1087 "runtime.in"
+void boolMemNeq(stack *Stack)
+{
+ frame * b=vm::pop<frame *>(Stack);
+ frame * a=vm::pop<frame *>(Stack);
+#line 1088 "runtime.in"
+ {Stack->push<bool>(a != b); return;}
+}
+
+#line 1092 "runtime.in"
+void boolFuncEq(stack *Stack)
+{
+ callable * b=vm::pop<callable *>(Stack);
+ callable * a=vm::pop<callable *>(Stack);
+#line 1093 "runtime.in"
+ {Stack->push<bool>(a->compare(b)); return;}
+}
+
+#line 1097 "runtime.in"
+void boolFuncNeq(stack *Stack)
+{
+ callable * b=vm::pop<callable *>(Stack);
+ callable * a=vm::pop<callable *>(Stack);
+#line 1098 "runtime.in"
+ {Stack->push<bool>(!(a->compare(b))); return;}
+}
+
+
+// Bit operations
+#line 1104 "runtime.in"
+// Int AND(Int a, Int b);
+void gen13(stack *Stack)
+{
+ Int b=vm::pop<Int>(Stack);
+ Int a=vm::pop<Int>(Stack);
+#line 1105 "runtime.in"
+ {Stack->push<Int>(a & b); return;}
+}
+
+#line 1110 "runtime.in"
+// Int OR(Int a, Int b);
+void gen14(stack *Stack)
+{
+ Int b=vm::pop<Int>(Stack);
+ Int a=vm::pop<Int>(Stack);
+#line 1111 "runtime.in"
+ {Stack->push<Int>(a | b); return;}
+}
+
+#line 1115 "runtime.in"
+// Int XOR(Int a, Int b);
+void gen15(stack *Stack)
+{
+ Int b=vm::pop<Int>(Stack);
+ Int a=vm::pop<Int>(Stack);
+#line 1116 "runtime.in"
+ {Stack->push<Int>(a ^ b); return;}
+}
+
+#line 1120 "runtime.in"
+// Int NOT(Int a);
+void gen16(stack *Stack)
+{
+ Int a=vm::pop<Int>(Stack);
+#line 1121 "runtime.in"
+ {Stack->push<Int>(~a); return;}
+}
+
+
+// Casts
+#line 1127 "runtime.in"
+void pairToGuide(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 1128 "runtime.in"
+ {Stack->push<guide*>(new pairguide(z)); return;}
+}
+
+#line 1133 "runtime.in"
+void pathToGuide(stack *Stack)
+{
+ path p=vm::pop<path>(Stack);
+#line 1134 "runtime.in"
+ {Stack->push<guide*>(new pathguide(p)); return;}
+}
+
+#line 1138 "runtime.in"
+void guideToPath(stack *Stack)
+{
+ guide * g=vm::pop<guide *>(Stack);
+#line 1139 "runtime.in"
+ {Stack->push<path>(g->solve()); return;}
+}
+
+
+// Picture operations
+#line 1145 "runtime.in"
+void newPicture(stack *Stack)
+{
+#line 1146 "runtime.in"
+ {Stack->push<picture*>(new picture()); return;}
+}
+
+#line 1151 "runtime.in"
+// bool empty(picture *f);
+void gen21(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 1152 "runtime.in"
+ {Stack->push<bool>(f->null()); return;}
+}
+
+#line 1156 "runtime.in"
+// void erase(picture *f);
+void gen22(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 1157 "runtime.in"
+ f->nodes.clear();
+}
+
+#line 1161 "runtime.in"
+// pair min(picture *f);
+void gen23(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 1162 "runtime.in"
+ {Stack->push<pair>(f->bounds().Min()); return;}
+}
+
+#line 1166 "runtime.in"
+// pair max(picture *f);
+void gen24(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 1167 "runtime.in"
+ {Stack->push<pair>(f->bounds().Max()); return;}
+}
+
+#line 1171 "runtime.in"
+// void label(picture *f, string *s, string *size, transform t, pair position, pair align, pen p);
+void gen25(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+ pair align=vm::pop<pair>(Stack);
+ pair position=vm::pop<pair>(Stack);
+ transform t=vm::pop<transform>(Stack);
+ string * size=vm::pop<string *>(Stack);
+ string * s=vm::pop<string *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1173 "runtime.in"
+ f->append(new drawLabel(*s,*size,t,position,align,p));
+}
+
+#line 1177 "runtime.in"
+// bool labels(picture *f);
+void gen26(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 1178 "runtime.in"
+ {Stack->push<bool>(f->havelabels()); return;}
+}
+
+#line 1182 "runtime.in"
+// patharray* _texpath(string *s, pen p=CURRENTPEN);
+void gen27(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack,CURRENTPEN);
+ string * s=vm::pop<string *>(Stack);
+#line 1183 "runtime.in"
+ array *P=new array(0);
+ if(s->empty()) {Stack->push<patharray*>(P); return;}
+
+ string prefix=outname();
+ spaceToUnderscore(prefix);
+ string psname=auxname(prefix,"ps");
+
+ string texname=auxname(prefix,"tex");
+ string dviname=auxname(prefix,"dvi");
+ bbox b;
+ texfile tex(texname,b,true);
+ tex.miniprologue();
+
+ tex.setfont(p);
+ tex.verbatimline("\\special{ps:");
+ tex.verbatimline(ASYo);
+ tex.verbatimline("/ASY1 true def");
+ tex.verbatimline("/v {neg exch 4 copy 4 2 roll 2 copy 6 2 roll 2 copy (M) print ASYo ASYo (L) print ASYo add ASYo (L) print add ASYo add ASYo (L) print add ASYo ASYo (c) print} bind def");
+ tex.verbatimline("/show {ASY1 {(Z) "+currentpoint+
+ "/ASY1 false def} if currentpoint newpath moveto false charpath "+
+ pathforall+"} bind def}");
+ tex.verbatim(*s);
+ tex.verbatimline("\\special{ps: (E) print}");
+ tex.epilogue(true);
+ tex.close();
+
+ ostringstream cmd;
+ string aux=auxname(prefix,"aux");
+ unlink(aux.c_str());
+ cmd << texprogram(true) << " \\nonstopmode\\input '" << texname << "'";
+ bool quiet=verbose <= 2;
+ int status=System(cmd,quiet ? 1 : 0,"texpath",texpathmessage());
+ if(!status && getSetting<bool>("twice"))
+ status=System(cmd,quiet ? 1 : 0,"texpath",texpathmessage());
+ if(status) {
+ if(quiet) {
+ ostringstream cmd;
+ cmd << texprogram(true) << " \\scrollmode\\input '" << texname << "'";
+ System(cmd,0);
+ }
+ }
+
+ if(!status) {
+ ostringstream cmd;
+ cmd << "'" << getSetting<string>("dvips") << "' -R -Pdownload35 -D600 "
+ << getSetting<string>("dvipsOptions");
+ if(verbose <= 2) cmd << " -q";
+ cmd << " -o '" << psname << "' '" << dviname << "'";
+ status=System(cmd,0,true,"dvips");
+ }
+
+ if(status != 0)
+ error("texpath failed");
+
+ bool keep=getSetting<bool>("keep");
+ if(!keep) { // Delete temporary files.
+ unlink(texname.c_str());
+ if(!getSetting<bool>("keepaux"))
+ unlink(aux.c_str());
+ unlink(auxname(prefix,"log").c_str());
+ unlink(dviname.c_str());
+ }
+ {Stack->push<patharray*>(readpath(psname,true,keep)); return;}
+}
+
+#line 1249 "runtime.in"
+// patharray* _strokepath(path g, pen p=CURRENTPEN);
+void gen28(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack,CURRENTPEN);
+ path g=vm::pop<path>(Stack);
+#line 1250 "runtime.in"
+ array *P=new array(0);
+ if(g.size() == 0) {Stack->push<patharray*>(P); return;}
+
+ string prefix=outname();
+ spaceToUnderscore(prefix);
+ string psname=auxname(prefix,"ps");
+ bbox b;
+ psfile ps(psname, false);
+ ps.prologue(b);
+ ps.verbatimline(ASYo);
+ ps.verbatimline("/stroke {(Z) "+currentpoint+pathforall+"} bind def");
+ ps.resetpen();
+ ps.setpen(p);
+ ps.write(g);
+ ps.strokepath();
+ ps.stroke();
+ ps.verbatimline("(M) "+currentpoint+"(E) print");
+ ps.epilogue();
+ ps.close();
+ {Stack->push<patharray*>(readpath(psname,false,getSetting<bool>("keep"))); return;}
+}
+
+#line 1273 "runtime.in"
+// void _draw(picture *f, path g, pen p);
+void gen29(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+ path g=vm::pop<path>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1274 "runtime.in"
+ f->append(new drawPath(g,p));
+}
+
+#line 1278 "runtime.in"
+// void fill(picture *f, patharray *g, pen p=CURRENTPEN, bool copy=true);
+void gen30(stack *Stack)
+{
+ bool copy=vm::pop<bool>(Stack,true);
+ pen p=vm::pop<pen>(Stack,CURRENTPEN);
+ patharray * g=vm::pop<patharray *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1279 "runtime.in"
+ array *(*copyarray)(array *a)=copy ? copyArray: nop;
+ f->append(new drawFill(*copyarray(g),false,p));
+}
+
+#line 1284 "runtime.in"
+// void latticeshade(picture *f, patharray *g, bool stroke=false, pen fillrule=CURRENTPEN, penarray2 *p, bool copy=true);
+void gen31(stack *Stack)
+{
+ bool copy=vm::pop<bool>(Stack,true);
+ penarray2 * p=vm::pop<penarray2 *>(Stack);
+ pen fillrule=vm::pop<pen>(Stack,CURRENTPEN);
+ bool stroke=vm::pop<bool>(Stack,false);
+ patharray * g=vm::pop<patharray *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1286 "runtime.in"
+ array *(*copyarray)(array *a)=copy ? copyArray: nop;
+ f->append(new drawLatticeShade(*copyarray(g),stroke,fillrule,*copyarray(p)));
+}
+
+#line 1291 "runtime.in"
+// void axialshade(picture *f, patharray *g, bool stroke=false, pen pena, pair a, pen penb, pair b, bool copy=true);
+void gen32(stack *Stack)
+{
+ bool copy=vm::pop<bool>(Stack,true);
+ pair b=vm::pop<pair>(Stack);
+ pen penb=vm::pop<pen>(Stack);
+ pair a=vm::pop<pair>(Stack);
+ pen pena=vm::pop<pen>(Stack);
+ bool stroke=vm::pop<bool>(Stack,false);
+ patharray * g=vm::pop<patharray *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1293 "runtime.in"
+ array *(*copyarray)(array *a)=copy ? copyArray: nop;
+ f->append(new drawAxialShade(*copyarray(g),stroke,pena,a,penb,b));
+}
+
+#line 1298 "runtime.in"
+// void radialshade(picture *f, patharray *g, bool stroke=false, pen pena, pair a, real ra, pen penb, pair b, real rb, bool copy=true);
+void gen33(stack *Stack)
+{
+ bool copy=vm::pop<bool>(Stack,true);
+ real rb=vm::pop<real>(Stack);
+ pair b=vm::pop<pair>(Stack);
+ pen penb=vm::pop<pen>(Stack);
+ real ra=vm::pop<real>(Stack);
+ pair a=vm::pop<pair>(Stack);
+ pen pena=vm::pop<pen>(Stack);
+ bool stroke=vm::pop<bool>(Stack,false);
+ patharray * g=vm::pop<patharray *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1300 "runtime.in"
+ array *(*copyarray)(array *a)=copy ? copyArray: nop;
+ f->append(new drawRadialShade(*copyarray(g),stroke,pena,a,ra,penb,b,rb));
+}
+
+#line 1305 "runtime.in"
+// void gouraudshade(picture *f, patharray *g, bool stroke=false, pen fillrule=CURRENTPEN, penarray *p, pairarray *z, Intarray *edges, bool copy=true);
+void gen34(stack *Stack)
+{
+ bool copy=vm::pop<bool>(Stack,true);
+ Intarray * edges=vm::pop<Intarray *>(Stack);
+ pairarray * z=vm::pop<pairarray *>(Stack);
+ penarray * p=vm::pop<penarray *>(Stack);
+ pen fillrule=vm::pop<pen>(Stack,CURRENTPEN);
+ bool stroke=vm::pop<bool>(Stack,false);
+ patharray * g=vm::pop<patharray *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1308 "runtime.in"
+ array *(*copyarray)(array *a)=copy ? copyArray: nop;
+ checkArrays(p,z);
+ checkArrays(z,edges);
+ f->append(new drawGouraudShade(*copyarray(g),stroke,fillrule,*copyarray(p),
+ *copyarray(z),*copyarray(edges)));
+}
+
+#line 1316 "runtime.in"
+// void gouraudshade(picture *f, patharray *g, bool stroke=false, pen fillrule=CURRENTPEN, penarray *p, Intarray *edges, bool copy=true);
+void gen35(stack *Stack)
+{
+ bool copy=vm::pop<bool>(Stack,true);
+ Intarray * edges=vm::pop<Intarray *>(Stack);
+ penarray * p=vm::pop<penarray *>(Stack);
+ pen fillrule=vm::pop<pen>(Stack,CURRENTPEN);
+ bool stroke=vm::pop<bool>(Stack,false);
+ patharray * g=vm::pop<patharray *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1319 "runtime.in"
+ array *(*copyarray)(array *a)=copy ? copyArray: nop;
+ size_t n=checkArrays(p,edges);
+ size_t m=checkArray(g);
+ array *z=new array(n);
+ Int k=0;
+ Int in=(Int) n;
+ for(size_t j=0; j < m; ++j) {
+ path *P=read<path *>(g,j);
+ assert(P);
+ Int stop=Min(P->size(),in-k);
+ mem::vector<solvedKnot>& nodes=P->Nodes();
+ for(Int i=0; i < stop; ++i)
+ (*z)[k++]=nodes[i].point;
+ }
+ checkArrays(p,z);
+
+ f->append(new drawGouraudShade(*copyarray(g),stroke,fillrule,*copyarray(p),
+ *z,*copyarray(edges)));
+}
+
+#line 1340 "runtime.in"
+// void tensorshade(picture *f, patharray *g, bool stroke=false, pen fillrule=CURRENTPEN, penarray2 *p, patharray *b=NULL, pairarray2 *z=emptyarray, bool copy=true);
+void gen36(stack *Stack)
+{
+ bool copy=vm::pop<bool>(Stack,true);
+ pairarray2 * z=vm::pop<pairarray2 *>(Stack,emptyarray);
+ patharray * b=vm::pop<patharray *>(Stack,NULL);
+ penarray2 * p=vm::pop<penarray2 *>(Stack);
+ pen fillrule=vm::pop<pen>(Stack,CURRENTPEN);
+ bool stroke=vm::pop<bool>(Stack,false);
+ patharray * g=vm::pop<patharray *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1343 "runtime.in"
+ array *(*copyarray)(array *a)=copy ? copyArray: nop;
+ array *(*copyarray2)(array *a)=copy ? copyArray2: nop;
+ if(b == NULL) b=g;
+ size_t n=checkArrays(p,b);
+ size_t nz=checkArray(z);
+ if(nz != 0)
+ checkEqual(nz,n);
+ f->append(new drawTensorShade(*copyarray(g),stroke,fillrule,*copyarray2(p),
+ *copyarray(b),*copyarray2(z)));
+}
+
+#line 1355 "runtime.in"
+// void functionshade(picture *f, patharray *g, bool stroke=false, pen fillrule=CURRENTPEN, string shader=emptystring, bool copy=true);
+void gen37(stack *Stack)
+{
+ bool copy=vm::pop<bool>(Stack,true);
+ string shader=vm::pop<string>(Stack,emptystring);
+ pen fillrule=vm::pop<pen>(Stack,CURRENTPEN);
+ bool stroke=vm::pop<bool>(Stack,false);
+ patharray * g=vm::pop<patharray *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1358 "runtime.in"
+ array *(*copyarray)(array *a)=copy ? copyArray: nop;
+ f->append(new drawFunctionShade(*copyarray(g),stroke,fillrule,shader));
+}
+
+// Clip a picture to a superpath using the given fill rule.
+// Subsequent additions to the picture will not be affected by the clipping.
+#line 1365 "runtime.in"
+// void clip(picture *f, patharray *g, bool stroke=false, pen fillrule=CURRENTPEN, bool copy=true);
+void gen38(stack *Stack)
+{
+ bool copy=vm::pop<bool>(Stack,true);
+ pen fillrule=vm::pop<pen>(Stack,CURRENTPEN);
+ bool stroke=vm::pop<bool>(Stack,false);
+ patharray * g=vm::pop<patharray *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1367 "runtime.in"
+ array *(*copyarray)(array *a)=copy ? copyArray: nop;
+ drawClipBegin *begin=new drawClipBegin(*copyarray(g),stroke,fillrule,true);
+ f->enclose(begin,new drawClipEnd(true,begin));
+}
+
+#line 1373 "runtime.in"
+// void beginclip(picture *f, patharray *g, bool stroke=false, pen fillrule=CURRENTPEN, bool copy=true);
+void gen39(stack *Stack)
+{
+ bool copy=vm::pop<bool>(Stack,true);
+ pen fillrule=vm::pop<pen>(Stack,CURRENTPEN);
+ bool stroke=vm::pop<bool>(Stack,false);
+ patharray * g=vm::pop<patharray *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1375 "runtime.in"
+ array *(*copyarray)(array *a)=copy ? copyArray: nop;
+ f->append(new drawClipBegin(*copyarray(g),stroke,fillrule,false));
+}
+
+#line 1380 "runtime.in"
+// void endclip(picture *f);
+void gen40(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 1381 "runtime.in"
+ f->append(new drawClipEnd(false));
+}
+
+#line 1385 "runtime.in"
+// void gsave(picture *f);
+void gen41(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 1386 "runtime.in"
+ f->append(new drawGsave());
+}
+
+#line 1390 "runtime.in"
+// void grestore(picture *f);
+void gen42(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 1391 "runtime.in"
+ f->append(new drawGrestore());
+}
+
+#line 1395 "runtime.in"
+// void begingroup(picture *f);
+void gen43(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 1396 "runtime.in"
+ f->append(new drawBegin());
+}
+
+#line 1400 "runtime.in"
+// void endgroup(picture *f);
+void gen44(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 1401 "runtime.in"
+ f->append(new drawEnd());
+}
+
+#line 1405 "runtime.in"
+// void add(picture *dest, picture *src);
+void gen45(stack *Stack)
+{
+ picture * src=vm::pop<picture *>(Stack);
+ picture * dest=vm::pop<picture *>(Stack);
+#line 1406 "runtime.in"
+ dest->add(*src);
+}
+
+#line 1410 "runtime.in"
+// void prepend(picture *dest, picture *src);
+void gen46(stack *Stack)
+{
+ picture * src=vm::pop<picture *>(Stack);
+ picture * dest=vm::pop<picture *>(Stack);
+#line 1411 "runtime.in"
+ dest->prepend(*src);
+}
+
+#line 1415 "runtime.in"
+// void postscript(picture *f, string s);
+void gen47(stack *Stack)
+{
+ string s=vm::pop<string>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1416 "runtime.in"
+ f->append(new drawVerbatim(PostScript,s));
+}
+
+#line 1420 "runtime.in"
+// void tex(picture *f, string s);
+void gen48(stack *Stack)
+{
+ string s=vm::pop<string>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1421 "runtime.in"
+ f->append(new drawVerbatim(TeX,s));
+}
+
+#line 1425 "runtime.in"
+// void postscript(picture *f, string s, pair min, pair max);
+void gen49(stack *Stack)
+{
+ pair max=vm::pop<pair>(Stack);
+ pair min=vm::pop<pair>(Stack);
+ string s=vm::pop<string>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1426 "runtime.in"
+ f->append(new drawVerbatim(PostScript,s,min,max));
+}
+
+#line 1430 "runtime.in"
+// void tex(picture *f, string s, pair min, pair max);
+void gen50(stack *Stack)
+{
+ pair max=vm::pop<pair>(Stack);
+ pair min=vm::pop<pair>(Stack);
+ string s=vm::pop<string>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1431 "runtime.in"
+ f->append(new drawVerbatim(TeX,s,min,max));
+}
+
+#line 1435 "runtime.in"
+// void texpreamble(string s);
+void gen51(stack *Stack)
+{
+ string s=vm::pop<string>(Stack);
+#line 1436 "runtime.in"
+ string t=s+"\n";
+ processDataStruct &pd=processData();
+ pd.TeXpipepreamble.push_back(t);
+ pd.TeXpreamble.push_back(t);
+}
+
+#line 1443 "runtime.in"
+// void deletepreamble();
+void gen52(stack *)
+{
+#line 1444 "runtime.in"
+ if(getSetting<bool>("inlinetex")) {
+ unlink(auxname(outname(),"pre").c_str());
+ }
+}
+
+#line 1450 "runtime.in"
+// void _labelpath(picture *f, string s, string size, path g, string justify, pair offset, pen p);
+void gen53(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+ pair offset=vm::pop<pair>(Stack);
+ string justify=vm::pop<string>(Stack);
+ path g=vm::pop<path>(Stack);
+ string size=vm::pop<string>(Stack);
+ string s=vm::pop<string>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1452 "runtime.in"
+ f->append(new drawLabelPath(s,size,g,justify,offset,p));
+}
+
+#line 1456 "runtime.in"
+// void texreset();
+void gen54(stack *)
+{
+#line 1457 "runtime.in"
+ processDataStruct &pd=processData();
+ pd.TeXpipepreamble.clear();
+ pd.TeXpreamble.clear();
+ pd.tex.pipeclose();
+}
+
+#line 1464 "runtime.in"
+// void layer(picture *f);
+void gen55(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 1465 "runtime.in"
+ f->append(new drawLayer());
+}
+
+#line 1469 "runtime.in"
+// void newpage(picture *f);
+void gen56(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 1470 "runtime.in"
+ f->append(new drawNewPage());
+}
+
+#line 1474 "runtime.in"
+// void _image(picture *f, realarray2 *data, pair initial, pair final, penarray *palette=NULL, transform t=identity, bool copy=true, bool antialias=false);
+void gen57(stack *Stack)
+{
+ bool antialias=vm::pop<bool>(Stack,false);
+ bool copy=vm::pop<bool>(Stack,true);
+ transform t=vm::pop<transform>(Stack,identity);
+ penarray * palette=vm::pop<penarray *>(Stack,NULL);
+ pair final=vm::pop<pair>(Stack);
+ pair initial=vm::pop<pair>(Stack);
+ realarray2 * data=vm::pop<realarray2 *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1477 "runtime.in"
+ array *(*copyarray)(array *a)=copy ? copyArray: nop;
+ array *(*copyarray2)(array *a)=copy ? copyArray2: nop;
+ f->append(new drawImage(*copyarray2(data),*copyarray(palette),
+ t*matrix(initial,final),antialias));
+}
+
+#line 1484 "runtime.in"
+// void _image(picture *f, penarray2 *data, pair initial, pair final, transform t=identity, bool copy=true, bool antialias=false);
+void gen58(stack *Stack)
+{
+ bool antialias=vm::pop<bool>(Stack,false);
+ bool copy=vm::pop<bool>(Stack,true);
+ transform t=vm::pop<transform>(Stack,identity);
+ pair final=vm::pop<pair>(Stack);
+ pair initial=vm::pop<pair>(Stack);
+ penarray2 * data=vm::pop<penarray2 *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1486 "runtime.in"
+ array *(*copyarray2)(array *a)=copy ? copyArray2: nop;
+ f->append(new drawImage(*copyarray2(data),t*matrix(initial,final),antialias));
+}
+
+#line 1491 "runtime.in"
+// string nativeformat();
+void gen59(stack *Stack)
+{
+#line 1492 "runtime.in"
+ {Stack->push<string>(nativeformat()); return;}
+}
+
+#line 1496 "runtime.in"
+// bool latex();
+void gen60(stack *Stack)
+{
+#line 1497 "runtime.in"
+ {Stack->push<bool>(latex(getSetting<string>("tex"))); return;}
+}
+
+#line 1501 "runtime.in"
+// bool pdf();
+void gen61(stack *Stack)
+{
+#line 1502 "runtime.in"
+ {Stack->push<bool>(pdf(getSetting<string>("tex"))); return;}
+}
+
+#line 1506 "runtime.in"
+// void shipout(string prefix=emptystring, picture *f, picture *preamble=NULL, string format=emptystring, bool wait=false, bool view=true, callableTransform *xform);
+void gen62(stack *Stack)
+{
+ callableTransform * xform=vm::pop<callableTransform *>(Stack);
+ bool view=vm::pop<bool>(Stack,true);
+ bool wait=vm::pop<bool>(Stack,false);
+ string format=vm::pop<string>(Stack,emptystring);
+ picture * preamble=vm::pop<picture *>(Stack,NULL);
+ picture * f=vm::pop<picture *>(Stack);
+ string prefix=vm::pop<string>(Stack,emptystring);
+#line 1509 "runtime.in"
+ if(prefix.empty()) prefix=outname();
+
+ picture *result=new picture;
+ unsigned level=0;
+ picture::nodelist::iterator p;
+ for(p = f->nodes.begin(); p != f->nodes.end(); ++p) {
+ xform->call(Stack);
+ transform t=pop<transform>(Stack);
+ static transform Zero=transform(0.0,0.0,0.0,0.0,0.0,0.0);
+ bool Delete=(t == Zero);
+ picture *group=new picture;
+ assert(*p);
+ if((*p)->endgroup()) error(nobegin);
+ if((*p)->begingroup()) {
+ ++level;
+ while(p != f->nodes.end() && level) {
+ if(!Delete) {
+ drawElement *e=t.isIdentity() ? *p : (*p)->transformed(t);
+ group->append(e);
+ }
+ ++p;
+ if(p == f->nodes.end()) break;
+ assert(*p);
+ if((*p)->begingroup()) ++level;
+ if((*p)->endgroup()) {
+ if(level) --level;
+ else error(nobegin);
+ }
+ }
+ }
+ if(p == f->nodes.end()) break;
+ assert(*p);
+ if(!Delete) {
+ drawElement *e=t.isIdentity() ? *p : (*p)->transformed(t);
+ group->append(e);
+ result->add(*group);
+ }
+ }
+
+ result->shipout(preamble,prefix,format,0.0,wait,view);
+}
+
+#line 1552 "runtime.in"
+// void shipout3(string prefix, picture *f, string format=emptystring, real width, real height, real angle, triple m, triple M, realarray2 *t, triplearray *lights, realarray2 *diffuse, realarray2 *ambient, realarray2 *specular, bool viewportlighting, bool view=true);
+void gen63(stack *Stack)
+{
+ bool view=vm::pop<bool>(Stack,true);
+ bool viewportlighting=vm::pop<bool>(Stack);
+ realarray2 * specular=vm::pop<realarray2 *>(Stack);
+ realarray2 * ambient=vm::pop<realarray2 *>(Stack);
+ realarray2 * diffuse=vm::pop<realarray2 *>(Stack);
+ triplearray * lights=vm::pop<triplearray *>(Stack);
+ realarray2 * t=vm::pop<realarray2 *>(Stack);
+ triple M=vm::pop<triple>(Stack);
+ triple m=vm::pop<triple>(Stack);
+ real angle=vm::pop<real>(Stack);
+ real height=vm::pop<real>(Stack);
+ real width=vm::pop<real>(Stack);
+ string format=vm::pop<string>(Stack,emptystring);
+ picture * f=vm::pop<picture *>(Stack);
+ string prefix=vm::pop<string>(Stack);
+#line 1557 "runtime.in"
+ size_t n=checkArrays(lights,diffuse);
+ checkEqual(n,checkArray(ambient));
+ checkEqual(n,checkArray(specular));
+
+ f->shipout3(prefix,format,width,height,angle,m,M,copyArray2C(t,true,4),n,
+ copyTripleArrayC(lights),copyArray2C(diffuse,false,4),
+ copyArray2C(ambient,false,4),copyArray2C(specular,false,4),
+ viewportlighting,view);
+}
+
+#line 1568 "runtime.in"
+// void shipout3(string prefix, picture *f);
+void gen64(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+ string prefix=vm::pop<string>(Stack);
+#line 1569 "runtime.in"
+ f->shipout3(prefix);
+}
+
+#line 1573 "runtime.in"
+// void deconstruct(picture *f, picture *preamble=NULL, real magnification=1, callableTransform *xform);
+void gen65(stack *Stack)
+{
+ callableTransform * xform=vm::pop<callableTransform *>(Stack);
+ real magnification=vm::pop<real>(Stack,1);
+ picture * preamble=vm::pop<picture *>(Stack,NULL);
+ picture * f=vm::pop<picture *>(Stack);
+#line 1575 "runtime.in"
+ unsigned level=0;
+ unsigned n=0;
+
+ string prefix=outname();
+ string xformat=getSetting<string>("xformat");
+
+ static long arg_max=sysconf(_SC_ARG_MAX);
+ const unsigned maxargs=::min(arg_max/(prefix.size()+xformat.size()+25ul),
+ 256ul);
+
+ cout << xformat << newl;
+ cout << maxargs << newl;
+
+ string preformat=nativeformat();
+ const string Done="Done";
+ const string Error="Error";
+
+ ostringstream cmd;
+
+ // Enforce ghostscript limitations.
+ magnification=::max(magnification,0.0001);
+ real res=::min(::max(magnification*72.0,2.0),8192.0);
+
+ const char *converter=NULL, *hint=NULL;
+
+ bool png=xformat == "png";
+
+ if(magnification > 0.0) {
+ mem::list<string> nameStack;
+ string outname;
+ unsigned arg=0;
+ unsigned batch=0;
+ for(picture::nodelist::iterator p=f->nodes.begin();;) {
+ if(p == f->nodes.end()) break;
+ if(arg == 0) {
+ cmd.str("");
+ ostringstream buf;
+ buf << batch << "_";
+ outname=buildname(prefix+buf.str()+"%d",xformat,"");
+ if(png) {
+ cmd << "'" << getSetting<string>("gs")
+ << "' -q -dNOPAUSE -dBATCH -sDEVICE=pngalpha -dEPSCrop";
+ if(safe)
+ cmd << " -dSAFER";
+ cmd << " -r" << res << "x" << res
+ << " -sOutputFile='" << outname << "'";
+ converter="gs";
+ hint="Ghostscript";
+ } else {
+ cmd << "'" << getSetting<string>("convert")
+ << "' -density " << res << "x" << res
+ << " -transparent white";
+ hint=converter="convert";
+ }
+ }
+
+ picture *group=new picture;
+ xform->call(Stack);
+ transform t=pop<transform>(Stack);
+ assert(*p);
+ if((*p)->endgroup()) {
+ cout << Error << endl;
+ error(nobegin);
+ }
+ if((*p)->begingroup()) {
+ ++level;
+ while(p != f->nodes.end() && level) {
+ drawElement *e=t.isIdentity() ? *p : (*p)->transformed(t);
+ group->append(e);
+ ++p;
+ if(p == f->nodes.end()) break;
+ assert(*p);
+ if((*p)->begingroup()) ++level;
+ if((*p)->endgroup()) {
+ if(level) --level;
+ else {
+ cout << Error << endl;
+ error(nobegin);
+ }
+ }
+ }
+ }
+ if(p != f->nodes.end()) {
+ assert(*p);
+ drawElement *e=t.isIdentity() ? *p : (*p)->transformed(t);
+ group->append(e);
+ bbox b;
+ ostringstream buf;
+ buf << prefix << "_" << n;
+ group->shipout(preamble,buf.str(),preformat,magnification,false,false);
+ string Preformat=png && group->Transparency() ? "pdf" : preformat;
+ string name=buildname(buf.str(),Preformat);
+ nameStack.push_back(name);
+ cmd << " '";
+ if(!png) cmd << preformat+":";
+ cmd << name << "'";
+ b=group->bounds();
+ b *= magnification;
+
+ cout << b << newl;
+ ++n;
+ ++p;
+ ++arg;
+ }
+
+ if(p == f->nodes.end() || arg >= maxargs) {
+ arg=0;
+ ++batch;
+ cout.flush();
+ if(!png)
+ cmd << " -scene 1 '" << xformat << ":" << outname << "'";
+
+ int status=System(cmd,0,true,converter,hint);
+ if(status) {
+ cout << Error << endl;
+ error("deconstruct failed");
+ }
+ }
+ }
+
+ if(!getSetting<bool>("keep")) {
+ for(mem::list<string>::iterator p=nameStack.begin();
+ p != nameStack.end(); ++p)
+ unlink(p->c_str());
+ }
+
+ cout << Done << endl;
+ }
+}
+
+#line 1706 "runtime.in"
+// void purge(Int divisor=0);
+void gen66(stack *Stack)
+{
+ Int divisor=vm::pop<Int>(Stack,0);
+#line 1707 "runtime.in"
+ purge(divisor);
+}
+
+
+// Pen operations
+#line 1713 "runtime.in"
+void newPen(stack *Stack)
+{
+#line 1714 "runtime.in"
+ {Stack->push<pen>(pen()); return;}
+}
+
+#line 1719 "runtime.in"
+// bool ==(pen a, pen b);
+void gen68(stack *Stack)
+{
+ pen b=vm::pop<pen>(Stack);
+ pen a=vm::pop<pen>(Stack);
+#line 1720 "runtime.in"
+ {Stack->push<bool>(a == b); return;}
+}
+
+#line 1724 "runtime.in"
+// bool !=(pen a, pen b);
+void gen69(stack *Stack)
+{
+ pen b=vm::pop<pen>(Stack);
+ pen a=vm::pop<pen>(Stack);
+#line 1725 "runtime.in"
+ {Stack->push<bool>(a != b); return;}
+}
+
+#line 1729 "runtime.in"
+// pen +(pen a, pen b);
+void gen70(stack *Stack)
+{
+ pen b=vm::pop<pen>(Stack);
+ pen a=vm::pop<pen>(Stack);
+#line 1730 "runtime.in"
+ {Stack->push<pen>(a+b); return;}
+}
+
+#line 1734 "runtime.in"
+// pen *(real a, pen b);
+void gen71(stack *Stack)
+{
+ pen b=vm::pop<pen>(Stack);
+ real a=vm::pop<real>(Stack);
+#line 1735 "runtime.in"
+ {Stack->push<pen>(a*b); return;}
+}
+
+#line 1739 "runtime.in"
+// pen *(pen a, real b);
+void gen72(stack *Stack)
+{
+ real b=vm::pop<real>(Stack);
+ pen a=vm::pop<pen>(Stack);
+#line 1740 "runtime.in"
+ {Stack->push<pen>(b*a); return;}
+}
+
+#line 1744 "runtime.in"
+// pair max(pen p);
+void gen73(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1745 "runtime.in"
+ {Stack->push<pair>(p.bounds().Max()); return;}
+}
+
+#line 1749 "runtime.in"
+// pair min(pen p);
+void gen74(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1750 "runtime.in"
+ {Stack->push<pair>(p.bounds().Min()); return;}
+}
+
+// Reset the meaning of pen default attributes.
+#line 1755 "runtime.in"
+// void resetdefaultpen();
+void gen75(stack *)
+{
+#line 1756 "runtime.in"
+ processData().defaultpen=camp::pen::initialpen();
+}
+
+#line 1760 "runtime.in"
+// void defaultpen(pen p);
+void gen76(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1761 "runtime.in"
+ processData().defaultpen=pen(resolvepen,p);
+}
+
+#line 1765 "runtime.in"
+// pen defaultpen();
+void gen77(stack *Stack)
+{
+#line 1766 "runtime.in"
+ {Stack->push<pen>(processData().defaultpen); return;}
+}
+
+#line 1770 "runtime.in"
+// bool invisible(pen p);
+void gen78(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1771 "runtime.in"
+ {Stack->push<bool>(p.invisible()); return;}
+}
+
+#line 1775 "runtime.in"
+// pen invisible();
+void gen79(stack *Stack)
+{
+#line 1776 "runtime.in"
+ {Stack->push<pen>(pen(invisiblepen)); return;}
+}
+
+#line 1780 "runtime.in"
+// pen gray(pen p);
+void gen80(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1781 "runtime.in"
+ p.togrey();
+ {Stack->push<pen>(p); return;}
+}
+
+#line 1786 "runtime.in"
+// pen rgb(pen p);
+void gen81(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1787 "runtime.in"
+ p.torgb();
+ {Stack->push<pen>(p); return;}
+}
+
+#line 1792 "runtime.in"
+// pen cmyk(pen p);
+void gen82(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1793 "runtime.in"
+ p.tocmyk();
+ {Stack->push<pen>(p); return;}
+}
+
+#line 1798 "runtime.in"
+// pen interp(pen a, pen b, real t);
+void gen83(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ pen b=vm::pop<pen>(Stack);
+ pen a=vm::pop<pen>(Stack);
+#line 1799 "runtime.in"
+ {Stack->push<pen>(interpolate(a,b,t)); return;}
+}
+
+#line 1803 "runtime.in"
+// pen rgb(real r, real g, real b);
+void gen84(stack *Stack)
+{
+ real b=vm::pop<real>(Stack);
+ real g=vm::pop<real>(Stack);
+ real r=vm::pop<real>(Stack);
+#line 1804 "runtime.in"
+ {Stack->push<pen>(pen(r,g,b)); return;}
+}
+
+#line 1808 "runtime.in"
+// pen cmyk(real c, real m, real y, real k);
+void gen85(stack *Stack)
+{
+ real k=vm::pop<real>(Stack);
+ real y=vm::pop<real>(Stack);
+ real m=vm::pop<real>(Stack);
+ real c=vm::pop<real>(Stack);
+#line 1809 "runtime.in"
+ {Stack->push<pen>(pen(c,m,y,k)); return;}
+}
+
+#line 1813 "runtime.in"
+// pen gray(real gray);
+void gen86(stack *Stack)
+{
+ real gray=vm::pop<real>(Stack);
+#line 1814 "runtime.in"
+ {Stack->push<pen>(pen(gray)); return;}
+}
+
+#line 1818 "runtime.in"
+// realarray* colors(pen p);
+void gen87(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1819 "runtime.in"
+ size_t n=ColorComponents[p.colorspace()];
+ array *a=new array(n);
+
+ switch(n) {
+ case 0:
+ break;
+ case 1:
+ (*a)[0]=p.gray();
+ break;
+ case 3:
+ (*a)[0]=p.red();
+ (*a)[1]=p.green();
+ (*a)[2]=p.blue();
+ break;
+ case 4:
+ (*a)[0]=p.cyan();
+ (*a)[1]=p.magenta();
+ (*a)[2]=p.yellow();
+ (*a)[3]=p.black();
+ break;
+ default:
+ break;
+ }
+ {Stack->push<realarray*>(a); return;}
+}
+
+#line 1846 "runtime.in"
+// string colorspace(pen p);
+void gen88(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1847 "runtime.in"
+ string s=ColorDeviceSuffix[p.colorspace()];
+ std::transform(s.begin(),s.end(),s.begin(),tolower);
+ {Stack->push<string>(s); return;}
+}
+
+#line 1853 "runtime.in"
+// pen pattern(string *s);
+void gen89(stack *Stack)
+{
+ string * s=vm::pop<string *>(Stack);
+#line 1854 "runtime.in"
+ {Stack->push<pen>(pen(setpattern,*s)); return;}
+}
+
+#line 1858 "runtime.in"
+// string pattern(pen p);
+void gen90(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1859 "runtime.in"
+ {Stack->push<string>(p.fillpattern()); return;}
+}
+
+#line 1863 "runtime.in"
+// pen fillrule(Int n);
+void gen91(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+#line 1864 "runtime.in"
+ {Stack->push<pen>(pen(n >= 0 && n < nFill ? (FillRule) n : DEFFILL)); return;}
+}
+
+#line 1868 "runtime.in"
+// Int fillrule(pen p);
+void gen92(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1869 "runtime.in"
+ {Stack->push<Int>(p.Fillrule()); return;}
+}
+
+#line 1873 "runtime.in"
+// pen opacity(real opacity=1.0, string blend=defaulttransparency);
+void gen93(stack *Stack)
+{
+ string blend=vm::pop<string>(Stack,defaulttransparency);
+ real opacity=vm::pop<real>(Stack,1.0);
+#line 1874 "runtime.in"
+ for(Int i=0; i < nBlendMode; ++i)
+ if(blend == BlendMode[i]) {Stack->push<pen>(pen(Transparency(blend,opacity))); return;}
+
+ ostringstream buf;
+ buf << "Unknown blend mode: " << "'" << blend << "'";
+ error(buf);
+}
+
+#line 1883 "runtime.in"
+// real opacity(pen p);
+void gen94(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1884 "runtime.in"
+ {Stack->push<real>(p.opacity()); return;}
+}
+
+#line 1888 "runtime.in"
+// string blend(pen p);
+void gen95(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1889 "runtime.in"
+ {Stack->push<string>(p.blend()); return;}
+}
+
+#line 1893 "runtime.in"
+// pen linetype(string *s, real offset=0, bool scale=true, bool adjust=true);
+void gen96(stack *Stack)
+{
+ bool adjust=vm::pop<bool>(Stack,true);
+ bool scale=vm::pop<bool>(Stack,true);
+ real offset=vm::pop<real>(Stack,0);
+ string * s=vm::pop<string *>(Stack);
+#line 1894 "runtime.in"
+ {Stack->push<pen>(pen(LineType(*s,offset,scale,adjust))); return;}
+}
+
+#line 1898 "runtime.in"
+// string linetype(pen p=CURRENTPEN);
+void gen97(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack,CURRENTPEN);
+#line 1899 "runtime.in"
+ {Stack->push<string>(p.stroke()); return;}
+}
+
+#line 1903 "runtime.in"
+// real offset(pen p);
+void gen98(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1904 "runtime.in"
+ {Stack->push<real>(p.linetype().offset); return;}
+}
+
+#line 1908 "runtime.in"
+// bool scale(pen p);
+void gen99(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1909 "runtime.in"
+ {Stack->push<bool>(p.linetype().scale); return;}
+}
+
+#line 1913 "runtime.in"
+// bool adjust(pen p);
+void gen100(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 1914 "runtime.in"
+ {Stack->push<bool>(p.linetype().adjust); return;}
+}
+
+#line 1918 "runtime.in"
+// pen adjust(pen p, real arclength, bool cyclic);
+void gen101(stack *Stack)
+{
+ bool cyclic=vm::pop<bool>(Stack);
+ real arclength=vm::pop<real>(Stack);
+ pen p=vm::pop<pen>(Stack);
+#line 1919 "runtime.in"
+ {Stack->push<pen>(adjustdash(p,arclength,cyclic)); return;}
+}
+
+#line 1923 "runtime.in"
+// pen linecap(Int n);
+void gen102(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+#line 1924 "runtime.in"
+ {Stack->push<pen>(pen(setlinecap,n >= 0 && n < nCap ? n : DEFCAP)); return;}
+}
+
+#line 1928 "runtime.in"
+// Int linecap(pen p=CURRENTPEN);
+void gen103(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack,CURRENTPEN);
+#line 1929 "runtime.in"
+ {Stack->push<Int>(p.cap()); return;}
+}
+
+#line 1933 "runtime.in"
+// pen linejoin(Int n);
+void gen104(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+#line 1934 "runtime.in"
+ {Stack->push<pen>(pen(setlinejoin,n >= 0 && n < nJoin ? n : DEFJOIN)); return;}
+}
+
+#line 1938 "runtime.in"
+// Int linejoin(pen p=CURRENTPEN);
+void gen105(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack,CURRENTPEN);
+#line 1939 "runtime.in"
+ {Stack->push<Int>(p.join()); return;}
+}
+
+#line 1943 "runtime.in"
+// pen miterlimit(real x);
+void gen106(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 1944 "runtime.in"
+ {Stack->push<pen>(pen(setmiterlimit,x >= 1.0 ? x : DEFJOIN)); return;}
+}
+
+#line 1948 "runtime.in"
+// real miterlimit(pen p=CURRENTPEN);
+void gen107(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack,CURRENTPEN);
+#line 1949 "runtime.in"
+ {Stack->push<real>(p.miter()); return;}
+}
+
+#line 1953 "runtime.in"
+// pen linewidth(real x);
+void gen108(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 1954 "runtime.in"
+ {Stack->push<pen>(pen(setlinewidth,x >= 0.0 ? x : DEFWIDTH)); return;}
+}
+
+#line 1958 "runtime.in"
+// real linewidth(pen p=CURRENTPEN);
+void gen109(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack,CURRENTPEN);
+#line 1959 "runtime.in"
+ {Stack->push<real>(p.width()); return;}
+}
+
+#line 1963 "runtime.in"
+// pen fontcommand(string *s);
+void gen110(stack *Stack)
+{
+ string * s=vm::pop<string *>(Stack);
+#line 1964 "runtime.in"
+ {Stack->push<pen>(pen(setfont,*s)); return;}
+}
+
+#line 1968 "runtime.in"
+// string font(pen p=CURRENTPEN);
+void gen111(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack,CURRENTPEN);
+#line 1969 "runtime.in"
+ {Stack->push<string>(p.Font()); return;}
+}
+
+#line 1973 "runtime.in"
+// pen fontsize(real size, real lineskip);
+void gen112(stack *Stack)
+{
+ real lineskip=vm::pop<real>(Stack);
+ real size=vm::pop<real>(Stack);
+#line 1974 "runtime.in"
+ {Stack->push<pen>(pen(setfontsize,size > 0.0 ? size : 0.0,
+ lineskip > 0.0 ? lineskip : 0.0)); return;}
+}
+
+#line 1979 "runtime.in"
+// real fontsize(pen p=CURRENTPEN);
+void gen113(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack,CURRENTPEN);
+#line 1980 "runtime.in"
+ {Stack->push<real>(p.size()); return;}
+}
+
+#line 1984 "runtime.in"
+// real lineskip(pen p=CURRENTPEN);
+void gen114(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack,CURRENTPEN);
+#line 1985 "runtime.in"
+ {Stack->push<real>(p.Lineskip()); return;}
+}
+
+#line 1989 "runtime.in"
+// pen overwrite(Int n);
+void gen115(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+#line 1990 "runtime.in"
+ {Stack->push<pen>(pen(setoverwrite,n >= 0 && n < nOverwrite ? (overwrite_t) n :
+ DEFWRITE)); return;}
+}
+
+#line 1995 "runtime.in"
+// Int overwrite(pen p=CURRENTPEN);
+void gen116(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack,CURRENTPEN);
+#line 1996 "runtime.in"
+ {Stack->push<Int>(p.Overwrite()); return;}
+}
+
+#line 2000 "runtime.in"
+// pen basealign(Int n);
+void gen117(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+#line 2001 "runtime.in"
+ {Stack->push<pen>(pen(n >= 0 && n < nBaseLine ? (BaseLine) n : DEFBASE)); return;}
+}
+
+#line 2005 "runtime.in"
+// Int basealign(pen p=CURRENTPEN);
+void gen118(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack,CURRENTPEN);
+#line 2006 "runtime.in"
+ {Stack->push<Int>(p.Baseline()); return;}
+}
+
+#line 2010 "runtime.in"
+// transform transform(pen p);
+void gen119(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 2011 "runtime.in"
+ {Stack->push<transform>(p.getTransform()); return;}
+}
+
+#line 2015 "runtime.in"
+// path nib(pen p);
+void gen120(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 2016 "runtime.in"
+ {Stack->push<path>(p.Path()); return;}
+}
+
+#line 2020 "runtime.in"
+// pen makepen(path p);
+void gen121(stack *Stack)
+{
+ path p=vm::pop<path>(Stack);
+#line 2021 "runtime.in"
+ {Stack->push<pen>(pen(p)); return;}
+}
+
+#line 2025 "runtime.in"
+// pen colorless(pen p);
+void gen122(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+#line 2026 "runtime.in"
+ p.colorless();
+ {Stack->push<pen>(p); return;}
+}
+
+// Interactive mode
+#line 2032 "runtime.in"
+// bool interactive();
+void gen123(stack *Stack)
+{
+#line 2033 "runtime.in"
+ {Stack->push<bool>(interact::interactive); return;}
+}
+
+#line 2038 "runtime.in"
+// bool uptodate();
+void gen124(stack *Stack)
+{
+#line 2039 "runtime.in"
+ {Stack->push<bool>(interact::uptodate); return;}
+}
+
+
+// System commands
+#line 2045 "runtime.in"
+// Int system(string s);
+void gen125(stack *Stack)
+{
+ string s=vm::pop<string>(Stack);
+#line 2046 "runtime.in"
+ if(safe) error("system() call disabled; override with option -nosafe");
+ if(s.empty()) {Stack->push<Int>(0); return;}
+ else {Stack->push<Int>(System(s.c_str())); return;}
+}
+
+#line 2053 "runtime.in"
+// bool view();
+void gen126(stack *Stack)
+{
+#line 2054 "runtime.in"
+ {Stack->push<bool>(view()); return;}
+}
+
+#line 2058 "runtime.in"
+// string asydir();
+void gen127(stack *Stack)
+{
+#line 2059 "runtime.in"
+ {Stack->push<string>(systemDir); return;}
+}
+
+#line 2063 "runtime.in"
+// string locale(string s=emptystring);
+void gen128(stack *Stack)
+{
+ string s=vm::pop<string>(Stack,emptystring);
+#line 2064 "runtime.in"
+ char *L=setlocale(LC_ALL,s.empty() ? NULL : s.c_str());
+ {Stack->push<string>(L != NULL ? string(L) : ""); return;}
+}
+
+#line 2069 "runtime.in"
+// void abort(string s=emptystring);
+void gen129(stack *Stack)
+{
+ string s=vm::pop<string>(Stack,emptystring);
+#line 2070 "runtime.in"
+ if(s.empty()) throw handled_error();
+ error(s.c_str());
+}
+
+#line 2075 "runtime.in"
+// void exit();
+void gen130(stack *)
+{
+#line 2076 "runtime.in"
+ throw quit();
+}
+
+#line 2080 "runtime.in"
+// void assert(bool b, string s=emptystring);
+void gen131(stack *Stack)
+{
+ string s=vm::pop<string>(Stack,emptystring);
+ bool b=vm::pop<bool>(Stack);
+#line 2081 "runtime.in"
+ flush(cout);
+ if(!b) {
+ ostringstream buf;
+ buf << "assert FAILED";
+ if(s != "") buf << ": " << s << endl;
+ error(buf);
+ }
+}
+
+#line 2091 "runtime.in"
+// void sleep(Int seconds);
+void gen132(stack *Stack)
+{
+ Int seconds=vm::pop<Int>(Stack);
+#line 2092 "runtime.in"
+ if(seconds <= 0) return;
+ sleep(seconds);
+}
+
+#line 2097 "runtime.in"
+// void usleep(Int microseconds);
+void gen133(stack *Stack)
+{
+ Int microseconds=vm::pop<Int>(Stack);
+#line 2098 "runtime.in"
+ if(microseconds <= 0) return;
+ usleep((unsigned long) microseconds);
+}
+
+#line 2103 "runtime.in"
+// void _eval(string *s, bool embedded, bool interactiveWrite=false);
+void gen134(stack *Stack)
+{
+ bool interactiveWrite=vm::pop<bool>(Stack,false);
+ bool embedded=vm::pop<bool>(Stack);
+ string * s=vm::pop<string *>(Stack);
+#line 2104 "runtime.in"
+ if (embedded) {
+ trans::coenv *e=Stack->getEnvironment();
+ vm::interactiveStack *is=dynamic_cast<vm::interactiveStack *>(Stack);
+ if (e && is) {
+ runStringEmbedded(*s, *e, *is);
+ } else {
+ cerr << "no runtime environment for embedded eval" << endl;
+ }
+ } else {
+ runString(*s,interactiveWrite);
+ }
+}
+
+#line 2118 "runtime.in"
+// void _eval(runnable *s, bool embedded);
+void gen135(stack *Stack)
+{
+ bool embedded=vm::pop<bool>(Stack);
+ runnable * s=vm::pop<runnable *>(Stack);
+#line 2119 "runtime.in"
+ absyntax::block *ast=new absyntax::block(s->getPos(), false);
+ ast->add(s);
+
+ if (embedded) {
+ trans::coenv *e=Stack->getEnvironment();
+ vm::interactiveStack *is=dynamic_cast<vm::interactiveStack *>(Stack);
+ if (e && is) {
+ runCodeEmbedded(ast, *e, *is);
+ } else {
+ cerr << "no runtime environment for embedded eval" << endl;
+ }
+ } else {
+ runCode(ast);
+ }
+}
+
+#line 2136 "runtime.in"
+// string location();
+void gen136(stack *Stack)
+{
+#line 2137 "runtime.in"
+ ostringstream buf;
+ buf << getPos();
+ {Stack->push<string>(buf.str()); return;}
+}
+
+// Wrapper for the stack::load() method.
+#line 2143 "runtime.in"
+void loadModule(stack *Stack)
+{
+ string * index=vm::pop<string *>(Stack);
+#line 2144 "runtime.in"
+ Stack->load(*index);
+}
+
+#line 2148 "runtime.in"
+// string cd(string s=emptystring);
+void gen138(stack *Stack)
+{
+ string s=vm::pop<string>(Stack,emptystring);
+#line 2149 "runtime.in"
+ if(!s.empty() && !globalwrite()) writeDisabled();
+ {Stack->push<string>(setPath(s.c_str())); return;}
+}
+
+#line 2154 "runtime.in"
+// void list(string *s, bool imports=false);
+void gen139(stack *Stack)
+{
+ bool imports=vm::pop<bool>(Stack,false);
+ string * s=vm::pop<string *>(Stack);
+#line 2155 "runtime.in"
+ if(*s == "-") return;
+ trans::genv ge;
+ symbol *name=symbol::trans(*s);
+ record *r=ge.getModule(name,*s);
+ r->e.list(imports ? 0 : r);
+}
+
+
+// Path operations
+#line 2165 "runtime.in"
+void nullPath(stack *Stack)
+{
+#line 2166 "runtime.in"
+ {Stack->push<path>(nullpath); return;}
+}
+
+#line 2171 "runtime.in"
+// bool ==(path a, path b);
+void gen141(stack *Stack)
+{
+ path b=vm::pop<path>(Stack);
+ path a=vm::pop<path>(Stack);
+#line 2172 "runtime.in"
+ {Stack->push<bool>(a == b); return;}
+}
+
+#line 2176 "runtime.in"
+// bool !=(path a, path b);
+void gen142(stack *Stack)
+{
+ path b=vm::pop<path>(Stack);
+ path a=vm::pop<path>(Stack);
+#line 2177 "runtime.in"
+ {Stack->push<bool>(!(a == b)); return;}
+}
+
+#line 2181 "runtime.in"
+// pair point(path p, Int t);
+void gen143(stack *Stack)
+{
+ Int t=vm::pop<Int>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2182 "runtime.in"
+ {Stack->push<pair>(p.point((Int) t)); return;}
+}
+
+#line 2186 "runtime.in"
+// pair point(path p, real t);
+void gen144(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2187 "runtime.in"
+ {Stack->push<pair>(p.point(t)); return;}
+}
+
+#line 2191 "runtime.in"
+// pair precontrol(path p, Int t);
+void gen145(stack *Stack)
+{
+ Int t=vm::pop<Int>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2192 "runtime.in"
+ {Stack->push<pair>(p.precontrol((Int) t)); return;}
+}
+
+#line 2196 "runtime.in"
+// pair precontrol(path p, real t);
+void gen146(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2197 "runtime.in"
+ {Stack->push<pair>(p.precontrol(t)); return;}
+}
+
+#line 2201 "runtime.in"
+// pair postcontrol(path p, Int t);
+void gen147(stack *Stack)
+{
+ Int t=vm::pop<Int>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2202 "runtime.in"
+ {Stack->push<pair>(p.postcontrol((Int) t)); return;}
+}
+
+#line 2206 "runtime.in"
+// pair postcontrol(path p, real t);
+void gen148(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2207 "runtime.in"
+ {Stack->push<pair>(p.postcontrol(t)); return;}
+}
+
+#line 2211 "runtime.in"
+// pair dir(path p, Int t, Int sign=0, bool normalize=true);
+void gen149(stack *Stack)
+{
+ bool normalize=vm::pop<bool>(Stack,true);
+ Int sign=vm::pop<Int>(Stack,0);
+ Int t=vm::pop<Int>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2212 "runtime.in"
+ {Stack->push<pair>(p.dir(t,sign,normalize)); return;}
+}
+
+#line 2216 "runtime.in"
+// pair dir(path p, real t, bool normalize=true);
+void gen150(stack *Stack)
+{
+ bool normalize=vm::pop<bool>(Stack,true);
+ real t=vm::pop<real>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2217 "runtime.in"
+ {Stack->push<pair>(p.dir(t,normalize)); return;}
+}
+
+#line 2221 "runtime.in"
+// pair accel(path p, Int t, Int sign=0);
+void gen151(stack *Stack)
+{
+ Int sign=vm::pop<Int>(Stack,0);
+ Int t=vm::pop<Int>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2222 "runtime.in"
+ {Stack->push<pair>(p.accel(t,sign)); return;}
+}
+
+#line 2226 "runtime.in"
+// pair accel(path p, real t);
+void gen152(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2227 "runtime.in"
+ {Stack->push<pair>(p.accel(t)); return;}
+}
+
+#line 2231 "runtime.in"
+// real radius(path p, real t);
+void gen153(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2232 "runtime.in"
+ pair v=p.dir(t,false);
+ pair a=p.accel(t);
+ real d=dot(a,v);
+ real v2=v.abs2();
+ real a2=a.abs2();
+ real denom=v2*a2-d*d;
+ real r=v2*sqrt(v2);
+ {Stack->push<real>(denom > 0 ? r/sqrt(denom) : 0.0); return;}
+}
+
+#line 2243 "runtime.in"
+// path reverse(path p);
+void gen154(stack *Stack)
+{
+ path p=vm::pop<path>(Stack);
+#line 2244 "runtime.in"
+ {Stack->push<path>(p.reverse()); return;}
+}
+
+#line 2248 "runtime.in"
+// path subpath(path p, Int a, Int b);
+void gen155(stack *Stack)
+{
+ Int b=vm::pop<Int>(Stack);
+ Int a=vm::pop<Int>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2249 "runtime.in"
+ {Stack->push<path>(p.subpath((Int) a, (Int) b)); return;}
+}
+
+#line 2253 "runtime.in"
+// path subpath(path p, real a, real b);
+void gen156(stack *Stack)
+{
+ real b=vm::pop<real>(Stack);
+ real a=vm::pop<real>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2254 "runtime.in"
+ {Stack->push<path>(p.subpath(a,b)); return;}
+}
+
+#line 2258 "runtime.in"
+// path nurb(pair z0, pair z1, pair z2, pair z3, real w0, real w1, real w2, real w3, Int m);
+void gen157(stack *Stack)
+{
+ Int m=vm::pop<Int>(Stack);
+ real w3=vm::pop<real>(Stack);
+ real w2=vm::pop<real>(Stack);
+ real w1=vm::pop<real>(Stack);
+ real w0=vm::pop<real>(Stack);
+ pair z3=vm::pop<pair>(Stack);
+ pair z2=vm::pop<pair>(Stack);
+ pair z1=vm::pop<pair>(Stack);
+ pair z0=vm::pop<pair>(Stack);
+#line 2260 "runtime.in"
+ {Stack->push<path>(nurb(z0,z1,z2,z3,w0,w1,w2,w3,m)); return;}
+}
+
+#line 2264 "runtime.in"
+// Int length(path p);
+void gen158(stack *Stack)
+{
+ path p=vm::pop<path>(Stack);
+#line 2265 "runtime.in"
+ {Stack->push<Int>(p.length()); return;}
+}
+
+#line 2269 "runtime.in"
+// bool cyclic(path p);
+void gen159(stack *Stack)
+{
+ path p=vm::pop<path>(Stack);
+#line 2270 "runtime.in"
+ {Stack->push<bool>(p.cyclic()); return;}
+}
+
+#line 2274 "runtime.in"
+// bool straight(path p, Int t);
+void gen160(stack *Stack)
+{
+ Int t=vm::pop<Int>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2275 "runtime.in"
+ {Stack->push<bool>(p.straight(t)); return;}
+}
+
+#line 2279 "runtime.in"
+// path unstraighten(path p);
+void gen161(stack *Stack)
+{
+ path p=vm::pop<path>(Stack);
+#line 2280 "runtime.in"
+ {Stack->push<path>(p.unstraighten()); return;}
+}
+
+#line 2284 "runtime.in"
+// bool piecewisestraight(path p);
+void gen162(stack *Stack)
+{
+ path p=vm::pop<path>(Stack);
+#line 2285 "runtime.in"
+ {Stack->push<bool>(p.piecewisestraight()); return;}
+}
+
+#line 2289 "runtime.in"
+// real arclength(path p);
+void gen163(stack *Stack)
+{
+ path p=vm::pop<path>(Stack);
+#line 2290 "runtime.in"
+ {Stack->push<real>(p.arclength()); return;}
+}
+
+#line 2294 "runtime.in"
+// real arctime(path p, real dval);
+void gen164(stack *Stack)
+{
+ real dval=vm::pop<real>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2295 "runtime.in"
+ {Stack->push<real>(p.arctime(dval)); return;}
+}
+
+#line 2299 "runtime.in"
+// real dirtime(path p, pair z);
+void gen165(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2300 "runtime.in"
+ {Stack->push<real>(p.directiontime(z)); return;}
+}
+
+#line 2304 "runtime.in"
+// realarray* intersect(path p, path q, real fuzz=-1);
+void gen166(stack *Stack)
+{
+ real fuzz=vm::pop<real>(Stack,-1);
+ path q=vm::pop<path>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2305 "runtime.in"
+ bool exact=fuzz <= 0.0;
+ if(fuzz < 0)
+ fuzz=BigFuzz*::max(::max(length(p.max()),length(p.min())),
+ ::max(length(q.max()),length(q.min())));
+ std::vector<real> S,T;
+ real s,t;
+ if(intersections(s,t,S,T,p,q,fuzz,true,exact)) {
+ array *V=new array(2);
+ (*V)[0]=s;
+ (*V)[1]=t;
+ {Stack->push<realarray*>(V); return;}
+ } else
+ {Stack->push<realarray*>(new array(0)); return;}
+}
+
+#line 2321 "runtime.in"
+// realarray2* intersections(path p, path q, real fuzz=-1);
+void gen167(stack *Stack)
+{
+ real fuzz=vm::pop<real>(Stack,-1);
+ path q=vm::pop<path>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2322 "runtime.in"
+ bool exact=fuzz <= 0.0;
+ if(fuzz < 0.0)
+ fuzz=BigFuzz*::max(::max(length(p.max()),length(p.min())),
+ ::max(length(q.max()),length(q.min())));
+ real s,t;
+ std::vector<real> S,T;
+ intersections(s,t,S,T,p,q,fuzz,false,true);
+ size_t n=S.size();
+ if(n == 0 && !exact) {
+ if(intersections(s,t,S,T,p,q,fuzz,true,false)) {
+ array *V=new array(1);
+ array *Vi=new array(2);
+ (*V)[0]=Vi;
+ (*Vi)[0]=s;
+ (*Vi)[1]=t;
+ {Stack->push<realarray2*>(V); return;}
+ }
+ }
+ array *V=new array(n);
+ for(size_t i=0; i < n; ++i) {
+ array *Vi=new array(2);
+ (*V)[i]=Vi;
+ (*Vi)[0]=S[i];
+ (*Vi)[1]=T[i];
+ }
+ stable_sort(V->begin(),V->end(),run::compare2<real>());
+ {Stack->push<realarray2*>(V); return;}
+}
+
+#line 2352 "runtime.in"
+// realarray* intersections(path p, explicit pair a, explicit pair b, real fuzz=-1);
+void gen168(stack *Stack)
+{
+ real fuzz=vm::pop<real>(Stack,-1);
+ pair b=vm::pop<pair>(Stack);
+ pair a=vm::pop<pair>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2353 "runtime.in"
+ if(fuzz < 0)
+ fuzz=BigFuzz*::max(::max(length(p.max()),length(p.min())),
+ ::max(length(a),length(b)));
+ std::vector<real> S;
+ intersections(S,p,a,b,fuzz);
+ sort(S.begin(),S.end());
+ size_t n=S.size();
+ array *V=new array(n);
+ for(size_t i=0; i < n; ++i)
+ (*V)[i]=S[i];
+ {Stack->push<realarray*>(V); return;}
+}
+
+// Return the intersection point of the extensions of the line segments
+// PQ and pq.
+#line 2369 "runtime.in"
+// pair extension(pair P, pair Q, pair p, pair q);
+void gen169(stack *Stack)
+{
+ pair q=vm::pop<pair>(Stack);
+ pair p=vm::pop<pair>(Stack);
+ pair Q=vm::pop<pair>(Stack);
+ pair P=vm::pop<pair>(Stack);
+#line 2370 "runtime.in"
+ pair ac=P-Q;
+ pair bd=q-p;
+ real det=ac.getx()*bd.gety()-ac.gety()*bd.getx();
+ if(det == 0) {Stack->push<pair>(pair(infinity,infinity)); return;}
+ {Stack->push<pair>(P+((p.getx()-P.getx())*bd.gety()-(p.gety()-P.gety())*bd.getx())*ac/det); return;}
+}
+
+#line 2378 "runtime.in"
+// Int size(path p);
+void gen170(stack *Stack)
+{
+ path p=vm::pop<path>(Stack);
+#line 2379 "runtime.in"
+ {Stack->push<Int>(p.size()); return;}
+}
+
+#line 2383 "runtime.in"
+// path &(path p, path q);
+void gen171(stack *Stack)
+{
+ path q=vm::pop<path>(Stack);
+ path p=vm::pop<path>(Stack);
+#line 2384 "runtime.in"
+ {Stack->push<path>(camp::concat(p,q)); return;}
+}
+
+#line 2388 "runtime.in"
+// pair min(path p);
+void gen172(stack *Stack)
+{
+ path p=vm::pop<path>(Stack);
+#line 2389 "runtime.in"
+ {Stack->push<pair>(p.min()); return;}
+}
+
+#line 2393 "runtime.in"
+// pair max(path p);
+void gen173(stack *Stack)
+{
+ path p=vm::pop<path>(Stack);
+#line 2394 "runtime.in"
+ {Stack->push<pair>(p.max()); return;}
+}
+
+#line 2398 "runtime.in"
+// realarray* mintimes(path p);
+void gen174(stack *Stack)
+{
+ path p=vm::pop<path>(Stack);
+#line 2399 "runtime.in"
+ array *V=new array(2);
+ pair z=p.mintimes();
+ (*V)[0]=z.getx();
+ (*V)[1]=z.gety();
+ {Stack->push<realarray*>(V); return;}
+}
+
+#line 2407 "runtime.in"
+// realarray* maxtimes(path p);
+void gen175(stack *Stack)
+{
+ path p=vm::pop<path>(Stack);
+#line 2408 "runtime.in"
+ array *V=new array(2);
+ pair z=p.maxtimes();
+ (*V)[0]=z.getx();
+ (*V)[1]=z.gety();
+ {Stack->push<realarray*>(V); return;}
+}
+
+#line 2416 "runtime.in"
+// real relativedistance(real theta, real phi, real t, bool atleast);
+void gen176(stack *Stack)
+{
+ bool atleast=vm::pop<bool>(Stack);
+ real t=vm::pop<real>(Stack);
+ real phi=vm::pop<real>(Stack);
+ real theta=vm::pop<real>(Stack);
+#line 2417 "runtime.in"
+ {Stack->push<real>(camp::velocity(theta,phi,tension(t,atleast))); return;}
+}
+
+#line 2421 "runtime.in"
+// Int windingnumber(patharray *p, pair z);
+void gen177(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+ patharray * p=vm::pop<patharray *>(Stack);
+#line 2422 "runtime.in"
+ {Stack->push<Int>(windingnumber(p,z)); return;}
+}
+
+#line 2426 "runtime.in"
+// bool inside(explicit patharray *g, pair z, pen fillrule=CURRENTPEN);
+void gen178(stack *Stack)
+{
+ pen fillrule=vm::pop<pen>(Stack,CURRENTPEN);
+ pair z=vm::pop<pair>(Stack);
+ patharray * g=vm::pop<patharray *>(Stack);
+#line 2427 "runtime.in"
+ {Stack->push<bool>(fillrule.inside(windingnumber(g,z))); return;}
+}
+
+#line 2431 "runtime.in"
+// bool inside(path g, pair z, pen fillrule=CURRENTPEN);
+void gen179(stack *Stack)
+{
+ pen fillrule=vm::pop<pen>(Stack,CURRENTPEN);
+ pair z=vm::pop<pair>(Stack);
+ path g=vm::pop<path>(Stack);
+#line 2432 "runtime.in"
+ {Stack->push<bool>(fillrule.inside(g.windingnumber(z))); return;}
+}
+
+// Determine the side of a--b that c lies on
+// (negative=left, zero=on line, positive=right).
+#line 2438 "runtime.in"
+// real side(pair a, pair b, pair c);
+void gen180(stack *Stack)
+{
+ pair c=vm::pop<pair>(Stack);
+ pair b=vm::pop<pair>(Stack);
+ pair a=vm::pop<pair>(Stack);
+#line 2439 "runtime.in"
+ {Stack->push<real>(orient2d(a,b,c)); return;}
+}
+
+// Determine the side of the counterclockwise circle through a,b,c that d
+// lies on (negative=inside, 0=on circle, positive=right).
+#line 2445 "runtime.in"
+// real incircle(pair a, pair b, pair c, pair d);
+void gen181(stack *Stack)
+{
+ pair d=vm::pop<pair>(Stack);
+ pair c=vm::pop<pair>(Stack);
+ pair b=vm::pop<pair>(Stack);
+ pair a=vm::pop<pair>(Stack);
+#line 2446 "runtime.in"
+ {Stack->push<real>(incircle(a.getx(),a.gety(),b.getx(),b.gety(),c.getx(),c.gety(),
+ d.getx(),d.gety())); return;}
+}
+
+
+// Path3 operations
+#line 2453 "runtime.in"
+// path3 path3(triplearray *pre, triplearray *point, triplearray *post, boolarray *straight, bool cyclic);
+void gen182(stack *Stack)
+{
+ bool cyclic=vm::pop<bool>(Stack);
+ boolarray * straight=vm::pop<boolarray *>(Stack);
+ triplearray * post=vm::pop<triplearray *>(Stack);
+ triplearray * point=vm::pop<triplearray *>(Stack);
+ triplearray * pre=vm::pop<triplearray *>(Stack);
+#line 2455 "runtime.in"
+ size_t n=checkArrays(pre,point);
+ checkEqual(n,checkArray(post));
+ checkEqual(n,checkArray(straight));
+ mem::vector<solvedKnot3> nodes(n);
+ for(size_t i=0; i < n; ++i) {
+ nodes[i].pre=read<triple>(pre,i);
+ nodes[i].point=read<triple>(point,i);
+ nodes[i].post=read<triple>(post,i);
+ nodes[i].straight=read<bool>(straight,i);
+ }
+
+ {Stack->push<path3>(path3(nodes,(Int) n,cyclic)); return;}
+}
+
+#line 2471 "runtime.in"
+void nullPath3(stack *Stack)
+{
+#line 2472 "runtime.in"
+ {Stack->push<path3>(nullpath3); return;}
+}
+
+#line 2476 "runtime.in"
+// bool ==(path3 a, path3 b);
+void gen184(stack *Stack)
+{
+ path3 b=vm::pop<path3>(Stack);
+ path3 a=vm::pop<path3>(Stack);
+#line 2477 "runtime.in"
+ {Stack->push<bool>(a == b); return;}
+}
+
+#line 2481 "runtime.in"
+// bool !=(path3 a, path3 b);
+void gen185(stack *Stack)
+{
+ path3 b=vm::pop<path3>(Stack);
+ path3 a=vm::pop<path3>(Stack);
+#line 2482 "runtime.in"
+ {Stack->push<bool>(!(a == b)); return;}
+}
+
+#line 2486 "runtime.in"
+// triple point(path3 p, Int t);
+void gen186(stack *Stack)
+{
+ Int t=vm::pop<Int>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2487 "runtime.in"
+ {Stack->push<triple>(p.point((Int) t)); return;}
+}
+
+#line 2491 "runtime.in"
+// triple point(path3 p, real t);
+void gen187(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2492 "runtime.in"
+ {Stack->push<triple>(p.point(t)); return;}
+}
+
+#line 2496 "runtime.in"
+// triple precontrol(path3 p, Int t);
+void gen188(stack *Stack)
+{
+ Int t=vm::pop<Int>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2497 "runtime.in"
+ {Stack->push<triple>(p.precontrol((Int) t)); return;}
+}
+
+#line 2501 "runtime.in"
+// triple precontrol(path3 p, real t);
+void gen189(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2502 "runtime.in"
+ {Stack->push<triple>(p.precontrol(t)); return;}
+}
+
+#line 2506 "runtime.in"
+// triple postcontrol(path3 p, Int t);
+void gen190(stack *Stack)
+{
+ Int t=vm::pop<Int>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2507 "runtime.in"
+ {Stack->push<triple>(p.postcontrol((Int) t)); return;}
+}
+
+#line 2511 "runtime.in"
+// triple postcontrol(path3 p, real t);
+void gen191(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2512 "runtime.in"
+ {Stack->push<triple>(p.postcontrol(t)); return;}
+}
+
+#line 2516 "runtime.in"
+// triple dir(path3 p, Int t, Int sign=0, bool normalize=true);
+void gen192(stack *Stack)
+{
+ bool normalize=vm::pop<bool>(Stack,true);
+ Int sign=vm::pop<Int>(Stack,0);
+ Int t=vm::pop<Int>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2517 "runtime.in"
+ {Stack->push<triple>(p.dir(t,sign,normalize)); return;}
+}
+
+#line 2521 "runtime.in"
+// triple dir(path3 p, real t, bool normalize=true);
+void gen193(stack *Stack)
+{
+ bool normalize=vm::pop<bool>(Stack,true);
+ real t=vm::pop<real>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2522 "runtime.in"
+ {Stack->push<triple>(p.dir(t,normalize)); return;}
+}
+
+#line 2526 "runtime.in"
+// triple accel(path3 p, Int t, Int sign=0);
+void gen194(stack *Stack)
+{
+ Int sign=vm::pop<Int>(Stack,0);
+ Int t=vm::pop<Int>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2527 "runtime.in"
+ {Stack->push<triple>(p.accel(t,sign)); return;}
+}
+
+#line 2531 "runtime.in"
+// triple accel(path3 p, real t);
+void gen195(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2532 "runtime.in"
+ {Stack->push<triple>(p.accel(t)); return;}
+}
+
+#line 2536 "runtime.in"
+// real radius(path3 p, real t);
+void gen196(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2537 "runtime.in"
+ triple v=p.dir(t,false);
+ triple a=p.accel(t);
+ real d=dot(a,v);
+ real v2=v.abs2();
+ real a2=a.abs2();
+ real denom=v2*a2-d*d;
+ real r=v2*sqrt(v2);
+ {Stack->push<real>(denom > 0 ? r/sqrt(denom) : 0.0); return;}
+}
+
+#line 2548 "runtime.in"
+// real radius(triple z0, triple c0, triple c1, triple z1, real t);
+void gen197(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ triple z1=vm::pop<triple>(Stack);
+ triple c1=vm::pop<triple>(Stack);
+ triple c0=vm::pop<triple>(Stack);
+ triple z0=vm::pop<triple>(Stack);
+#line 2549 "runtime.in"
+ triple v=(3.0*(z1-z0)+9.0*(c0-c1))*t*t+(6.0*(z0+c1)-12.0*c0)*t+3.0*(c0-z0);
+ triple a=6.0*(z1-z0+3.0*(c0-c1))*t+6.0*(z0+c1)-12.0*c0;
+ real d=dot(a,v);
+ real v2=v.abs2();
+ real a2=a.abs2();
+ real denom=v2*a2-d*d;
+ real r=v2*sqrt(v2);
+ {Stack->push<real>(denom > 0 ? r/sqrt(denom) : 0.0); return;}
+}
+
+#line 2560 "runtime.in"
+// path3 reverse(path3 p);
+void gen198(stack *Stack)
+{
+ path3 p=vm::pop<path3>(Stack);
+#line 2561 "runtime.in"
+ {Stack->push<path3>(p.reverse()); return;}
+}
+
+#line 2565 "runtime.in"
+// path3 subpath(path3 p, Int a, Int b);
+void gen199(stack *Stack)
+{
+ Int b=vm::pop<Int>(Stack);
+ Int a=vm::pop<Int>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2566 "runtime.in"
+ {Stack->push<path3>(p.subpath((Int) a, (Int) b)); return;}
+}
+
+#line 2570 "runtime.in"
+// path3 subpath(path3 p, real a, real b);
+void gen200(stack *Stack)
+{
+ real b=vm::pop<real>(Stack);
+ real a=vm::pop<real>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2571 "runtime.in"
+ {Stack->push<path3>(p.subpath(a,b)); return;}
+}
+
+#line 2575 "runtime.in"
+// Int length(path3 p);
+void gen201(stack *Stack)
+{
+ path3 p=vm::pop<path3>(Stack);
+#line 2576 "runtime.in"
+ {Stack->push<Int>(p.length()); return;}
+}
+
+#line 2580 "runtime.in"
+// bool cyclic(path3 p);
+void gen202(stack *Stack)
+{
+ path3 p=vm::pop<path3>(Stack);
+#line 2581 "runtime.in"
+ {Stack->push<bool>(p.cyclic()); return;}
+}
+
+#line 2585 "runtime.in"
+// bool straight(path3 p, Int t);
+void gen203(stack *Stack)
+{
+ Int t=vm::pop<Int>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2586 "runtime.in"
+ {Stack->push<bool>(p.straight(t)); return;}
+}
+
+// Return the component of vector v perpendicular to a unit vector u.
+#line 2591 "runtime.in"
+// triple perp(triple v, triple u);
+void gen204(stack *Stack)
+{
+ triple u=vm::pop<triple>(Stack);
+ triple v=vm::pop<triple>(Stack);
+#line 2592 "runtime.in"
+ {Stack->push<triple>(v-dot(v,u)*u); return;}
+}
+
+// Return the maximum perpendicular deviation of segment i of path3 g
+// from a straight line.
+#line 2598 "runtime.in"
+// real straightness(path3 p, Int t);
+void gen205(stack *Stack)
+{
+ Int t=vm::pop<Int>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2599 "runtime.in"
+ if(p.straight(t)) {Stack->push<real>(0); return;}
+ triple z0=p.point(t);
+ triple u=unit(p.point(t+1)-z0);
+ {Stack->push<real>(::max(length(perp(p.postcontrol(t)-z0,u)),
+ length(perp(p.precontrol(t+1)-z0,u)))); return;}
+}
+
+// Return the maximum perpendicular deviation of z0..controls c0 and c1..z1
+// from a straight line.
+#line 2609 "runtime.in"
+// real straightness(triple z0, triple c0, triple c1, triple z1);
+void gen206(stack *Stack)
+{
+ triple z1=vm::pop<triple>(Stack);
+ triple c1=vm::pop<triple>(Stack);
+ triple c0=vm::pop<triple>(Stack);
+ triple z0=vm::pop<triple>(Stack);
+#line 2610 "runtime.in"
+ triple u=unit(z1-z0);
+ {Stack->push<real>(::max(length(perp(c0-z0,u)),length(perp(c1-z0,u)))); return;}
+}
+
+#line 2615 "runtime.in"
+// bool piecewisestraight(path3 p);
+void gen207(stack *Stack)
+{
+ path3 p=vm::pop<path3>(Stack);
+#line 2616 "runtime.in"
+ {Stack->push<bool>(p.piecewisestraight()); return;}
+}
+
+#line 2620 "runtime.in"
+// real arclength(path3 p);
+void gen208(stack *Stack)
+{
+ path3 p=vm::pop<path3>(Stack);
+#line 2621 "runtime.in"
+ {Stack->push<real>(p.arclength()); return;}
+}
+
+#line 2625 "runtime.in"
+// real arctime(path3 p, real dval);
+void gen209(stack *Stack)
+{
+ real dval=vm::pop<real>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2626 "runtime.in"
+ {Stack->push<real>(p.arctime(dval)); return;}
+}
+
+#line 2630 "runtime.in"
+// realarray* intersect(path3 p, path3 q, real fuzz=-1);
+void gen210(stack *Stack)
+{
+ real fuzz=vm::pop<real>(Stack,-1);
+ path3 q=vm::pop<path3>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2631 "runtime.in"
+ bool exact=fuzz <= 0.0;
+ if(fuzz < 0)
+ fuzz=BigFuzz*::max(::max(length(p.max()),length(p.min())),
+ ::max(length(q.max()),length(q.min())));
+
+ std::vector<real> S,T;
+ real s,t;
+ if(intersections(s,t,S,T,p,q,fuzz,true,exact)) {
+ array *V=new array(2);
+ (*V)[0]=s;
+ (*V)[1]=t;
+ {Stack->push<realarray*>(V); return;}
+ } else
+ {Stack->push<realarray*>(new array(0)); return;}
+}
+
+#line 2648 "runtime.in"
+// realarray2* intersections(path3 p, path3 q, real fuzz=-1);
+void gen211(stack *Stack)
+{
+ real fuzz=vm::pop<real>(Stack,-1);
+ path3 q=vm::pop<path3>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2649 "runtime.in"
+ bool exact=fuzz <= 0.0;
+ if(fuzz < 0)
+ fuzz=BigFuzz*::max(::max(length(p.max()),length(p.min())),
+ ::max(length(q.max()),length(q.min())));
+ bool single=!exact;
+
+ real s,t;
+ std::vector<real> S,T;
+ bool found=intersections(s,t,S,T,p,q,fuzz,single,exact);
+ if(!found) {Stack->push<realarray2*>(new array(0)); return;}
+ array *V;
+ if(single) {
+ V=new array(1);
+ array *Vi=new array(2);
+ (*V)[0]=Vi;
+ (*Vi)[0]=s;
+ (*Vi)[1]=t;
+ } else {
+ size_t n=S.size();
+ V=new array(n);
+ for(size_t i=0; i < n; ++i) {
+ array *Vi=new array(2);
+ (*V)[i]=Vi;
+ (*Vi)[0]=S[i];
+ (*Vi)[1]=T[i];
+ }
+ }
+ stable_sort(V->begin(),V->end(),run::compare2<real>());
+ {Stack->push<realarray2*>(V); return;}
+}
+
+#line 2681 "runtime.in"
+// Int size(path3 p);
+void gen212(stack *Stack)
+{
+ path3 p=vm::pop<path3>(Stack);
+#line 2682 "runtime.in"
+ {Stack->push<Int>(p.size()); return;}
+}
+
+#line 2686 "runtime.in"
+// path3 &(path3 p, path3 q);
+void gen213(stack *Stack)
+{
+ path3 q=vm::pop<path3>(Stack);
+ path3 p=vm::pop<path3>(Stack);
+#line 2687 "runtime.in"
+ {Stack->push<path3>(camp::concat(p,q)); return;}
+}
+
+#line 2691 "runtime.in"
+// triple min(path3 p);
+void gen214(stack *Stack)
+{
+ path3 p=vm::pop<path3>(Stack);
+#line 2692 "runtime.in"
+ {Stack->push<triple>(p.min()); return;}
+}
+
+#line 2696 "runtime.in"
+// triple max(path3 p);
+void gen215(stack *Stack)
+{
+ path3 p=vm::pop<path3>(Stack);
+#line 2697 "runtime.in"
+ {Stack->push<triple>(p.max()); return;}
+}
+
+#line 2701 "runtime.in"
+// realarray* mintimes(path3 p);
+void gen216(stack *Stack)
+{
+ path3 p=vm::pop<path3>(Stack);
+#line 2702 "runtime.in"
+ array *V=new array(3);
+ triple v=p.mintimes();
+ (*V)[0]=v.getx();
+ (*V)[1]=v.gety();
+ (*V)[2]=v.getz();
+ {Stack->push<realarray*>(V); return;}
+}
+
+#line 2711 "runtime.in"
+// realarray* maxtimes(path3 p);
+void gen217(stack *Stack)
+{
+ path3 p=vm::pop<path3>(Stack);
+#line 2712 "runtime.in"
+ array *V=new array(3);
+ triple v=p.maxtimes();
+ (*V)[0]=v.getx();
+ (*V)[1]=v.gety();
+ (*V)[2]=v.getz();
+ {Stack->push<realarray*>(V); return;}
+}
+
+#line 2721 "runtime.in"
+// path3 *(realarray2 *t, path3 g);
+void gen218(stack *Stack)
+{
+ path3 g=vm::pop<path3>(Stack);
+ realarray2 * t=vm::pop<realarray2 *>(Stack);
+#line 2722 "runtime.in"
+ {Stack->push<path3>(transformed(*t,g)); return;}
+}
+
+
+// Guide operations
+#line 2728 "runtime.in"
+void nullGuide(stack *Stack)
+{
+#line 2729 "runtime.in"
+ {Stack->push<guide*>(new pathguide(path())); return;}
+}
+
+#line 2734 "runtime.in"
+void dotsGuide(stack *Stack)
+{
+ guidearray * a=vm::pop<guidearray *>(Stack);
+#line 2735 "runtime.in"
+ guidevector v;
+ size_t size=checkArray(a);
+ for (size_t i=0; i < size; ++i)
+ v.push_back(a->read<guide*>(i));
+
+ {Stack->push<guide*>(new multiguide(v)); return;}
+}
+
+#line 2744 "runtime.in"
+void dashesGuide(stack *Stack)
+{
+ guidearray * a=vm::pop<guidearray *>(Stack);
+#line 2745 "runtime.in"
+ static camp::curlSpec curly;
+ static specguide curlout(&curly, camp::OUT);
+ static specguide curlin(&curly, camp::IN);
+
+ size_t n=checkArray(a);
+
+ // a--b is equivalent to a{curl 1}..{curl 1}b
+ guidevector v;
+ if (n > 0)
+ v.push_back(a->read<guide*>(0));
+
+ if (n==1) {
+ v.push_back(&curlout);
+ v.push_back(&curlin);
+ }
+ else
+ for (size_t i=1; i<n; ++i) {
+ v.push_back(&curlout);
+ v.push_back(&curlin);
+ v.push_back(a->read<guide*>(i));
+ }
+
+ {Stack->push<guide*>(new multiguide(v)); return;}
+}
+
+#line 2771 "runtime.in"
+void newCycleToken(stack *Stack)
+{
+#line 2772 "runtime.in"
+ {Stack->push<cycleToken>(cycleToken()); return;}
+}
+
+#line 2776 "runtime.in"
+// guide* operator cast(cycleToken tok);
+void gen223(stack *Stack)
+{
+ cycleToken tok=vm::pop<cycleToken>(Stack);
+#line 2777 "runtime.in"
+// Avoid unused variable warning messages.
+ unused(&tok);
+ {Stack->push<guide*>(new cycletokguide()); return;}
+}
+
+#line 2783 "runtime.in"
+// guide* operator spec(pair z, Int p);
+void gen224(stack *Stack)
+{
+ Int p=vm::pop<Int>(Stack);
+ pair z=vm::pop<pair>(Stack);
+#line 2784 "runtime.in"
+ camp::side d=(camp::side) p;
+ camp::dirSpec *sp=new camp::dirSpec(z);
+
+ {Stack->push<guide*>(new specguide(sp,d)); return;}
+}
+
+#line 2791 "runtime.in"
+// curlSpecifier operator curl(real gamma, Int p);
+void gen225(stack *Stack)
+{
+ Int p=vm::pop<Int>(Stack);
+ real gamma=vm::pop<real>(Stack);
+#line 2792 "runtime.in"
+ camp::side s=(camp::side) p;
+ {Stack->push<curlSpecifier>(curlSpecifier(gamma,s)); return;}
+}
+
+#line 2797 "runtime.in"
+void curlSpecifierValuePart(stack *Stack)
+{
+ curlSpecifier spec=vm::pop<curlSpecifier>(Stack);
+#line 2798 "runtime.in"
+ {Stack->push<real>(spec.getValue()); return;}
+}
+
+#line 2802 "runtime.in"
+void curlSpecifierSidePart(stack *Stack)
+{
+ curlSpecifier spec=vm::pop<curlSpecifier>(Stack);
+#line 2803 "runtime.in"
+ {Stack->push<Int>(spec.getSide()); return;}
+}
+
+#line 2807 "runtime.in"
+// guide* operator cast(curlSpecifier spec);
+void gen228(stack *Stack)
+{
+ curlSpecifier spec=vm::pop<curlSpecifier>(Stack);
+#line 2808 "runtime.in"
+ {Stack->push<guide*>(new specguide(spec)); return;}
+}
+
+#line 2812 "runtime.in"
+// tensionSpecifier operator tension(real tout, real tin, bool atleast);
+void gen229(stack *Stack)
+{
+ bool atleast=vm::pop<bool>(Stack);
+ real tin=vm::pop<real>(Stack);
+ real tout=vm::pop<real>(Stack);
+#line 2813 "runtime.in"
+ {Stack->push<tensionSpecifier>(tensionSpecifier(tout, tin, atleast)); return;}
+}
+
+#line 2817 "runtime.in"
+void tensionSpecifierOutPart(stack *Stack)
+{
+ tensionSpecifier t=vm::pop<tensionSpecifier>(Stack);
+#line 2818 "runtime.in"
+ {Stack->push<real>(t.getOut()); return;}
+}
+
+#line 2822 "runtime.in"
+void tensionSpecifierInPart(stack *Stack)
+{
+ tensionSpecifier t=vm::pop<tensionSpecifier>(Stack);
+#line 2823 "runtime.in"
+ {Stack->push<real>(t.getIn()); return;}
+}
+
+#line 2827 "runtime.in"
+void tensionSpecifierAtleastPart(stack *Stack)
+{
+ tensionSpecifier t=vm::pop<tensionSpecifier>(Stack);
+#line 2828 "runtime.in"
+ {Stack->push<bool>(t.getAtleast()); return;}
+}
+
+#line 2832 "runtime.in"
+// guide* operator cast(tensionSpecifier t);
+void gen233(stack *Stack)
+{
+ tensionSpecifier t=vm::pop<tensionSpecifier>(Stack);
+#line 2833 "runtime.in"
+ {Stack->push<guide*>(new tensionguide(t)); return;}
+}
+
+#line 2837 "runtime.in"
+// guide* operator controls(pair zout, pair zin);
+void gen234(stack *Stack)
+{
+ pair zin=vm::pop<pair>(Stack);
+ pair zout=vm::pop<pair>(Stack);
+#line 2838 "runtime.in"
+ {Stack->push<guide*>(new controlguide(zout, zin)); return;}
+}
+
+#line 2842 "runtime.in"
+// Int size(guide *g);
+void gen235(stack *Stack)
+{
+ guide * g=vm::pop<guide *>(Stack);
+#line 2843 "runtime.in"
+ flatguide f;
+ g->flatten(f,false);
+ {Stack->push<Int>(f.size()); return;}
+}
+
+#line 2849 "runtime.in"
+// Int length(guide *g);
+void gen236(stack *Stack)
+{
+ guide * g=vm::pop<guide *>(Stack);
+#line 2850 "runtime.in"
+ flatguide f;
+ g->flatten(f,false);
+ {Stack->push<Int>(g->cyclic() ? f.size() : f.size()-1); return;}
+}
+
+#line 2856 "runtime.in"
+// bool cyclic(guide *g);
+void gen237(stack *Stack)
+{
+ guide * g=vm::pop<guide *>(Stack);
+#line 2857 "runtime.in"
+ flatguide f;
+ g->flatten(f,false);
+ {Stack->push<bool>(g->cyclic()); return;}
+}
+
+#line 2863 "runtime.in"
+// pair point(guide *g, Int t);
+void gen238(stack *Stack)
+{
+ Int t=vm::pop<Int>(Stack);
+ guide * g=vm::pop<guide *>(Stack);
+#line 2864 "runtime.in"
+ flatguide f;
+ g->flatten(f,false);
+ {Stack->push<pair>(f.Nodes(adjustedIndex(t,f.size(),g->cyclic())).z); return;}
+}
+
+#line 2870 "runtime.in"
+// pairarray* dirSpecifier(guide *g, Int t);
+void gen239(stack *Stack)
+{
+ Int t=vm::pop<Int>(Stack);
+ guide * g=vm::pop<guide *>(Stack);
+#line 2871 "runtime.in"
+ flatguide f;
+ g->flatten(f,false);
+ Int n=f.size();
+ if(!g->cyclic() && (t < 0 || t >= n-1)) {Stack->push<pairarray*>(new array(0)); return;}
+ array *c=new array(2);
+ (*c)[0]=f.Nodes(t).out->dir();
+ (*c)[1]=f.Nodes(t+1).in->dir();
+ {Stack->push<pairarray*>(c); return;}
+}
+
+#line 2882 "runtime.in"
+// pairarray* controlSpecifier(guide *g, Int t);
+void gen240(stack *Stack)
+{
+ Int t=vm::pop<Int>(Stack);
+ guide * g=vm::pop<guide *>(Stack);
+#line 2883 "runtime.in"
+ flatguide f;
+ g->flatten(f,false);
+ Int n=f.size();
+ if(!g->cyclic() && (t < 0 || t >= n-1)) {Stack->push<pairarray*>(new array(0)); return;}
+ knot curr=f.Nodes(t);
+ knot next=f.Nodes(t+1);
+ if(curr.out->controlled()) {
+ assert(next.in->controlled());
+ array *c=new array(2);
+ (*c)[0]=curr.out->control();
+ (*c)[1]=next.in->control();
+ {Stack->push<pairarray*>(c); return;}
+ } else {Stack->push<pairarray*>(new array(0)); return;}
+}
+
+#line 2899 "runtime.in"
+// tensionSpecifier tensionSpecifier(guide *g, Int t);
+void gen241(stack *Stack)
+{
+ Int t=vm::pop<Int>(Stack);
+ guide * g=vm::pop<guide *>(Stack);
+#line 2900 "runtime.in"
+ flatguide f;
+ g->flatten(f,false);
+ Int n=f.size();
+ if(!g->cyclic() && (t < 0 || t >= n-1)) {Stack->push<tensionSpecifier>(tensionSpecifier(1.0,1.0,false)); return;}
+ knot curr=f.Nodes(t);
+ {Stack->push<tensionSpecifier>(tensionSpecifier(curr.tout.val,f.Nodes(t+1).tin.val,curr.tout.atleast)); return;}
+}
+
+#line 2909 "runtime.in"
+// realarray* curlSpecifier(guide *g, Int t);
+void gen242(stack *Stack)
+{
+ Int t=vm::pop<Int>(Stack);
+ guide * g=vm::pop<guide *>(Stack);
+#line 2910 "runtime.in"
+ flatguide f;
+ g->flatten(f,false);
+ Int n=f.size();
+ if(!g->cyclic() && (t < 0 || t >= n-1)) {Stack->push<realarray*>(new array(0)); return;}
+ array *c=new array(2);
+ real c0=f.Nodes(t).out->curl();
+ real c1=f.Nodes(t+1).in->curl();
+ (*c)[0]=c0 >= 0.0 ? c0 : 1.0;
+ (*c)[1]=c1 >= 0.0 ? c1 : 1.0;
+ {Stack->push<realarray*>(c); return;}
+}
+
+#line 2923 "runtime.in"
+// guide* reverse(guide *g);
+void gen243(stack *Stack)
+{
+ guide * g=vm::pop<guide *>(Stack);
+#line 2924 "runtime.in"
+ flatguide f;
+ g->flatten(f,false);
+ if(f.precyclic())
+ {Stack->push<guide*>(new pathguide(g->solve().reverse())); return;}
+
+ size_t n=f.size();
+ bool cyclic=g->cyclic();
+ guidevector v;
+ if(n >= 0) {
+ size_t start=cyclic ? n : n-1;
+ knot curr=f.Nodes(start);
+ knot next;
+ for(size_t i=start; i > 0; --i) {
+ next=f.Nodes(i-1);
+ v.push_back(new pairguide(curr.z));
+ if(next.out->controlled()) {
+ assert(curr.in->controlled());
+ v.push_back(new controlguide(curr.in->control(),next.out->control()));
+ } else {
+ pair d=curr.in->dir();
+ if(d != zero)
+ v.push_back(new specguide(new dirSpec(-d),camp::OUT));
+ else {
+ real C=curr.in->curl();
+ if(C >= 0.0)
+ v.push_back(new specguide(new curlSpec(C),camp::OUT));
+ }
+ real tout=curr.tin.val;
+ real tin=next.tout.val;
+ bool atleast=next.tout.atleast;
+ if(tout != 1.0 || tin != 1.0 || next.tout.atleast)
+ v.push_back(new tensionguide(tensionSpecifier(tout,tin,atleast)));
+ d=next.out->dir();
+ if(d != zero)
+ v.push_back(new specguide(new dirSpec(-d),camp::IN));
+ else {
+ real C=next.out->curl();
+ if(C >= 0.0)
+ v.push_back(new specguide(new curlSpec(C),camp::IN));
+ }
+ }
+ curr=next;
+ }
+ if(cyclic)
+ v.push_back(new cycletokguide());
+ else
+ v.push_back(new pairguide(next.z));
+
+ }
+ {Stack->push<guide*>(new multiguide(v)); return;}
+}
+
+
+// Three-dimensional picture and surface operations
+#line 2979 "runtime.in"
+// void _draw(picture *f, path3 g, pen p);
+void gen244(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+ path3 g=vm::pop<path3>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 2980 "runtime.in"
+ f->append(new drawPath3(g,p));
+}
+
+#line 2985 "runtime.in"
+// void draw(picture *f, triplearray2 *g, bool straight, penarray *p, real opacity, real shininess, real granularity, triple normal, bool lighton, penarray *colors);
+void gen245(stack *Stack)
+{
+ penarray * colors=vm::pop<penarray *>(Stack);
+ bool lighton=vm::pop<bool>(Stack);
+ triple normal=vm::pop<triple>(Stack);
+ real granularity=vm::pop<real>(Stack);
+ real shininess=vm::pop<real>(Stack);
+ real opacity=vm::pop<real>(Stack);
+ penarray * p=vm::pop<penarray *>(Stack);
+ bool straight=vm::pop<bool>(Stack);
+ triplearray2 * g=vm::pop<triplearray2 *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 2988 "runtime.in"
+ f->append(new drawSurface(*g,straight,*p,opacity,shininess,granularity,
+ normal,lighton,*colors));
+}
+
+#line 2993 "runtime.in"
+// triple min3(picture *f);
+void gen246(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 2994 "runtime.in"
+ {Stack->push<triple>(f->bounds3().Min()); return;}
+}
+
+#line 2998 "runtime.in"
+// triple max3(picture *f);
+void gen247(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 2999 "runtime.in"
+ {Stack->push<triple>(f->bounds3().Max()); return;}
+}
+
+#line 3003 "runtime.in"
+// pair min(picture *f, realarray2 *t);
+void gen248(stack *Stack)
+{
+ realarray2 * t=vm::pop<realarray2 *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 3004 "runtime.in"
+ real *T=copyArray2C(t,4);
+ pair m=f->bounds(::min,xproject,yproject,T);
+ delete[] T;
+ {Stack->push<pair>(m); return;}
+}
+
+#line 3011 "runtime.in"
+// pair max(picture *f, realarray2 *t);
+void gen249(stack *Stack)
+{
+ realarray2 * t=vm::pop<realarray2 *>(Stack);
+ picture * f=vm::pop<picture *>(Stack);
+#line 3012 "runtime.in"
+ real *T=copyArray2C(t,4);
+ pair M=f->bounds(::max,xproject,yproject,T);
+ delete[] T;
+ {Stack->push<pair>(M); return;}
+}
+
+#line 3019 "runtime.in"
+// pair minratio(picture *f);
+void gen250(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 3020 "runtime.in"
+ {Stack->push<pair>(f->bounds(::min,xratio,yratio)); return;}
+}
+
+#line 3024 "runtime.in"
+// pair maxratio(picture *f);
+void gen251(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 3025 "runtime.in"
+ {Stack->push<pair>(f->bounds(::max,xratio,yratio)); return;}
+}
+
+#line 3029 "runtime.in"
+// real minbound(realarray *a, real b);
+void gen252(stack *Stack)
+{
+ real b=vm::pop<real>(Stack);
+ realarray * a=vm::pop<realarray *>(Stack);
+#line 3030 "runtime.in"
+ real *A=copyArrayC(a,16);
+ b=bound(A,::min,b);
+ delete[] A;
+ {Stack->push<real>(b); return;}
+}
+
+#line 3037 "runtime.in"
+// real maxbound(realarray *a, real b);
+void gen253(stack *Stack)
+{
+ real b=vm::pop<real>(Stack);
+ realarray * a=vm::pop<realarray *>(Stack);
+#line 3038 "runtime.in"
+ real *A=copyArrayC(a,16);
+ b=bound(A,::max,b);
+ delete[] A;
+ {Stack->push<real>(b); return;}
+}
+
+#line 3045 "runtime.in"
+// pair minbound(triplearray *a, realarray2 *t, pair b);
+void gen254(stack *Stack)
+{
+ pair b=vm::pop<pair>(Stack);
+ realarray2 * t=vm::pop<realarray2 *>(Stack);
+ triplearray * a=vm::pop<triplearray *>(Stack);
+#line 3046 "runtime.in"
+ triple *A=copyTripleArrayC(a,16);
+ real *T=copyArray2C(t,4);
+ b=pair(bound(A,::min,xproject,T,b.getx()),
+ bound(A,::min,yproject,T,b.gety()));
+ delete[] T;
+ delete[] A;
+ {Stack->push<pair>(b); return;}
+}
+
+#line 3056 "runtime.in"
+// pair maxbound(triplearray *a, realarray2 *t, pair b);
+void gen255(stack *Stack)
+{
+ pair b=vm::pop<pair>(Stack);
+ realarray2 * t=vm::pop<realarray2 *>(Stack);
+ triplearray * a=vm::pop<triplearray *>(Stack);
+#line 3057 "runtime.in"
+ triple *A=copyTripleArrayC(a,16);
+ real *T=copyArray2C(t,4);
+ b=pair(bound(A,::max,xproject,T,b.getx()),
+ bound(A,::max,yproject,T,b.gety()));
+ delete[] T;
+ delete[] A;
+ {Stack->push<pair>(b); return;}
+}
+
+#line 3067 "runtime.in"
+// pair max(path3 g, realarray2 *t);
+void gen256(stack *Stack)
+{
+ realarray2 * t=vm::pop<realarray2 *>(Stack);
+ path3 g=vm::pop<path3>(Stack);
+#line 3068 "runtime.in"
+ real *T=copyArray2C(t,4);
+ pair b=g.bounds(::max,xproject,yproject,T);
+ delete[] T;
+ {Stack->push<pair>(b); return;}
+}
+
+#line 3075 "runtime.in"
+// pair min(path3 g, realarray2 *t);
+void gen257(stack *Stack)
+{
+ realarray2 * t=vm::pop<realarray2 *>(Stack);
+ path3 g=vm::pop<path3>(Stack);
+#line 3076 "runtime.in"
+ real *T=copyArray2C(t,4);
+ pair b=g.bounds(::min,xproject,yproject,T);
+ delete[] T;
+ {Stack->push<pair>(b); return;}
+}
+
+#line 3083 "runtime.in"
+// real change2(triplearray2 *a);
+void gen258(stack *Stack)
+{
+ triplearray2 * a=vm::pop<triplearray2 *>(Stack);
+#line 3084 "runtime.in"
+ size_t n=checkArray(a);
+ if(n == 0) {Stack->push<real>(0.0); return;}
+
+ vm::array *a0=vm::read<vm::array*>(a,0);
+ size_t m=checkArray(a0);
+ if(m == 0) {Stack->push<real>(0.0); return;}
+ triple a00=vm::read<triple>(a0,0);
+ real M=0.0;
+
+ for(size_t i=0; i < n; ++i) {
+ vm::array *ai=vm::read<vm::array*>(a,i);
+ size_t m=checkArray(ai);
+ for(size_t j=0; j < m; ++j) {
+ real a=(vm::read<triple>(ai,j)-a00).abs2();
+ if(a > M) M=a;
+ }
+ }
+ {Stack->push<real>(M); return;}
+}
+
+#line 3105 "runtime.in"
+// bool is3D(picture *f);
+void gen259(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+#line 3106 "runtime.in"
+ {Stack->push<bool>(f->have3D()); return;}
+}
+
+#line 3110 "runtime.in"
+// pair bezier(pair a, pair b, pair c, pair d, real t);
+void gen260(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ pair d=vm::pop<pair>(Stack);
+ pair c=vm::pop<pair>(Stack);
+ pair b=vm::pop<pair>(Stack);
+ pair a=vm::pop<pair>(Stack);
+#line 3111 "runtime.in"
+ real onemt=1-t;
+ real onemt2=onemt*onemt;
+ {Stack->push<pair>(onemt2*onemt*a+t*(3.0*(onemt2*b+t*onemt*c)+t*t*d)); return;}
+}
+
+#line 3117 "runtime.in"
+// pair bezierP(pair a, pair b, pair c, pair d, real t);
+void gen261(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ pair d=vm::pop<pair>(Stack);
+ pair c=vm::pop<pair>(Stack);
+ pair b=vm::pop<pair>(Stack);
+ pair a=vm::pop<pair>(Stack);
+#line 3118 "runtime.in"
+ {Stack->push<pair>(3.0*(t*t*(d-a+3.0*(b-c))+t*(2.0*(a+c)-4.0*b)+b-a)); return;}
+}
+
+#line 3122 "runtime.in"
+// pair bezierPP(pair a, pair b, pair c, pair d, real t);
+void gen262(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ pair d=vm::pop<pair>(Stack);
+ pair c=vm::pop<pair>(Stack);
+ pair b=vm::pop<pair>(Stack);
+ pair a=vm::pop<pair>(Stack);
+#line 3123 "runtime.in"
+ {Stack->push<pair>(6.0*(t*(d-a+3.0*(b-c))+a+c-2.0*b)); return;}
+}
+
+#line 3127 "runtime.in"
+// pair bezierPPP(pair a, pair b, pair c, pair d);
+void gen263(stack *Stack)
+{
+ pair d=vm::pop<pair>(Stack);
+ pair c=vm::pop<pair>(Stack);
+ pair b=vm::pop<pair>(Stack);
+ pair a=vm::pop<pair>(Stack);
+#line 3128 "runtime.in"
+ {Stack->push<pair>(6.0*(d-a+3.0*(b-c))); return;}
+}
+
+#line 3132 "runtime.in"
+// triple bezier(triple a, triple b, triple c, triple d, real t);
+void gen264(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ triple d=vm::pop<triple>(Stack);
+ triple c=vm::pop<triple>(Stack);
+ triple b=vm::pop<triple>(Stack);
+ triple a=vm::pop<triple>(Stack);
+#line 3133 "runtime.in"
+ real onemt=1-t;
+ real onemt2=onemt*onemt;
+ {Stack->push<triple>(onemt2*onemt*a+t*(3.0*(onemt2*b+t*onemt*c)+t*t*d)); return;}
+}
+
+#line 3139 "runtime.in"
+// triple bezierP(triple a, triple b, triple c, triple d, real t);
+void gen265(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ triple d=vm::pop<triple>(Stack);
+ triple c=vm::pop<triple>(Stack);
+ triple b=vm::pop<triple>(Stack);
+ triple a=vm::pop<triple>(Stack);
+#line 3140 "runtime.in"
+ {Stack->push<triple>(3.0*(t*t*(d-a+3.0*(b-c))+t*(2.0*(a+c)-4.0*b)+b-a)); return;}
+}
+
+#line 3144 "runtime.in"
+// triple bezierPP(triple a, triple b, triple c, triple d, real t);
+void gen266(stack *Stack)
+{
+ real t=vm::pop<real>(Stack);
+ triple d=vm::pop<triple>(Stack);
+ triple c=vm::pop<triple>(Stack);
+ triple b=vm::pop<triple>(Stack);
+ triple a=vm::pop<triple>(Stack);
+#line 3145 "runtime.in"
+ {Stack->push<triple>(6.0*(t*(d-a+3.0*(b-c))+a+c-2.0*b)); return;}
+}
+
+#line 3149 "runtime.in"
+// triple bezierPPP(triple a, triple b, triple c, triple d);
+void gen267(stack *Stack)
+{
+ triple d=vm::pop<triple>(Stack);
+ triple c=vm::pop<triple>(Stack);
+ triple b=vm::pop<triple>(Stack);
+ triple a=vm::pop<triple>(Stack);
+#line 3150 "runtime.in"
+ {Stack->push<triple>(6.0*(d-a+3.0*(b-c))); return;}
+}
+
+
+// String operations
+#line 3156 "runtime.in"
+void emptyString(stack *Stack)
+{
+#line 3157 "runtime.in"
+ {Stack->push<string>(emptystring); return;}
+}
+
+#line 3162 "runtime.in"
+// Int length(string *s);
+void gen269(stack *Stack)
+{
+ string * s=vm::pop<string *>(Stack);
+#line 3163 "runtime.in"
+ {Stack->push<Int>((Int) s->length()); return;}
+}
+
+#line 3167 "runtime.in"
+// Int find(string *s, string t, Int pos=0);
+void gen270(stack *Stack)
+{
+ Int pos=vm::pop<Int>(Stack,0);
+ string t=vm::pop<string>(Stack);
+ string * s=vm::pop<string *>(Stack);
+#line 3168 "runtime.in"
+ size_t n=s->find(t,pos);
+ {Stack->push<Int>(n == string::npos ? (Int) -1 : (Int) n); return;}
+}
+
+#line 3173 "runtime.in"
+// Int rfind(string *s, string t, Int pos=-1);
+void gen271(stack *Stack)
+{
+ Int pos=vm::pop<Int>(Stack,-1);
+ string t=vm::pop<string>(Stack);
+ string * s=vm::pop<string *>(Stack);
+#line 3174 "runtime.in"
+ size_t n=s->rfind(t,pos);
+ {Stack->push<Int>(n == string::npos ? (Int) -1 : (Int) n); return;}
+}
+
+#line 3179 "runtime.in"
+// string reverse(string s);
+void gen272(stack *Stack)
+{
+ string s=vm::pop<string>(Stack);
+#line 3180 "runtime.in"
+ reverse(s.begin(),s.end());
+ {Stack->push<string>(s); return;}
+}
+
+#line 3185 "runtime.in"
+// string insert(string s, Int pos, string t);
+void gen273(stack *Stack)
+{
+ string t=vm::pop<string>(Stack);
+ Int pos=vm::pop<Int>(Stack);
+ string s=vm::pop<string>(Stack);
+#line 3186 "runtime.in"
+ if ((size_t) pos < s.length())
+ {Stack->push<string>(s.insert(pos,t)); return;}
+ {Stack->push<string>(s); return;}
+}
+
+#line 3192 "runtime.in"
+// string substr(string* s, Int pos, Int n=-1);
+void gen274(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack,-1);
+ Int pos=vm::pop<Int>(Stack);
+ string* s=vm::pop<string*>(Stack);
+#line 3193 "runtime.in"
+ if ((size_t) pos < s->length())
+ {Stack->push<string>(s->substr(pos,n)); return;}
+ {Stack->push<string>(emptystring); return;}
+}
+
+#line 3199 "runtime.in"
+// string erase(string s, Int pos, Int n);
+void gen275(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+ Int pos=vm::pop<Int>(Stack);
+ string s=vm::pop<string>(Stack);
+#line 3200 "runtime.in"
+ if ((size_t) pos < s.length())
+ {Stack->push<string>(s.erase(pos,n)); return;}
+ {Stack->push<string>(s); return;}
+}
+
+#line 3206 "runtime.in"
+// string downcase(string s);
+void gen276(stack *Stack)
+{
+ string s=vm::pop<string>(Stack);
+#line 3207 "runtime.in"
+ std::transform(s.begin(),s.end(),s.begin(),tolower);
+ {Stack->push<string>(s); return;}
+}
+
+#line 3212 "runtime.in"
+// string upcase(string s);
+void gen277(stack *Stack)
+{
+ string s=vm::pop<string>(Stack);
+#line 3213 "runtime.in"
+ std::transform(s.begin(),s.end(),s.begin(),toupper);
+ {Stack->push<string>(s); return;}
+}
+
+// returns a string constructed by translating all occurrences of the string
+// from in an array of string pairs {from,to} to the string to in string s.
+#line 3220 "runtime.in"
+// string replace(string *S, stringarray2 *translate);
+void gen278(stack *Stack)
+{
+ stringarray2 * translate=vm::pop<stringarray2 *>(Stack);
+ string * S=vm::pop<string *>(Stack);
+#line 3221 "runtime.in"
+ size_t size=checkArray(translate);
+ for(size_t i=0; i < size; i++) {
+ array *a=read<array*>(translate,i);
+ checkArray(a);
+ }
+ const char *p=S->c_str();
+ ostringstream buf;
+ while(*p) {
+ for(size_t i=0; i < size;) {
+ array *a=read<array*>(translate,i);
+ string* from=read<string*>(a,0);
+ size_t len=from->length();
+ if(strncmp(p,from->c_str(),len) != 0) {i++; continue;}
+ buf << read<string>(a,1);
+ p += len;
+ if(*p == 0) {Stack->push<string>(buf.str()); return;}
+ i=0;
+ }
+ buf << *(p++);
+ }
+ {Stack->push<string>(buf.str()); return;}
+}
+
+#line 3245 "runtime.in"
+// string format(string *format, Int x);
+void gen279(stack *Stack)
+{
+ Int x=vm::pop<Int>(Stack);
+ string * format=vm::pop<string *>(Stack);
+#line 3246 "runtime.in"
+ const char *f=format->c_str();
+
+ checkformat(f,true);
+
+ Int size=snprintf(NULL,0,f,x)+1;
+ if(size < 1) size=255; // Workaround for non-C99 compliant systems.
+ char *buf=new char[size];
+ snprintf(buf,size,f,x);
+ string s=string(buf);
+ delete[] buf;
+ {Stack->push<string>(s); return;}
+}
+
+#line 3260 "runtime.in"
+// string format(string *format, real x, string locale=emptystring);
+void gen280(stack *Stack)
+{
+ string locale=vm::pop<string>(Stack,emptystring);
+ real x=vm::pop<real>(Stack);
+ string * format=vm::pop<string *>(Stack);
+#line 3261 "runtime.in"
+ ostringstream out;
+
+ checkformat(format->c_str(),false);
+
+ const char *phantom="\\phantom{+}";
+ const char *p0=format->c_str();
+
+ const char *p=p0;
+ const char *start=NULL;
+ while (*p != 0) {
+ if(*p == '%') {
+ p++;
+ if(*p != '%') {start=p-1; break;}
+ }
+ out << *(p++);
+ }
+
+ if(!start) {Stack->push<string>(out.str()); return;}
+
+ // Allow at most 1 argument
+ while (*p != 0) {
+ if(*p == '*' || *p == '$') {Stack->push<string>(out.str()); return;}
+ if(isupper(*p) || islower(*p)) {p++; break;}
+ p++;
+ }
+
+ const char *tail=p;
+ string f=format->substr(start-p0,tail-start);
+
+ const char *oldlocale=NULL;
+ if(!locale.empty()) {
+ oldlocale=setlocale(LC_ALL,NULL);
+ if(oldlocale) oldlocale=StrdupNoGC(oldlocale);
+ setlocale(LC_ALL,locale.c_str());
+ }
+
+ Int size=snprintf(NULL,0,f.c_str(),x)+1;
+ if(size < 1) size=255; // Workaround for non-C99 compliant systems.
+ char *buf=new char[size];
+ snprintf(buf,size,f.c_str(),x);
+
+ if(oldlocale) {
+ setlocale(LC_ALL,oldlocale);
+ delete[] oldlocale;
+ }
+
+ bool trailingzero=f.find("#") < string::npos;
+ bool plus=f.find("+") < string::npos;
+ bool space=f.find(" ") < string::npos;
+
+ char *q=buf; // beginning of formatted number
+
+ if(*q == ' ') {
+ out << phantom;
+ q++;
+ }
+
+ const char decimal=*(localeconv()->decimal_point);
+
+ // Remove any spurious sign
+ if(*q == '-' || *q == '+') {
+ p=q+1;
+ bool zero=true;
+ while(*p != 0) {
+ if(!isdigit(*p) && *p != decimal) break;
+ if(isdigit(*p) && *p != '0') {zero=false; break;}
+ p++;
+ }
+ if(zero) {
+ q++;
+ if(plus || space) out << phantom;
+ }
+ }
+
+ const char *r=p=q;
+ bool dp=false;
+ while(*r != 0 && (isdigit(*r) || *r == decimal || *r == '+' || *r == '-')) {
+ if(*r == decimal) dp=true;
+ r++;
+ }
+ if(dp) { // Remove trailing zeros and/or decimal point
+ r--;
+ unsigned n=0;
+ while(r > q && *r == '0') {r--; n++;}
+ if(*r == decimal) {r--; n++;}
+ while(q <= r) out << *(q++);
+ if(!trailingzero) q += n;
+ }
+
+ bool zero=(r == p && *r == '0') && !trailingzero;
+
+ // Translate "E+/E-/e+/e-" exponential notation to TeX
+ while(*q != 0) {
+ if((*q == 'E' || *q == 'e') && (*(q+1) == '+' || *(q+1) == '-')) {
+ if(!zero) out << "\\!\\times\\!10^{";
+ bool plus=(*(q+1) == '+');
+ q++;
+ if(plus) q++;
+ if(*q == '-') out << *(q++);
+ while(*q == '0' && (zero || isdigit(*(q+1)))) q++;
+ while(isdigit(*q)) out << *(q++);
+ if(!zero)
+ out << "}";
+ break;
+ }
+ out << *(q++);
+ }
+
+ while(*tail != 0)
+ out << *(tail++);
+
+ delete[] buf;
+
+ {Stack->push<string>(out.str()); return;}
+}
+
+#line 3378 "runtime.in"
+// Int hex(string s);
+void gen281(stack *Stack)
+{
+ string s=vm::pop<string>(Stack);
+#line 3379 "runtime.in"
+ istringstream is(s);
+ is.setf(std::ios::hex,std::ios::basefield);
+ Int value;
+ if(is && is >> value && ((is >> std::ws).eof())) {Stack->push<Int>(value); return;}
+ ostringstream buf;
+ buf << "invalid hexidecimal cast from string \"" << s << "\"";
+ error(buf);
+}
+
+#line 3389 "runtime.in"
+// string string(Int x);
+void gen282(stack *Stack)
+{
+ Int x=vm::pop<Int>(Stack);
+#line 3390 "runtime.in"
+ ostringstream buf;
+ buf << x;
+ {Stack->push<string>(buf.str()); return;}
+}
+
+#line 3396 "runtime.in"
+// string string(real x, Int digits=DBL_DIG);
+void gen283(stack *Stack)
+{
+ Int digits=vm::pop<Int>(Stack,DBL_DIG);
+ real x=vm::pop<real>(Stack);
+#line 3397 "runtime.in"
+ ostringstream buf;
+ buf.precision(digits);
+ buf << x;
+ {Stack->push<string>(buf.str()); return;}
+}
+
+#line 3404 "runtime.in"
+// string time(string format=defaulttimeformat);
+void gen284(stack *Stack)
+{
+ string format=vm::pop<string>(Stack,defaulttimeformat);
+#line 3405 "runtime.in"
+#ifdef HAVE_STRFTIME
+ const time_t bintime=time(NULL);
+ if(!strftime(Time,nTime,format.c_str(),localtime(&bintime))) {Stack->push<string>(""); return;}
+ {Stack->push<string>(Time); return;}
+#else
+ {Stack->push<string>(format); return;}
+#endif
+}
+
+#line 3415 "runtime.in"
+// string time(Int seconds, string format=defaulttimeformat);
+void gen285(stack *Stack)
+{
+ string format=vm::pop<string>(Stack,defaulttimeformat);
+ Int seconds=vm::pop<Int>(Stack);
+#line 3416 "runtime.in"
+#ifdef HAVE_STRFTIME
+ const time_t bintime=seconds;
+ if(!strftime(Time,nTime,format.c_str(),localtime(&bintime))) {Stack->push<string>(""); return;}
+ {Stack->push<string>(Time); return;}
+#else
+// Avoid unused variable warning messages
+ unused(&seconds);
+ {Stack->push<string>(format); return;}
+#endif
+}
+
+#line 3428 "runtime.in"
+// Int seconds(string t=emptystring, string format=emptystring);
+void gen286(stack *Stack)
+{
+ string format=vm::pop<string>(Stack,emptystring);
+ string t=vm::pop<string>(Stack,emptystring);
+#line 3429 "runtime.in"
+#if defined(HAVE_STRPTIME)
+ const time_t bintime=time(NULL);
+ tm tm=*localtime(&bintime);
+ if(t != "" && !strptime(t.c_str(),format.c_str(),&tm)) {Stack->push<Int>(-1); return;}
+ {Stack->push<Int>((Int) mktime(&tm)); return;}
+#else
+ {Stack->push<Int>(-1); return;}
+#endif
+}
+
+#line 3440 "runtime.in"
+// realarray* _cputime();
+void gen287(stack *Stack)
+{
+#line 3441 "runtime.in"
+ static const real ticktime=1.0/sysconf(_SC_CLK_TCK);
+ struct tms buf;
+
+ ::times(&buf);
+ array *t=new array(4);
+ (*t)[0] = ((real) buf.tms_utime)*ticktime;
+ (*t)[1] = ((real) buf.tms_stime)*ticktime;
+ (*t)[2] = ((real) buf.tms_cutime)*ticktime;
+ (*t)[3] = ((real) buf.tms_cstime)*ticktime;
+ {Stack->push<realarray*>(t); return;}
+}
+
+
+// Math
+#line 3456 "runtime.in"
+// real ^(real x, Int y);
+void gen288(stack *Stack)
+{
+ Int y=vm::pop<Int>(Stack);
+ real x=vm::pop<real>(Stack);
+#line 3457 "runtime.in"
+ {Stack->push<real>(pow(x,y)); return;}
+}
+
+#line 3462 "runtime.in"
+// pair ^(pair z, Int y);
+void gen289(stack *Stack)
+{
+ Int y=vm::pop<Int>(Stack);
+ pair z=vm::pop<pair>(Stack);
+#line 3463 "runtime.in"
+ {Stack->push<pair>(pow(z,y)); return;}
+}
+
+#line 3467 "runtime.in"
+// Int quotient(Int x, Int y);
+void gen290(stack *Stack)
+{
+ Int y=vm::pop<Int>(Stack);
+ Int x=vm::pop<Int>(Stack);
+#line 3468 "runtime.in"
+ if(y == 0) dividebyzero();
+ if(y == -1) {Stack->push<Int>(Negate(x)); return;}
+// Implementation-independent definition of integer division: round down
+ {Stack->push<Int>((x-portableMod(x,y))/y); return;}
+}
+
+#line 3475 "runtime.in"
+// Int abs(Int x);
+void gen291(stack *Stack)
+{
+ Int x=vm::pop<Int>(Stack);
+#line 3476 "runtime.in"
+ {Stack->push<Int>(Abs(x)); return;}
+}
+
+#line 3480 "runtime.in"
+// Int sgn(real x);
+void gen292(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 3481 "runtime.in"
+ {Stack->push<Int>(sgn(x)); return;}
+}
+
+#line 3485 "runtime.in"
+// Int rand();
+void gen293(stack *Stack)
+{
+#line 3486 "runtime.in"
+ {Stack->push<Int>(rand()); return;}
+}
+
+#line 3490 "runtime.in"
+// void srand(Int seed);
+void gen294(stack *Stack)
+{
+ Int seed=vm::pop<Int>(Stack);
+#line 3491 "runtime.in"
+ srand(intcast(seed));
+}
+
+// a random number uniformly distributed in the interval [0,1]
+#line 3496 "runtime.in"
+// real unitrand();
+void gen295(stack *Stack)
+{
+#line 3497 "runtime.in"
+ {Stack->push<real>(((real) rand())/RAND_MAX); return;}
+}
+
+#line 3501 "runtime.in"
+// Int ceil(real x);
+void gen296(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 3502 "runtime.in"
+ {Stack->push<Int>(Intcast(ceil(x))); return;}
+}
+
+#line 3506 "runtime.in"
+// Int floor(real x);
+void gen297(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 3507 "runtime.in"
+ {Stack->push<Int>(Intcast(floor(x))); return;}
+}
+
+#line 3511 "runtime.in"
+// Int round(real x);
+void gen298(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 3512 "runtime.in"
+ if(validInt(x)) {Stack->push<Int>(Round(x)); return;}
+ integeroverflow(0);
+}
+
+#line 3517 "runtime.in"
+// Int Ceil(real x);
+void gen299(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 3518 "runtime.in"
+ {Stack->push<Int>(Ceil(x)); return;}
+}
+
+#line 3522 "runtime.in"
+// Int Floor(real x);
+void gen300(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 3523 "runtime.in"
+ {Stack->push<Int>(Floor(x)); return;}
+}
+
+#line 3527 "runtime.in"
+// Int Round(real x);
+void gen301(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 3528 "runtime.in"
+ {Stack->push<Int>(Round(Intcap(x))); return;}
+}
+
+#line 3532 "runtime.in"
+// real fmod(real x, real y);
+void gen302(stack *Stack)
+{
+ real y=vm::pop<real>(Stack);
+ real x=vm::pop<real>(Stack);
+#line 3533 "runtime.in"
+ if (y == 0.0) dividebyzero();
+ {Stack->push<real>(fmod(x,y)); return;}
+}
+
+#line 3538 "runtime.in"
+// real atan2(real y, real x);
+void gen303(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+ real y=vm::pop<real>(Stack);
+#line 3539 "runtime.in"
+ {Stack->push<real>(atan2(y,x)); return;}
+}
+
+#line 3543 "runtime.in"
+// real hypot(real x, real y);
+void gen304(stack *Stack)
+{
+ real y=vm::pop<real>(Stack);
+ real x=vm::pop<real>(Stack);
+#line 3544 "runtime.in"
+ {Stack->push<real>(hypot(x,y)); return;}
+}
+
+#line 3548 "runtime.in"
+// real remainder(real x, real y);
+void gen305(stack *Stack)
+{
+ real y=vm::pop<real>(Stack);
+ real x=vm::pop<real>(Stack);
+#line 3549 "runtime.in"
+ {Stack->push<real>(remainder(x,y)); return;}
+}
+
+#line 3553 "runtime.in"
+// real J(Int n, real x);
+void gen306(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+ Int n=vm::pop<Int>(Stack);
+#line 3554 "runtime.in"
+ {Stack->push<real>(jn(n,x)); return;}
+}
+
+#line 3558 "runtime.in"
+// real Y(Int n, real x);
+void gen307(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+ Int n=vm::pop<Int>(Stack);
+#line 3559 "runtime.in"
+ {Stack->push<real>(yn(n,x)); return;}
+}
+
+#line 3563 "runtime.in"
+// real erf(real x);
+void gen308(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 3564 "runtime.in"
+ {Stack->push<real>(erf(x)); return;}
+}
+
+#line 3568 "runtime.in"
+// real erfc(real x);
+void gen309(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 3569 "runtime.in"
+ {Stack->push<real>(erfc(x)); return;}
+}
+
+#line 3573 "runtime.in"
+// Int factorial(Int n);
+void gen310(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+#line 3574 "runtime.in"
+ if(n < 0) error(invalidargument);
+ {Stack->push<Int>(factorial(n)); return;}
+}
+
+#line 3578 "runtime.in"
+// Int choose(Int n, Int k);
+void gen311(stack *Stack)
+{
+ Int k=vm::pop<Int>(Stack);
+ Int n=vm::pop<Int>(Stack);
+#line 3579 "runtime.in"
+ if(n < 0 || k < 0 || k > n) error(invalidargument);
+ Int f=1;
+ Int r=n-k;
+ for(Int i=n; i > r; --i) {
+ if(f > Int_MAX/i) integeroverflow(0);
+ f=(f*i)/(n-i+1);
+ }
+ {Stack->push<Int>(f); return;}
+}
+
+#line 3589 "runtime.in"
+// real gamma(real x);
+void gen312(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 3590 "runtime.in"
+#ifdef HAVE_TGAMMA
+ {Stack->push<real>(tgamma(x)); return;}
+#else
+ real lg = lgamma(x);
+ {Stack->push<real>(signgam*exp(lg)); return;}
+#endif
+}
+
+// Complex Gamma function
+#line 3600 "runtime.in"
+// pair gamma(explicit pair z);
+void gen313(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 3601 "runtime.in"
+ {Stack->push<pair>(gamma(z)); return;}
+}
+
+#line 3605 "runtime.in"
+// realarray* quadraticroots(real a, real b, real c);
+void gen314(stack *Stack)
+{
+ real c=vm::pop<real>(Stack);
+ real b=vm::pop<real>(Stack);
+ real a=vm::pop<real>(Stack);
+#line 3606 "runtime.in"
+ quadraticroots q(a,b,c);
+ array *roots=new array(q.roots);
+ if(q.roots >= 1) (*roots)[0]=q.t1;
+ if(q.roots == 2) (*roots)[1]=q.t2;
+ {Stack->push<realarray*>(roots); return;}
+}
+
+#line 3614 "runtime.in"
+// pairarray* quadraticroots(explicit pair a, explicit pair b, explicit pair c);
+void gen315(stack *Stack)
+{
+ pair c=vm::pop<pair>(Stack);
+ pair b=vm::pop<pair>(Stack);
+ pair a=vm::pop<pair>(Stack);
+#line 3615 "runtime.in"
+ Quadraticroots q(a,b,c);
+ array *roots=new array(q.roots);
+ if(q.roots >= 1) (*roots)[0]=q.z1;
+ if(q.roots == 2) (*roots)[1]=q.z2;
+ {Stack->push<pairarray*>(roots); return;}
+}
+
+#line 3623 "runtime.in"
+// realarray* cubicroots(real a, real b, real c, real d);
+void gen316(stack *Stack)
+{
+ real d=vm::pop<real>(Stack);
+ real c=vm::pop<real>(Stack);
+ real b=vm::pop<real>(Stack);
+ real a=vm::pop<real>(Stack);
+#line 3624 "runtime.in"
+ cubicroots q(a,b,c,d);
+ array *roots=new array(q.roots);
+ if(q.roots >= 1) (*roots)[0]=q.t1;
+ if(q.roots >= 2) (*roots)[1]=q.t2;
+ if(q.roots == 3) (*roots)[2]=q.t3;
+ {Stack->push<realarray*>(roots); return;}
+}
+
+
+// Transforms
+#line 3635 "runtime.in"
+// bool ==(transform a, transform b);
+void gen317(stack *Stack)
+{
+ transform b=vm::pop<transform>(Stack);
+ transform a=vm::pop<transform>(Stack);
+#line 3636 "runtime.in"
+ {Stack->push<bool>(a == b); return;}
+}
+
+#line 3641 "runtime.in"
+// bool !=(transform a, transform b);
+void gen318(stack *Stack)
+{
+ transform b=vm::pop<transform>(Stack);
+ transform a=vm::pop<transform>(Stack);
+#line 3642 "runtime.in"
+ {Stack->push<bool>(a != b); return;}
+}
+
+#line 3646 "runtime.in"
+// transform +(transform a, transform b);
+void gen319(stack *Stack)
+{
+ transform b=vm::pop<transform>(Stack);
+ transform a=vm::pop<transform>(Stack);
+#line 3647 "runtime.in"
+ {Stack->push<transform>(a+b); return;}
+}
+
+#line 3651 "runtime.in"
+// transform *(transform a, transform b);
+void gen320(stack *Stack)
+{
+ transform b=vm::pop<transform>(Stack);
+ transform a=vm::pop<transform>(Stack);
+#line 3652 "runtime.in"
+ {Stack->push<transform>(a*b); return;}
+}
+
+#line 3656 "runtime.in"
+// pair *(transform t, pair z);
+void gen321(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+ transform t=vm::pop<transform>(Stack);
+#line 3657 "runtime.in"
+ {Stack->push<pair>(t*z); return;}
+}
+
+#line 3661 "runtime.in"
+// path *(transform t, path g);
+void gen322(stack *Stack)
+{
+ path g=vm::pop<path>(Stack);
+ transform t=vm::pop<transform>(Stack);
+#line 3662 "runtime.in"
+ {Stack->push<path>(transformed(t,g)); return;}
+}
+
+#line 3666 "runtime.in"
+// pen *(transform t, pen p);
+void gen323(stack *Stack)
+{
+ pen p=vm::pop<pen>(Stack);
+ transform t=vm::pop<transform>(Stack);
+#line 3667 "runtime.in"
+ {Stack->push<pen>(transformed(t,p)); return;}
+}
+
+#line 3671 "runtime.in"
+// picture* *(transform t, picture *f);
+void gen324(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+ transform t=vm::pop<transform>(Stack);
+#line 3672 "runtime.in"
+ {Stack->push<picture*>(transformed(t,f)); return;}
+}
+
+#line 3676 "runtime.in"
+// picture* *(realarray2 *t, picture *f);
+void gen325(stack *Stack)
+{
+ picture * f=vm::pop<picture *>(Stack);
+ realarray2 * t=vm::pop<realarray2 *>(Stack);
+#line 3677 "runtime.in"
+ {Stack->push<picture*>(transformed(*t,f)); return;}
+}
+
+#line 3681 "runtime.in"
+// transform ^(transform t, Int n);
+void gen326(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+ transform t=vm::pop<transform>(Stack);
+#line 3682 "runtime.in"
+ transform T;
+ if(n < 0) {
+ n=-n;
+ t=inverse(t);
+ }
+ for(Int i=0; i < n; i++) T=T*t;
+ {Stack->push<transform>(T); return;}
+}
+
+#line 3692 "runtime.in"
+void transformXPart(stack *Stack)
+{
+ transform t=vm::pop<transform>(Stack);
+#line 3693 "runtime.in"
+ {Stack->push<real>(t.getx()); return;}
+}
+
+#line 3697 "runtime.in"
+void transformYPart(stack *Stack)
+{
+ transform t=vm::pop<transform>(Stack);
+#line 3698 "runtime.in"
+ {Stack->push<real>(t.gety()); return;}
+}
+
+#line 3702 "runtime.in"
+void transformXXPart(stack *Stack)
+{
+ transform t=vm::pop<transform>(Stack);
+#line 3703 "runtime.in"
+ {Stack->push<real>(t.getxx()); return;}
+}
+
+#line 3707 "runtime.in"
+void transformXYPart(stack *Stack)
+{
+ transform t=vm::pop<transform>(Stack);
+#line 3708 "runtime.in"
+ {Stack->push<real>(t.getxy()); return;}
+}
+
+#line 3712 "runtime.in"
+void transformYXPart(stack *Stack)
+{
+ transform t=vm::pop<transform>(Stack);
+#line 3713 "runtime.in"
+ {Stack->push<real>(t.getyx()); return;}
+}
+
+#line 3717 "runtime.in"
+void transformYYPart(stack *Stack)
+{
+ transform t=vm::pop<transform>(Stack);
+#line 3718 "runtime.in"
+ {Stack->push<real>(t.getyy()); return;}
+}
+
+#line 3722 "runtime.in"
+void real6ToTransform(stack *Stack)
+{
+ real yy=vm::pop<real>(Stack);
+ real yx=vm::pop<real>(Stack);
+ real xy=vm::pop<real>(Stack);
+ real xx=vm::pop<real>(Stack);
+ real y=vm::pop<real>(Stack);
+ real x=vm::pop<real>(Stack);
+#line 3724 "runtime.in"
+ {Stack->push<transform>(transform(x,y,xx,xy,yx,yy)); return;}
+}
+
+#line 3728 "runtime.in"
+// transform shift(transform t);
+void gen334(stack *Stack)
+{
+ transform t=vm::pop<transform>(Stack);
+#line 3729 "runtime.in"
+ {Stack->push<transform>(transform(t.getx(),t.gety(),0,0,0,0)); return;}
+}
+
+#line 3733 "runtime.in"
+// transform shiftless(transform t);
+void gen335(stack *Stack)
+{
+ transform t=vm::pop<transform>(Stack);
+#line 3734 "runtime.in"
+ {Stack->push<transform>(transform(0,0,t.getxx(),t.getxy(),t.getyx(),t.getyy())); return;}
+}
+
+#line 3738 "runtime.in"
+// transform identity();
+void transformIdentity(stack *Stack)
+{
+#line 3739 "runtime.in"
+ {Stack->push<transform>(identity); return;}
+}
+
+#line 3743 "runtime.in"
+// transform inverse(transform t);
+void gen337(stack *Stack)
+{
+ transform t=vm::pop<transform>(Stack);
+#line 3744 "runtime.in"
+ {Stack->push<transform>(inverse(t)); return;}
+}
+
+#line 3748 "runtime.in"
+// transform shift(pair z);
+void gen338(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 3749 "runtime.in"
+ {Stack->push<transform>(shift(z)); return;}
+}
+
+#line 3753 "runtime.in"
+// transform shift(real x, real y);
+void gen339(stack *Stack)
+{
+ real y=vm::pop<real>(Stack);
+ real x=vm::pop<real>(Stack);
+#line 3754 "runtime.in"
+ {Stack->push<transform>(shift(pair(x,y))); return;}
+}
+
+#line 3758 "runtime.in"
+// transform xscale(real x);
+void gen340(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 3759 "runtime.in"
+ {Stack->push<transform>(xscale(x)); return;}
+}
+
+#line 3763 "runtime.in"
+// transform yscale(real y);
+void gen341(stack *Stack)
+{
+ real y=vm::pop<real>(Stack);
+#line 3764 "runtime.in"
+ {Stack->push<transform>(yscale(y)); return;}
+}
+
+#line 3768 "runtime.in"
+// transform scale(real x);
+void gen342(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 3769 "runtime.in"
+ {Stack->push<transform>(scale(x)); return;}
+}
+
+#line 3773 "runtime.in"
+// transform scale(real x, real y);
+void gen343(stack *Stack)
+{
+ real y=vm::pop<real>(Stack);
+ real x=vm::pop<real>(Stack);
+#line 3774 "runtime.in"
+ {Stack->push<transform>(xscale(x)*yscale(y)); return;}
+}
+
+#line 3778 "runtime.in"
+// transform slant(real s);
+void gen344(stack *Stack)
+{
+ real s=vm::pop<real>(Stack);
+#line 3779 "runtime.in"
+ {Stack->push<transform>(slant(s)); return;}
+}
+
+#line 3783 "runtime.in"
+// transform rotate(real angle, pair z=0);
+void gen345(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack,0);
+ real angle=vm::pop<real>(Stack);
+#line 3784 "runtime.in"
+ {Stack->push<transform>(rotatearound(z,radians(angle))); return;}
+}
+
+#line 3788 "runtime.in"
+// transform reflect(pair a, pair b);
+void gen346(stack *Stack)
+{
+ pair b=vm::pop<pair>(Stack);
+ pair a=vm::pop<pair>(Stack);
+#line 3789 "runtime.in"
+ {Stack->push<transform>(reflectabout(a,b)); return;}
+}
+
+
+// Pair operations
+#line 3795 "runtime.in"
+void pairZero(stack *Stack)
+{
+#line 3796 "runtime.in"
+ {Stack->push<pair>(zero); return;}
+}
+
+#line 3801 "runtime.in"
+void realRealToPair(stack *Stack)
+{
+ real y=vm::pop<real>(Stack);
+ real x=vm::pop<real>(Stack);
+#line 3802 "runtime.in"
+ {Stack->push<pair>(pair(x,y)); return;}
+}
+
+#line 3806 "runtime.in"
+void pairNegate(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 3807 "runtime.in"
+ {Stack->push<pair>(-z); return;}
+}
+
+#line 3811 "runtime.in"
+// real xpart(pair z);
+void pairXPart(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 3812 "runtime.in"
+ {Stack->push<real>(z.getx()); return;}
+}
+
+#line 3816 "runtime.in"
+// real ypart(pair z);
+void pairYPart(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 3817 "runtime.in"
+ {Stack->push<real>(z.gety()); return;}
+}
+
+#line 3821 "runtime.in"
+// real length(pair z);
+void gen352(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 3822 "runtime.in"
+ {Stack->push<real>(z.length()); return;}
+}
+
+#line 3826 "runtime.in"
+// real abs(pair z);
+void gen353(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 3827 "runtime.in"
+ {Stack->push<real>(z.length()); return;}
+}
+
+#line 3831 "runtime.in"
+// pair sqrt(explicit pair z);
+void gen354(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 3832 "runtime.in"
+ {Stack->push<pair>(Sqrt(z)); return;}
+}
+
+// Return the angle of z in radians.
+#line 3837 "runtime.in"
+// real angle(pair z, bool warn=true);
+void gen355(stack *Stack)
+{
+ bool warn=vm::pop<bool>(Stack,true);
+ pair z=vm::pop<pair>(Stack);
+#line 3838 "runtime.in"
+ if(!warn && z.getx() == 0.0 && z.gety() == 0.0) {Stack->push<real>(0.0); return;}
+ {Stack->push<real>(z.angle()); return;}
+}
+
+// Return the angle of z in degrees in the interval [0,360).
+#line 3844 "runtime.in"
+// real degrees(pair z, bool warn=true);
+void gen356(stack *Stack)
+{
+ bool warn=vm::pop<bool>(Stack,true);
+ pair z=vm::pop<pair>(Stack);
+#line 3845 "runtime.in"
+ if(!warn && z.getx() == 0.0 && z.gety() == 0.0) {Stack->push<real>(0.0); return;}
+ {Stack->push<real>(principalBranch(degrees(z.angle()))); return;}
+}
+
+// Convert degrees to radians.
+#line 3851 "runtime.in"
+// real radians(real degrees);
+void gen357(stack *Stack)
+{
+ real degrees=vm::pop<real>(Stack);
+#line 3852 "runtime.in"
+ {Stack->push<real>(radians(degrees)); return;}
+}
+
+// Convert radians to degrees.
+#line 3857 "runtime.in"
+// real degrees(real radians);
+void gen358(stack *Stack)
+{
+ real radians=vm::pop<real>(Stack);
+#line 3858 "runtime.in"
+ {Stack->push<real>(degrees(radians)); return;}
+}
+
+// Convert radians to degrees in [0,360).
+#line 3863 "runtime.in"
+// real Degrees(real radians);
+void gen359(stack *Stack)
+{
+ real radians=vm::pop<real>(Stack);
+#line 3864 "runtime.in"
+ {Stack->push<real>(principalBranch(degrees(radians))); return;}
+}
+
+#line 3868 "runtime.in"
+// real Sin(real deg);
+void gen360(stack *Stack)
+{
+ real deg=vm::pop<real>(Stack);
+#line 3869 "runtime.in"
+ {Stack->push<real>(sin(radians(deg))); return;}
+}
+
+#line 3873 "runtime.in"
+// real Cos(real deg);
+void gen361(stack *Stack)
+{
+ real deg=vm::pop<real>(Stack);
+#line 3874 "runtime.in"
+ {Stack->push<real>(cos(radians(deg))); return;}
+}
+
+#line 3878 "runtime.in"
+// real Tan(real deg);
+void gen362(stack *Stack)
+{
+ real deg=vm::pop<real>(Stack);
+#line 3879 "runtime.in"
+ {Stack->push<real>(tan(radians(deg))); return;}
+}
+
+#line 3883 "runtime.in"
+// real aSin(real x);
+void gen363(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 3884 "runtime.in"
+ {Stack->push<real>(degrees(asin(x))); return;}
+}
+
+#line 3888 "runtime.in"
+// real aCos(real x);
+void gen364(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 3889 "runtime.in"
+ {Stack->push<real>(degrees(acos(x))); return;}
+}
+
+#line 3893 "runtime.in"
+// real aTan(real x);
+void gen365(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+#line 3894 "runtime.in"
+ {Stack->push<real>(degrees(atan(x))); return;}
+}
+
+#line 3898 "runtime.in"
+// pair unit(pair z);
+void gen366(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 3899 "runtime.in"
+ {Stack->push<pair>(unit(z)); return;}
+}
+
+#line 3903 "runtime.in"
+// pair dir(real degrees);
+void gen367(stack *Stack)
+{
+ real degrees=vm::pop<real>(Stack);
+#line 3904 "runtime.in"
+ {Stack->push<pair>(expi(radians(degrees))); return;}
+}
+
+#line 3908 "runtime.in"
+// pair dir(explicit pair z);
+void gen368(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 3909 "runtime.in"
+ {Stack->push<pair>(unit(z)); return;}
+}
+
+#line 3913 "runtime.in"
+// pair expi(real angle);
+void gen369(stack *Stack)
+{
+ real angle=vm::pop<real>(Stack);
+#line 3914 "runtime.in"
+ {Stack->push<pair>(expi(angle)); return;}
+}
+
+#line 3918 "runtime.in"
+// pair exp(explicit pair z);
+void gen370(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 3919 "runtime.in"
+ {Stack->push<pair>(exp(z)); return;}
+}
+
+#line 3923 "runtime.in"
+// pair log(explicit pair z);
+void gen371(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 3924 "runtime.in"
+ {Stack->push<pair>(pair(log(z.length()),z.angle())); return;}
+}
+
+#line 3928 "runtime.in"
+// pair sin(explicit pair z);
+void gen372(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 3929 "runtime.in"
+ {Stack->push<pair>(sin(z)); return;}
+}
+
+#line 3933 "runtime.in"
+// pair cos(explicit pair z);
+void gen373(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 3934 "runtime.in"
+ {Stack->push<pair>(pair(cos(z.getx())*cosh(z.gety()),-sin(z.getx())*sinh(z.gety()))); return;}
+}
+
+#line 3938 "runtime.in"
+// pair conj(pair z);
+void gen374(stack *Stack)
+{
+ pair z=vm::pop<pair>(Stack);
+#line 3939 "runtime.in"
+ {Stack->push<pair>(conj(z)); return;}
+}
+
+#line 3943 "runtime.in"
+// pair realmult(pair z, pair w);
+void gen375(stack *Stack)
+{
+ pair w=vm::pop<pair>(Stack);
+ pair z=vm::pop<pair>(Stack);
+#line 3944 "runtime.in"
+ {Stack->push<pair>(pair (z.getx()*w.getx(),z.gety()*w.gety())); return;}
+}
+
+#line 3948 "runtime.in"
+// triple realmult(triple u, triple v);
+void gen376(stack *Stack)
+{
+ triple v=vm::pop<triple>(Stack);
+ triple u=vm::pop<triple>(Stack);
+#line 3949 "runtime.in"
+ {Stack->push<triple>(triple (u.getx()*v.getx(),u.gety()*v.gety(),u.getz()*v.getz())); return;}
+}
+
+// To avoid confusion, a dot product requires explicit pair arguments.
+#line 3954 "runtime.in"
+// real dot(explicit pair z, explicit pair w);
+void gen377(stack *Stack)
+{
+ pair w=vm::pop<pair>(Stack);
+ pair z=vm::pop<pair>(Stack);
+#line 3955 "runtime.in"
+ {Stack->push<real>(dot(z,w)); return;}
+}
+
+
+// Triple operations
+#line 3961 "runtime.in"
+void tripleZero(stack *Stack)
+{
+#line 3962 "runtime.in"
+ static triple zero;
+ {Stack->push<triple>(zero); return;}
+}
+
+#line 3968 "runtime.in"
+void realRealRealToTriple(stack *Stack)
+{
+ real z=vm::pop<real>(Stack);
+ real y=vm::pop<real>(Stack);
+ real x=vm::pop<real>(Stack);
+#line 3969 "runtime.in"
+ {Stack->push<triple>(triple(x,y,z)); return;}
+}
+
+#line 3973 "runtime.in"
+// real xpart(triple v);
+void tripleXPart(stack *Stack)
+{
+ triple v=vm::pop<triple>(Stack);
+#line 3974 "runtime.in"
+ {Stack->push<real>(v.getx()); return;}
+}
+
+#line 3978 "runtime.in"
+// real ypart(triple v);
+void tripleYPart(stack *Stack)
+{
+ triple v=vm::pop<triple>(Stack);
+#line 3979 "runtime.in"
+ {Stack->push<real>(v.gety()); return;}
+}
+
+#line 3983 "runtime.in"
+// real zpart(triple v);
+void tripleZPart(stack *Stack)
+{
+ triple v=vm::pop<triple>(Stack);
+#line 3984 "runtime.in"
+ {Stack->push<real>(v.getz()); return;}
+}
+
+#line 3988 "runtime.in"
+// triple *(real x, triple v);
+void gen383(stack *Stack)
+{
+ triple v=vm::pop<triple>(Stack);
+ real x=vm::pop<real>(Stack);
+#line 3989 "runtime.in"
+ {Stack->push<triple>(x*v); return;}
+}
+
+#line 3993 "runtime.in"
+// triple *(triple v, real x);
+void gen384(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+ triple v=vm::pop<triple>(Stack);
+#line 3994 "runtime.in"
+ {Stack->push<triple>(v*x); return;}
+}
+
+#line 3998 "runtime.in"
+// triple /(triple v, real x);
+void gen385(stack *Stack)
+{
+ real x=vm::pop<real>(Stack);
+ triple v=vm::pop<triple>(Stack);
+#line 3999 "runtime.in"
+ {Stack->push<triple>(v/x); return;}
+}
+
+#line 4003 "runtime.in"
+// real length(triple v);
+void gen386(stack *Stack)
+{
+ triple v=vm::pop<triple>(Stack);
+#line 4004 "runtime.in"
+ {Stack->push<real>(v.length()); return;}
+}
+
+#line 4008 "runtime.in"
+// real abs(triple v);
+void gen387(stack *Stack)
+{
+ triple v=vm::pop<triple>(Stack);
+#line 4009 "runtime.in"
+ {Stack->push<real>(v.length()); return;}
+}
+
+#line 4013 "runtime.in"
+// real polar(triple v);
+void gen388(stack *Stack)
+{
+ triple v=vm::pop<triple>(Stack);
+#line 4014 "runtime.in"
+ {Stack->push<real>(v.polar()); return;}
+}
+
+#line 4018 "runtime.in"
+// real azimuth(triple v);
+void gen389(stack *Stack)
+{
+ triple v=vm::pop<triple>(Stack);
+#line 4019 "runtime.in"
+ {Stack->push<real>(v.azimuth()); return;}
+}
+
+#line 4023 "runtime.in"
+// real colatitude(triple v);
+void gen390(stack *Stack)
+{
+ triple v=vm::pop<triple>(Stack);
+#line 4024 "runtime.in"
+ {Stack->push<real>(degrees(v.polar())); return;}
+}
+
+#line 4028 "runtime.in"
+// real latitude(triple v);
+void gen391(stack *Stack)
+{
+ triple v=vm::pop<triple>(Stack);
+#line 4029 "runtime.in"
+ {Stack->push<real>(90.0-degrees(v.polar())); return;}
+}
+
+// Return the longitude of v in [0,360).
+#line 4034 "runtime.in"
+// real longitude(triple v, bool warn=true);
+void gen392(stack *Stack)
+{
+ bool warn=vm::pop<bool>(Stack,true);
+ triple v=vm::pop<triple>(Stack);
+#line 4035 "runtime.in"
+ if(!warn && v.getx() == 0.0 && v.gety() == 0.0) {Stack->push<real>(0.0); return;}
+ {Stack->push<real>(principalBranch(degrees(v.azimuth()))); return;}
+}
+
+#line 4040 "runtime.in"
+// triple unit(triple v);
+void gen393(stack *Stack)
+{
+ triple v=vm::pop<triple>(Stack);
+#line 4041 "runtime.in"
+ {Stack->push<triple>(unit(v)); return;}
+}
+
+#line 4045 "runtime.in"
+// real dot(triple u, triple v);
+void gen394(stack *Stack)
+{
+ triple v=vm::pop<triple>(Stack);
+ triple u=vm::pop<triple>(Stack);
+#line 4046 "runtime.in"
+ {Stack->push<real>(dot(u,v)); return;}
+}
+
+#line 4050 "runtime.in"
+// triple cross(triple u, triple v);
+void gen395(stack *Stack)
+{
+ triple v=vm::pop<triple>(Stack);
+ triple u=vm::pop<triple>(Stack);
+#line 4051 "runtime.in"
+ {Stack->push<triple>(cross(u,v)); return;}
+}
+
+#line 4055 "runtime.in"
+// triple expi(real polar, real azimuth);
+void gen396(stack *Stack)
+{
+ real azimuth=vm::pop<real>(Stack);
+ real polar=vm::pop<real>(Stack);
+#line 4056 "runtime.in"
+ {Stack->push<triple>(expi(polar,azimuth)); return;}
+}
+
+#line 4060 "runtime.in"
+// triple dir(real colatitude, real longitude);
+void gen397(stack *Stack)
+{
+ real longitude=vm::pop<real>(Stack);
+ real colatitude=vm::pop<real>(Stack);
+#line 4061 "runtime.in"
+ {Stack->push<triple>(expi(radians(colatitude),radians(longitude))); return;}
+}
+
+
+// System routines
+#line 4067 "runtime.in"
+// void atupdate(callable *f);
+void gen398(stack *Stack)
+{
+ callable * f=vm::pop<callable *>(Stack);
+#line 4068 "runtime.in"
+ processData().atUpdateFunction=f;
+}
+
+#line 4073 "runtime.in"
+// callable* atupdate();
+void gen399(stack *Stack)
+{
+#line 4074 "runtime.in"
+ {Stack->push<callable*>(processData().atUpdateFunction); return;}
+}
+
+#line 4078 "runtime.in"
+// void atexit(callable *f);
+void gen400(stack *Stack)
+{
+ callable * f=vm::pop<callable *>(Stack);
+#line 4079 "runtime.in"
+ processData().atExitFunction=f;
+}
+
+#line 4083 "runtime.in"
+// callable* atexit();
+void gen401(stack *Stack)
+{
+#line 4084 "runtime.in"
+ {Stack->push<callable*>(processData().atExitFunction); return;}
+}
+
+#line 4088 "runtime.in"
+// void atbreakpoint(callableBp *f);
+void gen402(stack *Stack)
+{
+ callableBp * f=vm::pop<callableBp *>(Stack);
+#line 4089 "runtime.in"
+ processData().atBreakpointFunction=f;
+}
+
+#line 4093 "runtime.in"
+// void breakpoint(runnable *s=NULL);
+void gen403(stack *Stack)
+{
+ runnable * s=vm::pop<runnable *>(Stack,NULL);
+#line 4094 "runtime.in"
+ breakpoint(Stack,s);
+}
+
+#line 4098 "runtime.in"
+// string locatefile(string file);
+void gen404(stack *Stack)
+{
+ string file=vm::pop<string>(Stack);
+#line 4099 "runtime.in"
+ {Stack->push<string>(locateFile(file)); return;}
+}
+
+#line 4103 "runtime.in"
+// void stop(string file, Int line, runnable *s=NULL);
+void gen405(stack *Stack)
+{
+ runnable * s=vm::pop<runnable *>(Stack,NULL);
+ Int line=vm::pop<Int>(Stack);
+ string file=vm::pop<string>(Stack);
+#line 4104 "runtime.in"
+ file=locateFile(file);
+ clear(file,line);
+ cout << "setting breakpoint at " << file << ": " << line << endl;
+ bplist.push_back(bpinfo(file,line,s));
+}
+
+#line 4111 "runtime.in"
+// void breakpoints();
+void gen406(stack *)
+{
+#line 4112 "runtime.in"
+ for(mem::list<bpinfo>::iterator p=bplist.begin(); p != bplist.end(); ++p)
+ cout << p->f.name() << ": " << p->f.line() << endl;
+}
+
+#line 4117 "runtime.in"
+// void clear(string file, Int line);
+void gen407(stack *Stack)
+{
+ Int line=vm::pop<Int>(Stack);
+ string file=vm::pop<string>(Stack);
+#line 4118 "runtime.in"
+ file=locateFile(file);
+ clear(file,line,true);
+}
+
+#line 4123 "runtime.in"
+// void clear();
+void gen408(stack *)
+{
+#line 4124 "runtime.in"
+ bplist.clear();
+}
+
+// Strip directory from string
+#line 4129 "runtime.in"
+// string stripdirectory(string *s);
+void gen409(stack *Stack)
+{
+ string * s=vm::pop<string *>(Stack);
+#line 4130 "runtime.in"
+ {Stack->push<string>(stripDir(*s)); return;}
+}
+
+// Strip directory from string
+#line 4135 "runtime.in"
+// string stripfile(string *s);
+void gen410(stack *Stack)
+{
+ string * s=vm::pop<string *>(Stack);
+#line 4136 "runtime.in"
+ {Stack->push<string>(stripFile(*s)); return;}
+}
+
+// Strip file extension from string
+#line 4141 "runtime.in"
+// string stripextension(string *s);
+void gen411(stack *Stack)
+{
+ string * s=vm::pop<string *>(Stack);
+#line 4142 "runtime.in"
+ {Stack->push<string>(stripExt(*s)); return;}
+}
+
+// Call ImageMagick convert.
+#line 4147 "runtime.in"
+// Int convert(string args=emptystring, string file=emptystring, string format=emptystring);
+void gen412(stack *Stack)
+{
+ string format=vm::pop<string>(Stack,emptystring);
+ string file=vm::pop<string>(Stack,emptystring);
+ string args=vm::pop<string>(Stack,emptystring);
+#line 4149 "runtime.in"
+ ostringstream cmd;
+
+ string name=convertname(file,format);
+ cmd << "'" << getSetting<string>("convert") << "' " << args
+ << " '" << name << "'";
+ bool quiet=verbose <= 1;
+ Int ret=System(cmd,quiet ? 1 : 0,true,"convert","your ImageMagick convert utility");
+
+ if(ret == 0 && verbose > 0)
+ cout << "Wrote " << ((file.empty()) ? name : file) << endl;
+
+ {Stack->push<Int>(ret); return;}
+}
+
+// Call ImageMagick animate.
+#line 4165 "runtime.in"
+// Int animate(string args=emptystring, string file=emptystring, string format=emptystring);
+void gen413(stack *Stack)
+{
+ string format=vm::pop<string>(Stack,emptystring);
+ string file=vm::pop<string>(Stack,emptystring);
+ string args=vm::pop<string>(Stack,emptystring);
+#line 4167 "runtime.in"
+#ifndef __CYGWIN__
+ string name=convertname(file,format,false);
+ if(view()) {
+ ostringstream cmd;
+ cmd << "'" << getSetting<string>("animate") << "' " << args
+ << " '" << name << "'";
+ {Stack->push<Int>(System(cmd,0,false,"animate","your animated GIF viewer")); return;}
+ }
+#endif
+ {Stack->push<Int>(0); return;}
+}
+
+// Delete file named s.
+#line 4181 "runtime.in"
+// Int delete(string *s);
+void gen414(stack *Stack)
+{
+ string * s=vm::pop<string *>(Stack);
+#line 4182 "runtime.in"
+ checkLocal(*s);
+ Int rc=unlink(s->c_str());
+ if(rc == 0 && verbose > 0)
+ cout << "Deleted " << *s << endl;
+ {Stack->push<Int>(rc); return;}
+}
+
+// Rename file "from" to file "to".
+#line 4191 "runtime.in"
+// Int rename(string *from, string *to);
+void gen415(stack *Stack)
+{
+ string * to=vm::pop<string *>(Stack);
+ string * from=vm::pop<string *>(Stack);
+#line 4192 "runtime.in"
+ checkLocal(*from);
+ checkLocal(*to);
+ Int rc=rename(from->c_str(),to->c_str());
+ if(rc == 0 && verbose > 0)
+ cout << "Renamed " << *from << " to " << *to << endl;
+ {Stack->push<Int>(rc); return;}
+}
+
+
+// Array operations
+
+// Create an empty array.
+#line 4205 "runtime.in"
+void emptyArray(stack *Stack)
+{
+#line 4206 "runtime.in"
+ {Stack->push<array*>(new array(0)); return;}
+}
+
+// Create a new array (technically a vector).
+// This array will be multidimensional. First the number of dimensions
+// is popped off the stack, followed by each dimension in reverse order.
+// The array itself is technically a one dimensional array of one
+// dimension arrays and so on.
+#line 4215 "runtime.in"
+void newDeepArray(stack *Stack)
+{
+ Int depth=vm::pop<Int>(Stack);
+#line 4216 "runtime.in"
+ assert(depth > 0);
+
+ Int *dims = new Int[depth];
+
+ for (Int index = depth-1; index >= 0; index--) {
+ Int i=pop<Int>(Stack);
+ if(i < 0) error("cannot create a negative length array");
+ dims[index]=i;
+ }
+
+ array *a=deepArray(depth, dims);
+ delete[] dims;
+ {Stack->push<array*>(a); return;}
+}
+
+// Creates an array with elements already specified. First, the number
+// of elements is popped off the stack, followed by each element in
+// reverse order.
+#line 4235 "runtime.in"
+void newInitializedArray(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+#line 4236 "runtime.in"
+ assert(n >= 0);
+
+ array *a = new array(n);
+
+ for (Int index = n-1; index >= 0; index--)
+ (*a)[index] = pop(Stack);
+
+ {Stack->push<array*>(a); return;}
+}
+
+// Similar to newInitializedArray, but after the n elements, append another
+// array to it.
+#line 4249 "runtime.in"
+void newAppendedArray(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+ array* tail=vm::pop<array*>(Stack);
+#line 4250 "runtime.in"
+ assert(n >= 0);
+
+ array *a = new array(n);
+
+ for (Int index = n-1; index >= 0; index--)
+ (*a)[index] = pop(Stack);
+
+ copy(tail->begin(), tail->end(), back_inserter(*a));
+
+ {Stack->push<array*>(a); return;}
+}
+
+// The function T[] array(int n, T value, int depth=0) produces a array of n
+// copies of x, where each copy is copied up to depth.
+#line 4265 "runtime.in"
+void newDuplicateArray(stack *Stack)
+{
+ Int depth=vm::pop<Int>(Stack,Int_MAX);
+ item value=vm::pop(Stack);
+ Int n=vm::pop<Int>(Stack);
+#line 4266 "runtime.in"
+ if(n < 0) error("cannot create a negative length array");
+ if(depth < 0) error("cannot copy to a negative depth");
+
+ {Stack->push<array*>(new array(n, value, depth)); return;}
+}
+
+// Read an element from an array. Checks for initialization & bounds.
+#line 4274 "runtime.in"
+void arrayRead(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+ array * a=vm::pop<array *>(Stack);
+#line 4275 "runtime.in"
+ item& i=arrayRead(a,n);
+ if (i.empty()) {
+ ostringstream buf;
+ buf << "read uninitialized value from array at index " << n;
+ error(buf);
+ }
+ {Stack->push(i); return;}
+}
+
+// Slice a substring from an array.
+#line 4286 "runtime.in"
+void arraySliceRead(stack *Stack)
+{
+ Int right=vm::pop<Int>(Stack);
+ Int left=vm::pop<Int>(Stack);
+ array * a=vm::pop<array *>(Stack);
+#line 4287 "runtime.in"
+ checkArray(a);
+ {Stack->push(a->slice(left, right)); return;}
+}
+
+// Slice a substring from an array. This implements the cases a[i:] and a[:]
+// where the endpoint is not given, and assumed to be the length of the array.
+#line 4294 "runtime.in"
+void arraySliceReadToEnd(stack *Stack)
+{
+ Int left=vm::pop<Int>(Stack);
+ array * a=vm::pop<array *>(Stack);
+#line 4295 "runtime.in"
+ size_t len=checkArray(a);
+ {Stack->push(a->slice(left, (Int)len)); return;}
+}
+
+// Read an element from an array of arrays. Check bounds and initialize
+// as necessary.
+#line 4302 "runtime.in"
+void arrayArrayRead(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+ array * a=vm::pop<array *>(Stack);
+#line 4303 "runtime.in"
+ item& i=arrayRead(a,n);
+ if (i.empty()) i=new array(0);
+ {Stack->push(i); return;}
+}
+
+// Write an element to an array. Increase size if necessary.
+#line 4310 "runtime.in"
+void arrayWrite(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+ array * a=vm::pop<array *>(Stack);
+ item value=vm::pop(Stack);
+#line 4311 "runtime.in"
+ size_t len=checkArray(a);
+ bool cyclic=a->cyclic();
+ if(cyclic && len > 0) n=imod(n,len);
+ else {
+ if(cyclic) outOfBounds("writing cyclic",len,n);
+ if(n < 0) outOfBounds("writing",len,n);
+ if(len <= (size_t) n)
+ a->resize(n+1);
+ }
+ (*a)[n] = value;
+ {Stack->push(value); return;}
+}
+
+#line 4325 "runtime.in"
+void arraySliceWrite(stack *Stack)
+{
+ Int right=vm::pop<Int>(Stack);
+ Int left=vm::pop<Int>(Stack);
+ array * dest=vm::pop<array *>(Stack);
+ array * src=vm::pop<array *>(Stack);
+#line 4326 "runtime.in"
+ checkArray(src);
+ checkArray(dest);
+ dest->setSlice(left, right, src);
+ {Stack->push<array*>(src); return;}
+}
+
+#line 4333 "runtime.in"
+void arraySliceWriteToEnd(stack *Stack)
+{
+ Int left=vm::pop<Int>(Stack);
+ array * dest=vm::pop<array *>(Stack);
+ array * src=vm::pop<array *>(Stack);
+#line 4334 "runtime.in"
+ checkArray(src);
+ size_t len=checkArray(dest);
+ dest->setSlice(left, (Int) len, src);
+ {Stack->push<array*>(src); return;}
+}
+
+// Returns the length of an array.
+#line 4342 "runtime.in"
+void arrayLength(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4343 "runtime.in"
+ {Stack->push<Int>((Int) checkArray(a)); return;}
+}
+
+// Returns an array of integers representing the keys of the array.
+#line 4348 "runtime.in"
+void arrayKeys(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4349 "runtime.in"
+ size_t size=checkArray(a);
+
+ array *keys=new array();
+ for (size_t i=0; i<size; ++i) {
+ item& cell = (*a)[i];
+ if (!cell.empty())
+ keys->push((Int)i);
+ }
+
+ {Stack->push<array*>(keys); return;}
+}
+
+// Return the cyclic flag for an array.
+#line 4363 "runtime.in"
+void arrayCyclicFlag(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4364 "runtime.in"
+ checkArray(a);
+ {Stack->push<bool>(a->cyclic()); return;}
+}
+
+// Check to see if an array element is initialized.
+#line 4370 "runtime.in"
+void arrayInitializedHelper(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+ Int n=vm::pop<Int>(Stack);
+#line 4371 "runtime.in"
+ size_t len=checkArray(a);
+ bool cyclic=a->cyclic();
+ if(cyclic && len > 0) n=imod(n,len);
+ else if(n < 0 || n >= (Int) len) {Stack->push<bool>(false); return;}
+ item&i=(*a)[(unsigned) n];
+ {Stack->push<bool>(!i.empty()); return;}
+}
+
+// Returns the initialize method for an array.
+#line 4381 "runtime.in"
+void arrayInitialized(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4382 "runtime.in"
+ {Stack->push<callable*>(new thunk(new bfunc(arrayInitializedHelper),a)); return;}
+}
+
+// The helper function for the cyclic method that sets the cyclic flag.
+#line 4387 "runtime.in"
+void arrayCyclicHelper(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+ bool b=vm::pop<bool>(Stack);
+#line 4388 "runtime.in"
+ checkArray(a);
+ a->cyclic(b);
+}
+
+// Set the cyclic flag for an array.
+#line 4394 "runtime.in"
+void arrayCyclic(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4395 "runtime.in"
+ {Stack->push<callable*>(new thunk(new bfunc(arrayCyclicHelper),a)); return;}
+}
+
+// The helper function for the push method that does the actual operation.
+#line 4400 "runtime.in"
+void arrayPushHelper(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+ item x=vm::pop(Stack);
+#line 4401 "runtime.in"
+ checkArray(a);
+ a->push(x);
+ {Stack->push(x); return;}
+}
+
+// Returns the push method for an array.
+#line 4408 "runtime.in"
+void arrayPush(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4409 "runtime.in"
+ {Stack->push<callable*>(new thunk(new bfunc(arrayPushHelper),a)); return;}
+}
+
+// The helper function for the append method that appends b to a.
+#line 4414 "runtime.in"
+void arrayAppendHelper(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+ array * b=vm::pop<array *>(Stack);
+#line 4415 "runtime.in"
+ checkArray(a);
+ size_t size=checkArray(b);
+ for(size_t i=0; i < size; i++)
+ a->push((*b)[i]);
+}
+
+// Returns the append method for an array.
+#line 4423 "runtime.in"
+void arrayAppend(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4424 "runtime.in"
+ {Stack->push<callable*>(new thunk(new bfunc(arrayAppendHelper),a)); return;}
+}
+
+// The helper function for the pop method.
+#line 4429 "runtime.in"
+void arrayPopHelper(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4430 "runtime.in"
+ size_t asize=checkArray(a);
+ if(asize == 0)
+ error("cannot pop element from empty array");
+ {Stack->push(a->pop()); return;}
+}
+
+// Returns the pop method for an array.
+#line 4438 "runtime.in"
+void arrayPop(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4439 "runtime.in"
+ {Stack->push<callable*>(new thunk(new bfunc(arrayPopHelper),a)); return;}
+}
+
+// The helper function for the insert method.
+#line 4444 "runtime.in"
+void arrayInsertHelper(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+ array * x=vm::pop<array *>(Stack);
+ Int i=vm::pop<Int>(Stack);
+#line 4445 "runtime.in"
+ size_t asize=checkArray(a);
+ checkArray(x);
+ if(a->cyclic() && asize > 0) i=imod(i,asize);
+ if(i < 0 || i > (Int) asize)
+ outOfBounds("inserting",asize,i);
+ (*a).insert((*a).begin()+i,(*x).begin(),(*x).end());
+}
+
+// Returns the insert method for an array.
+#line 4455 "runtime.in"
+void arrayInsert(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4456 "runtime.in"
+ {Stack->push<callable*>(new thunk(new bfunc(arrayInsertHelper),a)); return;}
+}
+
+// Returns the delete method for an array.
+#line 4461 "runtime.in"
+void arrayDelete(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4462 "runtime.in"
+ {Stack->push<callable*>(new thunk(new bfunc(arrayDeleteHelper),a)); return;}
+}
+
+#line 4466 "runtime.in"
+void arrayAlias(stack *Stack)
+{
+ array * b=vm::pop<array *>(Stack);
+ array * a=vm::pop<array *>(Stack);
+#line 4467 "runtime.in"
+ {Stack->push<bool>(a==b); return;}
+}
+
+// Return array formed by indexing array a with elements of integer array b
+#line 4472 "runtime.in"
+void arrayIntArray(stack *Stack)
+{
+ array * b=vm::pop<array *>(Stack);
+ array * a=vm::pop<array *>(Stack);
+#line 4473 "runtime.in"
+ size_t asize=checkArray(a);
+ size_t bsize=checkArray(b);
+ array *r=new array(bsize);
+ bool cyclic=a->cyclic();
+ for(size_t i=0; i < bsize; i++) {
+ Int index=read<Int>(b,i);
+ if(cyclic && asize > 0) index=imod(index,asize);
+ else
+ if(index < 0 || index >= (Int) asize)
+ outOfBounds("reading",asize,index);
+ (*r)[i]=(*a)[index];
+ }
+ {Stack->push<array*>(r); return;}
+}
+
+// returns the complement of the integer array a in {0,2,...,n-1},
+// so that b[complement(a,b.length)] yields the complement of b[a].
+#line 4491 "runtime.in"
+// Intarray* complement(Intarray *a, Int n);
+void gen446(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+ Intarray * a=vm::pop<Intarray *>(Stack);
+#line 4492 "runtime.in"
+ size_t asize=checkArray(a);
+ array *r=new array(0);
+ bool *keep=new bool[n];
+ for(Int i=0; i < n; ++i) keep[i]=true;
+ for(size_t i=0; i < asize; ++i) {
+ Int j=read<Int>(a,i);
+ if(j >= 0 && j < n) keep[j]=false;
+ }
+ for(Int i=0; i < n; i++)
+ if(keep[i]) r->push(i);
+
+ delete[] keep;
+ {Stack->push<Intarray*>(r); return;}
+}
+
+// Generate the sequence {f(i) : i=0,1,...n-1} given a function f and integer n
+#line 4509 "runtime.in"
+void arraySequence(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+ callable * f=vm::pop<callable *>(Stack);
+#line 4510 "runtime.in"
+ if(n < 0) n=0;
+ array *a=new array(n);
+ for(Int i=0; i < n; ++i) {
+ Stack->push(i);
+ f->call(Stack);
+ (*a)[i]=pop(Stack);
+ }
+ {Stack->push<Intarray*>(a); return;}
+}
+
+// Return the array {0,1,...n-1}
+#line 4522 "runtime.in"
+// Intarray* sequence(Int n);
+void gen448(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+#line 4523 "runtime.in"
+ if(n < 0) n=0;
+ array *a=new array(n);
+ for(Int i=0; i < n; ++i) {
+ (*a)[i]=i;
+ }
+ {Stack->push<Intarray*>(a); return;}
+}
+
+// Apply a function to each element of an array
+#line 4533 "runtime.in"
+void arrayFunction(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+ callable * f=vm::pop<callable *>(Stack);
+#line 4534 "runtime.in"
+ size_t size=checkArray(a);
+ array *b=new array(size);
+ for(size_t i=0; i < size; ++i) {
+ Stack->push((*a)[i]);
+ f->call(Stack);
+ (*b)[i]=pop(Stack);
+ }
+ {Stack->push<array*>(b); return;}
+}
+
+#line 4545 "runtime.in"
+void arraySort(stack *Stack)
+{
+ callable * f=vm::pop<callable *>(Stack);
+ array * a=vm::pop<array *>(Stack);
+#line 4546 "runtime.in"
+ array *c=copyArray(a);
+ compareFunc=f;
+ FuncStack=Stack;
+ stable_sort(c->begin(),c->end(),compareFunction);
+ {Stack->push<array*>(c); return;}
+}
+
+#line 4554 "runtime.in"
+// bool all(boolarray *a);
+void gen451(stack *Stack)
+{
+ boolarray * a=vm::pop<boolarray *>(Stack);
+#line 4555 "runtime.in"
+ size_t size=checkArray(a);
+ bool c=true;
+ for(size_t i=0; i < size; i++)
+ if(!get<bool>((*a)[i])) {c=false; break;}
+ {Stack->push<bool>(c); return;}
+}
+
+#line 4563 "runtime.in"
+// boolarray* !(boolarray* a);
+void gen452(stack *Stack)
+{
+ boolarray* a=vm::pop<boolarray*>(Stack);
+#line 4564 "runtime.in"
+ size_t size=checkArray(a);
+ array *c=new array(size);
+ for(size_t i=0; i < size; i++)
+ (*c)[i]=!read<bool>(a,i);
+ {Stack->push<boolarray*>(c); return;}
+}
+
+#line 4572 "runtime.in"
+// Int sum(boolarray *a);
+void gen453(stack *Stack)
+{
+ boolarray * a=vm::pop<boolarray *>(Stack);
+#line 4573 "runtime.in"
+ size_t size=checkArray(a);
+ Int sum=0;
+ for(size_t i=0; i < size; i++)
+ sum += read<bool>(a,i) ? 1 : 0;
+ {Stack->push<Int>(sum); return;}
+}
+
+#line 4581 "runtime.in"
+void arrayCopy(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4582 "runtime.in"
+ {Stack->push<array*>(copyArray(a)); return;}
+}
+
+#line 4586 "runtime.in"
+void arrayConcat(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4587 "runtime.in"
+ // a is an array of arrays to be concatenated together.
+ // The signature is
+ // T[] concat(... T[][] a);
+
+ size_t numArgs=checkArray(a);
+ size_t resultSize=0;
+ for (size_t i=0; i < numArgs; ++i) {
+ resultSize += checkArray(a->read<array *>(i));
+ }
+
+ array *result=new array(resultSize);
+
+ size_t ri=0;
+ for (size_t i=0; i < numArgs; ++i) {
+ array *arg=a->read<array *>(i);
+ size_t size=checkArray(arg);
+
+ for (size_t j=0; j < size; ++j) {
+ (*result)[ri]=(*arg)[j];
+ ++ri;
+ }
+ }
+
+ {Stack->push<array*>(result); return;}
+}
+
+#line 4614 "runtime.in"
+void array2Copy(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4615 "runtime.in"
+ {Stack->push<array*>(copyArray2(a)); return;}
+}
+
+#line 4619 "runtime.in"
+void array3Copy(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4620 "runtime.in"
+ {Stack->push<array*>(copyArray3(a)); return;}
+}
+
+#line 4624 "runtime.in"
+void array2Transpose(stack *Stack)
+{
+ array * a=vm::pop<array *>(Stack);
+#line 4625 "runtime.in"
+ size_t asize=checkArray(a);
+ array *c=new array(0);
+ for(size_t i=0; i < asize; i++) {
+ size_t ip=i+1;
+ array *ai=read<array*>(a,i);
+ size_t aisize=checkArray(ai);
+ size_t csize=checkArray(c);
+ if(csize < aisize) {
+ c->resize(aisize);
+ for(size_t j=csize; j < aisize; j++) {
+ (*c)[j]=new array(ip);
+ }
+ }
+ for(size_t j=0; j < aisize; j++) {
+ array *cj=read<array*>(c,j);
+ if(checkArray(cj) < ip) cj->resize(ip);
+ (*cj)[i]=(*ai)[j];
+ }
+ }
+ {Stack->push<array*>(c); return;}
+}
+
+// a is a rectangular 3D array; perm is an Int array indicating the type of
+// permutation (021 or 120, etc; original is 012).
+// Transpose by sending respective members to the permutated locations:
+// return the array obtained by putting a[i][j][k] into position perm{ijk}.
+#line 4652 "runtime.in"
+void array3Transpose(stack *Stack)
+{
+ array * perm=vm::pop<array *>(Stack);
+ array * a=vm::pop<array *>(Stack);
+#line 4653 "runtime.in"
+ const size_t DIM=3;
+
+ if(checkArray(perm) != DIM) {
+ ostringstream buf;
+ buf << "permutation array must have length " << DIM;
+ error(buf);
+ }
+
+ size_t* size=new size_t[DIM];
+ for(size_t i=0; i < DIM; ++i) size[i]=DIM;
+
+ for(size_t i=0; i < DIM; ++i) {
+ Int p=read<Int>(perm,i);
+ size_t P=(size_t) p;
+ if(p < 0 || P >= DIM) {
+ ostringstream buf;
+ buf << "permutation index out of range: " << p;
+ error(buf);
+ }
+ size[P]=P;
+ }
+
+ for(size_t i=0; i < DIM; ++i)
+ if(size[i] == DIM) error("permutation indices must be distinct");
+
+ static const char *rectangular=
+ "3D transpose implemented for rectangular matrices only";
+
+ size_t isize=size[0]=checkArray(a);
+ array *a0=read<array*>(a,0);
+ size[1]=checkArray(a0);
+ array *a00=read<array*>(a0,0);
+ size[2]=checkArray(a00);
+ for(size_t i=0; i < isize; i++) {
+ array *ai=read<array*>(a,i);
+ size_t jsize=checkArray(ai);
+ if(jsize != size[1]) error(rectangular);
+ for(size_t j=0; j < jsize; j++) {
+ array *aij=read<array*>(ai,j);
+ if(checkArray(aij) != size[2]) error(rectangular);
+ }
+ }
+
+ size_t perm0=(size_t) read<Int>(perm,0);
+ size_t perm1=(size_t) read<Int>(perm,1);
+ size_t perm2=(size_t) read<Int>(perm,2);
+
+ size_t sizep0=size[perm0];
+ size_t sizep1=size[perm1];
+ size_t sizep2=size[perm2];
+
+ array *c=new array(sizep0);
+ for(size_t i=0; i < sizep0; ++i) {
+ array *ci=new array(sizep1);
+ (*c)[i]=ci;
+ for(size_t j=0; j < sizep1; ++j) {
+ array *cij=new array(sizep2);
+ (*ci)[j]=cij;
+ }
+ }
+
+ size_t* i=new size_t[DIM];
+
+ for(i[0]=0; i[0] < size[0]; ++i[0]) {
+ array *a0=read<array*>(a,i[0]);
+ for(i[1]=0; i[1] < size[1]; ++i[1]) {
+ array *a1=read<array*>(a0,i[1]);
+ for(i[2]=0; i[2] < size[2]; ++i[2]) {
+ array *c0=read<array*>(c,i[perm0]);
+ array *c1=read<array*>(c0,i[perm1]);
+ (*c1)[i[perm2]]=read<real>(a1,i[2]);
+ }
+ }
+ }
+
+ delete [] i;
+ delete [] size;
+
+ {Stack->push<array*>(c); return;}
+}
+
+// In a boolean array, find the index of the nth true value or -1 if not found
+// If n is negative, search backwards.
+#line 4737 "runtime.in"
+// Int find(boolarray *a, Int n=1);
+void gen460(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack,1);
+ boolarray * a=vm::pop<boolarray *>(Stack);
+#line 4738 "runtime.in"
+
+ size_t size=checkArray(a);
+ Int j=-1;
+ if(n > 0)
+ for(size_t i=0; i < size; i++)
+ if(read<bool>(a,i)) {
+ n--; if(n == 0) {j=(Int) i; break;}
+ }
+ if(n < 0)
+ for(size_t i=size; i > 0;)
+ if(read<bool>(a,--i)) {
+ n++; if(n == 0) {j=(Int) i; break;}
+ }
+ {Stack->push<Int>(j); return;}
+}
+
+#line 4755 "runtime.in"
+// bool ==(realarray2 *a, realarray2 *b);
+void gen461(stack *Stack)
+{
+ realarray2 * b=vm::pop<realarray2 *>(Stack);
+ realarray2 * a=vm::pop<realarray2 *>(Stack);
+#line 4756 "runtime.in"
+ size_t n=checkArray(a);
+ if(n != checkArray(b)) {Stack->push<bool>(false); return;}
+
+ size_t n0=n == 0 ? 0 : checkArray(read<array*>(a,0));
+ if(n0 != checkArray(read<array*>(b,0))) {Stack->push<bool>(false); return;}
+
+ for(size_t i=0; i < n; ++i) {
+ array *ai=read<array*>(a,i);
+ array *bi=read<array*>(b,i);
+ for(size_t j=0; j < n0; ++j) {
+ if(read<real>(ai,j) != read<real>(bi,j))
+ {Stack->push<bool>(false); return;}
+ }
+ }
+ {Stack->push<bool>(true); return;}
+}
+
+// construct vector obtained by replacing those elements of b for which the
+// corresponding elements of a are false by the corresponding element of c.
+#line 4776 "runtime.in"
+void arrayConditional(stack *Stack)
+{
+ array * c=vm::pop<array *>(Stack);
+ array * b=vm::pop<array *>(Stack);
+ array * a=vm::pop<array *>(Stack);
+#line 4777 "runtime.in"
+ size_t size=checkArray(a);
+ array *r=new array(size);
+ if(b && c) {
+ checkArrays(a,b);
+ checkArrays(b,c);
+ for(size_t i=0; i < size; i++)
+ (*r)[i]=read<bool>(a,i) ? (*b)[i] : (*c)[i];
+ } else {
+ r->clear();
+ if(b) {
+ checkArrays(a,b);
+ for(size_t i=0; i < size; i++)
+ if(read<bool>(a,i)) r->push((*b)[i]);
+ } else if(c) {
+ checkArrays(a,c);
+ for(size_t i=0; i < size; i++)
+ if(!read<bool>(a,i)) r->push((*c)[i]);
+ }
+ }
+ {Stack->push<array*>(r); return;}
+}
+
+// Return an n x n identity matrix.
+#line 4801 "runtime.in"
+// realarray2* identity(Int n);
+void gen463(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack);
+#line 4802 "runtime.in"
+ {Stack->push<realarray2*>(Identity(n)); return;}
+}
+
+// Return the diagonal matrix with diagonal entries given by a.
+#line 4807 "runtime.in"
+void diagonal(stack *Stack)
+{
+ realarray * a=vm::pop<realarray *>(Stack);
+#line 4808 "runtime.in"
+ size_t n=checkArray(a);
+ array *c=new array(n);
+ for(size_t i=0; i < n; ++i) {
+ array *ci=new array(n);
+ (*c)[i]=ci;
+ for(size_t j=0; j < i; ++j)
+ (*ci)[j]=0.0;
+ (*ci)[i]=read<real>(a,i);
+ for(size_t j=i+1; j < n; ++j)
+ (*ci)[j]=0.0;
+ }
+ {Stack->push<realarray2*>(c); return;}
+}
+
+// Return the inverse of an n x n matrix a using Gauss-Jordan elimination.
+#line 4824 "runtime.in"
+// realarray2* inverse(realarray2 *a);
+void gen465(stack *Stack)
+{
+ realarray2 * a=vm::pop<realarray2 *>(Stack);
+#line 4825 "runtime.in"
+ a=copyArray2(a);
+ size_t n=checkArray(a);
+ checkSquare(a);
+
+ inverseAllocate(n);
+
+ for(size_t i=0; i < n; i++)
+ pivot[i]=0;
+
+ size_t col=0, row=0;
+ // This is the main loop over the columns to be reduced.
+ for(size_t i=0; i < n; i++) {
+ real big=0.0;
+ // This is the outer loop of the search for a pivot element.
+ for(size_t j=0; j < n; j++) {
+ array *aj=read<array*>(a,j);
+ if(pivot[j] != 1) {
+ for(size_t k=0; k < n; k++) {
+ if(pivot[k] == 0) {
+ real temp=fabs(read<real>(aj,k));
+ if(temp >= big) {
+ big=temp;
+ row=j;
+ col=k;
+ }
+ } else if(pivot[k] > 1) {
+ inverseDeallocate();
+ error(singular);
+ }
+ }
+ }
+ }
+ ++(pivot[col]);
+
+ // Interchange rows, if needed, to put the pivot element on the diagonal.
+ array *acol=read<array*>(a,col);
+ if(row != col) {
+ array *arow=read<array*>(a,row);
+ for(size_t l=0; l < n; l++) {
+ real temp=read<real>(arow,l);
+ (*arow)[l]=read<real>(acol,l);
+ (*acol)[l]=temp;
+ }
+ }
+
+ Row[i]=row;
+ Col[i]=col;
+
+ // Divide the pivot row by the pivot element.
+ real denom=read<real>(acol,col);
+ if(denom == 0.0) {
+ inverseDeallocate();
+ error(singular);
+ }
+ real pivinv=1.0/denom;
+ (*acol)[col]=1.0;
+ for(size_t l=0; l < n; l++)
+ (*acol)[l]=read<real>(acol,l)*pivinv;
+
+ // Reduce all rows except for the pivoted one.
+ for(size_t k=0; k < n; k++) {
+ if(k != col) {
+ array *ak=read<array*>(a,k);
+ real akcol=read<real>(ak,col);
+ (*ak)[col]=0.0;
+ for(size_t l=0; l < n; l++)
+ (*ak)[l]=read<real>(ak,l)-read<real>(acol,l)*akcol;
+ }
+ }
+ }
+
+ // Unscramble the inverse matrix in view of the column interchanges.
+ for(size_t l=n; l > 0;) {
+ l--;
+ size_t r=Row[l];
+ size_t c=Col[l];
+ if(r != c) {
+ for(size_t k=0; k < n; k++) {
+ array *ak=read<array*>(a,k);
+ real temp=read<real>(ak,r);
+ (*ak)[r]=read<real>(ak,c);
+ (*ak)[c]=temp;
+ }
+ }
+ }
+ inverseDeallocate();
+ {Stack->push<realarray2*>(a); return;}
+}
+
+// Solve the linear equation ax=b by LU decomposition, returning the
+// solution x, where a is an n x n matrix and b is an array of length n.
+// If no solution exists, return an empty array.
+#line 4918 "runtime.in"
+// realarray* solve(realarray2 *a, realarray *b, bool warn=true);
+void gen466(stack *Stack)
+{
+ bool warn=vm::pop<bool>(Stack,true);
+ realarray * b=vm::pop<realarray *>(Stack);
+ realarray2 * a=vm::pop<realarray2 *>(Stack);
+#line 4919 "runtime.in"
+ size_t n=checkArray(a);
+
+ if(n == 0) {Stack->push<realarray*>(new array(0)); return;}
+
+ size_t m=checkArray(b);
+ if(m != n) error(incommensurate);
+
+ real *A=copyArray2C(a);
+ size_t *index=new size_t[n];
+
+ if(LUdecompose(A,n,index,warn) == 0)
+ {Stack->push<realarray*>(new array(0)); return;}
+
+ array *x=new array(n);
+
+ real *B=copyArrayC(b);
+
+ for(size_t i=0; i < n; ++i) {
+ size_t ip=index[i];
+ real sum=B[ip];
+ B[ip]=B[i];
+ real *Ai=A+i*n;
+ for(size_t j=0; j < i; ++j)
+ sum -= Ai[j]*B[j];
+ B[i]=sum;
+ }
+
+ for(size_t i=n; i > 0;) {
+ --i;
+ real sum=B[i];
+ real *Ai=A+i*n;
+ for(size_t j=i+1; j < n; ++j)
+ sum -= Ai[j]*B[j];
+ B[i]=sum/Ai[i];
+ }
+
+ for(size_t i=0; i < n; ++i)
+ (*x)[i]=B[i];
+
+ delete[] index;
+ delete[] B;
+ delete[] A;
+
+ {Stack->push<realarray*>(x); return;}
+}
+
+// Solve the linear equation ax=b by LU decomposition, returning the
+// solution x, where a is an n x n matrix and b is an n x m matrix.
+// If no solution exists, return an empty array.
+#line 4969 "runtime.in"
+// realarray2* solve(realarray2 *a, realarray2 *b, bool warn=true);
+void gen467(stack *Stack)
+{
+ bool warn=vm::pop<bool>(Stack,true);
+ realarray2 * b=vm::pop<realarray2 *>(Stack);
+ realarray2 * a=vm::pop<realarray2 *>(Stack);
+#line 4970 "runtime.in"
+ size_t n=checkArray(a);
+
+ if(n == 0) {Stack->push<realarray2*>(new array(0)); return;}
+
+ if(checkArray(b) != n) error(incommensurate);
+ size_t m=checkArray(read<array*>(b,0));
+
+ real *A=copyArray2C(a);
+ real *B=copyArray2C(b,false);
+
+ size_t *index=new size_t[n];
+
+ if(LUdecompose(A,n,index,warn) == 0)
+ {Stack->push<realarray2*>(new array(0)); return;}
+
+ array *x=new array(n);
+
+ for(size_t i=0; i < n; ++i) {
+ real *Ai=A+i*n;
+ real *Bi=B+i*m;
+ real *Bip=B+index[i]*m;
+ for(size_t k=0; k < m; ++k) {
+ real sum=Bip[k];
+ Bip[k]=Bi[k];
+ size_t jk=k;
+ for(size_t j=0; j < i; ++j, jk += m)
+ sum -= Ai[j]*B[jk];
+ Bi[k]=sum;
+ }
+ }
+
+ for(size_t i=n; i > 0;) {
+ --i;
+ real *Ai=A+i*n;
+ real *Bi=B+i*m;
+ for(size_t k=0; k < m; ++k) {
+ real sum=Bi[k];
+ size_t jk=(i+1)*m+k;
+ for(size_t j=i+1; j < n; ++j, jk += m)
+ sum -= Ai[j]*B[jk];
+ Bi[k]=sum/Ai[i];
+ }
+ }
+
+ for(size_t i=0; i < n; ++i) {
+ real *Bi=B+i*m;
+ array *xi=new array(m);
+ (*x)[i]=xi;
+ for(size_t j=0; j < m; ++j)
+ (*xi)[j]=Bi[j];
+ }
+
+ delete[] index;
+ delete[] B;
+ delete[] A;
+
+ {Stack->push<realarray2*>(x); return;}
+}
+
+// Compute the determinant of an n x n matrix.
+#line 5031 "runtime.in"
+// real determinant(realarray2 *a);
+void gen468(stack *Stack)
+{
+ realarray2 * a=vm::pop<realarray2 *>(Stack);
+#line 5032 "runtime.in"
+ real *A=copyArray2C(a);
+ size_t n=checkArray(a);
+
+ real det=LUdecompose(A,n,NULL,false);
+ size_t n1=n+1;
+ for(size_t i=0; i < n; ++i)
+ det *= A[i*n1];
+
+ delete[] A;
+
+ {Stack->push<real>(det); return;}
+}
+
+#line 5046 "runtime.in"
+// realarray* *(realarray2 *a, realarray *b);
+void gen469(stack *Stack)
+{
+ realarray * b=vm::pop<realarray *>(Stack);
+ realarray2 * a=vm::pop<realarray2 *>(Stack);
+#line 5047 "runtime.in"
+ size_t n=checkArray(a);
+ size_t m=checkArray(b);
+ array *c=new array(n);
+ real *B=copyArrayC(b);
+ for(size_t i=0; i < n; ++i) {
+ array *ai=read<array*>(a,i);
+ if(checkArray(ai) != m) error(incommensurate);
+ real sum=0.0;
+ for(size_t j=0; j < m; ++j)
+ sum += read<real>(ai,j)*B[j];
+ (*c)[i]=sum;
+ }
+ delete[] B;
+ {Stack->push<realarray*>(c); return;}
+}
+
+#line 5064 "runtime.in"
+// realarray2* *(realarray2 *a, realarray2 *b);
+void gen470(stack *Stack)
+{
+ realarray2 * b=vm::pop<realarray2 *>(Stack);
+ realarray2 * a=vm::pop<realarray2 *>(Stack);
+#line 5065 "runtime.in"
+ size_t n=checkArray(a);
+
+ size_t nb=checkArray(b);
+ size_t na0=n == 0 ? 0 : checkArray(read<array*>(a,0));
+ if(na0 != nb)
+ error(incommensurate);
+
+ size_t nb0=nb == 0 ? 0 : checkArray(read<array*>(b,0));
+
+ array *c=new array(n);
+
+ real *A=copyArray2C(a,false);
+ real *B=copyArray2C(b,false);
+
+ for(size_t i=0; i < n; ++i) {
+ real *Ai=A+i*nb;
+ array *ci=new array(nb0);
+ (*c)[i]=ci;
+ for(size_t j=0; j < nb0; ++j) {
+ real sum=0.0;
+ size_t kj=j;
+ for(size_t k=0; k < nb; ++k, kj += nb0)
+ sum += Ai[k]*B[kj];
+ (*ci)[j]=sum;
+ }
+ }
+
+ delete[] B;
+ delete[] A;
+
+ {Stack->push<realarray2*>(c); return;}
+}
+
+#line 5099 "runtime.in"
+// triple *(realarray2 *t, triple v);
+void gen471(stack *Stack)
+{
+ triple v=vm::pop<triple>(Stack);
+ realarray2 * t=vm::pop<realarray2 *>(Stack);
+#line 5100 "runtime.in"
+ {Stack->push<triple>(*t*v); return;}
+}
+
+#line 5104 "runtime.in"
+// pair project(triple v, realarray2 *t);
+void gen472(stack *Stack)
+{
+ realarray2 * t=vm::pop<realarray2 *>(Stack);
+ triple v=vm::pop<triple>(Stack);
+#line 5105 "runtime.in"
+ size_t n=checkArray(t);
+ if(n != 4) error(incommensurate);
+ array *t0=read<array*>(t,0);
+ array *t1=read<array*>(t,1);
+ array *t3=read<array*>(t,3);
+ if(checkArray(t0) != 4 || checkArray(t1) != 4 || checkArray(t3) != 4)
+ error(incommensurate);
+
+ real x=v.getx();
+ real y=v.gety();
+ real z=v.getz();
+
+ real f=read<real>(t3,0)*x+read<real>(t3,1)*y+read<real>(t3,2)*z+
+ read<real>(t3,3);
+ if(f == 0.0) dividebyzero();
+ f=1.0/f;
+
+ {Stack->push<pair>(pair((read<real>(t0,0)*x+read<real>(t0,1)*y+read<real>(t0,2)*z+
+ read<real>(t0,3))*f,
+ (read<real>(t1,0)*x+read<real>(t1,1)*y+read<real>(t1,2)*z+
+ read<real>(t1,3))*f)); return;}
+}
+
+// Compute the dot product of vectors a and b.
+#line 5130 "runtime.in"
+// real dot(realarray *a, realarray *b);
+void gen473(stack *Stack)
+{
+ realarray * b=vm::pop<realarray *>(Stack);
+ realarray * a=vm::pop<realarray *>(Stack);
+#line 5131 "runtime.in"
+ size_t n=checkArrays(a,b);
+ real sum=0.0;
+ for(size_t i=0; i < n; ++i)
+ sum += read<real>(a,i)*read<real>(b,i);
+ {Stack->push<real>(sum); return;}
+}
+
+// Solve the problem L\inv f, where f is an n vector and L is the n x n matrix
+//
+// [ b[0] c[0] a[0] ]
+// [ a[1] b[1] c[1] ]
+// [ a[2] b[2] c[2] ]
+// [ ... ]
+// [ c[n-1] a[n-1] b[n-1] ]
+#line 5146 "runtime.in"
+// realarray* tridiagonal(realarray *a, realarray *b, realarray *c, realarray *f);
+void gen474(stack *Stack)
+{
+ realarray * f=vm::pop<realarray *>(Stack);
+ realarray * c=vm::pop<realarray *>(Stack);
+ realarray * b=vm::pop<realarray *>(Stack);
+ realarray * a=vm::pop<realarray *>(Stack);
+#line 5147 "runtime.in"
+ size_t n=checkArrays(a,b);
+ checkEqual(n,checkArray(c));
+ checkEqual(n,checkArray(f));
+
+ array *up=new array(n);
+ array& u=*up;
+
+ if(n == 0) {Stack->push<realarray*>(up); return;}
+
+ // Special case: zero Dirichlet boundary conditions
+ if(read<real>(a,0) == 0.0 && read<real>(c,n-1) == 0.0) {
+ real temp=read<real>(b,0);
+ if(temp == 0.0) dividebyzero();
+ temp=1.0/temp;
+
+ real *work=new real[n];
+ u[0]=read<real>(f,0)*temp;
+ work[0]=-read<real>(c,0)*temp;
+
+ for(size_t i=1; i < n; i++) {
+ real temp=(read<real>(b,i)+read<real>(a,i)*work[i-1]);
+ if(temp == 0.0) {delete[] work; dividebyzero();}
+ temp=1.0/temp;
+ u[i]=(read<real>(f,i)-read<real>(a,i)*read<real>(u,i-1))*temp;
+ work[i]=-read<real>(c,i)*temp;
+ }
+
+ for(size_t i=n-1; i >= 1; i--)
+ u[i-1]=read<real>(u,i-1)+work[i-1]*read<real>(u,i);
+
+ delete[] work;
+ {Stack->push<realarray*>(up); return;}
+ }
+
+ real binv=read<real>(b,0);
+ if(binv == 0.0) dividebyzero();
+ binv=1.0/binv;
+
+ if(n == 1) {u[0]=read<real>(f,0)*binv; {Stack->push<realarray*>(up); return;}}
+ if(n == 2) {
+ real factor=(read<real>(b,0)*read<real>(b,1)-
+ read<real>(a,0)*read<real>(c,1));
+ if(factor== 0.0) dividebyzero();
+ factor=1.0/factor;
+ real temp=(read<real>(b,0)*read<real>(f,1)-
+ read<real>(c,1)*read<real>(f,0))*factor;
+ u[0]=(read<real>(b,1)*read<real>(f,0)-
+ read<real>(a,0)*read<real>(f,1))*factor;
+ u[1]=temp;
+ {Stack->push<realarray*>(up); return;}
+ }
+
+ real *gamma=new real[n-2];
+ real *delta=new real[n-2];
+
+ gamma[0]=read<real>(c,0)*binv;
+ delta[0]=read<real>(a,0)*binv;
+ u[0]=read<real>(f,0)*binv;
+ real beta=read<real>(c,n-1);
+ real fn=read<real>(f,n-1)-beta*read<real>(u,0);
+ real alpha=read<real>(b,n-1)-beta*delta[0];
+
+ for(size_t i=1; i <= n-3; i++) {
+ real alphainv=read<real>(b,i)-read<real>(a,i)*gamma[i-1];
+ if(alphainv == 0.0) {delete[] gamma; delete[] delta; dividebyzero();}
+ alphainv=1.0/alphainv;
+ beta *= -gamma[i-1];
+ gamma[i]=read<real>(c,i)*alphainv;
+ u[i]=(read<real>(f,i)-read<real>(a,i)*read<real>(u,i-1))*alphainv;
+ fn -= beta*read<real>(u,i);
+ delta[i]=-read<real>(a,i)*delta[i-1]*alphainv;
+ alpha -= beta*delta[i];
+ }
+
+ real alphainv=read<real>(b,n-2)-read<real>(a,n-2)*gamma[n-3];
+ if(alphainv == 0.0) {delete[] gamma; delete[] delta; dividebyzero();}
+ alphainv=1.0/alphainv;
+ u[n-2]=(read<real>(f,n-2)-read<real>(a,n-2)*read<real>(u,n-3))
+ *alphainv;
+ beta=read<real>(a,n-1)-beta*gamma[n-3];
+ real dnm1=(read<real>(c,n-2)-read<real>(a,n-2)*delta[n-3])*alphainv;
+ real temp=alpha-beta*dnm1;
+ if(temp == 0.0) {delete[] gamma; delete[] delta; dividebyzero();}
+ u[n-1]=temp=(fn-beta*read<real>(u,n-2))/temp;
+ u[n-2]=read<real>(u,n-2)-dnm1*temp;
+
+ for(size_t i=n-2; i >= 1; i--)
+ u[i-1]=read<real>(u,i-1)-gamma[i-1]*read<real>(u,i)-delta[i-1]*temp;
+
+ delete[] delta;
+ delete[] gamma;
+
+ {Stack->push<realarray*>(up); return;}
+}
+
+// Root solve by Newton-Raphson
+#line 5244 "runtime.in"
+// real newton(Int iterations=100, callableReal *f, callableReal *fprime, real x, bool verbose=false);
+void gen475(stack *Stack)
+{
+ bool verbose=vm::pop<bool>(Stack,false);
+ real x=vm::pop<real>(Stack);
+ callableReal * fprime=vm::pop<callableReal *>(Stack);
+ callableReal * f=vm::pop<callableReal *>(Stack);
+ Int iterations=vm::pop<Int>(Stack,100);
+#line 5246 "runtime.in"
+ static const real fuzz=1000.0*DBL_EPSILON;
+ Int i=0;
+ size_t oldPrec=0;
+ if(verbose)
+ oldPrec=cout.precision(DBL_DIG);
+
+ real diff=DBL_MAX;
+ real lastdiff;
+ do {
+ real x0=x;
+
+ Stack->push(x);
+ fprime->call(Stack);
+ real dfdx=pop<real>(Stack);
+
+ if(dfdx == 0.0) {
+ x=DBL_MAX;
+ break;
+ }
+
+ Stack->push(x);
+ f->call(Stack);
+ real fx=pop<real>(Stack);
+
+ x -= fx/dfdx;
+
+ lastdiff=diff;
+
+ if(verbose)
+ cout << "Newton-Raphson: " << x << endl;
+
+ diff=fabs(x-x0);
+ if(++i == iterations) {
+ x=DBL_MAX;
+ break;
+ }
+ } while (diff != 0.0 && (diff < lastdiff || diff > fuzz*fabs(x)));
+
+ if(verbose)
+ cout.precision(oldPrec);
+ {Stack->push<real>(x); return;}
+}
+
+// Root solve by Newton-Raphson bisection
+// cf. routine rtsafe (Press et al., Numerical Recipes, 1991).
+#line 5292 "runtime.in"
+// real newton(Int iterations=100, callableReal *f, callableReal *fprime, real x1, real x2, bool verbose=false);
+void gen476(stack *Stack)
+{
+ bool verbose=vm::pop<bool>(Stack,false);
+ real x2=vm::pop<real>(Stack);
+ real x1=vm::pop<real>(Stack);
+ callableReal * fprime=vm::pop<callableReal *>(Stack);
+ callableReal * f=vm::pop<callableReal *>(Stack);
+ Int iterations=vm::pop<Int>(Stack,100);
+#line 5294 "runtime.in"
+ static const real fuzz=1000.0*DBL_EPSILON;
+ size_t oldPrec=0;
+ if(verbose)
+ oldPrec=cout.precision(DBL_DIG);
+
+ Stack->push(x1);
+ f->call(Stack);
+ real f1=pop<real>(Stack);
+ if(f1 == 0.0) {Stack->push<real>(x1); return;}
+
+ Stack->push(x2);
+ f->call(Stack);
+ real f2=pop<real>(Stack);
+ if(f2 == 0.0) {Stack->push<real>(x2); return;}
+
+ if((f1 > 0.0 && f2 > 0.0) || (f1 < 0.0 && f2 < 0.0)) {
+ ostringstream buf;
+ buf << "root not bracketed, f(x1)=" << f1 << ", f(x2)=" << f2 << endl;
+ error(buf);
+ }
+
+ real x=0.5*(x1+x2);
+ real dxold=fabs(x2-x1);
+ if(f1 > 0.0) {
+ real temp=x1;
+ x1=x2;
+ x2=temp;
+ }
+
+ if(verbose)
+ cout << "midpoint: " << x << endl;
+
+ real dx=dxold;
+ Stack->push(x);
+ f->call(Stack);
+ real y=pop<real>(Stack);
+
+ Stack->push(x);
+ fprime->call(Stack);
+ real dy=pop<real>(Stack);
+
+ Int j;
+ for(j=0; j < iterations; j++) {
+ if(((x-x2)*dy-y)*((x-x1)*dy-y) >= 0.0 || fabs(2.0*y) > fabs(dxold*dy)) {
+ dxold=dx;
+ dx=0.5*(x2-x1);
+ x=x1+dx;
+ if(verbose)
+ cout << "bisection: " << x << endl;
+ if(x1 == x) {Stack->push<real>(x); return;}
+ } else {
+ dxold=dx;
+ dx=y/dy;
+ real temp=x;
+ x -= dx;
+ if(verbose)
+ cout << "Newton-Raphson: " << x << endl;
+ if(temp == x) {Stack->push<real>(x); return;}
+ }
+ if(fabs(dx) < fuzz*fabs(x)) {Stack->push<real>(x); return;}
+
+ Stack->push(x);
+ f->call(Stack);
+ y=pop<real>(Stack);
+
+ Stack->push(x);
+ fprime->call(Stack);
+ dy=pop<real>(Stack);
+
+ if(y < 0.0) x1=x;
+ else x2=x;
+ }
+ if(verbose)
+ cout.precision(oldPrec);
+ {Stack->push<real>((j == iterations) ? DBL_MAX : x); return;}
+}
+
+#line 5372 "runtime.in"
+// real simpson(callableReal *f, real a, real b, real acc=DBL_EPSILON, real dxmax=0);
+void gen477(stack *Stack)
+{
+ real dxmax=vm::pop<real>(Stack,0);
+ real acc=vm::pop<real>(Stack,DBL_EPSILON);
+ real b=vm::pop<real>(Stack);
+ real a=vm::pop<real>(Stack);
+ callableReal * f=vm::pop<callableReal *>(Stack);
+#line 5374 "runtime.in"
+ real integral;
+ if(dxmax == 0) dxmax=b-a;
+ Func=f;
+ FuncStack=Stack;
+ if(!simpson(integral,wrapFunction,a,b,acc,dxmax))
+ error("nesting capacity exceeded in simpson");
+ {Stack->push<real>(integral); return;}
+}
+
+// Compute the fast Fourier transform of a pair array
+#line 5385 "runtime.in"
+void pairArrayFFT(stack *Stack)
+{
+ Int sign=vm::pop<Int>(Stack,1);
+ pairarray * a=vm::pop<pairarray *>(Stack);
+#line 5386 "runtime.in"
+ unsigned n=(unsigned) checkArray(a);
+#ifdef HAVE_LIBFFTW3
+ array *c=new array(n);
+ if(n) {
+ Complex *f=FFTWComplex(n);
+ fft1d Forward(n,intcast(sign),f);
+
+ for(size_t i=0; i < n; i++) {
+ pair z=read<pair>(a,i);
+ f[i]=Complex(z.getx(),z.gety());
+ }
+ Forward.fft(f);
+
+ for(size_t i=0; i < n; i++) {
+ Complex z=f[i];
+ (*c)[i]=pair(z.real(),z.imag());
+ }
+ FFTWdelete(f);
+ }
+#else
+ unused(&n);
+ unused(&sign);
+ array *c=new array(0);
+#endif // HAVE_LIBFFTW3
+ {Stack->push<pairarray*>(c); return;}
+}
+
+#line 5414 "runtime.in"
+// Intarray2* triangulate(pairarray *z);
+void gen479(stack *Stack)
+{
+ pairarray * z=vm::pop<pairarray *>(Stack);
+#line 5415 "runtime.in"
+ size_t nv=checkArray(z);
+// Call robust version of Gilles Dumoulin's port of Paul Bourke's
+// triangulation code.
+
+ XYZ *pxyz=new XYZ[nv+3];
+ ITRIANGLE *V=new ITRIANGLE[4*nv];
+
+ for(size_t i=0; i < nv; ++i) {
+ pair w=read<pair>(z,i);
+ pxyz[i].p[0]=w.getx();
+ pxyz[i].p[1]=w.gety();
+ pxyz[i].i=(Int) i;
+ }
+
+ Int ntri;
+ Triangulate((Int) nv,pxyz,V,ntri,true,false);
+
+ size_t nt=(size_t) ntri;
+ array *t=new array(nt);
+ for(size_t i=0; i < nt; ++i) {
+ array *ti=new array(3);
+ (*t)[i]=ti;
+ ITRIANGLE *Vi=V+i;
+ (*ti)[0]=pxyz[Vi->p1].i;
+ (*ti)[1]=pxyz[Vi->p2].i;
+ (*ti)[2]=pxyz[Vi->p3].i;
+ }
+
+ delete[] V;
+ delete[] pxyz;
+ {Stack->push<Intarray2*>(t); return;}
+}
+
+
+// File operations
+#line 5451 "runtime.in"
+// bool ==(file *a, file *b);
+void gen480(stack *Stack)
+{
+ file * b=vm::pop<file *>(Stack);
+ file * a=vm::pop<file *>(Stack);
+#line 5452 "runtime.in"
+ {Stack->push<bool>(a == b); return;}
+}
+
+#line 5457 "runtime.in"
+// bool !=(file *a, file *b);
+void gen481(stack *Stack)
+{
+ file * b=vm::pop<file *>(Stack);
+ file * a=vm::pop<file *>(Stack);
+#line 5458 "runtime.in"
+ {Stack->push<bool>(a != b); return;}
+}
+
+#line 5462 "runtime.in"
+void nullFile(stack *Stack)
+{
+#line 5463 "runtime.in"
+ {Stack->push<file*>(&camp::nullfile); return;}
+}
+
+#line 5467 "runtime.in"
+// file* input(string name, bool check=true, string comment=commentchar);
+void gen483(stack *Stack)
+{
+ string comment=vm::pop<string>(Stack,commentchar);
+ bool check=vm::pop<bool>(Stack,true);
+ string name=vm::pop<string>(Stack);
+#line 5468 "runtime.in"
+ char c=comment.empty() ? (char) 0 : comment[0];
+ file *f=new ifile(name,c,check);
+ f->open();
+ {Stack->push<file*>(f); return;}
+}
+
+#line 5475 "runtime.in"
+// file* output(string name, bool update=false, string comment=commentchar);
+void gen484(stack *Stack)
+{
+ string comment=vm::pop<string>(Stack,commentchar);
+ bool update=vm::pop<bool>(Stack,false);
+ string name=vm::pop<string>(Stack);
+#line 5476 "runtime.in"
+ file *f;
+ if(update) {
+ char c=comment.empty() ? (char) 0 : comment[0];
+ f=new iofile(name,c);
+ } else f=new ofile(name);
+ f->open();
+ if(update) f->seek(0,false);
+ {Stack->push<file*>(f); return;}
+}
+
+#line 5487 "runtime.in"
+// file* xinput(string name, bool check=true);
+void gen485(stack *Stack)
+{
+ bool check=vm::pop<bool>(Stack,true);
+ string name=vm::pop<string>(Stack);
+#line 5488 "runtime.in"
+#ifdef HAVE_RPC_RPC_H
+ file *f=new ixfile(name,check);
+ f->open();
+ {Stack->push<file*>(f); return;}
+#else
+ ostringstream buf;
+ buf << name << ": XDR read support not enabled";
+ error(buf);
+ unused(&check); // Suppress unused variable warning
+#endif
+}
+
+#line 5501 "runtime.in"
+// file* xoutput(string name, bool update=false);
+void gen486(stack *Stack)
+{
+ bool update=vm::pop<bool>(Stack,false);
+ string name=vm::pop<string>(Stack);
+#line 5502 "runtime.in"
+#ifdef HAVE_RPC_RPC_H
+ file *f;
+ if(update)
+ f=new ioxfile(name);
+ else f=new oxfile(name);
+ f->open();
+ if(update) f->seek(0,false);
+ {Stack->push<file*>(f); return;}
+#else
+ ostringstream buf;
+ buf << name << ": XDR write support not enabled";
+ error(buf);
+ unused(&update); // Suppress unused variable warning
+#endif
+}
+
+#line 5519 "runtime.in"
+// file* binput(string name, bool check=true);
+void gen487(stack *Stack)
+{
+ bool check=vm::pop<bool>(Stack,true);
+ string name=vm::pop<string>(Stack);
+#line 5520 "runtime.in"
+ file *f=new ibfile(name,check);
+ f->open();
+ {Stack->push<file*>(f); return;}
+}
+
+#line 5526 "runtime.in"
+// file* boutput(string name, bool update=false);
+void gen488(stack *Stack)
+{
+ bool update=vm::pop<bool>(Stack,false);
+ string name=vm::pop<string>(Stack);
+#line 5527 "runtime.in"
+ file *f;
+ if(update) f=new iobfile(name);
+ else f=new obfile(name);
+ f->open();
+ if(update) f->seek(0,false);
+ {Stack->push<file*>(f); return;}
+}
+
+#line 5536 "runtime.in"
+// bool eof(file *File);
+void gen489(stack *Stack)
+{
+ file * File=vm::pop<file *>(Stack);
+#line 5537 "runtime.in"
+ {Stack->push<bool>(File->eof()); return;}
+}
+
+#line 5541 "runtime.in"
+// bool eol(file *File);
+void gen490(stack *Stack)
+{
+ file * File=vm::pop<file *>(Stack);
+#line 5542 "runtime.in"
+ {Stack->push<bool>(File->eol()); return;}
+}
+
+#line 5546 "runtime.in"
+// bool error(file *File);
+void gen491(stack *Stack)
+{
+ file * File=vm::pop<file *>(Stack);
+#line 5547 "runtime.in"
+ {Stack->push<bool>(File->error()); return;}
+}
+
+#line 5551 "runtime.in"
+// void clear(file *File);
+void gen492(stack *Stack)
+{
+ file * File=vm::pop<file *>(Stack);
+#line 5552 "runtime.in"
+ File->clear();
+}
+
+#line 5556 "runtime.in"
+// void close(file *File);
+void gen493(stack *Stack)
+{
+ file * File=vm::pop<file *>(Stack);
+#line 5557 "runtime.in"
+ File->close();
+}
+
+#line 5561 "runtime.in"
+// Int precision(file *File=NULL, Int digits=0);
+void gen494(stack *Stack)
+{
+ Int digits=vm::pop<Int>(Stack,0);
+ file * File=vm::pop<file *>(Stack,NULL);
+#line 5562 "runtime.in"
+ if(File == 0) File=&camp::Stdout;
+ {Stack->push<Int>(File->precision(digits)); return;}
+}
+
+#line 5567 "runtime.in"
+// void flush(file *File);
+void gen495(stack *Stack)
+{
+ file * File=vm::pop<file *>(Stack);
+#line 5568 "runtime.in"
+ File->flush();
+}
+
+#line 5572 "runtime.in"
+// string getc(file *File);
+void gen496(stack *Stack)
+{
+ file * File=vm::pop<file *>(Stack);
+#line 5573 "runtime.in"
+ char c=0;
+ if(File->isOpen()) File->read(c);
+ static char str[1];
+ str[0]=c;
+ {Stack->push<string>(string(str)); return;}
+}
+
+#line 5581 "runtime.in"
+// Int tell(file *File);
+void gen497(stack *Stack)
+{
+ file * File=vm::pop<file *>(Stack);
+#line 5582 "runtime.in"
+ {Stack->push<Int>(File->tell()); return;}
+}
+
+#line 5586 "runtime.in"
+// void seek(file *File, Int pos);
+void gen498(stack *Stack)
+{
+ Int pos=vm::pop<Int>(Stack);
+ file * File=vm::pop<file *>(Stack);
+#line 5587 "runtime.in"
+ File->seek(pos,pos >= 0);
+}
+
+#line 5591 "runtime.in"
+// void seekeof(file *File);
+void gen499(stack *Stack)
+{
+ file * File=vm::pop<file *>(Stack);
+#line 5592 "runtime.in"
+ File->seek(0,false);
+}
+
+// Set file dimensions
+#line 5597 "runtime.in"
+// file* dimension(file *File, Int nx);
+void gen500(stack *Stack)
+{
+ Int nx=vm::pop<Int>(Stack);
+ file * File=vm::pop<file *>(Stack);
+#line 5598 "runtime.in"
+ File->dimension(nx);
+ {Stack->push<file*>(File); return;}
+}
+
+#line 5603 "runtime.in"
+// file* dimension(file *File, Int nx, Int ny);
+void gen501(stack *Stack)
+{
+ Int ny=vm::pop<Int>(Stack);
+ Int nx=vm::pop<Int>(Stack);
+ file * File=vm::pop<file *>(Stack);
+#line 5604 "runtime.in"
+ File->dimension(nx,ny);
+ {Stack->push<file*>(File); return;}
+}
+
+#line 5609 "runtime.in"
+// file* dimension(file *File, Int nx, Int ny, Int nz);
+void gen502(stack *Stack)
+{
+ Int nz=vm::pop<Int>(Stack);
+ Int ny=vm::pop<Int>(Stack);
+ Int nx=vm::pop<Int>(Stack);
+ file * File=vm::pop<file *>(Stack);
+#line 5610 "runtime.in"
+ File->dimension(nx,ny,nz);
+ {Stack->push<file*>(File); return;}
+}
+
+// Set file to read comma-separated values
+#line 5616 "runtime.in"
+// file* csv(file *File, bool b=true);
+void gen503(stack *Stack)
+{
+ bool b=vm::pop<bool>(Stack,true);
+ file * File=vm::pop<file *>(Stack);
+#line 5617 "runtime.in"
+ File->CSVMode(b);
+ {Stack->push<file*>(File); return;}
+}
+
+// Set file to read whitespace-separated values
+#line 5623 "runtime.in"
+// file* word(file *File, bool b=true);
+void gen504(stack *Stack)
+{
+ bool b=vm::pop<bool>(Stack,true);
+ file * File=vm::pop<file *>(Stack);
+#line 5624 "runtime.in"
+ File->WordMode(b);
+ {Stack->push<file*>(File); return;}
+}
+
+// Set file to read arrays in line-at-a-time mode
+#line 5630 "runtime.in"
+// file* line(file *File, bool b=true);
+void gen505(stack *Stack)
+{
+ bool b=vm::pop<bool>(Stack,true);
+ file * File=vm::pop<file *>(Stack);
+#line 5631 "runtime.in"
+ File->LineMode(b);
+ {Stack->push<file*>(File); return;}
+}
+
+// Set file to read/write single-precision XDR values.
+#line 5637 "runtime.in"
+// file* single(file *File, bool b=true);
+void gen506(stack *Stack)
+{
+ bool b=vm::pop<bool>(Stack,true);
+ file * File=vm::pop<file *>(Stack);
+#line 5638 "runtime.in"
+ File->SingleReal(b);
+ File->SingleInt(b);
+ {Stack->push<file*>(File); return;}
+}
+
+// Set file to read/write single-precision real XDR values.
+#line 5645 "runtime.in"
+// file* single(file *File, real x, bool b=true);
+void gen507(stack *Stack)
+{
+ bool b=vm::pop<bool>(Stack,true);
+ real x=vm::pop<real>(Stack);
+ file * File=vm::pop<file *>(Stack);
+#line 5646 "runtime.in"
+ File->SingleReal(b);
+ unused(&x);
+ {Stack->push<file*>(File); return;}
+}
+
+// Set file to read/write single-precision int XDR values.
+#line 5653 "runtime.in"
+// file* single(file *File, Int x, bool b=true);
+void gen508(stack *Stack)
+{
+ bool b=vm::pop<bool>(Stack,true);
+ Int x=vm::pop<Int>(Stack);
+ file * File=vm::pop<file *>(Stack);
+#line 5654 "runtime.in"
+ File->SingleInt(b);
+ unused(&x);
+ {Stack->push<file*>(File); return;}
+}
+
+// Set file to read an array1 (1 Int size followed by a 1d array)
+#line 5661 "runtime.in"
+// file* read1(file *File);
+void gen509(stack *Stack)
+{
+ file * File=vm::pop<file *>(Stack);
+#line 5662 "runtime.in"
+ File->dimension(-2);
+ {Stack->push<file*>(File); return;}
+}
+
+// Set file to read an array2 (2 Int sizes followed by a 2d array)
+#line 5668 "runtime.in"
+// file* read2(file *File);
+void gen510(stack *Stack)
+{
+ file * File=vm::pop<file *>(Stack);
+#line 5669 "runtime.in"
+ File->dimension(-2,-2);
+ {Stack->push<file*>(File); return;}
+}
+
+// Set file to read an array3 (3 Int sizes followed by a 3d array)
+#line 5675 "runtime.in"
+// file* read3(file *File);
+void gen511(stack *Stack)
+{
+ file * File=vm::pop<file *>(Stack);
+#line 5676 "runtime.in"
+ File->dimension(-2,-2,-2);
+ {Stack->push<file*>(File); return;}
+}
+
+// Return the last n lines of the history named name.
+#line 5682 "runtime.in"
+// stringarray* history(string name, Int n=1);
+void gen512(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack,1);
+ string name=vm::pop<string>(Stack);
+#line 5683 "runtime.in"
+#if defined(HAVE_LIBREADLINE) && defined(HAVE_LIBCURSES)
+ bool newhistory=historyMap.find(name) == historyMap.end();
+
+ string filename;
+
+ if(newhistory) {
+ filename=historyfilename(name);
+ std::ifstream exists(filename.c_str());
+ if(!exists) {Stack->push<stringarray*>(new array(0)); return;}
+ }
+
+ store_history(&history_save);
+ HISTORY_STATE& history=historyMap[name].state;
+ history_set_history_state(&history);
+
+ if(newhistory)
+ read_history(filename.c_str());
+
+ array *a=get_history(n);
+
+ store_history(&history);
+ history_set_history_state(&history_save);
+
+ {Stack->push<stringarray*>(a); return;}
+#else
+ unused(&n);
+ {Stack->push<stringarray*>(new array(0)); return;}
+#endif
+}
+
+// Return the last n lines of the interactive history.
+#line 5715 "runtime.in"
+// stringarray* history(Int n=0);
+void gen513(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack,0);
+#line 5716 "runtime.in"
+#if defined(HAVE_LIBREADLINE) && defined(HAVE_LIBCURSES)
+ {Stack->push<stringarray*>(get_history(n)); return;}
+#else
+ unused(&n);
+ {Stack->push<stringarray*>(new array(0)); return;}
+#endif
+}
+
+// Prompt for a string using prompt, the GNU readline library, and a
+// local history named name.
+#line 5727 "runtime.in"
+// string readline(string prompt=emptystring, string name=emptystring, bool tabcompletion=false);
+void gen514(stack *Stack)
+{
+ bool tabcompletion=vm::pop<bool>(Stack,false);
+ string name=vm::pop<string>(Stack,emptystring);
+ string prompt=vm::pop<string>(Stack,emptystring);
+#line 5729 "runtime.in"
+ if(!isatty(STDIN_FILENO))
+ {Stack->push<string>(emptystring); return;}
+#if defined(HAVE_LIBREADLINE) && defined(HAVE_LIBCURSES)
+ init_readline(tabcompletion);
+
+ store_history(&history_save);
+ bool newhistory=historyMap.find(name) == historyMap.end();
+ historyState& h=historyMap[name];
+ HISTORY_STATE& history=h.state;
+ history_set_history_state(&history);
+
+ if(newhistory)
+ read_history(historyfilename(name).c_str());
+
+ static char *line=NULL;
+ /* Return the memory to the free pool
+ if the buffer has already been allocated. */
+ if(line) {
+ free(line);
+ line=NULL;
+ }
+
+ /* Get a line from the user. */
+ line=readline(prompt.c_str());
+
+ if(!line) cout << endl;
+
+ history_set_history_state(&history_save);
+
+ {Stack->push<string>(line ? string(line) : emptystring); return;}
+#else
+ cout << prompt;
+ string s;
+ getline(cin,s);
+ unused(&tabcompletion); // Avoid unused variable warning message.
+ {Stack->push<string>(s); return;}
+#endif
+}
+
+// Save a string in a local history named name.
+// If store=true, store the local history in the file historyfilename(name).
+#line 5771 "runtime.in"
+// void saveline(string name, string value, bool store=true);
+void gen515(stack *Stack)
+{
+ bool store=vm::pop<bool>(Stack,true);
+ string value=vm::pop<string>(Stack);
+ string name=vm::pop<string>(Stack);
+#line 5772 "runtime.in"
+#if defined(HAVE_LIBREADLINE) && defined(HAVE_LIBCURSES)
+ store_history(&history_save);
+ bool newhistory=historyMap.find(name) == historyMap.end();
+ historyState& h=historyMap[name];
+ h.store=store;
+ HISTORY_STATE& history=h.state;
+ history_set_history_state(&history);
+
+ if(newhistory)
+ read_history(historyfilename(name).c_str());
+
+ if(value != "") {
+ add_history(value.c_str());
+ if(store) {
+ std::ofstream hout(historyfilename(name).c_str(),std::ios::app);
+ hout << value << endl;
+ }
+ }
+
+ store_history(&history);
+ history_set_history_state(&history_save);
+#else
+ unused(&store);
+#endif
+}
+
+#line 5799 "runtime.in"
+// void generate_random_backtrace();
+void gen516(stack *)
+{
+#line 5800 "runtime.in"
+#if defined(USEGC) && defined(GC_DEBUG) && defined(GC_BACKTRACE)
+ GC_generate_random_backtrace();
+#else
+ error("generate_random_backtrace() requires ./configure --enable-gc-debug");
+#endif
+}
+
+#line 5808 "runtime.in"
+// void print_random_addresses(Int n=1);
+void gen517(stack *Stack)
+{
+ Int n=vm::pop<Int>(Stack,1);
+#line 5809 "runtime.in"
+#if defined(USEGC) && defined(GC_DEBUG) && defined(GC_BACKTRACE)
+ GC_gcollect();
+ for (Int i=0; i < n; ++i)
+ GC_debug_print_heap_obj_proc(GC_base(GC_generate_random_valid_address()));
+#else
+ error("print_random_addresses() requires ./configure --enable-gc-debug");
+ unused(&n); // Avoid unused variable warning message.
+#endif
+}
+
+} // namespace run
+
+namespace trans {
+
+void gen_base_venv(venv &ve)
+{
+#line 1074 "runtime.in"
+ addFunc(ve, run::gen8, primBoolean(), "!", formal(primBoolean(), "b", false, false));
+#line 1102 "runtime.in"
+ addFunc(ve, run::gen13, primInt(), "AND", formal(primInt(), "a", false, false), formal(primInt(), "b", false, false));
+#line 1110 "runtime.in"
+ addFunc(ve, run::gen14, primInt(), "OR", formal(primInt(), "a", false, false), formal(primInt(), "b", false, false));
+#line 1115 "runtime.in"
+ addFunc(ve, run::gen15, primInt(), "XOR", formal(primInt(), "a", false, false), formal(primInt(), "b", false, false));
+#line 1120 "runtime.in"
+ addFunc(ve, run::gen16, primInt(), "NOT", formal(primInt(), "a", false, false));
+#line 1151 "runtime.in"
+ addFunc(ve, run::gen21, primBoolean(), "empty", formal(primPicture(), "f", false, false));
+#line 1156 "runtime.in"
+ addFunc(ve, run::gen22, primVoid(), "erase", formal(primPicture(), "f", false, false));
+#line 1161 "runtime.in"
+ addFunc(ve, run::gen23, primPair(), "min", formal(primPicture(), "f", false, false));
+#line 1166 "runtime.in"
+ addFunc(ve, run::gen24, primPair(), "max", formal(primPicture(), "f", false, false));
+#line 1171 "runtime.in"
+ addFunc(ve, run::gen25, primVoid(), "label", formal(primPicture(), "f", false, false), formal(primString(), "s", false, false), formal(primString(), "size", false, false), formal(primTransform(), "t", false, false), formal(primPair(), "position", false, false), formal(primPair(), "align", false, false), formal(primPen(), "p", false, false));
+#line 1177 "runtime.in"
+ addFunc(ve, run::gen26, primBoolean(), "labels", formal(primPicture(), "f", false, false));
+#line 1182 "runtime.in"
+ addFunc(ve, run::gen27, pathArray() , "_texpath", formal(primString(), "s", false, false), formal(primPen(), "p", true, false));
+#line 1249 "runtime.in"
+ addFunc(ve, run::gen28, pathArray() , "_strokepath", formal(primPath(), "g", false, false), formal(primPen(), "p", true, false));
+#line 1273 "runtime.in"
+ addFunc(ve, run::gen29, primVoid(), "_draw", formal(primPicture(), "f", false, false), formal(primPath(), "g", false, false), formal(primPen(), "p", false, false));
+#line 1278 "runtime.in"
+ addFunc(ve, run::gen30, primVoid(), "fill", formal(primPicture(), "f", false, false), formal(pathArray() , "g", false, false), formal(primPen(), "p", true, false), formal(primBoolean(), "copy", true, false));
+#line 1284 "runtime.in"
+ addFunc(ve, run::gen31, primVoid(), "latticeshade", formal(primPicture(), "f", false, false), formal(pathArray() , "g", false, false), formal(primBoolean(), "stroke", true, false), formal(primPen(), "fillrule", true, false), formal(penArray2() , "p", false, false), formal(primBoolean(), "copy", true, false));
+#line 1291 "runtime.in"
+ addFunc(ve, run::gen32, primVoid(), "axialshade", formal(primPicture(), "f", false, false), formal(pathArray() , "g", false, false), formal(primBoolean(), "stroke", true, false), formal(primPen(), "pena", false, false), formal(primPair(), "a", false, false), formal(primPen(), "penb", false, false), formal(primPair(), "b", false, false), formal(primBoolean(), "copy", true, false));
+#line 1298 "runtime.in"
+ addFunc(ve, run::gen33, primVoid(), "radialshade", formal(primPicture(), "f", false, false), formal(pathArray() , "g", false, false), formal(primBoolean(), "stroke", true, false), formal(primPen(), "pena", false, false), formal(primPair(), "a", false, false), formal(primReal(), "ra", false, false), formal(primPen(), "penb", false, false), formal(primPair(), "b", false, false), formal(primReal(), "rb", false, false), formal(primBoolean(), "copy", true, false));
+#line 1305 "runtime.in"
+ addFunc(ve, run::gen34, primVoid(), "gouraudshade", formal(primPicture(), "f", false, false), formal(pathArray() , "g", false, false), formal(primBoolean(), "stroke", true, false), formal(primPen(), "fillrule", true, false), formal(penArray() , "p", false, false), formal(pairArray(), "z", false, false), formal(IntArray(), "edges", false, false), formal(primBoolean(), "copy", true, false));
+#line 1316 "runtime.in"
+ addFunc(ve, run::gen35, primVoid(), "gouraudshade", formal(primPicture(), "f", false, false), formal(pathArray() , "g", false, false), formal(primBoolean(), "stroke", true, false), formal(primPen(), "fillrule", true, false), formal(penArray() , "p", false, false), formal(IntArray(), "edges", false, false), formal(primBoolean(), "copy", true, false));
+#line 1340 "runtime.in"
+ addFunc(ve, run::gen36, primVoid(), "tensorshade", formal(primPicture(), "f", false, false), formal(pathArray() , "g", false, false), formal(primBoolean(), "stroke", true, false), formal(primPen(), "fillrule", true, false), formal(penArray2() , "p", false, false), formal(pathArray() , "b", true, false), formal(pairArray2(), "z", true, false), formal(primBoolean(), "copy", true, false));
+#line 1355 "runtime.in"
+ addFunc(ve, run::gen37, primVoid(), "functionshade", formal(primPicture(), "f", false, false), formal(pathArray() , "g", false, false), formal(primBoolean(), "stroke", true, false), formal(primPen(), "fillrule", true, false), formal(primString() , "shader", true, false), formal(primBoolean(), "copy", true, false));
+#line 1363 "runtime.in"
+ addFunc(ve, run::gen38, primVoid(), "clip", formal(primPicture(), "f", false, false), formal(pathArray() , "g", false, false), formal(primBoolean(), "stroke", true, false), formal(primPen(), "fillrule", true, false), formal(primBoolean(), "copy", true, false));
+#line 1373 "runtime.in"
+ addFunc(ve, run::gen39, primVoid(), "beginclip", formal(primPicture(), "f", false, false), formal(pathArray() , "g", false, false), formal(primBoolean(), "stroke", true, false), formal(primPen(), "fillrule", true, false), formal(primBoolean(), "copy", true, false));
+#line 1380 "runtime.in"
+ addFunc(ve, run::gen40, primVoid(), "endclip", formal(primPicture(), "f", false, false));
+#line 1385 "runtime.in"
+ addFunc(ve, run::gen41, primVoid(), "gsave", formal(primPicture(), "f", false, false));
+#line 1390 "runtime.in"
+ addFunc(ve, run::gen42, primVoid(), "grestore", formal(primPicture(), "f", false, false));
+#line 1395 "runtime.in"
+ addFunc(ve, run::gen43, primVoid(), "begingroup", formal(primPicture(), "f", false, false));
+#line 1400 "runtime.in"
+ addFunc(ve, run::gen44, primVoid(), "endgroup", formal(primPicture(), "f", false, false));
+#line 1405 "runtime.in"
+ addFunc(ve, run::gen45, primVoid(), "add", formal(primPicture(), "dest", false, false), formal(primPicture(), "src", false, false));
+#line 1410 "runtime.in"
+ addFunc(ve, run::gen46, primVoid(), "prepend", formal(primPicture(), "dest", false, false), formal(primPicture(), "src", false, false));
+#line 1415 "runtime.in"
+ addFunc(ve, run::gen47, primVoid(), "postscript", formal(primPicture(), "f", false, false), formal(primString() , "s", false, false));
+#line 1420 "runtime.in"
+ addFunc(ve, run::gen48, primVoid(), "tex", formal(primPicture(), "f", false, false), formal(primString() , "s", false, false));
+#line 1425 "runtime.in"
+ addFunc(ve, run::gen49, primVoid(), "postscript", formal(primPicture(), "f", false, false), formal(primString() , "s", false, false), formal(primPair(), "min", false, false), formal(primPair(), "max", false, false));
+#line 1430 "runtime.in"
+ addFunc(ve, run::gen50, primVoid(), "tex", formal(primPicture(), "f", false, false), formal(primString() , "s", false, false), formal(primPair(), "min", false, false), formal(primPair(), "max", false, false));
+#line 1435 "runtime.in"
+ addFunc(ve, run::gen51, primVoid(), "texpreamble", formal(primString() , "s", false, false));
+#line 1443 "runtime.in"
+ addFunc(ve, run::gen52, primVoid(), "deletepreamble");
+#line 1450 "runtime.in"
+ addFunc(ve, run::gen53, primVoid(), "_labelpath", formal(primPicture(), "f", false, false), formal(primString() , "s", false, false), formal(primString() , "size", false, false), formal(primPath(), "g", false, false), formal(primString() , "justify", false, false), formal(primPair(), "offset", false, false), formal(primPen(), "p", false, false));
+#line 1456 "runtime.in"
+ addFunc(ve, run::gen54, primVoid(), "texreset");
+#line 1464 "runtime.in"
+ addFunc(ve, run::gen55, primVoid(), "layer", formal(primPicture(), "f", false, false));
+#line 1469 "runtime.in"
+ addFunc(ve, run::gen56, primVoid(), "newpage", formal(primPicture(), "f", false, false));
+#line 1474 "runtime.in"
+ addFunc(ve, run::gen57, primVoid(), "_image", formal(primPicture(), "f", false, false), formal(realArray2(), "data", false, false), formal(primPair(), "initial", false, false), formal(primPair(), "final", false, false), formal(penArray() , "palette", true, false), formal(primTransform(), "t", true, false), formal(primBoolean(), "copy", true, false), formal(primBoolean(), "antialias", true, false));
+#line 1484 "runtime.in"
+ addFunc(ve, run::gen58, primVoid(), "_image", formal(primPicture(), "f", false, false), formal(penArray2() , "data", false, false), formal(primPair(), "initial", false, false), formal(primPair(), "final", false, false), formal(primTransform(), "t", true, false), formal(primBoolean(), "copy", true, false), formal(primBoolean(), "antialias", true, false));
+#line 1491 "runtime.in"
+ addFunc(ve, run::gen59, primString() , "nativeformat");
+#line 1496 "runtime.in"
+ addFunc(ve, run::gen60, primBoolean(), "latex");
+#line 1501 "runtime.in"
+ addFunc(ve, run::gen61, primBoolean(), "pdf");
+#line 1506 "runtime.in"
+ addFunc(ve, run::gen62, primVoid(), "shipout", formal(primString() , "prefix", true, false), formal(primPicture(), "f", false, false), formal(primPicture(), "preamble", true, false), formal(primString() , "format", true, false), formal(primBoolean(), "wait", true, false), formal(primBoolean(), "view", true, false), formal(transformFunction(), "xform", false, false));
+#line 1552 "runtime.in"
+ addFunc(ve, run::gen63, primVoid(), "shipout3", formal(primString() , "prefix", false, false), formal(primPicture(), "f", false, false), formal(primString() , "format", true, false), formal(primReal(), "width", false, false), formal(primReal(), "height", false, false), formal(primReal(), "angle", false, false), formal(primTriple(), "m", false, false), formal(primTriple(), "m", false, false), formal(realArray2(), "t", false, false), formal(tripleArray(), "lights", false, false), formal(realArray2(), "diffuse", false, false), formal(realArray2(), "ambient", false, false), formal(realArray2(), "specular", false, false), formal(primBoolean(), "viewportlighting", false, false), formal(primBoolean(), "view", true, false));
+#line 1568 "runtime.in"
+ addFunc(ve, run::gen64, primVoid(), "shipout3", formal(primString() , "prefix", false, false), formal(primPicture(), "f", false, false));
+#line 1573 "runtime.in"
+ addFunc(ve, run::gen65, primVoid(), "deconstruct", formal(primPicture(), "f", false, false), formal(primPicture(), "preamble", true, false), formal(primReal(), "magnification", true, false), formal(transformFunction(), "xform", false, false));
+#line 1706 "runtime.in"
+ addFunc(ve, run::gen66, primVoid(), "purge", formal(primInt(), "divisor", true, false));
+#line 1719 "runtime.in"
+ addFunc(ve, run::gen68, primBoolean(), "==", formal(primPen(), "a", false, false), formal(primPen(), "b", false, false));
+#line 1724 "runtime.in"
+ addFunc(ve, run::gen69, primBoolean(), "!=", formal(primPen(), "a", false, false), formal(primPen(), "b", false, false));
+#line 1729 "runtime.in"
+ addFunc(ve, run::gen70, primPen(), "+", formal(primPen(), "a", false, false), formal(primPen(), "b", false, false));
+#line 1734 "runtime.in"
+ addFunc(ve, run::gen71, primPen(), "*", formal(primReal(), "a", false, false), formal(primPen(), "b", false, false));
+#line 1739 "runtime.in"
+ addFunc(ve, run::gen72, primPen(), "*", formal(primPen(), "a", false, false), formal(primReal(), "b", false, false));
+#line 1744 "runtime.in"
+ addFunc(ve, run::gen73, primPair(), "max", formal(primPen(), "p", false, false));
+#line 1749 "runtime.in"
+ addFunc(ve, run::gen74, primPair(), "min", formal(primPen(), "p", false, false));
+#line 1754 "runtime.in"
+ addFunc(ve, run::gen75, primVoid(), "resetdefaultpen");
+#line 1760 "runtime.in"
+ addFunc(ve, run::gen76, primVoid(), "defaultpen", formal(primPen(), "p", false, false));
+#line 1765 "runtime.in"
+ addFunc(ve, run::gen77, primPen(), "defaultpen");
+#line 1770 "runtime.in"
+ addFunc(ve, run::gen78, primBoolean(), "invisible", formal(primPen(), "p", false, false));
+#line 1775 "runtime.in"
+ addFunc(ve, run::gen79, primPen(), "invisible");
+#line 1780 "runtime.in"
+ addFunc(ve, run::gen80, primPen(), "gray", formal(primPen(), "p", false, false));
+#line 1786 "runtime.in"
+ addFunc(ve, run::gen81, primPen(), "rgb", formal(primPen(), "p", false, false));
+#line 1792 "runtime.in"
+ addFunc(ve, run::gen82, primPen(), "cmyk", formal(primPen(), "p", false, false));
+#line 1798 "runtime.in"
+ addFunc(ve, run::gen83, primPen(), "interp", formal(primPen(), "a", false, false), formal(primPen(), "b", false, false), formal(primReal(), "t", false, false));
+#line 1803 "runtime.in"
+ addFunc(ve, run::gen84, primPen(), "rgb", formal(primReal(), "r", false, false), formal(primReal(), "g", false, false), formal(primReal(), "b", false, false));
+#line 1808 "runtime.in"
+ addFunc(ve, run::gen85, primPen(), "cmyk", formal(primReal(), "c", false, false), formal(primReal(), "m", false, false), formal(primReal(), "y", false, false), formal(primReal(), "k", false, false));
+#line 1813 "runtime.in"
+ addFunc(ve, run::gen86, primPen(), "gray", formal(primReal(), "gray", false, false));
+#line 1818 "runtime.in"
+ addFunc(ve, run::gen87, realArray(), "colors", formal(primPen(), "p", false, false));
+#line 1846 "runtime.in"
+ addFunc(ve, run::gen88, primString() , "colorspace", formal(primPen(), "p", false, false));
+#line 1853 "runtime.in"
+ addFunc(ve, run::gen89, primPen(), "pattern", formal(primString(), "s", false, false));
+#line 1858 "runtime.in"
+ addFunc(ve, run::gen90, primString() , "pattern", formal(primPen(), "p", false, false));
+#line 1863 "runtime.in"
+ addFunc(ve, run::gen91, primPen(), "fillrule", formal(primInt(), "n", false, false));
+#line 1868 "runtime.in"
+ addFunc(ve, run::gen92, primInt(), "fillrule", formal(primPen(), "p", false, false));
+#line 1873 "runtime.in"
+ addFunc(ve, run::gen93, primPen(), "opacity", formal(primReal(), "opacity", true, false), formal(primString() , "blend", true, false));
+#line 1883 "runtime.in"
+ addFunc(ve, run::gen94, primReal(), "opacity", formal(primPen(), "p", false, false));
+#line 1888 "runtime.in"
+ addFunc(ve, run::gen95, primString() , "blend", formal(primPen(), "p", false, false));
+#line 1893 "runtime.in"
+ addFunc(ve, run::gen96, primPen(), "linetype", formal(primString(), "s", false, false), formal(primReal(), "offset", true, false), formal(primBoolean(), "scale", true, false), formal(primBoolean(), "adjust", true, false));
+#line 1898 "runtime.in"
+ addFunc(ve, run::gen97, primString() , "linetype", formal(primPen(), "p", true, false));
+#line 1903 "runtime.in"
+ addFunc(ve, run::gen98, primReal(), "offset", formal(primPen(), "p", false, false));
+#line 1908 "runtime.in"
+ addFunc(ve, run::gen99, primBoolean(), "scale", formal(primPen(), "p", false, false));
+#line 1913 "runtime.in"
+ addFunc(ve, run::gen100, primBoolean(), "adjust", formal(primPen(), "p", false, false));
+#line 1918 "runtime.in"
+ addFunc(ve, run::gen101, primPen(), "adjust", formal(primPen(), "p", false, false), formal(primReal(), "arclength", false, false), formal(primBoolean(), "cyclic", false, false));
+#line 1923 "runtime.in"
+ addFunc(ve, run::gen102, primPen(), "linecap", formal(primInt(), "n", false, false));
+#line 1928 "runtime.in"
+ addFunc(ve, run::gen103, primInt(), "linecap", formal(primPen(), "p", true, false));
+#line 1933 "runtime.in"
+ addFunc(ve, run::gen104, primPen(), "linejoin", formal(primInt(), "n", false, false));
+#line 1938 "runtime.in"
+ addFunc(ve, run::gen105, primInt(), "linejoin", formal(primPen(), "p", true, false));
+#line 1943 "runtime.in"
+ addFunc(ve, run::gen106, primPen(), "miterlimit", formal(primReal(), "x", false, false));
+#line 1948 "runtime.in"
+ addFunc(ve, run::gen107, primReal(), "miterlimit", formal(primPen(), "p", true, false));
+#line 1953 "runtime.in"
+ addFunc(ve, run::gen108, primPen(), "linewidth", formal(primReal(), "x", false, false));
+#line 1958 "runtime.in"
+ addFunc(ve, run::gen109, primReal(), "linewidth", formal(primPen(), "p", true, false));
+#line 1963 "runtime.in"
+ addFunc(ve, run::gen110, primPen(), "fontcommand", formal(primString(), "s", false, false));
+#line 1968 "runtime.in"
+ addFunc(ve, run::gen111, primString() , "font", formal(primPen(), "p", true, false));
+#line 1973 "runtime.in"
+ addFunc(ve, run::gen112, primPen(), "fontsize", formal(primReal(), "size", false, false), formal(primReal(), "lineskip", false, false));
+#line 1979 "runtime.in"
+ addFunc(ve, run::gen113, primReal(), "fontsize", formal(primPen(), "p", true, false));
+#line 1984 "runtime.in"
+ addFunc(ve, run::gen114, primReal(), "lineskip", formal(primPen(), "p", true, false));
+#line 1989 "runtime.in"
+ addFunc(ve, run::gen115, primPen(), "overwrite", formal(primInt(), "n", false, false));
+#line 1995 "runtime.in"
+ addFunc(ve, run::gen116, primInt(), "overwrite", formal(primPen(), "p", true, false));
+#line 2000 "runtime.in"
+ addFunc(ve, run::gen117, primPen(), "basealign", formal(primInt(), "n", false, false));
+#line 2005 "runtime.in"
+ addFunc(ve, run::gen118, primInt(), "basealign", formal(primPen(), "p", true, false));
+#line 2010 "runtime.in"
+ addFunc(ve, run::gen119, primTransform(), "transform", formal(primPen(), "p", false, false));
+#line 2015 "runtime.in"
+ addFunc(ve, run::gen120, primPath(), "nib", formal(primPen(), "p", false, false));
+#line 2020 "runtime.in"
+ addFunc(ve, run::gen121, primPen(), "makepen", formal(primPath(), "p", false, false));
+#line 2025 "runtime.in"
+ addFunc(ve, run::gen122, primPen(), "colorless", formal(primPen(), "p", false, false));
+#line 2031 "runtime.in"
+ addFunc(ve, run::gen123, primBoolean(), "interactive");
+#line 2038 "runtime.in"
+ addFunc(ve, run::gen124, primBoolean(), "uptodate");
+#line 2043 "runtime.in"
+ addFunc(ve, run::gen125, primInt(), "system", formal(primString() , "s", false, false));
+#line 2053 "runtime.in"
+ addFunc(ve, run::gen126, primBoolean(), "view");
+#line 2058 "runtime.in"
+ addFunc(ve, run::gen127, primString() , "asydir");
+#line 2063 "runtime.in"
+ addFunc(ve, run::gen128, primString() , "locale", formal(primString() , "s", true, false));
+#line 2069 "runtime.in"
+ addFunc(ve, run::gen129, primVoid(), "abort", formal(primString() , "s", true, false));
+#line 2075 "runtime.in"
+ addFunc(ve, run::gen130, primVoid(), "exit");
+#line 2080 "runtime.in"
+ addFunc(ve, run::gen131, primVoid(), "assert", formal(primBoolean(), "b", false, false), formal(primString() , "s", true, false));
+#line 2091 "runtime.in"
+ addFunc(ve, run::gen132, primVoid(), "sleep", formal(primInt(), "seconds", false, false));
+#line 2097 "runtime.in"
+ addFunc(ve, run::gen133, primVoid(), "usleep", formal(primInt(), "microseconds", false, false));
+#line 2103 "runtime.in"
+ addFunc(ve, run::gen134, primVoid(), "_eval", formal(primString(), "s", false, false), formal(primBoolean(), "embedded", false, false), formal(primBoolean(), "interactivewrite", true, false));
+#line 2118 "runtime.in"
+ addFunc(ve, run::gen135, primVoid(), "_eval", formal(primCode(), "s", false, false), formal(primBoolean(), "embedded", false, false));
+#line 2136 "runtime.in"
+ addFunc(ve, run::gen136, primString() , "location");
+#line 2148 "runtime.in"
+ addFunc(ve, run::gen138, primString() , "cd", formal(primString() , "s", true, false));
+#line 2154 "runtime.in"
+ addFunc(ve, run::gen139, primVoid(), "list", formal(primString(), "s", false, false), formal(primBoolean(), "imports", true, false));
+#line 2171 "runtime.in"
+ addFunc(ve, run::gen141, primBoolean(), "==", formal(primPath(), "a", false, false), formal(primPath(), "b", false, false));
+#line 2176 "runtime.in"
+ addFunc(ve, run::gen142, primBoolean(), "!=", formal(primPath(), "a", false, false), formal(primPath(), "b", false, false));
+#line 2181 "runtime.in"
+ addFunc(ve, run::gen143, primPair(), "point", formal(primPath(), "p", false, false), formal(primInt(), "t", false, false));
+#line 2186 "runtime.in"
+ addFunc(ve, run::gen144, primPair(), "point", formal(primPath(), "p", false, false), formal(primReal(), "t", false, false));
+#line 2191 "runtime.in"
+ addFunc(ve, run::gen145, primPair(), "precontrol", formal(primPath(), "p", false, false), formal(primInt(), "t", false, false));
+#line 2196 "runtime.in"
+ addFunc(ve, run::gen146, primPair(), "precontrol", formal(primPath(), "p", false, false), formal(primReal(), "t", false, false));
+#line 2201 "runtime.in"
+ addFunc(ve, run::gen147, primPair(), "postcontrol", formal(primPath(), "p", false, false), formal(primInt(), "t", false, false));
+#line 2206 "runtime.in"
+ addFunc(ve, run::gen148, primPair(), "postcontrol", formal(primPath(), "p", false, false), formal(primReal(), "t", false, false));
+#line 2211 "runtime.in"
+ addFunc(ve, run::gen149, primPair(), "dir", formal(primPath(), "p", false, false), formal(primInt(), "t", false, false), formal(primInt(), "sign", true, false), formal(primBoolean(), "normalize", true, false));
+#line 2216 "runtime.in"
+ addFunc(ve, run::gen150, primPair(), "dir", formal(primPath(), "p", false, false), formal(primReal(), "t", false, false), formal(primBoolean(), "normalize", true, false));
+#line 2221 "runtime.in"
+ addFunc(ve, run::gen151, primPair(), "accel", formal(primPath(), "p", false, false), formal(primInt(), "t", false, false), formal(primInt(), "sign", true, false));
+#line 2226 "runtime.in"
+ addFunc(ve, run::gen152, primPair(), "accel", formal(primPath(), "p", false, false), formal(primReal(), "t", false, false));
+#line 2231 "runtime.in"
+ addFunc(ve, run::gen153, primReal(), "radius", formal(primPath(), "p", false, false), formal(primReal(), "t", false, false));
+#line 2243 "runtime.in"
+ addFunc(ve, run::gen154, primPath(), "reverse", formal(primPath(), "p", false, false));
+#line 2248 "runtime.in"
+ addFunc(ve, run::gen155, primPath(), "subpath", formal(primPath(), "p", false, false), formal(primInt(), "a", false, false), formal(primInt(), "b", false, false));
+#line 2253 "runtime.in"
+ addFunc(ve, run::gen156, primPath(), "subpath", formal(primPath(), "p", false, false), formal(primReal(), "a", false, false), formal(primReal(), "b", false, false));
+#line 2258 "runtime.in"
+ addFunc(ve, run::gen157, primPath(), "nurb", formal(primPair(), "z0", false, false), formal(primPair(), "z1", false, false), formal(primPair(), "z2", false, false), formal(primPair(), "z3", false, false), formal(primReal(), "w0", false, false), formal(primReal(), "w1", false, false), formal(primReal(), "w2", false, false), formal(primReal(), "w3", false, false), formal(primInt(), "m", false, false));
+#line 2264 "runtime.in"
+ addFunc(ve, run::gen158, primInt(), "length", formal(primPath(), "p", false, false));
+#line 2269 "runtime.in"
+ addFunc(ve, run::gen159, primBoolean(), "cyclic", formal(primPath(), "p", false, false));
+#line 2274 "runtime.in"
+ addFunc(ve, run::gen160, primBoolean(), "straight", formal(primPath(), "p", false, false), formal(primInt(), "t", false, false));
+#line 2279 "runtime.in"
+ addFunc(ve, run::gen161, primPath(), "unstraighten", formal(primPath(), "p", false, false));
+#line 2284 "runtime.in"
+ addFunc(ve, run::gen162, primBoolean(), "piecewisestraight", formal(primPath(), "p", false, false));
+#line 2289 "runtime.in"
+ addFunc(ve, run::gen163, primReal(), "arclength", formal(primPath(), "p", false, false));
+#line 2294 "runtime.in"
+ addFunc(ve, run::gen164, primReal(), "arctime", formal(primPath(), "p", false, false), formal(primReal(), "dval", false, false));
+#line 2299 "runtime.in"
+ addFunc(ve, run::gen165, primReal(), "dirtime", formal(primPath(), "p", false, false), formal(primPair(), "z", false, false));
+#line 2304 "runtime.in"
+ addFunc(ve, run::gen166, realArray(), "intersect", formal(primPath(), "p", false, false), formal(primPath(), "q", false, false), formal(primReal(), "fuzz", true, false));
+#line 2321 "runtime.in"
+ addFunc(ve, run::gen167, realArray2(), "intersections", formal(primPath(), "p", false, false), formal(primPath(), "q", false, false), formal(primReal(), "fuzz", true, false));
+#line 2352 "runtime.in"
+ addFunc(ve, run::gen168, realArray(), "intersections", formal(primPath(), "p", false, false), formal(primPair(), "a", false, true), formal(primPair(), "b", false, true), formal(primReal(), "fuzz", true, false));
+#line 2367 "runtime.in"
+ addFunc(ve, run::gen169, primPair(), "extension", formal(primPair(), "p", false, false), formal(primPair(), "q", false, false), formal(primPair(), "p", false, false), formal(primPair(), "q", false, false));
+#line 2378 "runtime.in"
+ addFunc(ve, run::gen170, primInt(), "size", formal(primPath(), "p", false, false));
+#line 2383 "runtime.in"
+ addFunc(ve, run::gen171, primPath(), "&", formal(primPath(), "p", false, false), formal(primPath(), "q", false, false));
+#line 2388 "runtime.in"
+ addFunc(ve, run::gen172, primPair(), "min", formal(primPath(), "p", false, false));
+#line 2393 "runtime.in"
+ addFunc(ve, run::gen173, primPair(), "max", formal(primPath(), "p", false, false));
+#line 2398 "runtime.in"
+ addFunc(ve, run::gen174, realArray(), "mintimes", formal(primPath(), "p", false, false));
+#line 2407 "runtime.in"
+ addFunc(ve, run::gen175, realArray(), "maxtimes", formal(primPath(), "p", false, false));
+#line 2416 "runtime.in"
+ addFunc(ve, run::gen176, primReal(), "relativedistance", formal(primReal(), "theta", false, false), formal(primReal(), "phi", false, false), formal(primReal(), "t", false, false), formal(primBoolean(), "atleast", false, false));
+#line 2421 "runtime.in"
+ addFunc(ve, run::gen177, primInt(), "windingnumber", formal(pathArray() , "p", false, false), formal(primPair(), "z", false, false));
+#line 2426 "runtime.in"
+ addFunc(ve, run::gen178, primBoolean(), "inside", formal(pathArray() , "g", false, true), formal(primPair(), "z", false, false), formal(primPen(), "fillrule", true, false));
+#line 2431 "runtime.in"
+ addFunc(ve, run::gen179, primBoolean(), "inside", formal(primPath(), "g", false, false), formal(primPair(), "z", false, false), formal(primPen(), "fillrule", true, false));
+#line 2436 "runtime.in"
+ addFunc(ve, run::gen180, primReal(), "side", formal(primPair(), "a", false, false), formal(primPair(), "b", false, false), formal(primPair(), "c", false, false));
+#line 2443 "runtime.in"
+ addFunc(ve, run::gen181, primReal(), "incircle", formal(primPair(), "a", false, false), formal(primPair(), "b", false, false), formal(primPair(), "c", false, false), formal(primPair(), "d", false, false));
+#line 2451 "runtime.in"
+ addFunc(ve, run::gen182, primPath3(), "path3", formal(tripleArray(), "pre", false, false), formal(tripleArray(), "point", false, false), formal(tripleArray(), "post", false, false), formal(boolArray(), "straight", false, false), formal(primBoolean(), "cyclic", false, false));
+#line 2476 "runtime.in"
+ addFunc(ve, run::gen184, primBoolean(), "==", formal(primPath3(), "a", false, false), formal(primPath3(), "b", false, false));
+#line 2481 "runtime.in"
+ addFunc(ve, run::gen185, primBoolean(), "!=", formal(primPath3(), "a", false, false), formal(primPath3(), "b", false, false));
+#line 2486 "runtime.in"
+ addFunc(ve, run::gen186, primTriple(), "point", formal(primPath3(), "p", false, false), formal(primInt(), "t", false, false));
+#line 2491 "runtime.in"
+ addFunc(ve, run::gen187, primTriple(), "point", formal(primPath3(), "p", false, false), formal(primReal(), "t", false, false));
+#line 2496 "runtime.in"
+ addFunc(ve, run::gen188, primTriple(), "precontrol", formal(primPath3(), "p", false, false), formal(primInt(), "t", false, false));
+#line 2501 "runtime.in"
+ addFunc(ve, run::gen189, primTriple(), "precontrol", formal(primPath3(), "p", false, false), formal(primReal(), "t", false, false));
+#line 2506 "runtime.in"
+ addFunc(ve, run::gen190, primTriple(), "postcontrol", formal(primPath3(), "p", false, false), formal(primInt(), "t", false, false));
+#line 2511 "runtime.in"
+ addFunc(ve, run::gen191, primTriple(), "postcontrol", formal(primPath3(), "p", false, false), formal(primReal(), "t", false, false));
+#line 2516 "runtime.in"
+ addFunc(ve, run::gen192, primTriple(), "dir", formal(primPath3(), "p", false, false), formal(primInt(), "t", false, false), formal(primInt(), "sign", true, false), formal(primBoolean(), "normalize", true, false));
+#line 2521 "runtime.in"
+ addFunc(ve, run::gen193, primTriple(), "dir", formal(primPath3(), "p", false, false), formal(primReal(), "t", false, false), formal(primBoolean(), "normalize", true, false));
+#line 2526 "runtime.in"
+ addFunc(ve, run::gen194, primTriple(), "accel", formal(primPath3(), "p", false, false), formal(primInt(), "t", false, false), formal(primInt(), "sign", true, false));
+#line 2531 "runtime.in"
+ addFunc(ve, run::gen195, primTriple(), "accel", formal(primPath3(), "p", false, false), formal(primReal(), "t", false, false));
+#line 2536 "runtime.in"
+ addFunc(ve, run::gen196, primReal(), "radius", formal(primPath3(), "p", false, false), formal(primReal(), "t", false, false));
+#line 2548 "runtime.in"
+ addFunc(ve, run::gen197, primReal(), "radius", formal(primTriple(), "z0", false, false), formal(primTriple(), "c0", false, false), formal(primTriple(), "c1", false, false), formal(primTriple(), "z1", false, false), formal(primReal(), "t", false, false));
+#line 2560 "runtime.in"
+ addFunc(ve, run::gen198, primPath3(), "reverse", formal(primPath3(), "p", false, false));
+#line 2565 "runtime.in"
+ addFunc(ve, run::gen199, primPath3(), "subpath", formal(primPath3(), "p", false, false), formal(primInt(), "a", false, false), formal(primInt(), "b", false, false));
+#line 2570 "runtime.in"
+ addFunc(ve, run::gen200, primPath3(), "subpath", formal(primPath3(), "p", false, false), formal(primReal(), "a", false, false), formal(primReal(), "b", false, false));
+#line 2575 "runtime.in"
+ addFunc(ve, run::gen201, primInt(), "length", formal(primPath3(), "p", false, false));
+#line 2580 "runtime.in"
+ addFunc(ve, run::gen202, primBoolean(), "cyclic", formal(primPath3(), "p", false, false));
+#line 2585 "runtime.in"
+ addFunc(ve, run::gen203, primBoolean(), "straight", formal(primPath3(), "p", false, false), formal(primInt(), "t", false, false));
+#line 2590 "runtime.in"
+ addFunc(ve, run::gen204, primTriple(), "perp", formal(primTriple(), "v", false, false), formal(primTriple(), "u", false, false));
+#line 2596 "runtime.in"
+ addFunc(ve, run::gen205, primReal(), "straightness", formal(primPath3(), "p", false, false), formal(primInt(), "t", false, false));
+#line 2607 "runtime.in"
+ addFunc(ve, run::gen206, primReal(), "straightness", formal(primTriple(), "z0", false, false), formal(primTriple(), "c0", false, false), formal(primTriple(), "c1", false, false), formal(primTriple(), "z1", false, false));
+#line 2615 "runtime.in"
+ addFunc(ve, run::gen207, primBoolean(), "piecewisestraight", formal(primPath3(), "p", false, false));
+#line 2620 "runtime.in"
+ addFunc(ve, run::gen208, primReal(), "arclength", formal(primPath3(), "p", false, false));
+#line 2625 "runtime.in"
+ addFunc(ve, run::gen209, primReal(), "arctime", formal(primPath3(), "p", false, false), formal(primReal(), "dval", false, false));
+#line 2630 "runtime.in"
+ addFunc(ve, run::gen210, realArray(), "intersect", formal(primPath3(), "p", false, false), formal(primPath3(), "q", false, false), formal(primReal(), "fuzz", true, false));
+#line 2648 "runtime.in"
+ addFunc(ve, run::gen211, realArray2(), "intersections", formal(primPath3(), "p", false, false), formal(primPath3(), "q", false, false), formal(primReal(), "fuzz", true, false));
+#line 2681 "runtime.in"
+ addFunc(ve, run::gen212, primInt(), "size", formal(primPath3(), "p", false, false));
+#line 2686 "runtime.in"
+ addFunc(ve, run::gen213, primPath3(), "&", formal(primPath3(), "p", false, false), formal(primPath3(), "q", false, false));
+#line 2691 "runtime.in"
+ addFunc(ve, run::gen214, primTriple(), "min", formal(primPath3(), "p", false, false));
+#line 2696 "runtime.in"
+ addFunc(ve, run::gen215, primTriple(), "max", formal(primPath3(), "p", false, false));
+#line 2701 "runtime.in"
+ addFunc(ve, run::gen216, realArray(), "mintimes", formal(primPath3(), "p", false, false));
+#line 2711 "runtime.in"
+ addFunc(ve, run::gen217, realArray(), "maxtimes", formal(primPath3(), "p", false, false));
+#line 2721 "runtime.in"
+ addFunc(ve, run::gen218, primPath3(), "*", formal(realArray2(), "t", false, false), formal(primPath3(), "g", false, false));
+#line 2776 "runtime.in"
+ addFunc(ve, run::gen223, primGuide(), "operator cast", formal(primCycleToken(), "tok", false, false));
+#line 2783 "runtime.in"
+ addFunc(ve, run::gen224, primGuide(), "operator spec", formal(primPair(), "z", false, false), formal(primInt(), "p", false, false));
+#line 2791 "runtime.in"
+ addFunc(ve, run::gen225, primCurlSpecifier(), "operator curl", formal(primReal(), "gamma", false, false), formal(primInt(), "p", false, false));
+#line 2807 "runtime.in"
+ addFunc(ve, run::gen228, primGuide(), "operator cast", formal(primCurlSpecifier(), "spec", false, false));
+#line 2812 "runtime.in"
+ addFunc(ve, run::gen229, primTensionSpecifier(), "operator tension", formal(primReal(), "tout", false, false), formal(primReal(), "tin", false, false), formal(primBoolean(), "atleast", false, false));
+#line 2832 "runtime.in"
+ addFunc(ve, run::gen233, primGuide(), "operator cast", formal(primTensionSpecifier(), "t", false, false));
+#line 2837 "runtime.in"
+ addFunc(ve, run::gen234, primGuide(), "operator controls", formal(primPair(), "zout", false, false), formal(primPair(), "zin", false, false));
+#line 2842 "runtime.in"
+ addFunc(ve, run::gen235, primInt(), "size", formal(primGuide(), "g", false, false));
+#line 2849 "runtime.in"
+ addFunc(ve, run::gen236, primInt(), "length", formal(primGuide(), "g", false, false));
+#line 2856 "runtime.in"
+ addFunc(ve, run::gen237, primBoolean(), "cyclic", formal(primGuide(), "g", false, false));
+#line 2863 "runtime.in"
+ addFunc(ve, run::gen238, primPair(), "point", formal(primGuide(), "g", false, false), formal(primInt(), "t", false, false));
+#line 2870 "runtime.in"
+ addFunc(ve, run::gen239, pairArray(), "dirSpecifier", formal(primGuide(), "g", false, false), formal(primInt(), "t", false, false));
+#line 2882 "runtime.in"
+ addFunc(ve, run::gen240, pairArray(), "controlSpecifier", formal(primGuide(), "g", false, false), formal(primInt(), "t", false, false));
+#line 2899 "runtime.in"
+ addFunc(ve, run::gen241, primTensionSpecifier(), "tensionSpecifier", formal(primGuide(), "g", false, false), formal(primInt(), "t", false, false));
+#line 2909 "runtime.in"
+ addFunc(ve, run::gen242, realArray(), "curlSpecifier", formal(primGuide(), "g", false, false), formal(primInt(), "t", false, false));
+#line 2923 "runtime.in"
+ addFunc(ve, run::gen243, primGuide(), "reverse", formal(primGuide(), "g", false, false));
+#line 2977 "runtime.in"
+ addFunc(ve, run::gen244, primVoid(), "_draw", formal(primPicture(), "f", false, false), formal(primPath3(), "g", false, false), formal(primPen(), "p", false, false));
+#line 2985 "runtime.in"
+ addFunc(ve, run::gen245, primVoid(), "draw", formal(primPicture(), "f", false, false), formal(tripleArray2(), "g", false, false), formal(primBoolean(), "straight", false, false), formal(penArray() , "p", false, false), formal(primReal(), "opacity", false, false), formal(primReal(), "shininess", false, false), formal(primReal(), "granularity", false, false), formal(primTriple(), "normal", false, false), formal(primBoolean(), "lighton", false, false), formal(penArray() , "colors", false, false));
+#line 2993 "runtime.in"
+ addFunc(ve, run::gen246, primTriple(), "min3", formal(primPicture(), "f", false, false));
+#line 2998 "runtime.in"
+ addFunc(ve, run::gen247, primTriple(), "max3", formal(primPicture(), "f", false, false));
+#line 3003 "runtime.in"
+ addFunc(ve, run::gen248, primPair(), "min", formal(primPicture(), "f", false, false), formal(realArray2(), "t", false, false));
+#line 3011 "runtime.in"
+ addFunc(ve, run::gen249, primPair(), "max", formal(primPicture(), "f", false, false), formal(realArray2(), "t", false, false));
+#line 3019 "runtime.in"
+ addFunc(ve, run::gen250, primPair(), "minratio", formal(primPicture(), "f", false, false));
+#line 3024 "runtime.in"
+ addFunc(ve, run::gen251, primPair(), "maxratio", formal(primPicture(), "f", false, false));
+#line 3029 "runtime.in"
+ addFunc(ve, run::gen252, primReal(), "minbound", formal(realArray(), "a", false, false), formal(primReal(), "b", false, false));
+#line 3037 "runtime.in"
+ addFunc(ve, run::gen253, primReal(), "maxbound", formal(realArray(), "a", false, false), formal(primReal(), "b", false, false));
+#line 3045 "runtime.in"
+ addFunc(ve, run::gen254, primPair(), "minbound", formal(tripleArray(), "a", false, false), formal(realArray2(), "t", false, false), formal(primPair(), "b", false, false));
+#line 3056 "runtime.in"
+ addFunc(ve, run::gen255, primPair(), "maxbound", formal(tripleArray(), "a", false, false), formal(realArray2(), "t", false, false), formal(primPair(), "b", false, false));
+#line 3067 "runtime.in"
+ addFunc(ve, run::gen256, primPair(), "max", formal(primPath3(), "g", false, false), formal(realArray2(), "t", false, false));
+#line 3075 "runtime.in"
+ addFunc(ve, run::gen257, primPair(), "min", formal(primPath3(), "g", false, false), formal(realArray2(), "t", false, false));
+#line 3083 "runtime.in"
+ addFunc(ve, run::gen258, primReal(), "change2", formal(tripleArray2(), "a", false, false));
+#line 3105 "runtime.in"
+ addFunc(ve, run::gen259, primBoolean(), "is3D", formal(primPicture(), "f", false, false));
+#line 3110 "runtime.in"
+ addFunc(ve, run::gen260, primPair(), "bezier", formal(primPair(), "a", false, false), formal(primPair(), "b", false, false), formal(primPair(), "c", false, false), formal(primPair(), "d", false, false), formal(primReal(), "t", false, false));
+#line 3117 "runtime.in"
+ addFunc(ve, run::gen261, primPair(), "bezierP", formal(primPair(), "a", false, false), formal(primPair(), "b", false, false), formal(primPair(), "c", false, false), formal(primPair(), "d", false, false), formal(primReal(), "t", false, false));
+#line 3122 "runtime.in"
+ addFunc(ve, run::gen262, primPair(), "bezierPP", formal(primPair(), "a", false, false), formal(primPair(), "b", false, false), formal(primPair(), "c", false, false), formal(primPair(), "d", false, false), formal(primReal(), "t", false, false));
+#line 3127 "runtime.in"
+ addFunc(ve, run::gen263, primPair(), "bezierPPP", formal(primPair(), "a", false, false), formal(primPair(), "b", false, false), formal(primPair(), "c", false, false), formal(primPair(), "d", false, false));
+#line 3132 "runtime.in"
+ addFunc(ve, run::gen264, primTriple(), "bezier", formal(primTriple(), "a", false, false), formal(primTriple(), "b", false, false), formal(primTriple(), "c", false, false), formal(primTriple(), "d", false, false), formal(primReal(), "t", false, false));
+#line 3139 "runtime.in"
+ addFunc(ve, run::gen265, primTriple(), "bezierP", formal(primTriple(), "a", false, false), formal(primTriple(), "b", false, false), formal(primTriple(), "c", false, false), formal(primTriple(), "d", false, false), formal(primReal(), "t", false, false));
+#line 3144 "runtime.in"
+ addFunc(ve, run::gen266, primTriple(), "bezierPP", formal(primTriple(), "a", false, false), formal(primTriple(), "b", false, false), formal(primTriple(), "c", false, false), formal(primTriple(), "d", false, false), formal(primReal(), "t", false, false));
+#line 3149 "runtime.in"
+ addFunc(ve, run::gen267, primTriple(), "bezierPPP", formal(primTriple(), "a", false, false), formal(primTriple(), "b", false, false), formal(primTriple(), "c", false, false), formal(primTriple(), "d", false, false));
+#line 3162 "runtime.in"
+ addFunc(ve, run::gen269, primInt(), "length", formal(primString(), "s", false, false));
+#line 3167 "runtime.in"
+ addFunc(ve, run::gen270, primInt(), "find", formal(primString(), "s", false, false), formal(primString() , "t", false, false), formal(primInt(), "pos", true, false));
+#line 3173 "runtime.in"
+ addFunc(ve, run::gen271, primInt(), "rfind", formal(primString(), "s", false, false), formal(primString() , "t", false, false), formal(primInt(), "pos", true, false));
+#line 3179 "runtime.in"
+ addFunc(ve, run::gen272, primString() , "reverse", formal(primString() , "s", false, false));
+#line 3185 "runtime.in"
+ addFunc(ve, run::gen273, primString() , "insert", formal(primString() , "s", false, false), formal(primInt(), "pos", false, false), formal(primString() , "t", false, false));
+#line 3192 "runtime.in"
+ addFunc(ve, run::gen274, primString() , "substr", formal(primString(), "s", false, false), formal(primInt(), "pos", false, false), formal(primInt(), "n", true, false));
+#line 3199 "runtime.in"
+ addFunc(ve, run::gen275, primString() , "erase", formal(primString() , "s", false, false), formal(primInt(), "pos", false, false), formal(primInt(), "n", false, false));
+#line 3206 "runtime.in"
+ addFunc(ve, run::gen276, primString() , "downcase", formal(primString() , "s", false, false));
+#line 3212 "runtime.in"
+ addFunc(ve, run::gen277, primString() , "upcase", formal(primString() , "s", false, false));
+#line 3218 "runtime.in"
+ addFunc(ve, run::gen278, primString() , "replace", formal(primString(), "s", false, false), formal(stringArray2(), "translate", false, false));
+#line 3245 "runtime.in"
+ addFunc(ve, run::gen279, primString() , "format", formal(primString(), "format", false, false), formal(primInt(), "x", false, false));
+#line 3260 "runtime.in"
+ addFunc(ve, run::gen280, primString() , "format", formal(primString(), "format", false, false), formal(primReal(), "x", false, false), formal(primString() , "locale", true, false));
+#line 3378 "runtime.in"
+ addFunc(ve, run::gen281, primInt(), "hex", formal(primString() , "s", false, false));
+#line 3389 "runtime.in"
+ addFunc(ve, run::gen282, primString() , "string", formal(primInt(), "x", false, false));
+#line 3396 "runtime.in"
+ addFunc(ve, run::gen283, primString() , "string", formal(primReal(), "x", false, false), formal(primInt(), "digits", true, false));
+#line 3404 "runtime.in"
+ addFunc(ve, run::gen284, primString() , "time", formal(primString() , "format", true, false));
+#line 3415 "runtime.in"
+ addFunc(ve, run::gen285, primString() , "time", formal(primInt(), "seconds", false, false), formal(primString() , "format", true, false));
+#line 3428 "runtime.in"
+ addFunc(ve, run::gen286, primInt(), "seconds", formal(primString() , "t", true, false), formal(primString() , "format", true, false));
+#line 3440 "runtime.in"
+ addFunc(ve, run::gen287, realArray(), "_cputime");
+#line 3454 "runtime.in"
+ addFunc(ve, run::gen288, primReal(), "^", formal(primReal(), "x", false, false), formal(primInt(), "y", false, false));
+#line 3462 "runtime.in"
+ addFunc(ve, run::gen289, primPair(), "^", formal(primPair(), "z", false, false), formal(primInt(), "y", false, false));
+#line 3467 "runtime.in"
+ addFunc(ve, run::gen290, primInt(), "quotient", formal(primInt(), "x", false, false), formal(primInt(), "y", false, false));
+#line 3475 "runtime.in"
+ addFunc(ve, run::gen291, primInt(), "abs", formal(primInt(), "x", false, false));
+#line 3480 "runtime.in"
+ addFunc(ve, run::gen292, primInt(), "sgn", formal(primReal(), "x", false, false));
+#line 3485 "runtime.in"
+ addFunc(ve, run::gen293, primInt(), "rand");
+#line 3490 "runtime.in"
+ addFunc(ve, run::gen294, primVoid(), "srand", formal(primInt(), "seed", false, false));
+#line 3495 "runtime.in"
+ addFunc(ve, run::gen295, primReal(), "unitrand");
+#line 3501 "runtime.in"
+ addFunc(ve, run::gen296, primInt(), "ceil", formal(primReal(), "x", false, false));
+#line 3506 "runtime.in"
+ addFunc(ve, run::gen297, primInt(), "floor", formal(primReal(), "x", false, false));
+#line 3511 "runtime.in"
+ addFunc(ve, run::gen298, primInt(), "round", formal(primReal(), "x", false, false));
+#line 3517 "runtime.in"
+ addFunc(ve, run::gen299, primInt(), "Ceil", formal(primReal(), "x", false, false));
+#line 3522 "runtime.in"
+ addFunc(ve, run::gen300, primInt(), "Floor", formal(primReal(), "x", false, false));
+#line 3527 "runtime.in"
+ addFunc(ve, run::gen301, primInt(), "Round", formal(primReal(), "x", false, false));
+#line 3532 "runtime.in"
+ addFunc(ve, run::gen302, primReal(), "fmod", formal(primReal(), "x", false, false), formal(primReal(), "y", false, false));
+#line 3538 "runtime.in"
+ addFunc(ve, run::gen303, primReal(), "atan2", formal(primReal(), "y", false, false), formal(primReal(), "x", false, false));
+#line 3543 "runtime.in"
+ addFunc(ve, run::gen304, primReal(), "hypot", formal(primReal(), "x", false, false), formal(primReal(), "y", false, false));
+#line 3548 "runtime.in"
+ addFunc(ve, run::gen305, primReal(), "remainder", formal(primReal(), "x", false, false), formal(primReal(), "y", false, false));
+#line 3553 "runtime.in"
+ addFunc(ve, run::gen306, primReal(), "J", formal(primInt(), "n", false, false), formal(primReal(), "x", false, false));
+#line 3558 "runtime.in"
+ addFunc(ve, run::gen307, primReal(), "Y", formal(primInt(), "n", false, false), formal(primReal(), "x", false, false));
+#line 3563 "runtime.in"
+ addFunc(ve, run::gen308, primReal(), "erf", formal(primReal(), "x", false, false));
+#line 3568 "runtime.in"
+ addFunc(ve, run::gen309, primReal(), "erfc", formal(primReal(), "x", false, false));
+#line 3573 "runtime.in"
+ addFunc(ve, run::gen310, primInt(), "factorial", formal(primInt(), "n", false, false));
+#line 3578 "runtime.in"
+ addFunc(ve, run::gen311, primInt(), "choose", formal(primInt(), "n", false, false), formal(primInt(), "k", false, false));
+#line 3589 "runtime.in"
+ addFunc(ve, run::gen312, primReal(), "gamma", formal(primReal(), "x", false, false));
+#line 3599 "runtime.in"
+ addFunc(ve, run::gen313, primPair(), "gamma", formal(primPair(), "z", false, true));
+#line 3605 "runtime.in"
+ addFunc(ve, run::gen314, realArray(), "quadraticroots", formal(primReal(), "a", false, false), formal(primReal(), "b", false, false), formal(primReal(), "c", false, false));
+#line 3614 "runtime.in"
+ addFunc(ve, run::gen315, pairArray(), "quadraticroots", formal(primPair(), "a", false, true), formal(primPair(), "b", false, true), formal(primPair(), "c", false, true));
+#line 3623 "runtime.in"
+ addFunc(ve, run::gen316, realArray(), "cubicroots", formal(primReal(), "a", false, false), formal(primReal(), "b", false, false), formal(primReal(), "c", false, false), formal(primReal(), "d", false, false));
+#line 3633 "runtime.in"
+ addFunc(ve, run::gen317, primBoolean(), "==", formal(primTransform(), "a", false, false), formal(primTransform(), "b", false, false));
+#line 3641 "runtime.in"
+ addFunc(ve, run::gen318, primBoolean(), "!=", formal(primTransform(), "a", false, false), formal(primTransform(), "b", false, false));
+#line 3646 "runtime.in"
+ addFunc(ve, run::gen319, primTransform(), "+", formal(primTransform(), "a", false, false), formal(primTransform(), "b", false, false));
+#line 3651 "runtime.in"
+ addFunc(ve, run::gen320, primTransform(), "*", formal(primTransform(), "a", false, false), formal(primTransform(), "b", false, false));
+#line 3656 "runtime.in"
+ addFunc(ve, run::gen321, primPair(), "*", formal(primTransform(), "t", false, false), formal(primPair(), "z", false, false));
+#line 3661 "runtime.in"
+ addFunc(ve, run::gen322, primPath(), "*", formal(primTransform(), "t", false, false), formal(primPath(), "g", false, false));
+#line 3666 "runtime.in"
+ addFunc(ve, run::gen323, primPen(), "*", formal(primTransform(), "t", false, false), formal(primPen(), "p", false, false));
+#line 3671 "runtime.in"
+ addFunc(ve, run::gen324, primPicture(), "*", formal(primTransform(), "t", false, false), formal(primPicture(), "f", false, false));
+#line 3676 "runtime.in"
+ addFunc(ve, run::gen325, primPicture(), "*", formal(realArray2(), "t", false, false), formal(primPicture(), "f", false, false));
+#line 3681 "runtime.in"
+ addFunc(ve, run::gen326, primTransform(), "^", formal(primTransform(), "t", false, false), formal(primInt(), "n", false, false));
+#line 3728 "runtime.in"
+ addFunc(ve, run::gen334, primTransform(), "shift", formal(primTransform(), "t", false, false));
+#line 3733 "runtime.in"
+ addFunc(ve, run::gen335, primTransform(), "shiftless", formal(primTransform(), "t", false, false));
+#line 3738 "runtime.in"
+ addFunc(ve, run::transformIdentity, primTransform(), "identity");
+#line 3743 "runtime.in"
+ addFunc(ve, run::gen337, primTransform(), "inverse", formal(primTransform(), "t", false, false));
+#line 3748 "runtime.in"
+ addFunc(ve, run::gen338, primTransform(), "shift", formal(primPair(), "z", false, false));
+#line 3753 "runtime.in"
+ addFunc(ve, run::gen339, primTransform(), "shift", formal(primReal(), "x", false, false), formal(primReal(), "y", false, false));
+#line 3758 "runtime.in"
+ addFunc(ve, run::gen340, primTransform(), "xscale", formal(primReal(), "x", false, false));
+#line 3763 "runtime.in"
+ addFunc(ve, run::gen341, primTransform(), "yscale", formal(primReal(), "y", false, false));
+#line 3768 "runtime.in"
+ addFunc(ve, run::gen342, primTransform(), "scale", formal(primReal(), "x", false, false));
+#line 3773 "runtime.in"
+ addFunc(ve, run::gen343, primTransform(), "scale", formal(primReal(), "x", false, false), formal(primReal(), "y", false, false));
+#line 3778 "runtime.in"
+ addFunc(ve, run::gen344, primTransform(), "slant", formal(primReal(), "s", false, false));
+#line 3783 "runtime.in"
+ addFunc(ve, run::gen345, primTransform(), "rotate", formal(primReal(), "angle", false, false), formal(primPair(), "z", true, false));
+#line 3788 "runtime.in"
+ addFunc(ve, run::gen346, primTransform(), "reflect", formal(primPair(), "a", false, false), formal(primPair(), "b", false, false));
+#line 3811 "runtime.in"
+ addFunc(ve, run::pairXPart, primReal(), "xpart", formal(primPair(), "z", false, false));
+#line 3816 "runtime.in"
+ addFunc(ve, run::pairYPart, primReal(), "ypart", formal(primPair(), "z", false, false));
+#line 3821 "runtime.in"
+ addFunc(ve, run::gen352, primReal(), "length", formal(primPair(), "z", false, false));
+#line 3826 "runtime.in"
+ addFunc(ve, run::gen353, primReal(), "abs", formal(primPair(), "z", false, false));
+#line 3831 "runtime.in"
+ addFunc(ve, run::gen354, primPair(), "sqrt", formal(primPair(), "z", false, true));
+#line 3836 "runtime.in"
+ addFunc(ve, run::gen355, primReal(), "angle", formal(primPair(), "z", false, false), formal(primBoolean(), "warn", true, false));
+#line 3843 "runtime.in"
+ addFunc(ve, run::gen356, primReal(), "degrees", formal(primPair(), "z", false, false), formal(primBoolean(), "warn", true, false));
+#line 3850 "runtime.in"
+ addFunc(ve, run::gen357, primReal(), "radians", formal(primReal(), "degrees", false, false));
+#line 3856 "runtime.in"
+ addFunc(ve, run::gen358, primReal(), "degrees", formal(primReal(), "radians", false, false));
+#line 3862 "runtime.in"
+ addFunc(ve, run::gen359, primReal(), "Degrees", formal(primReal(), "radians", false, false));
+#line 3868 "runtime.in"
+ addFunc(ve, run::gen360, primReal(), "Sin", formal(primReal(), "deg", false, false));
+#line 3873 "runtime.in"
+ addFunc(ve, run::gen361, primReal(), "Cos", formal(primReal(), "deg", false, false));
+#line 3878 "runtime.in"
+ addFunc(ve, run::gen362, primReal(), "Tan", formal(primReal(), "deg", false, false));
+#line 3883 "runtime.in"
+ addFunc(ve, run::gen363, primReal(), "aSin", formal(primReal(), "x", false, false));
+#line 3888 "runtime.in"
+ addFunc(ve, run::gen364, primReal(), "aCos", formal(primReal(), "x", false, false));
+#line 3893 "runtime.in"
+ addFunc(ve, run::gen365, primReal(), "aTan", formal(primReal(), "x", false, false));
+#line 3898 "runtime.in"
+ addFunc(ve, run::gen366, primPair(), "unit", formal(primPair(), "z", false, false));
+#line 3903 "runtime.in"
+ addFunc(ve, run::gen367, primPair(), "dir", formal(primReal(), "degrees", false, false));
+#line 3908 "runtime.in"
+ addFunc(ve, run::gen368, primPair(), "dir", formal(primPair(), "z", false, true));
+#line 3913 "runtime.in"
+ addFunc(ve, run::gen369, primPair(), "expi", formal(primReal(), "angle", false, false));
+#line 3918 "runtime.in"
+ addFunc(ve, run::gen370, primPair(), "exp", formal(primPair(), "z", false, true));
+#line 3923 "runtime.in"
+ addFunc(ve, run::gen371, primPair(), "log", formal(primPair(), "z", false, true));
+#line 3928 "runtime.in"
+ addFunc(ve, run::gen372, primPair(), "sin", formal(primPair(), "z", false, true));
+#line 3933 "runtime.in"
+ addFunc(ve, run::gen373, primPair(), "cos", formal(primPair(), "z", false, true));
+#line 3938 "runtime.in"
+ addFunc(ve, run::gen374, primPair(), "conj", formal(primPair(), "z", false, false));
+#line 3943 "runtime.in"
+ addFunc(ve, run::gen375, primPair(), "realmult", formal(primPair(), "z", false, false), formal(primPair(), "w", false, false));
+#line 3948 "runtime.in"
+ addFunc(ve, run::gen376, primTriple(), "realmult", formal(primTriple(), "u", false, false), formal(primTriple(), "v", false, false));
+#line 3953 "runtime.in"
+ addFunc(ve, run::gen377, primReal(), "dot", formal(primPair(), "z", false, true), formal(primPair(), "w", false, true));
+#line 3973 "runtime.in"
+ addFunc(ve, run::tripleXPart, primReal(), "xpart", formal(primTriple(), "v", false, false));
+#line 3978 "runtime.in"
+ addFunc(ve, run::tripleYPart, primReal(), "ypart", formal(primTriple(), "v", false, false));
+#line 3983 "runtime.in"
+ addFunc(ve, run::tripleZPart, primReal(), "zpart", formal(primTriple(), "v", false, false));
+#line 3988 "runtime.in"
+ addFunc(ve, run::gen383, primTriple(), "*", formal(primReal(), "x", false, false), formal(primTriple(), "v", false, false));
+#line 3993 "runtime.in"
+ addFunc(ve, run::gen384, primTriple(), "*", formal(primTriple(), "v", false, false), formal(primReal(), "x", false, false));
+#line 3998 "runtime.in"
+ addFunc(ve, run::gen385, primTriple(), "/", formal(primTriple(), "v", false, false), formal(primReal(), "x", false, false));
+#line 4003 "runtime.in"
+ addFunc(ve, run::gen386, primReal(), "length", formal(primTriple(), "v", false, false));
+#line 4008 "runtime.in"
+ addFunc(ve, run::gen387, primReal(), "abs", formal(primTriple(), "v", false, false));
+#line 4013 "runtime.in"
+ addFunc(ve, run::gen388, primReal(), "polar", formal(primTriple(), "v", false, false));
+#line 4018 "runtime.in"
+ addFunc(ve, run::gen389, primReal(), "azimuth", formal(primTriple(), "v", false, false));
+#line 4023 "runtime.in"
+ addFunc(ve, run::gen390, primReal(), "colatitude", formal(primTriple(), "v", false, false));
+#line 4028 "runtime.in"
+ addFunc(ve, run::gen391, primReal(), "latitude", formal(primTriple(), "v", false, false));
+#line 4033 "runtime.in"
+ addFunc(ve, run::gen392, primReal(), "longitude", formal(primTriple(), "v", false, false), formal(primBoolean(), "warn", true, false));
+#line 4040 "runtime.in"
+ addFunc(ve, run::gen393, primTriple(), "unit", formal(primTriple(), "v", false, false));
+#line 4045 "runtime.in"
+ addFunc(ve, run::gen394, primReal(), "dot", formal(primTriple(), "u", false, false), formal(primTriple(), "v", false, false));
+#line 4050 "runtime.in"
+ addFunc(ve, run::gen395, primTriple(), "cross", formal(primTriple(), "u", false, false), formal(primTriple(), "v", false, false));
+#line 4055 "runtime.in"
+ addFunc(ve, run::gen396, primTriple(), "expi", formal(primReal(), "polar", false, false), formal(primReal(), "azimuth", false, false));
+#line 4060 "runtime.in"
+ addFunc(ve, run::gen397, primTriple(), "dir", formal(primReal(), "colatitude", false, false), formal(primReal(), "longitude", false, false));
+#line 4065 "runtime.in"
+ addFunc(ve, run::gen398, primVoid(), "atupdate", formal(voidFunction(), "f", false, false));
+#line 4073 "runtime.in"
+ addFunc(ve, run::gen399, voidFunction(), "atupdate");
+#line 4078 "runtime.in"
+ addFunc(ve, run::gen400, primVoid(), "atexit", formal(voidFunction(), "f", false, false));
+#line 4083 "runtime.in"
+ addFunc(ve, run::gen401, voidFunction(), "atexit");
+#line 4088 "runtime.in"
+ addFunc(ve, run::gen402, primVoid(), "atbreakpoint", formal(breakpointFunction(), "f", false, false));
+#line 4093 "runtime.in"
+ addFunc(ve, run::gen403, primVoid(), "breakpoint", formal(primCode(), "s", true, false));
+#line 4098 "runtime.in"
+ addFunc(ve, run::gen404, primString() , "locatefile", formal(primString() , "file", false, false));
+#line 4103 "runtime.in"
+ addFunc(ve, run::gen405, primVoid(), "stop", formal(primString() , "file", false, false), formal(primInt(), "line", false, false), formal(primCode(), "s", true, false));
+#line 4111 "runtime.in"
+ addFunc(ve, run::gen406, primVoid(), "breakpoints");
+#line 4117 "runtime.in"
+ addFunc(ve, run::gen407, primVoid(), "clear", formal(primString() , "file", false, false), formal(primInt(), "line", false, false));
+#line 4123 "runtime.in"
+ addFunc(ve, run::gen408, primVoid(), "clear");
+#line 4128 "runtime.in"
+ addFunc(ve, run::gen409, primString() , "stripdirectory", formal(primString(), "s", false, false));
+#line 4134 "runtime.in"
+ addFunc(ve, run::gen410, primString() , "stripfile", formal(primString(), "s", false, false));
+#line 4140 "runtime.in"
+ addFunc(ve, run::gen411, primString() , "stripextension", formal(primString(), "s", false, false));
+#line 4146 "runtime.in"
+ addFunc(ve, run::gen412, primInt(), "convert", formal(primString() , "args", true, false), formal(primString() , "file", true, false), formal(primString() , "format", true, false));
+#line 4164 "runtime.in"
+ addFunc(ve, run::gen413, primInt(), "animate", formal(primString() , "args", true, false), formal(primString() , "file", true, false), formal(primString() , "format", true, false));
+#line 4180 "runtime.in"
+ addFunc(ve, run::gen414, primInt(), "delete", formal(primString(), "s", false, false));
+#line 4190 "runtime.in"
+ addFunc(ve, run::gen415, primInt(), "rename", formal(primString(), "from", false, false), formal(primString(), "to", false, false));
+#line 4489 "runtime.in"
+ addFunc(ve, run::gen446, IntArray(), "complement", formal(IntArray(), "a", false, false), formal(primInt(), "n", false, false));
+#line 4521 "runtime.in"
+ addFunc(ve, run::gen448, IntArray(), "sequence", formal(primInt(), "n", false, false));
+#line 4554 "runtime.in"
+ addFunc(ve, run::gen451, primBoolean(), "all", formal(boolArray(), "a", false, false));
+#line 4563 "runtime.in"
+ addFunc(ve, run::gen452, boolArray(), "!", formal(boolArray(), "a", false, false));
+#line 4572 "runtime.in"
+ addFunc(ve, run::gen453, primInt(), "sum", formal(boolArray(), "a", false, false));
+#line 4735 "runtime.in"
+ addFunc(ve, run::gen460, primInt(), "find", formal(boolArray(), "a", false, false), formal(primInt(), "n", true, false));
+#line 4755 "runtime.in"
+ addFunc(ve, run::gen461, primBoolean(), "==", formal(realArray2(), "a", false, false), formal(realArray2(), "b", false, false));
+#line 4800 "runtime.in"
+ addFunc(ve, run::gen463, realArray2(), "identity", formal(primInt(), "n", false, false));
+#line 4823 "runtime.in"
+ addFunc(ve, run::gen465, realArray2(), "inverse", formal(realArray2(), "a", false, false));
+#line 4915 "runtime.in"
+ addFunc(ve, run::gen466, realArray(), "solve", formal(realArray2(), "a", false, false), formal(realArray(), "b", false, false), formal(primBoolean(), "warn", true, false));
+#line 4966 "runtime.in"
+ addFunc(ve, run::gen467, realArray2(), "solve", formal(realArray2(), "a", false, false), formal(realArray2(), "b", false, false), formal(primBoolean(), "warn", true, false));
+#line 5030 "runtime.in"
+ addFunc(ve, run::gen468, primReal(), "determinant", formal(realArray2(), "a", false, false));
+#line 5046 "runtime.in"
+ addFunc(ve, run::gen469, realArray(), "*", formal(realArray2(), "a", false, false), formal(realArray(), "b", false, false));
+#line 5064 "runtime.in"
+ addFunc(ve, run::gen470, realArray2(), "*", formal(realArray2(), "a", false, false), formal(realArray2(), "b", false, false));
+#line 5099 "runtime.in"
+ addFunc(ve, run::gen471, primTriple(), "*", formal(realArray2(), "t", false, false), formal(primTriple(), "v", false, false));
+#line 5104 "runtime.in"
+ addFunc(ve, run::gen472, primPair(), "project", formal(primTriple(), "v", false, false), formal(realArray2(), "t", false, false));
+#line 5129 "runtime.in"
+ addFunc(ve, run::gen473, primReal(), "dot", formal(realArray(), "a", false, false), formal(realArray(), "b", false, false));
+#line 5139 "runtime.in"
+ addFunc(ve, run::gen474, realArray(), "tridiagonal", formal(realArray(), "a", false, false), formal(realArray(), "b", false, false), formal(realArray(), "c", false, false), formal(realArray(), "f", false, false));
+#line 5243 "runtime.in"
+ addFunc(ve, run::gen475, primReal(), "newton", formal(primInt(), "iterations", true, false), formal(realRealFunction(), "f", false, false), formal(realRealFunction(), "fprime", false, false), formal(primReal(), "x", false, false), formal(primBoolean(), "verbose", true, false));
+#line 5290 "runtime.in"
+ addFunc(ve, run::gen476, primReal(), "newton", formal(primInt(), "iterations", true, false), formal(realRealFunction(), "f", false, false), formal(realRealFunction(), "fprime", false, false), formal(primReal(), "x1", false, false), formal(primReal(), "x2", false, false), formal(primBoolean(), "verbose", true, false));
+#line 5372 "runtime.in"
+ addFunc(ve, run::gen477, primReal(), "simpson", formal(realRealFunction(), "f", false, false), formal(primReal(), "a", false, false), formal(primReal(), "b", false, false), formal(primReal(), "acc", true, false), formal(primReal(), "dxmax", true, false));
+#line 5414 "runtime.in"
+ addFunc(ve, run::gen479, IntArray2(), "triangulate", formal(pairArray(), "z", false, false));
+#line 5449 "runtime.in"
+ addFunc(ve, run::gen480, primBoolean(), "==", formal(primFile(), "a", false, false), formal(primFile(), "b", false, false));
+#line 5457 "runtime.in"
+ addFunc(ve, run::gen481, primBoolean(), "!=", formal(primFile(), "a", false, false), formal(primFile(), "b", false, false));
+#line 5467 "runtime.in"
+ addFunc(ve, run::gen483, primFile(), "input", formal(primString() , "name", false, false), formal(primBoolean(), "check", true, false), formal(primString() , "comment", true, false));
+#line 5475 "runtime.in"
+ addFunc(ve, run::gen484, primFile(), "output", formal(primString() , "name", false, false), formal(primBoolean(), "update", true, false), formal(primString() , "comment", true, false));
+#line 5487 "runtime.in"
+ addFunc(ve, run::gen485, primFile(), "xinput", formal(primString() , "name", false, false), formal(primBoolean(), "check", true, false));
+#line 5501 "runtime.in"
+ addFunc(ve, run::gen486, primFile(), "xoutput", formal(primString() , "name", false, false), formal(primBoolean(), "update", true, false));
+#line 5519 "runtime.in"
+ addFunc(ve, run::gen487, primFile(), "binput", formal(primString() , "name", false, false), formal(primBoolean(), "check", true, false));
+#line 5526 "runtime.in"
+ addFunc(ve, run::gen488, primFile(), "boutput", formal(primString() , "name", false, false), formal(primBoolean(), "update", true, false));
+#line 5536 "runtime.in"
+ addFunc(ve, run::gen489, primBoolean(), "eof", formal(primFile(), "file", false, false));
+#line 5541 "runtime.in"
+ addFunc(ve, run::gen490, primBoolean(), "eol", formal(primFile(), "file", false, false));
+#line 5546 "runtime.in"
+ addFunc(ve, run::gen491, primBoolean(), "error", formal(primFile(), "file", false, false));
+#line 5551 "runtime.in"
+ addFunc(ve, run::gen492, primVoid(), "clear", formal(primFile(), "file", false, false));
+#line 5556 "runtime.in"
+ addFunc(ve, run::gen493, primVoid(), "close", formal(primFile(), "file", false, false));
+#line 5561 "runtime.in"
+ addFunc(ve, run::gen494, primInt(), "precision", formal(primFile(), "file", true, false), formal(primInt(), "digits", true, false));
+#line 5567 "runtime.in"
+ addFunc(ve, run::gen495, primVoid(), "flush", formal(primFile(), "file", false, false));
+#line 5572 "runtime.in"
+ addFunc(ve, run::gen496, primString() , "getc", formal(primFile(), "file", false, false));
+#line 5581 "runtime.in"
+ addFunc(ve, run::gen497, primInt(), "tell", formal(primFile(), "file", false, false));
+#line 5586 "runtime.in"
+ addFunc(ve, run::gen498, primVoid(), "seek", formal(primFile(), "file", false, false), formal(primInt(), "pos", false, false));
+#line 5591 "runtime.in"
+ addFunc(ve, run::gen499, primVoid(), "seekeof", formal(primFile(), "file", false, false));
+#line 5596 "runtime.in"
+ addFunc(ve, run::gen500, primFile(), "dimension", formal(primFile(), "file", false, false), formal(primInt(), "nx", false, false));
+#line 5603 "runtime.in"
+ addFunc(ve, run::gen501, primFile(), "dimension", formal(primFile(), "file", false, false), formal(primInt(), "nx", false, false), formal(primInt(), "ny", false, false));
+#line 5609 "runtime.in"
+ addFunc(ve, run::gen502, primFile(), "dimension", formal(primFile(), "file", false, false), formal(primInt(), "nx", false, false), formal(primInt(), "ny", false, false), formal(primInt(), "nz", false, false));
+#line 5615 "runtime.in"
+ addFunc(ve, run::gen503, primFile(), "csv", formal(primFile(), "file", false, false), formal(primBoolean(), "b", true, false));
+#line 5622 "runtime.in"
+ addFunc(ve, run::gen504, primFile(), "word", formal(primFile(), "file", false, false), formal(primBoolean(), "b", true, false));
+#line 5629 "runtime.in"
+ addFunc(ve, run::gen505, primFile(), "line", formal(primFile(), "file", false, false), formal(primBoolean(), "b", true, false));
+#line 5636 "runtime.in"
+ addFunc(ve, run::gen506, primFile(), "single", formal(primFile(), "file", false, false), formal(primBoolean(), "b", true, false));
+#line 5644 "runtime.in"
+ addFunc(ve, run::gen507, primFile(), "single", formal(primFile(), "file", false, false), formal(primReal(), "x", false, false), formal(primBoolean(), "b", true, false));
+#line 5652 "runtime.in"
+ addFunc(ve, run::gen508, primFile(), "single", formal(primFile(), "file", false, false), formal(primInt(), "x", false, false), formal(primBoolean(), "b", true, false));
+#line 5660 "runtime.in"
+ addFunc(ve, run::gen509, primFile(), "read1", formal(primFile(), "file", false, false));
+#line 5667 "runtime.in"
+ addFunc(ve, run::gen510, primFile(), "read2", formal(primFile(), "file", false, false));
+#line 5674 "runtime.in"
+ addFunc(ve, run::gen511, primFile(), "read3", formal(primFile(), "file", false, false));
+#line 5681 "runtime.in"
+ addFunc(ve, run::gen512, stringArray(), "history", formal(primString() , "name", false, false), formal(primInt(), "n", true, false));
+#line 5714 "runtime.in"
+ addFunc(ve, run::gen513, stringArray(), "history", formal(primInt(), "n", true, false));
+#line 5725 "runtime.in"
+ addFunc(ve, run::gen514, primString() , "readline", formal(primString() , "prompt", true, false), formal(primString() , "name", true, false), formal(primBoolean(), "tabcompletion", true, false));
+#line 5769 "runtime.in"
+ addFunc(ve, run::gen515, primVoid(), "saveline", formal(primString() , "name", false, false), formal(primString() , "value", false, false), formal(primBoolean(), "store", true, false));
+#line 5799 "runtime.in"
+ addFunc(ve, run::gen516, primVoid(), "generate_random_backtrace");
+#line 5808 "runtime.in"
+ addFunc(ve, run::gen517, primVoid(), "print_random_addresses", formal(primInt(), "n", true, false));
+}
+
+} // namespace trans