string defaultformat(int n, string trailingzero="", bool fixed=false,
                    bool signed=true)
{
 return "$%"+trailingzero+"."+string(n)+(fixed ? "f" : "g")+"$";
}

string defaultformat=defaultformat(4);
string defaultseparator="\!\times\!";

string ask(string prompt)
{
 write(stdout,prompt);
 return stdin;
}

string getstring(string name="", string default="", string prompt="",
                bool store=true)
{
 string[] history=history(name,1);
 if(history.length > 0) default=history[0];
 if(prompt == "") prompt=name+"? [%s] ";
 prompt=replace(prompt,new string[][] {{"%s",default}});
 string s=readline(prompt,name);
 if(s == "") s=default;
 else saveline(name,s,store);
 return s;
}

int getint(string name="", int default=0, string prompt="", bool store=true)
{
 return (int) getstring(name,(string) default,prompt,store);
}

real getreal(string name="", real default=0, string prompt="", bool store=true)
{
 return (real) getstring(name,(string) default,prompt,store);
}

pair getpair(string name="", pair default=0, string prompt="", bool store=true)
{
 return (pair) getstring(name,(string) default,prompt,store);
}

triple gettriple(string name="", triple default=(0,0,0), string prompt="",
                bool store=true)
{
 return (triple) getstring(name,(string) default,prompt,store);
}

// returns a string with all occurrences of string 'before' in string 's'
// changed to string 'after'.
string replace(string s, string before, string after)
{
 return replace(s,new string[][] {{before,after}});
}

// Like texify but don't convert embedded TeX commands: \${}
string TeXify(string s)
{
 static string[][] t={{"&","\&"},{"%","\%"},{"_","\_"},{"#","\#"},{"<","$<$"},
                      {">","$>$"},{"|","$|$"},{"^","$\hat{\ }$"},
                      {"~","$\tilde{\ }$"},{" ","\phantom{ }"}};
 return replace(s,t);
}

private string[][] trans1={{'\\',"\backslash "},
                          {"$","\$"},{"{","\{"},{"}","\}"}};
private string[][] trans2={{"\backslash ","$\backslash$"}};

// Convert string to TeX
string texify(string s)
{
 return TeXify(replace(replace(s,trans1),trans2));
}

// Convert string to TeX, preserving newlines
string verbatim(string s)
{
 bool space=substr(s,0,1) == '\n';
 static string[][] t={{'\n',"\\"}};
 t.append(trans1);
 s=TeXify(replace(replace(s,t),trans2));
 return space ? "\ "+s : s;
}

// Split a string into an array of substrings delimited by delimiter
// If delimiter is an empty string, use space delimiter but discard empty
// substrings. TODO: Move to C++ code.
string[] split(string s, string delimiter="")
{
 bool prune=false;
 if(delimiter == "") {
   prune=true;
   delimiter=" ";
 }

 string[] S;
 int last=0;
 int i;
 int N=length(delimiter);
 int n=length(s);
 while((i=find(s,delimiter,last)) >= 0) {
   if(i > last || (i == last && !prune))
     S.push(substr(s,last,i-last));
   last=i+N;
 }
 if(n > last || (n == last && !prune))
   S.push(substr(s,last,n-last));
 return S;
}

// Returns an array of strings obtained by splitting s into individual
// characters. TODO: Move to C++ code.
string[] array(string s)
{
 int len=length(s);
 string[] S=new string[len];
 for(int i=0; i < len; ++i)
   S[i]=substr(s,i,1);
 return S;
}

// Concatenate an array of strings into a single string.
// TODO: Move to C++ code.
string operator +(...string[] a)
{
 string S;
 for(string s : a)
   S += s;
 return S;
}

int system(string s)
{
 return system(split(s));
}

int[] operator ecast(string[] a)
{
 return sequence(new int(int i) {return (int) a[i];},a.length);
}

real[] operator ecast(string[] a)
{
 return sequence(new real(int i) {return (real) a[i];},a.length);
}

// Read contents of file as a string.
string file(string s)
{
 file f=input(s);
 string s;
 while(!eof(f)) {
   s += f+'\n';
 }
 return s;
}

string italic(string s)
{
 return s != "" ? "{\it "+s+"}" : s;
}

string baseline(string s, string template="\strut")
{
 return s != "" && settings.tex != "none" ? "\vphantom{"+template+"}"+s : s;
}

string math(string s)
{
 return s != "" ? "$"+s+"$" : s;
}

private void notimplemented(string text)
{
 abort(text+" is not implemented for the '"+settings.tex+"' TeX engine");
}

string jobname(string name)
{
 int pos=rfind(name,"-");
 return pos >= 0 ? "\ASYprefix\jobname"+substr(name,pos) : name;
}

string graphic(string name, string options="")
{
 if(latex()) {
   if(options != "") options="["+options+"]";
   string includegraphics="\includegraphics"+options;
   return includegraphics+"{"+(settings.inlinetex ? jobname(name) : name)+"}";
 }
 if(settings.tex != "context")
   notimplemented("graphic");
 return "\externalfigure["+name+"]["+options+"]";
}

string graphicscale(real x)
{
 return string(settings.tex == "context" ? 1000*x : x);
}

string minipage(string s, real width=100bp)
{
 if(latex())
   return "\begin{minipage}{"+(string) (width/pt)+"pt}"+s+"\end{minipage}";
 if(settings.tex != "context")
   notimplemented("minipage");
 return "\startframedtext[none][frame=off,width="+(string) (width/pt)+
   "pt]"+s+"\stopframedtext";
}

void usepackage(string s, string options="")
{
 if(!latex()) notimplemented("usepackage");
 string usepackage="\usepackage";
 if(options != "") usepackage += "["+options+"]";
 texpreamble(usepackage+"{"+s+"}");
}

void pause(string w="Hit enter to continue")
{
 write(w);
 w=stdin;
}

string format(string format=defaultformat, bool forcemath=false, real x,
             string locale="")
{
 return format(format,forcemath,defaultseparator,x,locale);
}

string phantom(string s)
{
 return settings.tex != "none" ? "\phantom{"+s+"}" : "";
}

string[] spinner=new string[] {'|','/','-','\\'};
spinner.cyclic=true;

void progress(bool3 init=default)
{
 static int count=-1;
 static int lastseconds=-1;
 if(init == true) {
   lastseconds=0;
   write(stdout,' ',flush);
 } else
   if(init == default) {
   int seconds=seconds();
   if(seconds > lastseconds) {
     lastseconds=seconds;
     write(stdout,'\b'+spinner[++count],flush);
   }
 } else
     write(stdout,'\b',flush);
}

restricted int ocgindex=0;