summaryrefslogtreecommitdiff
path: root/Build/source/utils/asymptote/asy.list
diff options
context:
space:
mode:
authorKarl Berry <karl@freefriends.org>2012-05-31 00:02:26 +0000
committerKarl Berry <karl@freefriends.org>2012-05-31 00:02:26 +0000
commit19fc9fd9a26973d87fad437ce549ffaba479df54 (patch)
treef40a9d2592b3cf827970c8bf54a1eebf9cc8f9c0 /Build/source/utils/asymptote/asy.list
parent24b3bac312553b2cc61e94fda581aba311967f5c (diff)
asy 2.16 sources
git-svn-id: svn://tug.org/texlive/trunk@26734 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/utils/asymptote/asy.list')
-rw-r--r--Build/source/utils/asymptote/asy.list3753
1 files changed, 3753 insertions, 0 deletions
diff --git a/Build/source/utils/asymptote/asy.list b/Build/source/utils/asymptote/asy.list
index e69de29bb2d..6e94649b60b 100644
--- a/Build/source/utils/asymptote/asy.list
+++ b/Build/source/utils/asymptote/asy.list
@@ -0,0 +1,3753 @@
+string stripfile(string s);
+string stripsuffix(string f, string suffix=<default>);
+real cbrt(real x);
+real[] cbrt(real[] a);
+cputime cputime();
+string stripdirectory(string s);
+real sqrtEpsilon;
+string stripextension(string s);
+version version;
+void texpreamble(string s);
+pen beveljoin;
+string cputimeformat;
+real Cos(real deg);
+string insert(string s, int pos, string t);
+marginT EndDotMargin(path, pen);
+pen heavyred;
+pen black;
+pen heavyblue;
+pen heavygreen;
+pen heavycyan;
+marginT PenMargin(path, pen)(real begin, real end);
+marginT PenMargin(path, pen);
+int realDigits;
+pen heavymagenta;
+marginT PenMargins(path, pen);
+void newl(file file);
+void seek(file f, int pos);
+string verbatim(string s);
+pen heavygray;
+pen heavygrey;
+void markuniform(picture pic=<default>, frame f, path g)(pair z(real t), real a, real b, int n);
+void markuniform(picture pic=<default>, frame f, path g)(bool centered=<default>, int n, bool rotated=<default>);
+real[] mintimes(path p);
+real[] mintimes(path3 p);
+bool straight(path p, int t);
+bool straight(path3 p, int t);
+pen makepen(path p);
+real dotsize(pen p=<default>);
+real[] curlSpecifier(guide g, int t);
+real straightness(path3 p, int t);
+real straightness(triple z0, triple c0, triple c1, triple z1);
+real log10(real x);
+real[] log10(real[] a);
+pen paleblue;
+bool prc0(string format=<default>);
+int CTZ(int a);
+real barfactor;
+pen Magenta;
+real cos(real x);
+real[] cos(real[] a);
+pair cos(explicit pair z);
+int intMax;
+bool cyclic(guide g);
+bool cyclic(path p);
+bool cyclic(path3 p);
+void printBytecode(<open>);
+transform Rotate(transform)(pair z);
+transform Rotate(transform t);
+bool inXasyMode;
+path subpath(path p, int a, int b);
+path subpath(path p, real a, real b);
+path3 subpath(path3 p, int a, int b);
+path3 subpath(path3 p, real a, real b);
+bool isnan(real x);
+string jobname(string name);
+void print_random_addresses(int n=<default>);
+void attach(picture dest=<default>, frame src, pair position=<default>, bool group=<default>, filltype filltype=<default>, bool above=<default>);
+void attach(picture dest=<default>, frame src, pair position, pair align, bool group=<default>, filltype filltype=<default>, bool above=<default>);
+real[] quadraticroots(real a, real b, real c);
+pair[] quadraticroots(explicit pair a, explicit pair b, explicit pair c);
+pen darkcyan;
+string[] file3;
+real[] maxtimes(path p);
+real[] maxtimes(path3 p);
+filltype FillDraw;
+filltype FillDraw(real xmargin=<default>, real ymargin=<default>, pen fillpen=<default>, pen drawpen=<default>);
+void initdefaults();
+void erase(frame f);
+string erase(string s, int pos, int n);
+void erase(picture pic=<default>);
+pair E;
+int Ceil(real x);
+pair I;
+pair SSW;
+pen magenta;
+pair WSW;
+pair N;
+bool view();
+void usersetting();
+pair S;
+void nowarn(string s);
+transform rotate(real angle, pair z=<default>);
+int quotient(int x, int y);
+transform rotation(transform t);
+pair W;
+int rand();
+pen ZapfChancery(string series=<default>, string shape=<default>);
+int XOR(int a, int b);
+void atupdate(void f());
+void atupdate()();
+void unfill(frame f, path[] g, bool copy=<default>);
+void unfill(picture pic=<default>, path[] g, bool copy=<default>);
+bool Bar(picture, path, pen, marginT(path, pen));
+bool Bar(picture, path, pen, marginT(path, pen))(real size=<default>);
+bool eol(file f);
+pen zerowinding;
+void atbreakpoint(string f(string, int, int, code));
+void savedefaults()();
+bool MidArrow(picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>);
+bool MidArrow(picture, path, pen, marginT(path, pen));
+bool MidArcArrow(picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>);
+bool MidArcArrow(picture, path, pen, marginT(path, pen));
+void exitXasyMode();
+void grestore(frame f);
+pair extension(pair p, pair q, pair p, pair q);
+pen extendcap;
+int ceil(real x);
+pen thick(pen p=<default>);
+pair left;
+int Suppress;
+file input(string name=<default>, bool check=<default>, string comment=<default>, string mode=<default>);
+int SuppressQuiet;
+real[] texsize(string s, pen p=<default>);
+string nativeformat();
+bool invisible(pen p);
+pen invisible();
+pen invisible;
+bool CCW;
+void usetypescript(string s, string encoding=<default>);
+path randompath(int n, bool cumulate=<default>, guide join(... guide[])=<default>);
+int system(string[] s);
+int system(string s);
+void bar(picture pic, pair a, pair d, pen p=<default>);
+picture bar(pair a, pair d, pen p=<default>);
+side NoSide;
+file stdout;
+transform Shift(transform t);
+real fmod(real x, real y);
+real offset(pen p);
+pen rgb(pen p);
+pen rgb(real r, real g, real b);
+pen rgb(string s);
+real inch;
+bool ArcArrow(picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>);
+bool ArcArrow(picture, path, pen, marginT(path, pen));
+bool ArcArrows(picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>);
+bool ArcArrows(picture, path, pen, marginT(path, pen));
+pen currentpen;
+pair precontrol(path p, int t);
+pair precontrol(path p, real t);
+triple precontrol(path3 p, int t);
+triple precontrol(path3 p, real t);
+light currentlight;
+pen royalblue;
+picture currentpicture;
+frame currentpatterns;
+int JOIN_IN;
+int JOIN_OUT;
+projection currentprojection;
+void endScript();
+pen linetype(real[] pattern, real offset=<default>, bool scale=<default>, bool adjust=<default>);
+real[] linetype(pen p=<default>);
+pen linetype(string pattern, real offset=<default>, bool scale=<default>, bool adjust=<default>);
+real xpart(pair z);
+real xpart(triple v);
+side Center;
+real ypart(pair z);
+real ypart(triple v);
+real zpart(triple v);
+frame orientation(frame);
+pen Courier(string series=<default>, string shape=<default>);
+real simpson(real f(real), real a, real b, real acc=<default>, real dxmax=<default>);
+transform shift(transform t);
+transform shift(pair z);
+transform shift(real x, real y);
+transform shift(frame f, pair align);
+real asinh(real x);
+real[] asinh(real[] a);
+pen orange;
+pen darkgray;
+slice lastcut(path p, path knife);
+pen darkgreen;
+pen darkgrey;
+transform xscale(real x);
+transform shiftless(transform t);
+real[][] shiftless(real[][] t);
+transform yscale(real y);
+void usleep(int microseconds);
+real cosh(real x);
+real[] cosh(real[] a);
+position MidPoint;
+real Sin(real deg);
+void assert(bool b, string s=<default>);
+pen Palatino(string series=<default>, string shape=<default>);
+real incircle(pair a, pair b, pair c, pair d);
+frame Landscape(frame f);
+pen purple;
+string italic(string s);
+real atan(real x);
+real[] atan(real[] a);
+real acos(real x);
+real[] acos(real[] a);
+pair minbound(pair a, pair b);
+triple minbound(triple a, triple b);
+pair minbound(pair[] a);
+pair minbound(pair[][] a);
+pair minbound(pair[][][] a);
+triple minbound(triple[] a);
+triple minbound(triple[][] a);
+triple minbound(triple[][][] a);
+void restore();
+pen basealign(int n);
+int basealign(pen p=<default>);
+pen basealign;
+int min(int a, int b);
+int[] min(int a, int[] b);
+int[] min(int[] a, int b);
+int[] min(int[] a, int[] b);
+int min(int[] a);
+int min(int[][] a);
+int min(int[][][] a);
+real min(real a, real b);
+real[] min(real a, real[] b);
+real[] min(real[] a, real b);
+real[] min(real[] a, real[] b);
+real min(real[] a);
+real min(real[][] a);
+real min(real[][][] a);
+string min(string a, string b);
+string[] min(string a, string[] b);
+string[] min(string[] a, string b);
+string[] min(string[] a, string[] b);
+string min(string[] a);
+string min(string[][] a);
+string min(string[][][] a);
+pair min(pen p);
+pair min(frame f);
+pair min(path p);
+pair min(explicit path[] p);
+triple min(path3 p);
+real min(... real[] a);
+pair min(picture pic, bool user=<default>);
+real min(real m, scaling s, coord[] c);
+real min(real m, scaling s, coord[] c);
+int min(... int[] a);
+filltype RadialShade(pen penc, pen penr);
+int search(int[] a, int key);
+int search(real[] a, real key);
+int search(string[] a, string key);
+int search(void()()[] a, void key()(), bool less(void()(), void()()));
+int search(object[] a, object key, bool less(object, object));
+int search(real[] a, real key, bool less(real, real));
+int search(guide[] a, guide key, bool less(guide, guide));
+int search(coord[] a, coord key, bool less(coord, coord));
+int search(Label[] a, Label key, bool less(Label, Label));
+int search(pair[] a, pair key, bool less(pair, pair));
+int search(frame[] a, frame key, bool less(frame, frame));
+int search(coord[] a, coord key, bool less(coord, coord));
+int search(int[] a, int key, bool less(int, int));
+int search(bool3[] a, bool3 key, bool less(bool3, bool3));
+int search(picture[] a, picture key, bool less(picture, picture));
+int search(marker[] a, marker key, bool less(marker, marker));
+int search(string[] a, string key, bool less(string, string));
+int search(path[] a, path key, bool less(path, path));
+int search(pen[] a, pen key, bool less(pen, pen));
+int search(bool[] a, bool key, bool less(bool, bool));
+int search(triple[] a, triple key, bool less(triple, triple));
+int search(Legend[] a, Legend key, bool less(Legend, Legend));
+filltype RadialShadeDraw(real xmargin=<default>, real ymargin=<default>, pen penc, pen penr, pen drawpen=<default>);
+real sin(real x);
+real[] sin(real[] a);
+pair sin(explicit pair z);
+pen deepcyan;
+void restoredefaults();
+path[] plus;
+pair expi(real angle);
+triple expi(real polar, real azimuth);
+void endclip(frame f);
+void endclip(picture pic=<default>);
+pen opacity(real opacity=<default>, string blend=<default>);
+real opacity(pen p);
+real[] solve(real[][] a, real[] b, bool warn=<default>);
+real[][] solve(real[][] a, real[][] b, bool warn=<default>);
+int rename(string from, string to);
+void DOSendl(file file);
+string debugger(string file, int line, int column, code s=<default>);
+string getc(file f);
+bool debugging;
+void shipout(string prefix=<default>, frame f, frame preamble=<default>, string format=<default>, bool wait=<default>, bool view=<default>, transform xform());
+void shipout(string prefix=<default>, frame f, string format=<default>, bool wait=<default>, bool view=<default>, string options=<default>, string script=<default>, light light=<default>, projection P=<default>);
+void shipout(string prefix=<default>, picture pic=<default>, frame orientation(frame)=<default>, string format=<default>, bool wait=<default>, bool view=<default>, string options=<default>, string script=<default>, light light=<default>, projection P=<default>);
+void shipout3(string prefix, frame f, string format=<default>, real width, real height, real angle, real zoom, triple m, triple m, pair shift, real[][] t, real[] background, triple[] lights, real[][] diffuse, real[][] ambient, real[][] specular, bool viewportlighting, bool view=<default>);
+void shipout3(string prefix, frame f, int[] index, triple[] center);
+string getstring(string name=<default>, string default=<default>, string prompt=<default>, bool store=<default>);
+int debuggerlines;
+frame bbox(picture pic=<default>, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>);
+real radians(real degrees);
+bool pdf();
+void _eval(string s, bool embedded, bool interactivewrite=<default>);
+void _eval(code s, bool embedded);
+path[][] textpath(string[] s, pen[] p);
+void radialshade(frame f, path[] g, bool stroke=<default>, pen pena, pair a, real ra, pen penb, pair b, real rb, bool copy=<default>);
+void radialshade(picture pic=<default>, path[] g, bool stroke=<default>, pen pena, pair a, real ra, pen penb, pair b, real rb, bool copy=<default>);
+pair maxbound(pair a, pair b);
+triple maxbound(triple a, triple b);
+pair maxbound(pair[] a);
+pair maxbound(pair[][] a);
+pair maxbound(pair[][][] a);
+triple maxbound(triple[] a);
+triple maxbound(triple[][] a);
+triple maxbound(triple[][][] a);
+string Embed(string name, string options=<default>, real width=<default>, real height=<default>);
+pair postcontrol(path p, int t);
+pair postcontrol(path p, real t);
+triple postcontrol(path3 p, int t);
+triple postcontrol(path3 p, real t);
+int max(int a, int b);
+int[] max(int a, int[] b);
+int[] max(int[] a, int b);
+int[] max(int[] a, int[] b);
+int max(int[] a);
+int max(int[][] a);
+int max(int[][][] a);
+real max(real a, real b);
+real[] max(real a, real[] b);
+real[] max(real[] a, real b);
+real[] max(real[] a, real[] b);
+real max(real[] a);
+real max(real[][] a);
+real max(real[][][] a);
+string max(string a, string b);
+string[] max(string a, string[] b);
+string[] max(string[] a, string b);
+string[] max(string[] a, string[] b);
+string max(string[] a);
+string max(string[][] a);
+string max(string[][][] a);
+pair max(pen p);
+pair max(frame f);
+pair max(path p);
+pair max(explicit path[] p);
+triple max(path3 p);
+pair max(picture pic, bool user=<default>);
+real max(real M, scaling s, coord[] c);
+real max(real M, scaling s, coord[] c);
+int max(... int[] a);
+real max(... real[] a);
+Label Label(Label L, align align=<default>, pen p=<default>, transform embed(transform)=<default>, filltype filltype=<default>);
+Label Label(Label L, pair position, align align=<default>, pen p=<default>, transform embed(transform)=<default>, filltype filltype=<default>);
+Label Label(string s, string size=<default>, explicit position position, align align=<default>, pen p=<default>, transform embed(transform)=<default>, filltype filltype=<default>);
+Label Label(Label L, explicit position position, align align=<default>, pen p=<default>, transform embed(transform)=<default>, filltype filltype=<default>);
+Label Label;
+Label Label(explicit pair position, align align=<default>, pen p=<default>, transform embed(transform)=<default>, filltype filltype=<default>);
+Label Label(string s=<default>, string size=<default>, align align=<default>, pen p=<default>, transform embed(transform)=<default>, filltype filltype=<default>);
+Label Label(string s, string size=<default>, pair position, align align=<default>, pen p=<default>, transform embed(transform)=<default>, filltype filltype=<default>);
+string font(pen p=<default>);
+pen font(string name, string options=<default>);
+pen font(string encoding, string family, string series, string shape);
+pen font(string name, real size, string options=<default>);
+marker markthin(path g, pen p=<default>, real thin(real fraction)=<default>, filltype filltype=<default>);
+int intMin;
+pen white;
+side RightSide;
+string replace(string s, string[][] translate);
+string replace(string s, string before, string after);
+transform fixedscaling(picture pic=<default>, pair min, pair max, pen p=<default>, bool warn=<default>);
+pen Symbol(string series=<default>, string shape=<default>);
+slice firstcut(path p, path knife);
+pen squarecap;
+pen squarepen;
+bool EndArrow(picture, path, pen, marginT(path, pen));
+bool EndArrow(picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>);
+real barsize(pen p=<default>);
+bool EndArcArrow(picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>);
+bool EndArcArrow(picture, path, pen, marginT(path, pen));
+void tensorshade(frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[][] p, path[] b=<default>, pair[][] z=<default>, bool copy=<default>);
+void tensorshade(picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[][] p, path[] b=<default>, pair[][] z=<default>, bool copy=<default>);
+void tensorshade(frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, path b=<default>, pair[] z);
+void tensorshade(picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, path b=<default>, pair[] z);
+void tensorshade(frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, path b=<default>);
+void tensorshade(picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, path b=<default>);
+string[] split(string s, string delimiter=<default>);
+void addSaveFunction(void s()());
+object embed3(string, frame, string, string, string, light, projection);
+filltype NoFill;
+real colatitude(triple v, bool warn=<default>);
+void label(frame f, string s, string size, transform t, pair position, pair align, pen p);
+void label(picture pic=<default>, Label L, align align=<default>, pen p=<default>, filltype filltype=<default>);
+void label(frame f, Label L, pair position, align align=<default>, pen p=<default>, filltype filltype=<default>);
+void label(picture pic=<default>, Label L, pair position, align align=<default>, pen p=<default>, filltype filltype=<default>);
+void label(frame f, Label L, align align=<default>, pen p=<default>, filltype filltype=<default>);
+void label(picture pic=<default>, Label L, explicit guide g, align align=<default>, pen p=<default>, filltype filltype=<default>);
+void label(picture pic=<default>, Label L, explicit path g, align align=<default>, pen p=<default>, filltype filltype=<default>);
+real fabs(real x);
+real[] fabs(real[] a);
+bool labels(frame f);
+light light(pen diffuse=<default>, pen ambient=<default>, pen specular=<default>, pen background=<default>, real specularfactor=<default>, bool viewport=<default> ... triple[] position);
+light light(pen[] diffuse, pen[] ambient=<default>, pen[] specular=<default>, pen background=<default>, real specularfactor=<default>, bool viewport=<default>, triple[] position);
+light light(explicit light light);
+light light(pen diffuse=<default>, pen ambient=<default>, pen specular=<default>, pen background=<default>, bool viewport=<default>, real x, real y, real z);
+real remainder(real x, real y);
+int byte(real x);
+real camerafactor;
+pen lightred;
+real labelmargin;
+real labelmargin(pen p=<default>);
+pen lightblue;
+pen lightgreen;
+pair right;
+string outformat(string format=<default>);
+pen lightcyan;
+pen lightmagenta;
+pen lightyellow;
+pen lightgray;
+pen lightolive;
+pen lightgrey;
+string upcase(string s);
+pen darkblue;
+pen darkbrown;
+path[] strokepath(path g, pen p=<default>);
+real erf(real x);
+void saveline(string name, string value, bool store=<default>);
+pen fuchsia;
+bool needshipout();
+filltype filltype(int type=<default>, pen fillpen=<default>, pen drawpen=<default>, void fill2(frame f, path[] g, pen fillpen));
+frame[] fit(string prefix=<default>, picture[] pictures, string format=<default>, bool view=<default>, string options=<default>, string script=<default>, projection P=<default>);
+path box(pair a, pair b);
+path box(frame dest, frame src=<default>, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
+path box(frame f, Label L, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
+pen Bookman(string series=<default>, string shape=<default>);
+void seekeof(file f);
+path unitcircle;
+framedTransformStack xformStack;
+pair[] conj(pair[] a);
+pair[][] conj(pair[][] a);
+pair conj(pair z);
+pen deepgray;
+pen deepgreen;
+pen deepgrey;
+marker[] Mark;
+marker Mark(int n);
+real aTan(real x);
+void _begingroup3(frame f, string name, real compression, real granularity, bool closed, bool tessellate, bool dobreak, bool nobreak, triple center, int interaction);
+path[] MarkPath;
+string graphic(string name, string options=<default>);
+real aCos(real x);
+void texreset();
+int[] complement(int[] a, int n);
+path[] complement(frame f, path[] g);
+pen Cyan;
+marginT NoMargin(path, pen);
+marginT NoMargin(path, pen)();
+path[][] _texpath(string[] s, pen[] p);
+real sinh(real x);
+real[] sinh(real[] a);
+real[] _cputime();
+position EndPoint;
+hsv hsv(real h, real s, real v);
+hsv hsv(pen p);
+void deconstruct(frame f, frame preamble=<default>, real magnification=<default>, transform xform());
+void deconstruct(picture pic=<default>, real magnification=<default>);
+int sgn(real x);
+pair minAfterTransform(transform t, path[] a);
+int seconds(string t=<default>, string format=<default>);
+pen cyan;
+pen grey;
+real cm;
+filltype Fill;
+filltype Fill(real xmargin=<default>, real ymargin=<default>, pen p=<default>);
+pen olive;
+pen darkolive;
+int ascii(string s);
+real arcarrowangle;
+real arcarrowfactor;
+real mm;
+real arcarrowsize(pen p=<default>);
+real calculateScaling(string dir, coord[] coords, real size, bool warn=<default>);
+real calculateScaling(string dir, coord[] coords, real size, bool warn=<default>);
+real calculateScaling(string dir, coord[] m, coord[] M, real size, bool warn=<default>);
+real calculateScaling(string dir, coord[] m, coord[] M, real size, bool warn=<default>);
+triple gettriple(string name=<default>, triple default=<default>, string prompt=<default>, bool store=<default>);
+void drawpixel(frame f, triple v, pen p, real width=<default>);
+pen fontsize(real size, real lineskip);
+real fontsize(pen p=<default>);
+pen fontsize(real size);
+string Link(string label, string text, string options=<default>);
+void close(file f);
+real lineskip(pen p=<default>);
+pen dashed;
+pair maxAfterTransform(transform t, path[] a);
+int[][] triangulate(pair[] z);
+void fill(frame f, path[] g, pen p=<default>, bool copy=<default>);
+path fill(frame dest, frame src, filltype filltype=<default>, real xmargin=<default>, real ymargin=<default>);
+void fill(picture pic=<default>, path[] g, pen p=<default>, bool copy=<default>);
+void fill(pair origin, picture pic=<default>, path[] g, pen p=<default>);
+pair midpoint(path p);
+real exp(real x);
+real[] exp(real[] a);
+pair exp(explicit pair z);
+pen linejoin(int n);
+int linejoin(pen p=<default>);
+real ldexp(real x, int e);
+pen rgba(real[] a);
+real[] rgba(pen p);
+string time(string format=<default>);
+string time(int seconds, string format=<default>);
+void prepend(frame dest, frame src);
+real pt;
+settings settings;
+int MoveQuiet;
+marginT EndMargin(path, pen);
+pen nullpen;
+side LeftSide;
+path nullpath;
+guide[] copy(guide[] a, int depth=<default>);
+real[] copy(real[] a, int depth=<default>);
+triple[] copy(triple[] a, int depth=<default>);
+bool[] copy(bool[] a, int depth=<default>);
+real[][] copy(real[][] a, int depth=<default>);
+pen[] copy(pen[] a, int depth=<default>);
+coord[] copy(coord[] a, int depth=<default>);
+coord[] copy(coord[] a, int depth=<default>);
+picture[] copy(picture[] a, int depth=<default>);
+marker[] copy(marker[] a, int depth=<default>);
+Legend[] copy(Legend[] a, int depth=<default>);
+Label[] copy(Label[] a, int depth=<default>);
+pen[][] copy(pen[][] a, int depth=<default>);
+path[] copy(path[] a, int depth=<default>);
+string[] copy(string[] a, int depth=<default>);
+void()()[] copy(void()()[] a, int depth=<default>);
+int[] copy(int[] a, int depth=<default>);
+string[][] copy(string[][] a, int depth=<default>);
+frame[] copy(frame[] a, int depth=<default>);
+pair[] copy(pair[] a, int depth=<default>);
+bool3[] copy(bool3[] a, int depth=<default>);
+object[] copy(object[] a, int depth=<default>);
+pair[][] copy(pair[][] a, int depth=<default>);
+real[] abs(pair[] a);
+real[] abs(triple[] a);
+real abs(real x);
+real[] abs(real[] a);
+real abs(pair z);
+real abs(triple v);
+int abs(int x);
+pen pink;
+real inches;
+path ellipse(frame dest, frame src=<default>, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
+path ellipse(frame f, Label L, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
+path ellipse(pair c, real a, real b);
+pair getpair(string name=<default>, pair default=<default>, string prompt=<default>, bool store=<default>);
+void axialshade(frame f, path[] g, bool stroke=<default>, pen pena, pair a, pen penb, pair b, bool copy=<default>);
+void axialshade(picture pic=<default>, path[] g, bool stroke=<default>, pen pena, pair a, pen penb, pair b, bool copy=<default>);
+string locale(string s=<default>);
+real dirtime(path p, pair z);
+void copyPairOrTriple(pairOrTriple dest, pairOrTriple src);
+real[] colors(pen p);
+void filloutside(picture pic=<default>, path[] g, pen p=<default>, bool copy=<default>);
+void filloutside(frame f, path[] g, pen p=<default>, bool copy=<default>);
+pen[] colorPen;
+pen colorless(pen p);
+pen solid;
+string colorspace(pen p);
+void warn(string s);
+pen deepblue;
+pen palered;
+real[] map(real f(pair), pair[] a);
+int[] map(int f(real), real[] a);
+bool3[] map(bool3 f(bool3), bool3[] a);
+frame[] map(frame f(frame), frame[] a);
+coord[] map(coord f(coord), coord[] a);
+pen[][] map(pen[] f(pen[]), pen[][] a);
+triple[] map(triple f(triple), triple[] a);
+pen[] map(pen f(pen), pen[] a);
+pair[] map(pair f(pair), pair[] a);
+coord[] map(coord f(coord), coord[] a);
+Label[] map(Label f(Label), Label[] a);
+string[] map(string f(string), string[] a);
+object[] map(object f(object), object[] a);
+void()()[] map(void f()()(void()()), void()()[] a);
+pair[][] map(pair[] f(pair[]), pair[][] a);
+real[] map(real f(real), real[] a);
+Legend[] map(Legend f(Legend), Legend[] a);
+int[] map(int f(int), int[] a);
+string[][] map(string[] f(string[]), string[][] a);
+bool[] map(bool f(bool), bool[] a);
+path[] map(path f(path), path[] a);
+real[][] map(real[] f(real[]), real[][] a);
+picture[] map(picture f(picture), picture[] a);
+marker[] map(marker f(marker), marker[] a);
+guide[] map(guide f(guide), guide[] a);
+path unstraighten(path p);
+path3 unstraighten(path3 p);
+void _image(frame f, real[][] data, pair initial, pair final, pen[] palette=<default>, transform t=<default>, bool copy=<default>, bool antialias=<default>);
+void _image(frame f, pen[][] data, pair initial, pair final, transform t=<default>, bool copy=<default>, bool antialias=<default>);
+void _image(frame f, pen f(int, int), int width, int height, pair initial, pair final, transform t=<default>, bool antialias=<default>);
+pair arcpoint(path p, real L);
+pen Pen(int n);
+int rfind(string s, string t, int pos=<default>);
+pair minratio(frame f);
+pair minratio(triple[][] p, pair b);
+pair minratio(path3 g);
+int[] sequence(int n);
+pen[][] sequence(pen[] f(int), int n);
+coord[] sequence(coord f(int), int n);
+coord[] sequence(coord f(int), int n);
+picture[] sequence(picture f(int), int n);
+marker[] sequence(marker f(int), int n);
+Legend[] sequence(Legend f(int), int n);
+Label[] sequence(Label f(int), int n);
+int[] sequence(int f(int), int n);
+string[][] sequence(string[] f(int), int n);
+pair[] sequence(pair f(int), int n);
+guide[] sequence(guide f(int), int n);
+pen[] sequence(pen f(int), int n);
+void()()[] sequence(void f()()(int), int n);
+bool[] sequence(bool f(int), int n);
+string[] sequence(string f(int), int n);
+pair[][] sequence(pair[] f(int), int n);
+bool3[] sequence(bool3 f(int), int n);
+object[] sequence(object f(int), int n);
+real[][] sequence(real[] f(int), int n);
+real[] sequence(real f(int), int n);
+int[] sequence(int n, int m);
+triple[] sequence(triple f(int), int n);
+path[] sequence(path f(int), int n);
+frame[] sequence(frame f(int), int n);
+triple minbezier(triple[][] p, triple b);
+path trim(path g, real begin, real end);
+marginT DotMargin(path, pen)(real begin, real end);
+marginT DotMargin(path, pen);
+marginT DotMargins(path, pen);
+string string(int x);
+string string(real x, int digits=<default>);
+string cd(string s=<default>);
+int size(guide g);
+pair size(frame f);
+int size(path p);
+int size(path3 p);
+pair size(picture pic, bool user=<default>);
+void size(picture pic=<default>, real x, real y=<default>, bool keepAspect=<default>);
+void size(picture dest, picture src);
+void size(picture pic=<default>, real xsize, real ysize, pair min, pair max);
+void clear(file f);
+void clear(string file, int line);
+void clear();
+void clear(string file, string text);
+pen mediumred;
+pen mediumblue;
+pen mediumgreen;
+pen mediumcyan;
+pen mediummagenta;
+pair arcdir(path p, real L);
+pen mediumyellow;
+pen mediumgray;
+string downcase(string s);
+pen mediumgrey;
+transform transform(pen p);
+string readline(string prompt=<default>, string name=<default>, bool tabcompletion=<default>);
+void beep();
+pair relpoint(path p, real l);
+pair[][] transpose(pair[][] a);
+pen[][] transpose(pen[][] a);
+string[][] transpose(string[][] a);
+real[][] transpose(real[][] a);
+pen overwrite(int n);
+int overwrite(pen p=<default>);
+pen linewidth(real x);
+real linewidth(pen p=<default>);
+transformation transformation(real[][] modelview);
+transformation transformation(real[][] modelview, real[][] projection);
+pair maxratio(frame f);
+pair maxratio(triple[][] p, pair b);
+pair maxratio(path3 g);
+triple maxbezier(triple[][] p, triple b);
+void layer(frame f);
+void layer(picture pic=<default>);
+void DOSnewl(file file);
+pen cmyk(pen p);
+pen cmyk(real c, real m, real y, real k);
+pen blue;
+pen evenodd;
+int precision(file f=<default>, int digits=<default>);
+path3 path3(triple[] pre, triple[] point, triple[] post, bool[] straight, bool cyclic);
+bool piecewisestraight(path p);
+bool piecewisestraight(path3 p);
+void stop(string file, int line, code s=<default>);
+void stop(string file, string text, code s=<default>);
+pair reldir(path p, real l);
+pen TimesRoman(string series=<default>, string shape=<default>);
+slice cut(path p, path knife, int n);
+bool is3D(frame f);
+bool is3D(string format=<default>);
+void report(string text);
+void report(int i);
+void report(transform t);
+void add(frame dest, frame src);
+void add(picture pic=<default>, Label L);
+void add(picture pic=<default>, void d(frame f, transform t), bool exact=<default>);
+void add(frame dest, frame src, filltype filltype, bool above=<default>);
+void add(frame dest, frame src, bool group, filltype filltype=<default>, bool above=<default>);
+void add(picture pic=<default>, void d(picture, real[][]), bool exact=<default>);
+void add(frame dest, frame src, pair position, bool group=<default>, filltype filltype=<default>, bool above=<default>);
+void add(picture dest=<default>, frame src, pair position=<default>, bool group=<default>, filltype filltype=<default>, bool above=<default>);
+void add(picture src, pair position, bool group=<default>, filltype filltype=<default>, bool above=<default>);
+void add(picture dest=<default>, frame src, pair position, pair align, bool group=<default>, filltype filltype=<default>, bool above=<default>);
+void add(frame dest, frame src, pair position, pair align, bool group=<default>, filltype filltype=<default>, bool above=<default>);
+void add(picture src, bool group=<default>, filltype filltype=<default>, bool above=<default>);
+void add(picture pic=<default>, void d(frame f, real[][] t, picture pic, projection P), bool exact=<default>);
+void add(frame f, transform t=<default>, Label L);
+void add(picture pic=<default>, void d(picture, transform), bool exact=<default>);
+void add(picture dest, picture src, bool group=<default>, filltype filltype=<default>, bool above=<default>);
+void add(picture dest, picture src, pair position, bool group=<default>, filltype filltype=<default>, bool above=<default>);
+void add(picture dest=<default>, object F, pair position=<default>, bool group=<default>, filltype filltype=<default>, bool above=<default>);
+plain plain;
+void purge(int divisor=<default>);
+int Round(real x);
+real sqrt(real x);
+real[] sqrt(real[] a);
+pair sqrt(explicit pair z);
+real[] times(path p, real x);
+real[] times(path p, explicit pair z);
+void Draw(picture pic=<default>, path g, pen p=<default>);
+filltype Draw;
+void Draw(picture pic=<default>, explicit path[] g, pen p=<default>);
+filltype Draw(real xmargin=<default>, real ymargin=<default>, pen p=<default>);
+void tab(file file);
+plain_scaling plain_scaling;
+string file(string s);
+plain_bounds plain_bounds;
+string outprefix(string prefix=<default>);
+object object(frame f);
+object object(Label L);
+object object(Label L, path e(frame dest, frame src=<default>, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>), real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
+file stdin;
+void()()[] array(int n, void value()(), int depth=<default>);
+bool[] array(int n, bool value, int depth=<default>);
+string[] array(int n, string value, int depth=<default>);
+pair[][] array(int n, pair[] value, int depth=<default>);
+bool3[] array(int n, bool3 value, int depth=<default>);
+object[] array(int n, object value, int depth=<default>);
+real[][] array(int n, real[] value, int depth=<default>);
+real[] array(int n, real value, int depth=<default>);
+triple[] array(int n, triple value, int depth=<default>);
+path[] array(int n, path value, int depth=<default>);
+frame[] array(int n, frame value, int depth=<default>);
+pen[][] array(int n, pen[] value, int depth=<default>);
+coord[] array(int n, coord value, int depth=<default>);
+coord[] array(int n, coord value, int depth=<default>);
+picture[] array(int n, picture value, int depth=<default>);
+marker[] array(int n, marker value, int depth=<default>);
+Legend[] array(int n, Legend value, int depth=<default>);
+Label[] array(int n, Label value, int depth=<default>);
+int[] array(int n, int value, int depth=<default>);
+string[][] array(int n, string[] value, int depth=<default>);
+pair[] array(int n, pair value, int depth=<default>);
+guide[] array(int n, guide value, int depth=<default>);
+pen[] array(int n, pen value, int depth=<default>);
+bool BeginBar(picture, path, pen, marginT(path, pen));
+bool BeginBar(picture, path, pen, marginT(path, pen))(real size=<default>);
+triple perp(triple v, triple u);
+int find(bool[] a, int n=<default>);
+int find(string s, string t, int pos=<default>);
+position BeginPoint;
+marginT BeginMargin(path, pen);
+path buildcycle(... path[] p);
+bool BeginArrow(picture, path, pen, marginT(path, pen));
+bool BeginArrow(picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>);
+marginT BeginPenMargin(path, pen);
+int round(real x);
+marginT BeginDotMargin(path, pen);
+bool BeginArcArrow(picture, path, pen, marginT(path, pen));
+bool BeginArcArrow(picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>);
+pen roundcap;
+void buildRestoreThunk()();
+pen roundjoin;
+int sourceline(string file, string text);
+void buildRestoreDefaults()();
+path roundbox(frame dest, frame src=<default>, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
+path roundbox(frame f, Label L, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
+real asin(real x);
+real[] asin(real[] a);
+pair endpoint(path p);
+real latitude(triple v, bool warn=<default>);
+int sum(int[] a);
+real sum(real[] a);
+pair sum(pair[] a);
+triple sum(triple[] a);
+int sum(bool[] a);
+real inf;
+real arctime(path p, real l);
+real arctime(path3 p, real dval);
+pen palemagenta;
+void draw(frame f, triple[][] p, triple center, bool straight, pen[] p, real opacity, real shininess, real prcshininess, triple normal, pen[] colors, bool lighton, int interaction, bool prc=<default>);
+void draw(frame f, triple[] p, real[] knot, real[] weights=<default>, pen p);
+void draw(frame f, triple[][] p, real[] uknot, real[] vknot, real[][] weights=<default>, pen[] p, real opacity, real shininess, real prcshininess, pen[] colors, bool lighton);
+void draw(picture pic=<default>, path[] g, pen fillrule=<default>, pen[] p);
+object draw(picture pic=<default>, Label L, path e(frame dest, frame src=<default>, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>), real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
+void draw(frame f, explicit path[] g, pen p=<default>);
+void draw(frame f, path g, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen)));
+void draw(picture pic=<default>, Label L=<default>, path g, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
+void draw(pair origin, picture pic=<default>, Label L=<default>, path g, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
+void draw(picture pic=<default>, guide[] g, pen p=<default>, Label legend=<default>, marker marker=<default>);
+void draw(pair origin, picture pic=<default>, guide[] g, pen p=<default>, Label legend=<default>, marker marker=<default>);
+object draw(picture pic=<default>, Label L, path e(frame dest, frame src=<default>, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>), pair position, real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
+void draw(picture pic=<default>, explicit path[] g, pen p=<default>, Label legend=<default>, marker marker=<default>);
+void draw(pair origin, picture pic=<default>, explicit path[] g, pen p=<default>, Label legend=<default>, marker marker=<default>);
+void draw(frame f, guide[] g, pen p=<default>);
+void draw(frame f, path g, pen p=<default>);
+int mantissaBits;
+real identity(real x);
+real[] identity(real[] a);
+transform identity();
+real[][] identity(int n);
+real[][] identity4;
+marker[] MarkFill;
+pen pattern(string s);
+string pattern(pen p);
+transform invert;
+transform inverse(transform t);
+real[][] inverse(real[][] a);
+pair unit(pair z);
+triple unit(triple v);
+triple min3(frame f);
+triple min3(pen p);
+void begin(picture pic=<default>, string name, string id=<default>, bool visible=<default>);
+void drawPRCdisk(frame f, real[][] t, pen[] p, real opacity, real shininess);
+void drawPRCtube(frame f, path3 center, path3 g, pen[] p, real opacity, real shininess);
+int CLZ(int a);
+void drawPRCsphere(frame f, real[][] t, bool half=<default>, pen[] p, real opacity, real shininess, int type);
+arrowhead DefaultHead;
+void drawPRCcylinder(frame f, real[][] t, pen[] p, real opacity, real shininess);
+void beginclip(frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, bool copy=<default>);
+void beginclip(picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, bool copy=<default>);
+void begingroup(frame f);
+void begingroup(picture pic=<default>);
+marker nomarker;
+pair beginpoint(path p);
+real azimuth(triple v, bool warn=<default>);
+real angle(pair z, bool warn=<default>);
+real angle(transform t);
+pair ENE;
+frame pack(pair align=<default> ... object[] inset);
+void gsave(frame f);
+void write(file file=<default>, string s=<default>, bool x, void suffix(file)=<default> ... bool[]);
+void write(file file=<default>, string s=<default>, explicit bool[] a ... bool[][]);
+void write(file file=<default>, bool[][]);
+void write(file file=<default>, bool[][][]);
+void write(file file=<default>, string s=<default>, int x, void suffix(file)=<default> ... int[]);
+void write(file file=<default>, string s=<default>, explicit int[] a ... int[][]);
+void write(file file=<default>, int[][]);
+void write(file file=<default>, int[][][]);
+void write(file file=<default>, string s=<default>, real x, void suffix(file)=<default> ... real[]);
+void write(file file=<default>, string s=<default>, explicit real[] a ... real[][]);
+void write(file file=<default>, real[][]);
+void write(file file=<default>, real[][][]);
+void write(file file=<default>, string s=<default>, pair x, void suffix(file)=<default> ... pair[]);
+void write(file file=<default>, string s=<default>, explicit pair[] a ... pair[][]);
+void write(file file=<default>, pair[][]);
+void write(file file=<default>, pair[][][]);
+void write(file file=<default>, string s=<default>, triple x, void suffix(file)=<default> ... triple[]);
+void write(file file=<default>, string s=<default>, explicit triple[] a ... triple[][]);
+void write(file file=<default>, triple[][]);
+void write(file file=<default>, triple[][][]);
+void write(file file=<default>, string s=<default>, string x, void suffix(file)=<default> ... string[]);
+void write(file file=<default>, string s=<default>, explicit string[] a ... string[][]);
+void write(file file=<default>, string[][]);
+void write(file file=<default>, string[][][]);
+void write(file file=<default>, string s, void suffix(file)=<default>);
+void write(file file=<default>, string s=<default>, transform x, void suffix(file)=<default> ... transform[]);
+void write(file file=<default>, string s=<default>, guide x, void suffix(file)=<default> ... guide[]);
+void write(file file=<default>, string s=<default>, pen x, void suffix(file)=<default> ... pen[]);
+void write(file file, string s=<default>, explicit guide[] x, void suffix(file)=<default>);
+void write(pairOrTriple a);
+void write(string s=<default>, cputime c, string format=<default>, void suffix(file)=<default>);
+void write(string s=<default>, explicit path[] x, void suffix(file)=<default>);
+void write(file file, void suffix(file)=<default>);
+void write(file file=<default>, string s=<default>, pen[] p);
+void write(void suffix(file)=<default>);
+void write(file file, string s=<default>, explicit path[] x, void suffix(file)=<default>);
+void write(file file=<default>, align align, void suffix(file)=<default>);
+void write(file file=<default>, Label L, void suffix(file)=<default>);
+void write(file file, string s=<default>, cputime c, string format=<default>, void suffix(file)=<default>);
+void write(string s=<default>, bool3 b, void suffix(file)=<default>);
+void write(file file, string s=<default>, bool3 b, void suffix(file)=<default>);
+void write(string s=<default>, explicit guide[] x, void suffix(file)=<default>);
+void save()();
+marginT EndPenMargin(path, pen);
+pair NNE;
+real[] tridiagonal(real[] a, real[] b, real[] c, real[] f);
+pen Dotted;
+pen Dotted(pen p=<default>);
+pair dir(real degrees);
+pair dir(explicit pair z);
+triple dir(explicit triple z);
+triple dir(real colatitude, real longitude);
+pair dir(path p, int t, int sign=<default>, bool normalize=<default>);
+pair dir(path p, real t, bool normalize=<default>);
+triple dir(path3 p, int t, int sign=<default>, bool normalize=<default>);
+triple dir(path3 p, real t, bool normalize=<default>);
+pair dir(path p);
+pair dir(path p, path q);
+int[][] diagonal(... int[]);
+real[][] diagonal(... real[]);
+pair[][] diagonal(... pair[]);
+real reltime(path p, real l);
+void marknodes(picture pic=<default>, frame f, path g);
+real newton(int iterations=<default>, real f(real), real fprime(real), real x, bool verbose=<default>);
+real newton(int iterations=<default>, real f(real), real fprime(real), real x1, real x2, bool verbose=<default>);
+string TeXify(string s);
+bool3 default;
+pair[] controlSpecifier(guide g, int t);
+void defaultpen(pen p);
+pen defaultpen();
+pen defaultpen;
+void defaultpen(real w);
+transform Slant(transform t);
+triple max3(frame f);
+triple max3(pen p);
+string defaultformat(int n, string trailingzero=<default>, bool fixed=<default>, bool signed=<default>);
+string defaultformat;
+pen dashdotted;
+string defaultseparator;
+string asydir();
+string defaultfilename;
+real longitude(triple v, bool warn=<default>);
+bool Blank(picture, path, pen, marginT(path, pen));
+tensionSpecifier tensionSpecifier(guide g, int t);
+marker marker(frame f=<default>, void markroutine(picture pic=<default>, frame f, path g)=<default>, bool above=<default>);
+marker marker(path[] g, void markroutine(picture pic=<default>, frame f, path g)=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
+int Move;
+string location();
+string locatefile(string file);
+pen dotted;
+string blend(pen p);
+arrowhead HookHead;
+arrowhead HookHead(real dir=<default>, real barb=<default>);
+Legend[] concat(... Legend[][]);
+real[] concat(... real[][]);
+object[] concat(... object[][]);
+pair[] concat(... pair[][]);
+coord[] concat(... coord[][]);
+Label[] concat(... Label[][]);
+pen[] concat(... pen[][]);
+path[] concat(... path[][]);
+coord[] concat(... coord[][]);
+int[] concat(... int[][]);
+void()()[] concat(... void()()[][]);
+bool3[] concat(... bool3[][]);
+string[] concat(... string[][]);
+picture[] concat(... picture[][]);
+marker[] concat(... marker[][]);
+triple[] concat(... triple[][]);
+frame[] concat(... frame[][]);
+guide[] concat(... guide[][]);
+bool[] concat(... bool[][]);
+int OR(int a, int b);
+real log1p(real x);
+real[] log1p(real[] a);
+real infinity;
+bool alias(pair[][] a, pair[][] b);
+bool alias(guide[] a, guide[] b);
+bool alias(hsv a, hsv b);
+bool alias(coord[] a, coord[] b);
+bool alias(projection a, projection b);
+bool alias(picture a, picture b);
+bool alias(marker a, marker b);
+bool alias(pair[] a, pair[] b);
+bool alias(scaling a, scaling b);
+bool alias(bounds a, bounds b);
+bool alias(scaleT a, scaleT b);
+bool alias(position a, position b);
+bool alias(cputime a, cputime b);
+bool alias(int[] a, int[] b);
+bool alias(string[][] a, string[][] b);
+bool alias(filltype a, filltype b);
+bool alias(coord[] a, coord[] b);
+bool alias(coords2 a, coords2 b);
+bool alias(Legend a, Legend b);
+bool alias(align a, align b);
+bool alias(framedTransformStack a, framedTransformStack b);
+bool alias(Label[] a, Label[] b);
+bool alias(real[][] a, real[][] b);
+bool alias(bool3 a, bool3 b);
+bool alias(bool3[] a, bool3[] b);
+bool alias(light a, light b);
+bool alias(indexedTransform a, indexedTransform b);
+bool alias(arrowhead a, arrowhead b);
+bool alias(string[] a, string[] b);
+bool alias(frame[] a, frame[] b);
+bool alias(coords2 a, coords2 b);
+bool alias(coord a, coord b);
+bool alias(autoscaleT a, autoscaleT b);
+bool alias(Label a, Label b);
+bool alias(Legend[] a, Legend[] b);
+bool alias(bool[] a, bool[] b);
+bool alias(void()()[] a, void()()[] b);
+bool alias(pen[][] a, pen[][] b);
+bool alias(marginT a, marginT b);
+bool alias(freezableBounds a, freezableBounds b);
+bool alias(transformation a, transformation b);
+bool alias(pairOrTriple a, pairOrTriple b);
+bool alias(path[] a, path[] b);
+bool alias(triple[] a, triple[] b);
+bool alias(coord a, coord b);
+bool alias(coords3 a, coords3 b);
+bool alias(side a, side b);
+bool alias(picture[] a, picture[] b);
+bool alias(marker[] a, marker[] b);
+bool alias(processtime a, processtime b);
+bool alias(real[] a, real[] b);
+bool alias(pen[] a, pen[] b);
+bool alias(slice a, slice b);
+bool alias(scaling a, scaling b);
+bool alias(ScaleT a, ScaleT b);
+bool alias(object a, object b);
+bool alias(object[] a, object[] b);
+real pi;
+int getint(string name=<default>, int default=<default>, string prompt=<default>, bool store=<default>);
+bool IgnoreAspect;
+void postscript(frame f, string s);
+void postscript(frame f, string s, pair min, pair max);
+void postscript(picture pic=<default>, string s, pair min, pair max);
+void postscript(picture pic=<default>, string s);
+transform slant(real s);
+void breakpoint(code s=<default>);
+void breakpoints();
+void endgroup(frame f);
+void endgroup(picture pic=<default>);
+void endgroup3(frame f);
+int Floor(real x);
+pair gamma(explicit pair z);
+real gamma(real x);
+real pow10(real x);
+real[] pow10(real[] a);
+real bp;
+int[] sort(int[] a);
+int[][] sort(int[][] a);
+real[] sort(real[] a);
+real[][] sort(real[][] a);
+string[] sort(string[] a);
+string[][] sort(string[][] a);
+path[] sort(path[] a, bool less(path, path));
+Legend[] sort(Legend[] a, bool less(Legend, Legend));
+pair[] sort(pair[] a, bool less(pair, pair));
+void()()[] sort(void()()[] a, bool less(void()(), void()()));
+real[] sort(real[] a, bool less(real, real));
+bool[] sort(bool[] a, bool less(bool, bool));
+object[] sort(object[] a, bool less(object, object));
+coord[] sort(coord[] a, bool less(coord, coord));
+Label[] sort(Label[] a, bool less(Label, Label));
+pen[] sort(pen[] a, bool less(pen, pen));
+pen[][] sort(pen[][] a, bool less(pen[], pen[]));
+guide[] sort(guide[] a, bool less(guide, guide));
+real[][] sort(real[][] a, bool less(real[], real[]));
+triple[] sort(triple[] a, bool less(triple, triple));
+coord[] sort(coord[] a, bool less(coord, coord));
+string[] sort(string[] a, bool less(string, string));
+int[] sort(int[] a, bool less(int, int));
+string[][] sort(string[][] a, bool less(string[], string[]));
+bool3[] sort(bool3[] a, bool less(bool3, bool3));
+pair[][] sort(pair[][] a, bool less(pair[], pair[]));
+picture[] sort(picture[] a, bool less(picture, picture));
+marker[] sort(marker[] a, bool less(marker, marker));
+frame[] sort(frame[] a, bool less(frame, frame));
+pen salmon;
+bool ignore;
+pen Pentype(int n);
+pen chartreuse;
+void latticeshade(frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[][] p, transform t=<default>, bool copy=<default>);
+void latticeshade(picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[][] p, bool copy=<default>);
+pair[] pairs(real[] x, real[] y);
+void eval(code s, bool embedded=<default>);
+void eval(string s, bool embedded=<default>);
+bool Arrow(picture, path, pen, marginT(path, pen));
+bool Arrow(picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>);
+bool Arrows(picture, path, pen, marginT(path, pen))(arrowhead arrowhead=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>);
+bool Arrows(picture, path, pen, marginT(path, pen));
+int tell(file f);
+pen Yellow;
+pair up;
+guide reverse(guide g);
+string reverse(string s);
+path reverse(path p);
+path3 reverse(path3 p);
+triple[] reverse(triple[] a);
+int[] reverse(int[] a);
+real[] reverse(real[] a);
+int[] reverse(int n);
+string[] reverse(string[] a);
+pair[] reverse(pair[] a);
+bool[] reverse(bool[] a);
+void _labelpath(frame f, string s, string size, path g, string justify, pair offset, pen p);
+int floor(real x);
+void resetdefaultpen();
+real aSin(real x);
+pen darkred;
+transform Scale(transform t);
+pen mean(pen[] p, real opacity(real[])=<default>);
+pen[] mean(pen[][] palette, real opacity(real[])=<default>);
+string mktemp(string s);
+void sleep(int seconds);
+void unitsize(picture pic=<default>, real x, real y=<default>, real z=<default>);
+void arrow(picture pic=<default>, Label L=<default>, pair b, pair dir, real length=<default>, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>);
+picture arrow(arrowhead arrowhead=<default>, path g, pen p=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>, bool forwards=<default>, marginT margin(path, pen)=<default>, bool center=<default>);
+picture arrow2(arrowhead arrowhead=<default>, path g, pen p=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, marginT margin(path, pen)=<default>);
+path unitsquare;
+real arrowdir;
+real arrowbarb;
+pen yellow;
+int delete(string s);
+pen miterjoin;
+arrowhead SimpleHead;
+real arrowangle;
+real arrowlength;
+pen miterlimit(real x);
+real miterlimit(pen p=<default>);
+real arrowfactor;
+real arrowsize(pen p=<default>);
+real Tan(real deg);
+real arrowsizelimit;
+real arrow2sizelimit;
+real arrowhookfactor;
+real arrowtexfactor;
+void comma(file file);
+void deletepreamble();
+real[] arrowbasepoints(path base, path left, path right);
+path arrowbase(path r, pair y, real t, real size);
+int choose(int n, int k);
+real hypot(real x, real y);
+path[] _strokepath(path g, pen p=<default>);
+void pause(string w=<default>);
+int ocgindex;
+pen springgreen;
+pen brown;
+bool scale(pen p);
+transform scale(real x);
+transform scale(real x, real y);
+real[][] scale(real x, real y, real z);
+scaleT scaleT(real T(real x), real Tinv(real x), bool logarithmic=<default>, bool automin=<default>, bool automax=<default>);
+string baseline(string s, string template=<default>);
+real[][] scale3(real s);
+int AND(int a, int b);
+real polar(triple v, bool warn=<default>);
+real radius(path p, real t);
+real radius(path3 p, real t);
+real radius(triple z0, triple c0, triple c1, triple z1, real t);
+transform scaleless(transform t);
+void makedraw(frame f, path g, pen p, int depth=<default>);
+pair down;
+path arc(pair c, real r, real angle1, real angle2);
+path arc(pair c, explicit pair z1, explicit pair z2, bool direction=<default>);
+path arc(pair c, real r, real angle1, real angle2, bool direction);
+real[] cubicroots(real a, real b, real c, real d);
+pen green;
+real tan(real x);
+real[] tan(real[] a);
+pen longdashed;
+pair point(guide g, int t);
+pair point(path p, int t);
+pair point(path p, real t);
+triple point(path3 p, int t);
+triple point(path3 p, real t);
+pair point(picture pic=<default>, pair dir, bool user=<default>);
+pair point(object F, pair dir, transform t=<default>);
+pair point(frame f, pair dir);
+pen longdashdotted;
+void usepackage(string s, string options=<default>);
+real side(pair a, pair b, pair c);
+void drawarrow(frame f, arrowhead arrowhead=<default>, path g, pen p=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, position position=<default>, bool forwards=<default>, marginT margin(path, pen)=<default>, bool center=<default>);
+void drawarrow2(frame f, arrowhead arrowhead=<default>, path g, pen p=<default>, real size=<default>, real angle=<default>, filltype filltype=<default>, marginT margin(path, pen)=<default>);
+pen fillrule(int n);
+int fillrule(pen p);
+pair ESE;
+pair project(triple v, real[][] t);
+bool prc(string format=<default>);
+projection projection(triple camera, triple up=<default>, triple target=<default>, triple normal=<default>, real zoom=<default>, real angle=<default>, pair viewportshift=<default>, bool showtarget=<default>, bool autoadjust=<default>, bool center=<default>, transformation projector(triple camera, triple up, triple target));
+void endl(file file);
+marginT TrueMargin(path, pen)(real begin, real end);
+pair bezier(pair a, pair b, pair c, pair d, real t);
+triple bezier(triple a, triple b, triple c, triple d, real t);
+pair SSE;
+pair bezierP(pair a, pair b, pair c, pair d, real t);
+triple bezierP(triple a, triple b, triple c, triple d, real t);
+pair bezierPP(pair a, pair b, pair c, pair d, real t);
+triple bezierPP(triple a, triple b, triple c, triple d, real t);
+real[] _projection();
+pair bezierPPP(pair a, pair b, pair c, pair d);
+triple bezierPPP(triple a, triple b, triple c, triple d);
+real Jn(int n, real x);
+void initXasyMode();
+int randMax;
+path nurb(pair z0, pair z1, pair z2, pair z3, real w0, real w1, real w2, real w3, int m);
+align NoAlign;
+bool EndBar(picture, path, pen, marginT(path, pen));
+bool EndBar(picture, path, pen, marginT(path, pen))(real size=<default>);
+Legend Legend(string label, pen plabel=<default>, pen p=<default>, frame mark=<default>, bool above=<default>);
+real Yn(int n, real x);
+int NOT(int a);
+pen[] monoPen;
+bool CW;
+bool all(bool[] a);
+real atanh(real x);
+real[] atanh(real[] a);
+frame UpsideDown(frame f);
+pair realmult(pair z, pair w);
+triple realmult(triple u, triple v);
+real acosh(real x);
+real[] acosh(real[] a);
+real realEpsilon;
+pair NW;
+real norm(real[] a);
+real norm(real[][] a);
+real norm(triple[][] a);
+int length(guide g);
+int length(string s);
+real length(pair z);
+real length(triple v);
+int length(path p);
+int length(path3 p);
+pair SW;
+void flush(file f);
+pen thin();
+pen palecyan;
+void warning(string s, string t, bool position=<default>);
+frame legend(picture pic=<default>, int perline=<default>, real xmargin=<default>, real ymargin=<default>, real linelength=<default>, real hskip=<default>, real vskip=<default>, real maxwidth=<default>, real maxheight=<default>, bool hstretch=<default>, bool vstretch=<default>, pen p=<default>);
+picture legend(Legend[] Legend, int perline=<default>, real linelength, real hskip, real vskip, real maxwidth=<default>, real maxheight=<default>, bool hstretch=<default>, bool vstretch=<default>);
+real Degrees(real radians);
+picture legenditem(Legend legenditem, real linelength);
+real legendhskip;
+real legendvskip;
+pen darkmagenta;
+real change2(triple[][] a);
+real legendmargin;
+bool None(picture, path, pen, marginT(path, pen));
+real dotfactor;
+real legendlinelength;
+bool diagnostics;
+string minipage(string s, real width=<default>);
+real legendmaxrelativewidth;
+triple cross(triple u, triple v);
+path cross(int n, bool round=<default>, real r=<default>);
+string operator +(string a, string b);
+int operator +(int a, int b);
+int[] operator +(int a, int[] b);
+int[] operator +(int[] a, int b);
+int[] operator +(int[] a, int[] b);
+int[][] operator +(int[][] a, int[][] b);
+int operator +(int a);
+int[] operator +(int[] a);
+real operator +(real a, real b);
+real[] operator +(real a, real[] b);
+real[] operator +(real[] a, real b);
+real[] operator +(real[] a, real[] b);
+real[][] operator +(real[][] a, real[][] b);
+real operator +(real a);
+real[] operator +(real[] a);
+pair operator +(pair a, pair b);
+pair[] operator +(pair a, pair[] b);
+pair[] operator +(pair[] a, pair b);
+pair[] operator +(pair[] a, pair[] b);
+pair[][] operator +(pair[][] a, pair[][] b);
+pair operator +(pair a);
+pair[] operator +(pair[] a);
+triple operator +(triple a, triple b);
+triple[] operator +(triple a, triple[] b);
+triple[] operator +(triple[] a, triple b);
+triple[] operator +(triple[] a, triple[] b);
+triple[][] operator +(triple[][] a, triple[][] b);
+triple operator +(triple a);
+triple[] operator +(triple[] a);
+pen operator +(pen a, pen b);
+transform operator +(transform a, transform b);
+pen operator +(pen p, real w);
+marginT operator +(path, pen)(marginT ma(path, pen), marginT mb(path, pen));
+pen[] operator +(pen a, pen[] b);
+pen operator +(real w, pen p);
+pen[] operator +(pen[] a, pen b);
+int operator -(int a, int b);
+int[] operator -(int a, int[] b);
+int[] operator -(int[] a, int b);
+int[] operator -(int[] a, int[] b);
+int[][] operator -(int[][] a, int[][] b);
+int operator -(int a);
+int[] operator -(int[] a);
+int[][] operator -(int[][] a);
+real operator -(real a, real b);
+real[] operator -(real a, real[] b);
+real[] operator -(real[] a, real b);
+real[] operator -(real[] a, real[] b);
+real[][] operator -(real[][] a, real[][] b);
+real operator -(real a);
+real[] operator -(real[] a);
+real[][] operator -(real[][] a);
+pair operator -(pair a, pair b);
+pair[] operator -(pair a, pair[] b);
+pair[] operator -(pair[] a, pair b);
+pair[] operator -(pair[] a, pair[] b);
+pair[][] operator -(pair[][] a, pair[][] b);
+pair operator -(pair a);
+pair[] operator -(pair[] a);
+pair[][] operator -(pair[][] a);
+triple operator -(triple a, triple b);
+triple[] operator -(triple a, triple[] b);
+triple[] operator -(triple[] a, triple b);
+triple[] operator -(triple[] a, triple[] b);
+triple[][] operator -(triple[][] a, triple[][] b);
+triple operator -(triple a);
+triple[] operator -(triple[] a);
+triple[][] operator -(triple[][] a);
+int operator *(int a, int b);
+int[] operator *(int a, int[] b);
+int[] operator *(int[] a, int b);
+int[] operator *(int[] a, int[] b);
+int[][] operator *(int a, int[][] b);
+int[][] operator *(int[][] a, int b);
+real operator *(real a, real b);
+real[] operator *(real a, real[] b);
+real[] operator *(real[] a, real b);
+real[] operator *(real[] a, real[] b);
+real[][] operator *(real a, real[][] b);
+real[][] operator *(real[][] a, real b);
+pair operator *(pair a, pair b);
+pair[] operator *(pair a, pair[] b);
+pair[] operator *(pair[] a, pair b);
+pair[] operator *(pair[] a, pair[] b);
+pair[][] operator *(pair a, pair[][] b);
+pair[][] operator *(pair[][] a, pair b);
+triple[] operator *(real a, triple[] b);
+triple[][] operator *(real a, triple[][] b);
+triple[] operator *(triple[] a, real b);
+triple[][] operator *(triple[][] a, real b);
+pen operator *(real a, pen b);
+pen operator *(pen a, real b);
+transform operator *(transform a, transform b);
+pair operator *(transform t, pair z);
+path operator *(transform t, path g);
+pen operator *(transform t, pen p);
+frame operator *(transform t, frame f);
+frame operator *(real[][] t, frame f);
+real[] operator *(real[][] a, real[] b);
+real[] operator *(real[] a, real[][] b);
+int[][] operator *(int[][] a, int[][] b);
+real[][] operator *(real[][] a, real[][] b);
+pair[][] operator *(pair[][] a, pair[][] b);
+triple operator *(real[][] t, triple v);
+triple operator *(real x, triple v);
+triple operator *(triple v, real x);
+path3 operator *(real[][] t, path3 g);
+object operator *(transform t, explicit object F);
+Label operator *(transform t, Label L);
+picture operator *(real[][] t, picture orig);
+path[] operator *(transform t, explicit path[] p);
+bounds operator *(transform t, bounds b);
+pair[] operator *(transform t, pair[] z);
+picture operator *(transform t, picture orig);
+side operator *(real x, side s);
+Label operator *(real[][] t, Label L);
+bool operator init();
+int operator init();
+real operator init();
+string operator init();
+pair operator init();
+triple operator init();
+transform operator init();
+guide operator init();
+path operator init();
+path3 operator init();
+pen operator init();
+frame operator init();
+file operator init();
+hsv operator init();
+projection operator init();
+picture operator init();
+marker operator init();
+marginT operator init();
+transformation operator init();
+pairOrTriple operator init();
+filltype operator init();
+coords2 operator init();
+Legend operator init();
+align operator init();
+framedTransformStack operator init();
+slice operator init();
+scaling operator init();
+ScaleT operator init();
+object operator init();
+coords2 operator init();
+coord operator init();
+autoscaleT operator init();
+Label operator init();
+scaling operator init();
+bounds operator init();
+scaleT operator init();
+position operator init();
+cputime operator init();
+coord operator init();
+coords3 operator init();
+side operator init();
+processtime operator init();
+bool3 operator init();
+light operator init();
+indexedTransform operator init();
+arrowhead operator init();
+real operator cast(int);
+pair operator cast(int);
+pair operator cast(real);
+path operator cast(pair);
+guide operator cast(pair);
+guide operator cast(path);
+path operator cast(guide);
+file operator cast(null);
+real[] operator cast(int[]);
+pair[] operator cast(int[]);
+pair[] operator cast(real[]);
+real[][] operator cast(int[][]);
+pair[][] operator cast(int[][]);
+pair[][] operator cast(real[][]);
+bool operator cast(file);
+bool[] operator cast(file);
+bool[][] operator cast(file);
+bool[][][] operator cast(file);
+int operator cast(file);
+int[] operator cast(file);
+int[][] operator cast(file);
+int[][][] operator cast(file);
+real operator cast(file);
+real[] operator cast(file);
+real[][] operator cast(file);
+real[][][] operator cast(file);
+pair operator cast(file);
+pair[] operator cast(file);
+pair[][] operator cast(file);
+pair[][][] operator cast(file);
+triple operator cast(file);
+triple[] operator cast(file);
+triple[][] operator cast(file);
+triple[][][] operator cast(file);
+string operator cast(file);
+string[] operator cast(file);
+string[][] operator cast(file);
+string[][][] operator cast(file);
+guide operator cast(cycleToken tok);
+guide operator cast(curlSpecifier spec);
+guide operator cast(tensionSpecifier t);
+object operator cast(Label L);
+Label operator cast(object F);
+guide[] operator cast(path[] g);
+position operator cast(pair x);
+align operator cast(side side);
+pair operator cast(position P);
+bool3[] operator cast(bool[] b);
+object operator cast(frame f);
+guide[] operator cast(pair[] z);
+path[] operator cast(guide[] g);
+bool operator cast(bool3 b);
+path[] operator cast(guide g);
+pen operator cast(hsv hsv);
+path[] operator cast(pair[] z);
+path[] operator cast(path p);
+pair operator cast(pairOrTriple a);
+triple operator cast(pairOrTriple a);
+bool[] operator cast(bool3[] b);
+position operator cast(int x);
+hsv operator cast(pen p);
+object operator cast(string s);
+align operator cast(pair dir);
+bool3 operator cast(bool b);
+position operator cast(real x);
+Label operator cast(string s);
+align operator cast(triple dir);
+frame operator cast(object F);
+pen deepred;
+bool error(file f);
+string operator ecast(int);
+string operator ecast(real);
+string operator ecast(pair);
+string operator ecast(triple);
+int operator ecast(string);
+real operator ecast(string);
+pair operator ecast(string);
+triple operator ecast(string);
+int operator ecast(real);
+int[] operator ecast(real[]);
+real[] operator ecast(string[] a);
+int[] operator ecast(string[] a);
+pair operator tuple(real x, real y);
+triple operator tuple(real x, real y, real z);
+transform operator tuple(real x, real y, real xx, real xy, real yx, real yy);
+real operator /(real a, real b);
+real[] operator /(real a, real[] b);
+real[] operator /(real[] a, real b);
+real[] operator /(real[] a, real[] b);
+real[][] operator /(real[][] a, real b);
+pair operator /(pair a, pair b);
+pair[] operator /(pair a, pair[] b);
+pair[] operator /(pair[] a, pair b);
+pair[] operator /(pair[] a, pair[] b);
+pair[][] operator /(pair[][] a, pair b);
+triple[] operator /(triple[] a, real b);
+real operator /(int a, int b);
+real[] operator /(int[] a, int b);
+real[] operator /(int a, int[] b);
+real[] operator /(int[] a, int[] b);
+triple operator /(triple v, real x);
+path[] texpath(Label L, bool tex=<default>, bool bbox=<default>);
+bool uptodate();
+int operator %(int a, int b);
+int[] operator %(int a, int[] b);
+int[] operator %(int[] a, int b);
+int[] operator %(int[] a, int[] b);
+real operator %(real a, real b);
+real[] operator %(real a, real[] b);
+real[] operator %(real[] a, real b);
+real[] operator %(real[] a, real[] b);
+bool operator ^(bool a, bool b);
+bool[] operator ^(bool a, bool[] b);
+bool[] operator ^(bool[] a, bool b);
+bool[] operator ^(bool[] a, bool[] b);
+int operator ^(int a, int b);
+int[] operator ^(int a, int[] b);
+int[] operator ^(int[] a, int b);
+int[] operator ^(int[] a, int[] b);
+real operator ^(real a, real b);
+real[] operator ^(real a, real[] b);
+real[] operator ^(real[] a, real b);
+real[] operator ^(real[] a, real[] b);
+pair operator ^(pair a, pair b);
+pair[] operator ^(pair a, pair[] b);
+pair[] operator ^(pair[] a, pair b);
+pair[] operator ^(pair[] a, pair[] b);
+transform operator ^(transform t, int n);
+real operator ^(real x, int y);
+pair operator ^(pair z, int y);
+bool operator ==(bool a, bool b);
+bool[] operator ==(bool a, bool[] b);
+bool[] operator ==(bool[] a, bool b);
+bool[] operator ==(bool[] a, bool[] b);
+bool operator ==(bool[][] a, bool[][] b);
+bool operator ==(int a, int b);
+bool[] operator ==(int a, int[] b);
+bool[] operator ==(int[] a, int b);
+bool[] operator ==(int[] a, int[] b);
+bool operator ==(int[][] a, int[][] b);
+bool operator ==(real a, real b);
+bool[] operator ==(real a, real[] b);
+bool[] operator ==(real[] a, real b);
+bool[] operator ==(real[] a, real[] b);
+bool operator ==(real[][] a, real[][] b);
+bool operator ==(pair a, pair b);
+bool[] operator ==(pair a, pair[] b);
+bool[] operator ==(pair[] a, pair b);
+bool[] operator ==(pair[] a, pair[] b);
+bool operator ==(pair[][] a, pair[][] b);
+bool operator ==(triple a, triple b);
+bool[] operator ==(triple a, triple[] b);
+bool[] operator ==(triple[] a, triple b);
+bool[] operator ==(triple[] a, triple[] b);
+bool operator ==(triple[][] a, triple[][] b);
+bool operator ==(string a, string b);
+bool[] operator ==(string a, string[] b);
+bool[] operator ==(string[] a, string b);
+bool[] operator ==(string[] a, string[] b);
+bool operator ==(string[][] a, string[][] b);
+bool[] operator ==(pen[] a, pen[] b);
+bool operator ==(pen a, pen b);
+bool operator ==(transform a, transform b);
+bool operator ==(file a, file b);
+bool operator ==(path a, path b);
+bool operator ==(path3 a, path3 b);
+bool operator ==(bool3 a, bool3 b);
+bool operator ==(light a, light b);
+bool operator ==(indexedTransform a, indexedTransform b);
+bool operator ==(arrowhead a, arrowhead b);
+bool operator ==(coords2 a, coords2 b);
+bool operator ==(coord a, coord b);
+bool operator ==(autoscaleT a, autoscaleT b);
+bool operator ==(Label a, Label b);
+bool operator ==(marginT a, marginT b);
+bool operator ==(freezableBounds a, freezableBounds b);
+bool operator ==(transformation a, transformation b);
+bool operator ==(pairOrTriple a, pairOrTriple b);
+bool operator ==(coord a, coord b);
+bool operator ==(coords3 a, coords3 b);
+bool operator ==(side a, side b);
+bool operator ==(processtime a, processtime b);
+bool operator ==(slice a, slice b);
+bool operator ==(scaling a, scaling b);
+bool operator ==(ScaleT a, ScaleT b);
+bool operator ==(object a, object b);
+bool operator ==(bool3 a, bool b);
+bool operator ==(hsv a, hsv b);
+bool operator ==(projection a, projection b);
+bool operator ==(picture a, picture b);
+bool operator ==(marker a, marker b);
+bool operator ==(scaling a, scaling b);
+bool operator ==(bounds a, bounds b);
+bool operator ==(scaleT a, scaleT b);
+bool operator ==(position a, position b);
+bool operator ==(cputime a, cputime b);
+bool operator ==(bool a, bool3 b);
+bool operator ==(filltype a, filltype b);
+bool operator ==(coords2 a, coords2 b);
+bool operator ==(Legend a, Legend b);
+bool operator ==(align a, align b);
+bool operator ==(framedTransformStack a, framedTransformStack b);
+bool operator !=(bool a, bool b);
+bool[] operator !=(bool a, bool[] b);
+bool[] operator !=(bool[] a, bool b);
+bool[] operator !=(bool[] a, bool[] b);
+bool operator !=(bool[][] a, bool[][] b);
+bool operator !=(int a, int b);
+bool[] operator !=(int a, int[] b);
+bool[] operator !=(int[] a, int b);
+bool[] operator !=(int[] a, int[] b);
+bool operator !=(int[][] a, int[][] b);
+bool operator !=(real a, real b);
+bool[] operator !=(real a, real[] b);
+bool[] operator !=(real[] a, real b);
+bool[] operator !=(real[] a, real[] b);
+bool operator !=(real[][] a, real[][] b);
+bool operator !=(pair a, pair b);
+bool[] operator !=(pair a, pair[] b);
+bool[] operator !=(pair[] a, pair b);
+bool[] operator !=(pair[] a, pair[] b);
+bool operator !=(pair[][] a, pair[][] b);
+bool operator !=(triple a, triple b);
+bool[] operator !=(triple a, triple[] b);
+bool[] operator !=(triple[] a, triple b);
+bool[] operator !=(triple[] a, triple[] b);
+bool operator !=(triple[][] a, triple[][] b);
+bool operator !=(string a, string b);
+bool[] operator !=(string a, string[] b);
+bool[] operator !=(string[] a, string b);
+bool[] operator !=(string[] a, string[] b);
+bool operator !=(string[][] a, string[][] b);
+bool[] operator !=(pen[] a, pen[] b);
+bool operator !=(pen a, pen b);
+bool operator !=(transform a, transform b);
+bool operator !=(file a, file b);
+bool operator !=(path a, path b);
+bool operator !=(path3 a, path3 b);
+bool operator !=(bool3 a, bool3 b);
+bool operator !=(light a, light b);
+bool operator !=(indexedTransform a, indexedTransform b);
+bool operator !=(arrowhead a, arrowhead b);
+bool operator !=(coords2 a, coords2 b);
+bool operator !=(coord a, coord b);
+bool operator !=(autoscaleT a, autoscaleT b);
+bool operator !=(Label a, Label b);
+bool operator !=(marginT a, marginT b);
+bool operator !=(freezableBounds a, freezableBounds b);
+bool operator !=(transformation a, transformation b);
+bool operator !=(pairOrTriple a, pairOrTriple b);
+bool operator !=(coord a, coord b);
+bool operator !=(coords3 a, coords3 b);
+bool operator !=(side a, side b);
+bool operator !=(processtime a, processtime b);
+bool operator !=(slice a, slice b);
+bool operator !=(scaling a, scaling b);
+bool operator !=(ScaleT a, ScaleT b);
+bool operator !=(object a, object b);
+bool operator !=(bool3 a, bool b);
+bool operator !=(hsv a, hsv b);
+bool operator !=(projection a, projection b);
+bool operator !=(picture a, picture b);
+bool operator !=(marker a, marker b);
+bool operator !=(scaling a, scaling b);
+bool operator !=(bounds a, bounds b);
+bool operator !=(scaleT a, scaleT b);
+bool operator !=(position a, position b);
+bool operator !=(cputime a, cputime b);
+bool operator !=(bool a, bool3 b);
+bool operator !=(filltype a, filltype b);
+bool operator !=(coords2 a, coords2 b);
+bool operator !=(Legend a, Legend b);
+bool operator !=(align a, align b);
+bool operator !=(framedTransformStack a, framedTransformStack b);
+bool operator <(int a, int b);
+bool[] operator <(int a, int[] b);
+bool[] operator <(int[] a, int b);
+bool[] operator <(int[] a, int[] b);
+bool operator <(real a, real b);
+bool[] operator <(real a, real[] b);
+bool[] operator <(real[] a, real b);
+bool[] operator <(real[] a, real[] b);
+bool operator <(string a, string b);
+bool[] operator <(string a, string[] b);
+bool[] operator <(string[] a, string b);
+bool[] operator <(string[] a, string[] b);
+bool operator <=(int a, int b);
+bool[] operator <=(int a, int[] b);
+bool[] operator <=(int[] a, int b);
+bool[] operator <=(int[] a, int[] b);
+bool operator <=(real a, real b);
+bool[] operator <=(real a, real[] b);
+bool[] operator <=(real[] a, real b);
+bool[] operator <=(real[] a, real[] b);
+bool operator <=(string a, string b);
+bool[] operator <=(string a, string[] b);
+bool[] operator <=(string[] a, string b);
+bool[] operator <=(string[] a, string[] b);
+bool operator <=(coord a, coord b);
+bool operator <=(coord a, coord b);
+bool operator >(int a, int b);
+bool[] operator >(int a, int[] b);
+bool[] operator >(int[] a, int b);
+bool[] operator >(int[] a, int[] b);
+bool operator >(real a, real b);
+bool[] operator >(real a, real[] b);
+bool[] operator >(real[] a, real b);
+bool[] operator >(real[] a, real[] b);
+bool operator >(string a, string b);
+bool[] operator >(string a, string[] b);
+bool[] operator >(string[] a, string b);
+bool[] operator >(string[] a, string[] b);
+void srand(int seed);
+bool operator >=(int a, int b);
+bool[] operator >=(int a, int[] b);
+bool[] operator >=(int[] a, int b);
+bool[] operator >=(int[] a, int[] b);
+bool operator >=(real a, real b);
+bool[] operator >=(real a, real[] b);
+bool[] operator >=(real[] a, real b);
+bool[] operator >=(real[] a, real[] b);
+bool operator >=(string a, string b);
+bool[] operator >=(string a, string[] b);
+bool[] operator >=(string[] a, string b);
+bool[] operator >=(string[] a, string[] b);
+bool operator >=(coord a, coord b);
+bool operator >=(coord a, coord b);
+filltype UnFill(real xmargin=<default>, real ymargin=<default>);
+filltype UnFill;
+bool[] operator !(bool[] a);
+bool operator !(bool b);
+path[] operator ^^(path p, path q);
+path[] operator ^^(explicit path[] p, path q);
+path[] operator ^^(path p, explicit path[] q);
+path[] operator ^^(explicit path[] p, explicit path[] q);
+real degrees(pair z, bool warn=<default>);
+real degrees(real radians);
+guide operator ::(... guide[]);
+pen Helvetica(string series=<default>, string shape=<default>);
+transform reflect(pair a, pair b);
+bool Bars(picture, path, pen, marginT(path, pen));
+bool Bars(picture, path, pen, marginT(path, pen))(real size=<default>);
+guide operator ..(... guide[]);
+guide operator ..(... guide[])(tensionSpecifier t);
+void none(file file);
+int factorial(int n);
+real log(real x);
+real[] log(real[] a);
+pair log(explicit pair z);
+guide operator --(... guide[]);
+path polygon(int n);
+guide operator ---(... guide[]);
+bool operator &(bool a, bool b);
+bool[] operator &(bool a, bool[] b);
+bool[] operator &(bool[] a, bool b);
+bool[] operator &(bool[] a, bool[] b);
+path operator &(path p, path q);
+path3 operator &(path3 p, path3 q);
+path operator &(path p, cycleToken tok);
+pen NewCenturySchoolBook(string series=<default>, string shape=<default>);
+void()()[] saveFunctions;
+bool operator |(bool a, bool b);
+bool[] operator |(bool a, bool[] b);
+bool[] operator |(bool[] a, bool b);
+bool[] operator |(bool[] a, bool[] b);
+guide operator controls(pair zout, pair zin);
+guide operator controls(pair z);
+string texify(string s);
+tensionSpecifier operator tension(real tout, real tin, bool atleast);
+tensionSpecifier operator tension(real t, bool atLeast);
+bool empty(frame f);
+curlSpecifier operator curl(real gamma, int p);
+void end(picture pic=<default>);
+guide operator spec(pair z, int p);
+string substr(string s, int pos, int n=<default>);
+pen paleyellow;
+file output(string name=<default>, bool update=<default>, string comment=<default>, string mode=<default>);
+pen ZapfDingbats(string series=<default>, string shape=<default>);
+real tanh(real x);
+real[] tanh(real[] a);
+real interp(real a, real b, real t);
+pair interp(explicit pair a, explicit pair b, real t);
+triple interp(triple a, triple b, real t);
+pen interp(pen a, pen b, real t);
+frame Seascape(frame f);
+bool interior(int windingnumber, pen fillrule);
+real[] intersect(path p, path q, real fuzz=<default>);
+real[] intersect(path3 p, path3 q, real fuzz=<default>);
+bool interactive();
+real[][] intersections(path p, path q, real fuzz=<default>);
+real[] intersections(path p, explicit pair a, explicit pair b, real fuzz=<default>);
+real[][] intersections(path3 p, path3 q, real fuzz=<default>);
+real[][] intersections(path3 p, triple[][] p, real fuzz=<default>);
+int animate(string args=<default>, string file=<default>, string format=<default>);
+void generate_random_backtrace();
+pair intersectionpoint(path p, path q, real fuzz=<default>);
+pair[] intersectionpoints(path p, path q, real fuzz=<default>);
+pair[] intersectionpoints(explicit path[] p, explicit path[] q, real fuzz=<default>);
+void asy(string format, bool overwrite=<default> ... string[] s);
+bool latex();
+void startScript();
+bool adjust(pen p);
+pen adjust(pen p, real arclength, bool cyclic);
+pair Align;
+void exit();
+real[] uniform(real a, real b, int n);
+pair viewportsize;
+pair viewportmargin;
+string VERSION;
+void filldraw(picture pic=<default>, path[] g, pen fillpen=<default>, pen drawpen=<default>);
+void filldraw(frame f, path[] g, pen fillpen=<default>, pen drawpen=<default>);
+real dot(real[] a, real[] b);
+pair dot(pair[] a, pair[] b);
+real dot(explicit pair z, explicit pair w);
+real dot(triple u, triple v);
+void dot(picture pic=<default>, Label[] L=<default>, explicit path g, align align=<default>, string format=<default>, pen p=<default>, filltype filltype=<default>);
+marker dot(pen p=<default>, filltype filltype=<default>);
+void dot(picture pic=<default>, pair z, pen p=<default>, filltype filltype=<default>);
+void dot(frame f, pair z, pen p=<default>, filltype filltype=<default>);
+void dot(picture pic=<default>, Label L, pen p=<default>, filltype filltype=<default>);
+marker dot;
+void dot(picture pic=<default>, Label[] L=<default>, pair[] z, align align=<default>, string format=<default>, pen p=<default>, filltype filltype=<default>);
+void dot(picture pic=<default>, path[] g, pen p=<default>, filltype filltype=<default>);
+void dot(picture pic=<default>, Label L, pair z, align align=<default>, string format=<default>, pen p=<default>, filltype filltype=<default>);
+void list(string s, bool imports=<default>);
+pair NNW;
+string phantom(string s);
+void atexit(void f());
+void atexit()();
+real getreal(string name=<default>, real default=<default>, string prompt=<default>, bool store=<default>);
+int convert(string args=<default>, string file=<default>, string format=<default>);
+pair WNW;
+pen palegray;
+pen palegreen;
+pen palegrey;
+void clip(frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, bool copy=<default>);
+void clip(picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, bool copy=<default>);
+marginT Margin(path, pen)(real begin, real end);
+marginT Margin(path, pen);
+position Relative(real position);
+side Relative(explicit pair align);
+marginT Margins(path, pen);
+pair truepoint(picture pic=<default>, pair dir, bool user=<default>);
+real arclength(path p);
+real arclength(path3 p);
+indexedTransform indexedTransform(int index, transform t, bool active=<default>);
+bool finite(real x);
+bool finite(pair z);
+bool finite(triple v);
+void updatefunction();
+void _draw(frame f, path g, pen p);
+void _draw(frame f, path3 g, triple center=<default>, pen p, int interaction=<default>);
+void _draw(picture pic, path g, pen p, marginT margin(path, pen));
+frame align(frame f, pair align);
+path[] align(path[] g, transform t=<default>, pair position, pair align, pen p=<default>);
+object align(object F, pair align);
+real unitrand();
+string[] history(string name, int n=<default>);
+string[] history(int n=<default>);
+coord[] maxcoords(coord[] in, bool operator <=(coord, coord));
+coord[] maxcoords(coord[] in, bool operator <=(coord, coord));
+pen AvantGarde(string series=<default>, string shape=<default>);
+frame enclose(string prefix=<default>, object F, string format=<default>);
+int count;
+real atan2(real y, real x);
+bool inside(explicit path[] g, pair z, pen fillrule=<default>);
+bool inside(path g, pair z, pen fillrule=<default>);
+int inside(path p, path q, pen fillrule=<default>);
+pair inside(path p, pen fillrule=<default>);
+pair rectify(pair dir);
+arrowhead TeXHead;
+path[] margin(path[] g, real xmargin, real ymargin);
+pair relative(picture pic=<default>, pair z);
+real expansionfactor;
+real erfc(real x);
+int windingnumber(path[] p, pair z);
+void addArrow(picture pic, arrowhead arrowhead, path g, pen p, real size, real angle, filltype filltype, real position);
+void exitfunction();
+pen gray(pen p);
+pen gray(real gray);
+pen gray;
+real relativedistance(real theta, real phi, real t, bool atleast);
+path circle(pair c, real r);
+void overloadedMessage(file file);
+pen deepmagenta;
+real circlescale;
+string math(real x);
+string math(string s);
+real circleprecision;
+int Allow;
+real determinant(real[][] a);
+void functionshade(frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, string shader=<default>, bool copy=<default>);
+void functionshade(picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, string shader, bool copy=<default>);
+pen red;
+pair[] dirSpecifier(guide g, int t);
+void abort(string s=<default>);
+bool Aspect;
+string hex(pen p);
+int hex(string s);
+void deactivatequote(picture pic=<default>);
+string format(string format, int x, string locale=<default>);
+string format(string format, string separator, real x, string locale=<default>);
+string format(string format, real x, string locale=<default>);
+string format(real x, string locale=<default>);
+real expm1(real x);
+real[] expm1(real[] a);
+void activatequote(picture pic=<default>);
+int undefined;
+frame[] fit2(picture[] pictures, picture all);
+string ask(string prompt);
+pen linecap(int n);
+int linecap(pen p=<default>);
+string outname();
+void newpage(frame f);
+void newpage(picture pic=<default>);
+pen fontcommand(string s);
+pair accel(path p, int t, int sign=<default>);
+pair accel(path p, real t);
+triple accel(path3 p, int t, int sign=<default>);
+triple accel(path3 p, real t);
+frame Portrait(frame f);
+void tex(frame f, string s);
+void tex(frame f, string s, pair min, pair max);
+void tex(picture pic=<default>, string s, pair min, pair max);
+void tex(picture pic=<default>, string s);
+pen Black;
+triple size3(frame f);
+void size3(picture pic=<default>, real x, real y=<default>, real z=<default>, bool keepAspect=<default>);
+bool eof(file f);
+frame dotframe(pen p=<default>, filltype filltype=<default>);
+frame dotframe;
+real realMax;
+pair NE;
+real realMin;
+path nib(pen p);
+void gouraudshade(frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, pair[] z, int[] edges, bool copy=<default>);
+void gouraudshade(frame f, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, int[] edges, bool copy=<default>);
+void gouraudshade(picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, pair[] z, int[] edges, bool copy=<default>);
+void gouraudshade(picture pic=<default>, path[] g, bool stroke=<default>, pen fillrule=<default>, pen[] p, int[] edges, bool copy=<default>);
+bool shipped;
+pair[] fft(pair[] a, int sign=<default>);
+pair SE;
+pen nobasealign;
+sCAD operator init();
+real animationdelay;
+animation operator init();
+frame NoBox(frame f);
+frame BBox(frame)(real xmargin=<default>, real ymargin=<default>, pen p=<default>, filltype filltype=<default>);
+void annotate(picture pic=<default>, string title, string text, pair position);
+void babel(string s);
+path removeDuplicates(path p);
+path uncycle(path p, real t);
+path[] bezulate(path[] p);
+real[][] intersections(pair a, pair b, path p);
+void connect(path[] paths, path[] result, path[] patch);
+int countIntersections(path[] p, pair start, pair end);
+real duplicateFuzz;
+path subdivide(path p);
+bool isDuplicate(pair a, pair b, real relSize);
+bool checkSegment(path g, pair p, pair q);
+path section(path p, real t1, real t2, bool loop=<default>);
+real fuzz;
+path[][] containmentTree(path[] paths);
+binarytree searchtree(... int[] keys);
+object draw(picture pic=<default>, binarytreeNode node, pair pos, int height, real minDist, real levelDist, real nodeDiameter, pen p=<default>);
+void draw(picture pic=<default>, binarytree tree, real minDist=<default>, real nodeMargin=<default>, pen p=<default>);
+real nodeMarginDefault;
+key key(int n, bool active=<default>);
+binarytree binarytree(... key[] keys);
+binarytreeNode binarytreeNode(int key);
+key nil;
+real minDistDefault;
+binarytreeNode operator init();
+key operator init();
+binarytree operator init();
+key operator cast(int n);
+int operator cast(key k);
+int[] operator cast(key[] k);
+line intersection(face a, face b);
+real epsilon;
+splitface split(face a, face cut, projection P);
+face operator init();
+line operator init();
+half operator init();
+splitface operator init();
+bsp operator init();
+picture operator cast(face f);
+face operator cast(path3 p);
+void add(picture pic=<default>, face[] faces, projection P=<default>);
+void searchindex(boxcontour bc, bool forward, void f(int i, int j));
+segment case1(pair p0, pair p1, pair p2, real v0, real v1, real v2);
+void draw(picture pic=<default>, Label[] L=<default>, guide[][] g, pen[] p);
+void draw(picture pic=<default>, Label[] L=<default>, guide[][] g, pen p=<default>);
+void draw(picture pic=<default>, Label L, guide[] g, pen p=<default>);
+int interior;
+pen[][] interior(picture pic=<default>, guide[][] g, pen[] palette);
+pen[] extend(pen[] palette, pen below, pen above);
+bool same(gridpoint gp1, gridpoint gp2);
+guide connect(Segment S, pair[][] z, guide join(... guide[]));
+guide[] connect(Segment[] S, pair[][] z, guide join(... guide[]));
+guide[][] connect(Segment[][] S, pair[][] z, guide join(... guide[]));
+guide[][] connect(pair[][][] points, real[] c, guide join(... guide[]));
+bool connected(boxcontour bc1, boxcontour bc2);
+int exterior;
+int connectedindex(boxcontour bc, boxcontour[] bca, bool activeonly=<default>);
+int connectedindex(boxcontour[] bca, boxcontour bc, bool activeonly=<default>);
+segment case2(pair p0, pair p1, pair p2, real v0, real v1, real v2);
+void collect(pair[][][] points, real[] c);
+int hyperbola;
+int edge;
+int line;
+segment case3(pair p0, pair p1, pair p2, real v0, real v1, real v2);
+segment checktriangle(pair p0, pair p1, pair p2, real v0, real v1, real v2);
+gridpoint operator init();
+boxcontour operator init();
+boxdata operator init();
+segment operator init();
+Segment operator init();
+segment operator init();
+void fill(picture pic=<default>, guide[][] g, pen[][] palette);
+guide[][] contour(pair[][] z, real[][] f, real[] c, guide join(... guide[])=<default>, int subsample=<default>);
+guide[][] contour(real[][] f, pair a, pair b, real[] c, guide join(... guide[])=<default>, int subsample=<default>);
+guide[][] contour(real f(real, real), pair a, pair b, real[] c, int nx=<default>, int ny=<default>, guide join(... guide[])=<default>, int subsample=<default>);
+guide[][] contour(real f(pair), pair a, pair b, real[] c, int nx=<default>, int ny=<default>, guide join(... guide[])=<default>, int subsample=<default>);
+guide[][] contour(pair[] z, real[] f, real[] c, guide join(... guide[])=<default>);
+segment[][] contouredges(real[][] f, real[] c, int subsample=<default>);
+void setcontour(real f00, real f10, real f01, real f11, real epsf, boxdata bd, int i, int j, int index);
+Segment[] Segment(segment[] s);
+Segment[][] Segment(segment[][] s);
+real eps;
+segment case4(pair p0, pair p1, pair p2, real v0, real v1, real v2);
+bool isCCW(pair p0, pair p1, pair p2);
+surface surface(vertex[][] g);
+weighted operator init();
+bucket operator init();
+vertex operator init();
+object operator init();
+vertex[][] contour3(triple[][][] v, real[][][] f, real[][][] midpoint=<default>, projection P=<default>);
+vertex[][] contour3(real[][][] f, real[][][] midpoint=<default>, triple a, triple b, projection P=<default>);
+vertex[][] contour3(real f(real, real, real), triple a, triple b, int nx=<default>, int ny=<default>, int nz=<default>, projection P=<default>);
+real eps;
+void draw(TreeNode root, pair pos);
+real treeNodeStep;
+void drawAll(TreeNode node, frame f);
+real layout(int level, TreeNode node);
+TreeNode operator init();
+void add(TreeNode child, TreeNode parent);
+real treeLevelStep;
+real treeMinNodeWidth;
+TreeNode makeNode(TreeNode parent=<default>, frame f);
+TreeNode makeNode(TreeNode parent=<default>, Label label);
+string link(string label, string text, string options=<default>);
+string embed(string name, string options=<default>, real width=<default>, real height=<default>);
+string hyperlink(string url, string text);
+string link(string url, string text, string options=<default>);
+string embed(string name, string options=<default>, real width=<default>, real height=<default>, string image=<default>);
+string hyperlink(string url, string text);
+real gluonratio;
+real gluonamplitude;
+void drawGluon(picture pic=<default>, path p, real amp=<default>, real width=<default>, pen fgpen=<default>, bool erasebg=<default>, pen bgpen=<default>, real vertexangle=<default>, real margin=<default>);
+void drawGhost(picture pic=<default>, path p, pen fgpen=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool erasebg=<default>, pen bgpen=<default>, real vertexangle=<default>, real margin=<default>);
+void drawVertex(picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>);
+void drawVertexO(picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>, bool erasebg=<default>, pen bgpen=<default>);
+void drawVertexX(picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>);
+void drawVertexBox(picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>);
+void drawVertexBoxO(picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>, bool erasebg=<default>, pen bgpen=<default>);
+void drawVertexOX(picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>, bool erasebg=<default>, pen bgpen=<default>);
+void drawVertexTriangle(picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>);
+void drawVertexTriangleO(picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>, bool erasebg=<default>, pen bgpen=<default>);
+void drawVertexBoxX(picture pic=<default>, pair xy, real r=<default>, pen fgpen=<default>, bool erasebg=<default>, pen bgpen=<default>);
+bool XYAlign;
+void do_overpaint(picture pic, path p, pen bgpen, real halfwidth, real vertexangle);
+void texshipout(string stem, picture pic=<default>, bool xalign=<default>);
+void drawDoubleLine(picture pic=<default>, path p, pen fgpen=<default>, real dlspacing=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool erasebg=<default>, pen bgpen=<default>, real vertexangle=<default>, real margin=<default>);
+void drawScalar(picture pic=<default>, path p, pen fgpen=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool erasebg=<default>, pen bgpen=<default>, real vertexangle=<default>, real margin=<default>);
+bool overpaint;
+path photon(path p, real amp=<default>, real width=<default>);
+pen photonpen;
+real photonratio;
+real photonamplitude;
+string includegraphicscommand;
+pen momarrowpen;
+real momarrowsize(pen p=<default>);
+real momarrowlength;
+real momarrowoffset;
+real momarrowmargin;
+real momarrowfactor;
+pen vertexpen;
+real vertexsize;
+path momArrowPath(path p, align align, position pos, real offset=<default>, real length=<default>);
+void drawPhoton(picture pic=<default>, path p, real amp=<default>, real width=<default>, pen fgpen=<default>, bool erasebg=<default>, pen bgpen=<default>, real vertexangle=<default>, real margin=<default>);
+bool YAlign;
+pen backgroundpen;
+pen ghostpen;
+pen scalarpen;
+pen fermionpen;
+pen bigvertexpen;
+real bigvertexsize;
+real minvertexangle;
+void drawMomArrow(picture pic=<default>, path p, align align, position pos=<default>, real offset=<default>, real length=<default>, pen fgpen=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool erasebg=<default>, pen bgpen=<default>, real margin=<default>);
+void fmdefaults();
+real linemargin;
+void drawFermion(picture pic=<default>, path p, pen fgpen=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool erasebg=<default>, pen bgpen=<default>, real vertexangle=<default>, real margin=<default>);
+bool currentarrow(picture, path, pen, marginT(path, pen));
+bool currentmomarrow(picture, path, pen, marginT(path, pen));
+bool appendsuffix;
+pen doublelinepen;
+real doublelinespacing;
+path gluon(path p, real amp=<default>, real width=<default>);
+pen gluonpen;
+Dir Left;
+block roundrectangle(object body, pair center=<default>, pen fillpen=<default>, pen drawpen=<default>, real ds=<default>, real dw=<default>, real minwidth=<default>, real minheight=<default>);
+block diamond(object body, pair center=<default>, pen fillpen=<default>, pen drawpen=<default>, real ds=<default>, real dw=<default>, real height=<default>, real minwidth=<default>, real minheight=<default>);
+void draw(picture pic=<default>, block block, pen p=<default>);
+real minblockwidth;
+real defaultexcursion;
+real minblockheight;
+path path(pair[] point ... flowdir[] dir);
+Dir Up;
+real mincirclediameter;
+flowdir Vertical;
+block rectangle(object header, object body, pair center=<default>, pen headerpen=<default>, pen bodypen=<default>, pen drawpen=<default>, real dx=<default>, real minheaderwidth=<default>, real minheaderheight=<default>, real minbodywidth=<default>, real minbodyheight=<default>);
+block rectangle(object body, pair center=<default>, pen fillpen=<default>, pen drawpen=<default>, real dx=<default>, real minwidth=<default>, real minheight=<default>);
+block parallelogram(object body, pair center=<default>, pen fillpen=<default>, pen drawpen=<default>, real dx=<default>, real slope=<default>, real minwidth=<default>, real minheight=<default>);
+block blockconnector(block, block)(picture pic, transform t, pen p=<default>, marginT margin(path, pen)=<default>);
+block circle(object body, pair center=<default>, pen fillpen=<default>, pen drawpen=<default>, real dr=<default>, real mindiameter=<default>);
+flowdir operator init();
+block operator init();
+Dir operator init();
+block operator --(block b1, Label label);
+block operator --(block b1, Dir dir);
+block operator --(block b, bool arrowbar(picture, path, pen, marginT(path, pen)));
+flowdir Horizontal;
+block bevel(object body, pair center=<default>, pen fillpen=<default>, pen drawpen=<default>, real dh=<default>, real dw=<default>, real minwidth=<default>, real minheight=<default>);
+Dir Right;
+Dir Down;
+int[] numarray;
+point midpoint(segment s);
+point midpoint(side side);
+point isotomicconjugate(triangle t, point M);
+line altitude(vertex V);
+line altitude(side side);
+real rd(real x, real y, real z);
+point circumcenter(point A, point B, point C);
+point circumcenter(triangle t);
+circle circumcircle(point A, point B, point C);
+circle circumcircle(triangle t);
+point point(coordsys R, pair p, real m=<default>);
+point point(explicit pair p, real m);
+point point(coordsys R, explicit point M, real m=<default>);
+point point(explicit vector u);
+point point(circle c, abscissa l);
+point point(ellipse el, abscissa l);
+point point(parabola p, abscissa l);
+point point(hyperbola h, abscissa l);
+point point(explicit conic co, abscissa l);
+point point(line l, abscissa x);
+point point(line l, explicit real x);
+point point(line l, explicit int x);
+point point(explicit circle c, explicit real x);
+point point(explicit circle c, explicit int x);
+point point(explicit ellipse el, explicit real x);
+point point(explicit ellipse el, explicit int x);
+point point(explicit parabola p, explicit real x);
+point point(explicit parabola p, explicit int x);
+point point(explicit hyperbola h, explicit real x);
+point point(explicit hyperbola h, explicit int x);
+point point(explicit conic co, explicit real x);
+point point(explicit conic co, explicit int x);
+point point(arc a, abscissa l);
+point point(arc a, real x);
+pair point(explicit arc a, int x);
+point point(explicit mass m);
+point point(explicit vertex V);
+point point(trilinear tri);
+point point(circle c, point M);
+point point(circle c, explicit vector v);
+bool finite(explicit point p);
+void dot(picture pic=<default>, Label L, explicit point Z, align align=<default>, string format=<default>, pen p=<default>);
+real dot(point A, point B);
+real dot(point A, explicit pair B);
+real dot(explicit pair A, point B);
+void dot(picture pic=<default>, Label L, explicit mass M, align align=<default>, string format=<default>, pen p=<default>);
+void dot(picture pic=<default>, triangle t, pen p=<default>);
+real[] realquarticroots(real a, real b, real c, real d, real e);
+point origin;
+point origin(coordsys R=<default>);
+void draw(picture pic=<default>, Label L=<default>, line l, bool dirA=<default>, bool dirB=<default>, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, Label legend=<default>, marker marker=<default>, path pathModifier(path)=<default>);
+void draw(picture pic=<default>, Label[] L=<default>, line[] l, align align=<default>, pen[] p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, Label[] legend=<default>, marker marker=<default>, path pathModifier(path)=<default>);
+void draw(picture pic=<default>, Label[] L=<default>, line[] l, align align=<default>, pen p, bool arrow(picture, path, pen, marginT(path, pen))=<default>, Label[] legend=<default>, marker marker=<default>, path pathModifier(path)=<default>);
+void draw(picture pic=<default>, Label L=<default>, circle c, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
+void draw(picture pic=<default>, Label L=<default>, ellipse el, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
+void draw(picture pic=<default>, Label L=<default>, parabola parabola, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
+void draw(picture pic=<default>, Label L=<default>, hyperbola h, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
+void draw(picture pic=<default>, Label L=<default>, explicit conic co, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
+void draw(picture pic=<default>, Label L=<default>, arc a, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, Label legend=<default>, marker marker=<default>);
+void draw(picture pic=<default>, triangle t, pen p=<default>, marker marker=<default>);
+void draw(picture pic=<default>, triangle[] t, pen p=<default>, marker marker=<default>);
+coordsys defaultcoordsys;
+string defaultmassformat;
+line radicalline(circle c1, circle c2);
+point radicalcenter(circle c1, circle c2);
+point radicalcenter(circle c1, circle c2, circle c3);
+ellipse ellipse(point F1, point F2, real a);
+ellipse ellipse(point F1, point F2, point M);
+ellipse ellipse(point C, real a, real b, real angle=<default>);
+ellipse ellipse(bqe bqe);
+ellipse ellipse(point M1, point M2, point M3, point M4, point M5);
+path arctopath(arc a, int n);
+bool inside(ellipse el, point M);
+bool inside(parabola p, point M);
+int ellipsenodesnumber(real a, real b);
+int ellipsenodesnumber(real a, real b, real angle1, real angle2, bool dir);
+int ellipsenodesnumberfactor;
+bool byfoci;
+point[] standardizecoordsys(coordsys R=<default>, bool warn=<default> ... point[] M);
+transform reflect(line l);
+transform reflect(line l1, line l2, bool safe=<default>);
+abscissa relabscissa(real x);
+abscissa relabscissa(int x);
+abscissa relabscissa(line l, point M);
+abscissa relabscissa(circle c, point M);
+abscissa relabscissa(ellipse el, point M);
+abscissa relabscissa(conic co, point M);
+abscissa relabscissa(arc a, point M);
+circle incircle(point A, point B, point C);
+circle incircle(triangle t);
+mass masscenter(... mass[] M);
+vector unit(point M);
+vector unit(vector u);
+line Ox(coordsys R=<default>);
+line Ox;
+conic conic(point F, line l, real e);
+conic conic(point M1, point M2, point M3, point M4, point M5);
+conic conic(bqe bqe);
+bool defined(point P);
+string conictype(bqe bqe);
+triangle antipedal(triangle t, point M);
+void clipdraw(picture pic=<default>, Label L=<default>, path g, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, bool bar(picture, path, pen, marginT(path, pen))=<default>, real xmargin=<default>, real ymargin=<default>, Label legend=<default>, marker marker=<default>);
+real perpfactor;
+int conicnodesfactor;
+int conicnodesnumber(conic co, real angle1, real angle2, bool dir=<default>);
+line hline(coordsys R=<default>);
+line hline;
+int[] tricoef(side side);
+path arcfromfocus(conic co, real angle1, real angle2, int n=<default>, bool direction=<default>);
+line sector(int n=<default>, int p=<default>, line l1, line l2, real angle=<default>, bool sharp=<default>);
+path arcfromcenter(ellipse el, real angle1, real angle2, bool direction=<default>, int n=<default>);
+path arcfromcenter(hyperbola h, real angle1, real angle2, int n=<default>, bool direction=<default>);
+path arcfromcenter(explicit conic co, real angle1, real angle2, int n, bool direction=<default>);
+line vline(coordsys R=<default>);
+line vline;
+vector vector(coordsys R=<default>, pair v);
+vector vector(point M);
+real[] intersect(path g, explicit pair p, real fuzz=<default>);
+real[] intersect(path g, explicit point P, real fuzz=<default>);
+int sgnd(real x);
+int sgnd(int x);
+circle excircle(point A, point B, point C);
+circle excircle(side side);
+line extend(line l);
+point intersectionpoint(line l1, line l2);
+pair[] intersectionpoints(pair A, pair B, real a, real b, real c, real d, real f, real g);
+pair[] intersectionpoints(pair A, pair B, real[] equation);
+point[] intersectionpoints(line l, path g);
+point[] intersectionpoints(bqe bqe1, bqe bqe2);
+point[] intersectionpoints(triangle t, line l, bool extended=<default>);
+point[] intersectionpoints(line l, triangle t, bool extended=<default>);
+point[] intersectionpoints(line l, circle c);
+point[] intersectionpoints(circle c, line l);
+point[] intersectionpoints(line l, ellipse el);
+point[] intersectionpoints(ellipse el, line l);
+point[] intersectionpoints(line l, parabola p);
+point[] intersectionpoints(parabola p, line l);
+point[] intersectionpoints(line l, hyperbola h);
+point[] intersectionpoints(hyperbola h, line l);
+point[] intersectionpoints(line l, conic co);
+point[] intersectionpoints(conic co, line l);
+point[] intersectionpoints(conic co1, conic co2);
+point[] intersectionpoints(triangle t, conic co, bool extended=<default>);
+point[] intersectionpoints(conic co, triangle t, bool extended=<default>);
+point[] intersectionpoints(ellipse a, ellipse b);
+point[] intersectionpoints(ellipse a, circle b);
+point[] intersectionpoints(circle a, ellipse b);
+point[] intersectionpoints(ellipse a, parabola b);
+point[] intersectionpoints(parabola a, ellipse b);
+point[] intersectionpoints(ellipse a, hyperbola b);
+point[] intersectionpoints(hyperbola a, ellipse b);
+point[] intersectionpoints(circle a, parabola b);
+point[] intersectionpoints(parabola a, circle b);
+point[] intersectionpoints(circle a, hyperbola b);
+point[] intersectionpoints(hyperbola a, circle b);
+point[] intersectionpoints(parabola a, parabola b);
+point[] intersectionpoints(parabola a, hyperbola b);
+point[] intersectionpoints(hyperbola a, parabola b);
+point[] intersectionpoints(hyperbola a, hyperbola b);
+point[] intersectionpoints(circle c1, circle c2);
+point[] intersectionpoints(conic co, arc a);
+point[] intersectionpoints(arc a, conic co);
+point[] intersectionpoints(arc a1, arc a2);
+point[] intersectionpoints(line l, arc a);
+point[] intersectionpoints(arc a, line l);
+point intouch(side side);
+triangle intouch(triangle t);
+point orthocentercenter(point A, point B, point C);
+point orthocentercenter(triangle t);
+real rf(real x, real y, real z);
+bool concurrent(... line[] l);
+real inradius(point A, point B, point C);
+real inradius(triangle t);
+pen addpenline;
+pen addpenline(pen p);
+pen addpenarc;
+pen addpenarc(pen p);
+void label(picture pic=<default>, Label L, explicit mass M, align align=<default>, string format=<default>, pen p=<default>, filltype filltype=<default>);
+void label(picture pic=<default>, Label L, vertex V, pair align=<default>, real alignFactor=<default>, pen p=<default>, filltype filltype=<default>);
+void label(picture pic=<default>, Label LA=<default>, Label LB=<default>, Label LC=<default>, triangle t, real alignAngle=<default>, real alignFactor=<default>, pen p=<default>, filltype filltype=<default>);
+real abs(coordsys R, pair m);
+real abs(explicit point M);
+point curpoint(line l, real x);
+point curpoint(explicit circle c, real x);
+point curpoint(explicit ellipse el, real x);
+point curpoint(explicit parabola p, real x);
+point curpoint(conic co, real x);
+point curpoint(arc a, real x);
+line bisector(line l1, line l2, real angle=<default>, bool sharp=<default>);
+line bisector(point A, point B, point C, point D, real angle=<default>, bool sharp=<default>);
+line bisector(segment s, real angle=<default>);
+line bisector(point A, point B, real angle=<default>);
+line bisector(vertex V, real angle=<default>);
+line bisector(side side);
+bqe canonical(bqe bqe);
+bool between(point M, point O, point N);
+point bisectorpoint(side side);
+abscissa angabscissa(real x, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>);
+abscissa angabscissa(int x, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>);
+abscissa angabscissa(circle c, point M);
+abscissa angabscissa(ellipse el, point M, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>);
+abscissa angabscissa(hyperbola h, point M, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>);
+abscissa angabscissa(parabola p, point M);
+abscissa angabscissa(explicit conic co, point M);
+abscissa angabscissa(arc a, point M);
+pair locate(point P);
+point locate(pair p);
+pair locate(explicit vector v);
+bool samecoordsys(bool warn=<default> ... point[] M);
+bool samecoordsys(bool warn=<default> ... bqe[] bqes);
+triangle extouch(triangle t);
+triangle extouch(side side);
+coordsys canonicalcartesiansystem(ellipse el);
+coordsys canonicalcartesiansystem(parabola p);
+coordsys canonicalcartesiansystem(hyperbola h);
+coordsys canonicalcartesiansystem(explicit conic co);
+arc arc(ellipse el, real angle1, real angle2, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>, bool direction=<default>);
+arc arc(ellipse el, explicit abscissa x1, explicit abscissa x2, bool direction=<default>);
+arc arc(ellipse el, point M, point N, bool direction=<default>);
+arc arc(explicit arc a, abscissa x1, abscissa x2);
+arc arc(explicit arc a, point M, point N);
+path arc(explicit pair B, explicit pair A, explicit pair C, real r);
+void markrightangle(picture pic=<default>, point A, point O, point B, real size=<default>, pen p=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
+real epsgeo;
+real sharpangle(line l1, line l2);
+bool isparabola(bqe bqe);
+real sharpdegrees(line l1, line l2);
+real exradius(point A, point B, point C);
+real exradius(side side);
+abscissa nodabscissa(real x);
+abscissa nodabscissa(int x);
+abscissa nodabscissa(line l, point M);
+abscissa nodabscissa(circle c, point M);
+abscissa nodabscissa(ellipse el, point M);
+abscissa nodabscissa(parabola p, point M);
+abscissa nodabscissa(conic co, point M);
+abscissa nodabscissa(arc a, point M);
+coordsys coordsys(line l);
+coordsys coordsys(conic co);
+coordsys coordsys(ellipse el);
+pair coordinates(point M);
+real length(explicit point M);
+real length(segment s);
+int arcnodesnumber(explicit arc a);
+int nodesystem;
+bool collinear(vector u, vector v);
+point centroid(point A, point B, point C);
+point centroid(triangle t);
+int angularsystem;
+path square(pair z1, pair z2);
+point symmedian(triangle t);
+point symmedian(side side);
+line symmedian(vertex V);
+triangle symmedial(triangle t);
+int curvilinearsystem;
+bqe bqe(coordsys R=<default>, real a, real b, real c, real d, real e, real f);
+bqe bqe(point M1, point M2, point M3, point M4, point M5);
+arc arccircle(point A, point M, point B);
+arc arccircle(point A, point B, real angle, bool direction=<default>);
+point relpoint(line l, real x);
+point relpoint(explicit circle c, real x);
+point relpoint(explicit ellipse el, real x);
+point relpoint(explicit parabola p, real x);
+point relpoint(explicit hyperbola h, real x);
+point relpoint(explicit conic co, explicit real x);
+point relpoint(explicit conic co, explicit int x);
+point relpoint(arc a, real x);
+point changecoordsys(coordsys R, point M);
+vector changecoordsys(coordsys R, vector v);
+line changecoordsys(coordsys R, line l);
+bqe changecoordsys(coordsys R, bqe bqe);
+conic changecoordsys(coordsys R, conic co);
+real angle(explicit point M, coordsys R=<default>, bool warn=<default>);
+real angle(explicit vector v, coordsys R=<default>, bool warn=<default>);
+real angle(line l, coordsys R=<default>);
+real angle(line l1, line l2);
+real angle(arc a);
+point[] fermat(triangle t);
+real arclength(circle c);
+real arclength(ellipse el);
+real arclength(ellipse el, real angle1, real angle2, bool direction=<default>, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>);
+real arclength(parabola p, real angle);
+real arclength(parabola p, real angle1, real angle2);
+real arclength(parabola p);
+real arclength(arc a);
+line reverse(line l);
+arc reverse(arc a);
+point gergonne(triangle t);
+real focusToCenter(ellipse el, real a);
+hyperbola hyperbola(point P1, point P2, real ae, bool byfoci=<default>);
+hyperbola hyperbola(point C, real a, real b, real angle=<default>);
+hyperbola hyperbola(bqe bqe);
+hyperbola hyperbola(point M1, point M2, point M3, point M4, point M5);
+side opposite(vertex V);
+vertex opposite(side side);
+int hyperbolanodesnumber(hyperbola h, real angle1, real angle2);
+path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)(conic co);
+int hyperbolanodesnumberfactor;
+line parallel(point M, line l);
+line parallel(point M, explicit vector dir);
+line parallel(point M, explicit pair dir);
+bool parallel(line l1, line l2, bool strictly=<default>);
+transform projection(point A, point B);
+transform projection(point A, point B, point C, point D, bool safe=<default>);
+transform projection(line l);
+transform projection(line l1, line l2, bool safe=<default>);
+bool degenerate(conic c);
+bool degenerate(circle c);
+bool degenerate(ellipse el);
+line line(point A, bool extendA=<default>, point B, bool extendB=<default>);
+line line(segment s);
+line line(real a, point A=<default>);
+line line(point A=<default>, real a);
+line line(int a, point A=<default>);
+line line(coordsys R=<default>, real slope, real origin);
+line line(coordsys R=<default>, real a, real b, real c);
+line line(circle c);
+line line(explicit side side);
+line complementary(explicit line l);
+line[] complementary(explicit segment s);
+arc complementary(arc a);
+point ppoint(arc a, real x);
+path fromFocus(conic co, real angle1, real angle2, int n, bool direction);
+bool sameside(point M, point N, point O);
+bool sameside(point M, point P, line l);
+point[] sameside(point M, line l1, line l2);
+arc arcsubtended(point A, point B, real angle);
+void distance(picture pic=<default>, Label L=<default>, point A, point B, bool rotated=<default>, real offset=<default>, pen p=<default>, pen joinpen=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>);
+real distance(point M, line l);
+real distance(line l, point M);
+point incenter(point A, point B, point C);
+point incenter(triangle t);
+void write(explicit line l);
+void write(explicit segment s);
+void write(trilinear tri);
+triangle incentral(triangle t);
+point arcsubtendedcenter(point A, point B, real angle);
+circle circle(explicit point C, real r);
+circle circle(point A, point B);
+circle circle(segment s);
+circle circle(point A, point B, point C);
+circle circle(triangle t);
+circle circle(inversion i);
+point angpoint(conic co, real angle);
+point angpoint(explicit circle c, real x);
+point angpoint(explicit ellipse el, real x, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>);
+point angpoint(explicit parabola p, real x);
+point angpoint(explicit hyperbola h, real x, path polarconicroutine(conic co, real angle1, real angle2, int n, bool direction)=<default>);
+point angpoint(arc a, real angle);
+triangle orthic(triangle t);
+int circlenodesnumber(real r);
+int circlenodesnumber(real r, real angle1, real angle2);
+path compassmark(pair O, pair A, real position, real angle=<default>);
+bool byvertices;
+int circlenodesnumberfactor;
+transform xscale(real k, point M);
+transform yscale(real k, point M);
+transform scale(real k, point M);
+transform scale(real k, point A, point B, point C, point D, bool safe=<default>);
+transform scale(real k, line l1, line l2, bool safe=<default>);
+point operator +(explicit point P1, explicit point P2);
+point operator +(explicit point P1, explicit pair p2);
+point operator +(explicit pair p1, explicit point p2);
+point operator +(point M, explicit vector v);
+point operator +(explicit pair m, explicit vector v);
+vector operator +(explicit vector v1, explicit vector v2);
+line operator +(line l, vector u);
+conic operator +(conic c, explicit point M);
+conic operator +(conic c, explicit pair m);
+conic operator +(conic c, vector v);
+circle operator +(explicit circle c, explicit point M);
+circle operator +(explicit circle c, pair m);
+circle operator +(explicit circle c, vector m);
+abscissa operator +(real x, explicit abscissa a);
+abscissa operator +(explicit abscissa a, real x);
+abscissa operator +(int x, explicit abscissa a);
+arc operator +(explicit arc a, point M);
+arc operator +(explicit arc a, vector v);
+mass operator +(mass M1, mass M2);
+mass operator +(explicit mass M, real x);
+mass operator +(explicit mass M, int x);
+point operator -(explicit point P);
+point operator -(explicit point P1, explicit point P2);
+point operator -(explicit point P1, explicit pair p2);
+point operator -(explicit pair p1, explicit point P2);
+point operator -(point M, explicit vector v);
+vector operator -(explicit vector v);
+point operator -(explicit pair m, explicit vector v);
+vector operator -(explicit vector v1, explicit vector v2);
+line operator -(line l, vector u);
+conic operator -(conic c, explicit point M);
+conic operator -(conic c, explicit pair m);
+conic operator -(conic c, vector v);
+circle operator -(explicit circle c, explicit point M);
+circle operator -(explicit circle c, pair m);
+circle operator -(explicit circle c, vector m);
+abscissa operator -(explicit abscissa a);
+abscissa operator -(real x, explicit abscissa a);
+abscissa operator -(explicit abscissa a, real x);
+abscissa operator -(int x, explicit abscissa a);
+arc operator -(explicit arc a, point M);
+arc operator -(explicit arc a, vector v);
+mass operator -(mass M1, mass M2);
+mass operator -(explicit mass M, real x);
+mass operator -(explicit mass M, int x);
+transform xscaleO(real x);
+pair operator *(coordsys R, pair p);
+path operator *(coordsys R, path g);
+coordsys operator *(transform t, coordsys R);
+point operator *(real x, explicit point P);
+point operator *(transform t, explicit point P);
+point operator *(explicit point P1, explicit point P2);
+point operator *(explicit point P1, explicit pair p2);
+point operator *(explicit pair p1, explicit point p2);
+vector operator *(real x, explicit vector v);
+vector operator *(transform t, explicit vector v);
+vector operator *(explicit point M, explicit vector v);
+line operator *(transform t, line l);
+line operator *(real x, line l);
+line operator *(int x, line l);
+line operator *(point M, line l);
+circle operator *(real x, explicit circle c);
+circle operator *(int x, explicit circle c);
+ellipse operator *(transform t, ellipse el);
+parabola operator *(transform t, parabola p);
+ellipse operator *(transform t, circle c);
+hyperbola operator *(transform t, hyperbola h);
+conic operator *(transform t, conic co);
+ellipse operator *(real x, ellipse el);
+abscissa operator *(real x, explicit abscissa a);
+abscissa operator *(explicit abscissa a, real x);
+arc operator *(transform t, explicit arc a);
+arc operator *(real x, explicit arc a);
+arc operator *(int x, explicit arc a);
+mass operator *(real x, explicit mass M);
+mass operator *(int x, explicit mass M);
+mass operator *(transform t, mass M);
+triangle operator *(transform T, triangle t);
+point operator *(inversion i, point P);
+circle operator *(inversion i, line l);
+circle operator *(inversion i, circle c);
+arc operator *(inversion i, segment s);
+path operator *(inversion i, triangle t);
+transform yscaleO(real x);
+coordsys operator init();
+point operator init();
+vector operator init();
+line operator init();
+segment operator init();
+bqe operator init();
+conic operator init();
+circle operator init();
+ellipse operator init();
+parabola operator init();
+hyperbola operator init();
+abscissa operator init();
+arc operator init();
+mass operator init();
+triangle operator init();
+trilinear operator init();
+inversion operator init();
+pair operator cast(point P);
+pair[] operator cast(point[] P);
+point operator cast(pair p);
+point[] operator cast(pair[] p);
+guide operator cast(point p);
+path operator cast(point p);
+point operator cast(vector v);
+vector operator cast(pair v);
+vector operator cast(explicit point v);
+pair operator cast(explicit vector v);
+align operator cast(vector v);
+line operator cast(segment s);
+segment operator cast(line l);
+ellipse operator cast(circle c);
+circle operator cast(ellipse el);
+ellipse operator cast(conic co);
+parabola operator cast(conic co);
+conic operator cast(parabola p);
+hyperbola operator cast(conic co);
+conic operator cast(hyperbola h);
+conic operator cast(ellipse el);
+conic operator cast(circle c);
+circle operator cast(conic c);
+path operator cast(ellipse el);
+path operator cast(circle c);
+path operator cast(parabola p);
+path operator cast(hyperbola h);
+path operator cast(conic co);
+abscissa operator cast(explicit position position);
+abscissa operator cast(real x);
+abscissa operator cast(int x);
+path operator cast(explicit arc a);
+guide operator cast(explicit arc a);
+point operator cast(mass m);
+mass operator cast(point M);
+point[] operator cast(mass[] m);
+mass[] operator cast(point[] P);
+mass operator cast(pair m);
+path operator cast(mass M);
+guide operator cast(mass M);
+line operator cast(side side);
+point operator cast(vertex V);
+point operator cast(trilinear tri);
+circle operator cast(inversion i);
+inversion operator cast(circle c);
+void lineinversion();
+pair operator /(pair p, coordsys R);
+point operator /(explicit point P, real x);
+point operator /(real x, explicit point P);
+vector operator /(explicit vector v, real x);
+line operator /(line l, real x);
+line operator /(line l, int x);
+circle operator /(explicit circle c, real x);
+circle operator /(explicit circle c, int x);
+ellipse operator /(ellipse el, real x);
+abscissa operator /(real x, explicit abscissa a);
+abscissa operator /(explicit abscissa a, real x);
+abscissa operator /(int x, explicit abscissa a);
+arc operator /(explicit arc a, real x);
+mass operator /(explicit mass M, real x);
+mass operator /(explicit mass M, int x);
+transform scaleO(real x);
+real operator ^(point M, explicit circle c);
+segment segment(point A, point B);
+segment segment(line l);
+segment segment(explicit side side);
+bool operator ==(coordsys c1, coordsys c2);
+bool operator ==(explicit point M, explicit point N);
+bool operator ==(explicit vector u, explicit vector v);
+bool operator ==(line l1, line l2);
+bool operator !=(explicit point M, explicit point N);
+bool operator !=(line l1, line l2);
+line[] operator ^^(line l1, line l2);
+line[] operator ^^(line l1, line[] l2);
+line[] operator ^^(line[] l2, line l1);
+line[] operator ^^(line[] l1, line[] l2);
+triangle[] operator ^^(triangle[] t1, triangle t2);
+triangle[] operator ^^(... triangle[] t);
+real elle(real phi, real k);
+point excenter(point A, point B, point C);
+point excenter(side side);
+mass mass(point M, real m);
+mass mass(explicit point P);
+mass mass(coordsys R, explicit pair p, real m);
+bool operator @(point m, line l);
+bool operator @(point M, conic co);
+bool operator @(point M, explicit circle c);
+bool operator @(point M, arc a);
+triangle cevian(triangle t, point P);
+point cevian(side side, point P);
+line cevian(vertex V, point P);
+triangle triangle(line l1, line l2, line l3);
+trilinear trilinear(triangle t, real a, real b, real c);
+trilinear trilinear(triangle t, point M);
+trilinear trilinear(triangle t, real f(real, real, real), real a=<default>, real b=<default>, real c=<default>);
+triangle triangleAbc(real alpha, real b, real c, real angle=<default>, point A=<default>);
+triangle triangleabc(real a, real b, real c, real angle=<default>, point A=<default>);
+triangle anticomplementary(triangle t);
+vector dir(vertex V);
+real degrees(explicit point M, coordsys R=<default>, bool warn=<default>);
+real degrees(vector v, coordsys R=<default>, bool warn=<default>);
+real degrees(line l, coordsys R=<default>);
+real degrees(line l1, line l2);
+real degrees(arc a);
+real linemargin;
+real linemargin();
+line Oy(coordsys R=<default>);
+line Oy;
+path fromCenter(conic co, real angle1, real angle2, int n, bool direction);
+void markarc(picture pic=<default>, Label L=<default>, int n=<default>, real radius=<default>, real space=<default>, arc a, pen sectorpen=<default>, pen markpen=<default>, marginT margin(path, pen)=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marker marker=<default>);
+real approximate(real t);
+real[] approximate(real[] T);
+void markangle(picture pic=<default>, Label L=<default>, int n=<default>, real radius=<default>, real space=<default>, explicit line l1, explicit line l2, explicit pair align=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, pen p=<default>, filltype filltype=<default>, marginT margin(path, pen)=<default>, marker marker=<default>);
+void markangle(picture pic=<default>, Label L=<default>, int n=<default>, real radius=<default>, real space=<default>, explicit line l1, explicit line l2, explicit vector align, bool arrow(picture, path, pen, marginT(path, pen))=<default>, pen p=<default>, filltype filltype=<default>, marginT margin(path, pen)=<default>, marker marker=<default>);
+transform hprojection(line l, bool safe=<default>);
+point conj(explicit point M);
+vector conj(explicit vector u);
+hyperbola conj(hyperbola h);
+transform vprojection(line l, bool safe=<default>);
+parabola parabola(point F, line l);
+parabola parabola(point F, point vertex);
+parabola parabola(point F, real a, real angle);
+parabola parabola(bqe bqe);
+parabola parabola(point M1, point M2, point M3, line l);
+parabola parabola(point M1, point M2, point M3, point M4, point M5);
+bool onpath(picture pic=<default>, path g, point M, pen p=<default>);
+int parabolanodesnumber(parabola p, real angle1, real angle2);
+int parabolanodesnumberfactor;
+path NoModifier(path);
+real[] bangles(picture pic=<default>, parabola p);
+real[][] bangles(picture pic=<default>, hyperbola h);
+coordsys currentcoordsys;
+point foot(vertex V);
+point foot(side side);
+path currentpolarconicroutine(conic co, real angle1, real angle2, int n, bool direction);
+transform rotate(explicit pair dir);
+transform rotate(explicit vector dir);
+transform rotate(explicit point dir);
+real EPS;
+transform rotateO(real a);
+pair attract(pair m, path g, real fuzz=<default>);
+point attract(point M, path g, real fuzz=<default>);
+line perpendicular(point M, line l);
+line perpendicular(point M, explicit vector normal);
+line perpendicular(point M, explicit pair normal);
+bool perpendicular(line l1, line l2);
+void perpendicular(picture pic=<default>, pair z, pair align, pair dir=<default>, real size=<default>, pen p=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
+void perpendicular(picture pic=<default>, pair z, pair align, path g, real size=<default>, pen p=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
+real binomial(real n, real k);
+void perpendicularmark(picture pic=<default>, point z, explicit pair align, explicit pair dir=<default>, real size=<default>, pen p=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
+void perpendicularmark(picture pic=<default>, point z, vector align, vector dir=<default>, real size=<default>, pen p=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
+void perpendicularmark(picture pic=<default>, point z, explicit pair align, path g, real size=<default>, pen p=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
+void perpendicularmark(picture pic=<default>, point z, vector align, path g, real size=<default>, pen p=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
+void perpendicularmark(picture pic=<default>, line l1, line l2, real size=<default>, pen p=<default>, int quarter=<default>, marginT margin(path, pen)=<default>, filltype filltype=<default>);
+point isogonalconjugate(triangle t, point M);
+point isogonal(side side, point M);
+line isogonal(vertex V, point M);
+triangle isogonal(triangle t, point M);
+void Drawline(picture pic=<default>, Label L=<default>, pair P, bool dirP=<default>, pair Q, bool dirQ=<default>, align align=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, Label legend=<default>, marker marker=<default>, path pathModifier(path)=<default>);
+bool simeq(point A, point B, real fuzz=<default>);
+bool simeq(point a, real b, real fuzz=<default>);
+point inverse(real k, point A, point M);
+circle inverse(real k, point A, line l);
+circle inverse(real k, point A, circle c);
+arc inverse(real k, point A, segment s);
+inversion inversion(real k, point C);
+inversion inversion(point C, real k);
+inversion inversion(circle c1, circle c2, real sgn=<default>);
+inversion inversion(circle c1, circle c2, circle c3);
+inversion inversion(circle c);
+coordsys cartesiansystem(pair O=<default>, pair i, pair j);
+line tangent(circle c, abscissa x);
+line tangent(circle c, point M);
+line tangent(circle c, explicit vector v);
+line tangent(ellipse el, abscissa x);
+line tangent(parabola p, abscissa x);
+line tangent(hyperbola h, abscissa x);
+line tangent(explicit arc a, abscissa x);
+line tangent(explicit arc a, point M);
+line[] tangents(circle c, point M);
+line[] tangents(ellipse el, point M);
+line[] tangents(parabola p, point M);
+line[] tangents(hyperbola h, point M);
+real centerToFocus(ellipse el, real a);
+bqe equation(ellipse el);
+bqe equation(parabola p);
+bqe equation(hyperbola h);
+bqe equation(explicit conic co);
+triangle tangential(triangle t);
+triangle pedal(triangle t, point M);
+line pedal(side side, point M);
+string massformat(string format=<default>, string s, mass M);
+int relativesystem;
+void drawline(picture pic=<default>, triangle t, pen p=<default>);
+void addMargins(picture pic=<default>, real lmargin=<default>, real bmargin=<default>, real rmargin=<default>, real tmargin=<default>, bool rigid=<default>, bool allObject=<default>);
+triangle medial(triangle t);
+line median(vertex V);
+line median(side side);
+void show(picture pic=<default>, Label lo=<default>, Label li=<default>, Label lj=<default>, coordsys R, pen dotpen=<default>, pen xpen=<default>, pen ypen=<default>, pen ipen=<default>, pen jpen=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>);
+void show(Label L, vector v, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>);
+void show(picture pic=<default>, line l, pen p=<default>);
+void show(picture pic=<default>, Label LA=<default>, Label LB=<default>, Label LC=<default>, Label La=<default>, Label Lb=<default>, Label Lc=<default>, triangle t, pen p=<default>, filltype filltype=<default>);
+line isotomic(vertex V, point M);
+point isotomic(side side, point M);
+triangle isotomic(triangle t, point M);
+abscissa curabscissa(real x);
+abscissa curabscissa(int x);
+abscissa curabscissa(line l, point M);
+abscissa curabscissa(circle c, point M);
+abscissa curabscissa(ellipse el, point M);
+abscissa curabscissa(parabola p, point M);
+abscissa curabscissa(conic co, point M);
+abscissa curabscissa(arc a, point M);
+string DefaultFormat(real);
+string DefaultLogFormat(real)(int base);
+string DefaultLogFormat(real);
+guide graph(pair f(real), real, real, int)(guide join(... guide[]));
+guide[] graph(pair f(real), real, real, int)(guide join(... guide[]), bool3 cond(real));
+guide graph(picture pic=<default>, real f(real), real a, real b, int n=<default>, real T(real)=<default>, guide join(... guide[])=<default>);
+guide[] graph(picture pic=<default>, real f(real), real a, real b, int n=<default>, real T(real)=<default>, bool3 cond(real), guide join(... guide[])=<default>);
+guide graph(picture pic=<default>, real x(real), real y(real), real a, real b, int n=<default>, real T(real)=<default>, guide join(... guide[])=<default>);
+guide[] graph(picture pic=<default>, real x(real), real y(real), real a, real b, int n=<default>, real T(real)=<default>, bool3 cond(real), guide join(... guide[])=<default>);
+guide graph(picture pic=<default>, pair z(real), real a, real b, int n=<default>, real T(real)=<default>, guide join(... guide[])=<default>);
+guide[] graph(picture pic=<default>, pair z(real), real a, real b, int n=<default>, real T(real)=<default>, bool3 cond(real), guide join(... guide[])=<default>);
+guide graph(picture pic=<default>, pair[] z, guide join(... guide[])=<default>);
+guide[] graph(picture pic=<default>, pair[] z, bool3[] cond, guide join(... guide[])=<default>);
+guide graph(picture pic=<default>, real[] x, real[] y, guide join(... guide[])=<default>);
+guide[] graph(picture pic=<default>, real[] x, real[] y, bool3[] cond, guide join(... guide[])=<default>);
+scientific scientific(real x);
+void Left(picture, axisT)(bool extend=<default>);
+void Left(picture, axisT);
+autoscaleT defaultS;
+void XEquals(picture, axisT)(real x, bool extend=<default>);
+void YEquals(picture, axisT)(real y, bool extend=<default>);
+tickvalues OmitTickIntervals(tickvalues)(real[] a, real[] b);
+tickvalues OmitTickInterval(tickvalues)(real a, real b);
+tickvalues OmitTick(tickvalues)(... real[] x);
+string LogFormat(real)(int base);
+string LogFormat(real);
+axisT axis;
+void axis(picture pic=<default>, Label L=<default>, path g, path g2=<default>, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>), ticklocate locate, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, int[] divisor=<default>, bool above=<default>, bool opposite=<default>);
+void drawtick(frame f, transform T, path g, path g2, ticklocate locate, real val, real Size, int sign, pen p, bool extend);
+real maxlength(pair a, pair b, int nx, int ny);
+void errorbar(picture pic, pair z, pair dp, pair dm, pen p=<default>, real size=<default>);
+void errorbars(picture pic=<default>, pair[] z, pair[] dp, pair[] dm=<default>, bool[] cond=<default>, pen p=<default>, real size=<default>);
+void errorbars(picture pic=<default>, real[] x, real[] y, real[] dpx, real[] dpy, real[] dmx=<default>, real[] dmy=<default>, bool[] cond=<default>, pen p=<default>, real size=<default>);
+void errorbars(picture pic=<default>, real[] x, real[] y, real[] dpy, bool[] cond=<default>, pen p=<default>, real size=<default>);
+void xlimits(picture pic=<default>, real min=<default>, real max=<default>, bool crop=<default>);
+string conditionlength;
+void ylimits(picture pic=<default>, real min=<default>, real max=<default>, bool crop=<default>);
+tickvalues None(tickvalues v);
+scaleT Logarithmic;
+void limits(picture pic=<default>, pair min, pair max, bool crop=<default>);
+void crop(picture pic=<default>);
+picture vectorfield(path vector(real), path g, int n, bool truesize=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>);
+picture vectorfield(path vector(pair), pair a, pair b, int nx=<default>, int ny=<default>, bool truesize=<default>, real maxlength=<default>, bool cond(pair z)=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>);
+string OmitFormat(real)(string s=<default> ... real[] x);
+guide Straight(... guide[]);
+int Min;
+string trailingzero;
+void label(picture pic, Label L, pair z, real x, align align, string format, pen p);
+void labelx(picture pic=<default>, Label L=<default>, explicit pair z, align align=<default>, string format=<default>, pen p=<default>);
+void labelx(picture pic=<default>, Label L=<default>, real x, align align=<default>, string format=<default>, pen p=<default>);
+void labelx(picture pic=<default>, Label L, string format=<default>, explicit pen p=<default>);
+path Arc(pair c, real r, real angle1, real angle2, bool direction, int n=<default>);
+path Arc(pair c, real r, real angle1, real angle2, int n=<default>);
+path Arc(pair c, explicit pair z1, explicit pair z2, bool direction=<default>, int n=<default>);
+void labely(picture pic=<default>, Label L=<default>, explicit pair z, align align=<default>, string format=<default>, pen p=<default>);
+void labely(picture pic=<default>, Label L=<default>, real y, align align=<default>, string format=<default>, pen p=<default>);
+void labely(picture pic=<default>, Label L, string format=<default>, explicit pen p=<default>);
+pair labeltick(frame d, transform T, path g, ticklocate locate, real val, pair side, int sign, real Size, string ticklabel(real), Label F, real norm=<default>);
+void labelaxis(frame f, transform T, Label L, path g, ticklocate locate=<default>, int sign=<default>, bool ticklabels=<default>);
+void xaxisAt(picture pic=<default>, Label L=<default>, void axis(picture, axisT), real xmin=<default>, real xmax=<default>, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, bool above=<default>, bool opposite=<default>);
+void yaxisAt(picture pic=<default>, Label L=<default>, void axis(picture, axisT), real ymin=<default>, real ymax=<default>, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, bool above=<default>, bool opposite=<default>);
+void xaxis(picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, real xmin=<default>, real xmax=<default>, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, bool above=<default>);
+void yaxis(picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, real ymin=<default>, real ymax=<default>, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, bool above=<default>, bool autorotate=<default>);
+void xtick(picture pic=<default>, explicit pair z, pair dir=<default>, real size=<default>, pen p=<default>);
+void xtick(picture pic=<default>, real x, pair dir=<default>, real size=<default>, pen p=<default>);
+void xtick(picture pic=<default>, Label L, explicit pair z, pair dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
+void xtick(picture pic=<default>, Label L, real x, pair dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
+void ytick(picture pic=<default>, explicit pair z, pair dir=<default>, real size=<default>, pen p=<default>);
+void ytick(picture pic=<default>, real y, pair dir=<default>, real size=<default>, pen p=<default>);
+void ytick(picture pic=<default>, Label L, explicit pair z, pair dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
+void ytick(picture pic=<default>, Label L, real y, pair dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
+picture secondaryX(picture primary=<default>, void f(picture));
+picture secondaryY(picture primary=<default>, void f(picture));
+Label Break;
+tickvalues Break(tickvalues)(real, real);
+scaleT Linear;
+scaleT Linear(bool automin=<default>, bool automax=<default>, real s=<default>, real intercept=<default>);
+pair tickMin(picture pic);
+pair tickMax(picture pic);
+string autoformat(string format=<default>, real norm ... real[] a);
+real linear(real)(real S(real x)=<default>, real Min, real Max);
+pair polar(real r, real theta);
+string Format(real)(string s=<default>);
+guide polargraph(picture pic=<default>, real r(real), real a, real b, int n=<default>, guide join(... guide[])=<default>);
+guide polargraph(picture pic=<default>, real[] r, real[] theta, guide join(... guide[])=<default>);
+void LeftTicks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+void LeftTicks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks, real[] ticks=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+void LeftTicks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>);
+tickvalues NoZero(tickvalues);
+string NoZeroFormat(real);
+guide Hermite(... guide[])(real[] splinetype(real[], real[]));
+guide Hermite(... guide[]);
+path Circle(pair c, real r, int n=<default>);
+bool axiscoverage(int N, transform T, path g, ticklocate locate, real Step, pair side, int sign, real Size, Label F, string ticklabel(real), real norm, real limit);
+scaleT Broken(real a, real b, bool automin=<default>, bool automax=<default>);
+scaleT BrokenLog(real a, real b, bool automin=<default>, bool automax=<default>);
+void Ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(int sign, Label F=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks=<default>, real[] ticks=<default>, int N=<default>, bool begin=<default>, bool end=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+void Ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(int sign, Label F=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+void Ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+void Ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks, real[] ticks=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+void Ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>);
+string noprimary;
+void xequals(picture pic=<default>, Label L=<default>, real x, bool extend=<default>, real ymin=<default>, real ymax=<default>, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, bool above=<default>);
+void yequals(picture pic=<default>, Label L=<default>, real y, bool extend=<default>, real xmin=<default>, real xmax=<default>, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, bool above=<default>);
+pair Scale(picture pic=<default>, pair z);
+real ScaleX(picture pic=<default>, real x);
+real ScaleY(picture pic=<default>, real y);
+tickvalues generateticks(int sign, Label F=<default>, string ticklabel(real)=<default>, int N, int n=<default>, real Step=<default>, real step=<default>, real Size=<default>, real size=<default>, transform T, pair side, path g, real limit, pen p, ticklocate locate, int[] divisor, bool opposite);
+void checkconditionlength(int x, int y);
+real xtrans(transform t, real x);
+void Top(picture, axisT)(bool extend=<default>);
+void Top(picture, axisT);
+real ytrans(transform t, real y);
+void scale(picture pic=<default>, scaleT x, scaleT y=<default>, scaleT z=<default>);
+void scale(picture pic=<default>, bool xautoscale=<default>, bool yautoscale=<default>, bool zautoscale=<default>);
+int[] divisors(int a, int b);
+scientific operator init();
+bounds operator init();
+ticklocate operator init();
+locateT operator init();
+tickvalues operator init();
+axisT operator init();
+path[] segment(pair[] z, bool[] cond, guide join(... guide[])=<default>);
+int Both;
+void axes(picture pic=<default>, Label xlabel=<default>, Label ylabel=<default>, pair min=<default>, pair max=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>, marginT margin(path, pen)=<default>, bool above=<default>);
+string signedtrailingzero;
+ticklocate ticklocate(real a, real b, autoscaleT S=<default>, real tickmin=<default>, real tickmax=<default>, real time(real)=<default>, pair dir(real)=<default>);
+pair ticklabelshift(pair align, pen p=<default>);
+pair zero(real);
+void Bottom(picture, axisT)(bool extend=<default>);
+void Bottom(picture, axisT);
+void BottomTop(picture, axisT)(bool extend=<default>);
+void BottomTop(picture, axisT);
+real zerotickfuzz;
+real upscale(real b, real a);
+bool logaxiscoverage(int N, transform T, path g, ticklocate locate, pair side, int sign, real Size, Label F, string ticklabel(real), real limit, int first, int last);
+string baselinetemplate;
+void NoTicks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)();
+void NoTicks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>);
+void tick(picture pic=<default>, pair z, pair dir, real size=<default>, pen p=<default>);
+void tick(picture pic=<default>, Label L, real value, explicit pair z, pair dir, string format=<default>, real size=<default>, pen p=<default>);
+int Value;
+scaleT Log;
+scaleT Log(bool automin=<default>, bool automax=<default>);
+void Right(picture, axisT)(bool extend=<default>);
+void Right(picture, axisT);
+void RightTicks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+void RightTicks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks, real[] ticks=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+void RightTicks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>);
+int Max;
+void XZero(picture, axisT)(bool extend=<default>);
+void XZero(picture, axisT);
+void YZero(picture, axisT)(bool extend=<default>);
+void YZero(picture, axisT);
+bounds autoscale(real Min, real Max, scaleT scale=<default>);
+void autoscale(picture pic=<default>, void axis(picture, axisT));
+guide Spline(... guide[]);
+void LeftRight(picture, axisT)(bool extend=<default>);
+void LeftRight(picture, axisT);
+locateT operator init();
+void Straight(flatguide3)(... void(flatguide3)[]);
+void graph(flatguide3)(triple F(real), real, real, int)(void join(flatguide3)(... void(flatguide3)[]));
+void(flatguide3)[] graph(triple F(real), real, real, int)(void join(flatguide3)(... void(flatguide3)[]), bool3 cond(real));
+void graph(flatguide3)(picture pic=<default>, real x(real), real y(real), real z(real), real a, real b, int n=<default>, void join(flatguide3)(... void(flatguide3)[])=<default>);
+void(flatguide3)[] graph(picture pic=<default>, real x(real), real y(real), real z(real), real a, real b, int n=<default>, bool3 cond(real), void join(flatguide3)(... void(flatguide3)[])=<default>);
+void graph(flatguide3)(picture pic=<default>, triple v(real), real a, real b, int n=<default>, void join(flatguide3)(... void(flatguide3)[])=<default>);
+void(flatguide3)[] graph(picture pic=<default>, triple v(real), real a, real b, int n=<default>, bool3 cond(real), void join(flatguide3)(... void(flatguide3)[])=<default>);
+void graph(flatguide3)(picture pic=<default>, triple[] v, void join(flatguide3)(... void(flatguide3)[])=<default>);
+void(flatguide3)[] graph(picture pic=<default>, triple[] v, bool3[] cond, void join(flatguide3)(... void(flatguide3)[])=<default>);
+void graph(flatguide3)(picture pic=<default>, real[] x, real[] y, real[] z, void join(flatguide3)(... void(flatguide3)[])=<default>);
+void(flatguide3)[] graph(picture pic=<default>, real[] x, real[] y, real[] z, bool3[] cond, void join(flatguide3)(... void(flatguide3)[])=<default>);
+void graph(flatguide3)(triple F(path, real), path p, int n=<default>, void join(flatguide3)(... void(flatguide3)[])=<default>);
+void graph(flatguide3)(triple F(pair), path p, int n=<default>, void join(flatguide3)(... void(flatguide3)[])=<default>);
+void graph(flatguide3)(picture pic=<default>, real f(pair), path p, int n=<default>, void join(flatguide3)(... void(flatguide3)[])=<default>);
+void graph(flatguide3)(real f(pair), path p, int n=<default>, real T(pair), void join(flatguide3)(... void(flatguide3)[])=<default>);
+void(flatguide3)[][] lift(real f(real x, real y), guide[][] g, void join(flatguide3)(... void(flatguide3)[])=<default>);
+void(flatguide3)[][] lift(real f(pair z), guide[][] g, void join(flatguide3)(... void(flatguide3)[])=<default>);
+triple polar(real r, real theta, real phi);
+void polargraph(flatguide3)(real r(real, real), real theta(real), real phi(real), int n=<default>, void join(flatguide3)(... void(flatguide3)[])=<default>);
+void xaxis3At(picture pic=<default>, Label L=<default>, void axis(picture, axisT), real xmin=<default>, real xmax=<default>, pen p=<default>, void ticks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, bool above=<default>, bool opposite=<default>, bool opposite2=<default>, bool primary=<default>);
+void yaxis3At(picture pic=<default>, Label L=<default>, void axis(picture, axisT), real ymin=<default>, real ymax=<default>, pen p=<default>, void ticks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, bool above=<default>, bool opposite=<default>, bool opposite2=<default>, bool primary=<default>);
+void zaxis3At(picture pic=<default>, Label L=<default>, void axis(picture, axisT), real zmin=<default>, real zmax=<default>, pen p=<default>, void ticks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, bool above=<default>, bool opposite=<default>, bool opposite2=<default>, bool primary=<default>);
+void xaxis3(picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, real xmin=<default>, real xmax=<default>, pen p=<default>, void ticks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, bool above=<default>);
+void yaxis3(picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, real ymin=<default>, real ymax=<default>, pen p=<default>, void ticks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, bool above=<default>);
+void zaxis3(picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, real zmin=<default>, real zmax=<default>, pen p=<default>, void ticks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, bool above=<default>);
+bool uperiodic(triple[][] a);
+bool vperiodic(triple[][] a);
+void OutTicks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+void OutTicks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks, real[] ticks=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+void OutTicks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>);
+void axis(picture pic=<default>, Label L=<default>, path3 g, path3 g2=<default>, pen p=<default>, void ticks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>), ticklocate locate, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, int[] divisor=<default>, bool above=<default>, bool opposite=<default>);
+void Bounds(picture, axisT)(int type=<default>, int type2=<default>, triple align=<default>, bool extend=<default>);
+void Bounds(picture, axisT);
+void XZZero(picture, axisT)(triple align=<default>, bool extend=<default>);
+void XZZero(picture, axisT);
+void YZZero(picture, axisT)(triple align=<default>, bool extend=<default>);
+void YZZero(picture, axisT);
+surface surface(triple[][] f, bool[][] cond=<default>);
+surface surface(real[][] f, real[] x, real[] y, real[] xsplinetype(real[], real[])=<default>, real[] ysplinetype(real[], real[])=<default>, bool[][] cond=<default>);
+surface surface(real[][] f, pair a, pair b, real[] xsplinetype(real[], real[]), real[] ysplinetype(real[], real[])=<default>, bool[][] cond=<default>);
+surface surface(real[][] f, pair a, pair b, bool[][] cond=<default>);
+surface surface(triple f(pair z), pair a, pair b, int nu=<default>, int nv=<default>, bool cond(pair z)=<default>);
+surface surface(triple f(pair z), pair a, pair b, int nu=<default>, int nv=<default>, real[](real[], real[])[] usplinetype, real[](real[], real[])[] vsplinetype=<default>, bool cond(pair z)=<default>);
+surface surface(real f(pair z), pair a, pair b, int nx=<default>, int ny=<default>, bool cond(pair z)=<default>);
+surface surface(real f(pair z), pair a, pair b, int nx=<default>, int ny=<default>, real[] xsplinetype(real[], real[]), real[] ysplinetype(real[], real[])=<default>, bool cond(pair z)=<default>);
+void XYEquals(picture, axisT)(real x, real y, triple align=<default>, bool extend=<default>);
+triple Dir(real)(triple dir);
+void draw(picture pic=<default>, Label[] L=<default>, void(flatguide3)[][] g, pen[] p, light light=<default>, string name=<default>, render render=<default>, interaction interaction=<default>);
+void draw(picture pic=<default>, Label[] L=<default>, void(flatguide3)[][] g, pen p=<default>, light light=<default>, string name=<default>, render render=<default>, interaction interaction=<default>);
+void Ticks3(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(int sign, Label F=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks=<default>, real[] ticks=<default>, int N=<default>, bool begin=<default>, bool end=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+void Ticks3(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(int sign, Label F=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+real maxlength(triple f(pair z), pair a, pair b, int nu, int nv);
+void drawtick(picture pic, real[][] T, path3 g, path3 g2, ticklocate locate, real val, real Size, int sign, pen p, bool extend);
+triple tickMin3(picture pic);
+triple tickMax3(picture pic);
+triple Scale(picture pic=<default>, triple v);
+real ScaleZ(picture pic=<default>, real z);
+picture vectorfield(path3 vector(pair v), triple f(pair z), pair a, pair b, int nu=<default>, int nv=<default>, bool truesize=<default>, real maxlength=<default>, bool cond(pair z)=<default>, pen p=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>, string name=<default>, render render=<default>);
+path3 Circle(triple c, real r, triple normal=<default>, int n=<default>);
+void InTicks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+void InTicks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks, real[] ticks=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+void InTicks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>);
+void Spline(flatguide3)(... void(flatguide3)[]);
+void InOutTicks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, tickvalues modify(tickvalues)=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+void InOutTicks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, real[] Ticks, real[] ticks=<default>, real Size=<default>, real size=<default>, bool extend=<default>, pen pTick=<default>, pen ptick=<default>);
+void InOutTicks(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>);
+void axes3(picture pic=<default>, Label xlabel=<default>, Label ylabel=<default>, Label zlabel=<default>, triple min=<default>, triple max=<default>, pen p=<default>, bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, marginT3 margin(path3, pen)=<default>);
+void label(picture pic, Label L, triple v, real x, align align, string format, pen p);
+void labelx(picture pic=<default>, Label L=<default>, triple v, align align=<default>, string format=<default>, pen p=<default>);
+void labely(picture pic=<default>, Label L=<default>, triple v, align align=<default>, string format=<default>, pen p=<default>);
+void labeltick(picture pic, real[][] T, path3 g, ticklocate locate, real val, int sign, real Size, string ticklabel(real), Label F, real norm=<default>);
+void labelaxis(picture pic, real[][] T, Label L, path3 g, ticklocate locate=<default>, int sign=<default>, bool ticklabels=<default>);
+void labelx3(picture pic=<default>, Label L=<default>, real x, align align=<default>, string format=<default>, pen p=<default>);
+void labely3(picture pic=<default>, Label L=<default>, real y, align align=<default>, string format=<default>, pen p=<default>);
+void labelz(picture pic=<default>, Label L=<default>, triple v, align align=<default>, string format=<default>, pen p=<default>);
+void labelz3(picture pic=<default>, Label L=<default>, real z, align align=<default>, string format=<default>, pen p=<default>);
+void autoscale3(picture pic=<default>, void axis(picture, axisT));
+void xtick(picture pic=<default>, triple v, triple dir=<default>, real size=<default>, pen p=<default>);
+void xtick(picture pic=<default>, Label L, triple v, triple dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
+void ytick(picture pic=<default>, triple v, triple dir=<default>, real size=<default>, pen p=<default>);
+void ytick(picture pic=<default>, Label L, triple v, triple dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
+void xtick3(picture pic=<default>, real x, triple dir=<default>, real size=<default>, pen p=<default>);
+void xtick3(picture pic=<default>, Label L, real x, triple dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
+void ytick3(picture pic=<default>, real y, triple dir=<default>, real size=<default>, pen p=<default>);
+void ytick3(picture pic=<default>, Label L, real y, triple dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
+void ztick(picture pic=<default>, triple v, triple dir=<default>, real size=<default>, pen p=<default>);
+void ztick(picture pic=<default>, Label L, triple v, triple dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
+void ztick3(picture pic=<default>, real z, triple dir=<default>, real size=<default>, pen p=<default>);
+void ztick3(picture pic=<default>, Label L, real z, triple dir=<default>, string format=<default>, real size=<default>, pen p=<default>);
+triple zero3(real);
+triple defaultdir(triple X, triple Y, triple Z, bool opposite=<default>, projection P);
+real xtrans(real[][] t, real x);
+real ytrans(real[][] t, real y);
+real ztrans(real[][] t, real z);
+ticklocate ticklocate(real a, real b, autoscaleT S=<default>, real tickmin=<default>, real tickmax=<default>, real time(real)=<default>, triple dir(real));
+triple ticklabelshift(triple align, pen p=<default>);
+path3 Arc(triple c, triple v1, triple v2, triple normal=<default>, bool direction=<default>, int n=<default>);
+path3 Arc(triple c, real r, real theta1, real phi1, real theta2, real phi2, triple normal=<default>, bool direction, int n=<default>);
+path3 Arc(triple c, real r, real theta1, real phi1, real theta2, real phi2, triple normal=<default>, int n=<default>);
+void limits(picture pic=<default>, triple min, triple max);
+void XZEquals(picture, axisT)(real x, real z, triple align=<default>, bool extend=<default>);
+void YZEquals(picture, axisT)(real y, real z, triple align=<default>, bool extend=<default>);
+void XYZero(picture, axisT)(triple align=<default>, bool extend=<default>);
+void XYZero(picture, axisT);
+void zlimits(picture pic=<default>, real min=<default>, real max=<default>, bool crop=<default>);
+void tick(picture pic=<default>, triple v, triple dir, real size=<default>, pen p=<default>);
+void tick(picture pic=<default>, Label L, real value, triple v, triple dir, string format=<default>, real size=<default>, pen p=<default>);
+surface bispline(real[][] z, real[][] p, real[][] q, real[][] r, real[] x, real[] y, bool[][] cond=<default>);
+path3[] segment(triple[] v, bool[] cond, void join(flatguide3)(... void(flatguide3)[])=<default>);
+void NoTicks3(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>)();
+void NoTicks3(picture, real[][], Label, path3, path3, pen, bool(picture, path3, material, marginT3(path3, pen), light, light), marginT3(path3, pen), ticklocate, int[], bool opposite=<default>, bool primary=<default>);
+bool Crop;
+int ngraph;
+real epsilon;
+real axiscoverage;
+real Ticksize;
+bool NoCrop;
+real ticksize;
+int nCircle;
+int nmesh;
+real ylabelwidth;
+real axislabelfactor;
+real[] clamped(real[], real[])(real slopea, real slopeb);
+real[] natural(real[] x, real[] y);
+real[] monotonic(real[] x, real[] y);
+real[] notaknot(real[] x, real[] y);
+real[] linear(real[] x, real[] y);
+string morepoints;
+guide hermite(real[] x, real[] y, real[] splinetype(real[], real[])=<default>);
+void checklengths(int x, int y, string text=<default>);
+void checkincreasing(real[] x);
+real[] periodic(real[] x, real[] y);
+string differentlengths;
+real[] Spline(real[] x, real[] y);
+real[](real[], real[])[] Spline;
+grid3(picture pic)[] YXYgrid(position pos=<default>);
+grid3(picture pic)[] YXYgrid;
+grid3 operator init();
+ticksgridT operator init();
+grid3(picture pic)[] operator cast(grid3 gridroutine(picture pic));
+grid3(picture pic)[][] operator cast(grid3(picture pic)[] gridroutine);
+grid3(picture pic)[][] operator cast(grid3 gridroutine(picture pic));
+triple X(picture pic);
+triple Y(picture pic);
+triple Z(picture pic);
+grid3(picture pic)[] XYXgrid(position pos=<default>);
+grid3(picture pic)[] XYXgrid;
+grid3(picture pic)[] XY_XZgrid(position posa=<default>, position posb=<default>);
+grid3(picture pic)[] XY_XZgrid;
+grid3(picture pic)[] ZX_ZYgrid(position posa=<default>, position posb=<default>);
+grid3(picture pic)[] ZX_ZYgrid;
+grid3 XYgrid(picture pic)(position pos=<default>);
+grid3 XYgrid(picture pic);
+grid3 ZYgrid(picture pic)(position pos=<default>);
+grid3 ZYgrid(picture pic);
+void xaxis3(picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, pen p=<default>, ticksgridT ticks(), bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, bool above=<default>);
+void yaxis3(picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, pen p=<default>, ticksgridT ticks(), bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, bool above=<default>);
+void zaxis3(picture pic=<default>, Label L=<default>, void axis(picture, axisT)=<default>, pen p=<default>, ticksgridT ticks(), bool arrow(picture, path3, material, marginT3(path3, pen), light, light)=<default>, bool above=<default>);
+void grid3(picture pic=<default>, grid3(picture pic)[][] gridroutine=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, pen pGrid=<default>, pen pgrid=<default>, bool above=<default>);
+void grid3(picture pic=<default>, grid3(picture pic)[][] gridroutine, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, pen[] pGrid, pen[] pgrid, bool above=<default>);
+ticksgridT OutTicks()(Label F=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, real Size=<default>, real size=<default>, pen pTick=<default>, pen ptick=<default>, grid3(picture pic)[][] gridroutine, pen pGrid=<default>, pen pgrid=<default>);
+triple YZ(picture pic);
+triple ZX(picture pic);
+grid3(picture pic)[] XZXgrid(position pos=<default>);
+grid3(picture pic)[] XZXgrid;
+grid3(picture pic)[] ZXZgrid(position pos=<default>);
+grid3(picture pic)[] ZXZgrid;
+position top;
+ticksgridT InTicks()(Label F=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, real Size=<default>, real size=<default>, pen pTick=<default>, pen ptick=<default>, grid3(picture pic)[][] gridroutine, pen pGrid=<default>, pen pgrid=<default>);
+ticksgridT InOutTicks()(Label F=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, bool begin=<default>, bool end=<default>, real Size=<default>, real size=<default>, pen pTick=<default>, pen ptick=<default>, grid3(picture pic)[][] gridroutine, pen pGrid=<default>, pen pgrid=<default>);
+grid3(picture pic)[] YX_YZgrid(position posa=<default>, position posb=<default>);
+grid3(picture pic)[] YX_YZgrid;
+position bottom;
+grid3 YXgrid(picture pic)(position pos=<default>);
+grid3 YXgrid(picture pic);
+grid3 ZXgrid(picture pic)(position pos=<default>);
+grid3 ZXgrid(picture pic);
+grid3 XZgrid(picture pic)(position pos=<default>);
+grid3 XZgrid(picture pic);
+grid3 YZgrid(picture pic)(position pos=<default>);
+grid3 YZgrid(picture pic);
+triple XY(picture pic);
+position middle;
+grid3(picture pic)[][] XYZgrid(position pos=<default>);
+grid3(picture pic)[][] XYZgrid;
+grid3(picture pic)[] ZYZgrid(position pos=<default>);
+grid3(picture pic)[] ZYZgrid;
+grid3(picture pic)[] YZYgrid(position pos=<default>);
+grid3(picture pic)[] YZYgrid;
+real fspline(real)(real[] x, real[] y, real[] splinetype(real[], real[])=<default>);
+real pwhermite(real)(real[] x, real[] y, real[] dy);
+horner diffdiv(real[] x, real[] y);
+horner hdiffdiv(real[] x, real[] y, real[] dy);
+horner operator init();
+real fhorner(real)(horner sh);
+void labelpath(frame f, Label L, path g, string justify=<default>, pen p=<default>);
+void labelpath(picture pic=<default>, Label L, path g, string justify=<default>, pen p=<default>);
+string LeftJustified;
+string Centered;
+string RightJustified;
+surface labelpath(string s, path3 p, real angle=<default>, triple optional=<default>);
+triple[] firstframe(path3 p, triple optional=<default>);
+triple[] nextframe(path3 p, real reltimestart, triple[] start, real reltimeend, int subdiv=<default>);
+real eps;
+triple nextnormal(triple p, triple q);
+string[] lm_infmsg;
+void lm_qrfac(int m, int n, real[] a, bool pivot, int[] ipvt, real[] rdiag, real[] acnorm, real[] wa);
+void lm_qrsolv(int n, real[] r, int ldr, int[] ipvt, real[] diag, real[] qtb, real[] x, real[] sdiag, real[] wa);
+FitControl defaultControl;
+real LM_MACHEP;
+real LM_SQRT_DWARF;
+real LM_SQRT_GIANT;
+void lm_lmpar(int n, real[] r, int ldr, int[] ipvt, real[] diag, real[] qtb, real delta, lm_real_type par, real[] x, real[] sdiag, real[] wa1, real[] wa2);
+void lm_lmdif(int m, int n, real[] x, real[] fvec, real ftol, real xtol, real gtol, int maxfev, real epsfcn, real[] diag, int mode, real factor, lm_int_type info, lm_int_type nfev, real[] fjac, int[] ipvt, real[] qtf, real[] wa1, real[] wa2, real[] wa3, real[] wa4, void evaluate(real[] par, int m_dat, real[] fvec, lm_data_type data, lm_int_type info), void printout(int n_par, real[] par, int m_dat, real[] fvec, lm_data_type data, int iflag, int iter, int nfev), lm_data_type data);
+void lm_minimize(int m_dat, int n_par, real[] par, void evaluate(real[] par, int m_dat, real[] fvec, lm_data_type data, lm_int_type info), void printout(int n_par, real[] par, int m_dat, real[] fvec, lm_data_type data, int iflag, int iter, int nfev), lm_data_type data, lm_control_type control);
+FitResult fit(real[] xdata, real[] ydata, real[] errors, real function(real[], real), real[] parameters, FitControl control=<default>);
+FitResult fit(real[] xdata, real[] ydata, real function(real[], real), real[] parameters, FitControl control=<default>);
+real lm_enorm(int n, real[] x, int offset=<default>);
+lm_data_type operator init();
+lm_int_type operator init();
+lm_real_type operator init();
+lm_control_type operator init();
+FitControl operator init();
+FitResult operator init();
+real SQR(real x);
+string[] lm_shortmsg;
+void lm_evaluate_default(real[] par, int m_dat, real[] fvec, lm_data_type data, lm_int_type info);
+string pad(string str, int count, string pad=<default>);
+string pad(int num, int digits, string pad=<default>);
+string pad(real num, int digits, string pad=<default>);
+real LM_USERTOL;
+real LM_DWARF;
+void lm_print_quiet(int n_par, real[] par, int m_dat, real[] fvec, lm_data_type data, int iflag, int iter, int nfev);
+void lm_print_default(int n_par, real[] par, int m_dat, real[] fvec, lm_data_type data, int iflag, int iter, int nfev);
+real barmarksize(pen p=<default>);
+real barmarksizefactor;
+marker CrossIntervalMarker(int i=<default>, int n=<default>, real size=<default>, real space=<default>, real angle=<default>, pair offset=<default>, bool rotated=<default>, pen p=<default>, frame uniform=<default>, bool above=<default>);
+marker StickIntervalMarker(int i=<default>, int n=<default>, real size=<default>, real space=<default>, real angle=<default>, pair offset=<default>, bool rotated=<default>, pen p=<default>, frame uniform=<default>, bool above=<default>);
+frame crossframe(int n=<default>, real size=<default>, pair space=<default>, real angle=<default>, pair offset=<default>, pen p=<default>);
+real crossmarksize(pen p=<default>);
+real crossmarksizefactor;
+frame stickframe(int n=<default>, real size=<default>, pair space=<default>, real angle=<default>, pair offset=<default>, pen p=<default>);
+frame stickframe;
+real stickmarksize(pen p=<default>);
+real stickmarkspace(pen p=<default>);
+real stickmarksizefactor;
+real stickmarkspacefactor;
+frame duplicate(path g, int n=<default>, pair space=<default>, pen p=<default>);
+marker CircleBarIntervalMarker(int i=<default>, int n=<default>, real barsize=<default>, real radius=<default>, real angle=<default>, pair offset=<default>, bool rotated=<default>, pen p=<default>, filltype filltype=<default>, bool circleabove=<default>, frame uniform=<default>, bool above=<default>);
+frame circlebarframe(int n=<default>, real barsize=<default>, real radius=<default>, real angle=<default>, pair offset=<default>, pen p=<default>, filltype filltype=<default>, bool above=<default>);
+real circlemarkradius(pen p=<default>);
+real circlemarkradiusfactor;
+marker operator *(transform T, marker m);
+marker TildeIntervalMarker(int i=<default>, int n=<default>, real size=<default>, real space=<default>, real angle=<default>, pair offset=<default>, bool rotated=<default>, pen p=<default>, frame uniform=<default>, bool above=<default>);
+frame tildeframe(int n=<default>, real size=<default>, pair space=<default>, real angle=<default>, pair offset=<default>, pen p=<default>);
+frame tildeframe;
+real tildemarksize(pen p=<default>);
+real tildemarksizefactor;
+void markangle(picture pic=<default>, Label L=<default>, int n=<default>, real radius=<default>, real space=<default>, pair A, pair O, pair B, bool arrow(picture, path, pen, marginT(path, pen))=<default>, pen p=<default>, filltype filltype=<default>, marginT margin(path, pen)=<default>, marker marker=<default>);
+real markanglespace(pen p=<default>);
+real markanglespace;
+real markangleradius(pen p=<default>);
+real markangleradius;
+real markanglespacefactor;
+real markangleradiusfactor;
+void markinterval(picture pic=<default>, frame f, path g)(int n=<default>, frame f, bool rotated=<default>);
+real[] partialsum(real[] a);
+real[] partialsum(real[] a, real[] dx);
+int[] partialsum(int[] a);
+int[] partialsum(int[] a, int[] dx);
+real cot(real x);
+int unique(real[] a, real x);
+int unique(string[] a, string x);
+int quadrant(real degrees);
+pair exp(explicit pair z);
+string nopoint;
+real intersect(pair p, pair q, pair z);
+real intersect(triple P, triple Q, triple n, triple Z);
+real interpolate(real[] x, real[] y, real x0, int i);
+real interpolate(real[] x, real[] y, real x0);
+triple intersectionpoint(triple n0, triple P0, triple n1, triple P1);
+pair[] quarticroots(real a, real b, real c, real d, real e);
+bool lexorder(pair a, pair b);
+bool lexorder(triple a, triple b);
+bool square(real[][] m);
+real sec(real x);
+bool rectangular(real[][] m);
+bool rectangular(pair[][] m);
+bool rectangular(triple[][] m);
+bool polygon(path p);
+pair unityroot(int n, int k=<default>);
+real acot(real x);
+pair[][] fft(pair[][] a, int sign=<default>);
+real slope(path g, real x, int n=<default>);
+real slope(path g, explicit pair z, int n=<default>);
+picture grid(int Nx, int Ny, pen p=<default>);
+int[][] segment(bool[] b);
+real frac(real x);
+real asec(real x);
+real time(path g, real x, int n=<default>);
+real time(path g, explicit pair z, int n=<default>);
+bool increasing(real[] a, bool strict=<default>);
+real[] zero(int n);
+real[][] zero(int n, int m);
+real acsc(real x);
+real value(path g, real x, int n=<default>);
+real value(path g, explicit pair z, int n=<default>);
+real csc(real x);
+pair log(explicit pair z);
+void drawline(picture pic=<default>, pair P, pair Q, pen p=<default>);
+path cutbefore(path p, path q);
+path cutafter(path p, path q);
+path cuttings;
+void draw(picture pic=<default>, obj o, light light=<default>);
+obj operator *(real[][] T, obj o);
+obj operator init();
+real[][] finiteDifferenceJacobian(real[] f(real[]), real[] t, real[] h=<default>);
+RKTableau E_Euler;
+real error(real error, real initial, real lowOrder, real norm, real diff);
+RKTableau RK5;
+real stepfactor;
+solution integrate(real y, real c=<default>, real g(real t, real y), real a, real b=<default>, real h=<default>, int n=<default>, bool dynamic=<default>, real tolmin=<default>, real tolmax=<default>, real dtmin=<default>, real dtmax=<default>, RKTableau tableau, bool verbose=<default>);
+Solution integrate(real[] y, real[] f(real t, real[] y), real a, real b=<default>, real h=<default>, int n=<default>, bool dynamic=<default>, real tolmin=<default>, real tolmax=<default>, real dtmin=<default>, real dtmax=<default>, RKTableau tableau, bool verbose=<default>);
+RKTableau RK4;
+real[] newton(int iterations=<default>, real[] f(real[]), real[][] jacobian(real[]), real[] t);
+real phi1(real x);
+RKTableau RK3;
+void expfactors(real x, coefficients a);
+real phi2(real x);
+void report(real old, real h, real t);
+real[] solveBVP(real[] f(real, real[]), real a, real b=<default>, real h=<default>, int n=<default>, bool dynamic=<default>, real tolmin=<default>, real tolmax=<default>, real dtmin=<default>, real dtmax=<default>, RKTableau tableau, bool verbose=<default>, real[] initial(real[]), real[] discrepancy(real[]), real[] guess, int iterations=<default>);
+RKTableau Euler;
+RKTableau E_PC;
+RKTableau RK2;
+real phi3(real x);
+void write(solution S);
+void write(Solution S);
+coefficients operator init();
+RKTableau operator init();
+solution operator init();
+Solution operator init();
+RKTableau E_RK2;
+RKTableau RK3BS;
+RKTableau RK5F;
+real adjust(real h, real error, real tolmin, real tolmax, RKTableau tableau);
+RKTableau RK5DP;
+real[] Coeff;
+RKTableau PC;
+RKTableau E_RK3BS;
+pen[] Grayscale(int NColors=<default>);
+pen[] Wheel(int NColors=<default>);
+void image(frame f, real[][] data, pair initial, pair final, pen[] palette, bool transpose=<default>, transform t=<default>, bool copy=<default>, bool antialias=<default>);
+void image(frame f, pen[][] data, pair initial, pair final, bool transpose=<default>, transform t=<default>, bool copy=<default>, bool antialias=<default>);
+bounds image(picture pic=<default>, real[][] f, bounds range(picture pic, real min, real max)=<default>, pair initial, pair final, pen[] palette, bool transpose=<default>, bool copy=<default>, bool antialias=<default>);
+bounds image(picture pic=<default>, real f(real, real), bounds range(picture pic, real min, real max)=<default>, pair initial, pair final, int nx=<default>, int ny=<default>, pen[] palette, bool antialias=<default>);
+void image(picture pic=<default>, pen[][] data, pair initial, pair final, bool transpose=<default>, bool copy=<default>, bool antialias=<default>);
+void image(picture pic=<default>, pen f(int, int), int width, int height, pair initial, pair final, bool transpose=<default>, bool antialias=<default>);
+bounds image(picture pic=<default>, pair[] z, real[] f, bounds range(picture pic, real min, real max)=<default>, pen[] palette);
+bounds image(picture pic=<default>, real[] x, real[] y, real[] f, bounds range(picture pic, real min, real max)=<default>, pen[] palette);
+pen[] cmyk(pen[] Palette);
+pen[] BWRainbow(int NColors, bool two);
+pen[] BWRainbow(int NColors=<default>);
+pen[] BWRainbow2(int NColors=<default>);
+transform swap;
+bounds Automatic(picture pic, real min, real max);
+real[] sequencereal;
+pen[] Rainbow(int NColors=<default>);
+pen[] adjust(picture pic, real min, real max, real rmin, real rmax, pen[] palette);
+pen[] Gradient(int NColors=<default> ... pen[] p);
+pen[] quantize(pen[] Palette, int n);
+bounds Range(picture pic, real min, real max)(bool automin=<default>, real min=<default>, bool automax=<default>, real max=<default>);
+bounds Full(picture pic, real min, real max);
+void PaletteTicks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(int sign=<default>)(Label format=<default>, string ticklabel(real)=<default>, bool beginlabel=<default>, bool endlabel=<default>, int N=<default>, int n=<default>, real Step=<default>, real step=<default>, pen pTick=<default>, pen ptick=<default>);
+void PaletteTicks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(int sign=<default>);
+pen[] palette(real[] f, pen[] palette);
+pen[][] palette(real[][] f, pen[] palette);
+void palette(picture pic=<default>, Label L=<default>, bounds bounds, pair initial, pair final, void axis(picture, axisT)=<default>, pen[] palette, pen p=<default>, void ticks(frame, transform, Label, pair, path, path, pen, bool(picture, path, pen, marginT(path, pen)), marginT(path, pen), ticklocate, int[], bool opposite=<default>)(int sign=<default>)=<default>, bool copy=<default>, bool antialias=<default>);
+picture brick(real Hx=<default>, real Hy=<default>, pen p=<default>);
+picture crosshatch(real H=<default>, pen p=<default>);
+picture hatch(real H=<default>, pair dir=<default>, pen p=<default>);
+real hatchepsilon;
+picture checker(real Hx=<default>, real Hy=<default>, pen p=<default>);
+void add(string name, picture pic, pair lb=<default>, pair rt=<default>);
+frame tiling(string name, picture pic, pair lb=<default>, pair rt=<default>);
+picture tile(real Hx=<default>, real Hy=<default>, pen p=<default>, filltype filltype=<default>);
+void grestore(picture pic=<default>);
+void gsave(picture pic=<default>);
+pair align;
+pen textpen;
+path roundedpath(path A, real R, real S=<default>);
+problem operator init();
+real infinity;
+pen authorpen;
+void display(frame[] f, real margin=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool final=<default>);
+void display(frame f, real margin=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool final=<default>);
+void display(string[] s, real margin=<default>, string[] captions=<default>, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool final=<default>);
+void display(string s, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool final=<default>);
+void multifigure(string[] slist, string options=<default>, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool step=<default>);
+void subitem(string s, pen p=<default>);
+pen pagenumberpen;
+pair pagenumberalign;
+pair pagenumberposition;
+void indexedfigure(string prefix, int first, int last, string options=<default>, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool step=<default>);
+string texcolor(pen p);
+void color(string name, string color);
+pen foregroundcolor;
+void bibliography(string name);
+void bibliographystyle(string name);
+int[] lastnode;
+void asyfigure(string s, string options=<default>, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, filltype filltype=<default>, bool newslide=<default>);
+void asyfilecode(bool center=<default>, string s, string options=<default>, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, real indent=<default>, real skip=<default>, filltype filltype=<default>, bool newslide=<default>);
+bool itemstep;
+real itemskip;
+void remark(bool center=<default>, string s, pair align=<default>, pen p=<default>, real indent=<default>, bool minipage=<default>, real skip=<default>, filltype filltype=<default>, bool step=<default>);
+int page;
+void usersetting();
+bool landscape;
+real codeskip;
+void newslide(bool stepping=<default>);
+void nextpage(pen p=<default>);
+pen itempen;
+void filecode(bool center=<default>, string s, pen p=<default>, real indent=<default>, real skip=<default>, filltype filltype=<default>);
+bool reverse;
+void reversevideo();
+void vbox(string s, pen p=<default>);
+void asycode(bool center=<default>, string s, string options=<default>, string caption=<default>, string preamble=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, real indent=<default>, real skip=<default>, filltype filltype=<default>, bool newslide=<default>);
+void exitfunction();
+bool havepagenumber;
+real pageheight;
+real pagewidth;
+picture background;
+void background();
+pen backgroundcolor;
+void normalvideo();
+void title(string s, pair position=<default>, pair align=<default>, pen p=<default>, bool newslide=<default>);
+pen titlepen;
+real titleskip;
+pair dateskip;
+pair titlealign;
+pen titlepagepen;
+void titlepage(string title, string author, string institution=<default>, string date=<default>, string url=<default>, bool newslide=<default>);
+pair titlepageposition;
+pen codepen;
+void erasestep(int erasenode);
+bool checkposition();
+void setpens(pen red=<default>, pen blue=<default>, pen steppen=<default>);
+void code(bool center=<default>, string s, pen p=<default>, real indent=<default>, real skip=<default>, filltype filltype=<default>);
+transform tinv;
+pair urlskip;
+void numberpage(pen p=<default>);
+pen urlpen;
+void item(string s, pen p=<default>, bool step=<default>);
+int[] firstnode;
+bool firststep;
+string asywrite(string s, string preamble=<default>);
+pair startposition;
+string oldbulletcolor;
+string newbulletcolor;
+pen datepen;
+void incrementposition(pair z);
+pen institutionpen;
+string cropcode(string s);
+void skip(real n=<default>);
+bool stepping;
+real pagemargin;
+pen steppagenumberpen;
+bool allowstepping;
+pair currentposition;
+bool empty();
+void currentexitfunction();
+void step();
+string[] codefile;
+void outline(string s=<default>, pair position=<default>, pair align=<default>, pen p=<default>);
+void center(string s, pen p=<default>);
+void equation(string s, pen p=<default>);
+void equations(string s, pen p=<default>);
+void asyinclude(string s, real xsize=<default>, real ysize=<default>);
+void figure(string[] s, string options=<default>, real margin=<default>, string[] captions=<default>, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool final=<default>);
+void figure(string s, string options=<default>, string caption=<default>, pair align=<default>, pen p=<default>, pen figuremattpen=<default>, bool final=<default>);
+real figureborder;
+pen figuremattpen;
+string bullet;
+int preamblenodes;
+string bulletcolor(string color);
+real minipagewidth;
+real minipagemargin;
+real stepfraction;
+path curve(pair c, real f(real, real), pair a, pair b);
+path curve(pair c, real f(real), pair a, pair b);
+picture slopefield(real f(real, real), pair a, pair b, int nx=<default>, int ny=<default>, real tickfactor=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>);
+picture slopefield(real f(real), pair a, pair b, int nx=<default>, int ny=<default>, pen p=<default>, bool arrow(picture, path, pen, marginT(path, pen))=<default>);
+revolution operator *(real[][] t, revolution r);
+skeleton operator init();
+revolution operator init();
+revolution sphere(triple c=<default>, real r, int n=<default>);
+path line(path p, path q, real[] t);
+surface surface(revolution r, int n=<default>, pen color(int i, real j)=<default>);
+void draw(picture pic=<default>, revolution r, int m=<default>, int n=<default>, pen frontpen=<default>, pen backpen=<default>, pen longitudinalpen=<default>, pen longitudinalbackpen=<default>, light light=<default>, string name=<default>, render render=<default>, projection P=<default>);
+real[] tangent(path p, path q, bool side);
+pen defaultbackpen;
+path[] cylinder(path3 base, real h, triple axis=<default>, projection P);
+revolution cylinder(triple c=<default>, real r, real h, triple axis=<default>);
+revolution cone(triple c=<default>, real r, real h, triple axis=<default>, int n=<default>);
+real rms(real[] A);
+int[] frequency(real[] data, real[] bins);
+int[] frequency(real[] data, real a, real b, int n);
+int[][] frequency(real[] x, real[] y, real[] xbins, real[] ybins);
+int[][] frequency(real[] x, real[] y, pair a, pair b, int nx, int ny=<default>);
+int[][] frequency(pair[] z, pair a, pair b, int nx, int ny=<default>);
+real mean(real[] A);
+int bins(real[] data, int max=<default>);
+real stdev(real[] A);
+path topbox(pair a, pair b);
+path halfbox(pair a, pair b);
+real Gaussian(real x, real sigma);
+real Gaussian(real x);
+pair Gaussrandpair();
+real Gaussrand();
+real variance(real[] A);
+real legendmarkersize;
+real variancebiased(real[] A);
+linefit operator init();
+real skewness(real[] A);
+linefit leastsquares(real[] x, real[] y);
+real kurtosis(real[] A);
+real kurtosisexcess(real[] A);
+void histogram(picture pic=<default>, real[] bins, real[] count, real low=<default>, pen fillpen=<default>, pen drawpen=<default>, bool bars=<default>, Label legend=<default>, real markersize=<default>);
+void histogram(picture pic=<default>, real[] data, real a, real b, int n, bool normalize=<default>, real low=<default>, pen fillpen=<default>, pen drawpen=<default>, bool bars=<default>, Label legend=<default>, real markersize=<default>);
+pair[] endpoints(guide[] a);
+Relation r3;
+picture tableau(frame[] cards, bool number=<default>);
+pair min(pair[] z);
+Component bp;
+Braid apply(Relation r, Braid b, int step, int place);
+Component phi;
+real gapfactor;
+Component bm;
+Component wye;
+Relation operator -(Relation r);
+Component operator init();
+Braid operator init();
+Relation operator init();
+Syzygy operator init();
+Relation r4b;
+real hwratio;
+Relation r4a;
+pair max(pair[] z);
+pen Orchid;
+pen Magenta;
+pen BrickRed;
+pen CadetBlue;
+pen CarnationPink;
+pen SpringGreen;
+pen MidnightBlue;
+pen OliveGreen;
+pen Apricot;
+pen Aquamarine;
+pen Cyan;
+pen Lavender;
+pen Red;
+pen RawSienna;
+pen Mahogany;
+pen Gray;
+pen Plum;
+pen BlueGreen;
+pen Cerulean;
+pen Blue;
+pen BlueViolet;
+pen RedOrange;
+pen Goldenrod;
+pen ForestGreen;
+pen BurntOrange;
+pen Tan;
+pen YellowOrange;
+pen Maroon;
+pen YellowGreen;
+pen Brown;
+pen RubineRed;
+pen TealBlue;
+pen White;
+pen Purple;
+pen Bittersweet;
+pen Orange;
+pen OrangeRed;
+pen Fuchsia;
+pen Peach;
+pen Sepia;
+pen PineGreen;
+pen Dandelion;
+pen Black;
+pen VioletRed;
+pen NavyBlue;
+pen Violet;
+pen Rhodamine;
+pen ProcessBlue;
+pen LimeGreen;
+pen Thistle;
+pen Green;
+pen GreenYellow;
+pen DarkOrchid;
+pen Emerald;
+pen Mulberry;
+pen RedViolet;
+pen SkyBlue;
+pen SeaGreen;
+pen WildStrawberry;
+pen Periwinkle;
+pen Yellow;
+pen JungleGreen;
+pen Salmon;
+pen CornflowerBlue;
+pen RoyalBlue;
+pen Melon;
+pen RoyalPurple;
+pen Turquoise;
+int lookup(tree t, int key);
+tree newtree();
+void write(file out=<default>, tree t);
+tree operator init();
+tree add(tree t, int key, int value);
+bool contains(tree t, int key);
+real trembleFuzz();
+real trembleAngle;
+real trembleRandom;
+real trembleFrequency;
+tremble operator init();
+real magneticRadius;
+real[] sample(path3 g, real r, real relstep=<default>);
+path3 roundedpath(path3 A, real r);
+int coloredNodes;
+int coloredSegments;
+surface surface(rmf[] R, real[] t, coloredpath cp, transform T(real), bool cyclic);
+surface tube(path3 g, coloredpath section, transform T(real)=<default>, real corner=<default>, real relstep=<default>);
+coloredpath operator init();
+coloredpath operator cast(path p);
+coloredpath operator cast(guide p);
+real degrees(rmf a, rmf b);
+string VERSION;
+pen Orchid;
+pen Indigo;
+pen Beige;
+pen SlateBlue;
+pen SlateGray;
+pen Magenta;
+pen SteelBlue;
+pen CadetBlue;
+pen DeepPink;
+pen SpringGreen;
+pen MidnightBlue;
+pen Olive;
+pen OliveDrab;
+pen LemonChiffon;
+pen Aquamarine;
+pen Chocolate;
+pen Cyan;
+pen Gainsboro;
+pen Lavender;
+pen Aqua;
+pen Ivory;
+pen PapayaWhip;
+pen Red;
+pen Pink;
+pen MintCream;
+pen DarkTurquoise;
+pen Gray;
+pen MediumBlue;
+pen MediumOrchid;
+pen MediumPurple;
+pen MediumSeaGreen;
+pen MediumSlateBlue;
+pen MediumAquamarine;
+pen MediumSpringGreen;
+pen MediumTurquoise;
+pen MediumVioletRed;
+pen Plum;
+pen Blue;
+pen Gold;
+pen Sienna;
+pen BlueViolet;
+pen Goldenrod;
+pen ForestGreen;
+pen Chartreuse;
+pen NavajoWhite;
+pen Tan;
+pen DarkMagenta;
+pen Maroon;
+pen AntiqueWhite;
+pen YellowGreen;
+pen PaleTurquoise;
+pen IndianRed;
+pen Crimson;
+pen Azure;
+pen LawnGreen;
+pen Brown;
+pen BurlyWood;
+pen Moccasin;
+pen DarkBlue;
+pen Peru;
+pen White;
+pen Purple;
+pen WhiteSmoke;
+pen DimGray;
+pen DarkOliveGreen;
+pen DarkOrange;
+pen Orange;
+pen OrangeRed;
+pen Fuchsia;
+pen PeachPuff;
+pen Honeydew;
+pen Bisque;
+pen RosyBrown;
+pen Silver;
+pen Black;
+pen Khaki;
+pen FireBrick;
+pen Violet;
+pen Snow;
+pen SandyBrown;
+pen LimeGreen;
+pen Lime;
+pen Thistle;
+pen DeepSkyBlue;
+pen OldLace;
+pen Green;
+pen GreenYellow;
+pen DarkCyan;
+pen FloralWhite;
+pen DarkRed;
+pen DarkOrchid;
+pen Cornsilk;
+pen BlanchedAlmond;
+pen PowderBlue;
+pen DarkGray;
+pen DarkGreen;
+pen DarkGoldenrod;
+pen SkyBlue;
+pen SeaGreen;
+pen DarkViolet;
+pen Teal;
+pen AliceBlue;
+pen HotPink;
+pen Seashell;
+pen DodgerBlue;
+pen SaddleBrown;
+pen Tomato;
+pen DarkKhaki;
+pen GhostWhite;
+pen LightBlue;
+pen LightCoral;
+pen LightCyan;
+pen Yellow;
+pen LightGreen;
+pen PaleGreen;
+pen Linen;
+pen LightGoldenrodYellow;
+pen LightGrey;
+pen LightPink;
+pen PaleGoldenrod;
+pen LightSalmon;
+pen LightSeaGreen;
+pen Navy;
+pen LightSkyBlue;
+pen LightSlateGray;
+pen PaleVioletRed;
+pen Salmon;
+pen LightSteelBlue;
+pen LightYellow;
+pen CornflowerBlue;
+pen rgbint(int r, int g, int b);
+pen Coral;
+pen MistyRose;
+pen LavenderBlush;
+pen DarkSalmon;
+pen Wheat;
+pen DarkSeaGreen;
+pen RoyalBlue;
+pen DarkSlateBlue;
+pen DarkSlateGray;
+pen Turquoise;