Index des fonctions Asymptote

Cette page se veut être une interface de lecture du fichier asy.list de la version SVN d'Asymptote (avec ses défauts : les types en reviennent aux fondamentaux, sans prendre en compte les typedef des fichiers asy.

Par exemple, au lieu d'y trouver le type transform3, on y lira real[][].).

Cible de la recherche	Texte à filtrer	Expression régulière	Smart filter
Filtre global
Filtre sur le TYPE
Filtre sur le NOM
Filtre sur les ARGUMENTS

Type	Nom	Arguments

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