- PR#5276: issue with ocamlc -pack and recursively-packed modules
- PR#5280: alignment constraints incorrectly autodetected on MIPS 32
- PR#5281: typo in error message
+- PR#5308: unused variables not detected in "include (struct .. end)"
- camlp4 revised syntax printing bug in the toplevel (reported on caml-list)
- configure: do not define _WIN32 under cygwin
- Hardened generic comparison in the case where two custom blocks
* First public release.
-$Id: Changes 11083 2011-06-11 07:24:12Z xleroy $
+$Id: Changes 11110 2011-07-04 21:15:01Z doligez $
that is compatible with the GPL. Executables generated by MSVC or by
MinGW have no such restrictions.
-(**) The debugger is supported but the "replay" function of it are not enabled.
+(**) The debugger is supported but the "replay" functions are not enabled.
Other functions are available (step, goto, run...).
The remainder of this document gives more information on each port.
The native Win32 port built with Mingw
--------------------------------------
+NOTE: Due to changes in cygwin's compilers, this port is not available
+in OCaml 3.12.1. A patch will be made available soon after the release
+of 3.12.1.
+
REQUIREMENTS:
This port runs under MS Windows Vista, XP, and 2000.
- Windows NT, 2000, XP, or Vista.
- Cygwin: http://sourceware.cygnus.com/cygwin/
Install at least the following packages: binutils, diffutils,
- gcc-core, gcc-mingw-core, make, mingw-runtime, ncurses, w32-api.
+ gcc-core, gcc-mingw-core, make, mingw-runtime, ncurses, w32api.
- TCL/TK version 8.5 (see above).
- The flexdll tool (see above).
The libraries available in this port are "num", "str", "threads",
"unix" and "labltk". "graph" is not available.
-The replay debugger is supported.
+The replay debugger is fully supported.
+When upgrading from 3.12.0 to 3.12.1, you will need to remove
+/usr/local/bin/ocamlmktop.exe before typing "make install".
------------------------------------------------------------------------------
-3.12.1+rc1
+3.12.1
# The version string is the first line of this file.
# It must be in the format described in stdlib/sys.mli
-# $Id: VERSION 11094 2011-06-15 11:01:14Z doligez $
+# $Id: VERSION 11110 2011-07-04 21:15:01Z doligez $
--- /dev/null
+module MySet = Set.Make(String);;
+let set = MySet.empty;;
+assert (MySet.is_empty set);;
--- /dev/null
+EXTEND Gram
+ abc: [ [ `(x,y) -> x + y ] ];
+END;
--- /dev/null
+EXTEND Gram
+ raw_string:
+ [[ `QUOTATION { Sig.Quotation.q_contents = c; q_name = n } -> (c, n) ]];
+END;
--- /dev/null
+EXTEND Gram
+ abc: [ [ `(A,y) -> y ] ];
+END;
--- /dev/null
+[|
+aaa;
+aab;
+aac;
+aad;
+aae;
+aaf;
+aag;
+aah;
+aai;
+aaj;
+aak;
+aal;
+aam;
+aan;
+aao;
+aap;
+aaq;
+aar;
+aas;
+aat;
+aau;
+aav;
+aaw;
+aax;
+aay;
+aaz;
+aba;
+abb;
+abc;
+abd;
+abe;
+abf;
+abg;
+abh;
+abi;
+abj;
+abk;
+abl;
+abm;
+abn;
+abo;
+abp;
+abq;
+abr;
+abs;
+abt;
+abu;
+abv;
+abw;
+abx;
+aby;
+abz;
+aca;
+acb;
+acc;
+acd;
+ace;
+acf;
+acg;
+ach;
+aci;
+acj;
+ack;
+acl;
+acm;
+acn;
+aco;
+acp;
+acq;
+acr;
+acs;
+act;
+acu;
+acv;
+acw;
+acx;
+acy;
+acz;
+ada;
+adb;
+adc;
+add;
+ade;
+adf;
+adg;
+adh;
+adi;
+adj;
+adk;
+adl;
+adm;
+adn;
+ado;
+adp;
+adq;
+adr;
+ads;
+adt;
+adu;
+adv;
+adw;
+adx;
+ady;
+adz;
+aea;
+aeb;
+aec;
+aed;
+aee;
+aef;
+aeg;
+aeh;
+aei;
+aej;
+aek;
+ael;
+aem;
+aen;
+aeo;
+aep;
+aeq;
+aer;
+aes;
+aet;
+aeu;
+aev;
+aew;
+aex;
+aey;
+aez;
+afa;
+afb;
+afc;
+afd;
+afe;
+aff;
+afg;
+afh;
+afi;
+afj;
+afk;
+afl;
+afm;
+afn;
+afo;
+afp;
+afq;
+afr;
+afs;
+aft;
+afu;
+afv;
+afw;
+afx;
+afy;
+afz;
+aga;
+agb;
+agc;
+agd;
+age;
+agf;
+agg;
+agh;
+agi;
+agj;
+agk;
+agl;
+agm;
+agn;
+ago;
+agp;
+agq;
+agr;
+ags;
+agt;
+agu;
+agv;
+agw;
+agx;
+agy;
+agz;
+aha;
+ahb;
+ahc;
+ahd;
+ahe;
+ahf;
+ahg;
+ahh;
+ahi;
+ahj;
+ahk;
+ahl;
+ahm;
+ahn;
+aho;
+ahp;
+ahq;
+ahr;
+ahs;
+aht;
+ahu;
+ahv;
+ahw;
+ahx;
+ahy;
+ahz;
+aia;
+aib;
+aic;
+aid;
+aie;
+aif;
+aig;
+aih;
+aii;
+aij;
+aik;
+ail;
+aim;
+ain;
+aio;
+aip;
+aiq;
+air;
+ais;
+ait;
+aiu;
+aiv;
+aiw;
+aix;
+aiy;
+aiz;
+aja;
+ajb;
+ajc;
+ajd;
+aje;
+ajf;
+ajg;
+ajh;
+aji;
+ajj;
+ajk;
+ajl;
+ajm;
+ajn;
+ajo;
+ajp;
+ajq;
+ajr;
+ajs;
+ajt;
+aju;
+ajv;
+ajw;
+ajx;
+ajy;
+ajz;
+aka;
+akb;
+akc;
+akd;
+ake;
+akf;
+akg;
+akh;
+aki;
+akj;
+akk;
+akl;
+akm;
+akn;
+ako;
+akp;
+akq;
+akr;
+aks;
+akt;
+aku;
+akv;
+akw;
+akx;
+aky;
+akz;
+ala;
+alb;
+alc;
+ald;
+ale;
+alf;
+alg;
+alh;
+ali;
+alj;
+alk;
+all;
+alm;
+aln;
+alo;
+alp;
+alq;
+alr;
+als;
+alt;
+alu;
+alv;
+alw;
+alx;
+aly;
+alz;
+ama;
+amb;
+amc;
+amd;
+ame;
+amf;
+amg;
+amh;
+ami;
+amj;
+amk;
+aml;
+amm;
+amn;
+amo;
+amp;
+amq;
+amr;
+ams;
+amt;
+amu;
+amv;
+amw;
+amx;
+amy;
+amz;
+ana;
+anb;
+anc;
+ane;
+anf;
+ang;
+anh;
+ani;
+anj;
+ank;
+anl;
+anm;
+ann;
+ano;
+anp;
+anq;
+anr;
+ans;
+ant;
+anu;
+anv;
+anw;
+anx;
+any;
+anz;
+aoa;
+aob;
+aoc;
+aod;
+aoe;
+aof;
+aog;
+aoh;
+aoi;
+aoj;
+aok;
+aol;
+aom;
+aon;
+aoo;
+aop;
+aoq;
+aor;
+aos;
+aot;
+aou;
+aov;
+aow;
+aox;
+aoy;
+aoz;
+apa;
+apb;
+apc;
+apd;
+ape;
+apf;
+apg;
+aph;
+api;
+apj;
+apk;
+apl;
+apm;
+apn;
+apo;
+app;
+apq;
+apr;
+aps;
+apt;
+apu;
+apv;
+apw;
+apx;
+apy;
+apz;
+aqa;
+aqb;
+aqc;
+aqd;
+aqe;
+aqf;
+aqg;
+aqh;
+aqi;
+aqj;
+aqk;
+aql;
+aqm;
+aqn;
+aqo;
+aqp;
+aqq;
+aqr;
+aqs;
+aqt;
+aqu;
+aqv;
+aqw;
+aqx;
+aqy;
+aqz;
+ara;
+arb;
+arc;
+ard;
+are;
+arf;
+arg;
+arh;
+ari;
+arj;
+ark;
+arl;
+arm;
+arn;
+aro;
+arp;
+arq;
+arr;
+ars;
+art;
+aru;
+arv;
+arw;
+arx;
+ary;
+arz;
+asa;
+asb;
+asc;
+asd;
+ase;
+asf;
+asg;
+ash;
+asi;
+asj;
+ask;
+asl;
+asm;
+asn;
+aso;
+asp;
+asq;
+ass;
+ast;
+asu;
+asv;
+asw;
+asx;
+asy;
+asz;
+ata;
+atb;
+atc;
+atd;
+ate;
+atf;
+atg;
+ath;
+ati;
+atj;
+atk;
+atl;
+atm;
+atn;
+ato;
+atp;
+atq;
+atr;
+ats;
+att;
+atu;
+atv;
+atw;
+atx;
+aty;
+atz;
+aua;
+aub;
+auc;
+aud;
+aue;
+auf;
+aug;
+auh;
+aui;
+auj;
+auk;
+aul;
+aum;
+aun;
+auo;
+aup;
+auq;
+aur;
+aus;
+aut;
+auu;
+auv;
+auw;
+aux;
+auy;
+auz;
+ava;
+avb;
+avc;
+avd;
+ave;
+avf;
+avg;
+avh;
+avi;
+avj;
+avk;
+avl;
+avm;
+avn;
+avo;
+avp;
+avq;
+avr;
+avs;
+avt;
+avu;
+avv;
+avw;
+avx;
+avy;
+avz;
+awa;
+awb;
+awc;
+awd;
+awe;
+awf;
+awg;
+awh;
+awi;
+awj;
+awk;
+awl;
+awm;
+awn;
+awo;
+awp;
+awq;
+awr;
+aws;
+awt;
+awu;
+awv;
+aww;
+awx;
+awy;
+awz;
+axa;
+axb;
+axc;
+axd;
+axe;
+axf;
+axg;
+axh;
+axi;
+axj;
+axk;
+axl;
+axm;
+axn;
+axo;
+axp;
+axq;
+axr;
+axs;
+axt;
+axu;
+axv;
+axw;
+axx;
+axy;
+axz;
+aya;
+ayb;
+ayc;
+ayd;
+aye;
+ayf;
+ayg;
+ayh;
+ayi;
+ayj;
+ayk;
+ayl;
+aym;
+ayn;
+ayo;
+ayp;
+ayq;
+ayr;
+ays;
+ayt;
+ayu;
+ayv;
+ayw;
+ayx;
+ayy;
+ayz;
+aza;
+azb;
+azc;
+azd;
+aze;
+azf;
+azg;
+azh;
+azi;
+azj;
+azk;
+azl;
+azm;
+azn;
+azo;
+azp;
+azq;
+azr;
+azs;
+azt;
+azu;
+azv;
+azw;
+azx;
+azy;
+azz;
+baa;
+bab;
+bac;
+bad;
+bae;
+baf;
+bag;
+bah;
+bai;
+baj;
+bak;
+bal;
+bam;
+ban;
+bao;
+bap;
+baq;
+bar;
+bas;
+bat;
+bau;
+bav;
+baw;
+bax;
+bay;
+baz;
+bba;
+bbb
+|];
--- /dev/null
+[|
+aaaa;
+aaab;
+aaac;
+aaad;
+aaae;
+aaaf;
+aaag;
+aaah;
+aaai;
+aaaj;
+aaak;
+aaal;
+aaam;
+aaan;
+aaao;
+aaap;
+aaaq;
+aaar;
+aaas;
+aaat;
+aaau;
+aaav;
+aaaw;
+aaax;
+aaay;
+aaaz;
+aaba;
+aabb;
+aabc;
+aabd;
+aabe;
+aabf;
+aabg;
+aabh;
+aabi;
+aabj;
+aabk;
+aabl;
+aabm;
+aabn;
+aabo;
+aabp;
+aabq;
+aabr;
+aabs;
+aabt;
+aabu;
+aabv;
+aabw;
+aabx;
+aaby;
+aabz;
+aaca;
+aacb;
+aacc;
+aacd;
+aace;
+aacf;
+aacg;
+aach;
+aaci;
+aacj;
+aack;
+aacl;
+aacm;
+aacn;
+aaco;
+aacp;
+aacq;
+aacr;
+aacs;
+aact;
+aacu;
+aacv;
+aacw;
+aacx;
+aacy;
+aacz;
+aada;
+aadb;
+aadc;
+aadd;
+aade;
+aadf;
+aadg;
+aadh;
+aadi;
+aadj;
+aadk;
+aadl;
+aadm;
+aadn;
+aado;
+aadp;
+aadq;
+aadr;
+aads;
+aadt;
+aadu;
+aadv;
+aadw;
+aadx;
+aady;
+aadz;
+aaea;
+aaeb;
+aaec;
+aaed;
+aaee;
+aaef;
+aaeg;
+aaeh;
+aaei;
+aaej;
+aaek;
+aael;
+aaem;
+aaen;
+aaeo;
+aaep;
+aaeq;
+aaer;
+aaes;
+aaet;
+aaeu;
+aaev;
+aaew;
+aaex;
+aaey;
+aaez;
+aafa;
+aafb;
+aafc;
+aafd;
+aafe;
+aaff;
+aafg;
+aafh;
+aafi;
+aafj;
+aafk;
+aafl;
+aafm;
+aafn;
+aafo;
+aafp;
+aafq;
+aafr;
+aafs;
+aaft;
+aafu;
+aafv;
+aafw;
+aafx;
+aafy;
+aafz;
+aaga;
+aagb;
+aagc;
+aagd;
+aage;
+aagf;
+aagg;
+aagh;
+aagi;
+aagj;
+aagk;
+aagl;
+aagm;
+aagn;
+aago;
+aagp;
+aagq;
+aagr;
+aags;
+aagt;
+aagu;
+aagv;
+aagw;
+aagx;
+aagy;
+aagz;
+aaha;
+aahb;
+aahc;
+aahd;
+aahe;
+aahf;
+aahg;
+aahh;
+aahi;
+aahj;
+aahk;
+aahl;
+aahm;
+aahn;
+aaho;
+aahp;
+aahq;
+aahr;
+aahs;
+aaht;
+aahu;
+aahv;
+aahw;
+aahx;
+aahy;
+aahz;
+aaia;
+aaib;
+aaic;
+aaid;
+aaie;
+aaif;
+aaig;
+aaih;
+aaii;
+aaij;
+aaik;
+aail;
+aaim;
+aain;
+aaio;
+aaip;
+aaiq;
+aair;
+aais;
+aait;
+aaiu;
+aaiv;
+aaiw;
+aaix;
+aaiy;
+aaiz;
+aaja;
+aajb;
+aajc;
+aajd;
+aaje;
+aajf;
+aajg;
+aajh;
+aaji;
+aajj;
+aajk;
+aajl;
+aajm;
+aajn;
+aajo;
+aajp;
+aajq;
+aajr;
+aajs;
+aajt;
+aaju;
+aajv;
+aajw;
+aajx;
+aajy;
+aajz;
+aaka;
+aakb;
+aakc;
+aakd;
+aake;
+aakf;
+aakg;
+aakh;
+aaki;
+aakj;
+aakk;
+aakl;
+aakm;
+aakn;
+aako;
+aakp;
+aakq;
+aakr;
+aaks;
+aakt;
+aaku;
+aakv;
+aakw;
+aakx;
+aaky;
+aakz;
+aala;
+aalb;
+aalc;
+aald;
+aale;
+aalf;
+aalg;
+aalh;
+aali;
+aalj;
+aalk;
+aall;
+aalm;
+aaln;
+aalo;
+aalp;
+aalq;
+aalr;
+aals;
+aalt;
+aalu;
+aalv;
+aalw;
+aalx;
+aaly;
+aalz;
+aama;
+aamb;
+aamc;
+aamd;
+aame;
+aamf;
+aamg;
+aamh;
+aami;
+aamj;
+aamk;
+aaml;
+aamm;
+aamn;
+aamo;
+aamp;
+aamq;
+aamr;
+aams;
+aamt;
+aamu;
+aamv;
+aamw;
+aamx;
+aamy;
+aamz;
+aana;
+aanb;
+aanc;
+aand;
+aane;
+aanf;
+aang;
+aanh;
+aani;
+aanj;
+aank;
+aanl;
+aanm;
+aann;
+aano;
+aanp;
+aanq;
+aanr;
+aans;
+aant;
+aanu;
+aanv;
+aanw;
+aanx;
+aany;
+aanz;
+aaoa;
+aaob;
+aaoc;
+aaod;
+aaoe;
+aaof;
+aaog;
+aaoh;
+aaoi;
+aaoj;
+aaok;
+aaol;
+aaom;
+aaon;
+aaoo;
+aaop;
+aaoq;
+aaor;
+aaos;
+aaot;
+aaou;
+aaov;
+aaow;
+aaox;
+aaoy;
+aaoz;
+aapa;
+aapb;
+aapc;
+aapd;
+aape;
+aapf;
+aapg;
+aaph;
+aapi;
+aapj;
+aapk;
+aapl;
+aapm;
+aapn;
+aapo;
+aapp;
+aapq;
+aapr;
+aaps;
+aapt;
+aapu;
+aapv;
+aapw;
+aapx;
+aapy;
+aapz;
+aaqa;
+aaqb;
+aaqc;
+aaqd;
+aaqe;
+aaqf;
+aaqg;
+aaqh;
+aaqi;
+aaqj;
+aaqk;
+aaql;
+aaqm;
+aaqn;
+aaqo;
+aaqp;
+aaqq;
+aaqr;
+aaqs;
+aaqt;
+aaqu;
+aaqv;
+aaqw;
+aaqx;
+aaqy;
+aaqz;
+aara;
+aarb;
+aarc;
+aard;
+aare;
+aarf;
+aarg;
+aarh;
+aari;
+aarj;
+aark;
+aarl;
+aarm;
+aarn;
+aaro;
+aarp;
+aarq;
+aarr;
+aars;
+aart;
+aaru;
+aarv;
+aarw;
+aarx;
+aary;
+aarz;
+aasa;
+aasb;
+aasc;
+aasd;
+aase;
+aasf;
+aasg;
+aash;
+aasi;
+aasj;
+aask;
+aasl;
+aasm;
+aasn;
+aaso;
+aasp;
+aasq;
+aasr;
+aass;
+aast;
+aasu;
+aasv;
+aasw;
+aasx;
+aasy;
+aasz;
+aata;
+aatb;
+aatc;
+aatd;
+aate;
+aatf;
+aatg;
+aath;
+aati;
+aatj;
+aatk;
+aatl;
+aatm;
+aatn;
+aato;
+aatp;
+aatq;
+aatr;
+aats;
+aatt;
+aatu;
+aatv;
+aatw;
+aatx;
+aaty;
+aatz;
+aaua;
+aaub;
+aauc;
+aaud;
+aaue;
+aauf;
+aaug;
+aauh;
+aaui;
+aauj;
+aauk;
+aaul;
+aaum;
+aaun;
+aauo;
+aaup;
+aauq;
+aaur;
+aaus;
+aaut;
+aauu;
+aauv;
+aauw;
+aaux;
+aauy;
+aauz;
+aava;
+aavb;
+aavc;
+aavd;
+aave;
+aavf;
+aavg;
+aavh;
+aavi;
+aavj;
+aavk;
+aavl;
+aavm;
+aavn;
+aavo;
+aavp;
+aavq;
+aavr;
+aavs;
+aavt;
+aavu;
+aavv;
+aavw;
+aavx;
+aavy;
+aavz;
+aawa;
+aawb;
+aawc;
+aawd;
+aawe;
+aawf;
+aawg;
+aawh;
+aawi;
+aawj;
+aawk;
+aawl;
+aawm;
+aawn;
+aawo;
+aawp;
+aawq;
+aawr;
+aaws;
+aawt;
+aawu;
+aawv;
+aaww;
+aawx;
+aawy;
+aawz;
+aaxa;
+aaxb;
+aaxc;
+aaxd;
+aaxe;
+aaxf;
+aaxg;
+aaxh;
+aaxi;
+aaxj;
+aaxk;
+aaxl;
+aaxm;
+aaxn;
+aaxo;
+aaxp;
+aaxq;
+aaxr;
+aaxs;
+aaxt;
+aaxu;
+aaxv;
+aaxw;
+aaxx;
+aaxy;
+aaxz;
+aaya;
+aayb;
+aayc;
+aayd;
+aaye;
+aayf;
+aayg;
+aayh;
+aayi;
+aayj;
+aayk;
+aayl;
+aaym;
+aayn;
+aayo;
+aayp;
+aayq;
+aayr;
+aays;
+aayt;
+aayu;
+aayv;
+aayw;
+aayx;
+aayy;
+aayz;
+aaza;
+aazb;
+aazc;
+aazd;
+aaze;
+aazf;
+aazg;
+aazh;
+aazi;
+aazj;
+aazk;
+aazl;
+aazm;
+aazn;
+aazo;
+aazp;
+aazq;
+aazr;
+aazs;
+aazt;
+aazu;
+aazv;
+aazw;
+aazx;
+aazy;
+aazz;
+abaa;
+abab;
+abac;
+abad;
+abae;
+abaf;
+abag;
+abah;
+abai;
+abaj;
+abak;
+abal;
+abam;
+aban;
+abao;
+abap;
+abaq;
+abar;
+abas;
+abat;
+abau;
+abav;
+abaw;
+abax;
+abay;
+abaz;
+abba;
+abbb;
+abbc;
+abbd;
+abbe;
+abbf;
+abbg;
+abbh;
+abbi;
+abbj;
+abbk;
+abbl;
+abbm;
+abbn;
+abbo;
+abbp;
+abbq;
+abbr;
+abbs;
+abbt;
+abbu;
+abbv;
+abbw;
+abbx;
+abby;
+abbz;
+abca;
+abcb;
+abcc;
+abcd;
+abce;
+abcf;
+abcg;
+abch;
+abci;
+abcj;
+abck;
+abcl;
+abcm;
+abcn;
+abco;
+abcp;
+abcq;
+abcr;
+abcs;
+abct;
+abcu;
+abcv;
+abcw;
+abcx;
+abcy;
+abcz;
+abda;
+abdb;
+abdc;
+abdd;
+abde;
+abdf;
+abdg;
+abdh;
+abdi;
+abdj;
+abdk;
+abdl;
+abdm;
+abdn;
+abdo;
+abdp;
+abdq;
+abdr;
+abds;
+abdt;
+abdu;
+abdv;
+abdw;
+abdx;
+abdy;
+abdz;
+abea;
+abeb;
+abec;
+abed;
+abee;
+abef;
+abeg;
+abeh;
+abei;
+abej;
+abek;
+abel;
+abem;
+aben;
+abeo;
+abep;
+abeq;
+aber;
+abes;
+abet;
+abeu;
+abev;
+abew;
+abex;
+abey;
+abez;
+abfa;
+abfb;
+abfc;
+abfd;
+abfe;
+abff;
+abfg;
+abfh;
+abfi;
+abfj;
+abfk;
+abfl;
+abfm;
+abfn;
+abfo;
+abfp;
+abfq;
+abfr;
+abfs;
+abft;
+abfu;
+abfv;
+abfw;
+abfx;
+abfy;
+abfz;
+abga;
+abgb;
+abgc;
+abgd;
+abge;
+abgf;
+abgg;
+abgh;
+abgi;
+abgj;
+abgk;
+abgl;
+abgm;
+abgn;
+abgo;
+abgp;
+abgq;
+abgr;
+abgs;
+abgt;
+abgu;
+abgv;
+abgw;
+abgx;
+abgy;
+abgz;
+abha;
+abhb;
+abhc;
+abhd;
+abhe;
+abhf;
+abhg;
+abhh;
+abhi;
+abhj;
+abhk;
+abhl;
+abhm;
+abhn;
+abho;
+abhp;
+abhq;
+abhr;
+abhs;
+abht;
+abhu;
+abhv;
+abhw;
+abhx;
+abhy;
+abhz;
+abia;
+abib;
+abic;
+abid;
+abie;
+abif;
+abig;
+abih;
+abii;
+abij;
+abik;
+abil;
+abim;
+abin;
+abio;
+abip;
+abiq;
+abir;
+abis;
+abit;
+abiu;
+abiv;
+abiw;
+abix;
+abiy;
+abiz;
+abja;
+abjb;
+abjc;
+abjd;
+abje;
+abjf;
+abjg;
+abjh;
+abji;
+abjj;
+abjk;
+abjl;
+abjm;
+abjn;
+abjo;
+abjp;
+abjq;
+abjr;
+abjs;
+abjt;
+abju;
+abjv;
+abjw;
+abjx;
+abjy;
+abjz;
+abka;
+abkb;
+abkc;
+abkd;
+abke;
+abkf;
+abkg;
+abkh;
+abki;
+abkj;
+abkk;
+abkl;
+abkm;
+abkn;
+abko;
+abkp;
+abkq;
+abkr;
+abks;
+abkt;
+abku;
+abkv;
+abkw;
+abkx;
+abky;
+abkz;
+abla;
+ablb;
+ablc;
+abld;
+able;
+ablf;
+ablg;
+ablh;
+abli;
+ablj;
+ablk;
+abll;
+ablm;
+abln;
+ablo;
+ablp;
+ablq;
+ablr;
+abls;
+ablt;
+ablu;
+ablv;
+ablw;
+ablx;
+ably;
+ablz;
+abma;
+abmb;
+abmc;
+abmd;
+abme;
+abmf;
+abmg;
+abmh;
+abmi;
+abmj;
+abmk;
+abml;
+abmm;
+abmn;
+abmo;
+abmp;
+abmq;
+abmr;
+abms;
+abmt;
+abmu;
+abmv;
+abmw;
+abmx;
+abmy;
+abmz;
+abna;
+abnb;
+abnc;
+abnd;
+abne;
+abnf;
+abng;
+abnh;
+abni;
+abnj;
+abnk;
+abnl;
+abnm;
+abnn;
+abno;
+abnp;
+abnq;
+abnr;
+abns;
+abnt;
+abnu;
+abnv;
+abnw;
+abnx;
+abny;
+abnz;
+aboa;
+abob;
+aboc;
+abod;
+aboe;
+abof;
+abog;
+aboh;
+aboi;
+aboj;
+abok;
+abol;
+abom;
+abon;
+aboo;
+abop;
+aboq;
+abor;
+abos;
+abot;
+abou;
+abov;
+abow;
+abox;
+aboy;
+aboz;
+abpa;
+abpb;
+abpc;
+abpd;
+abpe;
+abpf;
+abpg;
+abph;
+abpi;
+abpj;
+abpk;
+abpl;
+abpm;
+abpn;
+abpo;
+abpp;
+abpq;
+abpr;
+abps;
+abpt;
+abpu;
+abpv;
+abpw;
+abpx;
+abpy;
+abpz;
+abqa;
+abqb;
+abqc;
+abqd;
+abqe;
+abqf;
+abqg;
+abqh;
+abqi;
+abqj;
+abqk;
+abql;
+abqm;
+abqn;
+abqo;
+abqp;
+abqq;
+abqr;
+abqs;
+abqt;
+abqu;
+abqv;
+abqw;
+abqx;
+abqy;
+abqz;
+abra;
+abrb;
+abrc;
+abrd;
+abre;
+abrf;
+abrg;
+abrh;
+abri;
+abrj;
+abrk;
+abrl;
+abrm;
+abrn;
+abro;
+abrp;
+abrq;
+abrr;
+abrs;
+abrt;
+abru;
+abrv;
+abrw;
+abrx;
+abry;
+abrz;
+absa;
+absb;
+absc;
+absd;
+abse;
+absf;
+absg;
+absh;
+absi;
+absj;
+absk;
+absl;
+absm;
+absn;
+abso;
+absp;
+absq;
+absr;
+abss;
+abst;
+absu;
+absv;
+absw;
+absx;
+absy;
+absz;
+abta;
+abtb;
+abtc;
+abtd;
+abte;
+abtf;
+abtg;
+abth;
+abti;
+abtj;
+abtk;
+abtl;
+abtm;
+abtn;
+abto;
+abtp;
+abtq;
+abtr;
+abts;
+abtt;
+abtu;
+abtv;
+abtw;
+abtx;
+abty;
+abtz;
+abua;
+abub;
+abuc;
+abud;
+abue;
+abuf;
+abug;
+abuh;
+abui;
+abuj;
+abuk;
+abul;
+abum;
+abun;
+abuo;
+abup;
+abuq;
+abur;
+abus;
+abut;
+abuu;
+abuv;
+abuw;
+abux;
+abuy;
+abuz;
+abva;
+abvb;
+abvc;
+abvd;
+abve;
+abvf;
+abvg;
+abvh;
+abvi;
+abvj;
+abvk;
+abvl;
+abvm;
+abvn;
+abvo;
+abvp;
+abvq;
+abvr;
+abvs;
+abvt;
+abvu;
+abvv;
+abvw;
+abvx;
+abvy;
+abvz;
+abwa;
+abwb;
+abwc;
+abwd;
+abwe;
+abwf;
+abwg;
+abwh;
+abwi;
+abwj;
+abwk;
+abwl;
+abwm;
+abwn;
+abwo;
+abwp;
+abwq;
+abwr;
+abws;
+abwt;
+abwu;
+abwv;
+abww;
+abwx;
+abwy;
+abwz;
+abxa;
+abxb;
+abxc;
+abxd;
+abxe;
+abxf;
+abxg;
+abxh;
+abxi;
+abxj;
+abxk;
+abxl;
+abxm;
+abxn;
+abxo;
+abxp;
+abxq;
+abxr;
+abxs;
+abxt;
+abxu;
+abxv;
+abxw;
+abxx;
+abxy;
+abxz;
+abya;
+abyb;
+abyc;
+abyd;
+abye;
+abyf;
+abyg;
+abyh;
+abyi;
+abyj;
+abyk;
+abyl;
+abym;
+abyn;
+abyo;
+abyp;
+abyq;
+abyr;
+abys;
+abyt;
+abyu;
+abyv;
+abyw;
+abyx;
+abyy;
+abyz;
+abza;
+abzb;
+abzc;
+abzd;
+abze;
+abzf;
+abzg;
+abzh;
+abzi;
+abzj;
+abzk;
+abzl;
+abzm;
+abzn;
+abzo;
+abzp;
+abzq;
+abzr;
+abzs;
+abzt;
+abzu;
+abzv;
+abzw;
+abzx;
+abzy;
+abzz;
+acaa;
+acab;
+acac;
+acad;
+acae;
+acaf;
+acag;
+acah;
+acai;
+acaj;
+acak;
+acal;
+acam;
+acan;
+acao;
+acap;
+acaq;
+acar;
+acas;
+acat;
+acau;
+acav;
+acaw;
+acax;
+acay;
+acaz;
+acba;
+acbb;
+acbc;
+acbd;
+acbe;
+acbf;
+acbg;
+acbh;
+acbi;
+acbj;
+acbk;
+acbl;
+acbm;
+acbn;
+acbo;
+acbp;
+acbq;
+acbr;
+acbs;
+acbt;
+acbu;
+acbv;
+acbw;
+acbx;
+acby;
+acbz;
+acca;
+accb;
+accc;
+accd;
+acce;
+accf;
+accg;
+acch;
+acci;
+accj;
+acck;
+accl;
+accm;
+accn;
+acco;
+accp;
+accq;
+accr;
+accs;
+acct;
+accu;
+accv;
+accw;
+accx;
+accy;
+accz;
+acda;
+acdb;
+acdc;
+acdd;
+acde;
+acdf;
+acdg;
+acdh;
+acdi;
+acdj;
+acdk;
+acdl;
+acdm;
+acdn;
+acdo;
+acdp;
+acdq;
+acdr;
+acds;
+acdt;
+acdu;
+acdv;
+acdw;
+acdx;
+acdy;
+acdz;
+acea;
+aceb;
+acec;
+aced;
+acee;
+acef;
+aceg;
+aceh;
+acei;
+acej;
+acek;
+acel;
+acem;
+acen;
+aceo;
+acep;
+aceq;
+acer;
+aces;
+acet;
+aceu;
+acev;
+acew;
+acex;
+acey;
+acez;
+acfa;
+acfb;
+acfc;
+acfd;
+acfe;
+acff;
+acfg;
+acfh;
+acfi;
+acfj;
+acfk;
+acfl;
+acfm;
+acfn;
+acfo;
+acfp;
+acfq;
+acfr;
+acfs;
+acft;
+acfu;
+acfv;
+acfw;
+acfx;
+acfy;
+acfz;
+acga;
+acgb;
+acgc;
+acgd;
+acge;
+acgf;
+acgg;
+acgh;
+acgi;
+acgj;
+acgk;
+acgl;
+acgm;
+acgn;
+acgo;
+acgp;
+acgq;
+acgr;
+acgs;
+acgt;
+acgu;
+acgv;
+acgw;
+acgx;
+acgy;
+acgz;
+acha;
+achb;
+achc;
+achd;
+ache;
+achf;
+achg;
+achh;
+achi;
+achj;
+achk;
+achl;
+achm;
+achn;
+acho;
+achp;
+achq;
+achr;
+achs;
+acht;
+achu;
+achv;
+achw;
+achx;
+achy;
+achz;
+acia;
+acib;
+acic;
+acid;
+acie;
+acif;
+acig;
+acih;
+acii;
+acij;
+acik;
+acil;
+acim;
+acin;
+acio;
+acip;
+aciq;
+acir;
+acis;
+acit;
+aciu;
+aciv;
+aciw;
+acix;
+aciy;
+aciz;
+acja;
+acjb;
+acjc;
+acjd;
+acje;
+acjf;
+acjg;
+acjh;
+acji;
+acjj;
+acjk;
+acjl;
+acjm;
+acjn;
+acjo;
+acjp;
+acjq;
+acjr;
+acjs;
+acjt;
+acju;
+acjv;
+acjw;
+acjx;
+acjy;
+acjz;
+acka;
+ackb;
+ackc;
+ackd;
+acke;
+ackf;
+ackg;
+ackh;
+acki;
+ackj;
+ackk;
+ackl;
+ackm;
+ackn;
+acko;
+ackp;
+ackq;
+ackr;
+acks;
+ackt;
+acku;
+ackv;
+ackw;
+ackx;
+acky;
+ackz;
+acla;
+aclb;
+aclc;
+acld;
+acle;
+aclf;
+aclg;
+aclh;
+acli;
+aclj;
+aclk;
+acll;
+aclm;
+acln;
+aclo;
+aclp;
+aclq;
+aclr;
+acls;
+aclt;
+aclu;
+aclv;
+aclw;
+aclx;
+acly;
+aclz;
+acma;
+acmb;
+acmc;
+acmd;
+acme;
+acmf;
+acmg;
+acmh;
+acmi;
+acmj;
+acmk;
+acml;
+acmm;
+acmn;
+acmo;
+acmp;
+acmq;
+acmr;
+acms;
+acmt;
+acmu;
+acmv;
+acmw;
+acmx;
+acmy;
+acmz;
+acna;
+acnb;
+acnc;
+acnd;
+acne;
+acnf;
+acng;
+acnh;
+acni;
+acnj;
+acnk;
+acnl;
+acnm;
+acnn;
+acno;
+acnp;
+acnq;
+acnr;
+acns;
+acnt;
+acnu;
+acnv;
+acnw;
+acnx;
+acny;
+acnz;
+acoa;
+acob;
+acoc;
+acod;
+acoe;
+acof;
+acog;
+acoh;
+acoi;
+acoj;
+acok;
+acol;
+acom;
+acon;
+acoo;
+acop;
+acoq;
+acor;
+acos;
+acot;
+acou;
+acov;
+acow;
+acox;
+acoy;
+acoz;
+acpa;
+acpb;
+acpc;
+acpd;
+acpe;
+acpf;
+acpg;
+acph;
+acpi;
+acpj;
+acpk;
+acpl;
+acpm;
+acpn;
+acpo;
+acpp;
+acpq;
+acpr;
+acps;
+acpt;
+acpu;
+acpv;
+acpw;
+acpx;
+acpy;
+acpz;
+acqa;
+acqb;
+acqc;
+acqd;
+acqe;
+acqf;
+acqg;
+acqh;
+acqi;
+acqj;
+acqk;
+acql;
+acqm;
+acqn;
+acqo;
+acqp;
+acqq;
+acqr;
+acqs;
+acqt;
+acqu;
+acqv;
+acqw;
+acqx;
+acqy;
+acqz;
+acra;
+acrb;
+acrc;
+acrd;
+acre;
+acrf;
+acrg;
+acrh;
+acri;
+acrj;
+acrk;
+acrl;
+acrm;
+acrn;
+acro;
+acrp;
+acrq;
+acrr;
+acrs;
+acrt;
+acru;
+acrv;
+acrw;
+acrx;
+acry;
+acrz;
+acsa;
+acsb;
+acsc;
+acsd;
+acse;
+acsf;
+acsg;
+acsh;
+acsi;
+acsj;
+acsk;
+acsl;
+acsm;
+acsn;
+acso;
+acsp;
+acsq;
+acsr;
+acss;
+acst;
+acsu;
+acsv;
+acsw;
+acsx;
+acsy;
+acsz;
+acta;
+actb;
+actc;
+actd;
+acte;
+actf;
+actg;
+acth;
+acti;
+actj;
+actk;
+actl;
+actm;
+actn;
+acto;
+actp;
+actq;
+actr;
+acts;
+actt;
+actu;
+actv;
+actw;
+actx;
+acty;
+actz;
+acua;
+acub;
+acuc;
+acud;
+acue;
+acuf;
+acug;
+acuh;
+acui;
+acuj;
+acuk;
+acul;
+acum;
+acun;
+acuo;
+acup;
+acuq;
+acur;
+acus;
+acut;
+acuu;
+acuv;
+acuw;
+acux;
+acuy;
+acuz;
+acva;
+acvb;
+acvc;
+acvd;
+acve;
+acvf;
+acvg;
+acvh;
+acvi;
+acvj;
+acvk;
+acvl;
+acvm;
+acvn;
+acvo;
+acvp;
+acvq;
+acvr;
+acvs;
+acvt;
+acvu;
+acvv;
+acvw;
+acvx;
+acvy;
+acvz;
+acwa;
+acwb;
+acwc;
+acwd;
+acwe;
+acwf;
+acwg;
+acwh;
+acwi;
+acwj;
+acwk;
+acwl;
+acwm;
+acwn;
+acwo;
+acwp;
+acwq;
+acwr;
+acws;
+acwt;
+acwu;
+acwv;
+acww;
+acwx;
+acwy;
+acwz;
+acxa;
+acxb;
+acxc;
+acxd;
+acxe;
+acxf;
+acxg;
+acxh;
+acxi;
+acxj;
+acxk;
+acxl;
+acxm;
+acxn;
+acxo;
+acxp;
+acxq;
+acxr;
+acxs;
+acxt;
+acxu;
+acxv;
+acxw;
+acxx;
+acxy;
+acxz;
+acya;
+acyb;
+acyc;
+acyd;
+acye;
+acyf;
+acyg;
+acyh;
+acyi;
+acyj;
+acyk;
+acyl;
+acym;
+acyn;
+acyo;
+acyp;
+acyq;
+acyr;
+acys;
+acyt;
+acyu;
+acyv;
+acyw;
+acyx;
+acyy;
+acyz;
+acza;
+aczb;
+aczc;
+aczd;
+acze;
+aczf;
+aczg;
+aczh;
+aczi;
+aczj;
+aczk;
+aczl;
+aczm;
+aczn;
+aczo;
+aczp;
+aczq;
+aczr;
+aczs;
+aczt;
+aczu;
+aczv;
+aczw;
+aczx;
+aczy;
+aczz;
+adaa;
+adab;
+adac;
+adad;
+adae;
+adaf;
+adag;
+adah;
+adai;
+adaj;
+adak;
+adal;
+adam;
+adan;
+adao;
+adap;
+adaq;
+adar;
+adas;
+adat;
+adau;
+adav;
+adaw;
+adax;
+aday;
+adaz;
+adba;
+adbb;
+adbc;
+adbd;
+adbe;
+adbf;
+adbg;
+adbh;
+adbi;
+adbj;
+adbk;
+adbl;
+adbm;
+adbn;
+adbo;
+adbp;
+adbq;
+adbr;
+adbs;
+adbt;
+adbu;
+adbv;
+adbw;
+adbx;
+adby;
+adbz;
+adca;
+adcb;
+adcc;
+adcd;
+adce;
+adcf;
+adcg;
+adch;
+adci;
+adcj;
+adck;
+adcl;
+adcm;
+adcn;
+adco;
+adcp;
+adcq;
+adcr;
+adcs;
+adct;
+adcu;
+adcv;
+adcw;
+adcx;
+adcy;
+adcz;
+adda;
+addb;
+addc;
+addd;
+adde;
+addf;
+addg;
+addh;
+addi;
+addj;
+addk;
+addl;
+addm;
+addn;
+addo;
+addp;
+addq;
+addr;
+adds;
+addt;
+addu;
+addv;
+addw;
+addx;
+addy;
+addz;
+adea;
+adeb;
+adec;
+aded;
+adee;
+adef;
+adeg;
+adeh;
+adei;
+adej;
+adek;
+adel;
+adem;
+aden;
+adeo;
+adep;
+adeq;
+ader;
+ades;
+adet;
+adeu;
+adev;
+adew;
+adex;
+adey;
+adez;
+adfa;
+adfb;
+adfc;
+adfd;
+adfe;
+adff;
+adfg;
+adfh;
+adfi;
+adfj;
+adfk;
+adfl;
+adfm;
+adfn;
+adfo;
+adfp;
+adfq;
+adfr;
+adfs;
+adft;
+adfu;
+adfv;
+adfw;
+adfx;
+adfy;
+adfz;
+adga;
+adgb;
+adgc;
+adgd;
+adge;
+adgf;
+adgg;
+adgh;
+adgi;
+adgj;
+adgk;
+adgl;
+adgm;
+adgn;
+adgo;
+adgp;
+adgq;
+adgr;
+adgs;
+adgt;
+adgu;
+adgv;
+adgw;
+adgx;
+adgy;
+adgz;
+adha;
+adhb;
+adhc;
+adhd;
+adhe;
+adhf;
+adhg;
+adhh;
+adhi;
+adhj;
+adhk;
+adhl;
+adhm;
+adhn;
+adho;
+adhp;
+adhq;
+adhr;
+adhs;
+adht;
+adhu;
+adhv;
+adhw;
+adhx;
+adhy;
+adhz;
+adia;
+adib;
+adic;
+adid;
+adie;
+adif;
+adig;
+adih;
+adii;
+adij;
+adik;
+adil;
+adim;
+adin;
+adio;
+adip;
+adiq;
+adir;
+adis;
+adit;
+adiu;
+adiv;
+adiw;
+adix;
+adiy;
+adiz;
+adja;
+adjb;
+adjc;
+adjd;
+adje;
+adjf;
+adjg;
+adjh;
+adji;
+adjj;
+adjk;
+adjl;
+adjm;
+adjn;
+adjo;
+adjp;
+adjq;
+adjr;
+adjs;
+adjt;
+adju;
+adjv;
+adjw;
+adjx;
+adjy;
+adjz;
+adka;
+adkb;
+adkc;
+adkd;
+adke;
+adkf;
+adkg;
+adkh;
+adki;
+adkj;
+adkk;
+adkl;
+adkm;
+adkn;
+adko;
+adkp;
+adkq;
+adkr;
+adks;
+adkt;
+adku;
+adkv;
+adkw;
+adkx;
+adky;
+adkz;
+adla;
+adlb;
+adlc;
+adld;
+adle;
+adlf;
+adlg;
+adlh;
+adli;
+adlj;
+adlk;
+adll;
+adlm;
+adln;
+adlo;
+adlp;
+adlq;
+adlr;
+adls;
+adlt;
+adlu;
+adlv;
+adlw;
+adlx;
+adly;
+adlz;
+adma;
+admb;
+admc;
+admd;
+adme;
+admf;
+admg;
+admh;
+admi;
+admj;
+admk;
+adml;
+admm;
+admn;
+admo;
+admp;
+admq;
+admr;
+adms;
+admt;
+admu;
+admv;
+admw;
+admx;
+admy;
+admz;
+adna;
+adnb;
+adnc;
+adnd;
+adne;
+adnf;
+adng;
+adnh;
+adni;
+adnj;
+adnk;
+adnl;
+adnm;
+adnn;
+adno;
+adnp;
+adnq;
+adnr;
+adns;
+adnt;
+adnu;
+adnv;
+adnw;
+adnx;
+adny;
+adnz;
+adoa;
+adob;
+adoc;
+adod;
+adoe;
+adof;
+adog;
+adoh;
+adoi;
+adoj;
+adok;
+adol;
+adom;
+adon;
+adoo;
+adop;
+adoq;
+ador;
+ados;
+adot;
+adou;
+adov;
+adow;
+adox;
+adoy;
+adoz;
+adpa;
+adpb;
+adpc;
+adpd;
+adpe;
+adpf;
+adpg;
+adph;
+adpi;
+adpj;
+adpk;
+adpl;
+adpm;
+adpn;
+adpo;
+adpp;
+adpq;
+adpr;
+adps;
+adpt;
+adpu;
+adpv;
+adpw;
+adpx;
+adpy;
+adpz;
+adqa;
+adqb;
+adqc;
+adqd;
+adqe;
+adqf;
+adqg;
+adqh;
+adqi;
+adqj;
+adqk;
+adql;
+adqm;
+adqn;
+adqo;
+adqp;
+adqq;
+adqr;
+adqs;
+adqt;
+adqu;
+adqv;
+adqw;
+adqx;
+adqy;
+adqz;
+adra;
+adrb;
+adrc;
+adrd;
+adre;
+adrf;
+adrg;
+adrh;
+adri;
+adrj;
+adrk;
+adrl;
+adrm;
+adrn;
+adro;
+adrp;
+adrq;
+adrr;
+adrs;
+adrt;
+adru;
+adrv;
+adrw;
+adrx;
+adry;
+adrz;
+adsa;
+adsb;
+adsc;
+adsd;
+adse;
+adsf;
+adsg;
+adsh;
+adsi;
+adsj;
+adsk;
+adsl;
+adsm;
+adsn;
+adso;
+adsp;
+adsq;
+adsr;
+adss;
+adst;
+adsu;
+adsv;
+adsw;
+adsx;
+adsy;
+adsz;
+adta;
+adtb;
+adtc;
+adtd;
+adte;
+adtf;
+adtg;
+adth;
+adti;
+adtj;
+adtk;
+adtl;
+adtm;
+adtn;
+adto;
+adtp;
+adtq;
+adtr;
+adts;
+adtt;
+adtu;
+adtv;
+adtw;
+adtx;
+adty;
+adtz;
+adua;
+adub;
+aduc;
+adud;
+adue;
+aduf;
+adug;
+aduh;
+adui;
+aduj;
+aduk;
+adul;
+adum;
+adun;
+aduo;
+adup;
+aduq;
+adur;
+adus;
+adut;
+aduu;
+aduv;
+aduw;
+adux;
+aduy;
+aduz;
+adva;
+advb;
+advc;
+advd;
+adve;
+advf;
+advg;
+advh;
+advi;
+advj;
+advk;
+advl;
+advm;
+advn;
+advo;
+advp;
+advq;
+advr;
+advs;
+advt;
+advu;
+advv;
+advw;
+advx;
+advy;
+advz;
+adwa;
+adwb;
+adwc;
+adwd;
+adwe;
+adwf;
+adwg;
+adwh;
+adwi;
+adwj;
+adwk;
+adwl;
+adwm;
+adwn;
+adwo;
+adwp;
+adwq;
+adwr;
+adws;
+adwt;
+adwu;
+adwv;
+adww;
+adwx;
+adwy;
+adwz;
+adxa;
+adxb;
+adxc;
+adxd;
+adxe;
+adxf;
+adxg;
+adxh;
+adxi;
+adxj;
+adxk;
+adxl;
+adxm;
+adxn;
+adxo;
+adxp;
+adxq;
+adxr;
+adxs;
+adxt;
+adxu;
+adxv;
+adxw;
+adxx;
+adxy;
+adxz;
+adya;
+adyb;
+adyc;
+adyd;
+adye;
+adyf;
+adyg;
+adyh;
+adyi;
+adyj;
+adyk;
+adyl;
+adym;
+adyn;
+adyo;
+adyp;
+adyq;
+adyr;
+adys;
+adyt;
+adyu;
+adyv;
+adyw;
+adyx;
+adyy;
+adyz;
+adza;
+adzb;
+adzc;
+adzd;
+adze;
+adzf;
+adzg;
+adzh;
+adzi;
+adzj;
+adzk;
+adzl;
+adzm;
+adzn;
+adzo;
+adzp;
+adzq;
+adzr;
+adzs;
+adzt;
+adzu;
+adzv;
+adzw;
+adzx;
+adzy;
+adzz;
+aeaa;
+aeab;
+aeac;
+aead;
+aeae;
+aeaf;
+aeag;
+aeah;
+aeai;
+aeaj;
+aeak;
+aeal;
+aeam;
+aean;
+aeao;
+aeap;
+aeaq;
+aear;
+aeas;
+aeat;
+aeau;
+aeav;
+aeaw;
+aeax;
+aeay;
+aeaz;
+aeba;
+aebb;
+aebc;
+aebd;
+aebe;
+aebf;
+aebg;
+aebh;
+aebi;
+aebj;
+aebk;
+aebl;
+aebm;
+aebn;
+aebo;
+aebp;
+aebq;
+aebr;
+aebs;
+aebt;
+aebu;
+aebv;
+aebw;
+aebx;
+aeby;
+aebz;
+aeca;
+aecb;
+aecc;
+aecd;
+aece;
+aecf;
+aecg;
+aech;
+aeci;
+aecj;
+aeck;
+aecl;
+aecm;
+aecn;
+aeco;
+aecp;
+aecq;
+aecr;
+aecs;
+aect;
+aecu;
+aecv;
+aecw;
+aecx;
+aecy;
+aecz;
+aeda;
+aedb;
+aedc;
+aedd;
+aede;
+aedf;
+aedg;
+aedh;
+aedi;
+aedj;
+aedk;
+aedl;
+aedm;
+aedn;
+aedo;
+aedp;
+aedq;
+aedr;
+aeds;
+aedt;
+aedu;
+aedv;
+aedw;
+aedx;
+aedy;
+aedz;
+aeea;
+aeeb;
+aeec;
+aeed;
+aeee;
+aeef;
+aeeg;
+aeeh;
+aeei;
+aeej;
+aeek;
+aeel;
+aeem;
+aeen;
+aeeo;
+aeep;
+aeeq;
+aeer;
+aees;
+aeet;
+aeeu;
+aeev;
+aeew;
+aeex;
+aeey;
+aeez;
+aefa;
+aefb;
+aefc;
+aefd;
+aefe;
+aeff;
+aefg;
+aefh;
+aefi;
+aefj;
+aefk;
+aefl;
+aefm;
+aefn;
+aefo;
+aefp;
+aefq;
+aefr;
+aefs;
+aeft;
+aefu;
+aefv;
+aefw;
+aefx;
+aefy;
+aefz;
+aega;
+aegb;
+aegc;
+aegd;
+aege;
+aegf;
+aegg;
+aegh;
+aegi;
+aegj;
+aegk;
+aegl;
+aegm;
+aegn;
+aego;
+aegp;
+aegq;
+aegr;
+aegs;
+aegt;
+aegu;
+aegv;
+aegw;
+aegx;
+aegy;
+aegz;
+aeha;
+aehb;
+aehc;
+aehd;
+aehe;
+aehf;
+aehg;
+aehh;
+aehi;
+aehj;
+aehk;
+aehl;
+aehm;
+aehn;
+aeho;
+aehp;
+aehq;
+aehr;
+aehs;
+aeht;
+aehu;
+aehv;
+aehw;
+aehx;
+aehy;
+aehz;
+aeia;
+aeib;
+aeic;
+aeid;
+aeie;
+aeif;
+aeig;
+aeih;
+aeii;
+aeij;
+aeik;
+aeil;
+aeim;
+aein;
+aeio;
+aeip;
+aeiq;
+aeir;
+aeis;
+aeit;
+aeiu;
+aeiv;
+aeiw;
+aeix;
+aeiy;
+aeiz;
+aeja;
+aejb;
+aejc;
+aejd;
+aeje;
+aejf;
+aejg;
+aejh;
+aeji;
+aejj;
+aejk;
+aejl;
+aejm;
+aejn;
+aejo;
+aejp;
+aejq;
+aejr;
+aejs;
+aejt;
+aeju;
+aejv;
+aejw;
+aejx;
+aejy;
+aejz;
+aeka;
+aekb;
+aekc;
+aekd;
+aeke;
+aekf;
+aekg;
+aekh;
+aeki;
+aekj;
+aekk;
+aekl;
+aekm;
+aekn;
+aeko;
+aekp;
+aekq;
+aekr;
+aeks;
+aekt;
+aeku;
+aekv;
+aekw;
+aekx;
+aeky;
+aekz;
+aela;
+aelb;
+aelc;
+aeld;
+aele;
+aelf;
+aelg;
+aelh;
+aeli;
+aelj;
+aelk;
+aell;
+aelm;
+aeln;
+aelo;
+aelp;
+aelq;
+aelr;
+aels;
+aelt;
+aelu;
+aelv;
+aelw;
+aelx;
+aely;
+aelz;
+aema;
+aemb;
+aemc;
+aemd;
+aeme;
+aemf;
+aemg;
+aemh;
+aemi;
+aemj;
+aemk;
+aeml;
+aemm;
+aemn;
+aemo;
+aemp;
+aemq;
+aemr;
+aems;
+aemt;
+aemu;
+aemv;
+aemw;
+aemx;
+aemy;
+aemz;
+aena;
+aenb;
+aenc;
+aend;
+aene;
+aenf;
+aeng;
+aenh;
+aeni;
+aenj;
+aenk;
+aenl;
+aenm;
+aenn;
+aeno;
+aenp;
+aenq;
+aenr;
+aens;
+aent;
+aenu;
+aenv;
+aenw;
+aenx;
+aeny;
+aenz;
+aeoa;
+aeob;
+aeoc;
+aeod;
+aeoe;
+aeof;
+aeog;
+aeoh;
+aeoi;
+aeoj;
+aeok;
+aeol;
+aeom;
+aeon;
+aeoo;
+aeop;
+aeoq;
+aeor;
+aeos;
+aeot;
+aeou;
+aeov;
+aeow;
+aeox;
+aeoy;
+aeoz;
+aepa;
+aepb;
+aepc;
+aepd;
+aepe;
+aepf;
+aepg;
+aeph;
+aepi;
+aepj;
+aepk;
+aepl;
+aepm;
+aepn;
+aepo;
+aepp;
+aepq;
+aepr;
+aeps;
+aept;
+aepu;
+aepv;
+aepw;
+aepx;
+aepy;
+aepz;
+aeqa;
+aeqb;
+aeqc;
+aeqd;
+aeqe;
+aeqf;
+aeqg;
+aeqh;
+aeqi;
+aeqj;
+aeqk;
+aeql;
+aeqm;
+aeqn;
+aeqo;
+aeqp;
+aeqq;
+aeqr;
+aeqs;
+aeqt;
+aequ;
+aeqv;
+aeqw;
+aeqx;
+aeqy;
+aeqz;
+aera;
+aerb;
+aerc;
+aerd;
+aere;
+aerf;
+aerg;
+aerh;
+aeri;
+aerj;
+aerk;
+aerl;
+aerm;
+aern;
+aero;
+aerp;
+aerq;
+aerr;
+aers;
+aert;
+aeru;
+aerv;
+aerw;
+aerx;
+aery;
+aerz;
+aesa;
+aesb;
+aesc;
+aesd;
+aese;
+aesf;
+aesg;
+aesh;
+aesi;
+aesj;
+aesk;
+aesl;
+aesm;
+aesn;
+aeso;
+aesp;
+aesq;
+aesr;
+aess;
+aest;
+aesu;
+aesv;
+aesw;
+aesx;
+aesy;
+aesz;
+aeta;
+aetb;
+aetc;
+aetd;
+aete;
+aetf;
+aetg;
+aeth;
+aeti;
+aetj;
+aetk;
+aetl;
+aetm;
+aetn;
+aeto;
+aetp;
+aetq;
+aetr;
+aets;
+aett;
+aetu;
+aetv;
+aetw;
+aetx;
+aety;
+aetz;
+aeua;
+aeub;
+aeuc;
+aeud;
+aeue;
+aeuf;
+aeug;
+aeuh;
+aeui;
+aeuj;
+aeuk;
+aeul;
+aeum;
+aeun;
+aeuo;
+aeup;
+aeuq;
+aeur;
+aeus;
+aeut;
+aeuu;
+aeuv;
+aeuw;
+aeux;
+aeuy;
+aeuz;
+aeva;
+aevb;
+aevc;
+aevd;
+aeve;
+aevf;
+aevg;
+aevh;
+aevi;
+aevj;
+aevk;
+aevl;
+aevm;
+aevn;
+aevo;
+aevp;
+aevq;
+aevr;
+aevs;
+aevt;
+aevu;
+aevv;
+aevw;
+aevx;
+aevy;
+aevz;
+aewa;
+aewb;
+aewc;
+aewd;
+aewe;
+aewf;
+aewg;
+aewh;
+aewi;
+aewj;
+aewk;
+aewl;
+aewm;
+aewn;
+aewo;
+aewp;
+aewq;
+aewr;
+aews;
+aewt;
+aewu;
+aewv;
+aeww;
+aewx;
+aewy;
+aewz;
+aexa;
+aexb;
+aexc;
+aexd;
+aexe;
+aexf;
+aexg;
+aexh;
+aexi;
+aexj;
+aexk;
+aexl;
+aexm;
+aexn;
+aexo;
+aexp;
+aexq;
+aexr;
+aexs;
+aext;
+aexu;
+aexv;
+aexw;
+aexx;
+aexy;
+aexz;
+aeya;
+aeyb;
+aeyc;
+aeyd;
+aeye;
+aeyf;
+aeyg;
+aeyh;
+aeyi;
+aeyj;
+aeyk;
+aeyl;
+aeym;
+aeyn;
+aeyo;
+aeyp;
+aeyq;
+aeyr;
+aeys;
+aeyt;
+aeyu;
+aeyv;
+aeyw;
+aeyx;
+aeyy;
+aeyz;
+aeza;
+aezb;
+aezc;
+aezd;
+aeze;
+aezf;
+aezg;
+aezh;
+aezi;
+aezj;
+aezk;
+aezl;
+aezm;
+aezn;
+aezo;
+aezp;
+aezq;
+aezr;
+aezs;
+aezt;
+aezu;
+aezv;
+aezw;
+aezx;
+aezy;
+aezz;
+afaa;
+afab;
+afac;
+afad;
+afae;
+afaf;
+afag;
+afah;
+afai;
+afaj;
+afak;
+afal;
+afam;
+afan;
+afao;
+afap;
+afaq;
+afar;
+afas;
+afat;
+afau;
+afav;
+afaw;
+afax;
+afay;
+afaz;
+afba;
+afbb;
+afbc;
+afbd;
+afbe;
+afbf;
+afbg;
+afbh;
+afbi;
+afbj;
+afbk;
+afbl;
+afbm;
+afbn;
+afbo;
+afbp;
+afbq;
+afbr;
+afbs;
+afbt;
+afbu;
+afbv;
+afbw;
+afbx;
+afby;
+afbz;
+afca;
+afcb;
+afcc;
+afcd;
+afce;
+afcf;
+afcg;
+afch;
+afci;
+afcj;
+afck;
+afcl;
+afcm;
+afcn;
+afco;
+afcp;
+afcq;
+afcr;
+afcs;
+afct;
+afcu;
+afcv;
+afcw;
+afcx;
+afcy;
+afcz;
+afda;
+afdb;
+afdc;
+afdd;
+afde;
+afdf;
+afdg;
+afdh;
+afdi;
+afdj;
+afdk;
+afdl;
+afdm;
+afdn;
+afdo;
+afdp;
+afdq;
+afdr;
+afds;
+afdt;
+afdu;
+afdv;
+afdw;
+afdx;
+afdy;
+afdz;
+afea;
+afeb;
+afec;
+afed;
+afee;
+afef;
+afeg;
+afeh;
+afei;
+afej;
+afek;
+afel;
+afem;
+afen;
+afeo;
+afep;
+afeq;
+afer;
+afes;
+afet;
+afeu;
+afev;
+afew;
+afex;
+afey;
+afez;
+affa;
+affb;
+affc;
+affd;
+affe;
+afff;
+affg;
+affh;
+affi;
+affj;
+affk;
+affl;
+affm;
+affn;
+affo;
+affp;
+affq;
+affr;
+affs;
+afft;
+affu;
+affv;
+affw;
+affx;
+affy;
+affz;
+afga;
+afgb;
+afgc;
+afgd;
+afge;
+afgf;
+afgg;
+afgh;
+afgi;
+afgj;
+afgk;
+afgl;
+afgm;
+afgn;
+afgo;
+afgp;
+afgq;
+afgr;
+afgs;
+afgt;
+afgu;
+afgv;
+afgw;
+afgx;
+afgy;
+afgz;
+afha;
+afhb;
+afhc;
+afhd;
+afhe;
+afhf;
+afhg;
+afhh;
+afhi;
+afhj;
+afhk;
+afhl;
+afhm;
+afhn;
+afho;
+afhp;
+afhq;
+afhr;
+afhs;
+afht;
+afhu;
+afhv;
+afhw;
+afhx;
+afhy;
+afhz;
+afia;
+afib;
+afic;
+afid;
+afie;
+afif;
+afig;
+afih;
+afii;
+afij;
+afik;
+afil;
+afim;
+afin;
+afio;
+afip;
+afiq;
+afir;
+afis;
+afit;
+afiu;
+afiv;
+afiw;
+afix;
+afiy;
+afiz;
+afja;
+afjb;
+afjc;
+afjd;
+afje;
+afjf;
+afjg;
+afjh;
+afji;
+afjj;
+afjk;
+afjl;
+afjm;
+afjn;
+afjo;
+afjp;
+afjq;
+afjr;
+afjs;
+afjt;
+afju;
+afjv;
+afjw;
+afjx;
+afjy;
+afjz;
+afka;
+afkb;
+afkc;
+afkd;
+afke;
+afkf;
+afkg;
+afkh;
+afki;
+afkj;
+afkk;
+afkl;
+afkm;
+afkn;
+afko;
+afkp;
+afkq;
+afkr;
+afks;
+afkt;
+afku;
+afkv;
+afkw;
+afkx;
+afky;
+afkz;
+afla;
+aflb;
+aflc;
+afld;
+afle;
+aflf;
+aflg;
+aflh;
+afli;
+aflj;
+aflk;
+afll;
+aflm;
+afln;
+aflo;
+aflp;
+aflq;
+aflr;
+afls;
+aflt;
+aflu;
+aflv;
+aflw;
+aflx;
+afly;
+aflz;
+afma;
+afmb;
+afmc;
+afmd;
+afme;
+afmf;
+afmg;
+afmh;
+afmi;
+afmj;
+afmk;
+afml;
+afmm;
+afmn;
+afmo;
+afmp;
+afmq;
+afmr;
+afms;
+afmt;
+afmu;
+afmv;
+afmw;
+afmx;
+afmy;
+afmz;
+afna;
+afnb;
+afnc;
+afnd;
+afne;
+afnf;
+afng;
+afnh;
+afni;
+afnj;
+afnk;
+afnl;
+afnm;
+afnn;
+afno;
+afnp;
+afnq;
+afnr;
+afns;
+afnt;
+afnu;
+afnv;
+afnw;
+afnx;
+afny;
+afnz;
+afoa;
+afob;
+afoc;
+afod;
+afoe;
+afof;
+afog;
+afoh;
+afoi;
+afoj;
+afok;
+afol;
+afom;
+afon;
+afoo;
+afop;
+afoq;
+afor;
+afos;
+afot;
+afou;
+afov;
+afow;
+afox;
+afoy;
+afoz;
+afpa;
+afpb;
+afpc;
+afpd;
+afpe;
+afpf;
+afpg;
+afph;
+afpi;
+afpj;
+afpk;
+afpl;
+afpm;
+afpn;
+afpo;
+afpp;
+afpq;
+afpr;
+afps;
+afpt;
+afpu;
+afpv;
+afpw;
+afpx;
+afpy;
+afpz;
+afqa;
+afqb;
+afqc;
+afqd;
+afqe;
+afqf;
+afqg;
+afqh;
+afqi;
+afqj;
+afqk;
+afql;
+afqm;
+afqn;
+afqo;
+afqp;
+afqq;
+afqr;
+afqs;
+afqt;
+afqu;
+afqv;
+afqw;
+afqx;
+afqy;
+afqz;
+afra;
+afrb;
+afrc;
+afrd;
+afre;
+afrf;
+afrg;
+afrh;
+afri;
+afrj;
+afrk;
+afrl;
+afrm;
+afrn;
+afro;
+afrp;
+afrq;
+afrr;
+afrs;
+afrt;
+afru;
+afrv;
+afrw;
+afrx;
+afry;
+afrz;
+afsa;
+afsb;
+afsc;
+afsd;
+afse;
+afsf;
+afsg;
+afsh;
+afsi;
+afsj;
+afsk;
+afsl;
+afsm;
+afsn;
+afso;
+afsp;
+afsq;
+afsr;
+afss;
+afst;
+afsu;
+afsv;
+afsw;
+afsx;
+afsy;
+afsz;
+afta;
+aftb;
+aftc;
+aftd;
+afte;
+aftf;
+aftg;
+afth;
+afti;
+aftj;
+aftk;
+aftl;
+aftm;
+aftn;
+afto;
+aftp;
+aftq;
+aftr;
+afts;
+aftt;
+aftu;
+aftv;
+aftw;
+aftx;
+afty;
+aftz;
+afua;
+afub;
+afuc;
+afud;
+afue;
+afuf;
+afug;
+afuh;
+afui;
+afuj;
+afuk;
+aful;
+afum;
+afun;
+afuo;
+afup;
+afuq;
+afur;
+afus;
+afut;
+afuu;
+afuv;
+afuw;
+afux;
+afuy;
+afuz;
+afva;
+afvb;
+afvc;
+afvd;
+afve;
+afvf;
+afvg;
+afvh;
+afvi;
+afvj;
+afvk;
+afvl;
+afvm;
+afvn;
+afvo;
+afvp;
+afvq;
+afvr;
+afvs;
+afvt;
+afvu;
+afvv;
+afvw;
+afvx;
+afvy;
+afvz;
+afwa;
+afwb;
+afwc;
+afwd;
+afwe;
+afwf;
+afwg;
+afwh;
+afwi;
+afwj;
+afwk;
+afwl;
+afwm;
+afwn;
+afwo;
+afwp;
+afwq;
+afwr;
+afws;
+afwt;
+afwu;
+afwv;
+afww;
+afwx;
+afwy;
+afwz;
+afxa;
+afxb;
+afxc;
+afxd;
+afxe;
+afxf;
+afxg;
+afxh;
+afxi;
+afxj;
+afxk;
+afxl;
+afxm;
+afxn;
+afxo;
+afxp;
+afxq;
+afxr;
+afxs;
+afxt;
+afxu;
+afxv;
+afxw;
+afxx;
+afxy;
+afxz;
+afya;
+afyb;
+afyc;
+afyd;
+afye;
+afyf;
+afyg;
+afyh;
+afyi;
+afyj;
+afyk;
+afyl;
+afym;
+afyn;
+afyo;
+afyp;
+afyq;
+afyr;
+afys;
+afyt;
+afyu;
+afyv;
+afyw;
+afyx;
+afyy;
+afyz;
+afza;
+afzb;
+afzc;
+afzd;
+afze;
+afzf;
+afzg;
+afzh;
+afzi;
+afzj;
+afzk;
+afzl;
+afzm;
+afzn;
+afzo;
+afzp;
+afzq;
+afzr;
+afzs;
+afzt;
+afzu;
+afzv;
+afzw;
+afzx;
+afzy;
+afzz;
+agaa;
+agab;
+agac;
+agad;
+agae;
+agaf;
+agag;
+agah;
+agai;
+agaj;
+agak;
+agal;
+agam;
+agan;
+agao;
+agap;
+agaq;
+agar;
+agas;
+agat;
+agau;
+agav;
+agaw;
+agax;
+agay;
+agaz;
+agba;
+agbb;
+agbc;
+agbd;
+agbe;
+agbf;
+agbg;
+agbh;
+agbi;
+agbj;
+agbk;
+agbl;
+agbm;
+agbn;
+agbo;
+agbp;
+agbq;
+agbr;
+agbs;
+agbt;
+agbu;
+agbv;
+agbw;
+agbx;
+agby;
+agbz;
+agca;
+agcb;
+agcc;
+agcd;
+agce;
+agcf;
+agcg;
+agch;
+agci;
+agcj;
+agck;
+agcl;
+agcm;
+agcn;
+agco;
+agcp;
+agcq;
+agcr;
+agcs;
+agct;
+agcu;
+agcv;
+agcw;
+agcx;
+agcy;
+agcz;
+agda;
+agdb;
+agdc;
+agdd;
+agde;
+agdf;
+agdg;
+agdh;
+agdi;
+agdj;
+agdk;
+agdl;
+agdm;
+agdn;
+agdo;
+agdp;
+agdq;
+agdr;
+agds;
+agdt;
+agdu;
+agdv;
+agdw;
+agdx;
+agdy;
+agdz;
+agea;
+ageb;
+agec;
+aged;
+agee;
+agef;
+ageg;
+ageh;
+agei;
+agej;
+agek;
+agel;
+agem;
+agen;
+ageo;
+agep;
+ageq;
+ager;
+ages;
+aget;
+ageu;
+agev;
+agew;
+agex;
+agey;
+agez;
+agfa;
+agfb;
+agfc;
+agfd;
+agfe;
+agff;
+agfg;
+agfh;
+agfi;
+agfj;
+agfk;
+agfl;
+agfm;
+agfn;
+agfo;
+agfp;
+agfq;
+agfr;
+agfs;
+agft;
+agfu;
+agfv;
+agfw;
+agfx;
+agfy;
+agfz;
+agga;
+aggb;
+aggc;
+aggd;
+agge;
+aggf;
+aggg;
+aggh;
+aggi;
+aggj;
+aggk;
+aggl;
+aggm;
+aggn;
+aggo;
+aggp;
+aggq;
+aggr;
+aggs;
+aggt;
+aggu;
+aggv;
+aggw;
+aggx;
+aggy;
+aggz;
+agha;
+aghb;
+aghc;
+aghd;
+aghe;
+aghf;
+aghg;
+aghh;
+aghi;
+aghj;
+aghk;
+aghl;
+aghm;
+aghn;
+agho;
+aghp;
+aghq;
+aghr;
+aghs;
+aght;
+aghu;
+aghv;
+aghw;
+aghx;
+aghy;
+aghz;
+agia;
+agib;
+agic;
+agid;
+agie;
+agif;
+agig;
+agih;
+agii;
+agij;
+agik;
+agil;
+agim;
+agin;
+agio;
+agip;
+agiq;
+agir;
+agis;
+agit;
+agiu;
+agiv;
+agiw;
+agix;
+agiy;
+agiz;
+agja;
+agjb;
+agjc;
+agjd;
+agje;
+agjf;
+agjg;
+agjh;
+agji;
+agjj;
+agjk;
+agjl;
+agjm;
+agjn;
+agjo;
+agjp;
+agjq;
+agjr;
+agjs;
+agjt;
+agju;
+agjv;
+agjw;
+agjx;
+agjy;
+agjz;
+agka;
+agkb;
+agkc;
+agkd;
+agke;
+agkf;
+agkg;
+agkh;
+agki;
+agkj;
+agkk;
+agkl;
+agkm;
+agkn;
+agko;
+agkp;
+agkq;
+agkr;
+agks;
+agkt;
+agku;
+agkv;
+agkw;
+agkx;
+agky;
+agkz;
+agla;
+aglb;
+aglc;
+agld;
+agle;
+aglf;
+aglg;
+aglh;
+agli;
+aglj;
+aglk;
+agll;
+aglm;
+agln;
+aglo;
+aglp;
+aglq;
+aglr;
+agls;
+aglt;
+aglu;
+aglv;
+aglw;
+aglx;
+agly;
+aglz;
+agma;
+agmb;
+agmc;
+agmd;
+agme;
+agmf;
+agmg;
+agmh;
+agmi;
+agmj;
+agmk;
+agml;
+agmm;
+agmn;
+agmo;
+agmp;
+agmq;
+agmr;
+agms;
+agmt;
+agmu;
+agmv;
+agmw;
+agmx;
+agmy;
+agmz;
+agna;
+agnb;
+agnc;
+agnd;
+agne;
+agnf;
+agng;
+agnh;
+agni;
+agnj;
+agnk;
+agnl;
+agnm;
+agnn;
+agno;
+agnp;
+agnq;
+agnr;
+agns;
+agnt;
+agnu;
+agnv;
+agnw;
+agnx;
+agny;
+agnz;
+agoa;
+agob;
+agoc;
+agod;
+agoe;
+agof;
+agog;
+agoh;
+agoi;
+agoj;
+agok;
+agol;
+agom;
+agon;
+agoo;
+agop;
+agoq;
+agor;
+agos;
+agot;
+agou;
+agov;
+agow;
+agox;
+agoy;
+agoz;
+agpa;
+agpb;
+agpc;
+agpd;
+agpe;
+agpf;
+agpg;
+agph;
+agpi;
+agpj;
+agpk;
+agpl;
+agpm;
+agpn;
+agpo;
+agpp;
+agpq;
+agpr;
+agps;
+agpt;
+agpu;
+agpv;
+agpw;
+agpx;
+agpy;
+agpz;
+agqa;
+agqb;
+agqc;
+agqd;
+agqe;
+agqf;
+agqg;
+agqh;
+agqi;
+agqj;
+agqk;
+agql;
+agqm;
+agqn;
+agqo;
+agqp;
+agqq;
+agqr;
+agqs;
+agqt;
+agqu;
+agqv;
+agqw;
+agqx;
+agqy;
+agqz;
+agra;
+agrb;
+agrc;
+agrd;
+agre;
+agrf;
+agrg;
+agrh;
+agri;
+agrj;
+agrk;
+agrl;
+agrm;
+agrn;
+agro;
+agrp;
+agrq;
+agrr;
+agrs;
+agrt;
+agru;
+agrv;
+agrw;
+agrx;
+agry;
+agrz;
+agsa;
+agsb;
+agsc;
+agsd;
+agse;
+agsf;
+agsg;
+agsh;
+agsi;
+agsj;
+agsk;
+agsl;
+agsm;
+agsn;
+agso;
+agsp;
+agsq;
+agsr;
+agss;
+agst;
+agsu;
+agsv;
+agsw;
+agsx;
+agsy;
+agsz;
+agta;
+agtb;
+agtc;
+agtd;
+agte;
+agtf;
+agtg;
+agth;
+agti;
+agtj;
+agtk;
+agtl;
+agtm;
+agtn;
+agto;
+agtp;
+agtq;
+agtr;
+agts;
+agtt;
+agtu;
+agtv;
+agtw;
+agtx;
+agty;
+agtz;
+agua;
+agub;
+aguc;
+agud;
+ague;
+aguf;
+agug;
+aguh;
+agui;
+aguj;
+aguk;
+agul;
+agum;
+agun;
+aguo;
+agup;
+aguq;
+agur;
+agus;
+agut;
+aguu;
+aguv;
+aguw;
+agux;
+aguy;
+aguz;
+agva;
+agvb;
+agvc;
+agvd;
+agve;
+agvf;
+agvg;
+agvh;
+agvi;
+agvj;
+agvk;
+agvl;
+agvm;
+agvn;
+agvo;
+agvp;
+agvq;
+agvr;
+agvs;
+agvt;
+agvu;
+agvv;
+agvw;
+agvx;
+agvy;
+agvz;
+agwa;
+agwb;
+agwc;
+agwd;
+agwe;
+agwf;
+agwg;
+agwh;
+agwi;
+agwj;
+agwk;
+agwl;
+agwm;
+agwn;
+agwo;
+agwp;
+agwq;
+agwr;
+agws;
+agwt;
+agwu;
+agwv;
+agww;
+agwx;
+agwy;
+agwz;
+agxa;
+agxb;
+agxc;
+agxd;
+agxe;
+agxf;
+agxg;
+agxh;
+agxi;
+agxj;
+agxk;
+agxl;
+agxm;
+agxn;
+agxo;
+agxp;
+agxq;
+agxr;
+agxs;
+agxt;
+agxu;
+agxv;
+agxw;
+agxx;
+agxy;
+agxz;
+agya;
+agyb;
+agyc;
+agyd;
+agye;
+agyf;
+agyg;
+agyh;
+agyi;
+agyj;
+agyk;
+agyl;
+agym;
+agyn;
+agyo;
+agyp;
+agyq;
+agyr;
+agys;
+agyt;
+agyu;
+agyv;
+agyw;
+agyx;
+agyy;
+agyz;
+agza;
+agzb;
+agzc;
+agzd;
+agze;
+agzf;
+agzg;
+agzh;
+agzi;
+agzj;
+agzk;
+agzl;
+agzm;
+agzn;
+agzo;
+agzp;
+agzq;
+agzr;
+agzs;
+agzt;
+agzu;
+agzv;
+agzw;
+agzx;
+agzy;
+agzz;
+ahaa;
+ahab;
+ahac;
+ahad;
+ahae;
+ahaf;
+ahag;
+ahah;
+ahai;
+ahaj;
+ahak;
+ahal;
+aham;
+ahan;
+ahao;
+ahap;
+ahaq;
+ahar;
+ahas;
+ahat;
+ahau;
+ahav;
+ahaw;
+ahax;
+ahay;
+ahaz;
+ahba;
+ahbb;
+ahbc;
+ahbd;
+ahbe;
+ahbf;
+ahbg;
+ahbh;
+ahbi;
+ahbj;
+ahbk;
+ahbl;
+ahbm;
+ahbn;
+ahbo;
+ahbp;
+ahbq;
+ahbr;
+ahbs;
+ahbt;
+ahbu;
+ahbv;
+ahbw;
+ahbx;
+ahby;
+ahbz;
+ahca;
+ahcb;
+ahcc;
+ahcd;
+ahce;
+ahcf;
+ahcg;
+ahch;
+ahci;
+ahcj;
+ahck;
+ahcl;
+ahcm;
+ahcn;
+ahco;
+ahcp;
+ahcq;
+ahcr;
+ahcs;
+ahct;
+ahcu;
+ahcv;
+ahcw;
+ahcx;
+ahcy;
+ahcz;
+ahda;
+ahdb;
+ahdc;
+ahdd;
+ahde;
+ahdf;
+ahdg;
+ahdh;
+ahdi;
+ahdj;
+ahdk;
+ahdl;
+ahdm;
+ahdn;
+ahdo;
+ahdp;
+ahdq;
+ahdr;
+ahds;
+ahdt;
+ahdu;
+ahdv;
+ahdw;
+ahdx;
+ahdy;
+ahdz;
+ahea;
+aheb;
+ahec;
+ahed;
+ahee;
+ahef;
+aheg;
+aheh;
+ahei;
+ahej;
+ahek;
+ahel;
+ahem;
+ahen;
+aheo;
+ahep;
+aheq;
+aher;
+ahes;
+ahet;
+aheu;
+ahev;
+ahew;
+ahex;
+ahey;
+ahez;
+ahfa;
+ahfb;
+ahfc;
+ahfd;
+ahfe;
+ahff;
+ahfg;
+ahfh;
+ahfi;
+ahfj;
+ahfk;
+ahfl;
+ahfm;
+ahfn;
+ahfo;
+ahfp;
+ahfq;
+ahfr;
+ahfs;
+ahft;
+ahfu;
+ahfv;
+ahfw;
+ahfx;
+ahfy;
+ahfz;
+ahga;
+ahgb;
+ahgc;
+ahgd;
+ahge;
+ahgf;
+ahgg;
+ahgh;
+ahgi;
+ahgj;
+ahgk;
+ahgl;
+ahgm;
+ahgn;
+ahgo;
+ahgp;
+ahgq;
+ahgr;
+ahgs;
+ahgt;
+ahgu;
+ahgv;
+ahgw;
+ahgx;
+ahgy;
+ahgz;
+ahha;
+ahhb;
+ahhc;
+ahhd;
+ahhe;
+ahhf;
+ahhg;
+ahhh;
+ahhi;
+ahhj;
+ahhk;
+ahhl;
+ahhm;
+ahhn;
+ahho;
+ahhp;
+ahhq;
+ahhr;
+ahhs;
+ahht;
+ahhu;
+ahhv;
+ahhw;
+ahhx;
+ahhy;
+ahhz;
+ahia;
+ahib;
+ahic;
+ahid;
+ahie;
+ahif;
+ahig;
+ahih;
+ahii;
+ahij;
+ahik;
+ahil;
+ahim;
+ahin;
+ahio;
+ahip;
+ahiq;
+ahir;
+ahis;
+ahit;
+ahiu;
+ahiv;
+ahiw;
+ahix;
+ahiy;
+ahiz;
+ahja;
+ahjb;
+ahjc;
+ahjd;
+ahje;
+ahjf;
+ahjg;
+ahjh;
+ahji;
+ahjj;
+ahjk;
+ahjl;
+ahjm;
+ahjn;
+ahjo;
+ahjp;
+ahjq;
+ahjr;
+ahjs;
+ahjt;
+ahju;
+ahjv;
+ahjw;
+ahjx;
+ahjy;
+ahjz;
+ahka;
+ahkb;
+ahkc;
+ahkd;
+ahke;
+ahkf;
+ahkg;
+ahkh;
+ahki;
+ahkj;
+ahkk;
+ahkl;
+ahkm;
+ahkn;
+ahko;
+ahkp;
+ahkq;
+ahkr;
+ahks;
+ahkt;
+ahku;
+ahkv;
+ahkw;
+ahkx;
+ahky;
+ahkz;
+ahla;
+ahlb;
+ahlc;
+ahld;
+ahle;
+ahlf;
+ahlg;
+ahlh;
+ahli;
+ahlj;
+ahlk;
+ahll;
+ahlm;
+ahln;
+ahlo;
+ahlp;
+ahlq;
+ahlr;
+ahls;
+ahlt;
+ahlu;
+ahlv;
+ahlw;
+ahlx;
+ahly;
+ahlz;
+ahma;
+ahmb;
+ahmc;
+ahmd;
+ahme;
+ahmf;
+ahmg;
+ahmh;
+ahmi;
+ahmj;
+ahmk;
+ahml;
+ahmm;
+ahmn;
+ahmo;
+ahmp;
+ahmq;
+ahmr;
+ahms;
+ahmt;
+ahmu;
+ahmv;
+ahmw;
+ahmx;
+ahmy;
+ahmz;
+ahna;
+ahnb;
+ahnc;
+ahnd;
+ahne;
+ahnf;
+ahng;
+ahnh;
+ahni;
+ahnj;
+ahnk;
+ahnl;
+ahnm;
+ahnn;
+ahno;
+ahnp;
+ahnq;
+ahnr;
+ahns;
+ahnt;
+ahnu;
+ahnv;
+ahnw;
+ahnx;
+ahny;
+ahnz;
+ahoa;
+ahob;
+ahoc;
+ahod;
+ahoe;
+ahof;
+ahog;
+ahoh;
+ahoi;
+ahoj;
+ahok;
+ahol;
+ahom;
+ahon;
+ahoo;
+ahop;
+ahoq;
+ahor;
+ahos;
+ahot;
+ahou;
+ahov;
+ahow;
+ahox;
+ahoy;
+ahoz;
+ahpa;
+ahpb;
+ahpc;
+ahpd;
+ahpe;
+ahpf;
+ahpg;
+ahph;
+ahpi;
+ahpj;
+ahpk;
+ahpl;
+ahpm;
+ahpn;
+ahpo;
+ahpp;
+ahpq;
+ahpr;
+ahps;
+ahpt;
+ahpu;
+ahpv;
+ahpw;
+ahpx;
+ahpy;
+ahpz;
+ahqa;
+ahqb;
+ahqc;
+ahqd;
+ahqe;
+ahqf;
+ahqg;
+ahqh;
+ahqi;
+ahqj;
+ahqk;
+ahql;
+ahqm;
+ahqn;
+ahqo;
+ahqp;
+ahqq;
+ahqr;
+ahqs;
+ahqt;
+ahqu;
+ahqv;
+ahqw;
+ahqx;
+ahqy;
+ahqz;
+ahra;
+ahrb;
+ahrc;
+ahrd;
+ahre;
+ahrf;
+ahrg;
+ahrh;
+ahri;
+ahrj;
+ahrk;
+ahrl;
+ahrm;
+ahrn;
+ahro;
+ahrp;
+ahrq;
+ahrr;
+ahrs;
+ahrt;
+ahru;
+ahrv;
+ahrw;
+ahrx;
+ahry;
+ahrz;
+ahsa;
+ahsb;
+ahsc;
+ahsd;
+ahse;
+ahsf;
+ahsg;
+ahsh;
+ahsi;
+ahsj;
+ahsk;
+ahsl;
+ahsm;
+ahsn;
+ahso;
+ahsp;
+ahsq;
+ahsr;
+ahss;
+ahst;
+ahsu;
+ahsv;
+ahsw;
+ahsx;
+ahsy;
+ahsz;
+ahta;
+ahtb;
+ahtc;
+ahtd;
+ahte;
+ahtf;
+ahtg;
+ahth;
+ahti;
+ahtj;
+ahtk;
+ahtl;
+ahtm;
+ahtn;
+ahto;
+ahtp;
+ahtq;
+ahtr;
+ahts;
+ahtt;
+ahtu;
+ahtv;
+ahtw;
+ahtx;
+ahty;
+ahtz;
+ahua;
+ahub;
+ahuc;
+ahud;
+ahue;
+ahuf;
+ahug;
+ahuh;
+ahui;
+ahuj;
+ahuk;
+ahul;
+ahum;
+ahun;
+ahuo;
+ahup;
+ahuq;
+ahur;
+ahus;
+ahut;
+ahuu;
+ahuv;
+ahuw;
+ahux;
+ahuy;
+ahuz;
+ahva;
+ahvb;
+ahvc;
+ahvd;
+ahve;
+ahvf;
+ahvg;
+ahvh;
+ahvi;
+ahvj;
+ahvk;
+ahvl;
+ahvm;
+ahvn;
+ahvo;
+ahvp;
+ahvq;
+ahvr;
+ahvs;
+ahvt;
+ahvu;
+ahvv;
+ahvw;
+ahvx;
+ahvy;
+ahvz;
+ahwa;
+ahwb;
+ahwc;
+ahwd;
+ahwe;
+ahwf;
+ahwg;
+ahwh;
+ahwi;
+ahwj;
+ahwk;
+ahwl;
+ahwm;
+ahwn;
+ahwo;
+ahwp;
+ahwq;
+ahwr;
+ahws;
+ahwt;
+ahwu;
+ahwv;
+ahww;
+ahwx;
+ahwy;
+ahwz;
+ahxa;
+ahxb;
+ahxc;
+ahxd;
+ahxe;
+ahxf;
+ahxg;
+ahxh;
+ahxi;
+ahxj;
+ahxk;
+ahxl;
+ahxm;
+ahxn;
+ahxo;
+ahxp;
+ahxq;
+ahxr;
+ahxs;
+ahxt;
+ahxu;
+ahxv;
+ahxw;
+ahxx;
+ahxy;
+ahxz;
+ahya;
+ahyb;
+ahyc;
+ahyd;
+ahye;
+ahyf;
+ahyg;
+ahyh;
+ahyi;
+ahyj;
+ahyk;
+ahyl;
+ahym;
+ahyn;
+ahyo;
+ahyp;
+ahyq;
+ahyr;
+ahys;
+ahyt;
+ahyu;
+ahyv;
+ahyw;
+ahyx;
+ahyy;
+ahyz;
+ahza;
+ahzb;
+ahzc;
+ahzd;
+ahze;
+ahzf;
+ahzg;
+ahzh;
+ahzi;
+ahzj;
+ahzk;
+ahzl;
+ahzm;
+ahzn;
+ahzo;
+ahzp;
+ahzq;
+ahzr;
+ahzs;
+ahzt;
+ahzu;
+ahzv;
+ahzw;
+ahzx;
+ahzy;
+ahzz;
+aiaa;
+aiab;
+aiac;
+aiad;
+aiae;
+aiaf;
+aiag;
+aiah;
+aiai;
+aiaj;
+aiak;
+aial;
+aiam;
+aian;
+aiao;
+aiap;
+aiaq;
+aiar;
+aias;
+aiat;
+aiau;
+aiav;
+aiaw;
+aiax;
+aiay;
+aiaz;
+aiba;
+aibb;
+aibc;
+aibd;
+aibe;
+aibf;
+aibg;
+aibh;
+aibi;
+aibj;
+aibk;
+aibl;
+aibm;
+aibn;
+aibo;
+aibp;
+aibq;
+aibr;
+aibs;
+aibt;
+aibu;
+aibv;
+aibw;
+aibx;
+aiby;
+aibz;
+aica;
+aicb;
+aicc;
+aicd;
+aice;
+aicf;
+aicg;
+aich;
+aici;
+aicj;
+aick;
+aicl;
+aicm;
+aicn;
+aico;
+aicp;
+aicq;
+aicr;
+aics;
+aict;
+aicu;
+aicv;
+aicw;
+aicx;
+aicy;
+aicz;
+aida;
+aidb;
+aidc;
+aidd;
+aide;
+aidf;
+aidg;
+aidh;
+aidi;
+aidj;
+aidk;
+aidl;
+aidm;
+aidn;
+aido;
+aidp;
+aidq;
+aidr;
+aids;
+aidt;
+aidu;
+aidv;
+aidw;
+aidx;
+aidy;
+aidz;
+aiea;
+aieb;
+aiec;
+aied;
+aiee;
+aief;
+aieg;
+aieh;
+aiei;
+aiej;
+aiek;
+aiel;
+aiem;
+aien;
+aieo;
+aiep;
+aieq;
+aier;
+aies;
+aiet;
+aieu;
+aiev;
+aiew;
+aiex;
+aiey;
+aiez;
+aifa;
+aifb;
+aifc;
+aifd;
+aife;
+aiff;
+aifg;
+aifh;
+aifi;
+aifj;
+aifk;
+aifl;
+aifm;
+aifn;
+aifo;
+aifp;
+aifq;
+aifr;
+aifs;
+aift;
+aifu;
+aifv;
+aifw;
+aifx;
+aify;
+aifz;
+aiga;
+aigb;
+aigc;
+aigd;
+aige;
+aigf;
+aigg;
+aigh;
+aigi;
+aigj;
+aigk;
+aigl;
+aigm;
+aign;
+aigo;
+aigp;
+aigq;
+aigr;
+aigs;
+aigt;
+aigu;
+aigv;
+aigw;
+aigx;
+aigy;
+aigz;
+aiha;
+aihb;
+aihc;
+aihd;
+aihe;
+aihf;
+aihg;
+aihh;
+aihi;
+aihj;
+aihk;
+aihl;
+aihm;
+aihn;
+aiho;
+aihp;
+aihq;
+aihr;
+aihs;
+aiht;
+aihu;
+aihv;
+aihw;
+aihx;
+aihy;
+aihz;
+aiia;
+aiib;
+aiic;
+aiid;
+aiie;
+aiif;
+aiig;
+aiih;
+aiii;
+aiij;
+aiik;
+aiil;
+aiim;
+aiin;
+aiio;
+aiip;
+aiiq;
+aiir;
+aiis;
+aiit;
+aiiu;
+aiiv;
+aiiw;
+aiix;
+aiiy;
+aiiz;
+aija;
+aijb;
+aijc;
+aijd;
+aije;
+aijf;
+aijg;
+aijh;
+aiji;
+aijj;
+aijk;
+aijl;
+aijm;
+aijn;
+aijo;
+aijp;
+aijq;
+aijr;
+aijs;
+aijt;
+aiju;
+aijv;
+aijw;
+aijx;
+aijy;
+aijz;
+aika;
+aikb;
+aikc;
+aikd;
+aike;
+aikf;
+aikg;
+aikh;
+aiki;
+aikj;
+aikk;
+aikl;
+aikm;
+aikn;
+aiko;
+aikp;
+aikq;
+aikr;
+aiks;
+aikt;
+aiku;
+aikv;
+aikw;
+aikx;
+aiky;
+aikz;
+aila;
+ailb;
+ailc;
+aild;
+aile;
+ailf;
+ailg;
+ailh;
+aili;
+ailj;
+ailk;
+aill;
+ailm;
+ailn;
+ailo;
+ailp;
+ailq;
+ailr;
+ails;
+ailt;
+ailu;
+ailv;
+ailw;
+ailx;
+aily;
+ailz;
+aima;
+aimb;
+aimc;
+aimd;
+aime;
+aimf;
+aimg;
+aimh;
+aimi;
+aimj;
+aimk;
+aiml;
+aimm;
+aimn;
+aimo;
+aimp;
+aimq;
+aimr;
+aims;
+aimt;
+aimu;
+aimv;
+aimw;
+aimx;
+aimy;
+aimz;
+aina;
+ainb;
+ainc;
+aind;
+aine;
+ainf;
+aing;
+ainh;
+aini;
+ainj;
+aink;
+ainl;
+ainm;
+ainn;
+aino;
+ainp;
+ainq;
+ainr;
+ains;
+aint;
+ainu;
+ainv;
+ainw;
+ainx;
+ainy;
+ainz;
+aioa;
+aiob;
+aioc;
+aiod;
+aioe;
+aiof;
+aiog;
+aioh;
+aioi;
+aioj;
+aiok;
+aiol;
+aiom;
+aion;
+aioo;
+aiop;
+aioq;
+aior;
+aios;
+aiot;
+aiou;
+aiov;
+aiow;
+aiox;
+aioy;
+aioz;
+aipa;
+aipb;
+aipc;
+aipd;
+aipe;
+aipf;
+aipg;
+aiph;
+aipi;
+aipj;
+aipk;
+aipl;
+aipm;
+aipn;
+aipo;
+aipp;
+aipq;
+aipr;
+aips;
+aipt;
+aipu;
+aipv;
+aipw;
+aipx;
+aipy;
+aipz;
+aiqa;
+aiqb;
+aiqc;
+aiqd;
+aiqe;
+aiqf;
+aiqg;
+aiqh;
+aiqi;
+aiqj;
+aiqk;
+aiql;
+aiqm;
+aiqn;
+aiqo;
+aiqp;
+aiqq;
+aiqr;
+aiqs;
+aiqt;
+aiqu;
+aiqv;
+aiqw;
+aiqx;
+aiqy;
+aiqz;
+aira;
+airb;
+airc;
+aird;
+aire;
+airf;
+airg;
+airh;
+airi;
+airj;
+airk;
+airl;
+airm;
+airn;
+airo;
+airp;
+airq;
+airr;
+airs;
+airt;
+airu;
+airv;
+airw;
+airx;
+airy;
+airz;
+aisa;
+aisb;
+aisc;
+aisd;
+aise;
+aisf;
+aisg;
+aish;
+aisi;
+aisj;
+aisk;
+aisl;
+aism;
+aisn;
+aiso;
+aisp;
+aisq;
+aisr;
+aiss;
+aist;
+aisu;
+aisv;
+aisw;
+aisx;
+aisy;
+aisz;
+aita;
+aitb;
+aitc;
+aitd;
+aite;
+aitf;
+aitg;
+aith;
+aiti;
+aitj;
+aitk;
+aitl;
+aitm;
+aitn;
+aito;
+aitp;
+aitq;
+aitr;
+aits;
+aitt;
+aitu;
+aitv;
+aitw;
+aitx;
+aity;
+aitz;
+aiua;
+aiub;
+aiuc;
+aiud;
+aiue;
+aiuf;
+aiug;
+aiuh;
+aiui;
+aiuj;
+aiuk;
+aiul;
+aium;
+aiun;
+aiuo;
+aiup;
+aiuq;
+aiur;
+aius;
+aiut;
+aiuu;
+aiuv;
+aiuw;
+aiux;
+aiuy;
+aiuz;
+aiva;
+aivb;
+aivc;
+aivd;
+aive;
+aivf;
+aivg;
+aivh;
+aivi;
+aivj;
+aivk;
+aivl;
+aivm;
+aivn;
+aivo;
+aivp;
+aivq;
+aivr;
+aivs;
+aivt;
+aivu;
+aivv;
+aivw;
+aivx;
+aivy;
+aivz;
+aiwa;
+aiwb;
+aiwc;
+aiwd;
+aiwe;
+aiwf;
+aiwg;
+aiwh;
+aiwi;
+aiwj;
+aiwk;
+aiwl;
+aiwm;
+aiwn;
+aiwo;
+aiwp;
+aiwq;
+aiwr;
+aiws;
+aiwt;
+aiwu;
+aiwv;
+aiww;
+aiwx;
+aiwy;
+aiwz;
+aixa;
+aixb;
+aixc;
+aixd;
+aixe;
+aixf;
+aixg;
+aixh;
+aixi;
+aixj;
+aixk;
+aixl;
+aixm;
+aixn;
+aixo;
+aixp;
+aixq;
+aixr;
+aixs;
+aixt;
+aixu;
+aixv;
+aixw;
+aixx;
+aixy;
+aixz;
+aiya;
+aiyb;
+aiyc;
+aiyd;
+aiye;
+aiyf;
+aiyg;
+aiyh;
+aiyi;
+aiyj;
+aiyk;
+aiyl;
+aiym;
+aiyn;
+aiyo;
+aiyp;
+aiyq;
+aiyr;
+aiys;
+aiyt;
+aiyu;
+aiyv;
+aiyw;
+aiyx;
+aiyy;
+aiyz;
+aiza;
+aizb;
+aizc;
+aizd;
+aize;
+aizf;
+aizg;
+aizh;
+aizi;
+aizj;
+aizk;
+aizl;
+aizm;
+aizn;
+aizo;
+aizp;
+aizq;
+aizr;
+aizs;
+aizt;
+aizu;
+aizv;
+aizw;
+aizx;
+aizy;
+aizz;
+ajaa;
+ajab;
+ajac;
+ajad;
+ajae;
+ajaf;
+ajag;
+ajah;
+ajai;
+ajaj;
+ajak;
+ajal;
+ajam;
+ajan;
+ajao;
+ajap;
+ajaq;
+ajar;
+ajas;
+ajat;
+ajau;
+ajav;
+ajaw;
+ajax;
+ajay;
+ajaz;
+ajba;
+ajbb;
+ajbc;
+ajbd;
+ajbe;
+ajbf;
+ajbg;
+ajbh;
+ajbi;
+ajbj;
+ajbk;
+ajbl;
+ajbm;
+ajbn;
+ajbo;
+ajbp;
+ajbq;
+ajbr;
+ajbs;
+ajbt;
+ajbu;
+ajbv;
+ajbw;
+ajbx;
+ajby;
+ajbz;
+ajca;
+ajcb;
+ajcc;
+ajcd;
+ajce;
+ajcf;
+ajcg;
+ajch;
+ajci;
+ajcj;
+ajck;
+ajcl;
+ajcm;
+ajcn;
+ajco;
+ajcp;
+ajcq;
+ajcr;
+ajcs;
+ajct;
+ajcu;
+ajcv;
+ajcw;
+ajcx;
+ajcy;
+ajcz;
+ajda;
+ajdb;
+ajdc;
+ajdd;
+ajde;
+ajdf;
+ajdg;
+ajdh;
+ajdi;
+ajdj;
+ajdk;
+ajdl;
+ajdm;
+ajdn;
+ajdo;
+ajdp;
+ajdq;
+ajdr;
+ajds;
+ajdt;
+ajdu;
+ajdv;
+ajdw;
+ajdx;
+ajdy;
+ajdz;
+ajea;
+ajeb;
+ajec;
+ajed;
+ajee;
+ajef;
+ajeg;
+ajeh;
+ajei;
+ajej;
+ajek;
+ajel;
+ajem;
+ajen;
+ajeo;
+ajep;
+ajeq;
+ajer;
+ajes;
+ajet;
+ajeu;
+ajev;
+ajew;
+ajex;
+ajey;
+ajez;
+ajfa;
+ajfb;
+ajfc;
+ajfd;
+ajfe;
+ajff;
+ajfg;
+ajfh;
+ajfi;
+ajfj;
+ajfk;
+ajfl;
+ajfm;
+ajfn;
+ajfo;
+ajfp;
+ajfq;
+ajfr;
+ajfs;
+ajft;
+ajfu;
+ajfv;
+ajfw;
+ajfx;
+ajfy;
+ajfz;
+ajga;
+ajgb;
+ajgc;
+ajgd;
+ajge;
+ajgf;
+ajgg;
+ajgh;
+ajgi;
+ajgj;
+ajgk;
+ajgl;
+ajgm;
+ajgn;
+ajgo;
+ajgp;
+ajgq;
+ajgr;
+ajgs;
+ajgt;
+ajgu;
+ajgv;
+ajgw;
+ajgx;
+ajgy;
+ajgz;
+ajha;
+ajhb;
+ajhc;
+ajhd;
+ajhe;
+ajhf;
+ajhg;
+ajhh;
+ajhi;
+ajhj;
+ajhk;
+ajhl;
+ajhm;
+ajhn;
+ajho;
+ajhp;
+ajhq;
+ajhr;
+ajhs;
+ajht;
+ajhu;
+ajhv;
+ajhw;
+ajhx;
+ajhy;
+ajhz;
+ajia;
+ajib;
+ajic;
+ajid;
+ajie;
+ajif;
+ajig;
+ajih;
+ajii;
+ajij;
+ajik;
+ajil;
+ajim;
+ajin;
+ajio;
+ajip;
+ajiq;
+ajir;
+ajis;
+ajit;
+ajiu;
+ajiv;
+ajiw;
+ajix;
+ajiy;
+ajiz;
+ajja;
+ajjb;
+ajjc;
+ajjd;
+ajje;
+ajjf;
+ajjg;
+ajjh;
+ajji;
+ajjj;
+ajjk;
+ajjl;
+ajjm;
+ajjn;
+ajjo;
+ajjp;
+ajjq;
+ajjr;
+ajjs;
+ajjt;
+ajju;
+ajjv;
+ajjw;
+ajjx;
+ajjy;
+ajjz;
+ajka;
+ajkb;
+ajkc;
+ajkd;
+ajke;
+ajkf;
+ajkg;
+ajkh;
+ajki;
+ajkj;
+ajkk;
+ajkl;
+ajkm;
+ajkn;
+ajko;
+ajkp;
+ajkq;
+ajkr;
+ajks;
+ajkt;
+ajku;
+ajkv;
+ajkw;
+ajkx;
+ajky;
+ajkz;
+ajla;
+ajlb;
+ajlc;
+ajld;
+ajle;
+ajlf;
+ajlg;
+ajlh;
+ajli;
+ajlj;
+ajlk;
+ajll;
+ajlm;
+ajln;
+ajlo;
+ajlp;
+ajlq;
+ajlr;
+ajls;
+ajlt;
+ajlu;
+ajlv;
+ajlw;
+ajlx;
+ajly;
+ajlz;
+ajma;
+ajmb;
+ajmc;
+ajmd;
+ajme;
+ajmf;
+ajmg;
+ajmh;
+ajmi;
+ajmj;
+ajmk;
+ajml;
+ajmm;
+ajmn;
+ajmo;
+ajmp;
+ajmq;
+ajmr;
+ajms;
+ajmt;
+ajmu;
+ajmv;
+ajmw;
+ajmx;
+ajmy;
+ajmz;
+ajna;
+ajnb;
+ajnc;
+ajnd;
+ajne;
+ajnf;
+ajng;
+ajnh;
+ajni;
+ajnj;
+ajnk;
+ajnl;
+ajnm;
+ajnn;
+ajno;
+ajnp;
+ajnq;
+ajnr;
+ajns;
+ajnt;
+ajnu;
+ajnv;
+ajnw;
+ajnx;
+ajny;
+ajnz;
+ajoa;
+ajob;
+ajoc;
+ajod;
+ajoe;
+ajof;
+ajog;
+ajoh;
+ajoi;
+ajoj;
+ajok;
+ajol;
+ajom;
+ajon;
+ajoo;
+ajop;
+ajoq;
+ajor;
+ajos;
+ajot;
+ajou;
+ajov;
+ajow;
+ajox;
+ajoy;
+ajoz;
+ajpa;
+ajpb;
+ajpc;
+ajpd;
+ajpe;
+ajpf;
+ajpg;
+ajph;
+ajpi;
+ajpj;
+ajpk;
+ajpl;
+ajpm;
+ajpn;
+ajpo;
+ajpp;
+ajpq;
+ajpr;
+ajps;
+ajpt;
+ajpu;
+ajpv;
+ajpw;
+ajpx;
+ajpy;
+ajpz;
+ajqa;
+ajqb;
+ajqc;
+ajqd;
+ajqe;
+ajqf;
+ajqg;
+ajqh;
+ajqi;
+ajqj;
+ajqk;
+ajql;
+ajqm;
+ajqn;
+ajqo;
+ajqp;
+ajqq;
+ajqr;
+ajqs;
+ajqt;
+ajqu;
+ajqv;
+ajqw;
+ajqx;
+ajqy;
+ajqz;
+ajra;
+ajrb;
+ajrc;
+ajrd;
+ajre;
+ajrf;
+ajrg;
+ajrh;
+ajri;
+ajrj;
+ajrk;
+ajrl;
+ajrm;
+ajrn;
+ajro;
+ajrp;
+ajrq;
+ajrr;
+ajrs;
+ajrt;
+ajru;
+ajrv;
+ajrw;
+ajrx;
+ajry;
+ajrz;
+ajsa;
+ajsb;
+ajsc;
+ajsd;
+ajse;
+ajsf;
+ajsg;
+ajsh;
+ajsi;
+ajsj;
+ajsk;
+ajsl;
+ajsm;
+ajsn;
+ajso;
+ajsp;
+ajsq;
+ajsr;
+ajss;
+ajst;
+ajsu;
+ajsv;
+ajsw;
+ajsx;
+ajsy;
+ajsz;
+ajta;
+ajtb;
+ajtc;
+ajtd;
+ajte;
+ajtf;
+ajtg;
+ajth;
+ajti;
+ajtj;
+ajtk;
+ajtl;
+ajtm;
+ajtn;
+ajto;
+ajtp;
+ajtq;
+ajtr;
+ajts;
+ajtt;
+ajtu;
+ajtv;
+ajtw;
+ajtx;
+ajty;
+ajtz;
+ajua;
+ajub;
+ajuc;
+ajud;
+ajue;
+ajuf;
+ajug;
+ajuh;
+ajui;
+ajuj;
+ajuk;
+ajul;
+ajum;
+ajun;
+ajuo;
+ajup;
+ajuq;
+ajur;
+ajus;
+ajut;
+ajuu;
+ajuv;
+ajuw;
+ajux;
+ajuy;
+ajuz;
+ajva;
+ajvb;
+ajvc;
+ajvd;
+ajve;
+ajvf;
+ajvg;
+ajvh;
+ajvi;
+ajvj;
+ajvk;
+ajvl;
+ajvm;
+ajvn;
+ajvo;
+ajvp;
+ajvq;
+ajvr;
+ajvs;
+ajvt;
+ajvu;
+ajvv;
+ajvw;
+ajvx;
+ajvy;
+ajvz;
+ajwa;
+ajwb;
+ajwc;
+ajwd;
+ajwe;
+ajwf;
+ajwg;
+ajwh;
+ajwi;
+ajwj;
+ajwk;
+ajwl;
+ajwm;
+ajwn;
+ajwo;
+ajwp;
+ajwq;
+ajwr;
+ajws;
+ajwt;
+ajwu;
+ajwv;
+ajww;
+ajwx;
+ajwy;
+ajwz;
+ajxa;
+ajxb;
+ajxc;
+ajxd;
+ajxe;
+ajxf;
+ajxg;
+ajxh;
+ajxi;
+ajxj;
+ajxk;
+ajxl;
+ajxm;
+ajxn;
+ajxo;
+ajxp;
+ajxq;
+ajxr;
+ajxs;
+ajxt;
+ajxu;
+ajxv;
+ajxw;
+ajxx;
+ajxy;
+ajxz;
+ajya;
+ajyb;
+ajyc;
+ajyd;
+ajye;
+ajyf;
+ajyg;
+ajyh;
+ajyi;
+ajyj;
+ajyk;
+ajyl;
+ajym;
+ajyn;
+ajyo;
+ajyp;
+ajyq;
+ajyr;
+ajys;
+ajyt;
+ajyu;
+ajyv;
+ajyw;
+ajyx;
+ajyy;
+ajyz;
+ajza;
+ajzb;
+ajzc;
+ajzd;
+ajze;
+ajzf;
+ajzg;
+ajzh;
+ajzi;
+ajzj;
+ajzk;
+ajzl;
+ajzm;
+ajzn;
+ajzo;
+ajzp;
+ajzq;
+ajzr;
+ajzs;
+ajzt;
+ajzu;
+ajzv;
+ajzw;
+ajzx;
+ajzy;
+ajzz;
+akaa;
+akab;
+akac;
+akad;
+akae;
+akaf;
+akag;
+akah;
+akai;
+akaj;
+akak;
+akal;
+akam;
+akan;
+akao;
+akap;
+akaq;
+akar;
+akas;
+akat;
+akau;
+akav;
+akaw;
+akax;
+akay;
+akaz;
+akba;
+akbb;
+akbc;
+akbd;
+akbe;
+akbf;
+akbg;
+akbh;
+akbi;
+akbj;
+akbk;
+akbl;
+akbm;
+akbn;
+akbo;
+akbp;
+akbq;
+akbr;
+akbs;
+akbt;
+akbu;
+akbv;
+akbw;
+akbx;
+akby;
+akbz;
+akca;
+akcb;
+akcc;
+akcd;
+akce;
+akcf;
+akcg;
+akch;
+akci;
+akcj;
+akck;
+akcl;
+akcm;
+akcn;
+akco;
+akcp;
+akcq;
+akcr;
+akcs;
+akct;
+akcu;
+akcv;
+akcw;
+akcx;
+akcy;
+akcz;
+akda;
+akdb;
+akdc;
+akdd;
+akde;
+akdf;
+akdg;
+akdh;
+akdi;
+akdj;
+akdk;
+akdl;
+akdm;
+akdn;
+akdo;
+akdp;
+akdq;
+akdr;
+akds;
+akdt;
+akdu;
+akdv;
+akdw;
+akdx;
+akdy;
+akdz;
+akea;
+akeb;
+akec;
+aked;
+akee;
+akef;
+akeg;
+akeh;
+akei;
+akej;
+akek;
+akel;
+akem;
+aken;
+akeo;
+akep;
+akeq;
+aker;
+akes;
+aket;
+akeu;
+akev;
+akew;
+akex;
+akey;
+akez;
+akfa;
+akfb;
+akfc;
+akfd;
+akfe;
+akff;
+akfg;
+akfh;
+akfi;
+akfj;
+akfk;
+akfl;
+akfm;
+akfn;
+akfo;
+akfp;
+akfq;
+akfr;
+akfs;
+akft;
+akfu;
+akfv;
+akfw;
+akfx;
+akfy;
+akfz;
+akga;
+akgb;
+akgc;
+akgd;
+akge;
+akgf;
+akgg;
+akgh;
+akgi;
+akgj;
+akgk;
+akgl;
+akgm;
+akgn;
+akgo;
+akgp;
+akgq;
+akgr;
+akgs;
+akgt;
+akgu;
+akgv;
+akgw;
+akgx;
+akgy;
+akgz;
+akha;
+akhb;
+akhc;
+akhd;
+akhe;
+akhf;
+akhg;
+akhh;
+akhi;
+akhj;
+akhk;
+akhl;
+akhm;
+akhn;
+akho;
+akhp;
+akhq;
+akhr;
+akhs;
+akht;
+akhu;
+akhv;
+akhw;
+akhx;
+akhy;
+akhz;
+akia;
+akib;
+akic;
+akid;
+akie;
+akif;
+akig;
+akih;
+akii;
+akij;
+akik;
+akil;
+akim;
+akin;
+akio;
+akip;
+akiq;
+akir;
+akis;
+akit;
+akiu;
+akiv;
+akiw;
+akix;
+akiy;
+akiz;
+akja;
+akjb;
+akjc;
+akjd;
+akje;
+akjf;
+akjg;
+akjh;
+akji;
+akjj;
+akjk;
+akjl;
+akjm;
+akjn;
+akjo;
+akjp;
+akjq;
+akjr;
+akjs;
+akjt;
+akju;
+akjv;
+akjw;
+akjx;
+akjy;
+akjz;
+akka;
+akkb;
+akkc;
+akkd;
+akke;
+akkf;
+akkg;
+akkh;
+akki;
+akkj;
+akkk;
+akkl;
+akkm;
+akkn;
+akko;
+akkp;
+akkq;
+akkr;
+akks;
+akkt;
+akku;
+akkv;
+akkw;
+akkx;
+akky;
+akkz;
+akla;
+aklb;
+aklc;
+akld;
+akle;
+aklf;
+aklg;
+aklh;
+akli;
+aklj;
+aklk;
+akll;
+aklm;
+akln;
+aklo;
+aklp;
+aklq;
+aklr;
+akls;
+aklt;
+aklu;
+aklv;
+aklw;
+aklx;
+akly;
+aklz;
+akma;
+akmb;
+akmc;
+akmd;
+akme;
+akmf;
+akmg;
+akmh;
+akmi;
+akmj;
+akmk;
+akml;
+akmm;
+akmn;
+akmo;
+akmp;
+akmq;
+akmr;
+akms;
+akmt;
+akmu;
+akmv;
+akmw;
+akmx;
+akmy;
+akmz;
+akna;
+aknb;
+aknc;
+aknd;
+akne;
+aknf;
+akng;
+aknh;
+akni;
+aknj;
+aknk;
+aknl;
+aknm;
+aknn;
+akno;
+aknp;
+aknq;
+aknr;
+akns;
+aknt;
+aknu;
+aknv;
+aknw;
+aknx;
+akny;
+aknz;
+akoa;
+akob;
+akoc;
+akod;
+akoe;
+akof;
+akog;
+akoh;
+akoi;
+akoj;
+akok;
+akol;
+akom;
+akon;
+akoo;
+akop;
+akoq;
+akor;
+akos;
+akot;
+akou;
+akov;
+akow;
+akox;
+akoy;
+akoz;
+akpa;
+akpb;
+akpc;
+akpd;
+akpe;
+akpf;
+akpg;
+akph;
+akpi;
+akpj;
+akpk;
+akpl;
+akpm;
+akpn;
+akpo;
+akpp;
+akpq;
+akpr;
+akps;
+akpt;
+akpu;
+akpv;
+akpw;
+akpx;
+akpy;
+akpz;
+akqa;
+akqb;
+akqc;
+akqd;
+akqe;
+akqf;
+akqg;
+akqh;
+akqi;
+akqj;
+akqk;
+akql;
+akqm;
+akqn;
+akqo;
+akqp;
+akqq;
+akqr;
+akqs;
+akqt;
+akqu;
+akqv;
+akqw;
+akqx;
+akqy;
+akqz;
+akra;
+akrb;
+akrc;
+akrd;
+akre;
+akrf;
+akrg;
+akrh;
+akri;
+akrj;
+akrk;
+akrl;
+akrm;
+akrn;
+akro;
+akrp;
+akrq;
+akrr;
+akrs;
+akrt;
+akru;
+akrv;
+akrw;
+akrx;
+akry;
+akrz;
+aksa;
+aksb;
+aksc;
+aksd;
+akse;
+aksf;
+aksg;
+aksh;
+aksi;
+aksj;
+aksk;
+aksl;
+aksm;
+aksn;
+akso;
+aksp;
+aksq;
+aksr;
+akss;
+akst;
+aksu;
+aksv;
+aksw;
+aksx;
+aksy;
+aksz;
+akta;
+aktb;
+aktc;
+aktd;
+akte;
+aktf;
+aktg;
+akth;
+akti;
+aktj;
+aktk;
+aktl;
+aktm;
+aktn;
+akto;
+aktp;
+aktq;
+aktr;
+akts;
+aktt;
+aktu;
+aktv;
+aktw;
+aktx;
+akty;
+aktz;
+akua;
+akub;
+akuc;
+akud;
+akue;
+akuf;
+akug;
+akuh;
+akui;
+akuj;
+akuk;
+akul;
+akum;
+akun;
+akuo;
+akup;
+akuq;
+akur;
+akus;
+akut;
+akuu;
+akuv;
+akuw;
+akux;
+akuy;
+akuz;
+akva;
+akvb;
+akvc;
+akvd;
+akve;
+akvf;
+akvg;
+akvh;
+akvi;
+akvj;
+akvk;
+akvl;
+akvm;
+akvn;
+akvo;
+akvp;
+akvq;
+akvr;
+akvs;
+akvt;
+akvu;
+akvv;
+akvw;
+akvx;
+akvy;
+akvz;
+akwa;
+akwb;
+akwc;
+akwd;
+akwe;
+akwf;
+akwg;
+akwh;
+akwi;
+akwj;
+akwk;
+akwl;
+akwm;
+akwn;
+akwo;
+akwp;
+akwq;
+akwr;
+akws;
+akwt;
+akwu;
+akwv;
+akww;
+akwx;
+akwy;
+akwz;
+akxa;
+akxb;
+akxc;
+akxd;
+akxe;
+akxf;
+akxg;
+akxh;
+akxi;
+akxj;
+akxk;
+akxl;
+akxm;
+akxn;
+akxo;
+akxp;
+akxq;
+akxr;
+akxs;
+akxt;
+akxu;
+akxv;
+akxw;
+akxx;
+akxy;
+akxz;
+akya;
+akyb;
+akyc;
+akyd;
+akye;
+akyf;
+akyg;
+akyh;
+akyi;
+akyj;
+akyk;
+akyl;
+akym;
+akyn;
+akyo;
+akyp;
+akyq;
+akyr;
+akys;
+akyt;
+akyu;
+akyv;
+akyw;
+akyx;
+akyy;
+akyz;
+akza;
+akzb;
+akzc;
+akzd;
+akze;
+akzf;
+akzg;
+akzh;
+akzi;
+akzj;
+akzk;
+akzl;
+akzm;
+akzn;
+akzo;
+akzp;
+akzq;
+akzr;
+akzs;
+akzt;
+akzu;
+akzv;
+akzw;
+akzx;
+akzy;
+akzz;
+alaa;
+alab;
+alac;
+alad;
+alae;
+alaf;
+alag;
+alah;
+alai;
+alaj;
+alak;
+alal;
+alam;
+alan;
+alao;
+alap;
+alaq;
+alar;
+alas;
+alat;
+alau;
+alav;
+alaw;
+alax;
+alay;
+alaz;
+alba;
+albb;
+albc;
+albd;
+albe;
+albf;
+albg;
+albh;
+albi;
+albj;
+albk;
+albl;
+albm;
+albn;
+albo;
+albp;
+albq;
+albr;
+albs;
+albt;
+albu;
+albv;
+albw;
+albx;
+alby;
+albz;
+alca;
+alcb;
+alcc;
+alcd;
+alce;
+alcf;
+alcg;
+alch;
+alci;
+alcj;
+alck;
+alcl;
+alcm;
+alcn;
+alco;
+alcp;
+alcq;
+alcr;
+alcs;
+alct;
+alcu;
+alcv;
+alcw;
+alcx;
+alcy;
+alcz;
+alda;
+aldb;
+aldc;
+aldd;
+alde;
+aldf;
+aldg;
+aldh;
+aldi;
+aldj;
+aldk;
+aldl;
+aldm;
+aldn;
+aldo;
+aldp;
+aldq;
+aldr;
+alds;
+aldt;
+aldu;
+aldv;
+aldw;
+aldx;
+aldy;
+aldz;
+alea;
+aleb;
+alec;
+aled;
+alee;
+alef;
+aleg;
+aleh;
+alei;
+alej;
+alek;
+alel;
+alem;
+alen;
+aleo;
+alep;
+aleq;
+aler;
+ales;
+alet;
+aleu;
+alev;
+alew;
+alex;
+aley;
+alez;
+alfa;
+alfb;
+alfc;
+alfd;
+alfe;
+alff;
+alfg;
+alfh;
+alfi;
+alfj;
+alfk;
+alfl;
+alfm;
+alfn;
+alfo;
+alfp;
+alfq;
+alfr;
+alfs;
+alft;
+alfu;
+alfv;
+alfw;
+alfx;
+alfy;
+alfz;
+alga;
+algb;
+algc;
+algd;
+alge;
+algf;
+algg;
+algh;
+algi;
+algj;
+algk;
+algl;
+algm;
+algn;
+algo;
+algp;
+algq;
+algr;
+algs;
+algt;
+algu;
+algv;
+algw;
+algx;
+algy;
+algz;
+alha;
+alhb;
+alhc;
+alhd;
+alhe;
+alhf;
+alhg;
+alhh;
+alhi;
+alhj;
+alhk;
+alhl;
+alhm;
+alhn;
+alho;
+alhp;
+alhq;
+alhr;
+alhs;
+alht;
+alhu;
+alhv;
+alhw;
+alhx;
+alhy;
+alhz;
+alia;
+alib;
+alic;
+alid;
+alie;
+alif;
+alig;
+alih;
+alii;
+alij;
+alik;
+alil;
+alim;
+alin;
+alio;
+alip;
+aliq;
+alir;
+alis;
+alit;
+aliu;
+aliv;
+aliw;
+alix;
+aliy;
+aliz;
+alja;
+aljb;
+aljc;
+aljd;
+alje;
+aljf;
+aljg;
+aljh;
+alji;
+aljj;
+aljk;
+aljl;
+aljm;
+aljn;
+aljo;
+aljp;
+aljq;
+aljr;
+aljs;
+aljt;
+alju;
+aljv;
+aljw;
+aljx;
+aljy;
+aljz;
+alka;
+alkb;
+alkc;
+alkd;
+alke;
+alkf;
+alkg;
+alkh;
+alki;
+alkj;
+alkk;
+alkl;
+alkm;
+alkn;
+alko;
+alkp;
+alkq;
+alkr;
+alks;
+alkt;
+alku;
+alkv;
+alkw;
+alkx;
+alky;
+alkz;
+alla;
+allb;
+allc;
+alld;
+alle;
+allf;
+allg;
+allh;
+alli;
+allj;
+allk;
+alll;
+allm;
+alln;
+allo;
+allp;
+allq;
+allr;
+alls;
+allt;
+allu;
+allv;
+allw;
+allx;
+ally;
+allz;
+alma;
+almb;
+almc;
+almd;
+alme;
+almf;
+almg;
+almh;
+almi;
+almj;
+almk;
+alml;
+almm;
+almn;
+almo;
+almp;
+almq;
+almr;
+alms;
+almt;
+almu;
+almv;
+almw;
+almx;
+almy;
+almz;
+alna;
+alnb;
+alnc;
+alnd;
+alne;
+alnf;
+alng;
+alnh;
+alni;
+alnj;
+alnk;
+alnl;
+alnm;
+alnn;
+alno;
+alnp;
+alnq;
+alnr;
+alns;
+alnt;
+alnu;
+alnv;
+alnw;
+alnx;
+alny;
+alnz;
+aloa;
+alob;
+aloc;
+alod;
+aloe;
+alof;
+alog;
+aloh;
+aloi;
+aloj;
+alok;
+alol;
+alom;
+alon;
+aloo;
+alop;
+aloq;
+alor;
+alos;
+alot;
+alou;
+alov;
+alow;
+alox;
+aloy;
+aloz;
+alpa;
+alpb;
+alpc;
+alpd;
+alpe;
+alpf;
+alpg;
+alph;
+alpi;
+alpj;
+alpk;
+alpl;
+alpm;
+alpn;
+alpo;
+alpp;
+alpq;
+alpr;
+alps;
+alpt;
+alpu;
+alpv;
+alpw;
+alpx;
+alpy;
+alpz;
+alqa;
+alqb;
+alqc;
+alqd;
+alqe;
+alqf;
+alqg;
+alqh;
+alqi;
+alqj;
+alqk;
+alql;
+alqm;
+alqn;
+alqo;
+alqp;
+alqq;
+alqr;
+alqs;
+alqt;
+alqu;
+alqv;
+alqw;
+alqx;
+alqy;
+alqz;
+alra;
+alrb;
+alrc;
+alrd;
+alre;
+alrf;
+alrg;
+alrh;
+alri;
+alrj;
+alrk;
+alrl;
+alrm;
+alrn;
+alro;
+alrp;
+alrq;
+alrr;
+alrs;
+alrt;
+alru;
+alrv;
+alrw;
+alrx;
+alry;
+alrz;
+alsa;
+alsb;
+alsc;
+alsd;
+alse;
+alsf;
+alsg;
+alsh;
+alsi;
+alsj;
+alsk;
+alsl;
+alsm;
+alsn;
+also;
+alsp;
+alsq;
+alsr;
+alss;
+alst;
+alsu;
+alsv;
+alsw;
+alsx;
+alsy;
+alsz;
+alta;
+altb;
+altc;
+altd;
+alte;
+altf;
+altg;
+alth;
+alti;
+altj;
+altk;
+altl;
+altm;
+altn;
+alto;
+altp;
+altq;
+altr;
+alts;
+altt;
+altu;
+altv;
+altw;
+altx;
+alty;
+altz;
+alua;
+alub;
+aluc;
+alud;
+alue;
+aluf;
+alug;
+aluh;
+alui;
+aluj;
+aluk;
+alul;
+alum;
+alun;
+aluo;
+alup;
+aluq;
+alur;
+alus;
+alut;
+aluu;
+aluv;
+aluw;
+alux;
+aluy;
+aluz;
+alva;
+alvb;
+alvc;
+alvd;
+alve;
+alvf;
+alvg;
+alvh;
+alvi;
+alvj;
+alvk;
+alvl;
+alvm;
+alvn;
+alvo;
+alvp;
+alvq;
+alvr;
+alvs;
+alvt;
+alvu;
+alvv;
+alvw;
+alvx;
+alvy;
+alvz;
+alwa;
+alwb;
+alwc;
+alwd;
+alwe;
+alwf;
+alwg;
+alwh;
+alwi;
+alwj;
+alwk;
+alwl;
+alwm;
+alwn;
+alwo;
+alwp;
+alwq;
+alwr;
+alws;
+alwt;
+alwu;
+alwv;
+alww;
+alwx;
+alwy;
+alwz;
+alxa;
+alxb;
+alxc;
+alxd;
+alxe;
+alxf;
+alxg;
+alxh;
+alxi;
+alxj;
+alxk;
+alxl;
+alxm;
+alxn;
+alxo;
+alxp;
+alxq;
+alxr;
+alxs;
+alxt;
+alxu;
+alxv;
+alxw;
+alxx;
+alxy;
+alxz;
+alya;
+alyb;
+alyc;
+alyd;
+alye;
+alyf;
+alyg;
+alyh;
+alyi;
+alyj;
+alyk;
+alyl;
+alym;
+alyn;
+alyo;
+alyp;
+alyq;
+alyr;
+alys;
+alyt;
+alyu;
+alyv;
+alyw;
+alyx;
+alyy;
+alyz;
+alza;
+alzb;
+alzc;
+alzd;
+alze;
+alzf;
+alzg;
+alzh;
+alzi;
+alzj;
+alzk;
+alzl;
+alzm;
+alzn;
+alzo;
+alzp;
+alzq;
+alzr;
+alzs;
+alzt;
+alzu;
+alzv;
+alzw;
+alzx;
+alzy;
+alzz;
+amaa;
+amab;
+amac;
+amad;
+amae;
+amaf;
+amag;
+amah;
+amai;
+amaj;
+amak;
+amal;
+amam;
+aman;
+amao;
+amap;
+amaq;
+amar;
+amas;
+amat;
+amau;
+amav;
+amaw;
+amax;
+amay;
+amaz;
+amba;
+ambb;
+ambc;
+ambd;
+ambe;
+ambf;
+ambg;
+ambh;
+ambi;
+ambj;
+ambk;
+ambl;
+ambm;
+ambn;
+ambo;
+ambp;
+ambq;
+ambr;
+ambs;
+ambt;
+ambu;
+ambv;
+ambw;
+ambx;
+amby;
+ambz;
+amca;
+amcb;
+amcc;
+amcd;
+amce;
+amcf;
+amcg;
+amch;
+amci;
+amcj;
+amck;
+amcl;
+amcm;
+amcn;
+amco;
+amcp;
+amcq;
+amcr;
+amcs;
+amct;
+amcu;
+amcv;
+amcw;
+amcx;
+amcy;
+amcz;
+amda;
+amdb;
+amdc;
+amdd;
+amde;
+amdf;
+amdg;
+amdh;
+amdi;
+amdj;
+amdk;
+amdl;
+amdm;
+amdn;
+amdo;
+amdp;
+amdq;
+amdr;
+amds;
+amdt;
+amdu;
+amdv;
+amdw;
+amdx;
+amdy;
+amdz;
+amea;
+ameb;
+amec;
+amed;
+amee;
+amef;
+ameg;
+ameh;
+amei;
+amej;
+amek;
+amel;
+amem;
+amen;
+ameo;
+amep;
+ameq;
+amer;
+ames;
+amet;
+ameu;
+amev;
+amew;
+amex;
+amey;
+amez;
+amfa;
+amfb;
+amfc;
+amfd;
+amfe;
+amff;
+amfg;
+amfh;
+amfi;
+amfj;
+amfk;
+amfl;
+amfm;
+amfn;
+amfo;
+amfp;
+amfq;
+amfr;
+amfs;
+amft;
+amfu;
+amfv;
+amfw;
+amfx;
+amfy;
+amfz;
+amga;
+amgb;
+amgc;
+amgd;
+amge;
+amgf;
+amgg;
+amgh;
+amgi;
+amgj;
+amgk;
+amgl;
+amgm;
+amgn;
+amgo;
+amgp;
+amgq;
+amgr;
+amgs;
+amgt;
+amgu;
+amgv;
+amgw;
+amgx;
+amgy;
+amgz;
+amha;
+amhb;
+amhc;
+amhd;
+amhe;
+amhf;
+amhg;
+amhh;
+amhi;
+amhj;
+amhk;
+amhl;
+amhm;
+amhn;
+amho;
+amhp;
+amhq;
+amhr;
+amhs;
+amht;
+amhu;
+amhv;
+amhw;
+amhx;
+amhy;
+amhz;
+amia;
+amib;
+amic;
+amid;
+amie;
+amif;
+amig;
+amih;
+amii;
+amij;
+amik;
+amil;
+amim;
+amin;
+amio;
+amip;
+amiq;
+amir;
+amis;
+amit;
+amiu;
+amiv;
+amiw;
+amix;
+amiy;
+amiz;
+amja;
+amjb;
+amjc;
+amjd;
+amje;
+amjf;
+amjg;
+amjh;
+amji;
+amjj;
+amjk;
+amjl;
+amjm;
+amjn;
+amjo;
+amjp;
+amjq;
+amjr;
+amjs;
+amjt;
+amju;
+amjv;
+amjw;
+amjx;
+amjy;
+amjz;
+amka;
+amkb;
+amkc;
+amkd;
+amke;
+amkf;
+amkg;
+amkh;
+amki;
+amkj;
+amkk;
+amkl;
+amkm;
+amkn;
+amko;
+amkp;
+amkq;
+amkr;
+amks;
+amkt;
+amku;
+amkv;
+amkw;
+amkx;
+amky;
+amkz;
+amla;
+amlb;
+amlc;
+amld;
+amle;
+amlf;
+amlg;
+amlh;
+amli;
+amlj;
+amlk;
+amll;
+amlm;
+amln;
+amlo;
+amlp;
+amlq;
+amlr;
+amls;
+amlt;
+amlu;
+amlv;
+amlw;
+amlx;
+amly;
+amlz;
+amma;
+ammb;
+ammc;
+ammd;
+amme;
+ammf;
+ammg;
+ammh;
+ammi;
+ammj;
+ammk;
+amml;
+ammm;
+ammn;
+ammo;
+ammp;
+ammq;
+ammr;
+amms;
+ammt;
+ammu;
+ammv;
+ammw;
+ammx;
+ammy;
+ammz;
+amna;
+amnb;
+amnc;
+amnd;
+amne;
+amnf;
+amng;
+amnh;
+amni;
+amnj;
+amnk;
+amnl;
+amnm;
+amnn;
+amno;
+amnp;
+amnq;
+amnr;
+amns;
+amnt;
+amnu;
+amnv;
+amnw;
+amnx;
+amny;
+amnz;
+amoa;
+amob;
+amoc;
+amod;
+amoe;
+amof;
+amog;
+amoh;
+amoi;
+amoj;
+amok;
+amol;
+amom;
+amon;
+amoo;
+amop;
+amoq;
+amor;
+amos;
+amot;
+amou;
+amov;
+amow;
+amox;
+amoy;
+amoz;
+ampa;
+ampb;
+ampc;
+ampd;
+ampe;
+ampf;
+ampg;
+amph;
+ampi;
+ampj;
+ampk;
+ampl;
+ampm;
+ampn;
+ampo;
+ampp;
+ampq;
+ampr;
+amps;
+ampt;
+ampu;
+ampv;
+ampw;
+ampx;
+ampy;
+ampz;
+amqa;
+amqb;
+amqc;
+amqd;
+amqe;
+amqf;
+amqg;
+amqh;
+amqi;
+amqj;
+amqk;
+amql;
+amqm;
+amqn;
+amqo;
+amqp;
+amqq;
+amqr;
+amqs;
+amqt;
+amqu;
+amqv;
+amqw;
+amqx;
+amqy;
+amqz;
+amra;
+amrb;
+amrc;
+amrd;
+amre;
+amrf;
+amrg;
+amrh;
+amri;
+amrj;
+amrk;
+amrl;
+amrm;
+amrn;
+amro;
+amrp;
+amrq;
+amrr;
+amrs;
+amrt;
+amru;
+amrv;
+amrw;
+amrx;
+amry;
+amrz;
+amsa;
+amsb;
+amsc;
+amsd;
+amse;
+amsf;
+amsg;
+amsh;
+amsi;
+amsj;
+amsk;
+amsl;
+amsm;
+amsn;
+amso;
+amsp;
+amsq;
+amsr;
+amss;
+amst;
+amsu;
+amsv;
+amsw;
+amsx;
+amsy;
+amsz;
+amta;
+amtb;
+amtc;
+amtd;
+amte;
+amtf;
+amtg;
+amth;
+amti;
+amtj;
+amtk;
+amtl;
+amtm;
+amtn;
+amto;
+amtp;
+amtq;
+amtr;
+amts;
+amtt;
+amtu;
+amtv;
+amtw;
+amtx;
+amty;
+amtz;
+amua;
+amub;
+amuc;
+amud;
+amue;
+amuf;
+amug;
+amuh;
+amui;
+amuj;
+amuk;
+amul;
+amum;
+amun;
+amuo;
+amup;
+amuq;
+amur;
+amus;
+amut;
+amuu;
+amuv;
+amuw;
+amux;
+amuy;
+amuz;
+amva;
+amvb;
+amvc;
+amvd;
+amve;
+amvf;
+amvg;
+amvh;
+amvi;
+amvj;
+amvk;
+amvl;
+amvm;
+amvn;
+amvo;
+amvp;
+amvq;
+amvr;
+amvs;
+amvt;
+amvu;
+amvv;
+amvw;
+amvx;
+amvy;
+amvz;
+amwa;
+amwb;
+amwc;
+amwd;
+amwe;
+amwf;
+amwg;
+amwh;
+amwi;
+amwj;
+amwk;
+amwl;
+amwm;
+amwn;
+amwo;
+amwp;
+amwq;
+amwr;
+amws;
+amwt;
+amwu;
+amwv;
+amww;
+amwx;
+amwy;
+amwz;
+amxa;
+amxb;
+amxc;
+amxd;
+amxe;
+amxf;
+amxg;
+amxh;
+amxi;
+amxj;
+amxk;
+amxl;
+amxm;
+amxn;
+amxo;
+amxp;
+amxq;
+amxr;
+amxs;
+amxt;
+amxu;
+amxv;
+amxw;
+amxx;
+amxy;
+amxz;
+amya;
+amyb;
+amyc;
+amyd;
+amye;
+amyf;
+amyg;
+amyh;
+amyi;
+amyj;
+amyk;
+amyl;
+amym;
+amyn;
+amyo;
+amyp;
+amyq;
+amyr;
+amys;
+amyt;
+amyu;
+amyv;
+amyw;
+amyx;
+amyy;
+amyz;
+amza;
+amzb;
+amzc;
+amzd;
+amze;
+amzf;
+amzg;
+amzh;
+amzi;
+amzj;
+amzk;
+amzl;
+amzm;
+amzn;
+amzo;
+amzp;
+amzq;
+amzr;
+amzs;
+amzt;
+amzu;
+amzv;
+amzw;
+amzx;
+amzy;
+amzz;
+anaa;
+anab;
+anac;
+anad;
+anae;
+anaf;
+anag;
+anah;
+anai;
+anaj;
+anak;
+anal;
+anam;
+anan;
+anao;
+anap;
+anaq;
+anar;
+anas;
+anat;
+anau;
+anav;
+anaw;
+anax;
+anay;
+anaz;
+anba;
+anbb;
+anbc;
+anbd;
+anbe;
+anbf;
+anbg;
+anbh;
+anbi;
+anbj;
+anbk;
+anbl;
+anbm;
+anbn;
+anbo;
+anbp;
+anbq;
+anbr;
+anbs;
+anbt;
+anbu;
+anbv;
+anbw;
+anbx;
+anby;
+anbz;
+anca;
+ancb;
+ancc;
+ancd;
+ance;
+ancf;
+ancg;
+anch;
+anci;
+ancj;
+anck;
+ancl;
+ancm;
+ancn;
+anco;
+ancp;
+ancq;
+ancr;
+ancs;
+anct;
+ancu;
+ancv;
+ancw;
+ancx;
+ancy;
+ancz;
+anda;
+andb;
+andc;
+andd;
+ande;
+andf;
+andg;
+andh;
+andi;
+andj;
+andk;
+andl;
+andm;
+andn;
+ando;
+andp;
+andq;
+andr;
+ands;
+andt;
+andu;
+andv;
+andw;
+andx;
+andy;
+andz;
+anea;
+aneb;
+anec;
+aned;
+anee;
+anef;
+aneg;
+aneh;
+anei;
+anej;
+anek;
+anel;
+anem;
+anen;
+aneo;
+anep;
+aneq;
+aner;
+anes;
+anet;
+aneu;
+anev;
+anew;
+anex;
+aney;
+anez;
+anfa;
+anfb;
+anfc;
+anfd;
+anfe;
+anff;
+anfg;
+anfh;
+anfi;
+anfj;
+anfk;
+anfl;
+anfm;
+anfn;
+anfo;
+anfp;
+anfq;
+anfr;
+anfs;
+anft;
+anfu;
+anfv;
+anfw;
+anfx;
+anfy;
+anfz;
+anga;
+angb;
+angc;
+angd;
+ange;
+angf;
+angg;
+angh;
+angi;
+angj;
+angk;
+angl;
+angm;
+angn;
+ango;
+angp;
+angq;
+angr;
+angs;
+angt;
+angu;
+angv;
+angw;
+angx;
+angy;
+angz;
+anha;
+anhb;
+anhc;
+anhd;
+anhe;
+anhf;
+anhg;
+anhh;
+anhi;
+anhj;
+anhk;
+anhl;
+anhm;
+anhn;
+anho;
+anhp;
+anhq;
+anhr;
+anhs;
+anht;
+anhu;
+anhv;
+anhw;
+anhx;
+anhy;
+anhz;
+ania;
+anib;
+anic;
+anid;
+anie;
+anif;
+anig;
+anih;
+anii;
+anij;
+anik;
+anil;
+anim;
+anin;
+anio;
+anip;
+aniq;
+anir;
+anis;
+anit;
+aniu;
+aniv;
+aniw;
+anix;
+aniy;
+aniz;
+anja;
+anjb;
+anjc;
+anjd;
+anje;
+anjf;
+anjg;
+anjh;
+anji;
+anjj;
+anjk;
+anjl;
+anjm;
+anjn;
+anjo;
+anjp;
+anjq;
+anjr;
+anjs;
+anjt;
+anju;
+anjv;
+anjw;
+anjx;
+anjy;
+anjz;
+anka;
+ankb;
+ankc;
+ankd;
+anke;
+ankf;
+ankg;
+ankh;
+anki;
+ankj;
+ankk;
+ankl;
+ankm;
+ankn;
+anko;
+ankp;
+ankq;
+ankr;
+anks;
+ankt;
+anku;
+ankv;
+ankw;
+ankx;
+anky;
+ankz;
+anla;
+anlb;
+anlc;
+anld;
+anle;
+anlf;
+anlg;
+anlh;
+anli;
+anlj;
+anlk;
+anll;
+anlm;
+anln;
+anlo;
+anlp;
+anlq;
+anlr;
+anls;
+anlt;
+anlu;
+anlv;
+anlw;
+anlx;
+anly;
+anlz;
+anma;
+anmb;
+anmc;
+anmd;
+anme;
+anmf;
+anmg;
+anmh;
+anmi;
+anmj;
+anmk;
+anml;
+anmm;
+anmn;
+anmo;
+anmp;
+anmq;
+anmr;
+anms;
+anmt;
+anmu;
+anmv;
+anmw;
+anmx;
+anmy;
+anmz;
+anna;
+annb;
+annc;
+annd;
+anne;
+annf;
+anng;
+annh;
+anni;
+annj;
+annk;
+annl;
+annm;
+annn;
+anno;
+annp;
+annq;
+annr;
+anns;
+annt;
+annu;
+annv;
+annw;
+annx;
+anny;
+annz;
+anoa;
+anob;
+anoc;
+anod;
+anoe;
+anof;
+anog;
+anoh;
+anoi;
+anoj;
+anok;
+anol;
+anom;
+anon;
+anoo;
+anop;
+anoq;
+anor;
+anos;
+anot;
+anou;
+anov;
+anow;
+anox;
+anoy;
+anoz;
+anpa;
+anpb;
+anpc;
+anpd;
+anpe;
+anpf;
+anpg;
+anph;
+anpi;
+anpj;
+anpk;
+anpl;
+anpm;
+anpn;
+anpo;
+anpp;
+anpq;
+anpr;
+anps;
+anpt;
+anpu;
+anpv;
+anpw;
+anpx;
+anpy;
+anpz;
+anqa;
+anqb;
+anqc;
+anqd;
+anqe;
+anqf;
+anqg;
+anqh;
+anqi;
+anqj;
+anqk;
+anql;
+anqm;
+anqn;
+anqo;
+anqp;
+anqq;
+anqr;
+anqs;
+anqt;
+anqu;
+anqv;
+anqw;
+anqx;
+anqy;
+anqz;
+anra;
+anrb;
+anrc;
+anrd;
+anre;
+anrf;
+anrg;
+anrh;
+anri;
+anrj;
+anrk;
+anrl;
+anrm;
+anrn;
+anro;
+anrp;
+anrq;
+anrr;
+anrs;
+anrt;
+anru;
+anrv;
+anrw;
+anrx;
+anry;
+anrz;
+ansa;
+ansb;
+ansc;
+ansd;
+anse;
+ansf;
+ansg;
+ansh;
+ansi;
+ansj;
+ansk;
+ansl;
+ansm;
+ansn;
+anso;
+ansp;
+ansq;
+ansr;
+anss;
+anst;
+ansu;
+ansv;
+answ;
+ansx;
+ansy;
+ansz;
+anta;
+antb;
+antc;
+antd;
+ante;
+antf;
+antg;
+anth;
+anti;
+antj;
+antk;
+antl;
+antm;
+antn;
+anto;
+antp;
+antq;
+antr;
+ants;
+antt;
+antu;
+antv;
+antw;
+antx;
+anty;
+antz;
+anua;
+anub;
+anuc;
+anud;
+anue;
+anuf;
+anug;
+anuh;
+anui;
+anuj;
+anuk;
+anul;
+anum;
+anun;
+anuo;
+anup;
+anuq;
+anur;
+anus;
+anut;
+anuu;
+anuv;
+anuw;
+anux;
+anuy;
+anuz;
+anva;
+anvb;
+anvc;
+anvd;
+anve;
+anvf;
+anvg;
+anvh;
+anvi;
+anvj;
+anvk;
+anvl;
+anvm;
+anvn;
+anvo;
+anvp;
+anvq;
+anvr;
+anvs;
+anvt;
+anvu;
+anvv;
+anvw;
+anvx;
+anvy;
+anvz;
+anwa;
+anwb;
+anwc;
+anwd;
+anwe;
+anwf;
+anwg;
+anwh;
+anwi;
+anwj;
+anwk;
+anwl;
+anwm;
+anwn;
+anwo;
+anwp;
+anwq;
+anwr;
+anws;
+anwt;
+anwu;
+anwv;
+anww;
+anwx;
+anwy;
+anwz;
+anxa;
+anxb;
+anxc;
+anxd;
+anxe;
+anxf;
+anxg;
+anxh;
+anxi;
+anxj;
+anxk;
+anxl;
+anxm;
+anxn;
+anxo;
+anxp;
+anxq;
+anxr;
+anxs;
+anxt;
+anxu;
+anxv;
+anxw;
+anxx;
+anxy;
+anxz;
+anya;
+anyb;
+anyc;
+anyd;
+anye;
+anyf;
+anyg;
+anyh;
+anyi;
+anyj;
+anyk;
+anyl;
+anym;
+anyn;
+anyo;
+anyp;
+anyq;
+anyr;
+anys;
+anyt;
+anyu;
+anyv;
+anyw;
+anyx;
+anyy;
+anyz;
+anza;
+anzb;
+anzc;
+anzd;
+anze;
+anzf;
+anzg;
+anzh;
+anzi;
+anzj;
+anzk;
+anzl;
+anzm;
+anzn;
+anzo;
+anzp;
+anzq;
+anzr;
+anzs;
+anzt;
+anzu;
+anzv;
+anzw;
+anzx;
+anzy;
+anzz;
+aoaa;
+aoab;
+aoac;
+aoad;
+aoae;
+aoaf;
+aoag;
+aoah;
+aoai;
+aoaj;
+aoak;
+aoal;
+aoam;
+aoan;
+aoao;
+aoap;
+aoaq;
+aoar;
+aoas;
+aoat;
+aoau;
+aoav;
+aoaw;
+aoax;
+aoay;
+aoaz;
+aoba;
+aobb;
+aobc;
+aobd;
+aobe;
+aobf;
+aobg;
+aobh;
+aobi;
+aobj;
+aobk;
+aobl;
+aobm;
+aobn;
+aobo;
+aobp;
+aobq;
+aobr;
+aobs;
+aobt;
+aobu;
+aobv;
+aobw;
+aobx;
+aoby;
+aobz;
+aoca;
+aocb;
+aocc;
+aocd;
+aoce;
+aocf;
+aocg;
+aoch;
+aoci;
+aocj;
+aock;
+aocl;
+aocm;
+aocn;
+aoco;
+aocp;
+aocq;
+aocr;
+aocs;
+aoct;
+aocu;
+aocv;
+aocw;
+aocx;
+aocy;
+aocz;
+aoda;
+aodb;
+aodc;
+aodd;
+aode;
+aodf;
+aodg;
+aodh;
+aodi;
+aodj;
+aodk;
+aodl;
+aodm;
+aodn;
+aodo;
+aodp;
+aodq;
+aodr;
+aods;
+aodt;
+aodu;
+aodv;
+aodw;
+aodx;
+aody;
+aodz;
+aoea;
+aoeb;
+aoec;
+aoed;
+aoee;
+aoef;
+aoeg;
+aoeh;
+aoei;
+aoej;
+aoek;
+aoel;
+aoem;
+aoen;
+aoeo;
+aoep;
+aoeq;
+aoer;
+aoes;
+aoet;
+aoeu;
+aoev;
+aoew;
+aoex;
+aoey;
+aoez;
+aofa;
+aofb;
+aofc;
+aofd;
+aofe;
+aoff;
+aofg;
+aofh;
+aofi;
+aofj;
+aofk;
+aofl;
+aofm;
+aofn;
+aofo;
+aofp;
+aofq;
+aofr;
+aofs;
+aoft;
+aofu;
+aofv;
+aofw;
+aofx;
+aofy;
+aofz;
+aoga;
+aogb;
+aogc;
+aogd;
+aoge;
+aogf;
+aogg;
+aogh;
+aogi;
+aogj;
+aogk;
+aogl;
+aogm;
+aogn;
+aogo;
+aogp;
+aogq;
+aogr;
+aogs;
+aogt;
+aogu;
+aogv;
+aogw;
+aogx;
+aogy;
+aogz;
+aoha;
+aohb;
+aohc;
+aohd;
+aohe;
+aohf;
+aohg;
+aohh;
+aohi;
+aohj;
+aohk;
+aohl;
+aohm;
+aohn;
+aoho;
+aohp;
+aohq;
+aohr;
+aohs;
+aoht;
+aohu;
+aohv;
+aohw;
+aohx;
+aohy;
+aohz;
+aoia;
+aoib;
+aoic;
+aoid;
+aoie;
+aoif;
+aoig;
+aoih;
+aoii;
+aoij;
+aoik;
+aoil;
+aoim;
+aoin;
+aoio;
+aoip;
+aoiq;
+aoir;
+aois;
+aoit;
+aoiu;
+aoiv;
+aoiw;
+aoix;
+aoiy;
+aoiz;
+aoja;
+aojb;
+aojc;
+aojd;
+aoje;
+aojf;
+aojg;
+aojh;
+aoji;
+aojj;
+aojk;
+aojl;
+aojm;
+aojn;
+aojo;
+aojp;
+aojq;
+aojr;
+aojs;
+aojt;
+aoju;
+aojv;
+aojw;
+aojx;
+aojy;
+aojz;
+aoka;
+aokb;
+aokc;
+aokd;
+aoke;
+aokf;
+aokg;
+aokh;
+aoki;
+aokj;
+aokk;
+aokl;
+aokm;
+aokn;
+aoko;
+aokp;
+aokq;
+aokr;
+aoks;
+aokt;
+aoku;
+aokv;
+aokw;
+aokx;
+aoky;
+aokz;
+aola;
+aolb;
+aolc;
+aold;
+aole;
+aolf;
+aolg;
+aolh;
+aoli;
+aolj;
+aolk;
+aoll;
+aolm;
+aoln;
+aolo;
+aolp;
+aolq;
+aolr;
+aols;
+aolt;
+aolu;
+aolv;
+aolw;
+aolx;
+aoly;
+aolz;
+aoma;
+aomb;
+aomc;
+aomd;
+aome;
+aomf;
+aomg;
+aomh;
+aomi;
+aomj;
+aomk;
+aoml;
+aomm;
+aomn;
+aomo;
+aomp;
+aomq;
+aomr;
+aoms;
+aomt;
+aomu;
+aomv;
+aomw;
+aomx;
+aomy;
+aomz;
+aona;
+aonb;
+aonc;
+aond;
+aone;
+aonf;
+aong;
+aonh;
+aoni;
+aonj;
+aonk;
+aonl;
+aonm;
+aonn;
+aono;
+aonp;
+aonq;
+aonr;
+aons;
+aont;
+aonu;
+aonv;
+aonw;
+aonx;
+aony;
+aonz;
+aooa;
+aoob;
+aooc;
+aood;
+aooe;
+aoof;
+aoog;
+aooh;
+aooi;
+aooj;
+aook;
+aool;
+aoom;
+aoon;
+aooo;
+aoop;
+aooq;
+aoor;
+aoos;
+aoot;
+aoou;
+aoov;
+aoow;
+aoox;
+aooy;
+aooz;
+aopa;
+aopb;
+aopc;
+aopd;
+aope;
+aopf;
+aopg;
+aoph;
+aopi;
+aopj;
+aopk;
+aopl;
+aopm;
+aopn;
+aopo;
+aopp;
+aopq;
+aopr;
+aops;
+aopt;
+aopu;
+aopv;
+aopw;
+aopx;
+aopy;
+aopz;
+aoqa;
+aoqb;
+aoqc;
+aoqd;
+aoqe;
+aoqf;
+aoqg;
+aoqh;
+aoqi;
+aoqj;
+aoqk;
+aoql;
+aoqm;
+aoqn;
+aoqo;
+aoqp;
+aoqq;
+aoqr;
+aoqs;
+aoqt;
+aoqu;
+aoqv;
+aoqw;
+aoqx;
+aoqy;
+aoqz;
+aora;
+aorb;
+aorc;
+aord;
+aore;
+aorf;
+aorg;
+aorh;
+aori;
+aorj;
+aork;
+aorl;
+aorm;
+aorn;
+aoro;
+aorp;
+aorq;
+aorr;
+aors;
+aort;
+aoru;
+aorv;
+aorw;
+aorx;
+aory;
+aorz;
+aosa;
+aosb;
+aosc;
+aosd;
+aose;
+aosf;
+aosg;
+aosh;
+aosi;
+aosj;
+aosk;
+aosl;
+aosm;
+aosn;
+aoso;
+aosp;
+aosq;
+aosr;
+aoss;
+aost;
+aosu;
+aosv;
+aosw;
+aosx;
+aosy;
+aosz;
+aota;
+aotb;
+aotc;
+aotd;
+aote;
+aotf;
+aotg;
+aoth;
+aoti;
+aotj;
+aotk;
+aotl;
+aotm;
+aotn;
+aoto;
+aotp;
+aotq;
+aotr;
+aots;
+aott;
+aotu;
+aotv;
+aotw;
+aotx;
+aoty;
+aotz;
+aoua;
+aoub;
+aouc;
+aoud;
+aoue;
+aouf;
+aoug;
+aouh;
+aoui;
+aouj;
+aouk;
+aoul;
+aoum;
+aoun;
+aouo;
+aoup;
+aouq;
+aour;
+aous;
+aout;
+aouu;
+aouv;
+aouw;
+aoux;
+aouy;
+aouz;
+aova;
+aovb;
+aovc;
+aovd;
+aove;
+aovf;
+aovg;
+aovh;
+aovi;
+aovj;
+aovk;
+aovl;
+aovm;
+aovn;
+aovo;
+aovp;
+aovq;
+aovr;
+aovs;
+aovt;
+aovu;
+aovv;
+aovw;
+aovx;
+aovy;
+aovz;
+aowa;
+aowb;
+aowc;
+aowd;
+aowe;
+aowf;
+aowg;
+aowh;
+aowi;
+aowj;
+aowk;
+aowl;
+aowm;
+aown;
+aowo;
+aowp;
+aowq;
+aowr;
+aows;
+aowt;
+aowu;
+aowv;
+aoww;
+aowx;
+aowy;
+aowz;
+aoxa;
+aoxb;
+aoxc;
+aoxd;
+aoxe;
+aoxf;
+aoxg;
+aoxh;
+aoxi;
+aoxj;
+aoxk;
+aoxl;
+aoxm;
+aoxn;
+aoxo;
+aoxp;
+aoxq;
+aoxr;
+aoxs;
+aoxt;
+aoxu;
+aoxv;
+aoxw;
+aoxx;
+aoxy;
+aoxz;
+aoya;
+aoyb;
+aoyc;
+aoyd;
+aoye;
+aoyf;
+aoyg;
+aoyh;
+aoyi;
+aoyj;
+aoyk;
+aoyl;
+aoym;
+aoyn;
+aoyo;
+aoyp;
+aoyq;
+aoyr;
+aoys;
+aoyt;
+aoyu;
+aoyv;
+aoyw;
+aoyx;
+aoyy;
+aoyz;
+aoza;
+aozb;
+aozc;
+aozd;
+aoze;
+aozf;
+aozg;
+aozh;
+aozi;
+aozj;
+aozk;
+aozl;
+aozm;
+aozn;
+aozo;
+aozp;
+aozq;
+aozr;
+aozs;
+aozt;
+aozu;
+aozv;
+aozw;
+aozx;
+aozy;
+aozz;
+apaa;
+apab;
+apac;
+apad;
+apae;
+apaf;
+apag;
+apah;
+apai;
+apaj;
+apak;
+apal;
+apam;
+apan;
+apao;
+apap;
+apaq;
+apar;
+apas;
+apat;
+apau;
+apav;
+apaw;
+apax;
+apay;
+apaz;
+apba;
+apbb;
+apbc;
+apbd;
+apbe;
+apbf;
+apbg;
+apbh;
+apbi;
+apbj;
+apbk;
+apbl;
+apbm;
+apbn;
+apbo;
+apbp;
+apbq;
+apbr;
+apbs;
+apbt;
+apbu;
+apbv;
+apbw;
+apbx;
+apby;
+apbz;
+apca;
+apcb;
+apcc;
+apcd;
+apce;
+apcf;
+apcg;
+apch;
+apci;
+apcj;
+apck;
+apcl;
+apcm;
+apcn;
+apco;
+apcp;
+apcq;
+apcr;
+apcs;
+apct;
+apcu;
+apcv;
+apcw;
+apcx;
+apcy;
+apcz;
+apda;
+apdb;
+apdc;
+apdd;
+apde;
+apdf;
+apdg;
+apdh;
+apdi;
+apdj;
+apdk;
+apdl;
+apdm;
+apdn;
+apdo;
+apdp;
+apdq;
+apdr;
+apds;
+apdt;
+apdu;
+apdv;
+apdw;
+apdx;
+apdy;
+apdz;
+apea;
+apeb;
+apec;
+aped;
+apee;
+apef;
+apeg;
+apeh;
+apei;
+apej;
+apek;
+apel;
+apem;
+apen;
+apeo;
+apep;
+apeq;
+aper;
+apes;
+apet;
+apeu;
+apev;
+apew;
+apex;
+apey;
+apez;
+apfa;
+apfb;
+apfc;
+apfd;
+apfe;
+apff;
+apfg;
+apfh;
+apfi;
+apfj;
+apfk;
+apfl;
+apfm;
+apfn;
+apfo;
+apfp;
+apfq;
+apfr;
+apfs;
+apft;
+apfu;
+apfv;
+apfw;
+apfx;
+apfy;
+apfz;
+apga;
+apgb;
+apgc;
+apgd;
+apge;
+apgf;
+apgg;
+apgh;
+apgi;
+apgj;
+apgk;
+apgl;
+apgm;
+apgn;
+apgo;
+apgp;
+apgq;
+apgr;
+apgs;
+apgt;
+apgu;
+apgv;
+apgw;
+apgx;
+apgy;
+apgz;
+apha;
+aphb;
+aphc;
+aphd;
+aphe;
+aphf;
+aphg;
+aphh;
+aphi;
+aphj;
+aphk;
+aphl;
+aphm;
+aphn;
+apho;
+aphp;
+aphq;
+aphr;
+aphs;
+apht;
+aphu;
+aphv;
+aphw;
+aphx;
+aphy;
+aphz;
+apia;
+apib;
+apic;
+apid;
+apie;
+apif;
+apig;
+apih;
+apii;
+apij;
+apik;
+apil;
+apim;
+apin;
+apio;
+apip;
+apiq;
+apir;
+apis;
+apit;
+apiu;
+apiv;
+apiw;
+apix;
+apiy;
+apiz;
+apja;
+apjb;
+apjc;
+apjd;
+apje;
+apjf;
+apjg;
+apjh;
+apji;
+apjj;
+apjk;
+apjl;
+apjm;
+apjn;
+apjo;
+apjp;
+apjq;
+apjr;
+apjs;
+apjt;
+apju;
+apjv;
+apjw;
+apjx;
+apjy;
+apjz;
+apka;
+apkb;
+apkc;
+apkd;
+apke;
+apkf;
+apkg;
+apkh;
+apki;
+apkj;
+apkk;
+apkl;
+apkm;
+apkn;
+apko;
+apkp;
+apkq;
+apkr;
+apks;
+apkt;
+apku;
+apkv;
+apkw;
+apkx;
+apky;
+apkz;
+apla;
+aplb;
+aplc;
+apld;
+aple;
+aplf;
+aplg;
+aplh;
+apli;
+aplj;
+aplk;
+apll;
+aplm;
+apln;
+aplo;
+aplp;
+aplq;
+aplr;
+apls;
+aplt;
+aplu;
+aplv;
+aplw;
+aplx;
+aply;
+aplz;
+apma;
+apmb;
+apmc;
+apmd;
+apme;
+apmf;
+apmg;
+apmh;
+apmi;
+apmj;
+apmk;
+apml;
+apmm;
+apmn;
+apmo;
+apmp;
+apmq;
+apmr;
+apms;
+apmt;
+apmu;
+apmv;
+apmw;
+apmx;
+apmy;
+apmz;
+apna;
+apnb;
+apnc;
+apnd;
+apne;
+apnf;
+apng;
+apnh;
+apni;
+apnj;
+apnk;
+apnl;
+apnm;
+apnn;
+apno;
+apnp;
+apnq;
+apnr;
+apns;
+apnt;
+apnu;
+apnv;
+apnw;
+apnx;
+apny;
+apnz;
+apoa;
+apob;
+apoc;
+apod;
+apoe;
+apof;
+apog;
+apoh;
+apoi;
+apoj;
+apok;
+apol;
+apom;
+apon;
+apoo;
+apop;
+apoq;
+apor;
+apos;
+apot;
+apou;
+apov;
+apow;
+apox;
+apoy;
+apoz;
+appa;
+appb;
+appc;
+appd;
+appe;
+appf;
+appg;
+apph;
+appi;
+appj;
+appk;
+appl;
+appm;
+appn;
+appo;
+appp;
+appq;
+appr;
+apps;
+appt;
+appu;
+appv;
+appw;
+appx;
+appy;
+appz;
+apqa;
+apqb;
+apqc;
+apqd;
+apqe;
+apqf;
+apqg;
+apqh;
+apqi;
+apqj;
+apqk;
+apql;
+apqm;
+apqn;
+apqo;
+apqp;
+apqq;
+apqr;
+apqs;
+apqt;
+apqu;
+apqv;
+apqw;
+apqx;
+apqy;
+apqz;
+apra;
+aprb;
+aprc;
+aprd;
+apre;
+aprf;
+aprg;
+aprh;
+apri;
+aprj;
+aprk;
+aprl;
+aprm;
+aprn;
+apro;
+aprp;
+aprq;
+aprr;
+aprs;
+aprt;
+apru;
+aprv;
+aprw;
+aprx;
+apry;
+aprz;
+apsa;
+apsb;
+apsc;
+apsd;
+apse;
+apsf;
+apsg;
+apsh;
+apsi;
+apsj;
+apsk;
+apsl;
+apsm;
+apsn;
+apso;
+apsp;
+apsq;
+apsr;
+apss;
+apst;
+apsu;
+apsv;
+apsw;
+apsx;
+apsy;
+apsz;
+apta;
+aptb;
+aptc;
+aptd;
+apte;
+aptf;
+aptg;
+apth;
+apti;
+aptj;
+aptk;
+aptl;
+aptm;
+aptn;
+apto;
+aptp;
+aptq;
+aptr;
+apts;
+aptt;
+aptu;
+aptv;
+aptw;
+aptx;
+apty;
+aptz;
+apua;
+apub;
+apuc;
+apud;
+apue;
+apuf;
+apug;
+apuh;
+apui;
+apuj;
+apuk;
+apul;
+apum;
+apun;
+apuo;
+apup;
+apuq;
+apur;
+apus;
+aput;
+apuu;
+apuv;
+apuw;
+apux;
+apuy;
+apuz;
+apva;
+apvb;
+apvc;
+apvd;
+apve;
+apvf;
+apvg;
+apvh;
+apvi;
+apvj;
+apvk;
+apvl;
+apvm;
+apvn;
+apvo;
+apvp;
+apvq;
+apvr;
+apvs;
+apvt;
+apvu;
+apvv;
+apvw;
+apvx;
+apvy;
+apvz;
+apwa;
+apwb;
+apwc;
+apwd;
+apwe;
+apwf;
+apwg;
+apwh;
+apwi;
+apwj;
+apwk;
+apwl;
+apwm;
+apwn;
+apwo;
+apwp;
+apwq;
+apwr;
+apws;
+apwt;
+apwu;
+apwv;
+apww;
+apwx;
+apwy;
+apwz;
+apxa;
+apxb;
+apxc;
+apxd;
+apxe;
+apxf;
+apxg;
+apxh;
+apxi;
+apxj;
+apxk;
+apxl;
+apxm;
+apxn;
+apxo;
+apxp;
+apxq;
+apxr;
+apxs;
+apxt;
+apxu;
+apxv;
+apxw;
+apxx;
+apxy;
+apxz;
+apya;
+apyb;
+apyc;
+apyd;
+apye;
+apyf;
+apyg;
+apyh;
+apyi;
+apyj;
+apyk;
+apyl;
+apym;
+apyn;
+apyo;
+apyp;
+apyq;
+apyr;
+apys;
+apyt;
+apyu;
+apyv;
+apyw;
+apyx;
+apyy;
+apyz;
+apza;
+apzb;
+apzc;
+apzd;
+apze;
+apzf;
+apzg;
+apzh;
+apzi;
+apzj;
+apzk;
+apzl;
+apzm;
+apzn;
+apzo;
+apzp;
+apzq;
+apzr;
+apzs;
+apzt;
+apzu;
+apzv;
+apzw;
+apzx;
+apzy;
+apzz;
+aqaa;
+aqab;
+aqac;
+aqad;
+aqae;
+aqaf;
+aqag;
+aqah;
+aqai;
+aqaj;
+aqak;
+aqal;
+aqam;
+aqan;
+aqao;
+aqap;
+aqaq;
+aqar;
+aqas;
+aqat;
+aqau;
+aqav;
+aqaw;
+aqax;
+aqay;
+aqaz;
+aqba;
+aqbb;
+aqbc;
+aqbd;
+aqbe;
+aqbf;
+aqbg;
+aqbh;
+aqbi;
+aqbj;
+aqbk;
+aqbl;
+aqbm;
+aqbn;
+aqbo;
+aqbp;
+aqbq;
+aqbr;
+aqbs;
+aqbt;
+aqbu;
+aqbv;
+aqbw;
+aqbx;
+aqby;
+aqbz;
+aqca;
+aqcb;
+aqcc;
+aqcd;
+aqce;
+aqcf;
+aqcg;
+aqch;
+aqci;
+aqcj;
+aqck;
+aqcl;
+aqcm;
+aqcn;
+aqco;
+aqcp;
+aqcq;
+aqcr;
+aqcs;
+aqct;
+aqcu;
+aqcv;
+aqcw;
+aqcx;
+aqcy;
+aqcz;
+aqda;
+aqdb;
+aqdc;
+aqdd;
+aqde;
+aqdf;
+aqdg;
+aqdh;
+aqdi;
+aqdj;
+aqdk;
+aqdl;
+aqdm;
+aqdn;
+aqdo;
+aqdp;
+aqdq;
+aqdr;
+aqds;
+aqdt;
+aqdu;
+aqdv;
+aqdw;
+aqdx;
+aqdy;
+aqdz;
+aqea;
+aqeb;
+aqec;
+aqed;
+aqee;
+aqef;
+aqeg;
+aqeh;
+aqei;
+aqej;
+aqek;
+aqel;
+aqem;
+aqen;
+aqeo;
+aqep;
+aqeq;
+aqer;
+aqes;
+aqet;
+aqeu;
+aqev;
+aqew;
+aqex;
+aqey;
+aqez;
+aqfa;
+aqfb;
+aqfc;
+aqfd;
+aqfe;
+aqff;
+aqfg;
+aqfh;
+aqfi;
+aqfj;
+aqfk;
+aqfl;
+aqfm;
+aqfn;
+aqfo;
+aqfp;
+aqfq;
+aqfr;
+aqfs;
+aqft;
+aqfu;
+aqfv;
+aqfw;
+aqfx;
+aqfy;
+aqfz;
+aqga;
+aqgb;
+aqgc;
+aqgd;
+aqge;
+aqgf;
+aqgg;
+aqgh;
+aqgi;
+aqgj;
+aqgk;
+aqgl;
+aqgm;
+aqgn;
+aqgo;
+aqgp;
+aqgq;
+aqgr;
+aqgs;
+aqgt;
+aqgu;
+aqgv;
+aqgw;
+aqgx;
+aqgy;
+aqgz;
+aqha;
+aqhb;
+aqhc;
+aqhd;
+aqhe;
+aqhf;
+aqhg;
+aqhh;
+aqhi;
+aqhj;
+aqhk;
+aqhl;
+aqhm;
+aqhn;
+aqho;
+aqhp;
+aqhq;
+aqhr;
+aqhs;
+aqht;
+aqhu;
+aqhv;
+aqhw;
+aqhx;
+aqhy;
+aqhz;
+aqia;
+aqib;
+aqic;
+aqid;
+aqie;
+aqif;
+aqig;
+aqih;
+aqii;
+aqij;
+aqik;
+aqil;
+aqim;
+aqin;
+aqio;
+aqip;
+aqiq;
+aqir;
+aqis;
+aqit;
+aqiu;
+aqiv;
+aqiw;
+aqix;
+aqiy;
+aqiz;
+aqja;
+aqjb;
+aqjc;
+aqjd;
+aqje;
+aqjf;
+aqjg;
+aqjh;
+aqji;
+aqjj;
+aqjk;
+aqjl;
+aqjm;
+aqjn;
+aqjo;
+aqjp;
+aqjq;
+aqjr;
+aqjs;
+aqjt;
+aqju;
+aqjv;
+aqjw;
+aqjx;
+aqjy;
+aqjz;
+aqka;
+aqkb;
+aqkc;
+aqkd;
+aqke;
+aqkf;
+aqkg;
+aqkh;
+aqki;
+aqkj;
+aqkk;
+aqkl;
+aqkm;
+aqkn;
+aqko;
+aqkp;
+aqkq;
+aqkr;
+aqks;
+aqkt;
+aqku;
+aqkv;
+aqkw;
+aqkx;
+aqky;
+aqkz;
+aqla;
+aqlb;
+aqlc;
+aqld;
+aqle;
+aqlf;
+aqlg;
+aqlh;
+aqli;
+aqlj;
+aqlk;
+aqll;
+aqlm;
+aqln;
+aqlo;
+aqlp;
+aqlq;
+aqlr;
+aqls;
+aqlt;
+aqlu;
+aqlv;
+aqlw;
+aqlx;
+aqly;
+aqlz;
+aqma;
+aqmb;
+aqmc;
+aqmd;
+aqme;
+aqmf;
+aqmg;
+aqmh;
+aqmi;
+aqmj;
+aqmk;
+aqml;
+aqmm;
+aqmn;
+aqmo;
+aqmp;
+aqmq;
+aqmr;
+aqms;
+aqmt;
+aqmu;
+aqmv;
+aqmw;
+aqmx;
+aqmy;
+aqmz;
+aqna;
+aqnb;
+aqnc;
+aqnd;
+aqne;
+aqnf;
+aqng;
+aqnh;
+aqni;
+aqnj;
+aqnk;
+aqnl;
+aqnm;
+aqnn;
+aqno;
+aqnp;
+aqnq;
+aqnr;
+aqns;
+aqnt;
+aqnu;
+aqnv;
+aqnw;
+aqnx;
+aqny;
+aqnz;
+aqoa;
+aqob;
+aqoc;
+aqod;
+aqoe;
+aqof;
+aqog;
+aqoh;
+aqoi;
+aqoj;
+aqok;
+aqol;
+aqom;
+aqon;
+aqoo;
+aqop;
+aqoq;
+aqor;
+aqos;
+aqot;
+aqou;
+aqov;
+aqow;
+aqox;
+aqoy;
+aqoz;
+aqpa;
+aqpb;
+aqpc;
+aqpd;
+aqpe;
+aqpf;
+aqpg;
+aqph;
+aqpi;
+aqpj;
+aqpk;
+aqpl;
+aqpm;
+aqpn;
+aqpo;
+aqpp;
+aqpq;
+aqpr;
+aqps;
+aqpt;
+aqpu;
+aqpv;
+aqpw;
+aqpx;
+aqpy;
+aqpz;
+aqqa;
+aqqb;
+aqqc;
+aqqd;
+aqqe;
+aqqf;
+aqqg;
+aqqh;
+aqqi;
+aqqj;
+aqqk;
+aqql;
+aqqm;
+aqqn;
+aqqo;
+aqqp;
+aqqq;
+aqqr;
+aqqs;
+aqqt;
+aqqu;
+aqqv;
+aqqw;
+aqqx;
+aqqy;
+aqqz;
+aqra;
+aqrb;
+aqrc;
+aqrd;
+aqre;
+aqrf;
+aqrg;
+aqrh;
+aqri;
+aqrj;
+aqrk;
+aqrl;
+aqrm;
+aqrn;
+aqro;
+aqrp;
+aqrq;
+aqrr;
+aqrs;
+aqrt;
+aqru;
+aqrv;
+aqrw;
+aqrx;
+aqry;
+aqrz;
+aqsa;
+aqsb;
+aqsc;
+aqsd;
+aqse;
+aqsf;
+aqsg;
+aqsh;
+aqsi;
+aqsj;
+aqsk;
+aqsl;
+aqsm;
+aqsn;
+aqso;
+aqsp;
+aqsq;
+aqsr;
+aqss;
+aqst;
+aqsu;
+aqsv;
+aqsw;
+aqsx;
+aqsy;
+aqsz;
+aqta;
+aqtb;
+aqtc;
+aqtd;
+aqte;
+aqtf;
+aqtg;
+aqth;
+aqti;
+aqtj;
+aqtk;
+aqtl;
+aqtm;
+aqtn;
+aqto;
+aqtp;
+aqtq;
+aqtr;
+aqts;
+aqtt;
+aqtu;
+aqtv;
+aqtw;
+aqtx;
+aqty;
+aqtz;
+aqua;
+aqub;
+aquc;
+aqud;
+aque;
+aquf;
+aqug;
+aquh;
+aqui;
+aquj;
+aquk;
+aqul;
+aqum;
+aqun;
+aquo;
+aqup;
+aquq;
+aqur;
+aqus;
+aqut;
+aquu;
+aquv;
+aquw;
+aqux;
+aquy;
+aquz;
+aqva;
+aqvb;
+aqvc;
+aqvd;
+aqve;
+aqvf;
+aqvg;
+aqvh;
+aqvi;
+aqvj;
+aqvk;
+aqvl;
+aqvm;
+aqvn;
+aqvo;
+aqvp;
+aqvq;
+aqvr;
+aqvs;
+aqvt;
+aqvu;
+aqvv;
+aqvw;
+aqvx;
+aqvy;
+aqvz;
+aqwa;
+aqwb;
+aqwc;
+aqwd;
+aqwe;
+aqwf;
+aqwg;
+aqwh;
+aqwi;
+aqwj;
+aqwk;
+aqwl;
+aqwm;
+aqwn;
+aqwo;
+aqwp;
+aqwq;
+aqwr;
+aqws;
+aqwt;
+aqwu;
+aqwv;
+aqww;
+aqwx;
+aqwy;
+aqwz;
+aqxa;
+aqxb;
+aqxc;
+aqxd;
+aqxe;
+aqxf;
+aqxg;
+aqxh;
+aqxi;
+aqxj;
+aqxk;
+aqxl;
+aqxm;
+aqxn;
+aqxo;
+aqxp;
+aqxq;
+aqxr;
+aqxs;
+aqxt;
+aqxu;
+aqxv;
+aqxw;
+aqxx;
+aqxy;
+aqxz;
+aqya;
+aqyb;
+aqyc;
+aqyd;
+aqye;
+aqyf;
+aqyg;
+aqyh;
+aqyi;
+aqyj;
+aqyk;
+aqyl;
+aqym;
+aqyn;
+aqyo;
+aqyp;
+aqyq;
+aqyr;
+aqys;
+aqyt;
+aqyu;
+aqyv;
+aqyw;
+aqyx;
+aqyy;
+aqyz;
+aqza;
+aqzb;
+aqzc;
+aqzd;
+aqze;
+aqzf;
+aqzg;
+aqzh;
+aqzi;
+aqzj;
+aqzk;
+aqzl;
+aqzm;
+aqzn;
+aqzo;
+aqzp;
+aqzq;
+aqzr;
+aqzs;
+aqzt;
+aqzu;
+aqzv;
+aqzw;
+aqzx;
+aqzy;
+aqzz;
+araa;
+arab;
+arac;
+arad;
+arae;
+araf;
+arag;
+arah;
+arai;
+araj;
+arak;
+aral;
+aram;
+aran;
+arao;
+arap;
+araq;
+arar;
+aras;
+arat;
+arau;
+arav;
+araw;
+arax;
+aray;
+araz;
+arba;
+arbb;
+arbc;
+arbd;
+arbe;
+arbf;
+arbg;
+arbh;
+arbi;
+arbj;
+arbk;
+arbl;
+arbm;
+arbn;
+arbo;
+arbp;
+arbq;
+arbr;
+arbs;
+arbt;
+arbu;
+arbv;
+arbw;
+arbx;
+arby;
+arbz;
+arca;
+arcb;
+arcc;
+arcd;
+arce;
+arcf;
+arcg;
+arch;
+arci;
+arcj;
+arck;
+arcl;
+arcm;
+arcn;
+arco;
+arcp;
+arcq;
+arcr;
+arcs;
+arct;
+arcu;
+arcv;
+arcw;
+arcx;
+arcy;
+arcz;
+arda;
+ardb;
+ardc;
+ardd;
+arde;
+ardf;
+ardg;
+ardh;
+ardi;
+ardj;
+ardk;
+ardl;
+ardm;
+ardn;
+ardo;
+ardp;
+ardq;
+ardr;
+ards;
+ardt;
+ardu;
+ardv;
+ardw;
+ardx;
+ardy;
+ardz;
+area;
+areb;
+arec;
+ared;
+aree;
+aref;
+areg;
+areh;
+arei;
+arej;
+arek;
+arel;
+arem;
+aren;
+areo;
+arep;
+areq;
+arer;
+ares;
+aret;
+areu;
+arev;
+arew;
+arex;
+arey;
+arez;
+arfa;
+arfb;
+arfc;
+arfd;
+arfe;
+arff;
+arfg;
+arfh;
+arfi;
+arfj;
+arfk;
+arfl;
+arfm;
+arfn;
+arfo;
+arfp;
+arfq;
+arfr;
+arfs;
+arft;
+arfu;
+arfv;
+arfw;
+arfx;
+arfy;
+arfz;
+arga;
+argb;
+argc;
+argd;
+arge;
+argf;
+argg;
+argh;
+argi;
+argj;
+argk;
+argl;
+argm;
+argn;
+argo;
+argp;
+argq;
+argr;
+args;
+argt;
+argu;
+argv;
+argw;
+argx;
+argy;
+argz;
+arha;
+arhb;
+arhc;
+arhd;
+arhe;
+arhf;
+arhg;
+arhh;
+arhi;
+arhj;
+arhk;
+arhl;
+arhm;
+arhn;
+arho;
+arhp;
+arhq;
+arhr;
+arhs;
+arht;
+arhu;
+arhv;
+arhw;
+arhx;
+arhy;
+arhz;
+aria;
+arib;
+aric;
+arid;
+arie;
+arif;
+arig;
+arih;
+arii;
+arij;
+arik;
+aril;
+arim;
+arin;
+ario;
+arip;
+ariq;
+arir;
+aris;
+arit;
+ariu;
+ariv;
+ariw;
+arix;
+ariy;
+ariz;
+arja;
+arjb;
+arjc;
+arjd;
+arje;
+arjf;
+arjg;
+arjh;
+arji;
+arjj;
+arjk;
+arjl;
+arjm;
+arjn;
+arjo;
+arjp;
+arjq;
+arjr;
+arjs;
+arjt;
+arju;
+arjv;
+arjw;
+arjx;
+arjy;
+arjz;
+arka;
+arkb;
+arkc;
+arkd;
+arke;
+arkf;
+arkg;
+arkh;
+arki;
+arkj;
+arkk;
+arkl;
+arkm;
+arkn;
+arko;
+arkp;
+arkq;
+arkr;
+arks;
+arkt;
+arku;
+arkv;
+arkw;
+arkx;
+arky;
+arkz;
+arla;
+arlb;
+arlc;
+arld;
+arle;
+arlf;
+arlg;
+arlh;
+arli;
+arlj;
+arlk;
+arll;
+arlm;
+arln;
+arlo;
+arlp;
+arlq;
+arlr;
+arls;
+arlt;
+arlu;
+arlv;
+arlw;
+arlx;
+arly;
+arlz;
+arma;
+armb;
+armc;
+armd;
+arme;
+armf;
+armg;
+armh;
+armi;
+armj;
+armk;
+arml;
+armm;
+armn;
+armo;
+armp;
+armq;
+armr;
+arms;
+armt;
+armu;
+armv;
+armw;
+armx;
+army;
+armz;
+arna;
+arnb;
+arnc;
+arnd;
+arne;
+arnf;
+arng;
+arnh;
+arni;
+arnj;
+arnk;
+arnl;
+arnm;
+arnn;
+arno;
+arnp;
+arnq;
+arnr;
+arns;
+arnt;
+arnu;
+arnv;
+arnw;
+arnx;
+arny;
+arnz;
+aroa;
+arob;
+aroc;
+arod;
+aroe;
+arof;
+arog;
+aroh;
+aroi;
+aroj;
+arok;
+arol;
+arom;
+aron;
+aroo;
+arop;
+aroq;
+aror;
+aros;
+arot;
+arou;
+arov;
+arow;
+arox;
+aroy;
+aroz;
+arpa;
+arpb;
+arpc;
+arpd;
+arpe;
+arpf;
+arpg;
+arph;
+arpi;
+arpj;
+arpk;
+arpl;
+arpm;
+arpn;
+arpo;
+arpp;
+arpq;
+arpr;
+arps;
+arpt;
+arpu;
+arpv;
+arpw;
+arpx;
+arpy;
+arpz;
+arqa;
+arqb;
+arqc;
+arqd;
+arqe;
+arqf;
+arqg;
+arqh;
+arqi;
+arqj;
+arqk;
+arql;
+arqm;
+arqn;
+arqo;
+arqp;
+arqq;
+arqr;
+arqs;
+arqt;
+arqu;
+arqv;
+arqw;
+arqx;
+arqy;
+arqz;
+arra;
+arrb;
+arrc;
+arrd;
+arre;
+arrf;
+arrg;
+arrh;
+arri;
+arrj;
+arrk;
+arrl;
+arrm;
+arrn;
+arro;
+arrp;
+arrq;
+arrr;
+arrs;
+arrt;
+arru;
+arrv;
+arrw;
+arrx;
+arry;
+arrz;
+arsa;
+arsb;
+arsc;
+arsd;
+arse;
+arsf;
+arsg;
+arsh;
+arsi;
+arsj;
+arsk;
+arsl;
+arsm;
+arsn;
+arso;
+arsp;
+arsq;
+arsr;
+arss;
+arst;
+arsu;
+arsv;
+arsw;
+arsx;
+arsy;
+arsz;
+arta;
+artb;
+artc;
+artd;
+arte;
+artf;
+artg;
+arth;
+arti;
+artj;
+artk;
+artl;
+artm;
+artn;
+arto;
+artp;
+artq;
+artr;
+arts;
+artt;
+artu;
+artv;
+artw;
+artx;
+arty;
+artz;
+arua;
+arub;
+aruc;
+arud;
+arue;
+aruf;
+arug;
+aruh;
+arui;
+aruj;
+aruk;
+arul;
+arum;
+arun;
+aruo;
+arup;
+aruq;
+arur;
+arus;
+arut;
+aruu;
+aruv;
+aruw;
+arux;
+aruy;
+aruz;
+arva;
+arvb;
+arvc;
+arvd;
+arve;
+arvf;
+arvg;
+arvh;
+arvi;
+arvj;
+arvk;
+arvl;
+arvm;
+arvn;
+arvo;
+arvp;
+arvq;
+arvr;
+arvs;
+arvt;
+arvu;
+arvv;
+arvw;
+arvx;
+arvy;
+arvz;
+arwa;
+arwb;
+arwc;
+arwd;
+arwe;
+arwf;
+arwg;
+arwh;
+arwi;
+arwj;
+arwk;
+arwl;
+arwm;
+arwn;
+arwo;
+arwp;
+arwq;
+arwr;
+arws;
+arwt;
+arwu;
+arwv;
+arww;
+arwx;
+arwy;
+arwz;
+arxa;
+arxb;
+arxc;
+arxd;
+arxe;
+arxf;
+arxg;
+arxh;
+arxi;
+arxj;
+arxk;
+arxl;
+arxm;
+arxn;
+arxo;
+arxp;
+arxq;
+arxr;
+arxs;
+arxt;
+arxu;
+arxv;
+arxw;
+arxx;
+arxy;
+arxz;
+arya;
+aryb;
+aryc;
+aryd;
+arye;
+aryf;
+aryg;
+aryh;
+aryi;
+aryj;
+aryk;
+aryl;
+arym;
+aryn;
+aryo;
+aryp;
+aryq;
+aryr;
+arys;
+aryt;
+aryu;
+aryv;
+aryw;
+aryx;
+aryy;
+aryz;
+arza;
+arzb;
+arzc;
+arzd;
+arze;
+arzf;
+arzg;
+arzh;
+arzi;
+arzj;
+arzk;
+arzl;
+arzm;
+arzn;
+arzo;
+arzp;
+arzq;
+arzr;
+arzs;
+arzt;
+arzu;
+arzv;
+arzw;
+arzx;
+arzy;
+arzz;
+asaa;
+asab;
+asac;
+asad;
+asae;
+asaf;
+asag;
+asah;
+asai;
+asaj;
+asak;
+asal;
+asam;
+asan;
+asao;
+asap;
+asaq;
+asar;
+asas;
+asat;
+asau;
+asav;
+asaw;
+asax;
+asay;
+asaz;
+asba;
+asbb;
+asbc;
+asbd;
+asbe;
+asbf;
+asbg;
+asbh;
+asbi;
+asbj;
+asbk;
+asbl;
+asbm;
+asbn;
+asbo;
+asbp;
+asbq;
+asbr;
+asbs;
+asbt;
+asbu;
+asbv;
+asbw;
+asbx;
+asby;
+asbz;
+asca;
+ascb;
+ascc;
+ascd;
+asce;
+ascf;
+ascg;
+asch;
+asci;
+ascj;
+asck;
+ascl;
+ascm;
+ascn;
+asco;
+ascp;
+ascq;
+ascr;
+ascs;
+asct;
+ascu;
+ascv;
+ascw;
+ascx;
+ascy;
+ascz;
+asda;
+asdb;
+asdc;
+asdd;
+asde;
+asdf;
+asdg;
+asdh;
+asdi;
+asdj;
+asdk;
+asdl;
+asdm;
+asdn;
+asdo;
+asdp;
+asdq;
+asdr;
+asds;
+asdt;
+asdu;
+asdv;
+asdw;
+asdx;
+asdy;
+asdz;
+asea;
+aseb;
+asec;
+ased;
+asee;
+asef;
+aseg;
+aseh;
+asei;
+asej;
+asek;
+asel;
+asem;
+asen;
+aseo;
+asep;
+aseq;
+aser;
+ases;
+aset;
+aseu;
+asev;
+asew;
+asex;
+asey;
+asez;
+asfa;
+asfb;
+asfc;
+asfd;
+asfe;
+asff;
+asfg;
+asfh;
+asfi;
+asfj;
+asfk;
+asfl;
+asfm;
+asfn;
+asfo;
+asfp;
+asfq;
+asfr;
+asfs;
+asft;
+asfu;
+asfv;
+asfw;
+asfx;
+asfy;
+asfz;
+asga;
+asgb;
+asgc;
+asgd;
+asge;
+asgf;
+asgg;
+asgh;
+asgi;
+asgj;
+asgk;
+asgl;
+asgm;
+asgn;
+asgo;
+asgp;
+asgq;
+asgr;
+asgs;
+asgt;
+asgu;
+asgv;
+asgw;
+asgx;
+asgy;
+asgz;
+asha;
+ashb;
+ashc;
+ashd;
+ashe;
+ashf;
+ashg;
+ashh;
+ashi;
+ashj;
+ashk;
+ashl;
+ashm;
+ashn;
+asho;
+ashp;
+ashq;
+ashr;
+ashs;
+asht;
+ashu;
+ashv;
+ashw;
+ashx;
+ashy;
+ashz;
+asia;
+asib;
+asic;
+asid;
+asie;
+asif;
+asig;
+asih;
+asii;
+asij;
+asik;
+asil;
+asim;
+asin;
+asio;
+asip;
+asiq;
+asir;
+asis;
+asit;
+asiu;
+asiv;
+asiw;
+asix;
+asiy;
+asiz;
+asja;
+asjb;
+asjc;
+asjd;
+asje;
+asjf;
+asjg;
+asjh;
+asji;
+asjj;
+asjk;
+asjl;
+asjm;
+asjn;
+asjo;
+asjp;
+asjq;
+asjr;
+asjs;
+asjt;
+asju;
+asjv;
+asjw;
+asjx;
+asjy;
+asjz;
+aska;
+askb;
+askc;
+askd;
+aske;
+askf;
+askg;
+askh;
+aski;
+askj;
+askk;
+askl;
+askm;
+askn;
+asko;
+askp;
+askq;
+askr;
+asks;
+askt;
+asku;
+askv;
+askw;
+askx;
+asky;
+askz;
+asla;
+aslb;
+aslc;
+asld;
+asle;
+aslf;
+aslg;
+aslh;
+asli;
+aslj;
+aslk;
+asll;
+aslm;
+asln;
+aslo;
+aslp;
+aslq;
+aslr;
+asls;
+aslt;
+aslu;
+aslv;
+aslw;
+aslx;
+asly;
+aslz;
+asma;
+asmb;
+asmc;
+asmd;
+asme;
+asmf;
+asmg;
+asmh;
+asmi;
+asmj;
+asmk;
+asml;
+asmm;
+asmn;
+asmo;
+asmp;
+asmq;
+asmr;
+asms;
+asmt;
+asmu;
+asmv;
+asmw;
+asmx;
+asmy;
+asmz;
+asna;
+asnb;
+asnc;
+asnd;
+asne;
+asnf;
+asng;
+asnh;
+asni;
+asnj;
+asnk;
+asnl;
+asnm;
+asnn;
+asno;
+asnp;
+asnq;
+asnr;
+asns;
+asnt;
+asnu;
+asnv;
+asnw;
+asnx;
+asny;
+asnz;
+asoa;
+asob;
+asoc;
+asod;
+asoe;
+asof;
+asog;
+asoh;
+asoi;
+asoj;
+asok;
+asol;
+asom;
+ason;
+asoo;
+asop;
+asoq;
+asor;
+asos;
+asot;
+asou;
+asov;
+asow;
+asox;
+asoy;
+asoz;
+aspa;
+aspb;
+aspc;
+aspd;
+aspe;
+aspf;
+aspg;
+asph;
+aspi;
+aspj;
+aspk;
+aspl;
+aspm;
+aspn;
+aspo;
+aspp;
+aspq;
+aspr;
+asps;
+aspt;
+aspu;
+aspv;
+aspw;
+aspx;
+aspy;
+aspz;
+asqa;
+asqb;
+asqc;
+asqd;
+asqe;
+asqf;
+asqg;
+asqh;
+asqi;
+asqj;
+asqk;
+asql;
+asqm;
+asqn;
+asqo;
+asqp;
+asqq;
+asqr;
+asqs;
+asqt;
+asqu;
+asqv;
+asqw;
+asqx;
+asqy;
+asqz;
+asra;
+asrb;
+asrc;
+asrd;
+asre;
+asrf;
+asrg;
+asrh;
+asri;
+asrj;
+asrk;
+asrl;
+asrm;
+asrn;
+asro;
+asrp;
+asrq;
+asrr;
+asrs;
+asrt;
+asru;
+asrv;
+asrw;
+asrx;
+asry;
+asrz;
+assa;
+assb;
+assc;
+assd;
+asse;
+assf;
+assg;
+assh;
+assi;
+assj;
+assk;
+assl;
+assm;
+assn;
+asso;
+assp;
+assq;
+assr;
+asss;
+asst;
+assu;
+assv;
+assw;
+assx;
+assy;
+assz;
+asta;
+astb;
+astc;
+astd;
+aste;
+astf;
+astg;
+asth;
+asti;
+astj;
+astk;
+astl;
+astm;
+astn;
+asto;
+astp;
+astq;
+astr;
+asts;
+astt;
+astu;
+astv;
+astw;
+astx;
+asty;
+astz;
+asua;
+asub;
+asuc;
+asud;
+asue;
+asuf;
+asug;
+asuh;
+asui;
+asuj;
+asuk;
+asul;
+asum;
+asun;
+asuo;
+asup;
+asuq;
+asur;
+asus;
+asut;
+asuu;
+asuv;
+asuw;
+asux;
+asuy;
+asuz;
+asva;
+asvb;
+asvc;
+asvd;
+asve;
+asvf;
+asvg;
+asvh;
+asvi;
+asvj;
+asvk;
+asvl;
+asvm;
+asvn;
+asvo;
+asvp;
+asvq;
+asvr;
+asvs;
+asvt;
+asvu;
+asvv;
+asvw;
+asvx;
+asvy;
+asvz;
+aswa;
+aswb;
+aswc;
+aswd;
+aswe;
+aswf;
+aswg;
+aswh;
+aswi;
+aswj;
+aswk;
+aswl;
+aswm;
+aswn;
+aswo;
+aswp;
+aswq;
+aswr;
+asws;
+aswt;
+aswu;
+aswv;
+asww;
+aswx;
+aswy;
+aswz;
+asxa;
+asxb;
+asxc;
+asxd;
+asxe;
+asxf;
+asxg;
+asxh;
+asxi;
+asxj;
+asxk;
+asxl;
+asxm;
+asxn;
+asxo;
+asxp;
+asxq;
+asxr;
+asxs;
+asxt;
+asxu;
+asxv;
+asxw;
+asxx;
+asxy;
+asxz;
+asya;
+asyb;
+asyc;
+asyd;
+asye;
+asyf;
+asyg;
+asyh;
+asyi;
+asyj;
+asyk;
+asyl;
+asym;
+asyn;
+asyo;
+asyp;
+asyq;
+asyr;
+asys;
+asyt;
+asyu;
+asyv;
+asyw;
+asyx;
+asyy;
+asyz;
+asza;
+aszb;
+aszc;
+aszd;
+asze;
+aszf;
+aszg;
+aszh;
+aszi;
+aszj;
+aszk;
+aszl;
+aszm;
+aszn;
+aszo;
+aszp;
+aszq;
+aszr;
+aszs;
+aszt;
+aszu;
+aszv;
+aszw;
+aszx;
+aszy;
+aszz;
+ataa;
+atab;
+atac;
+atad;
+atae;
+ataf;
+atag;
+atah;
+atai;
+ataj;
+atak;
+atal;
+atam;
+atan;
+atao;
+atap;
+ataq;
+atar;
+atas;
+atat;
+atau;
+atav;
+ataw;
+atax;
+atay;
+ataz;
+atba;
+atbb;
+atbc;
+atbd;
+atbe;
+atbf;
+atbg;
+atbh;
+atbi;
+atbj;
+atbk;
+atbl;
+atbm;
+atbn;
+atbo;
+atbp;
+atbq;
+atbr;
+atbs;
+atbt;
+atbu;
+atbv;
+atbw;
+atbx;
+atby;
+atbz;
+atca;
+atcb;
+atcc;
+atcd;
+atce;
+atcf;
+atcg;
+atch;
+atci;
+atcj;
+atck;
+atcl;
+atcm;
+atcn;
+atco;
+atcp;
+atcq;
+atcr;
+atcs;
+atct;
+atcu;
+atcv;
+atcw;
+atcx;
+atcy;
+atcz;
+atda;
+atdb;
+atdc;
+atdd;
+atde;
+atdf;
+atdg;
+atdh;
+atdi;
+atdj;
+atdk;
+atdl;
+atdm;
+atdn;
+atdo;
+atdp;
+atdq;
+atdr;
+atds;
+atdt;
+atdu;
+atdv;
+atdw;
+atdx;
+atdy;
+atdz;
+atea;
+ateb;
+atec;
+ated;
+atee;
+atef;
+ateg;
+ateh;
+atei;
+atej;
+atek;
+atel;
+atem;
+aten;
+ateo;
+atep;
+ateq;
+ater;
+ates;
+atet;
+ateu;
+atev;
+atew;
+atex;
+atey;
+atez;
+atfa;
+atfb;
+atfc;
+atfd;
+atfe;
+atff;
+atfg;
+atfh;
+atfi;
+atfj;
+atfk;
+atfl;
+atfm;
+atfn;
+atfo;
+atfp;
+atfq;
+atfr;
+atfs;
+atft;
+atfu;
+atfv;
+atfw;
+atfx;
+atfy;
+atfz;
+atga;
+atgb;
+atgc;
+atgd;
+atge;
+atgf;
+atgg;
+atgh;
+atgi;
+atgj;
+atgk;
+atgl;
+atgm;
+atgn;
+atgo;
+atgp;
+atgq;
+atgr;
+atgs;
+atgt;
+atgu;
+atgv;
+atgw;
+atgx;
+atgy;
+atgz;
+atha;
+athb;
+athc;
+athd;
+athe;
+athf;
+athg;
+athh;
+athi;
+athj;
+athk;
+athl;
+athm;
+athn;
+atho;
+athp;
+athq;
+athr;
+aths;
+atht;
+athu;
+athv;
+athw;
+athx;
+athy;
+athz;
+atia;
+atib;
+atic;
+atid;
+atie;
+atif;
+atig;
+atih;
+atii;
+atij;
+atik;
+atil;
+atim;
+atin;
+atio;
+atip;
+atiq;
+atir;
+atis;
+atit;
+atiu;
+ativ;
+atiw;
+atix;
+atiy;
+atiz;
+atja;
+atjb;
+atjc;
+atjd;
+atje;
+atjf;
+atjg;
+atjh;
+atji;
+atjj;
+atjk;
+atjl;
+atjm;
+atjn;
+atjo;
+atjp;
+atjq;
+atjr;
+atjs;
+atjt;
+atju;
+atjv;
+atjw;
+atjx;
+atjy;
+atjz;
+atka;
+atkb;
+atkc;
+atkd;
+atke;
+atkf;
+atkg;
+atkh;
+atki;
+atkj;
+atkk;
+atkl;
+atkm;
+atkn;
+atko;
+atkp;
+atkq;
+atkr;
+atks;
+atkt;
+atku;
+atkv;
+atkw;
+atkx;
+atky;
+atkz;
+atla;
+atlb;
+atlc;
+atld;
+atle;
+atlf;
+atlg;
+atlh;
+atli;
+atlj;
+atlk;
+atll;
+atlm;
+atln;
+atlo;
+atlp;
+atlq;
+atlr;
+atls;
+atlt;
+atlu;
+atlv;
+atlw;
+atlx;
+atly;
+atlz;
+atma;
+atmb;
+atmc;
+atmd;
+atme;
+atmf;
+atmg;
+atmh;
+atmi;
+atmj;
+atmk;
+atml;
+atmm;
+atmn;
+atmo;
+atmp;
+atmq;
+atmr;
+atms;
+atmt;
+atmu;
+atmv;
+atmw;
+atmx;
+atmy;
+atmz;
+atna;
+atnb;
+atnc;
+atnd;
+atne;
+atnf;
+atng;
+atnh;
+atni;
+atnj;
+atnk;
+atnl;
+atnm;
+atnn;
+atno;
+atnp;
+atnq;
+atnr;
+atns;
+atnt;
+atnu;
+atnv;
+atnw;
+atnx;
+atny;
+atnz;
+atoa;
+atob;
+atoc;
+atod;
+atoe;
+atof;
+atog;
+atoh;
+atoi;
+atoj;
+atok;
+atol;
+atom;
+aton;
+atoo;
+atop;
+atoq;
+ator;
+atos;
+atot;
+atou;
+atov;
+atow;
+atox;
+atoy;
+atoz;
+atpa;
+atpb;
+atpc;
+atpd;
+atpe;
+atpf;
+atpg;
+atph;
+atpi;
+atpj;
+atpk;
+atpl;
+atpm;
+atpn;
+atpo;
+atpp;
+atpq;
+atpr;
+atps;
+atpt;
+atpu;
+atpv;
+atpw;
+atpx;
+atpy;
+atpz;
+atqa;
+atqb;
+atqc;
+atqd;
+atqe;
+atqf;
+atqg;
+atqh;
+atqi;
+atqj;
+atqk;
+atql;
+atqm;
+atqn;
+atqo;
+atqp;
+atqq;
+atqr;
+atqs;
+atqt;
+atqu;
+atqv;
+atqw;
+atqx;
+atqy;
+atqz;
+atra;
+atrb;
+atrc;
+atrd;
+atre;
+atrf;
+atrg;
+atrh;
+atri;
+atrj;
+atrk;
+atrl;
+atrm;
+atrn;
+atro;
+atrp;
+atrq;
+atrr;
+atrs;
+atrt;
+atru;
+atrv;
+atrw;
+atrx;
+atry;
+atrz;
+atsa;
+atsb;
+atsc;
+atsd;
+atse;
+atsf;
+atsg;
+atsh;
+atsi;
+atsj;
+atsk;
+atsl;
+atsm;
+atsn;
+atso;
+atsp;
+atsq;
+atsr;
+atss;
+atst;
+atsu;
+atsv;
+atsw;
+atsx;
+atsy;
+atsz;
+atta;
+attb;
+attc;
+attd;
+atte;
+attf;
+attg;
+atth;
+atti;
+attj;
+attk;
+attl;
+attm;
+attn;
+atto;
+attp;
+attq;
+attr;
+atts;
+attt;
+attu;
+attv;
+attw;
+attx;
+atty;
+attz;
+atua;
+atub;
+atuc;
+atud;
+atue;
+atuf;
+atug;
+atuh;
+atui;
+atuj;
+atuk;
+atul;
+atum;
+atun;
+atuo;
+atup;
+atuq;
+atur;
+atus;
+atut;
+atuu;
+atuv;
+atuw;
+atux;
+atuy;
+atuz;
+atva;
+atvb;
+atvc;
+atvd;
+atve;
+atvf;
+atvg;
+atvh;
+atvi;
+atvj;
+atvk;
+atvl;
+atvm;
+atvn;
+atvo;
+atvp;
+atvq;
+atvr;
+atvs;
+atvt;
+atvu;
+atvv;
+atvw;
+atvx;
+atvy;
+atvz;
+atwa;
+atwb;
+atwc;
+atwd;
+atwe;
+atwf;
+atwg;
+atwh;
+atwi;
+atwj;
+atwk;
+atwl;
+atwm;
+atwn;
+atwo;
+atwp;
+atwq;
+atwr;
+atws;
+atwt;
+atwu;
+atwv;
+atww;
+atwx;
+atwy;
+atwz;
+atxa;
+atxb;
+atxc;
+atxd;
+atxe;
+atxf;
+atxg;
+atxh;
+atxi;
+atxj;
+atxk;
+atxl;
+atxm;
+atxn;
+atxo;
+atxp;
+atxq;
+atxr;
+atxs;
+atxt;
+atxu;
+atxv;
+atxw;
+atxx;
+atxy;
+atxz;
+atya;
+atyb;
+atyc;
+atyd;
+atye;
+atyf;
+atyg;
+atyh;
+atyi;
+atyj;
+atyk;
+atyl;
+atym;
+atyn;
+atyo;
+atyp;
+atyq;
+atyr;
+atys;
+atyt;
+atyu;
+atyv;
+atyw;
+atyx;
+atyy;
+atyz;
+atza;
+atzb;
+atzc;
+atzd;
+atze;
+atzf;
+atzg;
+atzh;
+atzi;
+atzj;
+atzk;
+atzl;
+atzm;
+atzn;
+atzo;
+atzp;
+atzq;
+atzr;
+atzs;
+atzt;
+atzu;
+atzv;
+atzw;
+atzx;
+atzy;
+atzz;
+auaa;
+auab;
+auac;
+auad;
+auae;
+auaf;
+auag;
+auah;
+auai;
+auaj;
+auak;
+aual;
+auam;
+auan;
+auao;
+auap;
+auaq;
+auar;
+auas;
+auat;
+auau;
+auav;
+auaw;
+auax;
+auay;
+auaz;
+auba;
+aubb;
+aubc;
+aubd;
+aube;
+aubf;
+aubg;
+aubh;
+aubi;
+aubj;
+aubk;
+aubl;
+aubm;
+aubn;
+aubo;
+aubp;
+aubq;
+aubr;
+aubs;
+aubt;
+aubu;
+aubv;
+aubw;
+aubx;
+auby;
+aubz;
+auca;
+aucb;
+aucc;
+aucd;
+auce;
+aucf;
+aucg;
+auch;
+auci;
+aucj;
+auck;
+aucl;
+aucm;
+aucn;
+auco;
+aucp;
+aucq;
+aucr;
+aucs;
+auct;
+aucu;
+aucv;
+aucw;
+aucx;
+aucy;
+aucz;
+auda;
+audb;
+audc;
+audd;
+aude;
+audf;
+audg;
+audh;
+audi;
+audj;
+audk;
+audl;
+audm;
+audn;
+audo;
+audp;
+audq;
+audr;
+auds;
+audt;
+audu;
+audv;
+audw;
+audx;
+audy;
+audz;
+auea;
+aueb;
+auec;
+aued;
+auee;
+auef;
+aueg;
+aueh;
+auei;
+auej;
+auek;
+auel;
+auem;
+auen;
+aueo;
+auep;
+aueq;
+auer;
+aues;
+auet;
+aueu;
+auev;
+auew;
+auex;
+auey;
+auez;
+aufa;
+aufb;
+aufc;
+aufd;
+aufe;
+auff;
+aufg;
+aufh;
+aufi;
+aufj;
+aufk;
+aufl;
+aufm;
+aufn;
+aufo;
+aufp;
+aufq;
+aufr;
+aufs;
+auft;
+aufu;
+aufv;
+aufw;
+aufx;
+aufy;
+aufz;
+auga;
+augb;
+augc;
+augd;
+auge;
+augf;
+augg;
+augh;
+augi;
+augj;
+augk;
+augl;
+augm;
+augn;
+augo;
+augp;
+augq;
+augr;
+augs;
+augt;
+augu;
+augv;
+augw;
+augx;
+augy;
+augz;
+auha;
+auhb;
+auhc;
+auhd;
+auhe;
+auhf;
+auhg;
+auhh;
+auhi;
+auhj;
+auhk;
+auhl;
+auhm;
+auhn;
+auho;
+auhp;
+auhq;
+auhr;
+auhs;
+auht;
+auhu;
+auhv;
+auhw;
+auhx;
+auhy;
+auhz;
+auia;
+auib;
+auic;
+auid;
+auie;
+auif;
+auig;
+auih;
+auii;
+auij;
+auik;
+auil;
+auim;
+auin;
+auio;
+auip;
+auiq;
+auir;
+auis;
+auit;
+auiu;
+auiv;
+auiw;
+auix;
+auiy;
+auiz;
+auja;
+aujb;
+aujc;
+aujd;
+auje;
+aujf;
+aujg;
+aujh;
+auji;
+aujj;
+aujk;
+aujl;
+aujm;
+aujn;
+aujo;
+aujp;
+aujq;
+aujr;
+aujs;
+aujt;
+auju;
+aujv;
+aujw;
+aujx;
+aujy;
+aujz;
+auka;
+aukb;
+aukc;
+aukd;
+auke;
+aukf;
+aukg;
+aukh;
+auki;
+aukj;
+aukk;
+aukl;
+aukm;
+aukn;
+auko;
+aukp;
+aukq;
+aukr;
+auks;
+aukt;
+auku;
+aukv;
+aukw;
+aukx;
+auky;
+aukz;
+aula;
+aulb;
+aulc;
+auld;
+aule;
+aulf;
+aulg;
+aulh;
+auli;
+aulj;
+aulk;
+aull;
+aulm;
+auln;
+aulo;
+aulp;
+aulq;
+aulr;
+auls;
+ault;
+aulu;
+aulv;
+aulw;
+aulx;
+auly;
+aulz;
+auma;
+aumb;
+aumc;
+aumd;
+aume;
+aumf;
+aumg;
+aumh;
+aumi;
+aumj;
+aumk;
+auml;
+aumm;
+aumn;
+aumo;
+aump;
+aumq;
+aumr;
+aums;
+aumt;
+aumu;
+aumv;
+aumw;
+aumx;
+aumy;
+aumz;
+auna;
+aunb;
+aunc;
+aund;
+aune;
+aunf;
+aung;
+aunh;
+auni;
+aunj;
+aunk;
+aunl;
+aunm;
+aunn;
+auno;
+aunp;
+aunq;
+aunr;
+auns;
+aunt;
+aunu;
+aunv;
+aunw;
+aunx;
+auny;
+aunz;
+auoa;
+auob;
+auoc;
+auod;
+auoe;
+auof;
+auog;
+auoh;
+auoi;
+auoj;
+auok;
+auol;
+auom;
+auon;
+auoo;
+auop;
+auoq;
+auor;
+auos;
+auot;
+auou;
+auov;
+auow;
+auox;
+auoy;
+auoz;
+aupa;
+aupb;
+aupc;
+aupd;
+aupe;
+aupf;
+aupg;
+auph;
+aupi;
+aupj;
+aupk;
+aupl;
+aupm;
+aupn;
+aupo;
+aupp;
+aupq;
+aupr;
+aups;
+aupt;
+aupu;
+aupv;
+aupw;
+aupx;
+aupy;
+aupz;
+auqa;
+auqb;
+auqc;
+auqd;
+auqe;
+auqf;
+auqg;
+auqh;
+auqi;
+auqj;
+auqk;
+auql;
+auqm;
+auqn;
+auqo;
+auqp;
+auqq;
+auqr;
+auqs;
+auqt;
+auqu;
+auqv;
+auqw;
+auqx;
+auqy;
+auqz;
+aura;
+aurb;
+aurc;
+aurd;
+aure;
+aurf;
+aurg;
+aurh;
+auri;
+aurj;
+aurk;
+aurl;
+aurm;
+aurn;
+auro;
+aurp;
+aurq;
+aurr;
+aurs;
+aurt;
+auru;
+aurv;
+aurw;
+aurx;
+aury;
+aurz;
+ausa;
+ausb;
+ausc;
+ausd;
+ause;
+ausf;
+ausg;
+aush;
+ausi;
+ausj;
+ausk;
+ausl;
+ausm;
+ausn;
+auso;
+ausp;
+ausq;
+ausr;
+auss;
+aust;
+ausu;
+ausv;
+ausw;
+ausx;
+ausy;
+ausz;
+auta;
+autb;
+autc;
+autd;
+aute;
+autf;
+autg;
+auth;
+auti;
+autj;
+autk;
+autl;
+autm;
+autn;
+auto;
+autp;
+autq;
+autr;
+auts;
+autt;
+autu;
+autv;
+autw;
+autx;
+auty;
+autz;
+auua;
+auub;
+auuc;
+auud;
+auue;
+auuf;
+auug;
+auuh;
+auui;
+auuj;
+auuk;
+auul;
+auum;
+auun;
+auuo;
+auup;
+auuq;
+auur;
+auus;
+auut;
+auuu;
+auuv;
+auuw;
+auux;
+auuy;
+auuz;
+auva;
+auvb;
+auvc;
+auvd;
+auve;
+auvf;
+auvg;
+auvh;
+auvi;
+auvj;
+auvk;
+auvl;
+auvm;
+auvn;
+auvo;
+auvp;
+auvq;
+auvr;
+auvs;
+auvt;
+auvu;
+auvv;
+auvw;
+auvx;
+auvy;
+auvz;
+auwa;
+auwb;
+auwc;
+auwd;
+auwe;
+auwf;
+auwg;
+auwh;
+auwi;
+auwj;
+auwk;
+auwl;
+auwm;
+auwn;
+auwo;
+auwp;
+auwq;
+auwr;
+auws;
+auwt;
+auwu;
+auwv;
+auww;
+auwx;
+auwy;
+auwz;
+auxa;
+auxb;
+auxc;
+auxd;
+auxe;
+auxf;
+auxg;
+auxh;
+auxi;
+auxj;
+auxk;
+auxl;
+auxm;
+auxn;
+auxo;
+auxp;
+auxq;
+auxr;
+auxs;
+auxt;
+auxu;
+auxv;
+auxw;
+auxx;
+auxy;
+auxz;
+auya;
+auyb;
+auyc;
+auyd;
+auye;
+auyf;
+auyg;
+auyh;
+auyi;
+auyj;
+auyk;
+auyl;
+auym;
+auyn;
+auyo;
+auyp;
+auyq;
+auyr;
+auys;
+auyt;
+auyu;
+auyv;
+auyw;
+auyx;
+auyy;
+auyz;
+auza;
+auzb;
+auzc;
+auzd;
+auze;
+auzf;
+auzg;
+auzh;
+auzi;
+auzj;
+auzk;
+auzl;
+auzm;
+auzn;
+auzo;
+auzp;
+auzq;
+auzr;
+auzs;
+auzt;
+auzu;
+auzv;
+auzw;
+auzx;
+auzy;
+auzz;
+avaa;
+avab;
+avac;
+avad;
+avae;
+avaf;
+avag;
+avah;
+avai;
+avaj;
+avak;
+aval;
+avam;
+avan;
+avao;
+avap;
+avaq;
+avar;
+avas;
+avat;
+avau;
+avav;
+avaw;
+avax;
+avay;
+avaz;
+avba;
+avbb;
+avbc;
+avbd;
+avbe;
+avbf;
+avbg;
+avbh;
+avbi;
+avbj;
+avbk;
+avbl;
+avbm;
+avbn;
+avbo;
+avbp;
+avbq;
+avbr;
+avbs;
+avbt;
+avbu;
+avbv;
+avbw;
+avbx;
+avby;
+avbz;
+avca;
+avcb;
+avcc;
+avcd;
+avce;
+avcf;
+avcg;
+avch;
+avci;
+avcj;
+avck;
+avcl;
+avcm;
+avcn;
+avco;
+avcp;
+avcq;
+avcr;
+avcs;
+avct;
+avcu;
+avcv;
+avcw;
+avcx;
+avcy;
+avcz;
+avda;
+avdb;
+avdc;
+avdd;
+avde;
+avdf;
+avdg;
+avdh;
+avdi;
+avdj;
+avdk;
+avdl;
+avdm;
+avdn;
+avdo;
+avdp;
+avdq;
+avdr;
+avds;
+avdt;
+avdu;
+avdv;
+avdw;
+avdx;
+avdy;
+avdz;
+avea;
+aveb;
+avec;
+aved;
+avee;
+avef;
+aveg;
+aveh;
+avei;
+avej;
+avek;
+avel;
+avem;
+aven;
+aveo;
+avep;
+aveq;
+aver;
+aves;
+avet;
+aveu;
+avev;
+avew;
+avex;
+avey;
+avez;
+avfa;
+avfb;
+avfc;
+avfd;
+avfe;
+avff;
+avfg;
+avfh;
+avfi;
+avfj;
+avfk;
+avfl;
+avfm;
+avfn;
+avfo;
+avfp;
+avfq;
+avfr;
+avfs;
+avft;
+avfu;
+avfv;
+avfw;
+avfx;
+avfy;
+avfz;
+avga;
+avgb;
+avgc;
+avgd;
+avge;
+avgf;
+avgg;
+avgh;
+avgi;
+avgj;
+avgk;
+avgl;
+avgm;
+avgn;
+avgo;
+avgp;
+avgq;
+avgr;
+avgs;
+avgt;
+avgu;
+avgv;
+avgw;
+avgx;
+avgy;
+avgz;
+avha;
+avhb;
+avhc;
+avhd;
+avhe;
+avhf;
+avhg;
+avhh;
+avhi;
+avhj;
+avhk;
+avhl;
+avhm;
+avhn;
+avho;
+avhp;
+avhq;
+avhr;
+avhs;
+avht;
+avhu;
+avhv;
+avhw;
+avhx;
+avhy;
+avhz;
+avia;
+avib;
+avic;
+avid;
+avie;
+avif;
+avig;
+avih;
+avii;
+avij;
+avik;
+avil;
+avim;
+avin;
+avio;
+avip;
+aviq;
+avir;
+avis;
+avit;
+aviu;
+aviv;
+aviw;
+avix;
+aviy;
+aviz;
+avja;
+avjb;
+avjc;
+avjd;
+avje;
+avjf;
+avjg;
+avjh;
+avji;
+avjj;
+avjk;
+avjl;
+avjm;
+avjn;
+avjo;
+avjp;
+avjq;
+avjr;
+avjs;
+avjt;
+avju;
+avjv;
+avjw;
+avjx;
+avjy;
+avjz;
+avka;
+avkb;
+avkc;
+avkd;
+avke;
+avkf;
+avkg;
+avkh;
+avki;
+avkj;
+avkk;
+avkl;
+avkm;
+avkn;
+avko;
+avkp;
+avkq;
+avkr;
+avks;
+avkt;
+avku;
+avkv;
+avkw;
+avkx;
+avky;
+avkz;
+avla;
+avlb;
+avlc;
+avld;
+avle;
+avlf;
+avlg;
+avlh;
+avli;
+avlj;
+avlk;
+avll;
+avlm;
+avln;
+avlo;
+avlp;
+avlq;
+avlr;
+avls;
+avlt;
+avlu;
+avlv;
+avlw;
+avlx;
+avly;
+avlz;
+avma;
+avmb;
+avmc;
+avmd;
+avme;
+avmf;
+avmg;
+avmh;
+avmi;
+avmj;
+avmk;
+avml;
+avmm;
+avmn;
+avmo;
+avmp;
+avmq;
+avmr;
+avms;
+avmt;
+avmu;
+avmv;
+avmw;
+avmx;
+avmy;
+avmz;
+avna;
+avnb;
+avnc;
+avnd;
+avne;
+avnf;
+avng;
+avnh;
+avni;
+avnj;
+avnk;
+avnl;
+avnm;
+avnn;
+avno;
+avnp;
+avnq;
+avnr;
+avns;
+avnt;
+avnu;
+avnv;
+avnw;
+avnx;
+avny;
+avnz;
+avoa;
+avob;
+avoc;
+avod;
+avoe;
+avof;
+avog;
+avoh;
+avoi;
+avoj;
+avok;
+avol;
+avom;
+avon;
+avoo;
+avop;
+avoq;
+avor;
+avos;
+avot;
+avou;
+avov;
+avow;
+avox;
+avoy;
+avoz;
+avpa;
+avpb;
+avpc;
+avpd;
+avpe;
+avpf;
+avpg;
+avph;
+avpi;
+avpj;
+avpk;
+avpl;
+avpm;
+avpn;
+avpo;
+avpp;
+avpq;
+avpr;
+avps;
+avpt;
+avpu;
+avpv;
+avpw;
+avpx;
+avpy;
+avpz;
+avqa;
+avqb;
+avqc;
+avqd;
+avqe;
+avqf;
+avqg;
+avqh;
+avqi;
+avqj;
+avqk;
+avql;
+avqm;
+avqn;
+avqo;
+avqp;
+avqq;
+avqr;
+avqs;
+avqt;
+avqu;
+avqv;
+avqw;
+avqx;
+avqy;
+avqz;
+avra;
+avrb;
+avrc;
+avrd;
+avre;
+avrf;
+avrg;
+avrh;
+avri;
+avrj;
+avrk;
+avrl;
+avrm;
+avrn;
+avro;
+avrp;
+avrq;
+avrr;
+avrs;
+avrt;
+avru;
+avrv;
+avrw;
+avrx;
+avry;
+avrz;
+avsa;
+avsb;
+avsc;
+avsd;
+avse;
+avsf;
+avsg;
+avsh;
+avsi;
+avsj;
+avsk;
+avsl;
+avsm;
+avsn;
+avso;
+avsp;
+avsq;
+avsr;
+avss;
+avst;
+avsu;
+avsv;
+avsw;
+avsx;
+avsy;
+avsz;
+avta;
+avtb;
+avtc;
+avtd;
+avte;
+avtf;
+avtg;
+avth;
+avti;
+avtj;
+avtk;
+avtl;
+avtm;
+avtn;
+avto;
+avtp;
+avtq;
+avtr;
+avts;
+avtt;
+avtu;
+avtv;
+avtw;
+avtx;
+avty;
+avtz;
+avua;
+avub;
+avuc;
+avud;
+avue;
+avuf;
+avug;
+avuh;
+avui;
+avuj;
+avuk;
+avul;
+avum;
+avun;
+avuo;
+avup;
+avuq;
+avur;
+avus;
+avut;
+avuu;
+avuv;
+avuw;
+avux;
+avuy;
+avuz;
+avva;
+avvb;
+avvc;
+avvd;
+avve;
+avvf;
+avvg;
+avvh;
+avvi;
+avvj;
+avvk;
+avvl;
+avvm;
+avvn;
+avvo;
+avvp;
+avvq;
+avvr;
+avvs;
+avvt;
+avvu;
+avvv;
+avvw;
+avvx;
+avvy;
+avvz;
+avwa;
+avwb;
+avwc;
+avwd;
+avwe;
+avwf;
+avwg;
+avwh;
+avwi;
+avwj;
+avwk;
+avwl;
+avwm;
+avwn;
+avwo;
+avwp;
+avwq;
+avwr;
+avws;
+avwt;
+avwu;
+avwv;
+avww;
+avwx;
+avwy;
+avwz;
+avxa;
+avxb;
+avxc;
+avxd;
+avxe;
+avxf;
+avxg;
+avxh;
+avxi;
+avxj;
+avxk;
+avxl;
+avxm;
+avxn;
+avxo;
+avxp;
+avxq;
+avxr;
+avxs;
+avxt;
+avxu;
+avxv;
+avxw;
+avxx;
+avxy;
+avxz;
+avya;
+avyb;
+avyc;
+avyd;
+avye;
+avyf;
+avyg;
+avyh;
+avyi;
+avyj;
+avyk;
+avyl;
+avym;
+avyn;
+avyo;
+avyp;
+avyq;
+avyr;
+avys;
+avyt;
+avyu;
+avyv;
+avyw;
+avyx;
+avyy;
+avyz;
+avza;
+avzb;
+avzc;
+avzd;
+avze;
+avzf;
+avzg;
+avzh;
+avzi;
+avzj;
+avzk;
+avzl;
+avzm;
+avzn;
+avzo;
+avzp;
+avzq;
+avzr;
+avzs;
+avzt;
+avzu;
+avzv;
+avzw;
+avzx;
+avzy;
+avzz;
+awaa;
+awab;
+awac;
+awad;
+awae;
+awaf;
+awag;
+awah;
+awai;
+awaj;
+awak;
+awal;
+awam;
+awan;
+awao;
+awap;
+awaq;
+awar;
+awas;
+awat;
+awau;
+awav;
+awaw;
+awax;
+away;
+awaz;
+awba;
+awbb;
+awbc;
+awbd;
+awbe;
+awbf;
+awbg;
+awbh;
+awbi;
+awbj;
+awbk;
+awbl;
+awbm;
+awbn;
+awbo;
+awbp;
+awbq;
+awbr;
+awbs;
+awbt;
+awbu;
+awbv;
+awbw;
+awbx;
+awby;
+awbz;
+awca;
+awcb;
+awcc;
+awcd;
+awce;
+awcf;
+awcg;
+awch;
+awci;
+awcj;
+awck;
+awcl;
+awcm;
+awcn;
+awco;
+awcp;
+awcq;
+awcr;
+awcs;
+awct;
+awcu;
+awcv;
+awcw;
+awcx;
+awcy;
+awcz;
+awda;
+awdb;
+awdc;
+awdd;
+awde;
+awdf;
+awdg;
+awdh;
+awdi;
+awdj;
+awdk;
+awdl;
+awdm;
+awdn;
+awdo;
+awdp;
+awdq;
+awdr;
+awds;
+awdt;
+awdu;
+awdv;
+awdw;
+awdx;
+awdy;
+awdz;
+awea;
+aweb;
+awec;
+awed;
+awee;
+awef;
+aweg;
+aweh;
+awei;
+awej;
+awek;
+awel;
+awem;
+awen;
+aweo;
+awep;
+aweq;
+awer;
+awes;
+awet;
+aweu;
+awev;
+awew;
+awex;
+awey;
+awez;
+awfa;
+awfb;
+awfc;
+awfd;
+awfe;
+awff;
+awfg;
+awfh;
+awfi;
+awfj;
+awfk;
+awfl;
+awfm;
+awfn;
+awfo;
+awfp;
+awfq;
+awfr;
+awfs;
+awft;
+awfu;
+awfv;
+awfw;
+awfx;
+awfy;
+awfz;
+awga;
+awgb;
+awgc;
+awgd;
+awge;
+awgf;
+awgg;
+awgh;
+awgi;
+awgj;
+awgk;
+awgl;
+awgm;
+awgn;
+awgo;
+awgp;
+awgq;
+awgr;
+awgs;
+awgt;
+awgu;
+awgv;
+awgw;
+awgx;
+awgy;
+awgz;
+awha;
+awhb;
+awhc;
+awhd;
+awhe;
+awhf;
+awhg;
+awhh;
+awhi;
+awhj;
+awhk;
+awhl;
+awhm;
+awhn;
+awho;
+awhp;
+awhq;
+awhr;
+awhs;
+awht;
+awhu;
+awhv;
+awhw;
+awhx;
+awhy;
+awhz;
+awia;
+awib;
+awic;
+awid;
+awie;
+awif;
+awig;
+awih;
+awii;
+awij;
+awik;
+awil;
+awim;
+awin;
+awio;
+awip;
+awiq;
+awir;
+awis;
+awit;
+awiu;
+awiv;
+awiw;
+awix;
+awiy;
+awiz;
+awja;
+awjb;
+awjc;
+awjd;
+awje;
+awjf;
+awjg;
+awjh;
+awji;
+awjj;
+awjk;
+awjl;
+awjm;
+awjn;
+awjo;
+awjp;
+awjq;
+awjr;
+awjs;
+awjt;
+awju;
+awjv;
+awjw;
+awjx;
+awjy;
+awjz;
+awka;
+awkb;
+awkc;
+awkd;
+awke;
+awkf;
+awkg;
+awkh;
+awki;
+awkj;
+awkk;
+awkl;
+awkm;
+awkn;
+awko;
+awkp;
+awkq;
+awkr;
+awks;
+awkt;
+awku;
+awkv;
+awkw;
+awkx;
+awky;
+awkz;
+awla;
+awlb;
+awlc;
+awld;
+awle;
+awlf;
+awlg;
+awlh;
+awli;
+awlj;
+awlk;
+awll;
+awlm;
+awln;
+awlo;
+awlp;
+awlq;
+awlr;
+awls;
+awlt;
+awlu;
+awlv;
+awlw;
+awlx;
+awly;
+awlz;
+awma;
+awmb;
+awmc;
+awmd;
+awme;
+awmf;
+awmg;
+awmh;
+awmi;
+awmj;
+awmk;
+awml;
+awmm;
+awmn;
+awmo;
+awmp;
+awmq;
+awmr;
+awms;
+awmt;
+awmu;
+awmv;
+awmw;
+awmx;
+awmy;
+awmz;
+awna;
+awnb;
+awnc;
+awnd;
+awne;
+awnf;
+awng;
+awnh;
+awni;
+awnj;
+awnk;
+awnl;
+awnm;
+awnn;
+awno;
+awnp;
+awnq;
+awnr;
+awns;
+awnt;
+awnu;
+awnv;
+awnw;
+awnx;
+awny;
+awnz;
+awoa;
+awob;
+awoc;
+awod;
+awoe;
+awof;
+awog;
+awoh;
+awoi;
+awoj;
+awok;
+awol;
+awom;
+awon;
+awoo;
+awop;
+awoq;
+awor;
+awos;
+awot;
+awou;
+awov;
+awow;
+awox;
+awoy;
+awoz;
+awpa;
+awpb;
+awpc;
+awpd;
+awpe;
+awpf;
+awpg;
+awph;
+awpi;
+awpj;
+awpk;
+awpl;
+awpm;
+awpn;
+awpo;
+awpp;
+awpq;
+awpr;
+awps;
+awpt;
+awpu;
+awpv;
+awpw;
+awpx;
+awpy;
+awpz;
+awqa;
+awqb;
+awqc;
+awqd;
+awqe;
+awqf;
+awqg;
+awqh;
+awqi;
+awqj;
+awqk;
+awql;
+awqm;
+awqn;
+awqo;
+awqp;
+awqq;
+awqr;
+awqs;
+awqt;
+awqu;
+awqv;
+awqw;
+awqx;
+awqy;
+awqz;
+awra;
+awrb;
+awrc;
+awrd;
+awre;
+awrf;
+awrg;
+awrh;
+awri;
+awrj;
+awrk;
+awrl;
+awrm;
+awrn;
+awro;
+awrp;
+awrq;
+awrr;
+awrs;
+awrt;
+awru;
+awrv;
+awrw;
+awrx;
+awry;
+awrz;
+awsa;
+awsb;
+awsc;
+awsd;
+awse;
+awsf;
+awsg;
+awsh;
+awsi;
+awsj;
+awsk;
+awsl;
+awsm;
+awsn;
+awso;
+awsp;
+awsq;
+awsr;
+awss;
+awst;
+awsu;
+awsv;
+awsw;
+awsx;
+awsy;
+awsz;
+awta;
+awtb;
+awtc;
+awtd;
+awte;
+awtf;
+awtg;
+awth;
+awti;
+awtj;
+awtk;
+awtl;
+awtm;
+awtn;
+awto;
+awtp;
+awtq;
+awtr;
+awts;
+awtt;
+awtu;
+awtv;
+awtw;
+awtx;
+awty;
+awtz;
+awua;
+awub;
+awuc;
+awud;
+awue;
+awuf;
+awug;
+awuh;
+awui;
+awuj;
+awuk;
+awul;
+awum;
+awun;
+awuo;
+awup;
+awuq;
+awur;
+awus;
+awut;
+awuu;
+awuv;
+awuw;
+awux;
+awuy;
+awuz;
+awva;
+awvb;
+awvc;
+awvd;
+awve;
+awvf;
+awvg;
+awvh;
+awvi;
+awvj;
+awvk;
+awvl;
+awvm;
+awvn;
+awvo;
+awvp;
+awvq;
+awvr;
+awvs;
+awvt;
+awvu;
+awvv;
+awvw;
+awvx;
+awvy;
+awvz;
+awwa;
+awwb;
+awwc;
+awwd;
+awwe;
+awwf;
+awwg;
+awwh;
+awwi;
+awwj;
+awwk;
+awwl;
+awwm;
+awwn;
+awwo;
+awwp;
+awwq;
+awwr;
+awws;
+awwt;
+awwu;
+awwv;
+awww;
+awwx;
+awwy;
+awwz;
+awxa;
+awxb;
+awxc;
+awxd;
+awxe;
+awxf;
+awxg;
+awxh;
+awxi;
+awxj;
+awxk;
+awxl;
+awxm;
+awxn;
+awxo;
+awxp;
+awxq;
+awxr;
+awxs;
+awxt;
+awxu;
+awxv;
+awxw;
+awxx;
+awxy;
+awxz;
+awya;
+awyb;
+awyc;
+awyd;
+awye;
+awyf;
+awyg;
+awyh;
+awyi;
+awyj;
+awyk;
+awyl;
+awym;
+awyn;
+awyo;
+awyp;
+awyq;
+awyr;
+awys;
+awyt;
+awyu;
+awyv;
+awyw;
+awyx;
+awyy;
+awyz;
+awza;
+awzb;
+awzc;
+awzd;
+awze;
+awzf;
+awzg;
+awzh;
+awzi;
+awzj;
+awzk;
+awzl;
+awzm;
+awzn;
+awzo;
+awzp;
+awzq;
+awzr;
+awzs;
+awzt;
+awzu;
+awzv;
+awzw;
+awzx;
+awzy;
+awzz;
+axaa;
+axab;
+axac;
+axad;
+axae;
+axaf;
+axag;
+axah;
+axai;
+axaj;
+axak;
+axal;
+axam;
+axan;
+axao;
+axap;
+axaq;
+axar;
+axas;
+axat;
+axau;
+axav;
+axaw;
+axax;
+axay;
+axaz;
+axba;
+axbb;
+axbc;
+axbd;
+axbe;
+axbf;
+axbg;
+axbh;
+axbi;
+axbj;
+axbk;
+axbl;
+axbm;
+axbn;
+axbo;
+axbp;
+axbq;
+axbr;
+axbs;
+axbt;
+axbu;
+axbv;
+axbw;
+axbx;
+axby;
+axbz;
+axca;
+axcb;
+axcc;
+axcd;
+axce;
+axcf;
+axcg;
+axch;
+axci;
+axcj;
+axck;
+axcl;
+axcm;
+axcn;
+axco;
+axcp;
+axcq;
+axcr;
+axcs;
+axct;
+axcu;
+axcv;
+axcw;
+axcx;
+axcy;
+axcz;
+axda;
+axdb;
+axdc;
+axdd;
+axde;
+axdf;
+axdg;
+axdh;
+axdi;
+axdj;
+axdk;
+axdl;
+axdm;
+axdn;
+axdo;
+axdp;
+axdq;
+axdr;
+axds;
+axdt;
+axdu;
+axdv;
+axdw;
+axdx;
+axdy;
+axdz;
+axea;
+axeb;
+axec;
+axed;
+axee;
+axef;
+axeg;
+axeh;
+axei;
+axej;
+axek;
+axel;
+axem;
+axen;
+axeo;
+axep;
+axeq;
+axer;
+axes;
+axet;
+axeu;
+axev;
+axew;
+axex;
+axey;
+axez;
+axfa;
+axfb;
+axfc;
+axfd;
+axfe;
+axff;
+axfg;
+axfh;
+axfi;
+axfj;
+axfk;
+axfl;
+axfm;
+axfn;
+axfo;
+axfp;
+axfq;
+axfr;
+axfs;
+axft;
+axfu;
+axfv;
+axfw;
+axfx;
+axfy;
+axfz;
+axga;
+axgb;
+axgc;
+axgd;
+axge;
+axgf;
+axgg;
+axgh;
+axgi;
+axgj;
+axgk;
+axgl;
+axgm;
+axgn;
+axgo;
+axgp;
+axgq;
+axgr;
+axgs;
+axgt;
+axgu;
+axgv;
+axgw;
+axgx;
+axgy;
+axgz;
+axha;
+axhb;
+axhc;
+axhd;
+axhe;
+axhf;
+axhg;
+axhh;
+axhi;
+axhj;
+axhk;
+axhl;
+axhm;
+axhn;
+axho;
+axhp;
+axhq;
+axhr;
+axhs;
+axht;
+axhu;
+axhv;
+axhw;
+axhx;
+axhy;
+axhz;
+axia;
+axib;
+axic;
+axid;
+axie;
+axif;
+axig;
+axih;
+axii;
+axij;
+axik;
+axil;
+axim;
+axin;
+axio;
+axip;
+axiq;
+axir;
+axis;
+axit;
+axiu;
+axiv;
+axiw;
+axix;
+axiy;
+axiz;
+axja;
+axjb;
+axjc;
+axjd;
+axje;
+axjf;
+axjg;
+axjh;
+axji;
+axjj;
+axjk;
+axjl;
+axjm;
+axjn;
+axjo;
+axjp;
+axjq;
+axjr;
+axjs;
+axjt;
+axju;
+axjv;
+axjw;
+axjx;
+axjy;
+axjz;
+axka;
+axkb;
+axkc;
+axkd;
+axke;
+axkf;
+axkg;
+axkh;
+axki;
+axkj;
+axkk;
+axkl;
+axkm;
+axkn;
+axko;
+axkp;
+axkq;
+axkr;
+axks;
+axkt;
+axku;
+axkv;
+axkw;
+axkx;
+axky;
+axkz;
+axla;
+axlb;
+axlc;
+axld;
+axle;
+axlf;
+axlg;
+axlh;
+axli;
+axlj;
+axlk;
+axll;
+axlm;
+axln;
+axlo;
+axlp;
+axlq;
+axlr;
+axls;
+axlt;
+axlu;
+axlv;
+axlw;
+axlx;
+axly;
+axlz;
+axma;
+axmb;
+axmc;
+axmd;
+axme;
+axmf;
+axmg;
+axmh;
+axmi;
+axmj;
+axmk;
+axml;
+axmm;
+axmn;
+axmo;
+axmp;
+axmq;
+axmr;
+axms;
+axmt;
+axmu;
+axmv;
+axmw;
+axmx;
+axmy;
+axmz;
+axna;
+axnb;
+axnc;
+axnd;
+axne;
+axnf;
+axng;
+axnh;
+axni;
+axnj;
+axnk;
+axnl;
+axnm;
+axnn;
+axno;
+axnp;
+axnq;
+axnr;
+axns;
+axnt;
+axnu;
+axnv;
+axnw;
+axnx;
+axny;
+axnz;
+axoa;
+axob;
+axoc;
+axod;
+axoe;
+axof;
+axog;
+axoh;
+axoi;
+axoj;
+axok;
+axol;
+axom;
+axon;
+axoo;
+axop;
+axoq;
+axor;
+axos;
+axot;
+axou;
+axov;
+axow;
+axox;
+axoy;
+axoz;
+axpa;
+axpb;
+axpc;
+axpd;
+axpe;
+axpf;
+axpg;
+axph;
+axpi;
+axpj;
+axpk;
+axpl;
+axpm;
+axpn;
+axpo;
+axpp;
+axpq;
+axpr;
+axps;
+axpt;
+axpu;
+axpv;
+axpw;
+axpx;
+axpy;
+axpz;
+axqa;
+axqb;
+axqc;
+axqd;
+axqe;
+axqf;
+axqg;
+axqh;
+axqi;
+axqj;
+axqk;
+axql;
+axqm;
+axqn;
+axqo;
+axqp;
+axqq;
+axqr;
+axqs;
+axqt;
+axqu;
+axqv;
+axqw;
+axqx;
+axqy;
+axqz;
+axra;
+axrb;
+axrc;
+axrd;
+axre;
+axrf;
+axrg;
+axrh;
+axri;
+axrj;
+axrk;
+axrl;
+axrm;
+axrn;
+axro;
+axrp;
+axrq;
+axrr;
+axrs;
+axrt;
+axru;
+axrv;
+axrw;
+axrx;
+axry;
+axrz;
+axsa;
+axsb;
+axsc;
+axsd;
+axse;
+axsf;
+axsg;
+axsh;
+axsi;
+axsj;
+axsk;
+axsl;
+axsm;
+axsn;
+axso;
+axsp;
+axsq;
+axsr;
+axss;
+axst;
+axsu;
+axsv;
+axsw;
+axsx;
+axsy;
+axsz;
+axta;
+axtb;
+axtc;
+axtd;
+axte;
+axtf;
+axtg;
+axth;
+axti;
+axtj;
+axtk;
+axtl;
+axtm;
+axtn;
+axto;
+axtp;
+axtq;
+axtr;
+axts;
+axtt;
+axtu;
+axtv;
+axtw;
+axtx;
+axty;
+axtz;
+axua;
+axub;
+axuc;
+axud;
+axue;
+axuf;
+axug;
+axuh;
+axui;
+axuj;
+axuk;
+axul;
+axum;
+axun;
+axuo;
+axup;
+axuq;
+axur;
+axus;
+axut;
+axuu;
+axuv;
+axuw;
+axux;
+axuy;
+axuz;
+axva;
+axvb;
+axvc;
+axvd;
+axve;
+axvf;
+axvg;
+axvh;
+axvi;
+axvj;
+axvk;
+axvl;
+axvm;
+axvn;
+axvo;
+axvp;
+axvq;
+axvr;
+axvs;
+axvt;
+axvu;
+axvv;
+axvw;
+axvx;
+axvy;
+axvz;
+axwa;
+axwb;
+axwc;
+axwd;
+axwe;
+axwf;
+axwg;
+axwh;
+axwi;
+axwj;
+axwk;
+axwl;
+axwm;
+axwn;
+axwo;
+axwp;
+axwq;
+axwr;
+axws;
+axwt;
+axwu;
+axwv;
+axww;
+axwx;
+axwy;
+axwz;
+axxa;
+axxb;
+axxc;
+axxd;
+axxe;
+axxf;
+axxg;
+axxh;
+axxi;
+axxj;
+axxk;
+axxl;
+axxm;
+axxn;
+axxo;
+axxp;
+axxq;
+axxr;
+axxs;
+axxt;
+axxu;
+axxv;
+axxw;
+axxx;
+axxy;
+axxz;
+axya;
+axyb;
+axyc;
+axyd;
+axye;
+axyf;
+axyg;
+axyh;
+axyi;
+axyj;
+axyk;
+axyl;
+axym;
+axyn;
+axyo;
+axyp;
+axyq;
+axyr;
+axys;
+axyt;
+axyu;
+axyv;
+axyw;
+axyx;
+axyy;
+axyz;
+axza;
+axzb;
+axzc;
+axzd;
+axze;
+axzf;
+axzg;
+axzh;
+axzi;
+axzj;
+axzk;
+axzl;
+axzm;
+axzn;
+axzo;
+axzp;
+axzq;
+axzr;
+axzs;
+axzt;
+axzu;
+axzv;
+axzw;
+axzx;
+axzy;
+axzz;
+ayaa;
+ayab;
+ayac;
+ayad;
+ayae;
+ayaf;
+ayag;
+ayah;
+ayai;
+ayaj;
+ayak;
+ayal;
+ayam;
+ayan;
+ayao;
+ayap;
+ayaq;
+ayar;
+ayas;
+ayat;
+ayau;
+ayav;
+ayaw;
+ayax;
+ayay;
+ayaz;
+ayba;
+aybb;
+aybc;
+aybd;
+aybe;
+aybf;
+aybg;
+aybh;
+aybi;
+aybj;
+aybk;
+aybl;
+aybm;
+aybn;
+aybo;
+aybp;
+aybq;
+aybr;
+aybs;
+aybt;
+aybu;
+aybv;
+aybw;
+aybx;
+ayby;
+aybz;
+ayca;
+aycb;
+aycc;
+aycd;
+ayce;
+aycf;
+aycg;
+aych;
+ayci;
+aycj;
+ayck;
+aycl;
+aycm;
+aycn;
+ayco;
+aycp;
+aycq;
+aycr;
+aycs;
+ayct;
+aycu;
+aycv;
+aycw;
+aycx;
+aycy;
+aycz;
+ayda;
+aydb;
+aydc;
+aydd;
+ayde;
+aydf;
+aydg;
+aydh;
+aydi;
+aydj;
+aydk;
+aydl;
+aydm;
+aydn;
+aydo;
+aydp;
+aydq;
+aydr;
+ayds;
+aydt;
+aydu;
+aydv;
+aydw;
+aydx;
+aydy;
+aydz;
+ayea;
+ayeb;
+ayec;
+ayed;
+ayee;
+ayef;
+ayeg;
+ayeh;
+ayei;
+ayej;
+ayek;
+ayel;
+ayem;
+ayen;
+ayeo;
+ayep;
+ayeq;
+ayer;
+ayes;
+ayet;
+ayeu;
+ayev;
+ayew;
+ayex;
+ayey;
+ayez;
+ayfa;
+ayfb;
+ayfc;
+ayfd;
+ayfe;
+ayff;
+ayfg;
+ayfh;
+ayfi;
+ayfj;
+ayfk;
+ayfl;
+ayfm;
+ayfn;
+ayfo;
+ayfp;
+ayfq;
+ayfr;
+ayfs;
+ayft;
+ayfu;
+ayfv;
+ayfw;
+ayfx;
+ayfy;
+ayfz;
+ayga;
+aygb;
+aygc;
+aygd;
+ayge;
+aygf;
+aygg;
+aygh;
+aygi;
+aygj;
+aygk;
+aygl;
+aygm;
+aygn;
+aygo;
+aygp;
+aygq;
+aygr;
+aygs;
+aygt;
+aygu;
+aygv;
+aygw;
+aygx;
+aygy;
+aygz;
+ayha;
+ayhb;
+ayhc;
+ayhd;
+ayhe;
+ayhf;
+ayhg;
+ayhh;
+ayhi;
+ayhj;
+ayhk;
+ayhl;
+ayhm;
+ayhn;
+ayho;
+ayhp;
+ayhq;
+ayhr;
+ayhs;
+ayht;
+ayhu;
+ayhv;
+ayhw;
+ayhx;
+ayhy;
+ayhz;
+ayia;
+ayib;
+ayic;
+ayid;
+ayie;
+ayif;
+ayig;
+ayih;
+ayii;
+ayij;
+ayik;
+ayil;
+ayim;
+ayin;
+ayio;
+ayip;
+ayiq;
+ayir;
+ayis;
+ayit;
+ayiu;
+ayiv;
+ayiw;
+ayix;
+ayiy;
+ayiz;
+ayja;
+ayjb;
+ayjc;
+ayjd;
+ayje;
+ayjf;
+ayjg;
+ayjh;
+ayji;
+ayjj;
+ayjk;
+ayjl;
+ayjm;
+ayjn;
+ayjo;
+ayjp;
+ayjq;
+ayjr;
+ayjs;
+ayjt;
+ayju;
+ayjv;
+ayjw;
+ayjx;
+ayjy;
+ayjz;
+ayka;
+aykb;
+aykc;
+aykd;
+ayke;
+aykf;
+aykg;
+aykh;
+ayki;
+aykj;
+aykk;
+aykl;
+aykm;
+aykn;
+ayko;
+aykp;
+aykq;
+aykr;
+ayks;
+aykt;
+ayku;
+aykv;
+aykw;
+aykx;
+ayky;
+aykz;
+ayla;
+aylb;
+aylc;
+ayld;
+ayle;
+aylf;
+aylg;
+aylh;
+ayli;
+aylj;
+aylk;
+ayll;
+aylm;
+ayln;
+aylo;
+aylp;
+aylq;
+aylr;
+ayls;
+aylt;
+aylu;
+aylv;
+aylw;
+aylx;
+ayly;
+aylz;
+ayma;
+aymb;
+aymc;
+aymd;
+ayme;
+aymf;
+aymg;
+aymh;
+aymi;
+aymj;
+aymk;
+ayml;
+aymm;
+aymn;
+aymo;
+aymp;
+aymq;
+aymr;
+ayms;
+aymt;
+aymu;
+aymv;
+aymw;
+aymx;
+aymy;
+aymz;
+ayna;
+aynb;
+aync;
+aynd;
+ayne;
+aynf;
+ayng;
+aynh;
+ayni;
+aynj;
+aynk;
+aynl;
+aynm;
+aynn;
+ayno;
+aynp;
+aynq;
+aynr;
+ayns;
+aynt;
+aynu;
+aynv;
+aynw;
+aynx;
+ayny;
+aynz;
+ayoa;
+ayob;
+ayoc;
+ayod;
+ayoe;
+ayof;
+ayog;
+ayoh;
+ayoi;
+ayoj;
+ayok;
+ayol;
+ayom;
+ayon;
+ayoo;
+ayop;
+ayoq;
+ayor;
+ayos;
+ayot;
+ayou;
+ayov;
+ayow;
+ayox;
+ayoy;
+ayoz;
+aypa;
+aypb;
+aypc;
+aypd;
+aype;
+aypf;
+aypg;
+ayph;
+aypi;
+aypj;
+aypk;
+aypl;
+aypm;
+aypn;
+aypo;
+aypp;
+aypq;
+aypr;
+ayps;
+aypt;
+aypu;
+aypv;
+aypw;
+aypx;
+aypy;
+aypz;
+ayqa;
+ayqb;
+ayqc;
+ayqd;
+ayqe;
+ayqf;
+ayqg;
+ayqh;
+ayqi;
+ayqj;
+ayqk;
+ayql;
+ayqm;
+ayqn;
+ayqo;
+ayqp;
+ayqq;
+ayqr;
+ayqs;
+ayqt;
+ayqu;
+ayqv;
+ayqw;
+ayqx;
+ayqy;
+ayqz;
+ayra;
+ayrb;
+ayrc;
+ayrd;
+ayre;
+ayrf;
+ayrg;
+ayrh;
+ayri;
+ayrj;
+ayrk;
+ayrl;
+ayrm;
+ayrn;
+ayro;
+ayrp;
+ayrq;
+ayrr;
+ayrs;
+ayrt;
+ayru;
+ayrv;
+ayrw;
+ayrx;
+ayry;
+ayrz;
+aysa;
+aysb;
+aysc;
+aysd;
+ayse;
+aysf;
+aysg;
+aysh;
+aysi;
+aysj;
+aysk;
+aysl;
+aysm;
+aysn;
+ayso;
+aysp;
+aysq;
+aysr;
+ayss;
+ayst;
+aysu;
+aysv;
+aysw;
+aysx;
+aysy;
+aysz;
+ayta;
+aytb;
+aytc;
+aytd;
+ayte;
+aytf;
+aytg;
+ayth;
+ayti;
+aytj;
+aytk;
+aytl;
+aytm;
+aytn;
+ayto;
+aytp;
+aytq;
+aytr;
+ayts;
+aytt;
+aytu;
+aytv;
+aytw;
+aytx;
+ayty;
+aytz;
+ayua;
+ayub;
+ayuc;
+ayud;
+ayue;
+ayuf;
+ayug;
+ayuh;
+ayui;
+ayuj;
+ayuk;
+ayul;
+ayum;
+ayun;
+ayuo;
+ayup;
+ayuq;
+ayur;
+ayus;
+ayut;
+ayuu;
+ayuv;
+ayuw;
+ayux;
+ayuy;
+ayuz;
+ayva;
+ayvb;
+ayvc;
+ayvd;
+ayve;
+ayvf;
+ayvg;
+ayvh;
+ayvi;
+ayvj;
+ayvk;
+ayvl;
+ayvm;
+ayvn;
+ayvo;
+ayvp;
+ayvq;
+ayvr;
+ayvs;
+ayvt;
+ayvu;
+ayvv;
+ayvw;
+ayvx;
+ayvy;
+ayvz;
+aywa;
+aywb;
+aywc;
+aywd;
+aywe;
+aywf;
+aywg;
+aywh;
+aywi;
+aywj;
+aywk;
+aywl;
+aywm;
+aywn;
+aywo;
+aywp;
+aywq;
+aywr;
+ayws;
+aywt;
+aywu;
+aywv;
+ayww;
+aywx;
+aywy;
+aywz;
+ayxa;
+ayxb;
+ayxc;
+ayxd;
+ayxe;
+ayxf;
+ayxg;
+ayxh;
+ayxi;
+ayxj;
+ayxk;
+ayxl;
+ayxm;
+ayxn;
+ayxo;
+ayxp;
+ayxq;
+ayxr;
+ayxs;
+ayxt;
+ayxu;
+ayxv;
+ayxw;
+ayxx;
+ayxy;
+ayxz;
+ayya;
+ayyb;
+ayyc;
+ayyd;
+ayye;
+ayyf;
+ayyg;
+ayyh;
+ayyi;
+ayyj;
+ayyk;
+ayyl;
+ayym;
+ayyn;
+ayyo;
+ayyp;
+ayyq;
+ayyr;
+ayys;
+ayyt;
+ayyu;
+ayyv;
+ayyw;
+ayyx;
+ayyy;
+ayyz;
+ayza;
+ayzb;
+ayzc;
+ayzd;
+ayze;
+ayzf;
+ayzg;
+ayzh;
+ayzi;
+ayzj;
+ayzk;
+ayzl;
+ayzm;
+ayzn;
+ayzo;
+ayzp;
+ayzq;
+ayzr;
+ayzs;
+ayzt;
+ayzu;
+ayzv;
+ayzw;
+ayzx;
+ayzy;
+ayzz;
+azaa;
+azab;
+azac;
+azad;
+azae;
+azaf;
+azag;
+azah;
+azai;
+azaj;
+azak;
+azal;
+azam;
+azan;
+azao;
+azap;
+azaq;
+azar;
+azas;
+azat;
+azau;
+azav;
+azaw;
+azax;
+azay;
+azaz;
+azba;
+azbb;
+azbc;
+azbd;
+azbe;
+azbf;
+azbg;
+azbh;
+azbi;
+azbj;
+azbk;
+azbl;
+azbm;
+azbn;
+azbo;
+azbp;
+azbq;
+azbr;
+azbs;
+azbt;
+azbu;
+azbv;
+azbw;
+azbx;
+azby;
+azbz;
+azca;
+azcb;
+azcc;
+azcd;
+azce;
+azcf;
+azcg;
+azch;
+azci;
+azcj;
+azck;
+azcl;
+azcm;
+azcn;
+azco;
+azcp;
+azcq;
+azcr;
+azcs;
+azct;
+azcu;
+azcv;
+azcw;
+azcx;
+azcy;
+azcz;
+azda;
+azdb;
+azdc;
+azdd;
+azde;
+azdf;
+azdg;
+azdh;
+azdi;
+azdj;
+azdk;
+azdl;
+azdm;
+azdn;
+azdo;
+azdp;
+azdq;
+azdr;
+azds;
+azdt;
+azdu;
+azdv;
+azdw;
+azdx;
+azdy;
+azdz;
+azea;
+azeb;
+azec;
+azed;
+azee;
+azef;
+azeg;
+azeh;
+azei;
+azej;
+azek;
+azel;
+azem;
+azen;
+azeo;
+azep;
+azeq;
+azer;
+azes;
+azet;
+azeu;
+azev;
+azew;
+azex;
+azey;
+azez;
+azfa;
+azfb;
+azfc;
+azfd;
+azfe;
+azff;
+azfg;
+azfh;
+azfi;
+azfj;
+azfk;
+azfl;
+azfm;
+azfn;
+azfo;
+azfp;
+azfq;
+azfr;
+azfs;
+azft;
+azfu;
+azfv;
+azfw;
+azfx;
+azfy;
+azfz;
+azga;
+azgb;
+azgc;
+azgd;
+azge;
+azgf;
+azgg;
+azgh;
+azgi;
+azgj;
+azgk;
+azgl;
+azgm;
+azgn;
+azgo;
+azgp;
+azgq;
+azgr;
+azgs;
+azgt;
+azgu;
+azgv;
+azgw;
+azgx;
+azgy;
+azgz;
+azha;
+azhb;
+azhc;
+azhd;
+azhe;
+azhf;
+azhg;
+azhh;
+azhi;
+azhj;
+azhk;
+azhl;
+azhm;
+azhn;
+azho;
+azhp;
+azhq;
+azhr;
+azhs;
+azht;
+azhu;
+azhv;
+azhw;
+azhx;
+azhy;
+azhz;
+azia;
+azib;
+azic;
+azid;
+azie;
+azif;
+azig;
+azih;
+azii;
+azij;
+azik;
+azil;
+azim;
+azin;
+azio;
+azip;
+aziq;
+azir;
+azis;
+azit;
+aziu;
+aziv;
+aziw;
+azix;
+aziy;
+aziz;
+azja;
+azjb;
+azjc;
+azjd;
+azje;
+azjf;
+azjg;
+azjh;
+azji;
+azjj;
+azjk;
+azjl;
+azjm;
+azjn;
+azjo;
+azjp;
+azjq;
+azjr;
+azjs;
+azjt;
+azju;
+azjv;
+azjw;
+azjx;
+azjy;
+azjz;
+azka;
+azkb;
+azkc;
+azkd;
+azke;
+azkf;
+azkg;
+azkh;
+azki;
+azkj;
+azkk;
+azkl;
+azkm;
+azkn;
+azko;
+azkp;
+azkq;
+azkr;
+azks;
+azkt;
+azku;
+azkv;
+azkw;
+azkx;
+azky;
+azkz;
+azla;
+azlb;
+azlc;
+azld;
+azle;
+azlf;
+azlg;
+azlh;
+azli;
+azlj;
+azlk;
+azll;
+azlm;
+azln;
+azlo;
+azlp;
+azlq;
+azlr;
+azls;
+azlt;
+azlu;
+azlv;
+azlw;
+azlx;
+azly;
+azlz;
+azma;
+azmb;
+azmc;
+azmd;
+azme;
+azmf;
+azmg;
+azmh;
+azmi;
+azmj;
+azmk;
+azml;
+azmm;
+azmn;
+azmo;
+azmp;
+azmq;
+azmr;
+azms;
+azmt;
+azmu;
+azmv;
+azmw;
+azmx;
+azmy;
+azmz;
+azna;
+aznb;
+aznc;
+aznd;
+azne;
+aznf;
+azng;
+aznh;
+azni;
+aznj;
+aznk;
+aznl;
+aznm;
+aznn;
+azno;
+aznp;
+aznq;
+aznr;
+azns;
+aznt;
+aznu;
+aznv;
+aznw;
+aznx;
+azny;
+aznz;
+azoa;
+azob;
+azoc;
+azod;
+azoe;
+azof;
+azog;
+azoh;
+azoi;
+azoj;
+azok;
+azol;
+azom;
+azon;
+azoo;
+azop;
+azoq;
+azor;
+azos;
+azot;
+azou;
+azov;
+azow;
+azox;
+azoy;
+azoz;
+azpa;
+azpb;
+azpc;
+azpd;
+azpe;
+azpf;
+azpg;
+azph;
+azpi;
+azpj;
+azpk;
+azpl;
+azpm;
+azpn;
+azpo;
+azpp;
+azpq;
+azpr;
+azps;
+azpt;
+azpu;
+azpv;
+azpw;
+azpx;
+azpy;
+azpz;
+azqa;
+azqb;
+azqc;
+azqd;
+azqe;
+azqf;
+azqg;
+azqh;
+azqi;
+azqj;
+azqk;
+azql;
+azqm;
+azqn;
+azqo;
+azqp;
+azqq;
+azqr;
+azqs;
+azqt;
+azqu;
+azqv;
+azqw;
+azqx;
+azqy;
+azqz;
+azra;
+azrb;
+azrc;
+azrd;
+azre;
+azrf;
+azrg;
+azrh;
+azri;
+azrj;
+azrk;
+azrl;
+azrm;
+azrn;
+azro;
+azrp;
+azrq;
+azrr;
+azrs;
+azrt;
+azru;
+azrv;
+azrw;
+azrx;
+azry;
+azrz;
+azsa;
+azsb;
+azsc;
+azsd;
+azse;
+azsf;
+azsg;
+azsh;
+azsi;
+azsj;
+azsk;
+azsl;
+azsm;
+azsn;
+azso;
+azsp;
+azsq;
+azsr;
+azss;
+azst;
+azsu;
+azsv;
+azsw;
+azsx;
+azsy;
+azsz;
+azta;
+aztb;
+aztc;
+aztd;
+azte;
+aztf;
+aztg;
+azth;
+azti;
+aztj;
+aztk;
+aztl;
+aztm;
+aztn;
+azto;
+aztp;
+aztq;
+aztr;
+azts;
+aztt;
+aztu;
+aztv;
+aztw;
+aztx;
+azty;
+aztz;
+azua;
+azub;
+azuc;
+azud;
+azue;
+azuf;
+azug;
+azuh;
+azui;
+azuj;
+azuk;
+azul;
+azum;
+azun;
+azuo;
+azup;
+azuq;
+azur;
+azus;
+azut;
+azuu;
+azuv;
+azuw;
+azux;
+azuy;
+azuz;
+azva;
+azvb;
+azvc;
+azvd;
+azve;
+azvf;
+azvg;
+azvh;
+azvi;
+azvj;
+azvk;
+azvl;
+azvm;
+azvn;
+azvo;
+azvp;
+azvq;
+azvr;
+azvs;
+azvt;
+azvu;
+azvv;
+azvw;
+azvx;
+azvy;
+azvz;
+azwa;
+azwb;
+azwc;
+azwd;
+azwe;
+azwf;
+azwg;
+azwh;
+azwi;
+azwj;
+azwk;
+azwl;
+azwm;
+azwn;
+azwo;
+azwp;
+azwq;
+azwr;
+azws;
+azwt;
+azwu;
+azwv;
+azww;
+azwx;
+azwy;
+azwz;
+azxa;
+azxb;
+azxc;
+azxd;
+azxe;
+azxf;
+azxg;
+azxh;
+azxi;
+azxj;
+azxk;
+azxl;
+azxm;
+azxn;
+azxo;
+azxp;
+azxq;
+azxr;
+azxs;
+azxt;
+azxu;
+azxv;
+azxw;
+azxx;
+azxy;
+azxz;
+azya;
+azyb;
+azyc;
+azyd;
+azye;
+azyf;
+azyg;
+azyh;
+azyi;
+azyj;
+azyk;
+azyl;
+azym;
+azyn;
+azyo;
+azyp;
+azyq;
+azyr;
+azys;
+azyt;
+azyu;
+azyv;
+azyw;
+azyx;
+azyy;
+azyz;
+azza;
+azzb;
+azzc;
+azzd;
+azze;
+azzf;
+azzg;
+azzh;
+azzi;
+azzj;
+azzk;
+azzl;
+azzm;
+azzn;
+azzo;
+azzp;
+azzq;
+azzr;
+azzs;
+azzt;
+azzu;
+azzv;
+azzw;
+azzx;
+azzy;
+azzz;
+baaa;
+baab;
+baac;
+baad;
+baae;
+baaf;
+baag;
+baah;
+baai;
+baaj;
+baak;
+baal;
+baam;
+baan;
+baao;
+baap;
+baaq;
+baar;
+baas;
+baat;
+baau;
+baav;
+baaw;
+baax;
+baay;
+baaz;
+baba;
+babb;
+babc;
+babd;
+babe;
+babf;
+babg;
+babh;
+babi;
+babj;
+babk;
+babl;
+babm;
+babn;
+babo;
+babp;
+babq;
+babr;
+babs;
+babt;
+babu;
+babv;
+babw;
+babx;
+baby;
+babz;
+baca;
+bacb;
+bacc;
+bacd;
+bace;
+bacf;
+bacg;
+bach;
+baci;
+bacj;
+back;
+bacl;
+bacm;
+bacn;
+baco;
+bacp;
+bacq;
+bacr;
+bacs;
+bact;
+bacu;
+bacv;
+bacw;
+bacx;
+bacy;
+bacz;
+bada;
+badb;
+badc;
+badd;
+bade;
+badf;
+badg;
+badh;
+badi;
+badj;
+badk;
+badl;
+badm;
+badn;
+bado;
+badp;
+badq;
+badr;
+bads;
+badt;
+badu;
+badv;
+badw;
+badx;
+bady;
+badz;
+baea;
+baeb;
+baec;
+baed;
+baee;
+baef;
+baeg;
+baeh;
+baei;
+baej;
+baek;
+bael;
+baem;
+baen;
+baeo;
+baep;
+baeq;
+baer;
+baes;
+baet;
+baeu;
+baev;
+baew;
+baex;
+baey;
+baez;
+bafa;
+bafb;
+bafc;
+bafd;
+bafe;
+baff;
+bafg;
+bafh;
+bafi;
+bafj;
+bafk;
+bafl;
+bafm;
+bafn;
+bafo;
+bafp;
+bafq;
+bafr;
+bafs;
+baft;
+bafu;
+bafv;
+bafw;
+bafx;
+bafy;
+bafz;
+baga;
+bagb;
+bagc;
+bagd;
+bage;
+bagf;
+bagg;
+bagh;
+bagi;
+bagj;
+bagk;
+bagl;
+bagm;
+bagn;
+bago;
+bagp;
+bagq;
+bagr;
+bags;
+bagt;
+bagu;
+bagv;
+bagw;
+bagx;
+bagy;
+bagz;
+baha;
+bahb;
+bahc;
+bahd;
+bahe;
+bahf;
+bahg;
+bahh;
+bahi;
+bahj;
+bahk;
+bahl;
+bahm;
+bahn;
+baho;
+bahp;
+bahq;
+bahr;
+bahs;
+baht;
+bahu;
+bahv;
+bahw;
+bahx;
+bahy;
+bahz;
+baia;
+baib;
+baic;
+baid;
+baie;
+baif;
+baig;
+baih;
+baii;
+baij;
+baik;
+bail;
+baim;
+bain;
+baio;
+baip;
+baiq;
+bair;
+bais;
+bait;
+baiu;
+baiv;
+baiw;
+baix;
+baiy;
+baiz;
+baja;
+bajb;
+bajc;
+bajd;
+baje;
+bajf;
+bajg;
+bajh;
+baji;
+bajj;
+bajk;
+bajl;
+bajm;
+bajn;
+bajo;
+bajp;
+bajq;
+bajr;
+bajs;
+bajt;
+baju;
+bajv;
+bajw;
+bajx;
+bajy;
+bajz;
+baka;
+bakb;
+bakc;
+bakd;
+bake;
+bakf;
+bakg;
+bakh;
+baki;
+bakj;
+bakk;
+bakl;
+bakm;
+bakn;
+bako;
+bakp;
+bakq;
+bakr;
+baks;
+bakt;
+baku;
+bakv;
+bakw;
+bakx;
+baky;
+bakz;
+bala;
+balb;
+balc;
+bald;
+bale;
+balf;
+balg;
+balh;
+bali;
+balj;
+balk;
+ball;
+balm;
+baln;
+balo;
+balp;
+balq;
+balr;
+bals;
+balt;
+balu;
+balv;
+balw;
+balx;
+baly;
+balz;
+bama;
+bamb;
+bamc;
+bamd;
+bame;
+bamf;
+bamg;
+bamh;
+bami;
+bamj;
+bamk;
+baml;
+bamm;
+bamn;
+bamo;
+bamp;
+bamq;
+bamr;
+bams;
+bamt;
+bamu;
+bamv;
+bamw;
+bamx;
+bamy;
+bamz;
+bana;
+banb;
+banc;
+band;
+bane;
+banf;
+bang;
+banh;
+bani;
+banj;
+bank;
+banl;
+banm;
+bann;
+bano;
+banp;
+banq;
+banr;
+bans;
+bant;
+banu;
+banv;
+banw;
+banx;
+bany;
+banz;
+baoa;
+baob;
+baoc;
+baod;
+baoe;
+baof;
+baog;
+baoh;
+baoi;
+baoj;
+baok;
+baol;
+baom;
+baon;
+baoo;
+baop;
+baoq;
+baor;
+baos;
+baot;
+baou;
+baov;
+baow;
+baox;
+baoy;
+baoz;
+bapa;
+bapb;
+bapc;
+bapd;
+bape;
+bapf;
+bapg;
+baph;
+bapi;
+bapj;
+bapk;
+bapl;
+bapm;
+bapn;
+bapo;
+bapp;
+bapq;
+bapr;
+baps;
+bapt;
+bapu;
+bapv;
+bapw;
+bapx;
+bapy;
+bapz;
+baqa;
+baqb;
+baqc;
+baqd;
+baqe;
+baqf;
+baqg;
+baqh;
+baqi;
+baqj;
+baqk;
+baql;
+baqm;
+baqn;
+baqo;
+baqp;
+baqq;
+baqr;
+baqs;
+baqt;
+baqu;
+baqv;
+baqw;
+baqx;
+baqy;
+baqz;
+bara;
+barb;
+barc;
+bard;
+bare;
+barf;
+barg;
+barh;
+bari;
+barj;
+bark;
+barl;
+barm;
+barn;
+baro;
+barp;
+barq;
+barr;
+bars;
+bart;
+baru;
+barv;
+barw;
+barx;
+bary;
+barz;
+basa;
+basb;
+basc;
+basd;
+base;
+basf;
+basg;
+bash;
+basi;
+basj;
+bask;
+basl;
+basm;
+basn;
+baso;
+basp;
+basq;
+basr;
+bass;
+bast;
+basu;
+basv;
+basw;
+basx;
+basy;
+basz;
+bata;
+batb;
+batc;
+batd;
+bate;
+batf;
+batg;
+bath;
+bati;
+batj;
+batk;
+batl;
+batm;
+batn;
+bato;
+batp;
+batq;
+batr;
+bats;
+batt;
+batu;
+batv;
+batw;
+batx;
+baty;
+batz;
+baua;
+baub;
+bauc;
+baud;
+baue;
+bauf;
+baug;
+bauh;
+baui;
+bauj;
+bauk;
+baul;
+baum;
+baun;
+bauo;
+baup;
+bauq;
+baur;
+baus;
+baut;
+bauu;
+bauv;
+bauw;
+baux;
+bauy;
+bauz;
+bava;
+bavb;
+bavc;
+bavd;
+bave;
+bavf;
+bavg;
+bavh;
+bavi;
+bavj;
+bavk;
+bavl;
+bavm;
+bavn;
+bavo;
+bavp;
+bavq;
+bavr;
+bavs;
+bavt;
+bavu;
+bavv;
+bavw;
+bavx;
+bavy;
+bavz;
+bawa;
+bawb;
+bawc;
+bawd;
+bawe;
+bawf;
+bawg;
+bawh;
+bawi;
+bawj;
+bawk;
+bawl;
+bawm;
+bawn;
+bawo;
+bawp;
+bawq;
+bawr;
+baws;
+bawt;
+bawu;
+bawv;
+baww;
+bawx;
+bawy;
+bawz;
+baxa;
+baxb;
+baxc;
+baxd;
+baxe;
+baxf;
+baxg;
+baxh;
+baxi;
+baxj;
+baxk;
+baxl;
+baxm;
+baxn;
+baxo;
+baxp;
+baxq;
+baxr;
+baxs;
+baxt;
+baxu;
+baxv;
+baxw;
+baxx;
+baxy;
+baxz;
+baya;
+bayb;
+bayc;
+bayd;
+baye;
+bayf;
+bayg;
+bayh;
+bayi;
+bayj;
+bayk;
+bayl;
+baym;
+bayn;
+bayo;
+bayp;
+bayq;
+bayr;
+bays;
+bayt;
+bayu;
+bayv;
+bayw;
+bayx;
+bayy;
+bayz;
+baza;
+bazb;
+bazc;
+bazd;
+baze;
+bazf;
+bazg;
+bazh;
+bazi;
+bazj;
+bazk;
+bazl;
+bazm;
+bazn;
+bazo;
+bazp;
+bazq;
+bazr;
+bazs;
+bazt;
+bazu;
+bazv;
+bazw;
+bazx;
+bazy;
+bazz;
+bbaa;
+bbab;
+bbac;
+bbad;
+bbae;
+bbaf;
+bbag;
+bbah;
+bbai;
+bbaj;
+bbak;
+bbal;
+bbam;
+bban;
+bbao;
+bbap;
+bbaq;
+bbar;
+bbas;
+bbat;
+bbau;
+bbav;
+bbaw;
+bbax;
+bbay;
+bbaz;
+bbba;
+bbbb
+|];
--- /dev/null
+[|
+aaaaa;
+aaaab;
+aaaac;
+aaaad;
+aaaae;
+aaaaf;
+aaaag;
+aaaah;
+aaaai;
+aaaaj;
+aaaak;
+aaaal;
+aaaam;
+aaaan;
+aaaao;
+aaaap;
+aaaaq;
+aaaar;
+aaaas;
+aaaat;
+aaaau;
+aaaav;
+aaaaw;
+aaaax;
+aaaay;
+aaaaz;
+aaaba;
+aaabb;
+aaabc;
+aaabd;
+aaabe;
+aaabf;
+aaabg;
+aaabh;
+aaabi;
+aaabj;
+aaabk;
+aaabl;
+aaabm;
+aaabn;
+aaabo;
+aaabp;
+aaabq;
+aaabr;
+aaabs;
+aaabt;
+aaabu;
+aaabv;
+aaabw;
+aaabx;
+aaaby;
+aaabz;
+aaaca;
+aaacb;
+aaacc;
+aaacd;
+aaace;
+aaacf;
+aaacg;
+aaach;
+aaaci;
+aaacj;
+aaack;
+aaacl;
+aaacm;
+aaacn;
+aaaco;
+aaacp;
+aaacq;
+aaacr;
+aaacs;
+aaact;
+aaacu;
+aaacv;
+aaacw;
+aaacx;
+aaacy;
+aaacz;
+aaada;
+aaadb;
+aaadc;
+aaadd;
+aaade;
+aaadf;
+aaadg;
+aaadh;
+aaadi;
+aaadj;
+aaadk;
+aaadl;
+aaadm;
+aaadn;
+aaado;
+aaadp;
+aaadq;
+aaadr;
+aaads;
+aaadt;
+aaadu;
+aaadv;
+aaadw;
+aaadx;
+aaady;
+aaadz;
+aaaea;
+aaaeb;
+aaaec;
+aaaed;
+aaaee;
+aaaef;
+aaaeg;
+aaaeh;
+aaaei;
+aaaej;
+aaaek;
+aaael;
+aaaem;
+aaaen;
+aaaeo;
+aaaep;
+aaaeq;
+aaaer;
+aaaes;
+aaaet;
+aaaeu;
+aaaev;
+aaaew;
+aaaex;
+aaaey;
+aaaez;
+aaafa;
+aaafb;
+aaafc;
+aaafd;
+aaafe;
+aaaff;
+aaafg;
+aaafh;
+aaafi;
+aaafj;
+aaafk;
+aaafl;
+aaafm;
+aaafn;
+aaafo;
+aaafp;
+aaafq;
+aaafr;
+aaafs;
+aaaft;
+aaafu;
+aaafv;
+aaafw;
+aaafx;
+aaafy;
+aaafz;
+aaaga;
+aaagb;
+aaagc;
+aaagd;
+aaage;
+aaagf;
+aaagg;
+aaagh;
+aaagi;
+aaagj;
+aaagk;
+aaagl;
+aaagm;
+aaagn;
+aaago;
+aaagp;
+aaagq;
+aaagr;
+aaags;
+aaagt;
+aaagu;
+aaagv;
+aaagw;
+aaagx;
+aaagy;
+aaagz;
+aaaha;
+aaahb;
+aaahc;
+aaahd;
+aaahe;
+aaahf;
+aaahg;
+aaahh;
+aaahi;
+aaahj;
+aaahk;
+aaahl;
+aaahm;
+aaahn;
+aaaho;
+aaahp;
+aaahq;
+aaahr;
+aaahs;
+aaaht;
+aaahu;
+aaahv;
+aaahw;
+aaahx;
+aaahy;
+aaahz;
+aaaia;
+aaaib;
+aaaic;
+aaaid;
+aaaie;
+aaaif;
+aaaig;
+aaaih;
+aaaii;
+aaaij;
+aaaik;
+aaail;
+aaaim;
+aaain;
+aaaio;
+aaaip;
+aaaiq;
+aaair;
+aaais;
+aaait;
+aaaiu;
+aaaiv;
+aaaiw;
+aaaix;
+aaaiy;
+aaaiz;
+aaaja;
+aaajb;
+aaajc;
+aaajd;
+aaaje;
+aaajf;
+aaajg;
+aaajh;
+aaaji;
+aaajj;
+aaajk;
+aaajl;
+aaajm;
+aaajn;
+aaajo;
+aaajp;
+aaajq;
+aaajr;
+aaajs;
+aaajt;
+aaaju;
+aaajv;
+aaajw;
+aaajx;
+aaajy;
+aaajz;
+aaaka;
+aaakb;
+aaakc;
+aaakd;
+aaake;
+aaakf;
+aaakg;
+aaakh;
+aaaki;
+aaakj;
+aaakk;
+aaakl;
+aaakm;
+aaakn;
+aaako;
+aaakp;
+aaakq;
+aaakr;
+aaaks;
+aaakt;
+aaaku;
+aaakv;
+aaakw;
+aaakx;
+aaaky;
+aaakz;
+aaala;
+aaalb;
+aaalc;
+aaald;
+aaale;
+aaalf;
+aaalg;
+aaalh;
+aaali;
+aaalj;
+aaalk;
+aaall;
+aaalm;
+aaaln;
+aaalo;
+aaalp;
+aaalq;
+aaalr;
+aaals;
+aaalt;
+aaalu;
+aaalv;
+aaalw;
+aaalx;
+aaaly;
+aaalz;
+aaama;
+aaamb;
+aaamc;
+aaamd;
+aaame;
+aaamf;
+aaamg;
+aaamh;
+aaami;
+aaamj;
+aaamk;
+aaaml;
+aaamm;
+aaamn;
+aaamo;
+aaamp;
+aaamq;
+aaamr;
+aaams;
+aaamt;
+aaamu;
+aaamv;
+aaamw;
+aaamx;
+aaamy;
+aaamz;
+aaana;
+aaanb;
+aaanc;
+aaand;
+aaane;
+aaanf;
+aaang;
+aaanh;
+aaani;
+aaanj;
+aaank;
+aaanl;
+aaanm;
+aaann;
+aaano;
+aaanp;
+aaanq;
+aaanr;
+aaans;
+aaant;
+aaanu;
+aaanv;
+aaanw;
+aaanx;
+aaany;
+aaanz;
+aaaoa;
+aaaob;
+aaaoc;
+aaaod;
+aaaoe;
+aaaof;
+aaaog;
+aaaoh;
+aaaoi;
+aaaoj;
+aaaok;
+aaaol;
+aaaom;
+aaaon;
+aaaoo;
+aaaop;
+aaaoq;
+aaaor;
+aaaos;
+aaaot;
+aaaou;
+aaaov;
+aaaow;
+aaaox;
+aaaoy;
+aaaoz;
+aaapa;
+aaapb;
+aaapc;
+aaapd;
+aaape;
+aaapf;
+aaapg;
+aaaph;
+aaapi;
+aaapj;
+aaapk;
+aaapl;
+aaapm;
+aaapn;
+aaapo;
+aaapp;
+aaapq;
+aaapr;
+aaaps;
+aaapt;
+aaapu;
+aaapv;
+aaapw;
+aaapx;
+aaapy;
+aaapz;
+aaaqa;
+aaaqb;
+aaaqc;
+aaaqd;
+aaaqe;
+aaaqf;
+aaaqg;
+aaaqh;
+aaaqi;
+aaaqj;
+aaaqk;
+aaaql;
+aaaqm;
+aaaqn;
+aaaqo;
+aaaqp;
+aaaqq;
+aaaqr;
+aaaqs;
+aaaqt;
+aaaqu;
+aaaqv;
+aaaqw;
+aaaqx;
+aaaqy;
+aaaqz;
+aaara;
+aaarb;
+aaarc;
+aaard;
+aaare;
+aaarf;
+aaarg;
+aaarh;
+aaari;
+aaarj;
+aaark;
+aaarl;
+aaarm;
+aaarn;
+aaaro;
+aaarp;
+aaarq;
+aaarr;
+aaars;
+aaart;
+aaaru;
+aaarv;
+aaarw;
+aaarx;
+aaary;
+aaarz;
+aaasa;
+aaasb;
+aaasc;
+aaasd;
+aaase;
+aaasf;
+aaasg;
+aaash;
+aaasi;
+aaasj;
+aaask;
+aaasl;
+aaasm;
+aaasn;
+aaaso;
+aaasp;
+aaasq;
+aaasr;
+aaass;
+aaast;
+aaasu;
+aaasv;
+aaasw;
+aaasx;
+aaasy;
+aaasz;
+aaata;
+aaatb;
+aaatc;
+aaatd;
+aaate;
+aaatf;
+aaatg;
+aaath;
+aaati;
+aaatj;
+aaatk;
+aaatl;
+aaatm;
+aaatn;
+aaato;
+aaatp;
+aaatq;
+aaatr;
+aaats;
+aaatt;
+aaatu;
+aaatv;
+aaatw;
+aaatx;
+aaaty;
+aaatz;
+aaaua;
+aaaub;
+aaauc;
+aaaud;
+aaaue;
+aaauf;
+aaaug;
+aaauh;
+aaaui;
+aaauj;
+aaauk;
+aaaul;
+aaaum;
+aaaun;
+aaauo;
+aaaup;
+aaauq;
+aaaur;
+aaaus;
+aaaut;
+aaauu;
+aaauv;
+aaauw;
+aaaux;
+aaauy;
+aaauz;
+aaava;
+aaavb;
+aaavc;
+aaavd;
+aaave;
+aaavf;
+aaavg;
+aaavh;
+aaavi;
+aaavj;
+aaavk;
+aaavl;
+aaavm;
+aaavn;
+aaavo;
+aaavp;
+aaavq;
+aaavr;
+aaavs;
+aaavt;
+aaavu;
+aaavv;
+aaavw;
+aaavx;
+aaavy;
+aaavz;
+aaawa;
+aaawb;
+aaawc;
+aaawd;
+aaawe;
+aaawf;
+aaawg;
+aaawh;
+aaawi;
+aaawj;
+aaawk;
+aaawl;
+aaawm;
+aaawn;
+aaawo;
+aaawp;
+aaawq;
+aaawr;
+aaaws;
+aaawt;
+aaawu;
+aaawv;
+aaaww;
+aaawx;
+aaawy;
+aaawz;
+aaaxa;
+aaaxb;
+aaaxc;
+aaaxd;
+aaaxe;
+aaaxf;
+aaaxg;
+aaaxh;
+aaaxi;
+aaaxj;
+aaaxk;
+aaaxl;
+aaaxm;
+aaaxn;
+aaaxo;
+aaaxp;
+aaaxq;
+aaaxr;
+aaaxs;
+aaaxt;
+aaaxu;
+aaaxv;
+aaaxw;
+aaaxx;
+aaaxy;
+aaaxz;
+aaaya;
+aaayb;
+aaayc;
+aaayd;
+aaaye;
+aaayf;
+aaayg;
+aaayh;
+aaayi;
+aaayj;
+aaayk;
+aaayl;
+aaaym;
+aaayn;
+aaayo;
+aaayp;
+aaayq;
+aaayr;
+aaays;
+aaayt;
+aaayu;
+aaayv;
+aaayw;
+aaayx;
+aaayy;
+aaayz;
+aaaza;
+aaazb;
+aaazc;
+aaazd;
+aaaze;
+aaazf;
+aaazg;
+aaazh;
+aaazi;
+aaazj;
+aaazk;
+aaazl;
+aaazm;
+aaazn;
+aaazo;
+aaazp;
+aaazq;
+aaazr;
+aaazs;
+aaazt;
+aaazu;
+aaazv;
+aaazw;
+aaazx;
+aaazy;
+aaazz;
+aabaa;
+aabab;
+aabac;
+aabad;
+aabae;
+aabaf;
+aabag;
+aabah;
+aabai;
+aabaj;
+aabak;
+aabal;
+aabam;
+aaban;
+aabao;
+aabap;
+aabaq;
+aabar;
+aabas;
+aabat;
+aabau;
+aabav;
+aabaw;
+aabax;
+aabay;
+aabaz;
+aabba;
+aabbb;
+aabbc;
+aabbd;
+aabbe;
+aabbf;
+aabbg;
+aabbh;
+aabbi;
+aabbj;
+aabbk;
+aabbl;
+aabbm;
+aabbn;
+aabbo;
+aabbp;
+aabbq;
+aabbr;
+aabbs;
+aabbt;
+aabbu;
+aabbv;
+aabbw;
+aabbx;
+aabby;
+aabbz;
+aabca;
+aabcb;
+aabcc;
+aabcd;
+aabce;
+aabcf;
+aabcg;
+aabch;
+aabci;
+aabcj;
+aabck;
+aabcl;
+aabcm;
+aabcn;
+aabco;
+aabcp;
+aabcq;
+aabcr;
+aabcs;
+aabct;
+aabcu;
+aabcv;
+aabcw;
+aabcx;
+aabcy;
+aabcz;
+aabda;
+aabdb;
+aabdc;
+aabdd;
+aabde;
+aabdf;
+aabdg;
+aabdh;
+aabdi;
+aabdj;
+aabdk;
+aabdl;
+aabdm;
+aabdn;
+aabdo;
+aabdp;
+aabdq;
+aabdr;
+aabds;
+aabdt;
+aabdu;
+aabdv;
+aabdw;
+aabdx;
+aabdy;
+aabdz;
+aabea;
+aabeb;
+aabec;
+aabed;
+aabee;
+aabef;
+aabeg;
+aabeh;
+aabei;
+aabej;
+aabek;
+aabel;
+aabem;
+aaben;
+aabeo;
+aabep;
+aabeq;
+aaber;
+aabes;
+aabet;
+aabeu;
+aabev;
+aabew;
+aabex;
+aabey;
+aabez;
+aabfa;
+aabfb;
+aabfc;
+aabfd;
+aabfe;
+aabff;
+aabfg;
+aabfh;
+aabfi;
+aabfj;
+aabfk;
+aabfl;
+aabfm;
+aabfn;
+aabfo;
+aabfp;
+aabfq;
+aabfr;
+aabfs;
+aabft;
+aabfu;
+aabfv;
+aabfw;
+aabfx;
+aabfy;
+aabfz;
+aabga;
+aabgb;
+aabgc;
+aabgd;
+aabge;
+aabgf;
+aabgg;
+aabgh;
+aabgi;
+aabgj;
+aabgk;
+aabgl;
+aabgm;
+aabgn;
+aabgo;
+aabgp;
+aabgq;
+aabgr;
+aabgs;
+aabgt;
+aabgu;
+aabgv;
+aabgw;
+aabgx;
+aabgy;
+aabgz;
+aabha;
+aabhb;
+aabhc;
+aabhd;
+aabhe;
+aabhf;
+aabhg;
+aabhh;
+aabhi;
+aabhj;
+aabhk;
+aabhl;
+aabhm;
+aabhn;
+aabho;
+aabhp;
+aabhq;
+aabhr;
+aabhs;
+aabht;
+aabhu;
+aabhv;
+aabhw;
+aabhx;
+aabhy;
+aabhz;
+aabia;
+aabib;
+aabic;
+aabid;
+aabie;
+aabif;
+aabig;
+aabih;
+aabii;
+aabij;
+aabik;
+aabil;
+aabim;
+aabin;
+aabio;
+aabip;
+aabiq;
+aabir;
+aabis;
+aabit;
+aabiu;
+aabiv;
+aabiw;
+aabix;
+aabiy;
+aabiz;
+aabja;
+aabjb;
+aabjc;
+aabjd;
+aabje;
+aabjf;
+aabjg;
+aabjh;
+aabji;
+aabjj;
+aabjk;
+aabjl;
+aabjm;
+aabjn;
+aabjo;
+aabjp;
+aabjq;
+aabjr;
+aabjs;
+aabjt;
+aabju;
+aabjv;
+aabjw;
+aabjx;
+aabjy;
+aabjz;
+aabka;
+aabkb;
+aabkc;
+aabkd;
+aabke;
+aabkf;
+aabkg;
+aabkh;
+aabki;
+aabkj;
+aabkk;
+aabkl;
+aabkm;
+aabkn;
+aabko;
+aabkp;
+aabkq;
+aabkr;
+aabks;
+aabkt;
+aabku;
+aabkv;
+aabkw;
+aabkx;
+aabky;
+aabkz;
+aabla;
+aablb;
+aablc;
+aabld;
+aable;
+aablf;
+aablg;
+aablh;
+aabli;
+aablj;
+aablk;
+aabll;
+aablm;
+aabln;
+aablo;
+aablp;
+aablq;
+aablr;
+aabls;
+aablt;
+aablu;
+aablv;
+aablw;
+aablx;
+aably;
+aablz;
+aabma;
+aabmb;
+aabmc;
+aabmd;
+aabme;
+aabmf;
+aabmg;
+aabmh;
+aabmi;
+aabmj;
+aabmk;
+aabml;
+aabmm;
+aabmn;
+aabmo;
+aabmp;
+aabmq;
+aabmr;
+aabms;
+aabmt;
+aabmu;
+aabmv;
+aabmw;
+aabmx;
+aabmy;
+aabmz;
+aabna;
+aabnb;
+aabnc;
+aabnd;
+aabne;
+aabnf;
+aabng;
+aabnh;
+aabni;
+aabnj;
+aabnk;
+aabnl;
+aabnm;
+aabnn;
+aabno;
+aabnp;
+aabnq;
+aabnr;
+aabns;
+aabnt;
+aabnu;
+aabnv;
+aabnw;
+aabnx;
+aabny;
+aabnz;
+aaboa;
+aabob;
+aaboc;
+aabod;
+aaboe;
+aabof;
+aabog;
+aaboh;
+aaboi;
+aaboj;
+aabok;
+aabol;
+aabom;
+aabon;
+aaboo;
+aabop;
+aaboq;
+aabor;
+aabos;
+aabot;
+aabou;
+aabov;
+aabow;
+aabox;
+aaboy;
+aaboz;
+aabpa;
+aabpb;
+aabpc;
+aabpd;
+aabpe;
+aabpf;
+aabpg;
+aabph;
+aabpi;
+aabpj;
+aabpk;
+aabpl;
+aabpm;
+aabpn;
+aabpo;
+aabpp;
+aabpq;
+aabpr;
+aabps;
+aabpt;
+aabpu;
+aabpv;
+aabpw;
+aabpx;
+aabpy;
+aabpz;
+aabqa;
+aabqb;
+aabqc;
+aabqd;
+aabqe;
+aabqf;
+aabqg;
+aabqh;
+aabqi;
+aabqj;
+aabqk;
+aabql;
+aabqm;
+aabqn;
+aabqo;
+aabqp;
+aabqq;
+aabqr;
+aabqs;
+aabqt;
+aabqu;
+aabqv;
+aabqw;
+aabqx;
+aabqy;
+aabqz;
+aabra;
+aabrb;
+aabrc;
+aabrd;
+aabre;
+aabrf;
+aabrg;
+aabrh;
+aabri;
+aabrj;
+aabrk;
+aabrl;
+aabrm;
+aabrn;
+aabro;
+aabrp;
+aabrq;
+aabrr;
+aabrs;
+aabrt;
+aabru;
+aabrv;
+aabrw;
+aabrx;
+aabry;
+aabrz;
+aabsa;
+aabsb;
+aabsc;
+aabsd;
+aabse;
+aabsf;
+aabsg;
+aabsh;
+aabsi;
+aabsj;
+aabsk;
+aabsl;
+aabsm;
+aabsn;
+aabso;
+aabsp;
+aabsq;
+aabsr;
+aabss;
+aabst;
+aabsu;
+aabsv;
+aabsw;
+aabsx;
+aabsy;
+aabsz;
+aabta;
+aabtb;
+aabtc;
+aabtd;
+aabte;
+aabtf;
+aabtg;
+aabth;
+aabti;
+aabtj;
+aabtk;
+aabtl;
+aabtm;
+aabtn;
+aabto;
+aabtp;
+aabtq;
+aabtr;
+aabts;
+aabtt;
+aabtu;
+aabtv;
+aabtw;
+aabtx;
+aabty;
+aabtz;
+aabua;
+aabub;
+aabuc;
+aabud;
+aabue;
+aabuf;
+aabug;
+aabuh;
+aabui;
+aabuj;
+aabuk;
+aabul;
+aabum;
+aabun;
+aabuo;
+aabup;
+aabuq;
+aabur;
+aabus;
+aabut;
+aabuu;
+aabuv;
+aabuw;
+aabux;
+aabuy;
+aabuz;
+aabva;
+aabvb;
+aabvc;
+aabvd;
+aabve;
+aabvf;
+aabvg;
+aabvh;
+aabvi;
+aabvj;
+aabvk;
+aabvl;
+aabvm;
+aabvn;
+aabvo;
+aabvp;
+aabvq;
+aabvr;
+aabvs;
+aabvt;
+aabvu;
+aabvv;
+aabvw;
+aabvx;
+aabvy;
+aabvz;
+aabwa;
+aabwb;
+aabwc;
+aabwd;
+aabwe;
+aabwf;
+aabwg;
+aabwh;
+aabwi;
+aabwj;
+aabwk;
+aabwl;
+aabwm;
+aabwn;
+aabwo;
+aabwp;
+aabwq;
+aabwr;
+aabws;
+aabwt;
+aabwu;
+aabwv;
+aabww;
+aabwx;
+aabwy;
+aabwz;
+aabxa;
+aabxb;
+aabxc;
+aabxd;
+aabxe;
+aabxf;
+aabxg;
+aabxh;
+aabxi;
+aabxj;
+aabxk;
+aabxl;
+aabxm;
+aabxn;
+aabxo;
+aabxp;
+aabxq;
+aabxr;
+aabxs;
+aabxt;
+aabxu;
+aabxv;
+aabxw;
+aabxx;
+aabxy;
+aabxz;
+aabya;
+aabyb;
+aabyc;
+aabyd;
+aabye;
+aabyf;
+aabyg;
+aabyh;
+aabyi;
+aabyj;
+aabyk;
+aabyl;
+aabym;
+aabyn;
+aabyo;
+aabyp;
+aabyq;
+aabyr;
+aabys;
+aabyt;
+aabyu;
+aabyv;
+aabyw;
+aabyx;
+aabyy;
+aabyz;
+aabza;
+aabzb;
+aabzc;
+aabzd;
+aabze;
+aabzf;
+aabzg;
+aabzh;
+aabzi;
+aabzj;
+aabzk;
+aabzl;
+aabzm;
+aabzn;
+aabzo;
+aabzp;
+aabzq;
+aabzr;
+aabzs;
+aabzt;
+aabzu;
+aabzv;
+aabzw;
+aabzx;
+aabzy;
+aabzz;
+aacaa;
+aacab;
+aacac;
+aacad;
+aacae;
+aacaf;
+aacag;
+aacah;
+aacai;
+aacaj;
+aacak;
+aacal;
+aacam;
+aacan;
+aacao;
+aacap;
+aacaq;
+aacar;
+aacas;
+aacat;
+aacau;
+aacav;
+aacaw;
+aacax;
+aacay;
+aacaz;
+aacba;
+aacbb;
+aacbc;
+aacbd;
+aacbe;
+aacbf;
+aacbg;
+aacbh;
+aacbi;
+aacbj;
+aacbk;
+aacbl;
+aacbm;
+aacbn;
+aacbo;
+aacbp;
+aacbq;
+aacbr;
+aacbs;
+aacbt;
+aacbu;
+aacbv;
+aacbw;
+aacbx;
+aacby;
+aacbz;
+aacca;
+aaccb;
+aaccc;
+aaccd;
+aacce;
+aaccf;
+aaccg;
+aacch;
+aacci;
+aaccj;
+aacck;
+aaccl;
+aaccm;
+aaccn;
+aacco;
+aaccp;
+aaccq;
+aaccr;
+aaccs;
+aacct;
+aaccu;
+aaccv;
+aaccw;
+aaccx;
+aaccy;
+aaccz;
+aacda;
+aacdb;
+aacdc;
+aacdd;
+aacde;
+aacdf;
+aacdg;
+aacdh;
+aacdi;
+aacdj;
+aacdk;
+aacdl;
+aacdm;
+aacdn;
+aacdo;
+aacdp;
+aacdq;
+aacdr;
+aacds;
+aacdt;
+aacdu;
+aacdv;
+aacdw;
+aacdx;
+aacdy;
+aacdz;
+aacea;
+aaceb;
+aacec;
+aaced;
+aacee;
+aacef;
+aaceg;
+aaceh;
+aacei;
+aacej;
+aacek;
+aacel;
+aacem;
+aacen;
+aaceo;
+aacep;
+aaceq;
+aacer;
+aaces;
+aacet;
+aaceu;
+aacev;
+aacew;
+aacex;
+aacey;
+aacez;
+aacfa;
+aacfb;
+aacfc;
+aacfd;
+aacfe;
+aacff;
+aacfg;
+aacfh;
+aacfi;
+aacfj;
+aacfk;
+aacfl;
+aacfm;
+aacfn;
+aacfo;
+aacfp;
+aacfq;
+aacfr;
+aacfs;
+aacft;
+aacfu;
+aacfv;
+aacfw;
+aacfx;
+aacfy;
+aacfz;
+aacga;
+aacgb;
+aacgc;
+aacgd;
+aacge;
+aacgf;
+aacgg;
+aacgh;
+aacgi;
+aacgj;
+aacgk;
+aacgl;
+aacgm;
+aacgn;
+aacgo;
+aacgp;
+aacgq;
+aacgr;
+aacgs;
+aacgt;
+aacgu;
+aacgv;
+aacgw;
+aacgx;
+aacgy;
+aacgz;
+aacha;
+aachb;
+aachc;
+aachd;
+aache;
+aachf;
+aachg;
+aachh;
+aachi;
+aachj;
+aachk;
+aachl;
+aachm;
+aachn;
+aacho;
+aachp;
+aachq;
+aachr;
+aachs;
+aacht;
+aachu;
+aachv;
+aachw;
+aachx;
+aachy;
+aachz;
+aacia;
+aacib;
+aacic;
+aacid;
+aacie;
+aacif;
+aacig;
+aacih;
+aacii;
+aacij;
+aacik;
+aacil;
+aacim;
+aacin;
+aacio;
+aacip;
+aaciq;
+aacir;
+aacis;
+aacit;
+aaciu;
+aaciv;
+aaciw;
+aacix;
+aaciy;
+aaciz;
+aacja;
+aacjb;
+aacjc;
+aacjd;
+aacje;
+aacjf;
+aacjg;
+aacjh;
+aacji;
+aacjj;
+aacjk;
+aacjl;
+aacjm;
+aacjn;
+aacjo;
+aacjp;
+aacjq;
+aacjr;
+aacjs;
+aacjt;
+aacju;
+aacjv;
+aacjw;
+aacjx;
+aacjy;
+aacjz;
+aacka;
+aackb;
+aackc;
+aackd;
+aacke;
+aackf;
+aackg;
+aackh;
+aacki;
+aackj;
+aackk;
+aackl;
+aackm;
+aackn;
+aacko;
+aackp;
+aackq;
+aackr;
+aacks;
+aackt;
+aacku;
+aackv;
+aackw;
+aackx;
+aacky;
+aackz;
+aacla;
+aaclb;
+aaclc;
+aacld;
+aacle;
+aaclf;
+aaclg;
+aaclh;
+aacli;
+aaclj;
+aaclk;
+aacll;
+aaclm;
+aacln;
+aaclo;
+aaclp;
+aaclq;
+aaclr;
+aacls;
+aaclt;
+aaclu;
+aaclv;
+aaclw;
+aaclx;
+aacly;
+aaclz;
+aacma;
+aacmb;
+aacmc;
+aacmd;
+aacme;
+aacmf;
+aacmg;
+aacmh;
+aacmi;
+aacmj;
+aacmk;
+aacml;
+aacmm;
+aacmn;
+aacmo;
+aacmp;
+aacmq;
+aacmr;
+aacms;
+aacmt;
+aacmu;
+aacmv;
+aacmw;
+aacmx;
+aacmy;
+aacmz;
+aacna;
+aacnb;
+aacnc;
+aacnd;
+aacne;
+aacnf;
+aacng;
+aacnh;
+aacni;
+aacnj;
+aacnk;
+aacnl;
+aacnm;
+aacnn;
+aacno;
+aacnp;
+aacnq;
+aacnr;
+aacns;
+aacnt;
+aacnu;
+aacnv;
+aacnw;
+aacnx;
+aacny;
+aacnz;
+aacoa;
+aacob;
+aacoc;
+aacod;
+aacoe;
+aacof;
+aacog;
+aacoh;
+aacoi;
+aacoj;
+aacok;
+aacol;
+aacom;
+aacon;
+aacoo;
+aacop;
+aacoq;
+aacor;
+aacos;
+aacot;
+aacou;
+aacov;
+aacow;
+aacox;
+aacoy;
+aacoz;
+aacpa;
+aacpb;
+aacpc;
+aacpd;
+aacpe;
+aacpf;
+aacpg;
+aacph;
+aacpi;
+aacpj;
+aacpk;
+aacpl;
+aacpm;
+aacpn;
+aacpo;
+aacpp;
+aacpq;
+aacpr;
+aacps;
+aacpt;
+aacpu;
+aacpv;
+aacpw;
+aacpx;
+aacpy;
+aacpz;
+aacqa;
+aacqb;
+aacqc;
+aacqd;
+aacqe;
+aacqf;
+aacqg;
+aacqh;
+aacqi;
+aacqj;
+aacqk;
+aacql;
+aacqm;
+aacqn;
+aacqo;
+aacqp;
+aacqq;
+aacqr;
+aacqs;
+aacqt;
+aacqu;
+aacqv;
+aacqw;
+aacqx;
+aacqy;
+aacqz;
+aacra;
+aacrb;
+aacrc;
+aacrd;
+aacre;
+aacrf;
+aacrg;
+aacrh;
+aacri;
+aacrj;
+aacrk;
+aacrl;
+aacrm;
+aacrn;
+aacro;
+aacrp;
+aacrq;
+aacrr;
+aacrs;
+aacrt;
+aacru;
+aacrv;
+aacrw;
+aacrx;
+aacry;
+aacrz;
+aacsa;
+aacsb;
+aacsc;
+aacsd;
+aacse;
+aacsf;
+aacsg;
+aacsh;
+aacsi;
+aacsj;
+aacsk;
+aacsl;
+aacsm;
+aacsn;
+aacso;
+aacsp;
+aacsq;
+aacsr;
+aacss;
+aacst;
+aacsu;
+aacsv;
+aacsw;
+aacsx;
+aacsy;
+aacsz;
+aacta;
+aactb;
+aactc;
+aactd;
+aacte;
+aactf;
+aactg;
+aacth;
+aacti;
+aactj;
+aactk;
+aactl;
+aactm;
+aactn;
+aacto;
+aactp;
+aactq;
+aactr;
+aacts;
+aactt;
+aactu;
+aactv;
+aactw;
+aactx;
+aacty;
+aactz;
+aacua;
+aacub;
+aacuc;
+aacud;
+aacue;
+aacuf;
+aacug;
+aacuh;
+aacui;
+aacuj;
+aacuk;
+aacul;
+aacum;
+aacun;
+aacuo;
+aacup;
+aacuq;
+aacur;
+aacus;
+aacut;
+aacuu;
+aacuv;
+aacuw;
+aacux;
+aacuy;
+aacuz;
+aacva;
+aacvb;
+aacvc;
+aacvd;
+aacve;
+aacvf;
+aacvg;
+aacvh;
+aacvi;
+aacvj;
+aacvk;
+aacvl;
+aacvm;
+aacvn;
+aacvo;
+aacvp;
+aacvq;
+aacvr;
+aacvs;
+aacvt;
+aacvu;
+aacvv;
+aacvw;
+aacvx;
+aacvy;
+aacvz;
+aacwa;
+aacwb;
+aacwc;
+aacwd;
+aacwe;
+aacwf;
+aacwg;
+aacwh;
+aacwi;
+aacwj;
+aacwk;
+aacwl;
+aacwm;
+aacwn;
+aacwo;
+aacwp;
+aacwq;
+aacwr;
+aacws;
+aacwt;
+aacwu;
+aacwv;
+aacww;
+aacwx;
+aacwy;
+aacwz;
+aacxa;
+aacxb;
+aacxc;
+aacxd;
+aacxe;
+aacxf;
+aacxg;
+aacxh;
+aacxi;
+aacxj;
+aacxk;
+aacxl;
+aacxm;
+aacxn;
+aacxo;
+aacxp;
+aacxq;
+aacxr;
+aacxs;
+aacxt;
+aacxu;
+aacxv;
+aacxw;
+aacxx;
+aacxy;
+aacxz;
+aacya;
+aacyb;
+aacyc;
+aacyd;
+aacye;
+aacyf;
+aacyg;
+aacyh;
+aacyi;
+aacyj;
+aacyk;
+aacyl;
+aacym;
+aacyn;
+aacyo;
+aacyp;
+aacyq;
+aacyr;
+aacys;
+aacyt;
+aacyu;
+aacyv;
+aacyw;
+aacyx;
+aacyy;
+aacyz;
+aacza;
+aaczb;
+aaczc;
+aaczd;
+aacze;
+aaczf;
+aaczg;
+aaczh;
+aaczi;
+aaczj;
+aaczk;
+aaczl;
+aaczm;
+aaczn;
+aaczo;
+aaczp;
+aaczq;
+aaczr;
+aaczs;
+aaczt;
+aaczu;
+aaczv;
+aaczw;
+aaczx;
+aaczy;
+aaczz;
+aadaa;
+aadab;
+aadac;
+aadad;
+aadae;
+aadaf;
+aadag;
+aadah;
+aadai;
+aadaj;
+aadak;
+aadal;
+aadam;
+aadan;
+aadao;
+aadap;
+aadaq;
+aadar;
+aadas;
+aadat;
+aadau;
+aadav;
+aadaw;
+aadax;
+aaday;
+aadaz;
+aadba;
+aadbb;
+aadbc;
+aadbd;
+aadbe;
+aadbf;
+aadbg;
+aadbh;
+aadbi;
+aadbj;
+aadbk;
+aadbl;
+aadbm;
+aadbn;
+aadbo;
+aadbp;
+aadbq;
+aadbr;
+aadbs;
+aadbt;
+aadbu;
+aadbv;
+aadbw;
+aadbx;
+aadby;
+aadbz;
+aadca;
+aadcb;
+aadcc;
+aadcd;
+aadce;
+aadcf;
+aadcg;
+aadch;
+aadci;
+aadcj;
+aadck;
+aadcl;
+aadcm;
+aadcn;
+aadco;
+aadcp;
+aadcq;
+aadcr;
+aadcs;
+aadct;
+aadcu;
+aadcv;
+aadcw;
+aadcx;
+aadcy;
+aadcz;
+aadda;
+aaddb;
+aaddc;
+aaddd;
+aadde;
+aaddf;
+aaddg;
+aaddh;
+aaddi;
+aaddj;
+aaddk;
+aaddl;
+aaddm;
+aaddn;
+aaddo;
+aaddp;
+aaddq;
+aaddr;
+aadds;
+aaddt;
+aaddu;
+aaddv;
+aaddw;
+aaddx;
+aaddy;
+aaddz;
+aadea;
+aadeb;
+aadec;
+aaded;
+aadee;
+aadef;
+aadeg;
+aadeh;
+aadei;
+aadej;
+aadek;
+aadel;
+aadem;
+aaden;
+aadeo;
+aadep;
+aadeq;
+aader;
+aades;
+aadet;
+aadeu;
+aadev;
+aadew;
+aadex;
+aadey;
+aadez;
+aadfa;
+aadfb;
+aadfc;
+aadfd;
+aadfe;
+aadff;
+aadfg;
+aadfh;
+aadfi;
+aadfj;
+aadfk;
+aadfl;
+aadfm;
+aadfn;
+aadfo;
+aadfp;
+aadfq;
+aadfr;
+aadfs;
+aadft;
+aadfu;
+aadfv;
+aadfw;
+aadfx;
+aadfy;
+aadfz;
+aadga;
+aadgb;
+aadgc;
+aadgd;
+aadge;
+aadgf;
+aadgg;
+aadgh;
+aadgi;
+aadgj;
+aadgk;
+aadgl;
+aadgm;
+aadgn;
+aadgo;
+aadgp;
+aadgq;
+aadgr;
+aadgs;
+aadgt;
+aadgu;
+aadgv;
+aadgw;
+aadgx;
+aadgy;
+aadgz;
+aadha;
+aadhb;
+aadhc;
+aadhd;
+aadhe;
+aadhf;
+aadhg;
+aadhh;
+aadhi;
+aadhj;
+aadhk;
+aadhl;
+aadhm;
+aadhn;
+aadho;
+aadhp;
+aadhq;
+aadhr;
+aadhs;
+aadht;
+aadhu;
+aadhv;
+aadhw;
+aadhx;
+aadhy;
+aadhz;
+aadia;
+aadib;
+aadic;
+aadid;
+aadie;
+aadif;
+aadig;
+aadih;
+aadii;
+aadij;
+aadik;
+aadil;
+aadim;
+aadin;
+aadio;
+aadip;
+aadiq;
+aadir;
+aadis;
+aadit;
+aadiu;
+aadiv;
+aadiw;
+aadix;
+aadiy;
+aadiz;
+aadja;
+aadjb;
+aadjc;
+aadjd;
+aadje;
+aadjf;
+aadjg;
+aadjh;
+aadji;
+aadjj;
+aadjk;
+aadjl;
+aadjm;
+aadjn;
+aadjo;
+aadjp;
+aadjq;
+aadjr;
+aadjs;
+aadjt;
+aadju;
+aadjv;
+aadjw;
+aadjx;
+aadjy;
+aadjz;
+aadka;
+aadkb;
+aadkc;
+aadkd;
+aadke;
+aadkf;
+aadkg;
+aadkh;
+aadki;
+aadkj;
+aadkk;
+aadkl;
+aadkm;
+aadkn;
+aadko;
+aadkp;
+aadkq;
+aadkr;
+aadks;
+aadkt;
+aadku;
+aadkv;
+aadkw;
+aadkx;
+aadky;
+aadkz;
+aadla;
+aadlb;
+aadlc;
+aadld;
+aadle;
+aadlf;
+aadlg;
+aadlh;
+aadli;
+aadlj;
+aadlk;
+aadll;
+aadlm;
+aadln;
+aadlo;
+aadlp;
+aadlq;
+aadlr;
+aadls;
+aadlt;
+aadlu;
+aadlv;
+aadlw;
+aadlx;
+aadly;
+aadlz;
+aadma;
+aadmb;
+aadmc;
+aadmd;
+aadme;
+aadmf;
+aadmg;
+aadmh;
+aadmi;
+aadmj;
+aadmk;
+aadml;
+aadmm;
+aadmn;
+aadmo;
+aadmp;
+aadmq;
+aadmr;
+aadms;
+aadmt;
+aadmu;
+aadmv;
+aadmw;
+aadmx;
+aadmy;
+aadmz;
+aadna;
+aadnb;
+aadnc;
+aadnd;
+aadne;
+aadnf;
+aadng;
+aadnh;
+aadni;
+aadnj;
+aadnk;
+aadnl;
+aadnm;
+aadnn;
+aadno;
+aadnp;
+aadnq;
+aadnr;
+aadns;
+aadnt;
+aadnu;
+aadnv;
+aadnw;
+aadnx;
+aadny;
+aadnz;
+aadoa;
+aadob;
+aadoc;
+aadod;
+aadoe;
+aadof;
+aadog;
+aadoh;
+aadoi;
+aadoj;
+aadok;
+aadol;
+aadom;
+aadon;
+aadoo;
+aadop;
+aadoq;
+aador;
+aados;
+aadot;
+aadou;
+aadov;
+aadow;
+aadox;
+aadoy;
+aadoz;
+aadpa;
+aadpb;
+aadpc;
+aadpd;
+aadpe;
+aadpf;
+aadpg;
+aadph;
+aadpi;
+aadpj;
+aadpk;
+aadpl;
+aadpm;
+aadpn;
+aadpo;
+aadpp;
+aadpq;
+aadpr;
+aadps;
+aadpt;
+aadpu;
+aadpv;
+aadpw;
+aadpx;
+aadpy;
+aadpz;
+aadqa;
+aadqb;
+aadqc;
+aadqd;
+aadqe;
+aadqf;
+aadqg;
+aadqh;
+aadqi;
+aadqj;
+aadqk;
+aadql;
+aadqm;
+aadqn;
+aadqo;
+aadqp;
+aadqq;
+aadqr;
+aadqs;
+aadqt;
+aadqu;
+aadqv;
+aadqw;
+aadqx;
+aadqy;
+aadqz;
+aadra;
+aadrb;
+aadrc;
+aadrd;
+aadre;
+aadrf;
+aadrg;
+aadrh;
+aadri;
+aadrj;
+aadrk;
+aadrl;
+aadrm;
+aadrn;
+aadro;
+aadrp;
+aadrq;
+aadrr;
+aadrs;
+aadrt;
+aadru;
+aadrv;
+aadrw;
+aadrx;
+aadry;
+aadrz;
+aadsa;
+aadsb;
+aadsc;
+aadsd;
+aadse;
+aadsf;
+aadsg;
+aadsh;
+aadsi;
+aadsj;
+aadsk;
+aadsl;
+aadsm;
+aadsn;
+aadso;
+aadsp;
+aadsq;
+aadsr;
+aadss;
+aadst;
+aadsu;
+aadsv;
+aadsw;
+aadsx;
+aadsy;
+aadsz;
+aadta;
+aadtb;
+aadtc;
+aadtd;
+aadte;
+aadtf;
+aadtg;
+aadth;
+aadti;
+aadtj;
+aadtk;
+aadtl;
+aadtm;
+aadtn;
+aadto;
+aadtp;
+aadtq;
+aadtr;
+aadts;
+aadtt;
+aadtu;
+aadtv;
+aadtw;
+aadtx;
+aadty;
+aadtz;
+aadua;
+aadub;
+aaduc;
+aadud;
+aadue;
+aaduf;
+aadug;
+aaduh;
+aadui;
+aaduj;
+aaduk;
+aadul;
+aadum;
+aadun;
+aaduo;
+aadup;
+aaduq;
+aadur;
+aadus;
+aadut;
+aaduu;
+aaduv;
+aaduw;
+aadux;
+aaduy;
+aaduz;
+aadva;
+aadvb;
+aadvc;
+aadvd;
+aadve;
+aadvf;
+aadvg;
+aadvh;
+aadvi;
+aadvj;
+aadvk;
+aadvl;
+aadvm;
+aadvn;
+aadvo;
+aadvp;
+aadvq;
+aadvr;
+aadvs;
+aadvt;
+aadvu;
+aadvv;
+aadvw;
+aadvx;
+aadvy;
+aadvz;
+aadwa;
+aadwb;
+aadwc;
+aadwd;
+aadwe;
+aadwf;
+aadwg;
+aadwh;
+aadwi;
+aadwj;
+aadwk;
+aadwl;
+aadwm;
+aadwn;
+aadwo;
+aadwp;
+aadwq;
+aadwr;
+aadws;
+aadwt;
+aadwu;
+aadwv;
+aadww;
+aadwx;
+aadwy;
+aadwz;
+aadxa;
+aadxb;
+aadxc;
+aadxd;
+aadxe;
+aadxf;
+aadxg;
+aadxh;
+aadxi;
+aadxj;
+aadxk;
+aadxl;
+aadxm;
+aadxn;
+aadxo;
+aadxp;
+aadxq;
+aadxr;
+aadxs;
+aadxt;
+aadxu;
+aadxv;
+aadxw;
+aadxx;
+aadxy;
+aadxz;
+aadya;
+aadyb;
+aadyc;
+aadyd;
+aadye;
+aadyf;
+aadyg;
+aadyh;
+aadyi;
+aadyj;
+aadyk;
+aadyl;
+aadym;
+aadyn;
+aadyo;
+aadyp;
+aadyq;
+aadyr;
+aadys;
+aadyt;
+aadyu;
+aadyv;
+aadyw;
+aadyx;
+aadyy;
+aadyz;
+aadza;
+aadzb;
+aadzc;
+aadzd;
+aadze;
+aadzf;
+aadzg;
+aadzh;
+aadzi;
+aadzj;
+aadzk;
+aadzl;
+aadzm;
+aadzn;
+aadzo;
+aadzp;
+aadzq;
+aadzr;
+aadzs;
+aadzt;
+aadzu;
+aadzv;
+aadzw;
+aadzx;
+aadzy;
+aadzz;
+aaeaa;
+aaeab;
+aaeac;
+aaead;
+aaeae;
+aaeaf;
+aaeag;
+aaeah;
+aaeai;
+aaeaj;
+aaeak;
+aaeal;
+aaeam;
+aaean;
+aaeao;
+aaeap;
+aaeaq;
+aaear;
+aaeas;
+aaeat;
+aaeau;
+aaeav;
+aaeaw;
+aaeax;
+aaeay;
+aaeaz;
+aaeba;
+aaebb;
+aaebc;
+aaebd;
+aaebe;
+aaebf;
+aaebg;
+aaebh;
+aaebi;
+aaebj;
+aaebk;
+aaebl;
+aaebm;
+aaebn;
+aaebo;
+aaebp;
+aaebq;
+aaebr;
+aaebs;
+aaebt;
+aaebu;
+aaebv;
+aaebw;
+aaebx;
+aaeby;
+aaebz;
+aaeca;
+aaecb;
+aaecc;
+aaecd;
+aaece;
+aaecf;
+aaecg;
+aaech;
+aaeci;
+aaecj;
+aaeck;
+aaecl;
+aaecm;
+aaecn;
+aaeco;
+aaecp;
+aaecq;
+aaecr;
+aaecs;
+aaect;
+aaecu;
+aaecv;
+aaecw;
+aaecx;
+aaecy;
+aaecz;
+aaeda;
+aaedb;
+aaedc;
+aaedd;
+aaede;
+aaedf;
+aaedg;
+aaedh;
+aaedi;
+aaedj;
+aaedk;
+aaedl;
+aaedm;
+aaedn;
+aaedo;
+aaedp;
+aaedq;
+aaedr;
+aaeds;
+aaedt;
+aaedu;
+aaedv;
+aaedw;
+aaedx;
+aaedy;
+aaedz;
+aaeea;
+aaeeb;
+aaeec;
+aaeed;
+aaeee;
+aaeef;
+aaeeg;
+aaeeh;
+aaeei;
+aaeej;
+aaeek;
+aaeel;
+aaeem;
+aaeen;
+aaeeo;
+aaeep;
+aaeeq;
+aaeer;
+aaees;
+aaeet;
+aaeeu;
+aaeev;
+aaeew;
+aaeex;
+aaeey;
+aaeez;
+aaefa;
+aaefb;
+aaefc;
+aaefd;
+aaefe;
+aaeff;
+aaefg;
+aaefh;
+aaefi;
+aaefj;
+aaefk;
+aaefl;
+aaefm;
+aaefn;
+aaefo;
+aaefp;
+aaefq;
+aaefr;
+aaefs;
+aaeft;
+aaefu;
+aaefv;
+aaefw;
+aaefx;
+aaefy;
+aaefz;
+aaega;
+aaegb;
+aaegc;
+aaegd;
+aaege;
+aaegf;
+aaegg;
+aaegh;
+aaegi;
+aaegj;
+aaegk;
+aaegl;
+aaegm;
+aaegn;
+aaego;
+aaegp;
+aaegq;
+aaegr;
+aaegs;
+aaegt;
+aaegu;
+aaegv;
+aaegw;
+aaegx;
+aaegy;
+aaegz;
+aaeha;
+aaehb;
+aaehc;
+aaehd;
+aaehe;
+aaehf;
+aaehg;
+aaehh;
+aaehi;
+aaehj;
+aaehk;
+aaehl;
+aaehm;
+aaehn;
+aaeho;
+aaehp;
+aaehq;
+aaehr;
+aaehs;
+aaeht;
+aaehu;
+aaehv;
+aaehw;
+aaehx;
+aaehy;
+aaehz;
+aaeia;
+aaeib;
+aaeic;
+aaeid;
+aaeie;
+aaeif;
+aaeig;
+aaeih;
+aaeii;
+aaeij;
+aaeik;
+aaeil;
+aaeim;
+aaein;
+aaeio;
+aaeip;
+aaeiq;
+aaeir;
+aaeis;
+aaeit;
+aaeiu;
+aaeiv;
+aaeiw;
+aaeix;
+aaeiy;
+aaeiz;
+aaeja;
+aaejb;
+aaejc;
+aaejd;
+aaeje;
+aaejf;
+aaejg;
+aaejh;
+aaeji;
+aaejj;
+aaejk;
+aaejl;
+aaejm;
+aaejn;
+aaejo;
+aaejp;
+aaejq;
+aaejr;
+aaejs;
+aaejt;
+aaeju;
+aaejv;
+aaejw;
+aaejx;
+aaejy;
+aaejz;
+aaeka;
+aaekb;
+aaekc;
+aaekd;
+aaeke;
+aaekf;
+aaekg;
+aaekh;
+aaeki;
+aaekj;
+aaekk;
+aaekl;
+aaekm;
+aaekn;
+aaeko;
+aaekp;
+aaekq;
+aaekr;
+aaeks;
+aaekt;
+aaeku;
+aaekv;
+aaekw;
+aaekx;
+aaeky;
+aaekz;
+aaela;
+aaelb;
+aaelc;
+aaeld;
+aaele;
+aaelf;
+aaelg;
+aaelh;
+aaeli;
+aaelj;
+aaelk;
+aaell;
+aaelm;
+aaeln;
+aaelo;
+aaelp;
+aaelq;
+aaelr;
+aaels;
+aaelt;
+aaelu;
+aaelv;
+aaelw;
+aaelx;
+aaely;
+aaelz;
+aaema;
+aaemb;
+aaemc;
+aaemd;
+aaeme;
+aaemf;
+aaemg;
+aaemh;
+aaemi;
+aaemj;
+aaemk;
+aaeml;
+aaemm;
+aaemn;
+aaemo;
+aaemp;
+aaemq;
+aaemr;
+aaems;
+aaemt;
+aaemu;
+aaemv;
+aaemw;
+aaemx;
+aaemy;
+aaemz;
+aaena;
+aaenb;
+aaenc;
+aaend;
+aaene;
+aaenf;
+aaeng;
+aaenh;
+aaeni;
+aaenj;
+aaenk;
+aaenl;
+aaenm;
+aaenn;
+aaeno;
+aaenp;
+aaenq;
+aaenr;
+aaens;
+aaent;
+aaenu;
+aaenv;
+aaenw;
+aaenx;
+aaeny;
+aaenz;
+aaeoa;
+aaeob;
+aaeoc;
+aaeod;
+aaeoe;
+aaeof;
+aaeog;
+aaeoh;
+aaeoi;
+aaeoj;
+aaeok;
+aaeol;
+aaeom;
+aaeon;
+aaeoo;
+aaeop;
+aaeoq;
+aaeor;
+aaeos;
+aaeot;
+aaeou;
+aaeov;
+aaeow;
+aaeox;
+aaeoy;
+aaeoz;
+aaepa;
+aaepb;
+aaepc;
+aaepd;
+aaepe;
+aaepf;
+aaepg;
+aaeph;
+aaepi;
+aaepj;
+aaepk;
+aaepl;
+aaepm;
+aaepn;
+aaepo;
+aaepp;
+aaepq;
+aaepr;
+aaeps;
+aaept;
+aaepu;
+aaepv;
+aaepw;
+aaepx;
+aaepy;
+aaepz;
+aaeqa;
+aaeqb;
+aaeqc;
+aaeqd;
+aaeqe;
+aaeqf;
+aaeqg;
+aaeqh;
+aaeqi;
+aaeqj;
+aaeqk;
+aaeql;
+aaeqm;
+aaeqn;
+aaeqo;
+aaeqp;
+aaeqq;
+aaeqr;
+aaeqs;
+aaeqt;
+aaequ;
+aaeqv;
+aaeqw;
+aaeqx;
+aaeqy;
+aaeqz;
+aaera;
+aaerb;
+aaerc;
+aaerd;
+aaere;
+aaerf;
+aaerg;
+aaerh;
+aaeri;
+aaerj;
+aaerk;
+aaerl;
+aaerm;
+aaern;
+aaero;
+aaerp;
+aaerq;
+aaerr;
+aaers;
+aaert;
+aaeru;
+aaerv;
+aaerw;
+aaerx;
+aaery;
+aaerz;
+aaesa;
+aaesb;
+aaesc;
+aaesd;
+aaese;
+aaesf;
+aaesg;
+aaesh;
+aaesi;
+aaesj;
+aaesk;
+aaesl;
+aaesm;
+aaesn;
+aaeso;
+aaesp;
+aaesq;
+aaesr;
+aaess;
+aaest;
+aaesu;
+aaesv;
+aaesw;
+aaesx;
+aaesy;
+aaesz;
+aaeta;
+aaetb;
+aaetc;
+aaetd;
+aaete;
+aaetf;
+aaetg;
+aaeth;
+aaeti;
+aaetj;
+aaetk;
+aaetl;
+aaetm;
+aaetn;
+aaeto;
+aaetp;
+aaetq;
+aaetr;
+aaets;
+aaett;
+aaetu;
+aaetv;
+aaetw;
+aaetx;
+aaety;
+aaetz;
+aaeua;
+aaeub;
+aaeuc;
+aaeud;
+aaeue;
+aaeuf;
+aaeug;
+aaeuh;
+aaeui;
+aaeuj;
+aaeuk;
+aaeul;
+aaeum;
+aaeun;
+aaeuo;
+aaeup;
+aaeuq;
+aaeur;
+aaeus;
+aaeut;
+aaeuu;
+aaeuv;
+aaeuw;
+aaeux;
+aaeuy;
+aaeuz;
+aaeva;
+aaevb;
+aaevc;
+aaevd;
+aaeve;
+aaevf;
+aaevg;
+aaevh;
+aaevi;
+aaevj;
+aaevk;
+aaevl;
+aaevm;
+aaevn;
+aaevo;
+aaevp;
+aaevq;
+aaevr;
+aaevs;
+aaevt;
+aaevu;
+aaevv;
+aaevw;
+aaevx;
+aaevy;
+aaevz;
+aaewa;
+aaewb;
+aaewc;
+aaewd;
+aaewe;
+aaewf;
+aaewg;
+aaewh;
+aaewi;
+aaewj;
+aaewk;
+aaewl;
+aaewm;
+aaewn;
+aaewo;
+aaewp;
+aaewq;
+aaewr;
+aaews;
+aaewt;
+aaewu;
+aaewv;
+aaeww;
+aaewx;
+aaewy;
+aaewz;
+aaexa;
+aaexb;
+aaexc;
+aaexd;
+aaexe;
+aaexf;
+aaexg;
+aaexh;
+aaexi;
+aaexj;
+aaexk;
+aaexl;
+aaexm;
+aaexn;
+aaexo;
+aaexp;
+aaexq;
+aaexr;
+aaexs;
+aaext;
+aaexu;
+aaexv;
+aaexw;
+aaexx;
+aaexy;
+aaexz;
+aaeya;
+aaeyb;
+aaeyc;
+aaeyd;
+aaeye;
+aaeyf;
+aaeyg;
+aaeyh;
+aaeyi;
+aaeyj;
+aaeyk;
+aaeyl;
+aaeym;
+aaeyn;
+aaeyo;
+aaeyp;
+aaeyq;
+aaeyr;
+aaeys;
+aaeyt;
+aaeyu;
+aaeyv;
+aaeyw;
+aaeyx;
+aaeyy;
+aaeyz;
+aaeza;
+aaezb;
+aaezc;
+aaezd;
+aaeze;
+aaezf;
+aaezg;
+aaezh;
+aaezi;
+aaezj;
+aaezk;
+aaezl;
+aaezm;
+aaezn;
+aaezo;
+aaezp;
+aaezq;
+aaezr;
+aaezs;
+aaezt;
+aaezu;
+aaezv;
+aaezw;
+aaezx;
+aaezy;
+aaezz;
+aafaa;
+aafab;
+aafac;
+aafad;
+aafae;
+aafaf;
+aafag;
+aafah;
+aafai;
+aafaj;
+aafak;
+aafal;
+aafam;
+aafan;
+aafao;
+aafap;
+aafaq;
+aafar;
+aafas;
+aafat;
+aafau;
+aafav;
+aafaw;
+aafax;
+aafay;
+aafaz;
+aafba;
+aafbb;
+aafbc;
+aafbd;
+aafbe;
+aafbf;
+aafbg;
+aafbh;
+aafbi;
+aafbj;
+aafbk;
+aafbl;
+aafbm;
+aafbn;
+aafbo;
+aafbp;
+aafbq;
+aafbr;
+aafbs;
+aafbt;
+aafbu;
+aafbv;
+aafbw;
+aafbx;
+aafby;
+aafbz;
+aafca;
+aafcb;
+aafcc;
+aafcd;
+aafce;
+aafcf;
+aafcg;
+aafch;
+aafci;
+aafcj;
+aafck;
+aafcl;
+aafcm;
+aafcn;
+aafco;
+aafcp;
+aafcq;
+aafcr;
+aafcs;
+aafct;
+aafcu;
+aafcv;
+aafcw;
+aafcx;
+aafcy;
+aafcz;
+aafda;
+aafdb;
+aafdc;
+aafdd;
+aafde;
+aafdf;
+aafdg;
+aafdh;
+aafdi;
+aafdj;
+aafdk;
+aafdl;
+aafdm;
+aafdn;
+aafdo;
+aafdp;
+aafdq;
+aafdr;
+aafds;
+aafdt;
+aafdu;
+aafdv;
+aafdw;
+aafdx;
+aafdy;
+aafdz;
+aafea;
+aafeb;
+aafec;
+aafed;
+aafee;
+aafef;
+aafeg;
+aafeh;
+aafei;
+aafej;
+aafek;
+aafel;
+aafem;
+aafen;
+aafeo;
+aafep;
+aafeq;
+aafer;
+aafes;
+aafet;
+aafeu;
+aafev;
+aafew;
+aafex;
+aafey;
+aafez;
+aaffa;
+aaffb;
+aaffc;
+aaffd;
+aaffe;
+aafff;
+aaffg;
+aaffh;
+aaffi;
+aaffj;
+aaffk;
+aaffl;
+aaffm;
+aaffn;
+aaffo;
+aaffp;
+aaffq;
+aaffr;
+aaffs;
+aafft;
+aaffu;
+aaffv;
+aaffw;
+aaffx;
+aaffy;
+aaffz;
+aafga;
+aafgb;
+aafgc;
+aafgd;
+aafge;
+aafgf;
+aafgg;
+aafgh;
+aafgi;
+aafgj;
+aafgk;
+aafgl;
+aafgm;
+aafgn;
+aafgo;
+aafgp;
+aafgq;
+aafgr;
+aafgs;
+aafgt;
+aafgu;
+aafgv;
+aafgw;
+aafgx;
+aafgy;
+aafgz;
+aafha;
+aafhb;
+aafhc;
+aafhd;
+aafhe;
+aafhf;
+aafhg;
+aafhh;
+aafhi;
+aafhj;
+aafhk;
+aafhl;
+aafhm;
+aafhn;
+aafho;
+aafhp;
+aafhq;
+aafhr;
+aafhs;
+aafht;
+aafhu;
+aafhv;
+aafhw;
+aafhx;
+aafhy;
+aafhz;
+aafia;
+aafib;
+aafic;
+aafid;
+aafie;
+aafif;
+aafig;
+aafih;
+aafii;
+aafij;
+aafik;
+aafil;
+aafim;
+aafin;
+aafio;
+aafip;
+aafiq;
+aafir;
+aafis;
+aafit;
+aafiu;
+aafiv;
+aafiw;
+aafix;
+aafiy;
+aafiz;
+aafja;
+aafjb;
+aafjc;
+aafjd;
+aafje;
+aafjf;
+aafjg;
+aafjh;
+aafji;
+aafjj;
+aafjk;
+aafjl;
+aafjm;
+aafjn;
+aafjo;
+aafjp;
+aafjq;
+aafjr;
+aafjs;
+aafjt;
+aafju;
+aafjv;
+aafjw;
+aafjx;
+aafjy;
+aafjz;
+aafka;
+aafkb;
+aafkc;
+aafkd;
+aafke;
+aafkf;
+aafkg;
+aafkh;
+aafki;
+aafkj;
+aafkk;
+aafkl;
+aafkm;
+aafkn;
+aafko;
+aafkp;
+aafkq;
+aafkr;
+aafks;
+aafkt;
+aafku;
+aafkv;
+aafkw;
+aafkx;
+aafky;
+aafkz;
+aafla;
+aaflb;
+aaflc;
+aafld;
+aafle;
+aaflf;
+aaflg;
+aaflh;
+aafli;
+aaflj;
+aaflk;
+aafll;
+aaflm;
+aafln;
+aaflo;
+aaflp;
+aaflq;
+aaflr;
+aafls;
+aaflt;
+aaflu;
+aaflv;
+aaflw;
+aaflx;
+aafly;
+aaflz;
+aafma;
+aafmb;
+aafmc;
+aafmd;
+aafme;
+aafmf;
+aafmg;
+aafmh;
+aafmi;
+aafmj;
+aafmk;
+aafml;
+aafmm;
+aafmn;
+aafmo;
+aafmp;
+aafmq;
+aafmr;
+aafms;
+aafmt;
+aafmu;
+aafmv;
+aafmw;
+aafmx;
+aafmy;
+aafmz;
+aafna;
+aafnb;
+aafnc;
+aafnd;
+aafne;
+aafnf;
+aafng;
+aafnh;
+aafni;
+aafnj;
+aafnk;
+aafnl;
+aafnm;
+aafnn;
+aafno;
+aafnp;
+aafnq;
+aafnr;
+aafns;
+aafnt;
+aafnu;
+aafnv;
+aafnw;
+aafnx;
+aafny;
+aafnz;
+aafoa;
+aafob;
+aafoc;
+aafod;
+aafoe;
+aafof;
+aafog;
+aafoh;
+aafoi;
+aafoj;
+aafok;
+aafol;
+aafom;
+aafon;
+aafoo;
+aafop;
+aafoq;
+aafor;
+aafos;
+aafot;
+aafou;
+aafov;
+aafow;
+aafox;
+aafoy;
+aafoz;
+aafpa;
+aafpb;
+aafpc;
+aafpd;
+aafpe;
+aafpf;
+aafpg;
+aafph;
+aafpi;
+aafpj;
+aafpk;
+aafpl;
+aafpm;
+aafpn;
+aafpo;
+aafpp;
+aafpq;
+aafpr;
+aafps;
+aafpt;
+aafpu;
+aafpv;
+aafpw;
+aafpx;
+aafpy;
+aafpz;
+aafqa;
+aafqb;
+aafqc;
+aafqd;
+aafqe;
+aafqf;
+aafqg;
+aafqh;
+aafqi;
+aafqj;
+aafqk;
+aafql;
+aafqm;
+aafqn;
+aafqo;
+aafqp;
+aafqq;
+aafqr;
+aafqs;
+aafqt;
+aafqu;
+aafqv;
+aafqw;
+aafqx;
+aafqy;
+aafqz;
+aafra;
+aafrb;
+aafrc;
+aafrd;
+aafre;
+aafrf;
+aafrg;
+aafrh;
+aafri;
+aafrj;
+aafrk;
+aafrl;
+aafrm;
+aafrn;
+aafro;
+aafrp;
+aafrq;
+aafrr;
+aafrs;
+aafrt;
+aafru;
+aafrv;
+aafrw;
+aafrx;
+aafry;
+aafrz;
+aafsa;
+aafsb;
+aafsc;
+aafsd;
+aafse;
+aafsf;
+aafsg;
+aafsh;
+aafsi;
+aafsj;
+aafsk;
+aafsl;
+aafsm;
+aafsn;
+aafso;
+aafsp;
+aafsq;
+aafsr;
+aafss;
+aafst;
+aafsu;
+aafsv;
+aafsw;
+aafsx;
+aafsy;
+aafsz;
+aafta;
+aaftb;
+aaftc;
+aaftd;
+aafte;
+aaftf;
+aaftg;
+aafth;
+aafti;
+aaftj;
+aaftk;
+aaftl;
+aaftm;
+aaftn;
+aafto;
+aaftp;
+aaftq;
+aaftr;
+aafts;
+aaftt;
+aaftu;
+aaftv;
+aaftw;
+aaftx;
+aafty;
+aaftz;
+aafua;
+aafub;
+aafuc;
+aafud;
+aafue;
+aafuf;
+aafug;
+aafuh;
+aafui;
+aafuj;
+aafuk;
+aaful;
+aafum;
+aafun;
+aafuo;
+aafup;
+aafuq;
+aafur;
+aafus;
+aafut;
+aafuu;
+aafuv;
+aafuw;
+aafux;
+aafuy;
+aafuz;
+aafva;
+aafvb;
+aafvc;
+aafvd;
+aafve;
+aafvf;
+aafvg;
+aafvh;
+aafvi;
+aafvj;
+aafvk;
+aafvl;
+aafvm;
+aafvn;
+aafvo;
+aafvp;
+aafvq;
+aafvr;
+aafvs;
+aafvt;
+aafvu;
+aafvv;
+aafvw;
+aafvx;
+aafvy;
+aafvz;
+aafwa;
+aafwb;
+aafwc;
+aafwd;
+aafwe;
+aafwf;
+aafwg;
+aafwh;
+aafwi;
+aafwj;
+aafwk;
+aafwl;
+aafwm;
+aafwn;
+aafwo;
+aafwp;
+aafwq;
+aafwr;
+aafws;
+aafwt;
+aafwu;
+aafwv;
+aafww;
+aafwx;
+aafwy;
+aafwz;
+aafxa;
+aafxb;
+aafxc;
+aafxd;
+aafxe;
+aafxf;
+aafxg;
+aafxh;
+aafxi;
+aafxj;
+aafxk;
+aafxl;
+aafxm;
+aafxn;
+aafxo;
+aafxp;
+aafxq;
+aafxr;
+aafxs;
+aafxt;
+aafxu;
+aafxv;
+aafxw;
+aafxx;
+aafxy;
+aafxz;
+aafya;
+aafyb;
+aafyc;
+aafyd;
+aafye;
+aafyf;
+aafyg;
+aafyh;
+aafyi;
+aafyj;
+aafyk;
+aafyl;
+aafym;
+aafyn;
+aafyo;
+aafyp;
+aafyq;
+aafyr;
+aafys;
+aafyt;
+aafyu;
+aafyv;
+aafyw;
+aafyx;
+aafyy;
+aafyz;
+aafza;
+aafzb;
+aafzc;
+aafzd;
+aafze;
+aafzf;
+aafzg;
+aafzh;
+aafzi;
+aafzj;
+aafzk;
+aafzl;
+aafzm;
+aafzn;
+aafzo;
+aafzp;
+aafzq;
+aafzr;
+aafzs;
+aafzt;
+aafzu;
+aafzv;
+aafzw;
+aafzx;
+aafzy;
+aafzz;
+aagaa;
+aagab;
+aagac;
+aagad;
+aagae;
+aagaf;
+aagag;
+aagah;
+aagai;
+aagaj;
+aagak;
+aagal;
+aagam;
+aagan;
+aagao;
+aagap;
+aagaq;
+aagar;
+aagas;
+aagat;
+aagau;
+aagav;
+aagaw;
+aagax;
+aagay;
+aagaz;
+aagba;
+aagbb;
+aagbc;
+aagbd;
+aagbe;
+aagbf;
+aagbg;
+aagbh;
+aagbi;
+aagbj;
+aagbk;
+aagbl;
+aagbm;
+aagbn;
+aagbo;
+aagbp;
+aagbq;
+aagbr;
+aagbs;
+aagbt;
+aagbu;
+aagbv;
+aagbw;
+aagbx;
+aagby;
+aagbz;
+aagca;
+aagcb;
+aagcc;
+aagcd;
+aagce;
+aagcf;
+aagcg;
+aagch;
+aagci;
+aagcj;
+aagck;
+aagcl;
+aagcm;
+aagcn;
+aagco;
+aagcp;
+aagcq;
+aagcr;
+aagcs;
+aagct;
+aagcu;
+aagcv;
+aagcw;
+aagcx;
+aagcy;
+aagcz;
+aagda;
+aagdb;
+aagdc;
+aagdd;
+aagde;
+aagdf;
+aagdg;
+aagdh;
+aagdi;
+aagdj;
+aagdk;
+aagdl;
+aagdm;
+aagdn;
+aagdo;
+aagdp;
+aagdq;
+aagdr;
+aagds;
+aagdt;
+aagdu;
+aagdv;
+aagdw;
+aagdx;
+aagdy;
+aagdz;
+aagea;
+aageb;
+aagec;
+aaged;
+aagee;
+aagef;
+aageg;
+aageh;
+aagei;
+aagej;
+aagek;
+aagel;
+aagem;
+aagen;
+aageo;
+aagep;
+aageq;
+aager;
+aages;
+aaget;
+aageu;
+aagev;
+aagew;
+aagex;
+aagey;
+aagez;
+aagfa;
+aagfb;
+aagfc;
+aagfd;
+aagfe;
+aagff;
+aagfg;
+aagfh;
+aagfi;
+aagfj;
+aagfk;
+aagfl;
+aagfm;
+aagfn;
+aagfo;
+aagfp;
+aagfq;
+aagfr;
+aagfs;
+aagft;
+aagfu;
+aagfv;
+aagfw;
+aagfx;
+aagfy;
+aagfz;
+aagga;
+aaggb;
+aaggc;
+aaggd;
+aagge;
+aaggf;
+aaggg;
+aaggh;
+aaggi;
+aaggj;
+aaggk;
+aaggl;
+aaggm;
+aaggn;
+aaggo;
+aaggp;
+aaggq;
+aaggr;
+aaggs;
+aaggt;
+aaggu;
+aaggv;
+aaggw;
+aaggx;
+aaggy;
+aaggz;
+aagha;
+aaghb;
+aaghc;
+aaghd;
+aaghe;
+aaghf;
+aaghg;
+aaghh;
+aaghi;
+aaghj;
+aaghk;
+aaghl;
+aaghm;
+aaghn;
+aagho;
+aaghp;
+aaghq;
+aaghr;
+aaghs;
+aaght;
+aaghu;
+aaghv;
+aaghw;
+aaghx;
+aaghy;
+aaghz;
+aagia;
+aagib;
+aagic;
+aagid;
+aagie;
+aagif;
+aagig;
+aagih;
+aagii;
+aagij;
+aagik;
+aagil;
+aagim;
+aagin;
+aagio;
+aagip;
+aagiq;
+aagir;
+aagis;
+aagit;
+aagiu;
+aagiv;
+aagiw;
+aagix;
+aagiy;
+aagiz;
+aagja;
+aagjb;
+aagjc;
+aagjd;
+aagje;
+aagjf;
+aagjg;
+aagjh;
+aagji;
+aagjj;
+aagjk;
+aagjl;
+aagjm;
+aagjn;
+aagjo;
+aagjp;
+aagjq;
+aagjr;
+aagjs;
+aagjt;
+aagju;
+aagjv;
+aagjw;
+aagjx;
+aagjy;
+aagjz;
+aagka;
+aagkb;
+aagkc;
+aagkd;
+aagke;
+aagkf;
+aagkg;
+aagkh;
+aagki;
+aagkj;
+aagkk;
+aagkl;
+aagkm;
+aagkn;
+aagko;
+aagkp;
+aagkq;
+aagkr;
+aagks;
+aagkt;
+aagku;
+aagkv;
+aagkw;
+aagkx;
+aagky;
+aagkz;
+aagla;
+aaglb;
+aaglc;
+aagld;
+aagle;
+aaglf;
+aaglg;
+aaglh;
+aagli;
+aaglj;
+aaglk;
+aagll;
+aaglm;
+aagln;
+aaglo;
+aaglp;
+aaglq;
+aaglr;
+aagls;
+aaglt;
+aaglu;
+aaglv;
+aaglw;
+aaglx;
+aagly;
+aaglz;
+aagma;
+aagmb;
+aagmc;
+aagmd;
+aagme;
+aagmf;
+aagmg;
+aagmh;
+aagmi;
+aagmj;
+aagmk;
+aagml;
+aagmm;
+aagmn;
+aagmo;
+aagmp;
+aagmq;
+aagmr;
+aagms;
+aagmt;
+aagmu;
+aagmv;
+aagmw;
+aagmx;
+aagmy;
+aagmz;
+aagna;
+aagnb;
+aagnc;
+aagnd;
+aagne;
+aagnf;
+aagng;
+aagnh;
+aagni;
+aagnj;
+aagnk;
+aagnl;
+aagnm;
+aagnn;
+aagno;
+aagnp;
+aagnq;
+aagnr;
+aagns;
+aagnt;
+aagnu;
+aagnv;
+aagnw;
+aagnx;
+aagny;
+aagnz;
+aagoa;
+aagob;
+aagoc;
+aagod;
+aagoe;
+aagof;
+aagog;
+aagoh;
+aagoi;
+aagoj;
+aagok;
+aagol;
+aagom;
+aagon;
+aagoo;
+aagop;
+aagoq;
+aagor;
+aagos;
+aagot;
+aagou;
+aagov;
+aagow;
+aagox;
+aagoy;
+aagoz;
+aagpa;
+aagpb;
+aagpc;
+aagpd;
+aagpe;
+aagpf;
+aagpg;
+aagph;
+aagpi;
+aagpj;
+aagpk;
+aagpl;
+aagpm;
+aagpn;
+aagpo;
+aagpp;
+aagpq;
+aagpr;
+aagps;
+aagpt;
+aagpu;
+aagpv;
+aagpw;
+aagpx;
+aagpy;
+aagpz;
+aagqa;
+aagqb;
+aagqc;
+aagqd;
+aagqe;
+aagqf;
+aagqg;
+aagqh;
+aagqi;
+aagqj;
+aagqk;
+aagql;
+aagqm;
+aagqn;
+aagqo;
+aagqp;
+aagqq;
+aagqr;
+aagqs;
+aagqt;
+aagqu;
+aagqv;
+aagqw;
+aagqx;
+aagqy;
+aagqz;
+aagra;
+aagrb;
+aagrc;
+aagrd;
+aagre;
+aagrf;
+aagrg;
+aagrh;
+aagri;
+aagrj;
+aagrk;
+aagrl;
+aagrm;
+aagrn;
+aagro;
+aagrp;
+aagrq;
+aagrr;
+aagrs;
+aagrt;
+aagru;
+aagrv;
+aagrw;
+aagrx;
+aagry;
+aagrz;
+aagsa;
+aagsb;
+aagsc;
+aagsd;
+aagse;
+aagsf;
+aagsg;
+aagsh;
+aagsi;
+aagsj;
+aagsk;
+aagsl;
+aagsm;
+aagsn;
+aagso;
+aagsp;
+aagsq;
+aagsr;
+aagss;
+aagst;
+aagsu;
+aagsv;
+aagsw;
+aagsx;
+aagsy;
+aagsz;
+aagta;
+aagtb;
+aagtc;
+aagtd;
+aagte;
+aagtf;
+aagtg;
+aagth;
+aagti;
+aagtj;
+aagtk;
+aagtl;
+aagtm;
+aagtn;
+aagto;
+aagtp;
+aagtq;
+aagtr;
+aagts;
+aagtt;
+aagtu;
+aagtv;
+aagtw;
+aagtx;
+aagty;
+aagtz;
+aagua;
+aagub;
+aaguc;
+aagud;
+aague;
+aaguf;
+aagug;
+aaguh;
+aagui;
+aaguj;
+aaguk;
+aagul;
+aagum;
+aagun;
+aaguo;
+aagup;
+aaguq;
+aagur;
+aagus;
+aagut;
+aaguu;
+aaguv;
+aaguw;
+aagux;
+aaguy;
+aaguz;
+aagva;
+aagvb;
+aagvc;
+aagvd;
+aagve;
+aagvf;
+aagvg;
+aagvh;
+aagvi;
+aagvj;
+aagvk;
+aagvl;
+aagvm;
+aagvn;
+aagvo;
+aagvp;
+aagvq;
+aagvr;
+aagvs;
+aagvt;
+aagvu;
+aagvv;
+aagvw;
+aagvx;
+aagvy;
+aagvz;
+aagwa;
+aagwb;
+aagwc;
+aagwd;
+aagwe;
+aagwf;
+aagwg;
+aagwh;
+aagwi;
+aagwj;
+aagwk;
+aagwl;
+aagwm;
+aagwn;
+aagwo;
+aagwp;
+aagwq;
+aagwr;
+aagws;
+aagwt;
+aagwu;
+aagwv;
+aagww;
+aagwx;
+aagwy;
+aagwz;
+aagxa;
+aagxb;
+aagxc;
+aagxd;
+aagxe;
+aagxf;
+aagxg;
+aagxh;
+aagxi;
+aagxj;
+aagxk;
+aagxl;
+aagxm;
+aagxn;
+aagxo;
+aagxp;
+aagxq;
+aagxr;
+aagxs;
+aagxt;
+aagxu;
+aagxv;
+aagxw;
+aagxx;
+aagxy;
+aagxz;
+aagya;
+aagyb;
+aagyc;
+aagyd;
+aagye;
+aagyf;
+aagyg;
+aagyh;
+aagyi;
+aagyj;
+aagyk;
+aagyl;
+aagym;
+aagyn;
+aagyo;
+aagyp;
+aagyq;
+aagyr;
+aagys;
+aagyt;
+aagyu;
+aagyv;
+aagyw;
+aagyx;
+aagyy;
+aagyz;
+aagza;
+aagzb;
+aagzc;
+aagzd;
+aagze;
+aagzf;
+aagzg;
+aagzh;
+aagzi;
+aagzj;
+aagzk;
+aagzl;
+aagzm;
+aagzn;
+aagzo;
+aagzp;
+aagzq;
+aagzr;
+aagzs;
+aagzt;
+aagzu;
+aagzv;
+aagzw;
+aagzx;
+aagzy;
+aagzz;
+aahaa;
+aahab;
+aahac;
+aahad;
+aahae;
+aahaf;
+aahag;
+aahah;
+aahai;
+aahaj;
+aahak;
+aahal;
+aaham;
+aahan;
+aahao;
+aahap;
+aahaq;
+aahar;
+aahas;
+aahat;
+aahau;
+aahav;
+aahaw;
+aahax;
+aahay;
+aahaz;
+aahba;
+aahbb;
+aahbc;
+aahbd;
+aahbe;
+aahbf;
+aahbg;
+aahbh;
+aahbi;
+aahbj;
+aahbk;
+aahbl;
+aahbm;
+aahbn;
+aahbo;
+aahbp;
+aahbq;
+aahbr;
+aahbs;
+aahbt;
+aahbu;
+aahbv;
+aahbw;
+aahbx;
+aahby;
+aahbz;
+aahca;
+aahcb;
+aahcc;
+aahcd;
+aahce;
+aahcf;
+aahcg;
+aahch;
+aahci;
+aahcj;
+aahck;
+aahcl;
+aahcm;
+aahcn;
+aahco;
+aahcp;
+aahcq;
+aahcr;
+aahcs;
+aahct;
+aahcu;
+aahcv;
+aahcw;
+aahcx;
+aahcy;
+aahcz;
+aahda;
+aahdb;
+aahdc;
+aahdd;
+aahde;
+aahdf;
+aahdg;
+aahdh;
+aahdi;
+aahdj;
+aahdk;
+aahdl;
+aahdm;
+aahdn;
+aahdo;
+aahdp;
+aahdq;
+aahdr;
+aahds;
+aahdt;
+aahdu;
+aahdv;
+aahdw;
+aahdx;
+aahdy;
+aahdz;
+aahea;
+aaheb;
+aahec;
+aahed;
+aahee;
+aahef;
+aaheg;
+aaheh;
+aahei;
+aahej;
+aahek;
+aahel;
+aahem;
+aahen;
+aaheo;
+aahep;
+aaheq;
+aaher;
+aahes;
+aahet;
+aaheu;
+aahev;
+aahew;
+aahex;
+aahey;
+aahez;
+aahfa;
+aahfb;
+aahfc;
+aahfd;
+aahfe;
+aahff;
+aahfg;
+aahfh;
+aahfi;
+aahfj;
+aahfk;
+aahfl;
+aahfm;
+aahfn;
+aahfo;
+aahfp;
+aahfq;
+aahfr;
+aahfs;
+aahft;
+aahfu;
+aahfv;
+aahfw;
+aahfx;
+aahfy;
+aahfz;
+aahga;
+aahgb;
+aahgc;
+aahgd;
+aahge;
+aahgf;
+aahgg;
+aahgh;
+aahgi;
+aahgj;
+aahgk;
+aahgl;
+aahgm;
+aahgn;
+aahgo;
+aahgp;
+aahgq;
+aahgr;
+aahgs;
+aahgt;
+aahgu;
+aahgv;
+aahgw;
+aahgx;
+aahgy;
+aahgz;
+aahha;
+aahhb;
+aahhc;
+aahhd;
+aahhe;
+aahhf;
+aahhg;
+aahhh;
+aahhi;
+aahhj;
+aahhk;
+aahhl;
+aahhm;
+aahhn;
+aahho;
+aahhp;
+aahhq;
+aahhr;
+aahhs;
+aahht;
+aahhu;
+aahhv;
+aahhw;
+aahhx;
+aahhy;
+aahhz;
+aahia;
+aahib;
+aahic;
+aahid;
+aahie;
+aahif;
+aahig;
+aahih;
+aahii;
+aahij;
+aahik;
+aahil;
+aahim;
+aahin;
+aahio;
+aahip;
+aahiq;
+aahir;
+aahis;
+aahit;
+aahiu;
+aahiv;
+aahiw;
+aahix;
+aahiy;
+aahiz;
+aahja;
+aahjb;
+aahjc;
+aahjd;
+aahje;
+aahjf;
+aahjg;
+aahjh;
+aahji;
+aahjj;
+aahjk;
+aahjl;
+aahjm;
+aahjn;
+aahjo;
+aahjp;
+aahjq;
+aahjr;
+aahjs;
+aahjt;
+aahju;
+aahjv;
+aahjw;
+aahjx;
+aahjy;
+aahjz;
+aahka;
+aahkb;
+aahkc;
+aahkd;
+aahke;
+aahkf;
+aahkg;
+aahkh;
+aahki;
+aahkj;
+aahkk;
+aahkl;
+aahkm;
+aahkn;
+aahko;
+aahkp;
+aahkq;
+aahkr;
+aahks;
+aahkt;
+aahku;
+aahkv;
+aahkw;
+aahkx;
+aahky;
+aahkz;
+aahla;
+aahlb;
+aahlc;
+aahld;
+aahle;
+aahlf;
+aahlg;
+aahlh;
+aahli;
+aahlj;
+aahlk;
+aahll;
+aahlm;
+aahln;
+aahlo;
+aahlp;
+aahlq;
+aahlr;
+aahls;
+aahlt;
+aahlu;
+aahlv;
+aahlw;
+aahlx;
+aahly;
+aahlz;
+aahma;
+aahmb;
+aahmc;
+aahmd;
+aahme;
+aahmf;
+aahmg;
+aahmh;
+aahmi;
+aahmj;
+aahmk;
+aahml;
+aahmm;
+aahmn;
+aahmo;
+aahmp;
+aahmq;
+aahmr;
+aahms;
+aahmt;
+aahmu;
+aahmv;
+aahmw;
+aahmx;
+aahmy;
+aahmz;
+aahna;
+aahnb;
+aahnc;
+aahnd;
+aahne;
+aahnf;
+aahng;
+aahnh;
+aahni;
+aahnj;
+aahnk;
+aahnl;
+aahnm;
+aahnn;
+aahno;
+aahnp;
+aahnq;
+aahnr;
+aahns;
+aahnt;
+aahnu;
+aahnv;
+aahnw;
+aahnx;
+aahny;
+aahnz;
+aahoa;
+aahob;
+aahoc;
+aahod;
+aahoe;
+aahof;
+aahog;
+aahoh;
+aahoi;
+aahoj;
+aahok;
+aahol;
+aahom;
+aahon;
+aahoo;
+aahop;
+aahoq;
+aahor;
+aahos;
+aahot;
+aahou;
+aahov;
+aahow;
+aahox;
+aahoy;
+aahoz;
+aahpa;
+aahpb;
+aahpc;
+aahpd;
+aahpe;
+aahpf;
+aahpg;
+aahph;
+aahpi;
+aahpj;
+aahpk;
+aahpl;
+aahpm;
+aahpn;
+aahpo;
+aahpp;
+aahpq;
+aahpr;
+aahps;
+aahpt;
+aahpu;
+aahpv;
+aahpw;
+aahpx;
+aahpy;
+aahpz;
+aahqa;
+aahqb;
+aahqc;
+aahqd;
+aahqe;
+aahqf;
+aahqg;
+aahqh;
+aahqi;
+aahqj;
+aahqk;
+aahql;
+aahqm;
+aahqn;
+aahqo;
+aahqp;
+aahqq;
+aahqr;
+aahqs;
+aahqt;
+aahqu;
+aahqv;
+aahqw;
+aahqx;
+aahqy;
+aahqz;
+aahra;
+aahrb;
+aahrc;
+aahrd;
+aahre;
+aahrf;
+aahrg;
+aahrh;
+aahri;
+aahrj;
+aahrk;
+aahrl;
+aahrm;
+aahrn;
+aahro;
+aahrp;
+aahrq;
+aahrr;
+aahrs;
+aahrt;
+aahru;
+aahrv;
+aahrw;
+aahrx;
+aahry;
+aahrz;
+aahsa;
+aahsb;
+aahsc;
+aahsd;
+aahse;
+aahsf;
+aahsg;
+aahsh;
+aahsi;
+aahsj;
+aahsk;
+aahsl;
+aahsm;
+aahsn;
+aahso;
+aahsp;
+aahsq;
+aahsr;
+aahss;
+aahst;
+aahsu;
+aahsv;
+aahsw;
+aahsx;
+aahsy;
+aahsz;
+aahta;
+aahtb;
+aahtc;
+aahtd;
+aahte;
+aahtf;
+aahtg;
+aahth;
+aahti;
+aahtj;
+aahtk;
+aahtl;
+aahtm;
+aahtn;
+aahto;
+aahtp;
+aahtq;
+aahtr;
+aahts;
+aahtt;
+aahtu;
+aahtv;
+aahtw;
+aahtx;
+aahty;
+aahtz;
+aahua;
+aahub;
+aahuc;
+aahud;
+aahue;
+aahuf;
+aahug;
+aahuh;
+aahui;
+aahuj;
+aahuk;
+aahul;
+aahum;
+aahun;
+aahuo;
+aahup;
+aahuq;
+aahur;
+aahus;
+aahut;
+aahuu;
+aahuv;
+aahuw;
+aahux;
+aahuy;
+aahuz;
+aahva;
+aahvb;
+aahvc;
+aahvd;
+aahve;
+aahvf;
+aahvg;
+aahvh;
+aahvi;
+aahvj;
+aahvk;
+aahvl;
+aahvm;
+aahvn;
+aahvo;
+aahvp;
+aahvq;
+aahvr;
+aahvs;
+aahvt;
+aahvu;
+aahvv;
+aahvw;
+aahvx;
+aahvy;
+aahvz;
+aahwa;
+aahwb;
+aahwc;
+aahwd;
+aahwe;
+aahwf;
+aahwg;
+aahwh;
+aahwi;
+aahwj;
+aahwk;
+aahwl;
+aahwm;
+aahwn;
+aahwo;
+aahwp;
+aahwq;
+aahwr;
+aahws;
+aahwt;
+aahwu;
+aahwv;
+aahww;
+aahwx;
+aahwy;
+aahwz;
+aahxa;
+aahxb;
+aahxc;
+aahxd;
+aahxe;
+aahxf;
+aahxg;
+aahxh;
+aahxi;
+aahxj;
+aahxk;
+aahxl;
+aahxm;
+aahxn;
+aahxo;
+aahxp;
+aahxq;
+aahxr;
+aahxs;
+aahxt;
+aahxu;
+aahxv;
+aahxw;
+aahxx;
+aahxy;
+aahxz;
+aahya;
+aahyb;
+aahyc;
+aahyd;
+aahye;
+aahyf;
+aahyg;
+aahyh;
+aahyi;
+aahyj;
+aahyk;
+aahyl;
+aahym;
+aahyn;
+aahyo;
+aahyp;
+aahyq;
+aahyr;
+aahys;
+aahyt;
+aahyu;
+aahyv;
+aahyw;
+aahyx;
+aahyy;
+aahyz;
+aahza;
+aahzb;
+aahzc;
+aahzd;
+aahze;
+aahzf;
+aahzg;
+aahzh;
+aahzi;
+aahzj;
+aahzk;
+aahzl;
+aahzm;
+aahzn;
+aahzo;
+aahzp;
+aahzq;
+aahzr;
+aahzs;
+aahzt;
+aahzu;
+aahzv;
+aahzw;
+aahzx;
+aahzy;
+aahzz;
+aaiaa;
+aaiab;
+aaiac;
+aaiad;
+aaiae;
+aaiaf;
+aaiag;
+aaiah;
+aaiai;
+aaiaj;
+aaiak;
+aaial;
+aaiam;
+aaian;
+aaiao;
+aaiap;
+aaiaq;
+aaiar;
+aaias;
+aaiat;
+aaiau;
+aaiav;
+aaiaw;
+aaiax;
+aaiay;
+aaiaz;
+aaiba;
+aaibb;
+aaibc;
+aaibd;
+aaibe;
+aaibf;
+aaibg;
+aaibh;
+aaibi;
+aaibj;
+aaibk;
+aaibl;
+aaibm;
+aaibn;
+aaibo;
+aaibp;
+aaibq;
+aaibr;
+aaibs;
+aaibt;
+aaibu;
+aaibv;
+aaibw;
+aaibx;
+aaiby;
+aaibz;
+aaica;
+aaicb;
+aaicc;
+aaicd;
+aaice;
+aaicf;
+aaicg;
+aaich;
+aaici;
+aaicj;
+aaick;
+aaicl;
+aaicm;
+aaicn;
+aaico;
+aaicp;
+aaicq;
+aaicr;
+aaics;
+aaict;
+aaicu;
+aaicv;
+aaicw;
+aaicx;
+aaicy;
+aaicz;
+aaida;
+aaidb;
+aaidc;
+aaidd;
+aaide;
+aaidf;
+aaidg;
+aaidh;
+aaidi;
+aaidj;
+aaidk;
+aaidl;
+aaidm;
+aaidn;
+aaido;
+aaidp;
+aaidq;
+aaidr;
+aaids;
+aaidt;
+aaidu;
+aaidv;
+aaidw;
+aaidx;
+aaidy;
+aaidz;
+aaiea;
+aaieb;
+aaiec;
+aaied;
+aaiee;
+aaief;
+aaieg;
+aaieh;
+aaiei;
+aaiej;
+aaiek;
+aaiel;
+aaiem;
+aaien;
+aaieo;
+aaiep;
+aaieq;
+aaier;
+aaies;
+aaiet;
+aaieu;
+aaiev;
+aaiew;
+aaiex;
+aaiey;
+aaiez;
+aaifa;
+aaifb;
+aaifc;
+aaifd;
+aaife;
+aaiff;
+aaifg;
+aaifh;
+aaifi;
+aaifj;
+aaifk;
+aaifl;
+aaifm;
+aaifn;
+aaifo;
+aaifp;
+aaifq;
+aaifr;
+aaifs;
+aaift;
+aaifu;
+aaifv;
+aaifw;
+aaifx;
+aaify;
+aaifz;
+aaiga;
+aaigb;
+aaigc;
+aaigd;
+aaige;
+aaigf;
+aaigg;
+aaigh;
+aaigi;
+aaigj;
+aaigk;
+aaigl;
+aaigm;
+aaign;
+aaigo;
+aaigp;
+aaigq;
+aaigr;
+aaigs;
+aaigt;
+aaigu;
+aaigv;
+aaigw;
+aaigx;
+aaigy;
+aaigz;
+aaiha;
+aaihb;
+aaihc;
+aaihd;
+aaihe;
+aaihf;
+aaihg;
+aaihh;
+aaihi;
+aaihj;
+aaihk;
+aaihl;
+aaihm;
+aaihn;
+aaiho;
+aaihp;
+aaihq;
+aaihr;
+aaihs;
+aaiht;
+aaihu;
+aaihv;
+aaihw;
+aaihx;
+aaihy;
+aaihz;
+aaiia;
+aaiib;
+aaiic;
+aaiid;
+aaiie;
+aaiif;
+aaiig;
+aaiih;
+aaiii;
+aaiij;
+aaiik;
+aaiil;
+aaiim;
+aaiin;
+aaiio;
+aaiip;
+aaiiq;
+aaiir;
+aaiis;
+aaiit;
+aaiiu;
+aaiiv;
+aaiiw;
+aaiix;
+aaiiy;
+aaiiz;
+aaija;
+aaijb;
+aaijc;
+aaijd;
+aaije;
+aaijf;
+aaijg;
+aaijh;
+aaiji;
+aaijj;
+aaijk;
+aaijl;
+aaijm;
+aaijn;
+aaijo;
+aaijp;
+aaijq;
+aaijr;
+aaijs;
+aaijt;
+aaiju;
+aaijv;
+aaijw;
+aaijx;
+aaijy;
+aaijz;
+aaika;
+aaikb;
+aaikc;
+aaikd;
+aaike;
+aaikf;
+aaikg;
+aaikh;
+aaiki;
+aaikj;
+aaikk;
+aaikl;
+aaikm;
+aaikn;
+aaiko;
+aaikp;
+aaikq;
+aaikr;
+aaiks;
+aaikt;
+aaiku;
+aaikv;
+aaikw;
+aaikx;
+aaiky;
+aaikz;
+aaila;
+aailb;
+aailc;
+aaild;
+aaile;
+aailf;
+aailg;
+aailh;
+aaili;
+aailj;
+aailk;
+aaill;
+aailm;
+aailn;
+aailo;
+aailp;
+aailq;
+aailr;
+aails;
+aailt;
+aailu;
+aailv;
+aailw;
+aailx;
+aaily;
+aailz;
+aaima;
+aaimb;
+aaimc;
+aaimd;
+aaime;
+aaimf;
+aaimg;
+aaimh;
+aaimi;
+aaimj;
+aaimk;
+aaiml;
+aaimm;
+aaimn;
+aaimo;
+aaimp;
+aaimq;
+aaimr;
+aaims;
+aaimt;
+aaimu;
+aaimv;
+aaimw;
+aaimx;
+aaimy;
+aaimz;
+aaina;
+aainb;
+aainc;
+aaind;
+aaine;
+aainf;
+aaing;
+aainh;
+aaini;
+aainj;
+aaink;
+aainl;
+aainm;
+aainn;
+aaino;
+aainp;
+aainq;
+aainr;
+aains;
+aaint;
+aainu;
+aainv;
+aainw;
+aainx;
+aainy;
+aainz;
+aaioa;
+aaiob;
+aaioc;
+aaiod;
+aaioe;
+aaiof;
+aaiog;
+aaioh;
+aaioi;
+aaioj;
+aaiok;
+aaiol;
+aaiom;
+aaion;
+aaioo;
+aaiop;
+aaioq;
+aaior;
+aaios;
+aaiot;
+aaiou;
+aaiov;
+aaiow;
+aaiox;
+aaioy;
+aaioz;
+aaipa;
+aaipb;
+aaipc;
+aaipd;
+aaipe;
+aaipf;
+aaipg;
+aaiph;
+aaipi;
+aaipj;
+aaipk;
+aaipl;
+aaipm;
+aaipn;
+aaipo;
+aaipp;
+aaipq;
+aaipr;
+aaips;
+aaipt;
+aaipu;
+aaipv;
+aaipw;
+aaipx;
+aaipy;
+aaipz;
+aaiqa;
+aaiqb;
+aaiqc;
+aaiqd;
+aaiqe;
+aaiqf;
+aaiqg;
+aaiqh;
+aaiqi;
+aaiqj;
+aaiqk;
+aaiql;
+aaiqm;
+aaiqn;
+aaiqo;
+aaiqp;
+aaiqq;
+aaiqr;
+aaiqs;
+aaiqt;
+aaiqu;
+aaiqv;
+aaiqw;
+aaiqx;
+aaiqy;
+aaiqz;
+aaira;
+aairb;
+aairc;
+aaird;
+aaire;
+aairf;
+aairg;
+aairh;
+aairi;
+aairj;
+aairk;
+aairl;
+aairm;
+aairn;
+aairo;
+aairp;
+aairq;
+aairr;
+aairs;
+aairt;
+aairu;
+aairv;
+aairw;
+aairx;
+aairy;
+aairz;
+aaisa;
+aaisb;
+aaisc;
+aaisd;
+aaise;
+aaisf;
+aaisg;
+aaish;
+aaisi;
+aaisj;
+aaisk;
+aaisl;
+aaism;
+aaisn;
+aaiso;
+aaisp;
+aaisq;
+aaisr;
+aaiss;
+aaist;
+aaisu;
+aaisv;
+aaisw;
+aaisx;
+aaisy;
+aaisz;
+aaita;
+aaitb;
+aaitc;
+aaitd;
+aaite;
+aaitf;
+aaitg;
+aaith;
+aaiti;
+aaitj;
+aaitk;
+aaitl;
+aaitm;
+aaitn;
+aaito;
+aaitp;
+aaitq;
+aaitr;
+aaits;
+aaitt;
+aaitu;
+aaitv;
+aaitw;
+aaitx;
+aaity;
+aaitz;
+aaiua;
+aaiub;
+aaiuc;
+aaiud;
+aaiue;
+aaiuf;
+aaiug;
+aaiuh;
+aaiui;
+aaiuj;
+aaiuk;
+aaiul;
+aaium;
+aaiun;
+aaiuo;
+aaiup;
+aaiuq;
+aaiur;
+aaius;
+aaiut;
+aaiuu;
+aaiuv;
+aaiuw;
+aaiux;
+aaiuy;
+aaiuz;
+aaiva;
+aaivb;
+aaivc;
+aaivd;
+aaive;
+aaivf;
+aaivg;
+aaivh;
+aaivi;
+aaivj;
+aaivk;
+aaivl;
+aaivm;
+aaivn;
+aaivo;
+aaivp;
+aaivq;
+aaivr;
+aaivs;
+aaivt;
+aaivu;
+aaivv;
+aaivw;
+aaivx;
+aaivy;
+aaivz;
+aaiwa;
+aaiwb;
+aaiwc;
+aaiwd;
+aaiwe;
+aaiwf;
+aaiwg;
+aaiwh;
+aaiwi;
+aaiwj;
+aaiwk;
+aaiwl;
+aaiwm;
+aaiwn;
+aaiwo;
+aaiwp;
+aaiwq;
+aaiwr;
+aaiws;
+aaiwt;
+aaiwu;
+aaiwv;
+aaiww;
+aaiwx;
+aaiwy;
+aaiwz;
+aaixa;
+aaixb;
+aaixc;
+aaixd;
+aaixe;
+aaixf;
+aaixg;
+aaixh;
+aaixi;
+aaixj;
+aaixk;
+aaixl;
+aaixm;
+aaixn;
+aaixo;
+aaixp;
+aaixq;
+aaixr;
+aaixs;
+aaixt;
+aaixu;
+aaixv;
+aaixw;
+aaixx;
+aaixy;
+aaixz;
+aaiya;
+aaiyb;
+aaiyc;
+aaiyd;
+aaiye;
+aaiyf;
+aaiyg;
+aaiyh;
+aaiyi;
+aaiyj;
+aaiyk;
+aaiyl;
+aaiym;
+aaiyn;
+aaiyo;
+aaiyp;
+aaiyq;
+aaiyr;
+aaiys;
+aaiyt;
+aaiyu;
+aaiyv;
+aaiyw;
+aaiyx;
+aaiyy;
+aaiyz;
+aaiza;
+aaizb;
+aaizc;
+aaizd;
+aaize;
+aaizf;
+aaizg;
+aaizh;
+aaizi;
+aaizj;
+aaizk;
+aaizl;
+aaizm;
+aaizn;
+aaizo;
+aaizp;
+aaizq;
+aaizr;
+aaizs;
+aaizt;
+aaizu;
+aaizv;
+aaizw;
+aaizx;
+aaizy;
+aaizz;
+aajaa;
+aajab;
+aajac;
+aajad;
+aajae;
+aajaf;
+aajag;
+aajah;
+aajai;
+aajaj;
+aajak;
+aajal;
+aajam;
+aajan;
+aajao;
+aajap;
+aajaq;
+aajar;
+aajas;
+aajat;
+aajau;
+aajav;
+aajaw;
+aajax;
+aajay;
+aajaz;
+aajba;
+aajbb;
+aajbc;
+aajbd;
+aajbe;
+aajbf;
+aajbg;
+aajbh;
+aajbi;
+aajbj;
+aajbk;
+aajbl;
+aajbm;
+aajbn;
+aajbo;
+aajbp;
+aajbq;
+aajbr;
+aajbs;
+aajbt;
+aajbu;
+aajbv;
+aajbw;
+aajbx;
+aajby;
+aajbz;
+aajca;
+aajcb;
+aajcc;
+aajcd;
+aajce;
+aajcf;
+aajcg;
+aajch;
+aajci;
+aajcj;
+aajck;
+aajcl;
+aajcm;
+aajcn;
+aajco;
+aajcp;
+aajcq;
+aajcr;
+aajcs;
+aajct;
+aajcu;
+aajcv;
+aajcw;
+aajcx;
+aajcy;
+aajcz;
+aajda;
+aajdb;
+aajdc;
+aajdd;
+aajde;
+aajdf;
+aajdg;
+aajdh;
+aajdi;
+aajdj;
+aajdk;
+aajdl;
+aajdm;
+aajdn;
+aajdo;
+aajdp;
+aajdq;
+aajdr;
+aajds;
+aajdt;
+aajdu;
+aajdv;
+aajdw;
+aajdx;
+aajdy;
+aajdz;
+aajea;
+aajeb;
+aajec;
+aajed;
+aajee;
+aajef;
+aajeg;
+aajeh;
+aajei;
+aajej;
+aajek;
+aajel;
+aajem;
+aajen;
+aajeo;
+aajep;
+aajeq;
+aajer;
+aajes;
+aajet;
+aajeu;
+aajev;
+aajew;
+aajex;
+aajey;
+aajez;
+aajfa;
+aajfb;
+aajfc;
+aajfd;
+aajfe;
+aajff;
+aajfg;
+aajfh;
+aajfi;
+aajfj;
+aajfk;
+aajfl;
+aajfm;
+aajfn;
+aajfo;
+aajfp;
+aajfq;
+aajfr;
+aajfs;
+aajft;
+aajfu;
+aajfv;
+aajfw;
+aajfx;
+aajfy;
+aajfz;
+aajga;
+aajgb;
+aajgc;
+aajgd;
+aajge;
+aajgf;
+aajgg;
+aajgh;
+aajgi;
+aajgj;
+aajgk;
+aajgl;
+aajgm;
+aajgn;
+aajgo;
+aajgp;
+aajgq;
+aajgr;
+aajgs;
+aajgt;
+aajgu;
+aajgv;
+aajgw;
+aajgx;
+aajgy;
+aajgz;
+aajha;
+aajhb;
+aajhc;
+aajhd;
+aajhe;
+aajhf;
+aajhg;
+aajhh;
+aajhi;
+aajhj;
+aajhk;
+aajhl;
+aajhm;
+aajhn;
+aajho;
+aajhp;
+aajhq;
+aajhr;
+aajhs;
+aajht;
+aajhu;
+aajhv;
+aajhw;
+aajhx;
+aajhy;
+aajhz;
+aajia;
+aajib;
+aajic;
+aajid;
+aajie;
+aajif;
+aajig;
+aajih;
+aajii;
+aajij;
+aajik;
+aajil;
+aajim;
+aajin;
+aajio;
+aajip;
+aajiq;
+aajir;
+aajis;
+aajit;
+aajiu;
+aajiv;
+aajiw;
+aajix;
+aajiy;
+aajiz;
+aajja;
+aajjb;
+aajjc;
+aajjd;
+aajje;
+aajjf;
+aajjg;
+aajjh;
+aajji;
+aajjj;
+aajjk;
+aajjl;
+aajjm;
+aajjn;
+aajjo;
+aajjp;
+aajjq;
+aajjr;
+aajjs;
+aajjt;
+aajju;
+aajjv;
+aajjw;
+aajjx;
+aajjy;
+aajjz;
+aajka;
+aajkb;
+aajkc;
+aajkd;
+aajke;
+aajkf;
+aajkg;
+aajkh;
+aajki;
+aajkj;
+aajkk;
+aajkl;
+aajkm;
+aajkn;
+aajko;
+aajkp;
+aajkq;
+aajkr;
+aajks;
+aajkt;
+aajku;
+aajkv;
+aajkw;
+aajkx;
+aajky;
+aajkz;
+aajla;
+aajlb;
+aajlc;
+aajld;
+aajle;
+aajlf;
+aajlg;
+aajlh;
+aajli;
+aajlj;
+aajlk;
+aajll;
+aajlm;
+aajln;
+aajlo;
+aajlp;
+aajlq;
+aajlr;
+aajls;
+aajlt;
+aajlu;
+aajlv;
+aajlw;
+aajlx;
+aajly;
+aajlz;
+aajma;
+aajmb;
+aajmc;
+aajmd;
+aajme;
+aajmf;
+aajmg;
+aajmh;
+aajmi;
+aajmj;
+aajmk;
+aajml;
+aajmm;
+aajmn;
+aajmo;
+aajmp;
+aajmq;
+aajmr;
+aajms;
+aajmt;
+aajmu;
+aajmv;
+aajmw;
+aajmx;
+aajmy;
+aajmz;
+aajna;
+aajnb;
+aajnc;
+aajnd;
+aajne;
+aajnf;
+aajng;
+aajnh;
+aajni;
+aajnj;
+aajnk;
+aajnl;
+aajnm;
+aajnn;
+aajno;
+aajnp;
+aajnq;
+aajnr;
+aajns;
+aajnt;
+aajnu;
+aajnv;
+aajnw;
+aajnx;
+aajny;
+aajnz;
+aajoa;
+aajob;
+aajoc;
+aajod;
+aajoe;
+aajof;
+aajog;
+aajoh;
+aajoi;
+aajoj;
+aajok;
+aajol;
+aajom;
+aajon;
+aajoo;
+aajop;
+aajoq;
+aajor;
+aajos;
+aajot;
+aajou;
+aajov;
+aajow;
+aajox;
+aajoy;
+aajoz;
+aajpa;
+aajpb;
+aajpc;
+aajpd;
+aajpe;
+aajpf;
+aajpg;
+aajph;
+aajpi;
+aajpj;
+aajpk;
+aajpl;
+aajpm;
+aajpn;
+aajpo;
+aajpp;
+aajpq;
+aajpr;
+aajps;
+aajpt;
+aajpu;
+aajpv;
+aajpw;
+aajpx;
+aajpy;
+aajpz;
+aajqa;
+aajqb;
+aajqc;
+aajqd;
+aajqe;
+aajqf;
+aajqg;
+aajqh;
+aajqi;
+aajqj;
+aajqk;
+aajql;
+aajqm;
+aajqn;
+aajqo;
+aajqp;
+aajqq;
+aajqr;
+aajqs;
+aajqt;
+aajqu;
+aajqv;
+aajqw;
+aajqx;
+aajqy;
+aajqz;
+aajra;
+aajrb;
+aajrc;
+aajrd;
+aajre;
+aajrf;
+aajrg;
+aajrh;
+aajri;
+aajrj;
+aajrk;
+aajrl;
+aajrm;
+aajrn;
+aajro;
+aajrp;
+aajrq;
+aajrr;
+aajrs;
+aajrt;
+aajru;
+aajrv;
+aajrw;
+aajrx;
+aajry;
+aajrz;
+aajsa;
+aajsb;
+aajsc;
+aajsd;
+aajse;
+aajsf;
+aajsg;
+aajsh;
+aajsi;
+aajsj;
+aajsk;
+aajsl;
+aajsm;
+aajsn;
+aajso;
+aajsp;
+aajsq;
+aajsr;
+aajss;
+aajst;
+aajsu;
+aajsv;
+aajsw;
+aajsx;
+aajsy;
+aajsz;
+aajta;
+aajtb;
+aajtc;
+aajtd;
+aajte;
+aajtf;
+aajtg;
+aajth;
+aajti;
+aajtj;
+aajtk;
+aajtl;
+aajtm;
+aajtn;
+aajto;
+aajtp;
+aajtq;
+aajtr;
+aajts;
+aajtt;
+aajtu;
+aajtv;
+aajtw;
+aajtx;
+aajty;
+aajtz;
+aajua;
+aajub;
+aajuc;
+aajud;
+aajue;
+aajuf;
+aajug;
+aajuh;
+aajui;
+aajuj;
+aajuk;
+aajul;
+aajum;
+aajun;
+aajuo;
+aajup;
+aajuq;
+aajur;
+aajus;
+aajut;
+aajuu;
+aajuv;
+aajuw;
+aajux;
+aajuy;
+aajuz;
+aajva;
+aajvb;
+aajvc;
+aajvd;
+aajve;
+aajvf;
+aajvg;
+aajvh;
+aajvi;
+aajvj;
+aajvk;
+aajvl;
+aajvm;
+aajvn;
+aajvo;
+aajvp;
+aajvq;
+aajvr;
+aajvs;
+aajvt;
+aajvu;
+aajvv;
+aajvw;
+aajvx;
+aajvy;
+aajvz;
+aajwa;
+aajwb;
+aajwc;
+aajwd;
+aajwe;
+aajwf;
+aajwg;
+aajwh;
+aajwi;
+aajwj;
+aajwk;
+aajwl;
+aajwm;
+aajwn;
+aajwo;
+aajwp;
+aajwq;
+aajwr;
+aajws;
+aajwt;
+aajwu;
+aajwv;
+aajww;
+aajwx;
+aajwy;
+aajwz;
+aajxa;
+aajxb;
+aajxc;
+aajxd;
+aajxe;
+aajxf;
+aajxg;
+aajxh;
+aajxi;
+aajxj;
+aajxk;
+aajxl;
+aajxm;
+aajxn;
+aajxo;
+aajxp;
+aajxq;
+aajxr;
+aajxs;
+aajxt;
+aajxu;
+aajxv;
+aajxw;
+aajxx;
+aajxy;
+aajxz;
+aajya;
+aajyb;
+aajyc;
+aajyd;
+aajye;
+aajyf;
+aajyg;
+aajyh;
+aajyi;
+aajyj;
+aajyk;
+aajyl;
+aajym;
+aajyn;
+aajyo;
+aajyp;
+aajyq;
+aajyr;
+aajys;
+aajyt;
+aajyu;
+aajyv;
+aajyw;
+aajyx;
+aajyy;
+aajyz;
+aajza;
+aajzb;
+aajzc;
+aajzd;
+aajze;
+aajzf;
+aajzg;
+aajzh;
+aajzi;
+aajzj;
+aajzk;
+aajzl;
+aajzm;
+aajzn;
+aajzo;
+aajzp;
+aajzq;
+aajzr;
+aajzs;
+aajzt;
+aajzu;
+aajzv;
+aajzw;
+aajzx;
+aajzy;
+aajzz;
+aakaa;
+aakab;
+aakac;
+aakad;
+aakae;
+aakaf;
+aakag;
+aakah;
+aakai;
+aakaj;
+aakak;
+aakal;
+aakam;
+aakan;
+aakao;
+aakap;
+aakaq;
+aakar;
+aakas;
+aakat;
+aakau;
+aakav;
+aakaw;
+aakax;
+aakay;
+aakaz;
+aakba;
+aakbb;
+aakbc;
+aakbd;
+aakbe;
+aakbf;
+aakbg;
+aakbh;
+aakbi;
+aakbj;
+aakbk;
+aakbl;
+aakbm;
+aakbn;
+aakbo;
+aakbp;
+aakbq;
+aakbr;
+aakbs;
+aakbt;
+aakbu;
+aakbv;
+aakbw;
+aakbx;
+aakby;
+aakbz;
+aakca;
+aakcb;
+aakcc;
+aakcd;
+aakce;
+aakcf;
+aakcg;
+aakch;
+aakci;
+aakcj;
+aakck;
+aakcl;
+aakcm;
+aakcn;
+aakco;
+aakcp;
+aakcq;
+aakcr;
+aakcs;
+aakct;
+aakcu;
+aakcv;
+aakcw;
+aakcx;
+aakcy;
+aakcz;
+aakda;
+aakdb;
+aakdc;
+aakdd;
+aakde;
+aakdf;
+aakdg;
+aakdh;
+aakdi;
+aakdj;
+aakdk;
+aakdl;
+aakdm;
+aakdn;
+aakdo;
+aakdp;
+aakdq;
+aakdr;
+aakds;
+aakdt;
+aakdu;
+aakdv;
+aakdw;
+aakdx;
+aakdy;
+aakdz;
+aakea;
+aakeb;
+aakec;
+aaked;
+aakee;
+aakef;
+aakeg;
+aakeh;
+aakei;
+aakej;
+aakek;
+aakel;
+aakem;
+aaken;
+aakeo;
+aakep;
+aakeq;
+aaker;
+aakes;
+aaket;
+aakeu;
+aakev;
+aakew;
+aakex;
+aakey;
+aakez;
+aakfa;
+aakfb;
+aakfc;
+aakfd;
+aakfe;
+aakff;
+aakfg;
+aakfh;
+aakfi;
+aakfj;
+aakfk;
+aakfl;
+aakfm;
+aakfn;
+aakfo;
+aakfp;
+aakfq;
+aakfr;
+aakfs;
+aakft;
+aakfu;
+aakfv;
+aakfw;
+aakfx;
+aakfy;
+aakfz;
+aakga;
+aakgb;
+aakgc;
+aakgd;
+aakge;
+aakgf;
+aakgg;
+aakgh;
+aakgi;
+aakgj;
+aakgk;
+aakgl;
+aakgm;
+aakgn;
+aakgo;
+aakgp;
+aakgq;
+aakgr;
+aakgs;
+aakgt;
+aakgu;
+aakgv;
+aakgw;
+aakgx;
+aakgy;
+aakgz;
+aakha;
+aakhb;
+aakhc;
+aakhd;
+aakhe;
+aakhf;
+aakhg;
+aakhh;
+aakhi;
+aakhj;
+aakhk;
+aakhl;
+aakhm;
+aakhn;
+aakho;
+aakhp;
+aakhq;
+aakhr;
+aakhs;
+aakht;
+aakhu;
+aakhv;
+aakhw;
+aakhx;
+aakhy;
+aakhz;
+aakia;
+aakib;
+aakic;
+aakid;
+aakie;
+aakif;
+aakig;
+aakih;
+aakii;
+aakij;
+aakik;
+aakil;
+aakim;
+aakin;
+aakio;
+aakip;
+aakiq;
+aakir;
+aakis;
+aakit;
+aakiu;
+aakiv;
+aakiw;
+aakix;
+aakiy;
+aakiz;
+aakja;
+aakjb;
+aakjc;
+aakjd;
+aakje;
+aakjf;
+aakjg;
+aakjh;
+aakji;
+aakjj;
+aakjk;
+aakjl;
+aakjm;
+aakjn;
+aakjo;
+aakjp;
+aakjq;
+aakjr;
+aakjs;
+aakjt;
+aakju;
+aakjv;
+aakjw;
+aakjx;
+aakjy;
+aakjz;
+aakka;
+aakkb;
+aakkc;
+aakkd;
+aakke;
+aakkf;
+aakkg;
+aakkh;
+aakki;
+aakkj;
+aakkk;
+aakkl;
+aakkm;
+aakkn;
+aakko;
+aakkp;
+aakkq;
+aakkr;
+aakks;
+aakkt;
+aakku;
+aakkv;
+aakkw;
+aakkx;
+aakky;
+aakkz;
+aakla;
+aaklb;
+aaklc;
+aakld;
+aakle;
+aaklf;
+aaklg;
+aaklh;
+aakli;
+aaklj;
+aaklk;
+aakll;
+aaklm;
+aakln;
+aaklo;
+aaklp;
+aaklq;
+aaklr;
+aakls;
+aaklt;
+aaklu;
+aaklv;
+aaklw;
+aaklx;
+aakly;
+aaklz;
+aakma;
+aakmb;
+aakmc;
+aakmd;
+aakme;
+aakmf;
+aakmg;
+aakmh;
+aakmi;
+aakmj;
+aakmk;
+aakml;
+aakmm;
+aakmn;
+aakmo;
+aakmp;
+aakmq;
+aakmr;
+aakms;
+aakmt;
+aakmu;
+aakmv;
+aakmw;
+aakmx;
+aakmy;
+aakmz;
+aakna;
+aaknb;
+aaknc;
+aaknd;
+aakne;
+aaknf;
+aakng;
+aaknh;
+aakni;
+aaknj;
+aaknk;
+aaknl;
+aaknm;
+aaknn;
+aakno;
+aaknp;
+aaknq;
+aaknr;
+aakns;
+aaknt;
+aaknu;
+aaknv;
+aaknw;
+aaknx;
+aakny;
+aaknz;
+aakoa;
+aakob;
+aakoc;
+aakod;
+aakoe;
+aakof;
+aakog;
+aakoh;
+aakoi;
+aakoj;
+aakok;
+aakol;
+aakom;
+aakon;
+aakoo;
+aakop;
+aakoq;
+aakor;
+aakos;
+aakot;
+aakou;
+aakov;
+aakow;
+aakox;
+aakoy;
+aakoz;
+aakpa;
+aakpb;
+aakpc;
+aakpd;
+aakpe;
+aakpf;
+aakpg;
+aakph;
+aakpi;
+aakpj;
+aakpk;
+aakpl;
+aakpm;
+aakpn;
+aakpo;
+aakpp;
+aakpq;
+aakpr;
+aakps;
+aakpt;
+aakpu;
+aakpv;
+aakpw;
+aakpx;
+aakpy;
+aakpz;
+aakqa;
+aakqb;
+aakqc;
+aakqd;
+aakqe;
+aakqf;
+aakqg;
+aakqh;
+aakqi;
+aakqj;
+aakqk;
+aakql;
+aakqm;
+aakqn;
+aakqo;
+aakqp;
+aakqq;
+aakqr;
+aakqs;
+aakqt;
+aakqu;
+aakqv;
+aakqw;
+aakqx;
+aakqy;
+aakqz;
+aakra;
+aakrb;
+aakrc;
+aakrd;
+aakre;
+aakrf;
+aakrg;
+aakrh;
+aakri;
+aakrj;
+aakrk;
+aakrl;
+aakrm;
+aakrn;
+aakro;
+aakrp;
+aakrq;
+aakrr;
+aakrs;
+aakrt;
+aakru;
+aakrv;
+aakrw;
+aakrx;
+aakry;
+aakrz;
+aaksa;
+aaksb;
+aaksc;
+aaksd;
+aakse;
+aaksf;
+aaksg;
+aaksh;
+aaksi;
+aaksj;
+aaksk;
+aaksl;
+aaksm;
+aaksn;
+aakso;
+aaksp;
+aaksq;
+aaksr;
+aakss;
+aakst;
+aaksu;
+aaksv;
+aaksw;
+aaksx;
+aaksy;
+aaksz;
+aakta;
+aaktb;
+aaktc;
+aaktd;
+aakte;
+aaktf;
+aaktg;
+aakth;
+aakti;
+aaktj;
+aaktk;
+aaktl;
+aaktm;
+aaktn;
+aakto;
+aaktp;
+aaktq;
+aaktr;
+aakts;
+aaktt;
+aaktu;
+aaktv;
+aaktw;
+aaktx;
+aakty;
+aaktz;
+aakua;
+aakub;
+aakuc;
+aakud;
+aakue;
+aakuf;
+aakug;
+aakuh;
+aakui;
+aakuj;
+aakuk;
+aakul;
+aakum;
+aakun;
+aakuo;
+aakup;
+aakuq;
+aakur;
+aakus;
+aakut;
+aakuu;
+aakuv;
+aakuw;
+aakux;
+aakuy;
+aakuz;
+aakva;
+aakvb;
+aakvc;
+aakvd;
+aakve;
+aakvf;
+aakvg;
+aakvh;
+aakvi;
+aakvj;
+aakvk;
+aakvl;
+aakvm;
+aakvn;
+aakvo;
+aakvp;
+aakvq;
+aakvr;
+aakvs;
+aakvt;
+aakvu;
+aakvv;
+aakvw;
+aakvx;
+aakvy;
+aakvz;
+aakwa;
+aakwb;
+aakwc;
+aakwd;
+aakwe;
+aakwf;
+aakwg;
+aakwh;
+aakwi;
+aakwj;
+aakwk;
+aakwl;
+aakwm;
+aakwn;
+aakwo;
+aakwp;
+aakwq;
+aakwr;
+aakws;
+aakwt;
+aakwu;
+aakwv;
+aakww;
+aakwx;
+aakwy;
+aakwz;
+aakxa;
+aakxb;
+aakxc;
+aakxd;
+aakxe;
+aakxf;
+aakxg;
+aakxh;
+aakxi;
+aakxj;
+aakxk;
+aakxl;
+aakxm;
+aakxn;
+aakxo;
+aakxp;
+aakxq;
+aakxr;
+aakxs;
+aakxt;
+aakxu;
+aakxv;
+aakxw;
+aakxx;
+aakxy;
+aakxz;
+aakya;
+aakyb;
+aakyc;
+aakyd;
+aakye;
+aakyf;
+aakyg;
+aakyh;
+aakyi;
+aakyj;
+aakyk;
+aakyl;
+aakym;
+aakyn;
+aakyo;
+aakyp;
+aakyq;
+aakyr;
+aakys;
+aakyt;
+aakyu;
+aakyv;
+aakyw;
+aakyx;
+aakyy;
+aakyz;
+aakza;
+aakzb;
+aakzc;
+aakzd;
+aakze;
+aakzf;
+aakzg;
+aakzh;
+aakzi;
+aakzj;
+aakzk;
+aakzl;
+aakzm;
+aakzn;
+aakzo;
+aakzp;
+aakzq;
+aakzr;
+aakzs;
+aakzt;
+aakzu;
+aakzv;
+aakzw;
+aakzx;
+aakzy;
+aakzz;
+aalaa;
+aalab;
+aalac;
+aalad;
+aalae;
+aalaf;
+aalag;
+aalah;
+aalai;
+aalaj;
+aalak;
+aalal;
+aalam;
+aalan;
+aalao;
+aalap;
+aalaq;
+aalar;
+aalas;
+aalat;
+aalau;
+aalav;
+aalaw;
+aalax;
+aalay;
+aalaz;
+aalba;
+aalbb;
+aalbc;
+aalbd;
+aalbe;
+aalbf;
+aalbg;
+aalbh;
+aalbi;
+aalbj;
+aalbk;
+aalbl;
+aalbm;
+aalbn;
+aalbo;
+aalbp;
+aalbq;
+aalbr;
+aalbs;
+aalbt;
+aalbu;
+aalbv;
+aalbw;
+aalbx;
+aalby;
+aalbz;
+aalca;
+aalcb;
+aalcc;
+aalcd;
+aalce;
+aalcf;
+aalcg;
+aalch;
+aalci;
+aalcj;
+aalck;
+aalcl;
+aalcm;
+aalcn;
+aalco;
+aalcp;
+aalcq;
+aalcr;
+aalcs;
+aalct;
+aalcu;
+aalcv;
+aalcw;
+aalcx;
+aalcy;
+aalcz;
+aalda;
+aaldb;
+aaldc;
+aaldd;
+aalde;
+aaldf;
+aaldg;
+aaldh;
+aaldi;
+aaldj;
+aaldk;
+aaldl;
+aaldm;
+aaldn;
+aaldo;
+aaldp;
+aaldq;
+aaldr;
+aalds;
+aaldt;
+aaldu;
+aaldv;
+aaldw;
+aaldx;
+aaldy;
+aaldz;
+aalea;
+aaleb;
+aalec;
+aaled;
+aalee;
+aalef;
+aaleg;
+aaleh;
+aalei;
+aalej;
+aalek;
+aalel;
+aalem;
+aalen;
+aaleo;
+aalep;
+aaleq;
+aaler;
+aales;
+aalet;
+aaleu;
+aalev;
+aalew;
+aalex;
+aaley;
+aalez;
+aalfa;
+aalfb;
+aalfc;
+aalfd;
+aalfe;
+aalff;
+aalfg;
+aalfh;
+aalfi;
+aalfj;
+aalfk;
+aalfl;
+aalfm;
+aalfn;
+aalfo;
+aalfp;
+aalfq;
+aalfr;
+aalfs;
+aalft;
+aalfu;
+aalfv;
+aalfw;
+aalfx;
+aalfy;
+aalfz;
+aalga;
+aalgb;
+aalgc;
+aalgd;
+aalge;
+aalgf;
+aalgg;
+aalgh;
+aalgi;
+aalgj;
+aalgk;
+aalgl;
+aalgm;
+aalgn;
+aalgo;
+aalgp;
+aalgq;
+aalgr;
+aalgs;
+aalgt;
+aalgu;
+aalgv;
+aalgw;
+aalgx;
+aalgy;
+aalgz;
+aalha;
+aalhb;
+aalhc;
+aalhd;
+aalhe;
+aalhf;
+aalhg;
+aalhh;
+aalhi;
+aalhj;
+aalhk;
+aalhl;
+aalhm;
+aalhn;
+aalho;
+aalhp;
+aalhq;
+aalhr;
+aalhs;
+aalht;
+aalhu;
+aalhv;
+aalhw;
+aalhx;
+aalhy;
+aalhz;
+aalia;
+aalib;
+aalic;
+aalid;
+aalie;
+aalif;
+aalig;
+aalih;
+aalii;
+aalij;
+aalik;
+aalil;
+aalim;
+aalin;
+aalio;
+aalip;
+aaliq;
+aalir;
+aalis;
+aalit;
+aaliu;
+aaliv;
+aaliw;
+aalix;
+aaliy;
+aaliz;
+aalja;
+aaljb;
+aaljc;
+aaljd;
+aalje;
+aaljf;
+aaljg;
+aaljh;
+aalji;
+aaljj;
+aaljk;
+aaljl;
+aaljm;
+aaljn;
+aaljo;
+aaljp;
+aaljq;
+aaljr;
+aaljs;
+aaljt;
+aalju;
+aaljv;
+aaljw;
+aaljx;
+aaljy;
+aaljz;
+aalka;
+aalkb;
+aalkc;
+aalkd;
+aalke;
+aalkf;
+aalkg;
+aalkh;
+aalki;
+aalkj;
+aalkk;
+aalkl;
+aalkm;
+aalkn;
+aalko;
+aalkp;
+aalkq;
+aalkr;
+aalks;
+aalkt;
+aalku;
+aalkv;
+aalkw;
+aalkx;
+aalky;
+aalkz;
+aalla;
+aallb;
+aallc;
+aalld;
+aalle;
+aallf;
+aallg;
+aallh;
+aalli;
+aallj;
+aallk;
+aalll;
+aallm;
+aalln;
+aallo;
+aallp;
+aallq;
+aallr;
+aalls;
+aallt;
+aallu;
+aallv;
+aallw;
+aallx;
+aally;
+aallz;
+aalma;
+aalmb;
+aalmc;
+aalmd;
+aalme;
+aalmf;
+aalmg;
+aalmh;
+aalmi;
+aalmj;
+aalmk;
+aalml;
+aalmm;
+aalmn;
+aalmo;
+aalmp;
+aalmq;
+aalmr;
+aalms;
+aalmt;
+aalmu;
+aalmv;
+aalmw;
+aalmx;
+aalmy;
+aalmz;
+aalna;
+aalnb;
+aalnc;
+aalnd;
+aalne;
+aalnf;
+aalng;
+aalnh;
+aalni;
+aalnj;
+aalnk;
+aalnl;
+aalnm;
+aalnn;
+aalno;
+aalnp;
+aalnq;
+aalnr;
+aalns;
+aalnt;
+aalnu;
+aalnv;
+aalnw;
+aalnx;
+aalny;
+aalnz;
+aaloa;
+aalob;
+aaloc;
+aalod;
+aaloe;
+aalof;
+aalog;
+aaloh;
+aaloi;
+aaloj;
+aalok;
+aalol;
+aalom;
+aalon;
+aaloo;
+aalop;
+aaloq;
+aalor;
+aalos;
+aalot;
+aalou;
+aalov;
+aalow;
+aalox;
+aaloy;
+aaloz;
+aalpa;
+aalpb;
+aalpc;
+aalpd;
+aalpe;
+aalpf;
+aalpg;
+aalph;
+aalpi;
+aalpj;
+aalpk;
+aalpl;
+aalpm;
+aalpn;
+aalpo;
+aalpp;
+aalpq;
+aalpr;
+aalps;
+aalpt;
+aalpu;
+aalpv;
+aalpw;
+aalpx;
+aalpy;
+aalpz;
+aalqa;
+aalqb;
+aalqc;
+aalqd;
+aalqe;
+aalqf;
+aalqg;
+aalqh;
+aalqi;
+aalqj;
+aalqk;
+aalql;
+aalqm;
+aalqn;
+aalqo;
+aalqp;
+aalqq;
+aalqr;
+aalqs;
+aalqt;
+aalqu;
+aalqv;
+aalqw;
+aalqx;
+aalqy;
+aalqz;
+aalra;
+aalrb;
+aalrc;
+aalrd;
+aalre;
+aalrf;
+aalrg;
+aalrh;
+aalri;
+aalrj;
+aalrk;
+aalrl;
+aalrm;
+aalrn;
+aalro;
+aalrp;
+aalrq;
+aalrr;
+aalrs;
+aalrt;
+aalru;
+aalrv;
+aalrw;
+aalrx;
+aalry;
+aalrz;
+aalsa;
+aalsb;
+aalsc;
+aalsd;
+aalse;
+aalsf;
+aalsg;
+aalsh;
+aalsi;
+aalsj;
+aalsk;
+aalsl;
+aalsm;
+aalsn;
+aalso;
+aalsp;
+aalsq;
+aalsr;
+aalss;
+aalst;
+aalsu;
+aalsv;
+aalsw;
+aalsx;
+aalsy;
+aalsz;
+aalta;
+aaltb;
+aaltc;
+aaltd;
+aalte;
+aaltf;
+aaltg;
+aalth;
+aalti;
+aaltj;
+aaltk;
+aaltl;
+aaltm;
+aaltn;
+aalto;
+aaltp;
+aaltq;
+aaltr;
+aalts;
+aaltt;
+aaltu;
+aaltv;
+aaltw;
+aaltx;
+aalty;
+aaltz;
+aalua;
+aalub;
+aaluc;
+aalud;
+aalue;
+aaluf;
+aalug;
+aaluh;
+aalui;
+aaluj;
+aaluk;
+aalul;
+aalum;
+aalun;
+aaluo;
+aalup;
+aaluq;
+aalur;
+aalus;
+aalut;
+aaluu;
+aaluv;
+aaluw;
+aalux;
+aaluy;
+aaluz;
+aalva;
+aalvb;
+aalvc;
+aalvd;
+aalve;
+aalvf;
+aalvg;
+aalvh;
+aalvi;
+aalvj;
+aalvk;
+aalvl;
+aalvm;
+aalvn;
+aalvo;
+aalvp;
+aalvq;
+aalvr;
+aalvs;
+aalvt;
+aalvu;
+aalvv;
+aalvw;
+aalvx;
+aalvy;
+aalvz;
+aalwa;
+aalwb;
+aalwc;
+aalwd;
+aalwe;
+aalwf;
+aalwg;
+aalwh;
+aalwi;
+aalwj;
+aalwk;
+aalwl;
+aalwm;
+aalwn;
+aalwo;
+aalwp;
+aalwq;
+aalwr;
+aalws;
+aalwt;
+aalwu;
+aalwv;
+aalww;
+aalwx;
+aalwy;
+aalwz;
+aalxa;
+aalxb;
+aalxc;
+aalxd;
+aalxe;
+aalxf;
+aalxg;
+aalxh;
+aalxi;
+aalxj;
+aalxk;
+aalxl;
+aalxm;
+aalxn;
+aalxo;
+aalxp;
+aalxq;
+aalxr;
+aalxs;
+aalxt;
+aalxu;
+aalxv;
+aalxw;
+aalxx;
+aalxy;
+aalxz;
+aalya;
+aalyb;
+aalyc;
+aalyd;
+aalye;
+aalyf;
+aalyg;
+aalyh;
+aalyi;
+aalyj;
+aalyk;
+aalyl;
+aalym;
+aalyn;
+aalyo;
+aalyp;
+aalyq;
+aalyr;
+aalys;
+aalyt;
+aalyu;
+aalyv;
+aalyw;
+aalyx;
+aalyy;
+aalyz;
+aalza;
+aalzb;
+aalzc;
+aalzd;
+aalze;
+aalzf;
+aalzg;
+aalzh;
+aalzi;
+aalzj;
+aalzk;
+aalzl;
+aalzm;
+aalzn;
+aalzo;
+aalzp;
+aalzq;
+aalzr;
+aalzs;
+aalzt;
+aalzu;
+aalzv;
+aalzw;
+aalzx;
+aalzy;
+aalzz;
+aamaa;
+aamab;
+aamac;
+aamad;
+aamae;
+aamaf;
+aamag;
+aamah;
+aamai;
+aamaj;
+aamak;
+aamal;
+aamam;
+aaman;
+aamao;
+aamap;
+aamaq;
+aamar;
+aamas;
+aamat;
+aamau;
+aamav;
+aamaw;
+aamax;
+aamay;
+aamaz;
+aamba;
+aambb;
+aambc;
+aambd;
+aambe;
+aambf;
+aambg;
+aambh;
+aambi;
+aambj;
+aambk;
+aambl;
+aambm;
+aambn;
+aambo;
+aambp;
+aambq;
+aambr;
+aambs;
+aambt;
+aambu;
+aambv;
+aambw;
+aambx;
+aamby;
+aambz;
+aamca;
+aamcb;
+aamcc;
+aamcd;
+aamce;
+aamcf;
+aamcg;
+aamch;
+aamci;
+aamcj;
+aamck;
+aamcl;
+aamcm;
+aamcn;
+aamco;
+aamcp;
+aamcq;
+aamcr;
+aamcs;
+aamct;
+aamcu;
+aamcv;
+aamcw;
+aamcx;
+aamcy;
+aamcz;
+aamda;
+aamdb;
+aamdc;
+aamdd;
+aamde;
+aamdf;
+aamdg;
+aamdh;
+aamdi;
+aamdj;
+aamdk;
+aamdl;
+aamdm;
+aamdn;
+aamdo;
+aamdp;
+aamdq;
+aamdr;
+aamds;
+aamdt;
+aamdu;
+aamdv;
+aamdw;
+aamdx;
+aamdy;
+aamdz;
+aamea;
+aameb;
+aamec;
+aamed;
+aamee;
+aamef;
+aameg;
+aameh;
+aamei;
+aamej;
+aamek;
+aamel;
+aamem;
+aamen;
+aameo;
+aamep;
+aameq;
+aamer;
+aames;
+aamet;
+aameu;
+aamev;
+aamew;
+aamex;
+aamey;
+aamez;
+aamfa;
+aamfb;
+aamfc;
+aamfd;
+aamfe;
+aamff;
+aamfg;
+aamfh;
+aamfi;
+aamfj;
+aamfk;
+aamfl;
+aamfm;
+aamfn;
+aamfo;
+aamfp;
+aamfq;
+aamfr;
+aamfs;
+aamft;
+aamfu;
+aamfv;
+aamfw;
+aamfx;
+aamfy;
+aamfz;
+aamga;
+aamgb;
+aamgc;
+aamgd;
+aamge;
+aamgf;
+aamgg;
+aamgh;
+aamgi;
+aamgj;
+aamgk;
+aamgl;
+aamgm;
+aamgn;
+aamgo;
+aamgp;
+aamgq;
+aamgr;
+aamgs;
+aamgt;
+aamgu;
+aamgv;
+aamgw;
+aamgx;
+aamgy;
+aamgz;
+aamha;
+aamhb;
+aamhc;
+aamhd;
+aamhe;
+aamhf;
+aamhg;
+aamhh;
+aamhi;
+aamhj;
+aamhk;
+aamhl;
+aamhm;
+aamhn;
+aamho;
+aamhp;
+aamhq;
+aamhr;
+aamhs;
+aamht;
+aamhu;
+aamhv;
+aamhw;
+aamhx;
+aamhy;
+aamhz;
+aamia;
+aamib;
+aamic;
+aamid;
+aamie;
+aamif;
+aamig;
+aamih;
+aamii;
+aamij;
+aamik;
+aamil;
+aamim;
+aamin;
+aamio;
+aamip;
+aamiq;
+aamir;
+aamis;
+aamit;
+aamiu;
+aamiv;
+aamiw;
+aamix;
+aamiy;
+aamiz;
+aamja;
+aamjb;
+aamjc;
+aamjd;
+aamje;
+aamjf;
+aamjg;
+aamjh;
+aamji;
+aamjj;
+aamjk;
+aamjl;
+aamjm;
+aamjn;
+aamjo;
+aamjp;
+aamjq;
+aamjr;
+aamjs;
+aamjt;
+aamju;
+aamjv;
+aamjw;
+aamjx;
+aamjy;
+aamjz;
+aamka;
+aamkb;
+aamkc;
+aamkd;
+aamke;
+aamkf;
+aamkg;
+aamkh;
+aamki;
+aamkj;
+aamkk;
+aamkl;
+aamkm;
+aamkn;
+aamko;
+aamkp;
+aamkq;
+aamkr;
+aamks;
+aamkt;
+aamku;
+aamkv;
+aamkw;
+aamkx;
+aamky;
+aamkz;
+aamla;
+aamlb;
+aamlc;
+aamld;
+aamle;
+aamlf;
+aamlg;
+aamlh;
+aamli;
+aamlj;
+aamlk;
+aamll;
+aamlm;
+aamln;
+aamlo;
+aamlp;
+aamlq;
+aamlr;
+aamls;
+aamlt;
+aamlu;
+aamlv;
+aamlw;
+aamlx;
+aamly;
+aamlz;
+aamma;
+aammb;
+aammc;
+aammd;
+aamme;
+aammf;
+aammg;
+aammh;
+aammi;
+aammj;
+aammk;
+aamml;
+aammm;
+aammn;
+aammo;
+aammp;
+aammq;
+aammr;
+aamms;
+aammt;
+aammu;
+aammv;
+aammw;
+aammx;
+aammy;
+aammz;
+aamna;
+aamnb;
+aamnc;
+aamnd;
+aamne;
+aamnf;
+aamng;
+aamnh;
+aamni;
+aamnj;
+aamnk;
+aamnl;
+aamnm;
+aamnn;
+aamno;
+aamnp;
+aamnq;
+aamnr;
+aamns;
+aamnt;
+aamnu;
+aamnv;
+aamnw;
+aamnx;
+aamny;
+aamnz;
+aamoa;
+aamob;
+aamoc;
+aamod;
+aamoe;
+aamof;
+aamog;
+aamoh;
+aamoi;
+aamoj;
+aamok;
+aamol;
+aamom;
+aamon;
+aamoo;
+aamop;
+aamoq;
+aamor;
+aamos;
+aamot;
+aamou;
+aamov;
+aamow;
+aamox;
+aamoy;
+aamoz;
+aampa;
+aampb;
+aampc;
+aampd;
+aampe;
+aampf;
+aampg;
+aamph;
+aampi;
+aampj;
+aampk;
+aampl;
+aampm;
+aampn;
+aampo;
+aampp;
+aampq;
+aampr;
+aamps;
+aampt;
+aampu;
+aampv;
+aampw;
+aampx;
+aampy;
+aampz;
+aamqa;
+aamqb;
+aamqc;
+aamqd;
+aamqe;
+aamqf;
+aamqg;
+aamqh;
+aamqi;
+aamqj;
+aamqk;
+aamql;
+aamqm;
+aamqn;
+aamqo;
+aamqp;
+aamqq;
+aamqr;
+aamqs;
+aamqt;
+aamqu;
+aamqv;
+aamqw;
+aamqx;
+aamqy;
+aamqz;
+aamra;
+aamrb;
+aamrc;
+aamrd;
+aamre;
+aamrf;
+aamrg;
+aamrh;
+aamri;
+aamrj;
+aamrk;
+aamrl;
+aamrm;
+aamrn;
+aamro;
+aamrp;
+aamrq;
+aamrr;
+aamrs;
+aamrt;
+aamru;
+aamrv;
+aamrw;
+aamrx;
+aamry;
+aamrz;
+aamsa;
+aamsb;
+aamsc;
+aamsd;
+aamse;
+aamsf;
+aamsg;
+aamsh;
+aamsi;
+aamsj;
+aamsk;
+aamsl;
+aamsm;
+aamsn;
+aamso;
+aamsp;
+aamsq;
+aamsr;
+aamss;
+aamst;
+aamsu;
+aamsv;
+aamsw;
+aamsx;
+aamsy;
+aamsz;
+aamta;
+aamtb;
+aamtc;
+aamtd;
+aamte;
+aamtf;
+aamtg;
+aamth;
+aamti;
+aamtj;
+aamtk;
+aamtl;
+aamtm;
+aamtn;
+aamto;
+aamtp;
+aamtq;
+aamtr;
+aamts;
+aamtt;
+aamtu;
+aamtv;
+aamtw;
+aamtx;
+aamty;
+aamtz;
+aamua;
+aamub;
+aamuc;
+aamud;
+aamue;
+aamuf;
+aamug;
+aamuh;
+aamui;
+aamuj;
+aamuk;
+aamul;
+aamum;
+aamun;
+aamuo;
+aamup;
+aamuq;
+aamur;
+aamus;
+aamut;
+aamuu;
+aamuv;
+aamuw;
+aamux;
+aamuy;
+aamuz;
+aamva;
+aamvb;
+aamvc;
+aamvd;
+aamve;
+aamvf;
+aamvg;
+aamvh;
+aamvi;
+aamvj;
+aamvk;
+aamvl;
+aamvm;
+aamvn;
+aamvo;
+aamvp;
+aamvq;
+aamvr;
+aamvs;
+aamvt;
+aamvu;
+aamvv;
+aamvw;
+aamvx;
+aamvy;
+aamvz;
+aamwa;
+aamwb;
+aamwc;
+aamwd;
+aamwe;
+aamwf;
+aamwg;
+aamwh;
+aamwi;
+aamwj;
+aamwk;
+aamwl;
+aamwm;
+aamwn;
+aamwo;
+aamwp;
+aamwq;
+aamwr;
+aamws;
+aamwt;
+aamwu;
+aamwv;
+aamww;
+aamwx;
+aamwy;
+aamwz;
+aamxa;
+aamxb;
+aamxc;
+aamxd;
+aamxe;
+aamxf;
+aamxg;
+aamxh;
+aamxi;
+aamxj;
+aamxk;
+aamxl;
+aamxm;
+aamxn;
+aamxo;
+aamxp;
+aamxq;
+aamxr;
+aamxs;
+aamxt;
+aamxu;
+aamxv;
+aamxw;
+aamxx;
+aamxy;
+aamxz;
+aamya;
+aamyb;
+aamyc;
+aamyd;
+aamye;
+aamyf;
+aamyg;
+aamyh;
+aamyi;
+aamyj;
+aamyk;
+aamyl;
+aamym;
+aamyn;
+aamyo;
+aamyp;
+aamyq;
+aamyr;
+aamys;
+aamyt;
+aamyu;
+aamyv;
+aamyw;
+aamyx;
+aamyy;
+aamyz;
+aamza;
+aamzb;
+aamzc;
+aamzd;
+aamze;
+aamzf;
+aamzg;
+aamzh;
+aamzi;
+aamzj;
+aamzk;
+aamzl;
+aamzm;
+aamzn;
+aamzo;
+aamzp;
+aamzq;
+aamzr;
+aamzs;
+aamzt;
+aamzu;
+aamzv;
+aamzw;
+aamzx;
+aamzy;
+aamzz;
+aanaa;
+aanab;
+aanac;
+aanad;
+aanae;
+aanaf;
+aanag;
+aanah;
+aanai;
+aanaj;
+aanak;
+aanal;
+aanam;
+aanan;
+aanao;
+aanap;
+aanaq;
+aanar;
+aanas;
+aanat;
+aanau;
+aanav;
+aanaw;
+aanax;
+aanay;
+aanaz;
+aanba;
+aanbb;
+aanbc;
+aanbd;
+aanbe;
+aanbf;
+aanbg;
+aanbh;
+aanbi;
+aanbj;
+aanbk;
+aanbl;
+aanbm;
+aanbn;
+aanbo;
+aanbp;
+aanbq;
+aanbr;
+aanbs;
+aanbt;
+aanbu;
+aanbv;
+aanbw;
+aanbx;
+aanby;
+aanbz;
+aanca;
+aancb;
+aancc;
+aancd;
+aance;
+aancf;
+aancg;
+aanch;
+aanci;
+aancj;
+aanck;
+aancl;
+aancm;
+aancn;
+aanco;
+aancp;
+aancq;
+aancr;
+aancs;
+aanct;
+aancu;
+aancv;
+aancw;
+aancx;
+aancy;
+aancz;
+aanda;
+aandb;
+aandc;
+aandd;
+aande;
+aandf;
+aandg;
+aandh;
+aandi;
+aandj;
+aandk;
+aandl;
+aandm;
+aandn;
+aando;
+aandp;
+aandq;
+aandr;
+aands;
+aandt;
+aandu;
+aandv;
+aandw;
+aandx;
+aandy;
+aandz;
+aanea;
+aaneb;
+aanec;
+aaned;
+aanee;
+aanef;
+aaneg;
+aaneh;
+aanei;
+aanej;
+aanek;
+aanel;
+aanem;
+aanen;
+aaneo;
+aanep;
+aaneq;
+aaner;
+aanes;
+aanet;
+aaneu;
+aanev;
+aanew;
+aanex;
+aaney;
+aanez;
+aanfa;
+aanfb;
+aanfc;
+aanfd;
+aanfe;
+aanff;
+aanfg;
+aanfh;
+aanfi;
+aanfj;
+aanfk;
+aanfl;
+aanfm;
+aanfn;
+aanfo;
+aanfp;
+aanfq;
+aanfr;
+aanfs;
+aanft;
+aanfu;
+aanfv;
+aanfw;
+aanfx;
+aanfy;
+aanfz;
+aanga;
+aangb;
+aangc;
+aangd;
+aange;
+aangf;
+aangg;
+aangh;
+aangi;
+aangj;
+aangk;
+aangl;
+aangm;
+aangn;
+aango;
+aangp;
+aangq;
+aangr;
+aangs;
+aangt;
+aangu;
+aangv;
+aangw;
+aangx;
+aangy;
+aangz;
+aanha;
+aanhb;
+aanhc;
+aanhd;
+aanhe;
+aanhf;
+aanhg;
+aanhh;
+aanhi;
+aanhj;
+aanhk;
+aanhl;
+aanhm;
+aanhn;
+aanho;
+aanhp;
+aanhq;
+aanhr;
+aanhs;
+aanht;
+aanhu;
+aanhv;
+aanhw;
+aanhx;
+aanhy;
+aanhz;
+aania;
+aanib;
+aanic;
+aanid;
+aanie;
+aanif;
+aanig;
+aanih;
+aanii;
+aanij;
+aanik;
+aanil;
+aanim;
+aanin;
+aanio;
+aanip;
+aaniq;
+aanir;
+aanis;
+aanit;
+aaniu;
+aaniv;
+aaniw;
+aanix;
+aaniy;
+aaniz;
+aanja;
+aanjb;
+aanjc;
+aanjd;
+aanje;
+aanjf;
+aanjg;
+aanjh;
+aanji;
+aanjj;
+aanjk;
+aanjl;
+aanjm;
+aanjn;
+aanjo;
+aanjp;
+aanjq;
+aanjr;
+aanjs;
+aanjt;
+aanju;
+aanjv;
+aanjw;
+aanjx;
+aanjy;
+aanjz;
+aanka;
+aankb;
+aankc;
+aankd;
+aanke;
+aankf;
+aankg;
+aankh;
+aanki;
+aankj;
+aankk;
+aankl;
+aankm;
+aankn;
+aanko;
+aankp;
+aankq;
+aankr;
+aanks;
+aankt;
+aanku;
+aankv;
+aankw;
+aankx;
+aanky;
+aankz;
+aanla;
+aanlb;
+aanlc;
+aanld;
+aanle;
+aanlf;
+aanlg;
+aanlh;
+aanli;
+aanlj;
+aanlk;
+aanll;
+aanlm;
+aanln;
+aanlo;
+aanlp;
+aanlq;
+aanlr;
+aanls;
+aanlt;
+aanlu;
+aanlv;
+aanlw;
+aanlx;
+aanly;
+aanlz;
+aanma;
+aanmb;
+aanmc;
+aanmd;
+aanme;
+aanmf;
+aanmg;
+aanmh;
+aanmi;
+aanmj;
+aanmk;
+aanml;
+aanmm;
+aanmn;
+aanmo;
+aanmp;
+aanmq;
+aanmr;
+aanms;
+aanmt;
+aanmu;
+aanmv;
+aanmw;
+aanmx;
+aanmy;
+aanmz;
+aanna;
+aannb;
+aannc;
+aannd;
+aanne;
+aannf;
+aanng;
+aannh;
+aanni;
+aannj;
+aannk;
+aannl;
+aannm;
+aannn;
+aanno;
+aannp;
+aannq;
+aannr;
+aanns;
+aannt;
+aannu;
+aannv;
+aannw;
+aannx;
+aanny;
+aannz;
+aanoa;
+aanob;
+aanoc;
+aanod;
+aanoe;
+aanof;
+aanog;
+aanoh;
+aanoi;
+aanoj;
+aanok;
+aanol;
+aanom;
+aanon;
+aanoo;
+aanop;
+aanoq;
+aanor;
+aanos;
+aanot;
+aanou;
+aanov;
+aanow;
+aanox;
+aanoy;
+aanoz;
+aanpa;
+aanpb;
+aanpc;
+aanpd;
+aanpe;
+aanpf;
+aanpg;
+aanph;
+aanpi;
+aanpj;
+aanpk;
+aanpl;
+aanpm;
+aanpn;
+aanpo;
+aanpp;
+aanpq;
+aanpr;
+aanps;
+aanpt;
+aanpu;
+aanpv;
+aanpw;
+aanpx;
+aanpy;
+aanpz;
+aanqa;
+aanqb;
+aanqc;
+aanqd;
+aanqe;
+aanqf;
+aanqg;
+aanqh;
+aanqi;
+aanqj;
+aanqk;
+aanql;
+aanqm;
+aanqn;
+aanqo;
+aanqp;
+aanqq;
+aanqr;
+aanqs;
+aanqt;
+aanqu;
+aanqv;
+aanqw;
+aanqx;
+aanqy;
+aanqz;
+aanra;
+aanrb;
+aanrc;
+aanrd;
+aanre;
+aanrf;
+aanrg;
+aanrh;
+aanri;
+aanrj;
+aanrk;
+aanrl;
+aanrm;
+aanrn;
+aanro;
+aanrp;
+aanrq;
+aanrr;
+aanrs;
+aanrt;
+aanru;
+aanrv;
+aanrw;
+aanrx;
+aanry;
+aanrz;
+aansa;
+aansb;
+aansc;
+aansd;
+aanse;
+aansf;
+aansg;
+aansh;
+aansi;
+aansj;
+aansk;
+aansl;
+aansm;
+aansn;
+aanso;
+aansp;
+aansq;
+aansr;
+aanss;
+aanst;
+aansu;
+aansv;
+aansw;
+aansx;
+aansy;
+aansz;
+aanta;
+aantb;
+aantc;
+aantd;
+aante;
+aantf;
+aantg;
+aanth;
+aanti;
+aantj;
+aantk;
+aantl;
+aantm;
+aantn;
+aanto;
+aantp;
+aantq;
+aantr;
+aants;
+aantt;
+aantu;
+aantv;
+aantw;
+aantx;
+aanty;
+aantz;
+aanua;
+aanub;
+aanuc;
+aanud;
+aanue;
+aanuf;
+aanug;
+aanuh;
+aanui;
+aanuj;
+aanuk;
+aanul;
+aanum;
+aanun;
+aanuo;
+aanup;
+aanuq;
+aanur;
+aanus;
+aanut;
+aanuu;
+aanuv;
+aanuw;
+aanux;
+aanuy;
+aanuz;
+aanva;
+aanvb;
+aanvc;
+aanvd;
+aanve;
+aanvf;
+aanvg;
+aanvh;
+aanvi;
+aanvj;
+aanvk;
+aanvl;
+aanvm;
+aanvn;
+aanvo;
+aanvp;
+aanvq;
+aanvr;
+aanvs;
+aanvt;
+aanvu;
+aanvv;
+aanvw;
+aanvx;
+aanvy;
+aanvz;
+aanwa;
+aanwb;
+aanwc;
+aanwd;
+aanwe;
+aanwf;
+aanwg;
+aanwh;
+aanwi;
+aanwj;
+aanwk;
+aanwl;
+aanwm;
+aanwn;
+aanwo;
+aanwp;
+aanwq;
+aanwr;
+aanws;
+aanwt;
+aanwu;
+aanwv;
+aanww;
+aanwx;
+aanwy;
+aanwz;
+aanxa;
+aanxb;
+aanxc;
+aanxd;
+aanxe;
+aanxf;
+aanxg;
+aanxh;
+aanxi;
+aanxj;
+aanxk;
+aanxl;
+aanxm;
+aanxn;
+aanxo;
+aanxp;
+aanxq;
+aanxr;
+aanxs;
+aanxt;
+aanxu;
+aanxv;
+aanxw;
+aanxx;
+aanxy;
+aanxz;
+aanya;
+aanyb;
+aanyc;
+aanyd;
+aanye;
+aanyf;
+aanyg;
+aanyh;
+aanyi;
+aanyj;
+aanyk;
+aanyl;
+aanym;
+aanyn;
+aanyo;
+aanyp;
+aanyq;
+aanyr;
+aanys;
+aanyt;
+aanyu;
+aanyv;
+aanyw;
+aanyx;
+aanyy;
+aanyz;
+aanza;
+aanzb;
+aanzc;
+aanzd;
+aanze;
+aanzf;
+aanzg;
+aanzh;
+aanzi;
+aanzj;
+aanzk;
+aanzl;
+aanzm;
+aanzn;
+aanzo;
+aanzp;
+aanzq;
+aanzr;
+aanzs;
+aanzt;
+aanzu;
+aanzv;
+aanzw;
+aanzx;
+aanzy;
+aanzz;
+aaoaa;
+aaoab;
+aaoac;
+aaoad;
+aaoae;
+aaoaf;
+aaoag;
+aaoah;
+aaoai;
+aaoaj;
+aaoak;
+aaoal;
+aaoam;
+aaoan;
+aaoao;
+aaoap;
+aaoaq;
+aaoar;
+aaoas;
+aaoat;
+aaoau;
+aaoav;
+aaoaw;
+aaoax;
+aaoay;
+aaoaz;
+aaoba;
+aaobb;
+aaobc;
+aaobd;
+aaobe;
+aaobf;
+aaobg;
+aaobh;
+aaobi;
+aaobj;
+aaobk;
+aaobl;
+aaobm;
+aaobn;
+aaobo;
+aaobp;
+aaobq;
+aaobr;
+aaobs;
+aaobt;
+aaobu;
+aaobv;
+aaobw;
+aaobx;
+aaoby;
+aaobz;
+aaoca;
+aaocb;
+aaocc;
+aaocd;
+aaoce;
+aaocf;
+aaocg;
+aaoch;
+aaoci;
+aaocj;
+aaock;
+aaocl;
+aaocm;
+aaocn;
+aaoco;
+aaocp;
+aaocq;
+aaocr;
+aaocs;
+aaoct;
+aaocu;
+aaocv;
+aaocw;
+aaocx;
+aaocy;
+aaocz;
+aaoda;
+aaodb;
+aaodc;
+aaodd;
+aaode;
+aaodf;
+aaodg;
+aaodh;
+aaodi;
+aaodj;
+aaodk;
+aaodl;
+aaodm;
+aaodn;
+aaodo;
+aaodp;
+aaodq;
+aaodr;
+aaods;
+aaodt;
+aaodu;
+aaodv;
+aaodw;
+aaodx;
+aaody;
+aaodz;
+aaoea;
+aaoeb;
+aaoec;
+aaoed;
+aaoee;
+aaoef;
+aaoeg;
+aaoeh;
+aaoei;
+aaoej;
+aaoek;
+aaoel;
+aaoem;
+aaoen;
+aaoeo;
+aaoep;
+aaoeq;
+aaoer;
+aaoes;
+aaoet;
+aaoeu;
+aaoev;
+aaoew;
+aaoex;
+aaoey;
+aaoez;
+aaofa;
+aaofb;
+aaofc;
+aaofd;
+aaofe;
+aaoff;
+aaofg;
+aaofh;
+aaofi;
+aaofj;
+aaofk;
+aaofl;
+aaofm;
+aaofn;
+aaofo;
+aaofp;
+aaofq;
+aaofr;
+aaofs;
+aaoft;
+aaofu;
+aaofv;
+aaofw;
+aaofx;
+aaofy;
+aaofz;
+aaoga;
+aaogb;
+aaogc;
+aaogd;
+aaoge;
+aaogf;
+aaogg;
+aaogh;
+aaogi;
+aaogj;
+aaogk;
+aaogl;
+aaogm;
+aaogn;
+aaogo;
+aaogp;
+aaogq;
+aaogr;
+aaogs;
+aaogt;
+aaogu;
+aaogv;
+aaogw;
+aaogx;
+aaogy;
+aaogz;
+aaoha;
+aaohb;
+aaohc;
+aaohd;
+aaohe;
+aaohf;
+aaohg;
+aaohh;
+aaohi;
+aaohj;
+aaohk;
+aaohl;
+aaohm;
+aaohn;
+aaoho;
+aaohp;
+aaohq;
+aaohr;
+aaohs;
+aaoht;
+aaohu;
+aaohv;
+aaohw;
+aaohx;
+aaohy;
+aaohz;
+aaoia;
+aaoib;
+aaoic;
+aaoid;
+aaoie;
+aaoif;
+aaoig;
+aaoih;
+aaoii;
+aaoij;
+aaoik;
+aaoil;
+aaoim;
+aaoin;
+aaoio;
+aaoip;
+aaoiq;
+aaoir;
+aaois;
+aaoit;
+aaoiu;
+aaoiv;
+aaoiw;
+aaoix;
+aaoiy;
+aaoiz;
+aaoja;
+aaojb;
+aaojc;
+aaojd;
+aaoje;
+aaojf;
+aaojg;
+aaojh;
+aaoji;
+aaojj;
+aaojk;
+aaojl;
+aaojm;
+aaojn;
+aaojo;
+aaojp;
+aaojq;
+aaojr;
+aaojs;
+aaojt;
+aaoju;
+aaojv;
+aaojw;
+aaojx;
+aaojy;
+aaojz;
+aaoka;
+aaokb;
+aaokc;
+aaokd;
+aaoke;
+aaokf;
+aaokg;
+aaokh;
+aaoki;
+aaokj;
+aaokk;
+aaokl;
+aaokm;
+aaokn;
+aaoko;
+aaokp;
+aaokq;
+aaokr;
+aaoks;
+aaokt;
+aaoku;
+aaokv;
+aaokw;
+aaokx;
+aaoky;
+aaokz;
+aaola;
+aaolb;
+aaolc;
+aaold;
+aaole;
+aaolf;
+aaolg;
+aaolh;
+aaoli;
+aaolj;
+aaolk;
+aaoll;
+aaolm;
+aaoln;
+aaolo;
+aaolp;
+aaolq;
+aaolr;
+aaols;
+aaolt;
+aaolu;
+aaolv;
+aaolw;
+aaolx;
+aaoly;
+aaolz;
+aaoma;
+aaomb;
+aaomc;
+aaomd;
+aaome;
+aaomf;
+aaomg;
+aaomh;
+aaomi;
+aaomj;
+aaomk;
+aaoml;
+aaomm;
+aaomn;
+aaomo;
+aaomp;
+aaomq;
+aaomr;
+aaoms;
+aaomt;
+aaomu;
+aaomv;
+aaomw;
+aaomx;
+aaomy;
+aaomz;
+aaona;
+aaonb;
+aaonc;
+aaond;
+aaone;
+aaonf;
+aaong;
+aaonh;
+aaoni;
+aaonj;
+aaonk;
+aaonl;
+aaonm;
+aaonn;
+aaono;
+aaonp;
+aaonq;
+aaonr;
+aaons;
+aaont;
+aaonu;
+aaonv;
+aaonw;
+aaonx;
+aaony;
+aaonz;
+aaooa;
+aaoob;
+aaooc;
+aaood;
+aaooe;
+aaoof;
+aaoog;
+aaooh;
+aaooi;
+aaooj;
+aaook;
+aaool;
+aaoom;
+aaoon;
+aaooo;
+aaoop;
+aaooq;
+aaoor;
+aaoos;
+aaoot;
+aaoou;
+aaoov;
+aaoow;
+aaoox;
+aaooy;
+aaooz;
+aaopa;
+aaopb;
+aaopc;
+aaopd;
+aaope;
+aaopf;
+aaopg;
+aaoph;
+aaopi;
+aaopj;
+aaopk;
+aaopl;
+aaopm;
+aaopn;
+aaopo;
+aaopp;
+aaopq;
+aaopr;
+aaops;
+aaopt;
+aaopu;
+aaopv;
+aaopw;
+aaopx;
+aaopy;
+aaopz;
+aaoqa;
+aaoqb;
+aaoqc;
+aaoqd;
+aaoqe;
+aaoqf;
+aaoqg;
+aaoqh;
+aaoqi;
+aaoqj;
+aaoqk;
+aaoql;
+aaoqm;
+aaoqn;
+aaoqo;
+aaoqp;
+aaoqq;
+aaoqr;
+aaoqs;
+aaoqt;
+aaoqu;
+aaoqv;
+aaoqw;
+aaoqx;
+aaoqy;
+aaoqz;
+aaora;
+aaorb;
+aaorc;
+aaord;
+aaore;
+aaorf;
+aaorg;
+aaorh;
+aaori;
+aaorj;
+aaork;
+aaorl;
+aaorm;
+aaorn;
+aaoro;
+aaorp;
+aaorq;
+aaorr;
+aaors;
+aaort;
+aaoru;
+aaorv;
+aaorw;
+aaorx;
+aaory;
+aaorz;
+aaosa;
+aaosb;
+aaosc;
+aaosd;
+aaose;
+aaosf;
+aaosg;
+aaosh;
+aaosi;
+aaosj;
+aaosk;
+aaosl;
+aaosm;
+aaosn;
+aaoso;
+aaosp;
+aaosq;
+aaosr;
+aaoss;
+aaost;
+aaosu;
+aaosv;
+aaosw;
+aaosx;
+aaosy;
+aaosz;
+aaota;
+aaotb;
+aaotc;
+aaotd;
+aaote;
+aaotf;
+aaotg;
+aaoth;
+aaoti;
+aaotj;
+aaotk;
+aaotl;
+aaotm;
+aaotn;
+aaoto;
+aaotp;
+aaotq;
+aaotr;
+aaots;
+aaott;
+aaotu;
+aaotv;
+aaotw;
+aaotx;
+aaoty;
+aaotz;
+aaoua;
+aaoub;
+aaouc;
+aaoud;
+aaoue;
+aaouf;
+aaoug;
+aaouh;
+aaoui;
+aaouj;
+aaouk;
+aaoul;
+aaoum;
+aaoun;
+aaouo;
+aaoup;
+aaouq;
+aaour;
+aaous;
+aaout;
+aaouu;
+aaouv;
+aaouw;
+aaoux;
+aaouy;
+aaouz;
+aaova;
+aaovb;
+aaovc;
+aaovd;
+aaove;
+aaovf;
+aaovg;
+aaovh;
+aaovi;
+aaovj;
+aaovk;
+aaovl;
+aaovm;
+aaovn;
+aaovo;
+aaovp;
+aaovq;
+aaovr;
+aaovs;
+aaovt;
+aaovu;
+aaovv;
+aaovw;
+aaovx;
+aaovy;
+aaovz;
+aaowa;
+aaowb;
+aaowc;
+aaowd;
+aaowe;
+aaowf;
+aaowg;
+aaowh;
+aaowi;
+aaowj;
+aaowk;
+aaowl;
+aaowm;
+aaown;
+aaowo;
+aaowp;
+aaowq;
+aaowr;
+aaows;
+aaowt;
+aaowu;
+aaowv;
+aaoww;
+aaowx;
+aaowy;
+aaowz;
+aaoxa;
+aaoxb;
+aaoxc;
+aaoxd;
+aaoxe;
+aaoxf;
+aaoxg;
+aaoxh;
+aaoxi;
+aaoxj;
+aaoxk;
+aaoxl;
+aaoxm;
+aaoxn;
+aaoxo;
+aaoxp;
+aaoxq;
+aaoxr;
+aaoxs;
+aaoxt;
+aaoxu;
+aaoxv;
+aaoxw;
+aaoxx;
+aaoxy;
+aaoxz;
+aaoya;
+aaoyb;
+aaoyc;
+aaoyd;
+aaoye;
+aaoyf;
+aaoyg;
+aaoyh;
+aaoyi;
+aaoyj;
+aaoyk;
+aaoyl;
+aaoym;
+aaoyn;
+aaoyo;
+aaoyp;
+aaoyq;
+aaoyr;
+aaoys;
+aaoyt;
+aaoyu;
+aaoyv;
+aaoyw;
+aaoyx;
+aaoyy;
+aaoyz;
+aaoza;
+aaozb;
+aaozc;
+aaozd;
+aaoze;
+aaozf;
+aaozg;
+aaozh;
+aaozi;
+aaozj;
+aaozk;
+aaozl;
+aaozm;
+aaozn;
+aaozo;
+aaozp;
+aaozq;
+aaozr;
+aaozs;
+aaozt;
+aaozu;
+aaozv;
+aaozw;
+aaozx;
+aaozy;
+aaozz;
+aapaa;
+aapab;
+aapac;
+aapad;
+aapae;
+aapaf;
+aapag;
+aapah;
+aapai;
+aapaj;
+aapak;
+aapal;
+aapam;
+aapan;
+aapao;
+aapap;
+aapaq;
+aapar;
+aapas;
+aapat;
+aapau;
+aapav;
+aapaw;
+aapax;
+aapay;
+aapaz;
+aapba;
+aapbb;
+aapbc;
+aapbd;
+aapbe;
+aapbf;
+aapbg;
+aapbh;
+aapbi;
+aapbj;
+aapbk;
+aapbl;
+aapbm;
+aapbn;
+aapbo;
+aapbp;
+aapbq;
+aapbr;
+aapbs;
+aapbt;
+aapbu;
+aapbv;
+aapbw;
+aapbx;
+aapby;
+aapbz;
+aapca;
+aapcb;
+aapcc;
+aapcd;
+aapce;
+aapcf;
+aapcg;
+aapch;
+aapci;
+aapcj;
+aapck;
+aapcl;
+aapcm;
+aapcn;
+aapco;
+aapcp;
+aapcq;
+aapcr;
+aapcs;
+aapct;
+aapcu;
+aapcv;
+aapcw;
+aapcx;
+aapcy;
+aapcz;
+aapda;
+aapdb;
+aapdc;
+aapdd;
+aapde;
+aapdf;
+aapdg;
+aapdh;
+aapdi;
+aapdj;
+aapdk;
+aapdl;
+aapdm;
+aapdn;
+aapdo;
+aapdp;
+aapdq;
+aapdr;
+aapds;
+aapdt;
+aapdu;
+aapdv;
+aapdw;
+aapdx;
+aapdy;
+aapdz;
+aapea;
+aapeb;
+aapec;
+aaped;
+aapee;
+aapef;
+aapeg;
+aapeh;
+aapei;
+aapej;
+aapek;
+aapel;
+aapem;
+aapen;
+aapeo;
+aapep;
+aapeq;
+aaper;
+aapes;
+aapet;
+aapeu;
+aapev;
+aapew;
+aapex;
+aapey;
+aapez;
+aapfa;
+aapfb;
+aapfc;
+aapfd;
+aapfe;
+aapff;
+aapfg;
+aapfh;
+aapfi;
+aapfj;
+aapfk;
+aapfl;
+aapfm;
+aapfn;
+aapfo;
+aapfp;
+aapfq;
+aapfr;
+aapfs;
+aapft;
+aapfu;
+aapfv;
+aapfw;
+aapfx;
+aapfy;
+aapfz;
+aapga;
+aapgb;
+aapgc;
+aapgd;
+aapge;
+aapgf;
+aapgg;
+aapgh;
+aapgi;
+aapgj;
+aapgk;
+aapgl;
+aapgm;
+aapgn;
+aapgo;
+aapgp;
+aapgq;
+aapgr;
+aapgs;
+aapgt;
+aapgu;
+aapgv;
+aapgw;
+aapgx;
+aapgy;
+aapgz;
+aapha;
+aaphb;
+aaphc;
+aaphd;
+aaphe;
+aaphf;
+aaphg;
+aaphh;
+aaphi;
+aaphj;
+aaphk;
+aaphl;
+aaphm;
+aaphn;
+aapho;
+aaphp;
+aaphq;
+aaphr;
+aaphs;
+aapht;
+aaphu;
+aaphv;
+aaphw;
+aaphx;
+aaphy;
+aaphz;
+aapia;
+aapib;
+aapic;
+aapid;
+aapie;
+aapif;
+aapig;
+aapih;
+aapii;
+aapij;
+aapik;
+aapil;
+aapim;
+aapin;
+aapio;
+aapip;
+aapiq;
+aapir;
+aapis;
+aapit;
+aapiu;
+aapiv;
+aapiw;
+aapix;
+aapiy;
+aapiz;
+aapja;
+aapjb;
+aapjc;
+aapjd;
+aapje;
+aapjf;
+aapjg;
+aapjh;
+aapji;
+aapjj;
+aapjk;
+aapjl;
+aapjm;
+aapjn;
+aapjo;
+aapjp;
+aapjq;
+aapjr;
+aapjs;
+aapjt;
+aapju;
+aapjv;
+aapjw;
+aapjx;
+aapjy;
+aapjz;
+aapka;
+aapkb;
+aapkc;
+aapkd;
+aapke;
+aapkf;
+aapkg;
+aapkh;
+aapki;
+aapkj;
+aapkk;
+aapkl;
+aapkm;
+aapkn;
+aapko;
+aapkp;
+aapkq;
+aapkr;
+aapks;
+aapkt;
+aapku;
+aapkv;
+aapkw;
+aapkx;
+aapky;
+aapkz;
+aapla;
+aaplb;
+aaplc;
+aapld;
+aaple;
+aaplf;
+aaplg;
+aaplh;
+aapli;
+aaplj;
+aaplk;
+aapll;
+aaplm;
+aapln;
+aaplo;
+aaplp;
+aaplq;
+aaplr;
+aapls;
+aaplt;
+aaplu;
+aaplv;
+aaplw;
+aaplx;
+aaply;
+aaplz;
+aapma;
+aapmb;
+aapmc;
+aapmd;
+aapme;
+aapmf;
+aapmg;
+aapmh;
+aapmi;
+aapmj;
+aapmk;
+aapml;
+aapmm;
+aapmn;
+aapmo;
+aapmp;
+aapmq;
+aapmr;
+aapms;
+aapmt;
+aapmu;
+aapmv;
+aapmw;
+aapmx;
+aapmy;
+aapmz;
+aapna;
+aapnb;
+aapnc;
+aapnd;
+aapne;
+aapnf;
+aapng;
+aapnh;
+aapni;
+aapnj;
+aapnk;
+aapnl;
+aapnm;
+aapnn;
+aapno;
+aapnp;
+aapnq;
+aapnr;
+aapns;
+aapnt;
+aapnu;
+aapnv;
+aapnw;
+aapnx;
+aapny;
+aapnz;
+aapoa;
+aapob;
+aapoc;
+aapod;
+aapoe;
+aapof;
+aapog;
+aapoh;
+aapoi;
+aapoj;
+aapok;
+aapol;
+aapom;
+aapon;
+aapoo;
+aapop;
+aapoq;
+aapor;
+aapos;
+aapot;
+aapou;
+aapov;
+aapow;
+aapox;
+aapoy;
+aapoz;
+aappa;
+aappb;
+aappc;
+aappd;
+aappe;
+aappf;
+aappg;
+aapph;
+aappi;
+aappj;
+aappk;
+aappl;
+aappm;
+aappn;
+aappo;
+aappp;
+aappq;
+aappr;
+aapps;
+aappt;
+aappu;
+aappv;
+aappw;
+aappx;
+aappy;
+aappz;
+aapqa;
+aapqb;
+aapqc;
+aapqd;
+aapqe;
+aapqf;
+aapqg;
+aapqh;
+aapqi;
+aapqj;
+aapqk;
+aapql;
+aapqm;
+aapqn;
+aapqo;
+aapqp;
+aapqq;
+aapqr;
+aapqs;
+aapqt;
+aapqu;
+aapqv;
+aapqw;
+aapqx;
+aapqy;
+aapqz;
+aapra;
+aaprb;
+aaprc;
+aaprd;
+aapre;
+aaprf;
+aaprg;
+aaprh;
+aapri;
+aaprj;
+aaprk;
+aaprl;
+aaprm;
+aaprn;
+aapro;
+aaprp;
+aaprq;
+aaprr;
+aaprs;
+aaprt;
+aapru;
+aaprv;
+aaprw;
+aaprx;
+aapry;
+aaprz;
+aapsa;
+aapsb;
+aapsc;
+aapsd;
+aapse;
+aapsf;
+aapsg;
+aapsh;
+aapsi;
+aapsj;
+aapsk;
+aapsl;
+aapsm;
+aapsn;
+aapso;
+aapsp;
+aapsq;
+aapsr;
+aapss;
+aapst;
+aapsu;
+aapsv;
+aapsw;
+aapsx;
+aapsy;
+aapsz;
+aapta;
+aaptb;
+aaptc;
+aaptd;
+aapte;
+aaptf;
+aaptg;
+aapth;
+aapti;
+aaptj;
+aaptk;
+aaptl;
+aaptm;
+aaptn;
+aapto;
+aaptp;
+aaptq;
+aaptr;
+aapts;
+aaptt;
+aaptu;
+aaptv;
+aaptw;
+aaptx;
+aapty;
+aaptz;
+aapua;
+aapub;
+aapuc;
+aapud;
+aapue;
+aapuf;
+aapug;
+aapuh;
+aapui;
+aapuj;
+aapuk;
+aapul;
+aapum;
+aapun;
+aapuo;
+aapup;
+aapuq;
+aapur;
+aapus;
+aaput;
+aapuu;
+aapuv;
+aapuw;
+aapux;
+aapuy;
+aapuz;
+aapva;
+aapvb;
+aapvc;
+aapvd;
+aapve;
+aapvf;
+aapvg;
+aapvh;
+aapvi;
+aapvj;
+aapvk;
+aapvl;
+aapvm;
+aapvn;
+aapvo;
+aapvp;
+aapvq;
+aapvr;
+aapvs;
+aapvt;
+aapvu;
+aapvv;
+aapvw;
+aapvx;
+aapvy;
+aapvz;
+aapwa;
+aapwb;
+aapwc;
+aapwd;
+aapwe;
+aapwf;
+aapwg;
+aapwh;
+aapwi;
+aapwj;
+aapwk;
+aapwl;
+aapwm;
+aapwn;
+aapwo;
+aapwp;
+aapwq;
+aapwr;
+aapws;
+aapwt;
+aapwu;
+aapwv;
+aapww;
+aapwx;
+aapwy;
+aapwz;
+aapxa;
+aapxb;
+aapxc;
+aapxd;
+aapxe;
+aapxf;
+aapxg;
+aapxh;
+aapxi;
+aapxj;
+aapxk;
+aapxl;
+aapxm;
+aapxn;
+aapxo;
+aapxp;
+aapxq;
+aapxr;
+aapxs;
+aapxt;
+aapxu;
+aapxv;
+aapxw;
+aapxx;
+aapxy;
+aapxz;
+aapya;
+aapyb;
+aapyc;
+aapyd;
+aapye;
+aapyf;
+aapyg;
+aapyh;
+aapyi;
+aapyj;
+aapyk;
+aapyl;
+aapym;
+aapyn;
+aapyo;
+aapyp;
+aapyq;
+aapyr;
+aapys;
+aapyt;
+aapyu;
+aapyv;
+aapyw;
+aapyx;
+aapyy;
+aapyz;
+aapza;
+aapzb;
+aapzc;
+aapzd;
+aapze;
+aapzf;
+aapzg;
+aapzh;
+aapzi;
+aapzj;
+aapzk;
+aapzl;
+aapzm;
+aapzn;
+aapzo;
+aapzp;
+aapzq;
+aapzr;
+aapzs;
+aapzt;
+aapzu;
+aapzv;
+aapzw;
+aapzx;
+aapzy;
+aapzz;
+aaqaa;
+aaqab;
+aaqac;
+aaqad;
+aaqae;
+aaqaf;
+aaqag;
+aaqah;
+aaqai;
+aaqaj;
+aaqak;
+aaqal;
+aaqam;
+aaqan;
+aaqao;
+aaqap;
+aaqaq;
+aaqar;
+aaqas;
+aaqat;
+aaqau;
+aaqav;
+aaqaw;
+aaqax;
+aaqay;
+aaqaz;
+aaqba;
+aaqbb;
+aaqbc;
+aaqbd;
+aaqbe;
+aaqbf;
+aaqbg;
+aaqbh;
+aaqbi;
+aaqbj;
+aaqbk;
+aaqbl;
+aaqbm;
+aaqbn;
+aaqbo;
+aaqbp;
+aaqbq;
+aaqbr;
+aaqbs;
+aaqbt;
+aaqbu;
+aaqbv;
+aaqbw;
+aaqbx;
+aaqby;
+aaqbz;
+aaqca;
+aaqcb;
+aaqcc;
+aaqcd;
+aaqce;
+aaqcf;
+aaqcg;
+aaqch;
+aaqci;
+aaqcj;
+aaqck;
+aaqcl;
+aaqcm;
+aaqcn;
+aaqco;
+aaqcp;
+aaqcq;
+aaqcr;
+aaqcs;
+aaqct;
+aaqcu;
+aaqcv;
+aaqcw;
+aaqcx;
+aaqcy;
+aaqcz;
+aaqda;
+aaqdb;
+aaqdc;
+aaqdd;
+aaqde;
+aaqdf;
+aaqdg;
+aaqdh;
+aaqdi;
+aaqdj;
+aaqdk;
+aaqdl;
+aaqdm;
+aaqdn;
+aaqdo;
+aaqdp;
+aaqdq;
+aaqdr;
+aaqds;
+aaqdt;
+aaqdu;
+aaqdv;
+aaqdw;
+aaqdx;
+aaqdy;
+aaqdz;
+aaqea;
+aaqeb;
+aaqec;
+aaqed;
+aaqee;
+aaqef;
+aaqeg;
+aaqeh;
+aaqei;
+aaqej;
+aaqek;
+aaqel;
+aaqem;
+aaqen;
+aaqeo;
+aaqep;
+aaqeq;
+aaqer;
+aaqes;
+aaqet;
+aaqeu;
+aaqev;
+aaqew;
+aaqex;
+aaqey;
+aaqez;
+aaqfa;
+aaqfb;
+aaqfc;
+aaqfd;
+aaqfe;
+aaqff;
+aaqfg;
+aaqfh;
+aaqfi;
+aaqfj;
+aaqfk;
+aaqfl;
+aaqfm;
+aaqfn;
+aaqfo;
+aaqfp;
+aaqfq;
+aaqfr;
+aaqfs;
+aaqft;
+aaqfu;
+aaqfv;
+aaqfw;
+aaqfx;
+aaqfy;
+aaqfz;
+aaqga;
+aaqgb;
+aaqgc;
+aaqgd;
+aaqge;
+aaqgf;
+aaqgg;
+aaqgh;
+aaqgi;
+aaqgj;
+aaqgk;
+aaqgl;
+aaqgm;
+aaqgn;
+aaqgo;
+aaqgp;
+aaqgq;
+aaqgr;
+aaqgs;
+aaqgt;
+aaqgu;
+aaqgv;
+aaqgw;
+aaqgx;
+aaqgy;
+aaqgz;
+aaqha;
+aaqhb;
+aaqhc;
+aaqhd;
+aaqhe;
+aaqhf;
+aaqhg;
+aaqhh;
+aaqhi;
+aaqhj;
+aaqhk;
+aaqhl;
+aaqhm;
+aaqhn;
+aaqho;
+aaqhp;
+aaqhq;
+aaqhr;
+aaqhs;
+aaqht;
+aaqhu;
+aaqhv;
+aaqhw;
+aaqhx;
+aaqhy;
+aaqhz;
+aaqia;
+aaqib;
+aaqic;
+aaqid;
+aaqie;
+aaqif;
+aaqig;
+aaqih;
+aaqii;
+aaqij;
+aaqik;
+aaqil;
+aaqim;
+aaqin;
+aaqio;
+aaqip;
+aaqiq;
+aaqir;
+aaqis;
+aaqit;
+aaqiu;
+aaqiv;
+aaqiw;
+aaqix;
+aaqiy;
+aaqiz;
+aaqja;
+aaqjb;
+aaqjc;
+aaqjd;
+aaqje;
+aaqjf;
+aaqjg;
+aaqjh;
+aaqji;
+aaqjj;
+aaqjk;
+aaqjl;
+aaqjm;
+aaqjn;
+aaqjo;
+aaqjp;
+aaqjq;
+aaqjr;
+aaqjs;
+aaqjt;
+aaqju;
+aaqjv;
+aaqjw;
+aaqjx;
+aaqjy;
+aaqjz;
+aaqka;
+aaqkb;
+aaqkc;
+aaqkd;
+aaqke;
+aaqkf;
+aaqkg;
+aaqkh;
+aaqki;
+aaqkj;
+aaqkk;
+aaqkl;
+aaqkm;
+aaqkn;
+aaqko;
+aaqkp;
+aaqkq;
+aaqkr;
+aaqks;
+aaqkt;
+aaqku;
+aaqkv;
+aaqkw;
+aaqkx;
+aaqky;
+aaqkz;
+aaqla;
+aaqlb;
+aaqlc;
+aaqld;
+aaqle;
+aaqlf;
+aaqlg;
+aaqlh;
+aaqli;
+aaqlj;
+aaqlk;
+aaqll;
+aaqlm;
+aaqln;
+aaqlo;
+aaqlp;
+aaqlq;
+aaqlr;
+aaqls;
+aaqlt;
+aaqlu;
+aaqlv;
+aaqlw;
+aaqlx;
+aaqly;
+aaqlz;
+aaqma;
+aaqmb;
+aaqmc;
+aaqmd;
+aaqme;
+aaqmf;
+aaqmg;
+aaqmh;
+aaqmi;
+aaqmj;
+aaqmk;
+aaqml;
+aaqmm;
+aaqmn;
+aaqmo;
+aaqmp;
+aaqmq;
+aaqmr;
+aaqms;
+aaqmt;
+aaqmu;
+aaqmv;
+aaqmw;
+aaqmx;
+aaqmy;
+aaqmz;
+aaqna;
+aaqnb;
+aaqnc;
+aaqnd;
+aaqne;
+aaqnf;
+aaqng;
+aaqnh;
+aaqni;
+aaqnj;
+aaqnk;
+aaqnl;
+aaqnm;
+aaqnn;
+aaqno;
+aaqnp;
+aaqnq;
+aaqnr;
+aaqns;
+aaqnt;
+aaqnu;
+aaqnv;
+aaqnw;
+aaqnx;
+aaqny;
+aaqnz;
+aaqoa;
+aaqob;
+aaqoc;
+aaqod;
+aaqoe;
+aaqof;
+aaqog;
+aaqoh;
+aaqoi;
+aaqoj;
+aaqok;
+aaqol;
+aaqom;
+aaqon;
+aaqoo;
+aaqop;
+aaqoq;
+aaqor;
+aaqos;
+aaqot;
+aaqou;
+aaqov;
+aaqow;
+aaqox;
+aaqoy;
+aaqoz;
+aaqpa;
+aaqpb;
+aaqpc;
+aaqpd;
+aaqpe;
+aaqpf;
+aaqpg;
+aaqph;
+aaqpi;
+aaqpj;
+aaqpk;
+aaqpl;
+aaqpm;
+aaqpn;
+aaqpo;
+aaqpp;
+aaqpq;
+aaqpr;
+aaqps;
+aaqpt;
+aaqpu;
+aaqpv;
+aaqpw;
+aaqpx;
+aaqpy;
+aaqpz;
+aaqqa;
+aaqqb;
+aaqqc;
+aaqqd;
+aaqqe;
+aaqqf;
+aaqqg;
+aaqqh;
+aaqqi;
+aaqqj;
+aaqqk;
+aaqql;
+aaqqm;
+aaqqn;
+aaqqo;
+aaqqp;
+aaqqq;
+aaqqr;
+aaqqs;
+aaqqt;
+aaqqu;
+aaqqv;
+aaqqw;
+aaqqx;
+aaqqy;
+aaqqz;
+aaqra;
+aaqrb;
+aaqrc;
+aaqrd;
+aaqre;
+aaqrf;
+aaqrg;
+aaqrh;
+aaqri;
+aaqrj;
+aaqrk;
+aaqrl;
+aaqrm;
+aaqrn;
+aaqro;
+aaqrp;
+aaqrq;
+aaqrr;
+aaqrs;
+aaqrt;
+aaqru;
+aaqrv;
+aaqrw;
+aaqrx;
+aaqry;
+aaqrz;
+aaqsa;
+aaqsb;
+aaqsc;
+aaqsd;
+aaqse;
+aaqsf;
+aaqsg;
+aaqsh;
+aaqsi;
+aaqsj;
+aaqsk;
+aaqsl;
+aaqsm;
+aaqsn;
+aaqso;
+aaqsp;
+aaqsq;
+aaqsr;
+aaqss;
+aaqst;
+aaqsu;
+aaqsv;
+aaqsw;
+aaqsx;
+aaqsy;
+aaqsz;
+aaqta;
+aaqtb;
+aaqtc;
+aaqtd;
+aaqte;
+aaqtf;
+aaqtg;
+aaqth;
+aaqti;
+aaqtj;
+aaqtk;
+aaqtl;
+aaqtm;
+aaqtn;
+aaqto;
+aaqtp;
+aaqtq;
+aaqtr;
+aaqts;
+aaqtt;
+aaqtu;
+aaqtv;
+aaqtw;
+aaqtx;
+aaqty;
+aaqtz;
+aaqua;
+aaqub;
+aaquc;
+aaqud;
+aaque;
+aaquf;
+aaqug;
+aaquh;
+aaqui;
+aaquj;
+aaquk;
+aaqul;
+aaqum;
+aaqun;
+aaquo;
+aaqup;
+aaquq;
+aaqur;
+aaqus;
+aaqut;
+aaquu;
+aaquv;
+aaquw;
+aaqux;
+aaquy;
+aaquz;
+aaqva;
+aaqvb;
+aaqvc;
+aaqvd;
+aaqve;
+aaqvf;
+aaqvg;
+aaqvh;
+aaqvi;
+aaqvj;
+aaqvk;
+aaqvl;
+aaqvm;
+aaqvn;
+aaqvo;
+aaqvp;
+aaqvq;
+aaqvr;
+aaqvs;
+aaqvt;
+aaqvu;
+aaqvv;
+aaqvw;
+aaqvx;
+aaqvy;
+aaqvz;
+aaqwa;
+aaqwb;
+aaqwc;
+aaqwd;
+aaqwe;
+aaqwf;
+aaqwg;
+aaqwh;
+aaqwi;
+aaqwj;
+aaqwk;
+aaqwl;
+aaqwm;
+aaqwn;
+aaqwo;
+aaqwp;
+aaqwq;
+aaqwr;
+aaqws;
+aaqwt;
+aaqwu;
+aaqwv;
+aaqww;
+aaqwx;
+aaqwy;
+aaqwz;
+aaqxa;
+aaqxb;
+aaqxc;
+aaqxd;
+aaqxe;
+aaqxf;
+aaqxg;
+aaqxh;
+aaqxi;
+aaqxj;
+aaqxk;
+aaqxl;
+aaqxm;
+aaqxn;
+aaqxo;
+aaqxp;
+aaqxq;
+aaqxr;
+aaqxs;
+aaqxt;
+aaqxu;
+aaqxv;
+aaqxw;
+aaqxx;
+aaqxy;
+aaqxz;
+aaqya;
+aaqyb;
+aaqyc;
+aaqyd;
+aaqye;
+aaqyf;
+aaqyg;
+aaqyh;
+aaqyi;
+aaqyj;
+aaqyk;
+aaqyl;
+aaqym;
+aaqyn;
+aaqyo;
+aaqyp;
+aaqyq;
+aaqyr;
+aaqys;
+aaqyt;
+aaqyu;
+aaqyv;
+aaqyw;
+aaqyx;
+aaqyy;
+aaqyz;
+aaqza;
+aaqzb;
+aaqzc;
+aaqzd;
+aaqze;
+aaqzf;
+aaqzg;
+aaqzh;
+aaqzi;
+aaqzj;
+aaqzk;
+aaqzl;
+aaqzm;
+aaqzn;
+aaqzo;
+aaqzp;
+aaqzq;
+aaqzr;
+aaqzs;
+aaqzt;
+aaqzu;
+aaqzv;
+aaqzw;
+aaqzx;
+aaqzy;
+aaqzz;
+aaraa;
+aarab;
+aarac;
+aarad;
+aarae;
+aaraf;
+aarag;
+aarah;
+aarai;
+aaraj;
+aarak;
+aaral;
+aaram;
+aaran;
+aarao;
+aarap;
+aaraq;
+aarar;
+aaras;
+aarat;
+aarau;
+aarav;
+aaraw;
+aarax;
+aaray;
+aaraz;
+aarba;
+aarbb;
+aarbc;
+aarbd;
+aarbe;
+aarbf;
+aarbg;
+aarbh;
+aarbi;
+aarbj;
+aarbk;
+aarbl;
+aarbm;
+aarbn;
+aarbo;
+aarbp;
+aarbq;
+aarbr;
+aarbs;
+aarbt;
+aarbu;
+aarbv;
+aarbw;
+aarbx;
+aarby;
+aarbz;
+aarca;
+aarcb;
+aarcc;
+aarcd;
+aarce;
+aarcf;
+aarcg;
+aarch;
+aarci;
+aarcj;
+aarck;
+aarcl;
+aarcm;
+aarcn;
+aarco;
+aarcp;
+aarcq;
+aarcr;
+aarcs;
+aarct;
+aarcu;
+aarcv;
+aarcw;
+aarcx;
+aarcy;
+aarcz;
+aarda;
+aardb;
+aardc;
+aardd;
+aarde;
+aardf;
+aardg;
+aardh;
+aardi;
+aardj;
+aardk;
+aardl;
+aardm;
+aardn;
+aardo;
+aardp;
+aardq;
+aardr;
+aards;
+aardt;
+aardu;
+aardv;
+aardw;
+aardx;
+aardy;
+aardz;
+aarea;
+aareb;
+aarec;
+aared;
+aaree;
+aaref;
+aareg;
+aareh;
+aarei;
+aarej;
+aarek;
+aarel;
+aarem;
+aaren;
+aareo;
+aarep;
+aareq;
+aarer;
+aares;
+aaret;
+aareu;
+aarev;
+aarew;
+aarex;
+aarey;
+aarez;
+aarfa;
+aarfb;
+aarfc;
+aarfd;
+aarfe;
+aarff;
+aarfg;
+aarfh;
+aarfi;
+aarfj;
+aarfk;
+aarfl;
+aarfm;
+aarfn;
+aarfo;
+aarfp;
+aarfq;
+aarfr;
+aarfs;
+aarft;
+aarfu;
+aarfv;
+aarfw;
+aarfx;
+aarfy;
+aarfz;
+aarga;
+aargb;
+aargc;
+aargd;
+aarge;
+aargf;
+aargg;
+aargh;
+aargi;
+aargj;
+aargk;
+aargl;
+aargm;
+aargn;
+aargo;
+aargp;
+aargq;
+aargr;
+aargs;
+aargt;
+aargu;
+aargv;
+aargw;
+aargx;
+aargy;
+aargz;
+aarha;
+aarhb;
+aarhc;
+aarhd;
+aarhe;
+aarhf;
+aarhg;
+aarhh;
+aarhi;
+aarhj;
+aarhk;
+aarhl;
+aarhm;
+aarhn;
+aarho;
+aarhp;
+aarhq;
+aarhr;
+aarhs;
+aarht;
+aarhu;
+aarhv;
+aarhw;
+aarhx;
+aarhy;
+aarhz;
+aaria;
+aarib;
+aaric;
+aarid;
+aarie;
+aarif;
+aarig;
+aarih;
+aarii;
+aarij;
+aarik;
+aaril;
+aarim;
+aarin;
+aario;
+aarip;
+aariq;
+aarir;
+aaris;
+aarit;
+aariu;
+aariv;
+aariw;
+aarix;
+aariy;
+aariz;
+aarja;
+aarjb;
+aarjc;
+aarjd;
+aarje;
+aarjf;
+aarjg;
+aarjh;
+aarji;
+aarjj;
+aarjk;
+aarjl;
+aarjm;
+aarjn;
+aarjo;
+aarjp;
+aarjq;
+aarjr;
+aarjs;
+aarjt;
+aarju;
+aarjv;
+aarjw;
+aarjx;
+aarjy;
+aarjz;
+aarka;
+aarkb;
+aarkc;
+aarkd;
+aarke;
+aarkf;
+aarkg;
+aarkh;
+aarki;
+aarkj;
+aarkk;
+aarkl;
+aarkm;
+aarkn;
+aarko;
+aarkp;
+aarkq;
+aarkr;
+aarks;
+aarkt;
+aarku;
+aarkv;
+aarkw;
+aarkx;
+aarky;
+aarkz;
+aarla;
+aarlb;
+aarlc;
+aarld;
+aarle;
+aarlf;
+aarlg;
+aarlh;
+aarli;
+aarlj;
+aarlk;
+aarll;
+aarlm;
+aarln;
+aarlo;
+aarlp;
+aarlq;
+aarlr;
+aarls;
+aarlt;
+aarlu;
+aarlv;
+aarlw;
+aarlx;
+aarly;
+aarlz;
+aarma;
+aarmb;
+aarmc;
+aarmd;
+aarme;
+aarmf;
+aarmg;
+aarmh;
+aarmi;
+aarmj;
+aarmk;
+aarml;
+aarmm;
+aarmn;
+aarmo;
+aarmp;
+aarmq;
+aarmr;
+aarms;
+aarmt;
+aarmu;
+aarmv;
+aarmw;
+aarmx;
+aarmy;
+aarmz;
+aarna;
+aarnb;
+aarnc;
+aarnd;
+aarne;
+aarnf;
+aarng;
+aarnh;
+aarni;
+aarnj;
+aarnk;
+aarnl;
+aarnm;
+aarnn;
+aarno;
+aarnp;
+aarnq;
+aarnr;
+aarns;
+aarnt;
+aarnu;
+aarnv;
+aarnw;
+aarnx;
+aarny;
+aarnz;
+aaroa;
+aarob;
+aaroc;
+aarod;
+aaroe;
+aarof;
+aarog;
+aaroh;
+aaroi;
+aaroj;
+aarok;
+aarol;
+aarom;
+aaron;
+aaroo;
+aarop;
+aaroq;
+aaror;
+aaros;
+aarot;
+aarou;
+aarov;
+aarow;
+aarox;
+aaroy;
+aaroz;
+aarpa;
+aarpb;
+aarpc;
+aarpd;
+aarpe;
+aarpf;
+aarpg;
+aarph;
+aarpi;
+aarpj;
+aarpk;
+aarpl;
+aarpm;
+aarpn;
+aarpo;
+aarpp;
+aarpq;
+aarpr;
+aarps;
+aarpt;
+aarpu;
+aarpv;
+aarpw;
+aarpx;
+aarpy;
+aarpz;
+aarqa;
+aarqb;
+aarqc;
+aarqd;
+aarqe;
+aarqf;
+aarqg;
+aarqh;
+aarqi;
+aarqj;
+aarqk;
+aarql;
+aarqm;
+aarqn;
+aarqo;
+aarqp;
+aarqq;
+aarqr;
+aarqs;
+aarqt;
+aarqu;
+aarqv;
+aarqw;
+aarqx;
+aarqy;
+aarqz;
+aarra;
+aarrb;
+aarrc;
+aarrd;
+aarre;
+aarrf;
+aarrg;
+aarrh;
+aarri;
+aarrj;
+aarrk;
+aarrl;
+aarrm;
+aarrn;
+aarro;
+aarrp;
+aarrq;
+aarrr;
+aarrs;
+aarrt;
+aarru;
+aarrv;
+aarrw;
+aarrx;
+aarry;
+aarrz;
+aarsa;
+aarsb;
+aarsc;
+aarsd;
+aarse;
+aarsf;
+aarsg;
+aarsh;
+aarsi;
+aarsj;
+aarsk;
+aarsl;
+aarsm;
+aarsn;
+aarso;
+aarsp;
+aarsq;
+aarsr;
+aarss;
+aarst;
+aarsu;
+aarsv;
+aarsw;
+aarsx;
+aarsy;
+aarsz;
+aarta;
+aartb;
+aartc;
+aartd;
+aarte;
+aartf;
+aartg;
+aarth;
+aarti;
+aartj;
+aartk;
+aartl;
+aartm;
+aartn;
+aarto;
+aartp;
+aartq;
+aartr;
+aarts;
+aartt;
+aartu;
+aartv;
+aartw;
+aartx;
+aarty;
+aartz;
+aarua;
+aarub;
+aaruc;
+aarud;
+aarue;
+aaruf;
+aarug;
+aaruh;
+aarui;
+aaruj;
+aaruk;
+aarul;
+aarum;
+aarun;
+aaruo;
+aarup;
+aaruq;
+aarur;
+aarus;
+aarut;
+aaruu;
+aaruv;
+aaruw;
+aarux;
+aaruy;
+aaruz;
+aarva;
+aarvb;
+aarvc;
+aarvd;
+aarve;
+aarvf;
+aarvg;
+aarvh;
+aarvi;
+aarvj;
+aarvk;
+aarvl;
+aarvm;
+aarvn;
+aarvo;
+aarvp;
+aarvq;
+aarvr;
+aarvs;
+aarvt;
+aarvu;
+aarvv;
+aarvw;
+aarvx;
+aarvy;
+aarvz;
+aarwa;
+aarwb;
+aarwc;
+aarwd;
+aarwe;
+aarwf;
+aarwg;
+aarwh;
+aarwi;
+aarwj;
+aarwk;
+aarwl;
+aarwm;
+aarwn;
+aarwo;
+aarwp;
+aarwq;
+aarwr;
+aarws;
+aarwt;
+aarwu;
+aarwv;
+aarww;
+aarwx;
+aarwy;
+aarwz;
+aarxa;
+aarxb;
+aarxc;
+aarxd;
+aarxe;
+aarxf;
+aarxg;
+aarxh;
+aarxi;
+aarxj;
+aarxk;
+aarxl;
+aarxm;
+aarxn;
+aarxo;
+aarxp;
+aarxq;
+aarxr;
+aarxs;
+aarxt;
+aarxu;
+aarxv;
+aarxw;
+aarxx;
+aarxy;
+aarxz;
+aarya;
+aaryb;
+aaryc;
+aaryd;
+aarye;
+aaryf;
+aaryg;
+aaryh;
+aaryi;
+aaryj;
+aaryk;
+aaryl;
+aarym;
+aaryn;
+aaryo;
+aaryp;
+aaryq;
+aaryr;
+aarys;
+aaryt;
+aaryu;
+aaryv;
+aaryw;
+aaryx;
+aaryy;
+aaryz;
+aarza;
+aarzb;
+aarzc;
+aarzd;
+aarze;
+aarzf;
+aarzg;
+aarzh;
+aarzi;
+aarzj;
+aarzk;
+aarzl;
+aarzm;
+aarzn;
+aarzo;
+aarzp;
+aarzq;
+aarzr;
+aarzs;
+aarzt;
+aarzu;
+aarzv;
+aarzw;
+aarzx;
+aarzy;
+aarzz;
+aasaa;
+aasab;
+aasac;
+aasad;
+aasae;
+aasaf;
+aasag;
+aasah;
+aasai;
+aasaj;
+aasak;
+aasal;
+aasam;
+aasan;
+aasao;
+aasap;
+aasaq;
+aasar;
+aasas;
+aasat;
+aasau;
+aasav;
+aasaw;
+aasax;
+aasay;
+aasaz;
+aasba;
+aasbb;
+aasbc;
+aasbd;
+aasbe;
+aasbf;
+aasbg;
+aasbh;
+aasbi;
+aasbj;
+aasbk;
+aasbl;
+aasbm;
+aasbn;
+aasbo;
+aasbp;
+aasbq;
+aasbr;
+aasbs;
+aasbt;
+aasbu;
+aasbv;
+aasbw;
+aasbx;
+aasby;
+aasbz;
+aasca;
+aascb;
+aascc;
+aascd;
+aasce;
+aascf;
+aascg;
+aasch;
+aasci;
+aascj;
+aasck;
+aascl;
+aascm;
+aascn;
+aasco;
+aascp;
+aascq;
+aascr;
+aascs;
+aasct;
+aascu;
+aascv;
+aascw;
+aascx;
+aascy;
+aascz;
+aasda;
+aasdb;
+aasdc;
+aasdd;
+aasde;
+aasdf;
+aasdg;
+aasdh;
+aasdi;
+aasdj;
+aasdk;
+aasdl;
+aasdm;
+aasdn;
+aasdo;
+aasdp;
+aasdq;
+aasdr;
+aasds;
+aasdt;
+aasdu;
+aasdv;
+aasdw;
+aasdx;
+aasdy;
+aasdz;
+aasea;
+aaseb;
+aasec;
+aased;
+aasee;
+aasef;
+aaseg;
+aaseh;
+aasei;
+aasej;
+aasek;
+aasel;
+aasem;
+aasen;
+aaseo;
+aasep;
+aaseq;
+aaser;
+aases;
+aaset;
+aaseu;
+aasev;
+aasew;
+aasex;
+aasey;
+aasez;
+aasfa;
+aasfb;
+aasfc;
+aasfd;
+aasfe;
+aasff;
+aasfg;
+aasfh;
+aasfi;
+aasfj;
+aasfk;
+aasfl;
+aasfm;
+aasfn;
+aasfo;
+aasfp;
+aasfq;
+aasfr;
+aasfs;
+aasft;
+aasfu;
+aasfv;
+aasfw;
+aasfx;
+aasfy;
+aasfz;
+aasga;
+aasgb;
+aasgc;
+aasgd;
+aasge;
+aasgf;
+aasgg;
+aasgh;
+aasgi;
+aasgj;
+aasgk;
+aasgl;
+aasgm;
+aasgn;
+aasgo;
+aasgp;
+aasgq;
+aasgr;
+aasgs;
+aasgt;
+aasgu;
+aasgv;
+aasgw;
+aasgx;
+aasgy;
+aasgz;
+aasha;
+aashb;
+aashc;
+aashd;
+aashe;
+aashf;
+aashg;
+aashh;
+aashi;
+aashj;
+aashk;
+aashl;
+aashm;
+aashn;
+aasho;
+aashp;
+aashq;
+aashr;
+aashs;
+aasht;
+aashu;
+aashv;
+aashw;
+aashx;
+aashy;
+aashz;
+aasia;
+aasib;
+aasic;
+aasid;
+aasie;
+aasif;
+aasig;
+aasih;
+aasii;
+aasij;
+aasik;
+aasil;
+aasim;
+aasin;
+aasio;
+aasip;
+aasiq;
+aasir;
+aasis;
+aasit;
+aasiu;
+aasiv;
+aasiw;
+aasix;
+aasiy;
+aasiz;
+aasja;
+aasjb;
+aasjc;
+aasjd;
+aasje;
+aasjf;
+aasjg;
+aasjh;
+aasji;
+aasjj;
+aasjk;
+aasjl;
+aasjm;
+aasjn;
+aasjo;
+aasjp;
+aasjq;
+aasjr;
+aasjs;
+aasjt;
+aasju;
+aasjv;
+aasjw;
+aasjx;
+aasjy;
+aasjz;
+aaska;
+aaskb;
+aaskc;
+aaskd;
+aaske;
+aaskf;
+aaskg;
+aaskh;
+aaski;
+aaskj;
+aaskk;
+aaskl;
+aaskm;
+aaskn;
+aasko;
+aaskp;
+aaskq;
+aaskr;
+aasks;
+aaskt;
+aasku;
+aaskv;
+aaskw;
+aaskx;
+aasky;
+aaskz;
+aasla;
+aaslb;
+aaslc;
+aasld;
+aasle;
+aaslf;
+aaslg;
+aaslh;
+aasli;
+aaslj;
+aaslk;
+aasll;
+aaslm;
+aasln;
+aaslo;
+aaslp;
+aaslq;
+aaslr;
+aasls;
+aaslt;
+aaslu;
+aaslv;
+aaslw;
+aaslx;
+aasly;
+aaslz;
+aasma;
+aasmb;
+aasmc;
+aasmd;
+aasme;
+aasmf;
+aasmg;
+aasmh;
+aasmi;
+aasmj;
+aasmk;
+aasml;
+aasmm;
+aasmn;
+aasmo;
+aasmp;
+aasmq;
+aasmr;
+aasms;
+aasmt;
+aasmu;
+aasmv;
+aasmw;
+aasmx;
+aasmy;
+aasmz;
+aasna;
+aasnb;
+aasnc;
+aasnd;
+aasne;
+aasnf;
+aasng;
+aasnh;
+aasni;
+aasnj;
+aasnk;
+aasnl;
+aasnm;
+aasnn;
+aasno;
+aasnp;
+aasnq;
+aasnr;
+aasns;
+aasnt;
+aasnu;
+aasnv;
+aasnw;
+aasnx;
+aasny;
+aasnz;
+aasoa;
+aasob;
+aasoc;
+aasod;
+aasoe;
+aasof;
+aasog;
+aasoh;
+aasoi;
+aasoj;
+aasok;
+aasol;
+aasom;
+aason;
+aasoo;
+aasop;
+aasoq;
+aasor;
+aasos;
+aasot;
+aasou;
+aasov;
+aasow;
+aasox;
+aasoy;
+aasoz;
+aaspa;
+aaspb;
+aaspc;
+aaspd;
+aaspe;
+aaspf;
+aaspg;
+aasph;
+aaspi;
+aaspj;
+aaspk;
+aaspl;
+aaspm;
+aaspn;
+aaspo;
+aaspp;
+aaspq;
+aaspr;
+aasps;
+aaspt;
+aaspu;
+aaspv;
+aaspw;
+aaspx;
+aaspy;
+aaspz;
+aasqa;
+aasqb;
+aasqc;
+aasqd;
+aasqe;
+aasqf;
+aasqg;
+aasqh;
+aasqi;
+aasqj;
+aasqk;
+aasql;
+aasqm;
+aasqn;
+aasqo;
+aasqp;
+aasqq;
+aasqr;
+aasqs;
+aasqt;
+aasqu;
+aasqv;
+aasqw;
+aasqx;
+aasqy;
+aasqz;
+aasra;
+aasrb;
+aasrc;
+aasrd;
+aasre;
+aasrf;
+aasrg;
+aasrh;
+aasri;
+aasrj;
+aasrk;
+aasrl;
+aasrm;
+aasrn;
+aasro;
+aasrp;
+aasrq;
+aasrr;
+aasrs;
+aasrt;
+aasru;
+aasrv;
+aasrw;
+aasrx;
+aasry;
+aasrz;
+aassa;
+aassb;
+aassc;
+aassd;
+aasse;
+aassf;
+aassg;
+aassh;
+aassi;
+aassj;
+aassk;
+aassl;
+aassm;
+aassn;
+aasso;
+aassp;
+aassq;
+aassr;
+aasss;
+aasst;
+aassu;
+aassv;
+aassw;
+aassx;
+aassy;
+aassz;
+aasta;
+aastb;
+aastc;
+aastd;
+aaste;
+aastf;
+aastg;
+aasth;
+aasti;
+aastj;
+aastk;
+aastl;
+aastm;
+aastn;
+aasto;
+aastp;
+aastq;
+aastr;
+aasts;
+aastt;
+aastu;
+aastv;
+aastw;
+aastx;
+aasty;
+aastz;
+aasua;
+aasub;
+aasuc;
+aasud;
+aasue;
+aasuf;
+aasug;
+aasuh;
+aasui;
+aasuj;
+aasuk;
+aasul;
+aasum;
+aasun;
+aasuo;
+aasup;
+aasuq;
+aasur;
+aasus;
+aasut;
+aasuu;
+aasuv;
+aasuw;
+aasux;
+aasuy;
+aasuz;
+aasva;
+aasvb;
+aasvc;
+aasvd;
+aasve;
+aasvf;
+aasvg;
+aasvh;
+aasvi;
+aasvj;
+aasvk;
+aasvl;
+aasvm;
+aasvn;
+aasvo;
+aasvp;
+aasvq;
+aasvr;
+aasvs;
+aasvt;
+aasvu;
+aasvv;
+aasvw;
+aasvx;
+aasvy;
+aasvz;
+aaswa;
+aaswb;
+aaswc;
+aaswd;
+aaswe;
+aaswf;
+aaswg;
+aaswh;
+aaswi;
+aaswj;
+aaswk;
+aaswl;
+aaswm;
+aaswn;
+aaswo;
+aaswp;
+aaswq;
+aaswr;
+aasws;
+aaswt;
+aaswu;
+aaswv;
+aasww;
+aaswx;
+aaswy;
+aaswz;
+aasxa;
+aasxb;
+aasxc;
+aasxd;
+aasxe;
+aasxf;
+aasxg;
+aasxh;
+aasxi;
+aasxj;
+aasxk;
+aasxl;
+aasxm;
+aasxn;
+aasxo;
+aasxp;
+aasxq;
+aasxr;
+aasxs;
+aasxt;
+aasxu;
+aasxv;
+aasxw;
+aasxx;
+aasxy;
+aasxz;
+aasya;
+aasyb;
+aasyc;
+aasyd;
+aasye;
+aasyf;
+aasyg;
+aasyh;
+aasyi;
+aasyj;
+aasyk;
+aasyl;
+aasym;
+aasyn;
+aasyo;
+aasyp;
+aasyq;
+aasyr;
+aasys;
+aasyt;
+aasyu;
+aasyv;
+aasyw;
+aasyx;
+aasyy;
+aasyz;
+aasza;
+aaszb;
+aaszc;
+aaszd;
+aasze;
+aaszf;
+aaszg;
+aaszh;
+aaszi;
+aaszj;
+aaszk;
+aaszl;
+aaszm;
+aaszn;
+aaszo;
+aaszp;
+aaszq;
+aaszr;
+aaszs;
+aaszt;
+aaszu;
+aaszv;
+aaszw;
+aaszx;
+aaszy;
+aaszz;
+aataa;
+aatab;
+aatac;
+aatad;
+aatae;
+aataf;
+aatag;
+aatah;
+aatai;
+aataj;
+aatak;
+aatal;
+aatam;
+aatan;
+aatao;
+aatap;
+aataq;
+aatar;
+aatas;
+aatat;
+aatau;
+aatav;
+aataw;
+aatax;
+aatay;
+aataz;
+aatba;
+aatbb;
+aatbc;
+aatbd;
+aatbe;
+aatbf;
+aatbg;
+aatbh;
+aatbi;
+aatbj;
+aatbk;
+aatbl;
+aatbm;
+aatbn;
+aatbo;
+aatbp;
+aatbq;
+aatbr;
+aatbs;
+aatbt;
+aatbu;
+aatbv;
+aatbw;
+aatbx;
+aatby;
+aatbz;
+aatca;
+aatcb;
+aatcc;
+aatcd;
+aatce;
+aatcf;
+aatcg;
+aatch;
+aatci;
+aatcj;
+aatck;
+aatcl;
+aatcm;
+aatcn;
+aatco;
+aatcp;
+aatcq;
+aatcr;
+aatcs;
+aatct;
+aatcu;
+aatcv;
+aatcw;
+aatcx;
+aatcy;
+aatcz;
+aatda;
+aatdb;
+aatdc;
+aatdd;
+aatde;
+aatdf;
+aatdg;
+aatdh;
+aatdi;
+aatdj;
+aatdk;
+aatdl;
+aatdm;
+aatdn;
+aatdo;
+aatdp;
+aatdq;
+aatdr;
+aatds;
+aatdt;
+aatdu;
+aatdv;
+aatdw;
+aatdx;
+aatdy;
+aatdz;
+aatea;
+aateb;
+aatec;
+aated;
+aatee;
+aatef;
+aateg;
+aateh;
+aatei;
+aatej;
+aatek;
+aatel;
+aatem;
+aaten;
+aateo;
+aatep;
+aateq;
+aater;
+aates;
+aatet;
+aateu;
+aatev;
+aatew;
+aatex;
+aatey;
+aatez;
+aatfa;
+aatfb;
+aatfc;
+aatfd;
+aatfe;
+aatff;
+aatfg;
+aatfh;
+aatfi;
+aatfj;
+aatfk;
+aatfl;
+aatfm;
+aatfn;
+aatfo;
+aatfp;
+aatfq;
+aatfr;
+aatfs;
+aatft;
+aatfu;
+aatfv;
+aatfw;
+aatfx;
+aatfy;
+aatfz;
+aatga;
+aatgb;
+aatgc;
+aatgd;
+aatge;
+aatgf;
+aatgg;
+aatgh;
+aatgi;
+aatgj;
+aatgk;
+aatgl;
+aatgm;
+aatgn;
+aatgo;
+aatgp;
+aatgq;
+aatgr;
+aatgs;
+aatgt;
+aatgu;
+aatgv;
+aatgw;
+aatgx;
+aatgy;
+aatgz;
+aatha;
+aathb;
+aathc;
+aathd;
+aathe;
+aathf;
+aathg;
+aathh;
+aathi;
+aathj;
+aathk;
+aathl;
+aathm;
+aathn;
+aatho;
+aathp;
+aathq;
+aathr;
+aaths;
+aatht;
+aathu;
+aathv;
+aathw;
+aathx;
+aathy;
+aathz;
+aatia;
+aatib;
+aatic;
+aatid;
+aatie;
+aatif;
+aatig;
+aatih;
+aatii;
+aatij;
+aatik;
+aatil;
+aatim;
+aatin;
+aatio;
+aatip;
+aatiq;
+aatir;
+aatis;
+aatit;
+aatiu;
+aativ;
+aatiw;
+aatix;
+aatiy;
+aatiz;
+aatja;
+aatjb;
+aatjc;
+aatjd;
+aatje;
+aatjf;
+aatjg;
+aatjh;
+aatji;
+aatjj;
+aatjk;
+aatjl;
+aatjm;
+aatjn;
+aatjo;
+aatjp;
+aatjq;
+aatjr;
+aatjs;
+aatjt;
+aatju;
+aatjv;
+aatjw;
+aatjx;
+aatjy;
+aatjz;
+aatka;
+aatkb;
+aatkc;
+aatkd;
+aatke;
+aatkf;
+aatkg;
+aatkh;
+aatki;
+aatkj;
+aatkk;
+aatkl;
+aatkm;
+aatkn;
+aatko;
+aatkp;
+aatkq;
+aatkr;
+aatks;
+aatkt;
+aatku;
+aatkv;
+aatkw;
+aatkx;
+aatky;
+aatkz;
+aatla;
+aatlb;
+aatlc;
+aatld;
+aatle;
+aatlf;
+aatlg;
+aatlh;
+aatli;
+aatlj;
+aatlk;
+aatll;
+aatlm;
+aatln;
+aatlo;
+aatlp;
+aatlq;
+aatlr;
+aatls;
+aatlt;
+aatlu;
+aatlv;
+aatlw;
+aatlx;
+aatly;
+aatlz;
+aatma;
+aatmb;
+aatmc;
+aatmd;
+aatme;
+aatmf;
+aatmg;
+aatmh;
+aatmi;
+aatmj;
+aatmk;
+aatml;
+aatmm;
+aatmn;
+aatmo;
+aatmp;
+aatmq;
+aatmr;
+aatms;
+aatmt;
+aatmu;
+aatmv;
+aatmw;
+aatmx;
+aatmy;
+aatmz;
+aatna;
+aatnb;
+aatnc;
+aatnd;
+aatne;
+aatnf;
+aatng;
+aatnh;
+aatni;
+aatnj;
+aatnk;
+aatnl;
+aatnm;
+aatnn;
+aatno;
+aatnp;
+aatnq;
+aatnr;
+aatns;
+aatnt;
+aatnu;
+aatnv;
+aatnw;
+aatnx;
+aatny;
+aatnz;
+aatoa;
+aatob;
+aatoc;
+aatod;
+aatoe;
+aatof;
+aatog;
+aatoh;
+aatoi;
+aatoj;
+aatok;
+aatol;
+aatom;
+aaton;
+aatoo;
+aatop;
+aatoq;
+aator;
+aatos;
+aatot;
+aatou;
+aatov;
+aatow;
+aatox;
+aatoy;
+aatoz;
+aatpa;
+aatpb;
+aatpc;
+aatpd;
+aatpe;
+aatpf;
+aatpg;
+aatph;
+aatpi;
+aatpj;
+aatpk;
+aatpl;
+aatpm;
+aatpn;
+aatpo;
+aatpp;
+aatpq;
+aatpr;
+aatps;
+aatpt;
+aatpu;
+aatpv;
+aatpw;
+aatpx;
+aatpy;
+aatpz;
+aatqa;
+aatqb;
+aatqc;
+aatqd;
+aatqe;
+aatqf;
+aatqg;
+aatqh;
+aatqi;
+aatqj;
+aatqk;
+aatql;
+aatqm;
+aatqn;
+aatqo;
+aatqp;
+aatqq;
+aatqr;
+aatqs;
+aatqt;
+aatqu;
+aatqv;
+aatqw;
+aatqx;
+aatqy;
+aatqz;
+aatra;
+aatrb;
+aatrc;
+aatrd;
+aatre;
+aatrf;
+aatrg;
+aatrh;
+aatri;
+aatrj;
+aatrk;
+aatrl;
+aatrm;
+aatrn;
+aatro;
+aatrp;
+aatrq;
+aatrr;
+aatrs;
+aatrt;
+aatru;
+aatrv;
+aatrw;
+aatrx;
+aatry;
+aatrz;
+aatsa;
+aatsb;
+aatsc;
+aatsd;
+aatse;
+aatsf;
+aatsg;
+aatsh;
+aatsi;
+aatsj;
+aatsk;
+aatsl;
+aatsm;
+aatsn;
+aatso;
+aatsp;
+aatsq;
+aatsr;
+aatss;
+aatst;
+aatsu;
+aatsv;
+aatsw;
+aatsx;
+aatsy;
+aatsz;
+aatta;
+aattb;
+aattc;
+aattd;
+aatte;
+aattf;
+aattg;
+aatth;
+aatti;
+aattj;
+aattk;
+aattl;
+aattm;
+aattn;
+aatto;
+aattp;
+aattq;
+aattr;
+aatts;
+aattt;
+aattu;
+aattv;
+aattw;
+aattx;
+aatty;
+aattz;
+aatua;
+aatub;
+aatuc;
+aatud;
+aatue;
+aatuf;
+aatug;
+aatuh;
+aatui;
+aatuj;
+aatuk;
+aatul;
+aatum;
+aatun;
+aatuo;
+aatup;
+aatuq;
+aatur;
+aatus;
+aatut;
+aatuu;
+aatuv;
+aatuw;
+aatux;
+aatuy;
+aatuz;
+aatva;
+aatvb;
+aatvc;
+aatvd;
+aatve;
+aatvf;
+aatvg;
+aatvh;
+aatvi;
+aatvj;
+aatvk;
+aatvl;
+aatvm;
+aatvn;
+aatvo;
+aatvp;
+aatvq;
+aatvr;
+aatvs;
+aatvt;
+aatvu;
+aatvv;
+aatvw;
+aatvx;
+aatvy;
+aatvz;
+aatwa;
+aatwb;
+aatwc;
+aatwd;
+aatwe;
+aatwf;
+aatwg;
+aatwh;
+aatwi;
+aatwj;
+aatwk;
+aatwl;
+aatwm;
+aatwn;
+aatwo;
+aatwp;
+aatwq;
+aatwr;
+aatws;
+aatwt;
+aatwu;
+aatwv;
+aatww;
+aatwx;
+aatwy;
+aatwz;
+aatxa;
+aatxb;
+aatxc;
+aatxd;
+aatxe;
+aatxf;
+aatxg;
+aatxh;
+aatxi;
+aatxj;
+aatxk;
+aatxl;
+aatxm;
+aatxn;
+aatxo;
+aatxp;
+aatxq;
+aatxr;
+aatxs;
+aatxt;
+aatxu;
+aatxv;
+aatxw;
+aatxx;
+aatxy;
+aatxz;
+aatya;
+aatyb;
+aatyc;
+aatyd;
+aatye;
+aatyf;
+aatyg;
+aatyh;
+aatyi;
+aatyj;
+aatyk;
+aatyl;
+aatym;
+aatyn;
+aatyo;
+aatyp;
+aatyq;
+aatyr;
+aatys;
+aatyt;
+aatyu;
+aatyv;
+aatyw;
+aatyx;
+aatyy;
+aatyz;
+aatza;
+aatzb;
+aatzc;
+aatzd;
+aatze;
+aatzf;
+aatzg;
+aatzh;
+aatzi;
+aatzj;
+aatzk;
+aatzl;
+aatzm;
+aatzn;
+aatzo;
+aatzp;
+aatzq;
+aatzr;
+aatzs;
+aatzt;
+aatzu;
+aatzv;
+aatzw;
+aatzx;
+aatzy;
+aatzz;
+aauaa;
+aauab;
+aauac;
+aauad;
+aauae;
+aauaf;
+aauag;
+aauah;
+aauai;
+aauaj;
+aauak;
+aaual;
+aauam;
+aauan;
+aauao;
+aauap;
+aauaq;
+aauar;
+aauas;
+aauat;
+aauau;
+aauav;
+aauaw;
+aauax;
+aauay;
+aauaz;
+aauba;
+aaubb;
+aaubc;
+aaubd;
+aaube;
+aaubf;
+aaubg;
+aaubh;
+aaubi;
+aaubj;
+aaubk;
+aaubl;
+aaubm;
+aaubn;
+aaubo;
+aaubp;
+aaubq;
+aaubr;
+aaubs;
+aaubt;
+aaubu;
+aaubv;
+aaubw;
+aaubx;
+aauby;
+aaubz;
+aauca;
+aaucb;
+aaucc;
+aaucd;
+aauce;
+aaucf;
+aaucg;
+aauch;
+aauci;
+aaucj;
+aauck;
+aaucl;
+aaucm;
+aaucn;
+aauco;
+aaucp;
+aaucq;
+aaucr;
+aaucs;
+aauct;
+aaucu;
+aaucv;
+aaucw;
+aaucx;
+aaucy;
+aaucz;
+aauda;
+aaudb;
+aaudc;
+aaudd;
+aaude;
+aaudf;
+aaudg;
+aaudh;
+aaudi;
+aaudj;
+aaudk;
+aaudl;
+aaudm;
+aaudn;
+aaudo;
+aaudp;
+aaudq;
+aaudr;
+aauds;
+aaudt;
+aaudu;
+aaudv;
+aaudw;
+aaudx;
+aaudy;
+aaudz;
+aauea;
+aaueb;
+aauec;
+aaued;
+aauee;
+aauef;
+aaueg;
+aaueh;
+aauei;
+aauej;
+aauek;
+aauel;
+aauem;
+aauen;
+aaueo;
+aauep;
+aaueq;
+aauer;
+aaues;
+aauet;
+aaueu;
+aauev;
+aauew;
+aauex;
+aauey;
+aauez;
+aaufa;
+aaufb;
+aaufc;
+aaufd;
+aaufe;
+aauff;
+aaufg;
+aaufh;
+aaufi;
+aaufj;
+aaufk;
+aaufl;
+aaufm;
+aaufn;
+aaufo;
+aaufp;
+aaufq;
+aaufr;
+aaufs;
+aauft;
+aaufu;
+aaufv;
+aaufw;
+aaufx;
+aaufy;
+aaufz;
+aauga;
+aaugb;
+aaugc;
+aaugd;
+aauge;
+aaugf;
+aaugg;
+aaugh;
+aaugi;
+aaugj;
+aaugk;
+aaugl;
+aaugm;
+aaugn;
+aaugo;
+aaugp;
+aaugq;
+aaugr;
+aaugs;
+aaugt;
+aaugu;
+aaugv;
+aaugw;
+aaugx;
+aaugy;
+aaugz;
+aauha;
+aauhb;
+aauhc;
+aauhd;
+aauhe;
+aauhf;
+aauhg;
+aauhh;
+aauhi;
+aauhj;
+aauhk;
+aauhl;
+aauhm;
+aauhn;
+aauho;
+aauhp;
+aauhq;
+aauhr;
+aauhs;
+aauht;
+aauhu;
+aauhv;
+aauhw;
+aauhx;
+aauhy;
+aauhz;
+aauia;
+aauib;
+aauic;
+aauid;
+aauie;
+aauif;
+aauig;
+aauih;
+aauii;
+aauij;
+aauik;
+aauil;
+aauim;
+aauin;
+aauio;
+aauip;
+aauiq;
+aauir;
+aauis;
+aauit;
+aauiu;
+aauiv;
+aauiw;
+aauix;
+aauiy;
+aauiz;
+aauja;
+aaujb;
+aaujc;
+aaujd;
+aauje;
+aaujf;
+aaujg;
+aaujh;
+aauji;
+aaujj;
+aaujk;
+aaujl;
+aaujm;
+aaujn;
+aaujo;
+aaujp;
+aaujq;
+aaujr;
+aaujs;
+aaujt;
+aauju;
+aaujv;
+aaujw;
+aaujx;
+aaujy;
+aaujz;
+aauka;
+aaukb;
+aaukc;
+aaukd;
+aauke;
+aaukf;
+aaukg;
+aaukh;
+aauki;
+aaukj;
+aaukk;
+aaukl;
+aaukm;
+aaukn;
+aauko;
+aaukp;
+aaukq;
+aaukr;
+aauks;
+aaukt;
+aauku;
+aaukv;
+aaukw;
+aaukx;
+aauky;
+aaukz;
+aaula;
+aaulb;
+aaulc;
+aauld;
+aaule;
+aaulf;
+aaulg;
+aaulh;
+aauli;
+aaulj;
+aaulk;
+aaull;
+aaulm;
+aauln;
+aaulo;
+aaulp;
+aaulq;
+aaulr;
+aauls;
+aault;
+aaulu;
+aaulv;
+aaulw;
+aaulx;
+aauly;
+aaulz;
+aauma;
+aaumb;
+aaumc;
+aaumd;
+aaume;
+aaumf;
+aaumg;
+aaumh;
+aaumi;
+aaumj;
+aaumk;
+aauml;
+aaumm;
+aaumn;
+aaumo;
+aaump;
+aaumq;
+aaumr;
+aaums;
+aaumt;
+aaumu;
+aaumv;
+aaumw;
+aaumx;
+aaumy;
+aaumz;
+aauna;
+aaunb;
+aaunc;
+aaund;
+aaune;
+aaunf;
+aaung;
+aaunh;
+aauni;
+aaunj;
+aaunk;
+aaunl;
+aaunm;
+aaunn;
+aauno;
+aaunp;
+aaunq;
+aaunr;
+aauns;
+aaunt;
+aaunu;
+aaunv;
+aaunw;
+aaunx;
+aauny;
+aaunz;
+aauoa;
+aauob;
+aauoc;
+aauod;
+aauoe;
+aauof;
+aauog;
+aauoh;
+aauoi;
+aauoj;
+aauok;
+aauol;
+aauom;
+aauon;
+aauoo;
+aauop;
+aauoq;
+aauor;
+aauos;
+aauot;
+aauou;
+aauov;
+aauow;
+aauox;
+aauoy;
+aauoz;
+aaupa;
+aaupb;
+aaupc;
+aaupd;
+aaupe;
+aaupf;
+aaupg;
+aauph;
+aaupi;
+aaupj;
+aaupk;
+aaupl;
+aaupm;
+aaupn;
+aaupo;
+aaupp;
+aaupq;
+aaupr;
+aaups;
+aaupt;
+aaupu;
+aaupv;
+aaupw;
+aaupx;
+aaupy;
+aaupz;
+aauqa;
+aauqb;
+aauqc;
+aauqd;
+aauqe;
+aauqf;
+aauqg;
+aauqh;
+aauqi;
+aauqj;
+aauqk;
+aauql;
+aauqm;
+aauqn;
+aauqo;
+aauqp;
+aauqq;
+aauqr;
+aauqs;
+aauqt;
+aauqu;
+aauqv;
+aauqw;
+aauqx;
+aauqy;
+aauqz;
+aaura;
+aaurb;
+aaurc;
+aaurd;
+aaure;
+aaurf;
+aaurg;
+aaurh;
+aauri;
+aaurj;
+aaurk;
+aaurl;
+aaurm;
+aaurn;
+aauro;
+aaurp;
+aaurq;
+aaurr;
+aaurs;
+aaurt;
+aauru;
+aaurv;
+aaurw;
+aaurx;
+aaury;
+aaurz;
+aausa;
+aausb;
+aausc;
+aausd;
+aause;
+aausf;
+aausg;
+aaush;
+aausi;
+aausj;
+aausk;
+aausl;
+aausm;
+aausn;
+aauso;
+aausp;
+aausq;
+aausr;
+aauss;
+aaust;
+aausu;
+aausv;
+aausw;
+aausx;
+aausy;
+aausz;
+aauta;
+aautb;
+aautc;
+aautd;
+aaute;
+aautf;
+aautg;
+aauth;
+aauti;
+aautj;
+aautk;
+aautl;
+aautm;
+aautn;
+aauto;
+aautp;
+aautq;
+aautr;
+aauts;
+aautt;
+aautu;
+aautv;
+aautw;
+aautx;
+aauty;
+aautz;
+aauua;
+aauub;
+aauuc;
+aauud;
+aauue;
+aauuf;
+aauug;
+aauuh;
+aauui;
+aauuj;
+aauuk;
+aauul;
+aauum;
+aauun;
+aauuo;
+aauup;
+aauuq;
+aauur;
+aauus;
+aauut;
+aauuu;
+aauuv;
+aauuw;
+aauux;
+aauuy;
+aauuz;
+aauva;
+aauvb;
+aauvc;
+aauvd;
+aauve;
+aauvf;
+aauvg;
+aauvh;
+aauvi;
+aauvj;
+aauvk;
+aauvl;
+aauvm;
+aauvn;
+aauvo;
+aauvp;
+aauvq;
+aauvr;
+aauvs;
+aauvt;
+aauvu;
+aauvv;
+aauvw;
+aauvx;
+aauvy;
+aauvz;
+aauwa;
+aauwb;
+aauwc;
+aauwd;
+aauwe;
+aauwf;
+aauwg;
+aauwh;
+aauwi;
+aauwj;
+aauwk;
+aauwl;
+aauwm;
+aauwn;
+aauwo;
+aauwp;
+aauwq;
+aauwr;
+aauws;
+aauwt;
+aauwu;
+aauwv;
+aauww;
+aauwx;
+aauwy;
+aauwz;
+aauxa;
+aauxb;
+aauxc;
+aauxd;
+aauxe;
+aauxf;
+aauxg;
+aauxh;
+aauxi;
+aauxj;
+aauxk;
+aauxl;
+aauxm;
+aauxn;
+aauxo;
+aauxp;
+aauxq;
+aauxr;
+aauxs;
+aauxt;
+aauxu;
+aauxv;
+aauxw;
+aauxx;
+aauxy;
+aauxz;
+aauya;
+aauyb;
+aauyc;
+aauyd;
+aauye;
+aauyf;
+aauyg;
+aauyh;
+aauyi;
+aauyj;
+aauyk;
+aauyl;
+aauym;
+aauyn;
+aauyo;
+aauyp;
+aauyq;
+aauyr;
+aauys;
+aauyt;
+aauyu;
+aauyv;
+aauyw;
+aauyx;
+aauyy;
+aauyz;
+aauza;
+aauzb;
+aauzc;
+aauzd;
+aauze;
+aauzf;
+aauzg;
+aauzh;
+aauzi;
+aauzj;
+aauzk;
+aauzl;
+aauzm;
+aauzn;
+aauzo;
+aauzp;
+aauzq;
+aauzr;
+aauzs;
+aauzt;
+aauzu;
+aauzv;
+aauzw;
+aauzx;
+aauzy;
+aauzz;
+aavaa;
+aavab;
+aavac;
+aavad;
+aavae;
+aavaf;
+aavag;
+aavah;
+aavai;
+aavaj;
+aavak;
+aaval;
+aavam;
+aavan;
+aavao;
+aavap;
+aavaq;
+aavar;
+aavas;
+aavat;
+aavau;
+aavav;
+aavaw;
+aavax;
+aavay;
+aavaz;
+aavba;
+aavbb;
+aavbc;
+aavbd;
+aavbe;
+aavbf;
+aavbg;
+aavbh;
+aavbi;
+aavbj;
+aavbk;
+aavbl;
+aavbm;
+aavbn;
+aavbo;
+aavbp;
+aavbq;
+aavbr;
+aavbs;
+aavbt;
+aavbu;
+aavbv;
+aavbw;
+aavbx;
+aavby;
+aavbz;
+aavca;
+aavcb;
+aavcc;
+aavcd;
+aavce;
+aavcf;
+aavcg;
+aavch;
+aavci;
+aavcj;
+aavck;
+aavcl;
+aavcm;
+aavcn;
+aavco;
+aavcp;
+aavcq;
+aavcr;
+aavcs;
+aavct;
+aavcu;
+aavcv;
+aavcw;
+aavcx;
+aavcy;
+aavcz;
+aavda;
+aavdb;
+aavdc;
+aavdd;
+aavde;
+aavdf;
+aavdg;
+aavdh;
+aavdi;
+aavdj;
+aavdk;
+aavdl;
+aavdm;
+aavdn;
+aavdo;
+aavdp;
+aavdq;
+aavdr;
+aavds;
+aavdt;
+aavdu;
+aavdv;
+aavdw;
+aavdx;
+aavdy;
+aavdz;
+aavea;
+aaveb;
+aavec;
+aaved;
+aavee;
+aavef;
+aaveg;
+aaveh;
+aavei;
+aavej;
+aavek;
+aavel;
+aavem;
+aaven;
+aaveo;
+aavep;
+aaveq;
+aaver;
+aaves;
+aavet;
+aaveu;
+aavev;
+aavew;
+aavex;
+aavey;
+aavez;
+aavfa;
+aavfb;
+aavfc;
+aavfd;
+aavfe;
+aavff;
+aavfg;
+aavfh;
+aavfi;
+aavfj;
+aavfk;
+aavfl;
+aavfm;
+aavfn;
+aavfo;
+aavfp;
+aavfq;
+aavfr;
+aavfs;
+aavft;
+aavfu;
+aavfv;
+aavfw;
+aavfx;
+aavfy;
+aavfz;
+aavga;
+aavgb;
+aavgc;
+aavgd;
+aavge;
+aavgf;
+aavgg;
+aavgh;
+aavgi;
+aavgj;
+aavgk;
+aavgl;
+aavgm;
+aavgn;
+aavgo;
+aavgp;
+aavgq;
+aavgr;
+aavgs;
+aavgt;
+aavgu;
+aavgv;
+aavgw;
+aavgx;
+aavgy;
+aavgz;
+aavha;
+aavhb;
+aavhc;
+aavhd;
+aavhe;
+aavhf;
+aavhg;
+aavhh;
+aavhi;
+aavhj;
+aavhk;
+aavhl;
+aavhm;
+aavhn;
+aavho;
+aavhp;
+aavhq;
+aavhr;
+aavhs;
+aavht;
+aavhu;
+aavhv;
+aavhw;
+aavhx;
+aavhy;
+aavhz;
+aavia;
+aavib;
+aavic;
+aavid;
+aavie;
+aavif;
+aavig;
+aavih;
+aavii;
+aavij;
+aavik;
+aavil;
+aavim;
+aavin;
+aavio;
+aavip;
+aaviq;
+aavir;
+aavis;
+aavit;
+aaviu;
+aaviv;
+aaviw;
+aavix;
+aaviy;
+aaviz;
+aavja;
+aavjb;
+aavjc;
+aavjd;
+aavje;
+aavjf;
+aavjg;
+aavjh;
+aavji;
+aavjj;
+aavjk;
+aavjl;
+aavjm;
+aavjn;
+aavjo;
+aavjp;
+aavjq;
+aavjr;
+aavjs;
+aavjt;
+aavju;
+aavjv;
+aavjw;
+aavjx;
+aavjy;
+aavjz;
+aavka;
+aavkb;
+aavkc;
+aavkd;
+aavke;
+aavkf;
+aavkg;
+aavkh;
+aavki;
+aavkj;
+aavkk;
+aavkl;
+aavkm;
+aavkn;
+aavko;
+aavkp;
+aavkq;
+aavkr;
+aavks;
+aavkt;
+aavku;
+aavkv;
+aavkw;
+aavkx;
+aavky;
+aavkz;
+aavla;
+aavlb;
+aavlc;
+aavld;
+aavle;
+aavlf;
+aavlg;
+aavlh;
+aavli;
+aavlj;
+aavlk;
+aavll;
+aavlm;
+aavln;
+aavlo;
+aavlp;
+aavlq;
+aavlr;
+aavls;
+aavlt;
+aavlu;
+aavlv;
+aavlw;
+aavlx;
+aavly;
+aavlz;
+aavma;
+aavmb;
+aavmc;
+aavmd;
+aavme;
+aavmf;
+aavmg;
+aavmh;
+aavmi;
+aavmj;
+aavmk;
+aavml;
+aavmm;
+aavmn;
+aavmo;
+aavmp;
+aavmq;
+aavmr;
+aavms;
+aavmt;
+aavmu;
+aavmv;
+aavmw;
+aavmx;
+aavmy;
+aavmz;
+aavna;
+aavnb;
+aavnc;
+aavnd;
+aavne;
+aavnf;
+aavng;
+aavnh;
+aavni;
+aavnj;
+aavnk;
+aavnl;
+aavnm;
+aavnn;
+aavno;
+aavnp;
+aavnq;
+aavnr;
+aavns;
+aavnt;
+aavnu;
+aavnv;
+aavnw;
+aavnx;
+aavny;
+aavnz;
+aavoa;
+aavob;
+aavoc;
+aavod;
+aavoe;
+aavof;
+aavog;
+aavoh;
+aavoi;
+aavoj;
+aavok;
+aavol;
+aavom;
+aavon;
+aavoo;
+aavop;
+aavoq;
+aavor;
+aavos;
+aavot;
+aavou;
+aavov;
+aavow;
+aavox;
+aavoy;
+aavoz;
+aavpa;
+aavpb;
+aavpc;
+aavpd;
+aavpe;
+aavpf;
+aavpg;
+aavph;
+aavpi;
+aavpj;
+aavpk;
+aavpl;
+aavpm;
+aavpn;
+aavpo;
+aavpp;
+aavpq;
+aavpr;
+aavps;
+aavpt;
+aavpu;
+aavpv;
+aavpw;
+aavpx;
+aavpy;
+aavpz;
+aavqa;
+aavqb;
+aavqc;
+aavqd;
+aavqe;
+aavqf;
+aavqg;
+aavqh;
+aavqi;
+aavqj;
+aavqk;
+aavql;
+aavqm;
+aavqn;
+aavqo;
+aavqp;
+aavqq;
+aavqr;
+aavqs;
+aavqt;
+aavqu;
+aavqv;
+aavqw;
+aavqx;
+aavqy;
+aavqz;
+aavra;
+aavrb;
+aavrc;
+aavrd;
+aavre;
+aavrf;
+aavrg;
+aavrh;
+aavri;
+aavrj;
+aavrk;
+aavrl;
+aavrm;
+aavrn;
+aavro;
+aavrp;
+aavrq;
+aavrr;
+aavrs;
+aavrt;
+aavru;
+aavrv;
+aavrw;
+aavrx;
+aavry;
+aavrz;
+aavsa;
+aavsb;
+aavsc;
+aavsd;
+aavse;
+aavsf;
+aavsg;
+aavsh;
+aavsi;
+aavsj;
+aavsk;
+aavsl;
+aavsm;
+aavsn;
+aavso;
+aavsp;
+aavsq;
+aavsr;
+aavss;
+aavst;
+aavsu;
+aavsv;
+aavsw;
+aavsx;
+aavsy;
+aavsz;
+aavta;
+aavtb;
+aavtc;
+aavtd;
+aavte;
+aavtf;
+aavtg;
+aavth;
+aavti;
+aavtj;
+aavtk;
+aavtl;
+aavtm;
+aavtn;
+aavto;
+aavtp;
+aavtq;
+aavtr;
+aavts;
+aavtt;
+aavtu;
+aavtv;
+aavtw;
+aavtx;
+aavty;
+aavtz;
+aavua;
+aavub;
+aavuc;
+aavud;
+aavue;
+aavuf;
+aavug;
+aavuh;
+aavui;
+aavuj;
+aavuk;
+aavul;
+aavum;
+aavun;
+aavuo;
+aavup;
+aavuq;
+aavur;
+aavus;
+aavut;
+aavuu;
+aavuv;
+aavuw;
+aavux;
+aavuy;
+aavuz;
+aavva;
+aavvb;
+aavvc;
+aavvd;
+aavve;
+aavvf;
+aavvg;
+aavvh;
+aavvi;
+aavvj;
+aavvk;
+aavvl;
+aavvm;
+aavvn;
+aavvo;
+aavvp;
+aavvq;
+aavvr;
+aavvs;
+aavvt;
+aavvu;
+aavvv;
+aavvw;
+aavvx;
+aavvy;
+aavvz;
+aavwa;
+aavwb;
+aavwc;
+aavwd;
+aavwe;
+aavwf;
+aavwg;
+aavwh;
+aavwi;
+aavwj;
+aavwk;
+aavwl;
+aavwm;
+aavwn;
+aavwo;
+aavwp;
+aavwq;
+aavwr;
+aavws;
+aavwt;
+aavwu;
+aavwv;
+aavww;
+aavwx;
+aavwy;
+aavwz;
+aavxa;
+aavxb;
+aavxc;
+aavxd;
+aavxe;
+aavxf;
+aavxg;
+aavxh;
+aavxi;
+aavxj;
+aavxk;
+aavxl;
+aavxm;
+aavxn;
+aavxo;
+aavxp;
+aavxq;
+aavxr;
+aavxs;
+aavxt;
+aavxu;
+aavxv;
+aavxw;
+aavxx;
+aavxy;
+aavxz;
+aavya;
+aavyb;
+aavyc;
+aavyd;
+aavye;
+aavyf;
+aavyg;
+aavyh;
+aavyi;
+aavyj;
+aavyk;
+aavyl;
+aavym;
+aavyn;
+aavyo;
+aavyp;
+aavyq;
+aavyr;
+aavys;
+aavyt;
+aavyu;
+aavyv;
+aavyw;
+aavyx;
+aavyy;
+aavyz;
+aavza;
+aavzb;
+aavzc;
+aavzd;
+aavze;
+aavzf;
+aavzg;
+aavzh;
+aavzi;
+aavzj;
+aavzk;
+aavzl;
+aavzm;
+aavzn;
+aavzo;
+aavzp;
+aavzq;
+aavzr;
+aavzs;
+aavzt;
+aavzu;
+aavzv;
+aavzw;
+aavzx;
+aavzy;
+aavzz;
+aawaa;
+aawab;
+aawac;
+aawad;
+aawae;
+aawaf;
+aawag;
+aawah;
+aawai;
+aawaj;
+aawak;
+aawal;
+aawam;
+aawan;
+aawao;
+aawap;
+aawaq;
+aawar;
+aawas;
+aawat;
+aawau;
+aawav;
+aawaw;
+aawax;
+aaway;
+aawaz;
+aawba;
+aawbb;
+aawbc;
+aawbd;
+aawbe;
+aawbf;
+aawbg;
+aawbh;
+aawbi;
+aawbj;
+aawbk;
+aawbl;
+aawbm;
+aawbn;
+aawbo;
+aawbp;
+aawbq;
+aawbr;
+aawbs;
+aawbt;
+aawbu;
+aawbv;
+aawbw;
+aawbx;
+aawby;
+aawbz;
+aawca;
+aawcb;
+aawcc;
+aawcd;
+aawce;
+aawcf;
+aawcg;
+aawch;
+aawci;
+aawcj;
+aawck;
+aawcl;
+aawcm;
+aawcn;
+aawco;
+aawcp;
+aawcq;
+aawcr;
+aawcs;
+aawct;
+aawcu;
+aawcv;
+aawcw;
+aawcx;
+aawcy;
+aawcz;
+aawda;
+aawdb;
+aawdc;
+aawdd;
+aawde;
+aawdf;
+aawdg;
+aawdh;
+aawdi;
+aawdj;
+aawdk;
+aawdl;
+aawdm;
+aawdn;
+aawdo;
+aawdp;
+aawdq;
+aawdr;
+aawds;
+aawdt;
+aawdu;
+aawdv;
+aawdw;
+aawdx;
+aawdy;
+aawdz;
+aawea;
+aaweb;
+aawec;
+aawed;
+aawee;
+aawef;
+aaweg;
+aaweh;
+aawei;
+aawej;
+aawek;
+aawel;
+aawem;
+aawen;
+aaweo;
+aawep;
+aaweq;
+aawer;
+aawes;
+aawet;
+aaweu;
+aawev;
+aawew;
+aawex;
+aawey;
+aawez;
+aawfa;
+aawfb;
+aawfc;
+aawfd;
+aawfe;
+aawff;
+aawfg;
+aawfh;
+aawfi;
+aawfj;
+aawfk;
+aawfl;
+aawfm;
+aawfn;
+aawfo;
+aawfp;
+aawfq;
+aawfr;
+aawfs;
+aawft;
+aawfu;
+aawfv;
+aawfw;
+aawfx;
+aawfy;
+aawfz;
+aawga;
+aawgb;
+aawgc;
+aawgd;
+aawge;
+aawgf;
+aawgg;
+aawgh;
+aawgi;
+aawgj;
+aawgk;
+aawgl;
+aawgm;
+aawgn;
+aawgo;
+aawgp;
+aawgq;
+aawgr;
+aawgs;
+aawgt;
+aawgu;
+aawgv;
+aawgw;
+aawgx;
+aawgy;
+aawgz;
+aawha;
+aawhb;
+aawhc;
+aawhd;
+aawhe;
+aawhf;
+aawhg;
+aawhh;
+aawhi;
+aawhj;
+aawhk;
+aawhl;
+aawhm;
+aawhn;
+aawho;
+aawhp;
+aawhq;
+aawhr;
+aawhs;
+aawht;
+aawhu;
+aawhv;
+aawhw;
+aawhx;
+aawhy;
+aawhz;
+aawia;
+aawib;
+aawic;
+aawid;
+aawie;
+aawif;
+aawig;
+aawih;
+aawii;
+aawij;
+aawik;
+aawil;
+aawim;
+aawin;
+aawio;
+aawip;
+aawiq;
+aawir;
+aawis;
+aawit;
+aawiu;
+aawiv;
+aawiw;
+aawix;
+aawiy;
+aawiz;
+aawja;
+aawjb;
+aawjc;
+aawjd;
+aawje;
+aawjf;
+aawjg;
+aawjh;
+aawji;
+aawjj;
+aawjk;
+aawjl;
+aawjm;
+aawjn;
+aawjo;
+aawjp;
+aawjq;
+aawjr;
+aawjs;
+aawjt;
+aawju;
+aawjv;
+aawjw;
+aawjx;
+aawjy;
+aawjz;
+aawka;
+aawkb;
+aawkc;
+aawkd;
+aawke;
+aawkf;
+aawkg;
+aawkh;
+aawki;
+aawkj;
+aawkk;
+aawkl;
+aawkm;
+aawkn;
+aawko;
+aawkp;
+aawkq;
+aawkr;
+aawks;
+aawkt;
+aawku;
+aawkv;
+aawkw;
+aawkx;
+aawky;
+aawkz;
+aawla;
+aawlb;
+aawlc;
+aawld;
+aawle;
+aawlf;
+aawlg;
+aawlh;
+aawli;
+aawlj;
+aawlk;
+aawll;
+aawlm;
+aawln;
+aawlo;
+aawlp;
+aawlq;
+aawlr;
+aawls;
+aawlt;
+aawlu;
+aawlv;
+aawlw;
+aawlx;
+aawly;
+aawlz;
+aawma;
+aawmb;
+aawmc;
+aawmd;
+aawme;
+aawmf;
+aawmg;
+aawmh;
+aawmi;
+aawmj;
+aawmk;
+aawml;
+aawmm;
+aawmn;
+aawmo;
+aawmp;
+aawmq;
+aawmr;
+aawms;
+aawmt;
+aawmu;
+aawmv;
+aawmw;
+aawmx;
+aawmy;
+aawmz;
+aawna;
+aawnb;
+aawnc;
+aawnd;
+aawne;
+aawnf;
+aawng;
+aawnh;
+aawni;
+aawnj;
+aawnk;
+aawnl;
+aawnm;
+aawnn;
+aawno;
+aawnp;
+aawnq;
+aawnr;
+aawns;
+aawnt;
+aawnu;
+aawnv;
+aawnw;
+aawnx;
+aawny;
+aawnz;
+aawoa;
+aawob;
+aawoc;
+aawod;
+aawoe;
+aawof;
+aawog;
+aawoh;
+aawoi;
+aawoj;
+aawok;
+aawol;
+aawom;
+aawon;
+aawoo;
+aawop;
+aawoq;
+aawor;
+aawos;
+aawot;
+aawou;
+aawov;
+aawow;
+aawox;
+aawoy;
+aawoz;
+aawpa;
+aawpb;
+aawpc;
+aawpd;
+aawpe;
+aawpf;
+aawpg;
+aawph;
+aawpi;
+aawpj;
+aawpk;
+aawpl;
+aawpm;
+aawpn;
+aawpo;
+aawpp;
+aawpq;
+aawpr;
+aawps;
+aawpt;
+aawpu;
+aawpv;
+aawpw;
+aawpx;
+aawpy;
+aawpz;
+aawqa;
+aawqb;
+aawqc;
+aawqd;
+aawqe;
+aawqf;
+aawqg;
+aawqh;
+aawqi;
+aawqj;
+aawqk;
+aawql;
+aawqm;
+aawqn;
+aawqo;
+aawqp;
+aawqq;
+aawqr;
+aawqs;
+aawqt;
+aawqu;
+aawqv;
+aawqw;
+aawqx;
+aawqy;
+aawqz;
+aawra;
+aawrb;
+aawrc;
+aawrd;
+aawre;
+aawrf;
+aawrg;
+aawrh;
+aawri;
+aawrj;
+aawrk;
+aawrl;
+aawrm;
+aawrn;
+aawro;
+aawrp;
+aawrq;
+aawrr;
+aawrs;
+aawrt;
+aawru;
+aawrv;
+aawrw;
+aawrx;
+aawry;
+aawrz;
+aawsa;
+aawsb;
+aawsc;
+aawsd;
+aawse;
+aawsf;
+aawsg;
+aawsh;
+aawsi;
+aawsj;
+aawsk;
+aawsl;
+aawsm;
+aawsn;
+aawso;
+aawsp;
+aawsq;
+aawsr;
+aawss;
+aawst;
+aawsu;
+aawsv;
+aawsw;
+aawsx;
+aawsy;
+aawsz;
+aawta;
+aawtb;
+aawtc;
+aawtd;
+aawte;
+aawtf;
+aawtg;
+aawth;
+aawti;
+aawtj;
+aawtk;
+aawtl;
+aawtm;
+aawtn;
+aawto;
+aawtp;
+aawtq;
+aawtr;
+aawts;
+aawtt;
+aawtu;
+aawtv;
+aawtw;
+aawtx;
+aawty;
+aawtz;
+aawua;
+aawub;
+aawuc;
+aawud;
+aawue;
+aawuf;
+aawug;
+aawuh;
+aawui;
+aawuj;
+aawuk;
+aawul;
+aawum;
+aawun;
+aawuo;
+aawup;
+aawuq;
+aawur;
+aawus;
+aawut;
+aawuu;
+aawuv;
+aawuw;
+aawux;
+aawuy;
+aawuz;
+aawva;
+aawvb;
+aawvc;
+aawvd;
+aawve;
+aawvf;
+aawvg;
+aawvh;
+aawvi;
+aawvj;
+aawvk;
+aawvl;
+aawvm;
+aawvn;
+aawvo;
+aawvp;
+aawvq;
+aawvr;
+aawvs;
+aawvt;
+aawvu;
+aawvv;
+aawvw;
+aawvx;
+aawvy;
+aawvz;
+aawwa;
+aawwb;
+aawwc;
+aawwd;
+aawwe;
+aawwf;
+aawwg;
+aawwh;
+aawwi;
+aawwj;
+aawwk;
+aawwl;
+aawwm;
+aawwn;
+aawwo;
+aawwp;
+aawwq;
+aawwr;
+aawws;
+aawwt;
+aawwu;
+aawwv;
+aawww;
+aawwx;
+aawwy;
+aawwz;
+aawxa;
+aawxb;
+aawxc;
+aawxd;
+aawxe;
+aawxf;
+aawxg;
+aawxh;
+aawxi;
+aawxj;
+aawxk;
+aawxl;
+aawxm;
+aawxn;
+aawxo;
+aawxp;
+aawxq;
+aawxr;
+aawxs;
+aawxt;
+aawxu;
+aawxv;
+aawxw;
+aawxx;
+aawxy;
+aawxz;
+aawya;
+aawyb;
+aawyc;
+aawyd;
+aawye;
+aawyf;
+aawyg;
+aawyh;
+aawyi;
+aawyj;
+aawyk;
+aawyl;
+aawym;
+aawyn;
+aawyo;
+aawyp;
+aawyq;
+aawyr;
+aawys;
+aawyt;
+aawyu;
+aawyv;
+aawyw;
+aawyx;
+aawyy;
+aawyz;
+aawza;
+aawzb;
+aawzc;
+aawzd;
+aawze;
+aawzf;
+aawzg;
+aawzh;
+aawzi;
+aawzj;
+aawzk;
+aawzl;
+aawzm;
+aawzn;
+aawzo;
+aawzp;
+aawzq;
+aawzr;
+aawzs;
+aawzt;
+aawzu;
+aawzv;
+aawzw;
+aawzx;
+aawzy;
+aawzz;
+aaxaa;
+aaxab;
+aaxac;
+aaxad;
+aaxae;
+aaxaf;
+aaxag;
+aaxah;
+aaxai;
+aaxaj;
+aaxak;
+aaxal;
+aaxam;
+aaxan;
+aaxao;
+aaxap;
+aaxaq;
+aaxar;
+aaxas;
+aaxat;
+aaxau;
+aaxav;
+aaxaw;
+aaxax;
+aaxay;
+aaxaz;
+aaxba;
+aaxbb;
+aaxbc;
+aaxbd;
+aaxbe;
+aaxbf;
+aaxbg;
+aaxbh;
+aaxbi;
+aaxbj;
+aaxbk;
+aaxbl;
+aaxbm;
+aaxbn;
+aaxbo;
+aaxbp;
+aaxbq;
+aaxbr;
+aaxbs;
+aaxbt;
+aaxbu;
+aaxbv;
+aaxbw;
+aaxbx;
+aaxby;
+aaxbz;
+aaxca;
+aaxcb;
+aaxcc;
+aaxcd;
+aaxce;
+aaxcf;
+aaxcg;
+aaxch;
+aaxci;
+aaxcj;
+aaxck;
+aaxcl;
+aaxcm;
+aaxcn;
+aaxco;
+aaxcp;
+aaxcq;
+aaxcr;
+aaxcs;
+aaxct;
+aaxcu;
+aaxcv;
+aaxcw;
+aaxcx;
+aaxcy;
+aaxcz;
+aaxda;
+aaxdb;
+aaxdc;
+aaxdd;
+aaxde;
+aaxdf;
+aaxdg;
+aaxdh;
+aaxdi;
+aaxdj;
+aaxdk;
+aaxdl;
+aaxdm;
+aaxdn;
+aaxdo;
+aaxdp;
+aaxdq;
+aaxdr;
+aaxds;
+aaxdt;
+aaxdu;
+aaxdv;
+aaxdw;
+aaxdx;
+aaxdy;
+aaxdz;
+aaxea;
+aaxeb;
+aaxec;
+aaxed;
+aaxee;
+aaxef;
+aaxeg;
+aaxeh;
+aaxei;
+aaxej;
+aaxek;
+aaxel;
+aaxem;
+aaxen;
+aaxeo;
+aaxep;
+aaxeq;
+aaxer;
+aaxes;
+aaxet;
+aaxeu;
+aaxev;
+aaxew;
+aaxex;
+aaxey;
+aaxez;
+aaxfa;
+aaxfb;
+aaxfc;
+aaxfd;
+aaxfe;
+aaxff;
+aaxfg;
+aaxfh;
+aaxfi;
+aaxfj;
+aaxfk;
+aaxfl;
+aaxfm;
+aaxfn;
+aaxfo;
+aaxfp;
+aaxfq;
+aaxfr;
+aaxfs;
+aaxft;
+aaxfu;
+aaxfv;
+aaxfw;
+aaxfx;
+aaxfy;
+aaxfz;
+aaxga;
+aaxgb;
+aaxgc;
+aaxgd;
+aaxge;
+aaxgf;
+aaxgg;
+aaxgh;
+aaxgi;
+aaxgj;
+aaxgk;
+aaxgl;
+aaxgm;
+aaxgn;
+aaxgo;
+aaxgp;
+aaxgq;
+aaxgr;
+aaxgs;
+aaxgt;
+aaxgu;
+aaxgv;
+aaxgw;
+aaxgx;
+aaxgy;
+aaxgz;
+aaxha;
+aaxhb;
+aaxhc;
+aaxhd;
+aaxhe;
+aaxhf;
+aaxhg;
+aaxhh;
+aaxhi;
+aaxhj;
+aaxhk;
+aaxhl;
+aaxhm;
+aaxhn;
+aaxho;
+aaxhp;
+aaxhq;
+aaxhr;
+aaxhs;
+aaxht;
+aaxhu;
+aaxhv;
+aaxhw;
+aaxhx;
+aaxhy;
+aaxhz;
+aaxia;
+aaxib;
+aaxic;
+aaxid;
+aaxie;
+aaxif;
+aaxig;
+aaxih;
+aaxii;
+aaxij;
+aaxik;
+aaxil;
+aaxim;
+aaxin;
+aaxio;
+aaxip;
+aaxiq;
+aaxir;
+aaxis;
+aaxit;
+aaxiu;
+aaxiv;
+aaxiw;
+aaxix;
+aaxiy;
+aaxiz;
+aaxja;
+aaxjb;
+aaxjc;
+aaxjd;
+aaxje;
+aaxjf;
+aaxjg;
+aaxjh;
+aaxji;
+aaxjj;
+aaxjk;
+aaxjl;
+aaxjm;
+aaxjn;
+aaxjo;
+aaxjp;
+aaxjq;
+aaxjr;
+aaxjs;
+aaxjt;
+aaxju;
+aaxjv;
+aaxjw;
+aaxjx;
+aaxjy;
+aaxjz;
+aaxka;
+aaxkb;
+aaxkc;
+aaxkd;
+aaxke;
+aaxkf;
+aaxkg;
+aaxkh;
+aaxki;
+aaxkj;
+aaxkk;
+aaxkl;
+aaxkm;
+aaxkn;
+aaxko;
+aaxkp;
+aaxkq;
+aaxkr;
+aaxks;
+aaxkt;
+aaxku;
+aaxkv;
+aaxkw;
+aaxkx;
+aaxky;
+aaxkz;
+aaxla;
+aaxlb;
+aaxlc;
+aaxld;
+aaxle;
+aaxlf;
+aaxlg;
+aaxlh;
+aaxli;
+aaxlj;
+aaxlk;
+aaxll;
+aaxlm;
+aaxln;
+aaxlo;
+aaxlp;
+aaxlq;
+aaxlr;
+aaxls;
+aaxlt;
+aaxlu;
+aaxlv;
+aaxlw;
+aaxlx;
+aaxly;
+aaxlz;
+aaxma;
+aaxmb;
+aaxmc;
+aaxmd;
+aaxme;
+aaxmf;
+aaxmg;
+aaxmh;
+aaxmi;
+aaxmj;
+aaxmk;
+aaxml;
+aaxmm;
+aaxmn;
+aaxmo;
+aaxmp;
+aaxmq;
+aaxmr;
+aaxms;
+aaxmt;
+aaxmu;
+aaxmv;
+aaxmw;
+aaxmx;
+aaxmy;
+aaxmz;
+aaxna;
+aaxnb;
+aaxnc;
+aaxnd;
+aaxne;
+aaxnf;
+aaxng;
+aaxnh;
+aaxni;
+aaxnj;
+aaxnk;
+aaxnl;
+aaxnm;
+aaxnn;
+aaxno;
+aaxnp;
+aaxnq;
+aaxnr;
+aaxns;
+aaxnt;
+aaxnu;
+aaxnv;
+aaxnw;
+aaxnx;
+aaxny;
+aaxnz;
+aaxoa;
+aaxob;
+aaxoc;
+aaxod;
+aaxoe;
+aaxof;
+aaxog;
+aaxoh;
+aaxoi;
+aaxoj;
+aaxok;
+aaxol;
+aaxom;
+aaxon;
+aaxoo;
+aaxop;
+aaxoq;
+aaxor;
+aaxos;
+aaxot;
+aaxou;
+aaxov;
+aaxow;
+aaxox;
+aaxoy;
+aaxoz;
+aaxpa;
+aaxpb;
+aaxpc;
+aaxpd;
+aaxpe;
+aaxpf;
+aaxpg;
+aaxph;
+aaxpi;
+aaxpj;
+aaxpk;
+aaxpl;
+aaxpm;
+aaxpn;
+aaxpo;
+aaxpp;
+aaxpq;
+aaxpr;
+aaxps;
+aaxpt;
+aaxpu;
+aaxpv;
+aaxpw;
+aaxpx;
+aaxpy;
+aaxpz;
+aaxqa;
+aaxqb;
+aaxqc;
+aaxqd;
+aaxqe;
+aaxqf;
+aaxqg;
+aaxqh;
+aaxqi;
+aaxqj;
+aaxqk;
+aaxql;
+aaxqm;
+aaxqn;
+aaxqo;
+aaxqp;
+aaxqq;
+aaxqr;
+aaxqs;
+aaxqt;
+aaxqu;
+aaxqv;
+aaxqw;
+aaxqx;
+aaxqy;
+aaxqz;
+aaxra;
+aaxrb;
+aaxrc;
+aaxrd;
+aaxre;
+aaxrf;
+aaxrg;
+aaxrh;
+aaxri;
+aaxrj;
+aaxrk;
+aaxrl;
+aaxrm;
+aaxrn;
+aaxro;
+aaxrp;
+aaxrq;
+aaxrr;
+aaxrs;
+aaxrt;
+aaxru;
+aaxrv;
+aaxrw;
+aaxrx;
+aaxry;
+aaxrz;
+aaxsa;
+aaxsb;
+aaxsc;
+aaxsd;
+aaxse;
+aaxsf;
+aaxsg;
+aaxsh;
+aaxsi;
+aaxsj;
+aaxsk;
+aaxsl;
+aaxsm;
+aaxsn;
+aaxso;
+aaxsp;
+aaxsq;
+aaxsr;
+aaxss;
+aaxst;
+aaxsu;
+aaxsv;
+aaxsw;
+aaxsx;
+aaxsy;
+aaxsz;
+aaxta;
+aaxtb;
+aaxtc;
+aaxtd;
+aaxte;
+aaxtf;
+aaxtg;
+aaxth;
+aaxti;
+aaxtj;
+aaxtk;
+aaxtl;
+aaxtm;
+aaxtn;
+aaxto;
+aaxtp;
+aaxtq;
+aaxtr;
+aaxts;
+aaxtt;
+aaxtu;
+aaxtv;
+aaxtw;
+aaxtx;
+aaxty;
+aaxtz;
+aaxua;
+aaxub;
+aaxuc;
+aaxud;
+aaxue;
+aaxuf;
+aaxug;
+aaxuh;
+aaxui;
+aaxuj;
+aaxuk;
+aaxul;
+aaxum;
+aaxun;
+aaxuo;
+aaxup;
+aaxuq;
+aaxur;
+aaxus;
+aaxut;
+aaxuu;
+aaxuv;
+aaxuw;
+aaxux;
+aaxuy;
+aaxuz;
+aaxva;
+aaxvb;
+aaxvc;
+aaxvd;
+aaxve;
+aaxvf;
+aaxvg;
+aaxvh;
+aaxvi;
+aaxvj;
+aaxvk;
+aaxvl;
+aaxvm;
+aaxvn;
+aaxvo;
+aaxvp;
+aaxvq;
+aaxvr;
+aaxvs;
+aaxvt;
+aaxvu;
+aaxvv;
+aaxvw;
+aaxvx;
+aaxvy;
+aaxvz;
+aaxwa;
+aaxwb;
+aaxwc;
+aaxwd;
+aaxwe;
+aaxwf;
+aaxwg;
+aaxwh;
+aaxwi;
+aaxwj;
+aaxwk;
+aaxwl;
+aaxwm;
+aaxwn;
+aaxwo;
+aaxwp;
+aaxwq;
+aaxwr;
+aaxws;
+aaxwt;
+aaxwu;
+aaxwv;
+aaxww;
+aaxwx;
+aaxwy;
+aaxwz;
+aaxxa;
+aaxxb;
+aaxxc;
+aaxxd;
+aaxxe;
+aaxxf;
+aaxxg;
+aaxxh;
+aaxxi;
+aaxxj;
+aaxxk;
+aaxxl;
+aaxxm;
+aaxxn;
+aaxxo;
+aaxxp;
+aaxxq;
+aaxxr;
+aaxxs;
+aaxxt;
+aaxxu;
+aaxxv;
+aaxxw;
+aaxxx;
+aaxxy;
+aaxxz;
+aaxya;
+aaxyb;
+aaxyc;
+aaxyd;
+aaxye;
+aaxyf;
+aaxyg;
+aaxyh;
+aaxyi;
+aaxyj;
+aaxyk;
+aaxyl;
+aaxym;
+aaxyn;
+aaxyo;
+aaxyp;
+aaxyq;
+aaxyr;
+aaxys;
+aaxyt;
+aaxyu;
+aaxyv;
+aaxyw;
+aaxyx;
+aaxyy;
+aaxyz;
+aaxza;
+aaxzb;
+aaxzc;
+aaxzd;
+aaxze;
+aaxzf;
+aaxzg;
+aaxzh;
+aaxzi;
+aaxzj;
+aaxzk;
+aaxzl;
+aaxzm;
+aaxzn;
+aaxzo;
+aaxzp;
+aaxzq;
+aaxzr;
+aaxzs;
+aaxzt;
+aaxzu;
+aaxzv;
+aaxzw;
+aaxzx;
+aaxzy;
+aaxzz;
+aayaa;
+aayab;
+aayac;
+aayad;
+aayae;
+aayaf;
+aayag;
+aayah;
+aayai;
+aayaj;
+aayak;
+aayal;
+aayam;
+aayan;
+aayao;
+aayap;
+aayaq;
+aayar;
+aayas;
+aayat;
+aayau;
+aayav;
+aayaw;
+aayax;
+aayay;
+aayaz;
+aayba;
+aaybb;
+aaybc;
+aaybd;
+aaybe;
+aaybf;
+aaybg;
+aaybh;
+aaybi;
+aaybj;
+aaybk;
+aaybl;
+aaybm;
+aaybn;
+aaybo;
+aaybp;
+aaybq;
+aaybr;
+aaybs;
+aaybt;
+aaybu;
+aaybv;
+aaybw;
+aaybx;
+aayby;
+aaybz;
+aayca;
+aaycb;
+aaycc;
+aaycd;
+aayce;
+aaycf;
+aaycg;
+aaych;
+aayci;
+aaycj;
+aayck;
+aaycl;
+aaycm;
+aaycn;
+aayco;
+aaycp;
+aaycq;
+aaycr;
+aaycs;
+aayct;
+aaycu;
+aaycv;
+aaycw;
+aaycx;
+aaycy;
+aaycz;
+aayda;
+aaydb;
+aaydc;
+aaydd;
+aayde;
+aaydf;
+aaydg;
+aaydh;
+aaydi;
+aaydj;
+aaydk;
+aaydl;
+aaydm;
+aaydn;
+aaydo;
+aaydp;
+aaydq;
+aaydr;
+aayds;
+aaydt;
+aaydu;
+aaydv;
+aaydw;
+aaydx;
+aaydy;
+aaydz;
+aayea;
+aayeb;
+aayec;
+aayed;
+aayee;
+aayef;
+aayeg;
+aayeh;
+aayei;
+aayej;
+aayek;
+aayel;
+aayem;
+aayen;
+aayeo;
+aayep;
+aayeq;
+aayer;
+aayes;
+aayet;
+aayeu;
+aayev;
+aayew;
+aayex;
+aayey;
+aayez;
+aayfa;
+aayfb;
+aayfc;
+aayfd;
+aayfe;
+aayff;
+aayfg;
+aayfh;
+aayfi;
+aayfj;
+aayfk;
+aayfl;
+aayfm;
+aayfn;
+aayfo;
+aayfp;
+aayfq;
+aayfr;
+aayfs;
+aayft;
+aayfu;
+aayfv;
+aayfw;
+aayfx;
+aayfy;
+aayfz;
+aayga;
+aaygb;
+aaygc;
+aaygd;
+aayge;
+aaygf;
+aaygg;
+aaygh;
+aaygi;
+aaygj;
+aaygk;
+aaygl;
+aaygm;
+aaygn;
+aaygo;
+aaygp;
+aaygq;
+aaygr;
+aaygs;
+aaygt;
+aaygu;
+aaygv;
+aaygw;
+aaygx;
+aaygy;
+aaygz;
+aayha;
+aayhb;
+aayhc;
+aayhd;
+aayhe;
+aayhf;
+aayhg;
+aayhh;
+aayhi;
+aayhj;
+aayhk;
+aayhl;
+aayhm;
+aayhn;
+aayho;
+aayhp;
+aayhq;
+aayhr;
+aayhs;
+aayht;
+aayhu;
+aayhv;
+aayhw;
+aayhx;
+aayhy;
+aayhz;
+aayia;
+aayib;
+aayic;
+aayid;
+aayie;
+aayif;
+aayig;
+aayih;
+aayii;
+aayij;
+aayik;
+aayil;
+aayim;
+aayin;
+aayio;
+aayip;
+aayiq;
+aayir;
+aayis;
+aayit;
+aayiu;
+aayiv;
+aayiw;
+aayix;
+aayiy;
+aayiz;
+aayja;
+aayjb;
+aayjc;
+aayjd;
+aayje;
+aayjf;
+aayjg;
+aayjh;
+aayji;
+aayjj;
+aayjk;
+aayjl;
+aayjm;
+aayjn;
+aayjo;
+aayjp;
+aayjq;
+aayjr;
+aayjs;
+aayjt;
+aayju;
+aayjv;
+aayjw;
+aayjx;
+aayjy;
+aayjz;
+aayka;
+aaykb;
+aaykc;
+aaykd;
+aayke;
+aaykf;
+aaykg;
+aaykh;
+aayki;
+aaykj;
+aaykk;
+aaykl;
+aaykm;
+aaykn;
+aayko;
+aaykp;
+aaykq;
+aaykr;
+aayks;
+aaykt;
+aayku;
+aaykv;
+aaykw;
+aaykx;
+aayky;
+aaykz;
+aayla;
+aaylb;
+aaylc;
+aayld;
+aayle;
+aaylf;
+aaylg;
+aaylh;
+aayli;
+aaylj;
+aaylk;
+aayll;
+aaylm;
+aayln;
+aaylo;
+aaylp;
+aaylq;
+aaylr;
+aayls;
+aaylt;
+aaylu;
+aaylv;
+aaylw;
+aaylx;
+aayly;
+aaylz;
+aayma;
+aaymb;
+aaymc;
+aaymd;
+aayme;
+aaymf;
+aaymg;
+aaymh;
+aaymi;
+aaymj;
+aaymk;
+aayml;
+aaymm;
+aaymn;
+aaymo;
+aaymp;
+aaymq;
+aaymr;
+aayms;
+aaymt;
+aaymu;
+aaymv;
+aaymw;
+aaymx;
+aaymy;
+aaymz;
+aayna;
+aaynb;
+aaync;
+aaynd;
+aayne;
+aaynf;
+aayng;
+aaynh;
+aayni;
+aaynj;
+aaynk;
+aaynl;
+aaynm;
+aaynn;
+aayno;
+aaynp;
+aaynq;
+aaynr;
+aayns;
+aaynt;
+aaynu;
+aaynv;
+aaynw;
+aaynx;
+aayny;
+aaynz;
+aayoa;
+aayob;
+aayoc;
+aayod;
+aayoe;
+aayof;
+aayog;
+aayoh;
+aayoi;
+aayoj;
+aayok;
+aayol;
+aayom;
+aayon;
+aayoo;
+aayop;
+aayoq;
+aayor;
+aayos;
+aayot;
+aayou;
+aayov;
+aayow;
+aayox;
+aayoy;
+aayoz;
+aaypa;
+aaypb;
+aaypc;
+aaypd;
+aaype;
+aaypf;
+aaypg;
+aayph;
+aaypi;
+aaypj;
+aaypk;
+aaypl;
+aaypm;
+aaypn;
+aaypo;
+aaypp;
+aaypq;
+aaypr;
+aayps;
+aaypt;
+aaypu;
+aaypv;
+aaypw;
+aaypx;
+aaypy;
+aaypz;
+aayqa;
+aayqb;
+aayqc;
+aayqd;
+aayqe;
+aayqf;
+aayqg;
+aayqh;
+aayqi;
+aayqj;
+aayqk;
+aayql;
+aayqm;
+aayqn;
+aayqo;
+aayqp;
+aayqq;
+aayqr;
+aayqs;
+aayqt;
+aayqu;
+aayqv;
+aayqw;
+aayqx;
+aayqy;
+aayqz;
+aayra;
+aayrb;
+aayrc;
+aayrd;
+aayre;
+aayrf;
+aayrg;
+aayrh;
+aayri;
+aayrj;
+aayrk;
+aayrl;
+aayrm;
+aayrn;
+aayro;
+aayrp;
+aayrq;
+aayrr;
+aayrs;
+aayrt;
+aayru;
+aayrv;
+aayrw;
+aayrx;
+aayry;
+aayrz;
+aaysa;
+aaysb;
+aaysc;
+aaysd;
+aayse;
+aaysf;
+aaysg;
+aaysh;
+aaysi;
+aaysj;
+aaysk;
+aaysl;
+aaysm;
+aaysn;
+aayso;
+aaysp;
+aaysq;
+aaysr;
+aayss;
+aayst;
+aaysu;
+aaysv;
+aaysw;
+aaysx;
+aaysy;
+aaysz;
+aayta;
+aaytb;
+aaytc;
+aaytd;
+aayte;
+aaytf;
+aaytg;
+aayth;
+aayti;
+aaytj;
+aaytk;
+aaytl;
+aaytm;
+aaytn;
+aayto;
+aaytp;
+aaytq;
+aaytr;
+aayts;
+aaytt;
+aaytu;
+aaytv;
+aaytw;
+aaytx;
+aayty;
+aaytz;
+aayua;
+aayub;
+aayuc;
+aayud;
+aayue;
+aayuf;
+aayug;
+aayuh;
+aayui;
+aayuj;
+aayuk;
+aayul;
+aayum;
+aayun;
+aayuo;
+aayup;
+aayuq;
+aayur;
+aayus;
+aayut;
+aayuu;
+aayuv;
+aayuw;
+aayux;
+aayuy;
+aayuz;
+aayva;
+aayvb;
+aayvc;
+aayvd;
+aayve;
+aayvf;
+aayvg;
+aayvh;
+aayvi;
+aayvj;
+aayvk;
+aayvl;
+aayvm;
+aayvn;
+aayvo;
+aayvp;
+aayvq;
+aayvr;
+aayvs;
+aayvt;
+aayvu;
+aayvv;
+aayvw;
+aayvx;
+aayvy;
+aayvz;
+aaywa;
+aaywb;
+aaywc;
+aaywd;
+aaywe;
+aaywf;
+aaywg;
+aaywh;
+aaywi;
+aaywj;
+aaywk;
+aaywl;
+aaywm;
+aaywn;
+aaywo;
+aaywp;
+aaywq;
+aaywr;
+aayws;
+aaywt;
+aaywu;
+aaywv;
+aayww;
+aaywx;
+aaywy;
+aaywz;
+aayxa;
+aayxb;
+aayxc;
+aayxd;
+aayxe;
+aayxf;
+aayxg;
+aayxh;
+aayxi;
+aayxj;
+aayxk;
+aayxl;
+aayxm;
+aayxn;
+aayxo;
+aayxp;
+aayxq;
+aayxr;
+aayxs;
+aayxt;
+aayxu;
+aayxv;
+aayxw;
+aayxx;
+aayxy;
+aayxz;
+aayya;
+aayyb;
+aayyc;
+aayyd;
+aayye;
+aayyf;
+aayyg;
+aayyh;
+aayyi;
+aayyj;
+aayyk;
+aayyl;
+aayym;
+aayyn;
+aayyo;
+aayyp;
+aayyq;
+aayyr;
+aayys;
+aayyt;
+aayyu;
+aayyv;
+aayyw;
+aayyx;
+aayyy;
+aayyz;
+aayza;
+aayzb;
+aayzc;
+aayzd;
+aayze;
+aayzf;
+aayzg;
+aayzh;
+aayzi;
+aayzj;
+aayzk;
+aayzl;
+aayzm;
+aayzn;
+aayzo;
+aayzp;
+aayzq;
+aayzr;
+aayzs;
+aayzt;
+aayzu;
+aayzv;
+aayzw;
+aayzx;
+aayzy;
+aayzz;
+aazaa;
+aazab;
+aazac;
+aazad;
+aazae;
+aazaf;
+aazag;
+aazah;
+aazai;
+aazaj;
+aazak;
+aazal;
+aazam;
+aazan;
+aazao;
+aazap;
+aazaq;
+aazar;
+aazas;
+aazat;
+aazau;
+aazav;
+aazaw;
+aazax;
+aazay;
+aazaz;
+aazba;
+aazbb;
+aazbc;
+aazbd;
+aazbe;
+aazbf;
+aazbg;
+aazbh;
+aazbi;
+aazbj;
+aazbk;
+aazbl;
+aazbm;
+aazbn;
+aazbo;
+aazbp;
+aazbq;
+aazbr;
+aazbs;
+aazbt;
+aazbu;
+aazbv;
+aazbw;
+aazbx;
+aazby;
+aazbz;
+aazca;
+aazcb;
+aazcc;
+aazcd;
+aazce;
+aazcf;
+aazcg;
+aazch;
+aazci;
+aazcj;
+aazck;
+aazcl;
+aazcm;
+aazcn;
+aazco;
+aazcp;
+aazcq;
+aazcr;
+aazcs;
+aazct;
+aazcu;
+aazcv;
+aazcw;
+aazcx;
+aazcy;
+aazcz;
+aazda;
+aazdb;
+aazdc;
+aazdd;
+aazde;
+aazdf;
+aazdg;
+aazdh;
+aazdi;
+aazdj;
+aazdk;
+aazdl;
+aazdm;
+aazdn;
+aazdo;
+aazdp;
+aazdq;
+aazdr;
+aazds;
+aazdt;
+aazdu;
+aazdv;
+aazdw;
+aazdx;
+aazdy;
+aazdz;
+aazea;
+aazeb;
+aazec;
+aazed;
+aazee;
+aazef;
+aazeg;
+aazeh;
+aazei;
+aazej;
+aazek;
+aazel;
+aazem;
+aazen;
+aazeo;
+aazep;
+aazeq;
+aazer;
+aazes;
+aazet;
+aazeu;
+aazev;
+aazew;
+aazex;
+aazey;
+aazez;
+aazfa;
+aazfb;
+aazfc;
+aazfd;
+aazfe;
+aazff;
+aazfg;
+aazfh;
+aazfi;
+aazfj;
+aazfk;
+aazfl;
+aazfm;
+aazfn;
+aazfo;
+aazfp;
+aazfq;
+aazfr;
+aazfs;
+aazft;
+aazfu;
+aazfv;
+aazfw;
+aazfx;
+aazfy;
+aazfz;
+aazga;
+aazgb;
+aazgc;
+aazgd;
+aazge;
+aazgf;
+aazgg;
+aazgh;
+aazgi;
+aazgj;
+aazgk;
+aazgl;
+aazgm;
+aazgn;
+aazgo;
+aazgp;
+aazgq;
+aazgr;
+aazgs;
+aazgt;
+aazgu;
+aazgv;
+aazgw;
+aazgx;
+aazgy;
+aazgz;
+aazha;
+aazhb;
+aazhc;
+aazhd;
+aazhe;
+aazhf;
+aazhg;
+aazhh;
+aazhi;
+aazhj;
+aazhk;
+aazhl;
+aazhm;
+aazhn;
+aazho;
+aazhp;
+aazhq;
+aazhr;
+aazhs;
+aazht;
+aazhu;
+aazhv;
+aazhw;
+aazhx;
+aazhy;
+aazhz;
+aazia;
+aazib;
+aazic;
+aazid;
+aazie;
+aazif;
+aazig;
+aazih;
+aazii;
+aazij;
+aazik;
+aazil;
+aazim;
+aazin;
+aazio;
+aazip;
+aaziq;
+aazir;
+aazis;
+aazit;
+aaziu;
+aaziv;
+aaziw;
+aazix;
+aaziy;
+aaziz;
+aazja;
+aazjb;
+aazjc;
+aazjd;
+aazje;
+aazjf;
+aazjg;
+aazjh;
+aazji;
+aazjj;
+aazjk;
+aazjl;
+aazjm;
+aazjn;
+aazjo;
+aazjp;
+aazjq;
+aazjr;
+aazjs;
+aazjt;
+aazju;
+aazjv;
+aazjw;
+aazjx;
+aazjy;
+aazjz;
+aazka;
+aazkb;
+aazkc;
+aazkd;
+aazke;
+aazkf;
+aazkg;
+aazkh;
+aazki;
+aazkj;
+aazkk;
+aazkl;
+aazkm;
+aazkn;
+aazko;
+aazkp;
+aazkq;
+aazkr;
+aazks;
+aazkt;
+aazku;
+aazkv;
+aazkw;
+aazkx;
+aazky;
+aazkz;
+aazla;
+aazlb;
+aazlc;
+aazld;
+aazle;
+aazlf;
+aazlg;
+aazlh;
+aazli;
+aazlj;
+aazlk;
+aazll;
+aazlm;
+aazln;
+aazlo;
+aazlp;
+aazlq;
+aazlr;
+aazls;
+aazlt;
+aazlu;
+aazlv;
+aazlw;
+aazlx;
+aazly;
+aazlz;
+aazma;
+aazmb;
+aazmc;
+aazmd;
+aazme;
+aazmf;
+aazmg;
+aazmh;
+aazmi;
+aazmj;
+aazmk;
+aazml;
+aazmm;
+aazmn;
+aazmo;
+aazmp;
+aazmq;
+aazmr;
+aazms;
+aazmt;
+aazmu;
+aazmv;
+aazmw;
+aazmx;
+aazmy;
+aazmz;
+aazna;
+aaznb;
+aaznc;
+aaznd;
+aazne;
+aaznf;
+aazng;
+aaznh;
+aazni;
+aaznj;
+aaznk;
+aaznl;
+aaznm;
+aaznn;
+aazno;
+aaznp;
+aaznq;
+aaznr;
+aazns;
+aaznt;
+aaznu;
+aaznv;
+aaznw;
+aaznx;
+aazny;
+aaznz;
+aazoa;
+aazob;
+aazoc;
+aazod;
+aazoe;
+aazof;
+aazog;
+aazoh;
+aazoi;
+aazoj;
+aazok;
+aazol;
+aazom;
+aazon;
+aazoo;
+aazop;
+aazoq;
+aazor;
+aazos;
+aazot;
+aazou;
+aazov;
+aazow;
+aazox;
+aazoy;
+aazoz;
+aazpa;
+aazpb;
+aazpc;
+aazpd;
+aazpe;
+aazpf;
+aazpg;
+aazph;
+aazpi;
+aazpj;
+aazpk;
+aazpl;
+aazpm;
+aazpn;
+aazpo;
+aazpp;
+aazpq;
+aazpr;
+aazps;
+aazpt;
+aazpu;
+aazpv;
+aazpw;
+aazpx;
+aazpy;
+aazpz;
+aazqa;
+aazqb;
+aazqc;
+aazqd;
+aazqe;
+aazqf;
+aazqg;
+aazqh;
+aazqi;
+aazqj;
+aazqk;
+aazql;
+aazqm;
+aazqn;
+aazqo;
+aazqp;
+aazqq;
+aazqr;
+aazqs;
+aazqt;
+aazqu;
+aazqv;
+aazqw;
+aazqx;
+aazqy;
+aazqz;
+aazra;
+aazrb;
+aazrc;
+aazrd;
+aazre;
+aazrf;
+aazrg;
+aazrh;
+aazri;
+aazrj;
+aazrk;
+aazrl;
+aazrm;
+aazrn;
+aazro;
+aazrp;
+aazrq;
+aazrr;
+aazrs;
+aazrt;
+aazru;
+aazrv;
+aazrw;
+aazrx;
+aazry;
+aazrz;
+aazsa;
+aazsb;
+aazsc;
+aazsd;
+aazse;
+aazsf;
+aazsg;
+aazsh;
+aazsi;
+aazsj;
+aazsk;
+aazsl;
+aazsm;
+aazsn;
+aazso;
+aazsp;
+aazsq;
+aazsr;
+aazss;
+aazst;
+aazsu;
+aazsv;
+aazsw;
+aazsx;
+aazsy;
+aazsz;
+aazta;
+aaztb;
+aaztc;
+aaztd;
+aazte;
+aaztf;
+aaztg;
+aazth;
+aazti;
+aaztj;
+aaztk;
+aaztl;
+aaztm;
+aaztn;
+aazto;
+aaztp;
+aaztq;
+aaztr;
+aazts;
+aaztt;
+aaztu;
+aaztv;
+aaztw;
+aaztx;
+aazty;
+aaztz;
+aazua;
+aazub;
+aazuc;
+aazud;
+aazue;
+aazuf;
+aazug;
+aazuh;
+aazui;
+aazuj;
+aazuk;
+aazul;
+aazum;
+aazun;
+aazuo;
+aazup;
+aazuq;
+aazur;
+aazus;
+aazut;
+aazuu;
+aazuv;
+aazuw;
+aazux;
+aazuy;
+aazuz;
+aazva;
+aazvb;
+aazvc;
+aazvd;
+aazve;
+aazvf;
+aazvg;
+aazvh;
+aazvi;
+aazvj;
+aazvk;
+aazvl;
+aazvm;
+aazvn;
+aazvo;
+aazvp;
+aazvq;
+aazvr;
+aazvs;
+aazvt;
+aazvu;
+aazvv;
+aazvw;
+aazvx;
+aazvy;
+aazvz;
+aazwa;
+aazwb;
+aazwc;
+aazwd;
+aazwe;
+aazwf;
+aazwg;
+aazwh;
+aazwi;
+aazwj;
+aazwk;
+aazwl;
+aazwm;
+aazwn;
+aazwo;
+aazwp;
+aazwq;
+aazwr;
+aazws;
+aazwt;
+aazwu;
+aazwv;
+aazww;
+aazwx;
+aazwy;
+aazwz;
+aazxa;
+aazxb;
+aazxc;
+aazxd;
+aazxe;
+aazxf;
+aazxg;
+aazxh;
+aazxi;
+aazxj;
+aazxk;
+aazxl;
+aazxm;
+aazxn;
+aazxo;
+aazxp;
+aazxq;
+aazxr;
+aazxs;
+aazxt;
+aazxu;
+aazxv;
+aazxw;
+aazxx;
+aazxy;
+aazxz;
+aazya;
+aazyb;
+aazyc;
+aazyd;
+aazye;
+aazyf;
+aazyg;
+aazyh;
+aazyi;
+aazyj;
+aazyk;
+aazyl;
+aazym;
+aazyn;
+aazyo;
+aazyp;
+aazyq;
+aazyr;
+aazys;
+aazyt;
+aazyu;
+aazyv;
+aazyw;
+aazyx;
+aazyy;
+aazyz;
+aazza;
+aazzb;
+aazzc;
+aazzd;
+aazze;
+aazzf;
+aazzg;
+aazzh;
+aazzi;
+aazzj;
+aazzk;
+aazzl;
+aazzm;
+aazzn;
+aazzo;
+aazzp;
+aazzq;
+aazzr;
+aazzs;
+aazzt;
+aazzu;
+aazzv;
+aazzw;
+aazzx;
+aazzy;
+aazzz;
+abaaa;
+abaab;
+abaac;
+abaad;
+abaae;
+abaaf;
+abaag;
+abaah;
+abaai;
+abaaj;
+abaak;
+abaal;
+abaam;
+abaan;
+abaao;
+abaap;
+abaaq;
+abaar;
+abaas;
+abaat;
+abaau;
+abaav;
+abaaw;
+abaax;
+abaay;
+abaaz;
+ababa;
+ababb;
+ababc;
+ababd;
+ababe;
+ababf;
+ababg;
+ababh;
+ababi;
+ababj;
+ababk;
+ababl;
+ababm;
+ababn;
+ababo;
+ababp;
+ababq;
+ababr;
+ababs;
+ababt;
+ababu;
+ababv;
+ababw;
+ababx;
+ababy;
+ababz;
+abaca;
+abacb;
+abacc;
+abacd;
+abace;
+abacf;
+abacg;
+abach;
+abaci;
+abacj;
+aback;
+abacl;
+abacm;
+abacn;
+abaco;
+abacp;
+abacq;
+abacr;
+abacs;
+abact;
+abacu;
+abacv;
+abacw;
+abacx;
+abacy;
+abacz;
+abada;
+abadb;
+abadc;
+abadd;
+abade;
+abadf;
+abadg;
+abadh;
+abadi;
+abadj;
+abadk;
+abadl;
+abadm;
+abadn;
+abado;
+abadp;
+abadq;
+abadr;
+abads;
+abadt;
+abadu;
+abadv;
+abadw;
+abadx;
+abady;
+abadz;
+abaea;
+abaeb;
+abaec;
+abaed;
+abaee;
+abaef;
+abaeg;
+abaeh;
+abaei;
+abaej;
+abaek;
+abael;
+abaem;
+abaen;
+abaeo;
+abaep;
+abaeq;
+abaer;
+abaes;
+abaet;
+abaeu;
+abaev;
+abaew;
+abaex;
+abaey;
+abaez;
+abafa;
+abafb;
+abafc;
+abafd;
+abafe;
+abaff;
+abafg;
+abafh;
+abafi;
+abafj;
+abafk;
+abafl;
+abafm;
+abafn;
+abafo;
+abafp;
+abafq;
+abafr;
+abafs;
+abaft;
+abafu;
+abafv;
+abafw;
+abafx;
+abafy;
+abafz;
+abaga;
+abagb;
+abagc;
+abagd;
+abage;
+abagf;
+abagg;
+abagh;
+abagi;
+abagj;
+abagk;
+abagl;
+abagm;
+abagn;
+abago;
+abagp;
+abagq;
+abagr;
+abags;
+abagt;
+abagu;
+abagv;
+abagw;
+abagx;
+abagy;
+abagz;
+abaha;
+abahb;
+abahc;
+abahd;
+abahe;
+abahf;
+abahg;
+abahh;
+abahi;
+abahj;
+abahk;
+abahl;
+abahm;
+abahn;
+abaho;
+abahp;
+abahq;
+abahr;
+abahs;
+abaht;
+abahu;
+abahv;
+abahw;
+abahx;
+abahy;
+abahz;
+abaia;
+abaib;
+abaic;
+abaid;
+abaie;
+abaif;
+abaig;
+abaih;
+abaii;
+abaij;
+abaik;
+abail;
+abaim;
+abain;
+abaio;
+abaip;
+abaiq;
+abair;
+abais;
+abait;
+abaiu;
+abaiv;
+abaiw;
+abaix;
+abaiy;
+abaiz;
+abaja;
+abajb;
+abajc;
+abajd;
+abaje;
+abajf;
+abajg;
+abajh;
+abaji;
+abajj;
+abajk;
+abajl;
+abajm;
+abajn;
+abajo;
+abajp;
+abajq;
+abajr;
+abajs;
+abajt;
+abaju;
+abajv;
+abajw;
+abajx;
+abajy;
+abajz;
+abaka;
+abakb;
+abakc;
+abakd;
+abake;
+abakf;
+abakg;
+abakh;
+abaki;
+abakj;
+abakk;
+abakl;
+abakm;
+abakn;
+abako;
+abakp;
+abakq;
+abakr;
+abaks;
+abakt;
+abaku;
+abakv;
+abakw;
+abakx;
+abaky;
+abakz;
+abala;
+abalb;
+abalc;
+abald;
+abale;
+abalf;
+abalg;
+abalh;
+abali;
+abalj;
+abalk;
+aball;
+abalm;
+abaln;
+abalo;
+abalp;
+abalq;
+abalr;
+abals;
+abalt;
+abalu;
+abalv;
+abalw;
+abalx;
+abaly;
+abalz;
+abama;
+abamb;
+abamc;
+abamd;
+abame;
+abamf;
+abamg;
+abamh;
+abami;
+abamj;
+abamk;
+abaml;
+abamm;
+abamn;
+abamo;
+abamp;
+abamq;
+abamr;
+abams;
+abamt;
+abamu;
+abamv;
+abamw;
+abamx;
+abamy;
+abamz;
+abana;
+abanb;
+abanc;
+aband;
+abane;
+abanf;
+abang;
+abanh;
+abani;
+abanj;
+abank;
+abanl;
+abanm;
+abann;
+abano;
+abanp;
+abanq;
+abanr;
+abans;
+abant;
+abanu;
+abanv;
+abanw;
+abanx;
+abany;
+abanz;
+abaoa;
+abaob;
+abaoc;
+abaod;
+abaoe;
+abaof;
+abaog;
+abaoh;
+abaoi;
+abaoj;
+abaok;
+abaol;
+abaom;
+abaon;
+abaoo;
+abaop;
+abaoq;
+abaor;
+abaos;
+abaot;
+abaou;
+abaov;
+abaow;
+abaox;
+abaoy;
+abaoz;
+abapa;
+abapb;
+abapc;
+abapd;
+abape;
+abapf;
+abapg;
+abaph;
+abapi;
+abapj;
+abapk;
+abapl;
+abapm;
+abapn;
+abapo;
+abapp;
+abapq;
+abapr;
+abaps;
+abapt;
+abapu;
+abapv;
+abapw;
+abapx;
+abapy;
+abapz;
+abaqa;
+abaqb;
+abaqc;
+abaqd;
+abaqe;
+abaqf;
+abaqg;
+abaqh;
+abaqi;
+abaqj;
+abaqk;
+abaql;
+abaqm;
+abaqn;
+abaqo;
+abaqp;
+abaqq;
+abaqr;
+abaqs;
+abaqt;
+abaqu;
+abaqv;
+abaqw;
+abaqx;
+abaqy;
+abaqz;
+abara;
+abarb;
+abarc;
+abard;
+abare;
+abarf;
+abarg;
+abarh;
+abari;
+abarj;
+abark;
+abarl;
+abarm;
+abarn;
+abaro;
+abarp;
+abarq;
+abarr;
+abars;
+abart;
+abaru;
+abarv;
+abarw;
+abarx;
+abary;
+abarz;
+abasa;
+abasb;
+abasc;
+abasd;
+abase;
+abasf;
+abasg;
+abash;
+abasi;
+abasj;
+abask;
+abasl;
+abasm;
+abasn;
+abaso;
+abasp;
+abasq;
+abasr;
+abass;
+abast;
+abasu;
+abasv;
+abasw;
+abasx;
+abasy;
+abasz;
+abata;
+abatb;
+abatc;
+abatd;
+abate;
+abatf;
+abatg;
+abath;
+abati;
+abatj;
+abatk;
+abatl;
+abatm;
+abatn;
+abato;
+abatp;
+abatq;
+abatr;
+abats;
+abatt;
+abatu;
+abatv;
+abatw;
+abatx;
+abaty;
+abatz;
+abaua;
+abaub;
+abauc;
+abaud;
+abaue;
+abauf;
+abaug;
+abauh;
+abaui;
+abauj;
+abauk;
+abaul;
+abaum;
+abaun;
+abauo;
+abaup;
+abauq;
+abaur;
+abaus;
+abaut;
+abauu;
+abauv;
+abauw;
+abaux;
+abauy;
+abauz;
+abava;
+abavb;
+abavc;
+abavd;
+abave;
+abavf;
+abavg;
+abavh;
+abavi;
+abavj;
+abavk;
+abavl;
+abavm;
+abavn;
+abavo;
+abavp;
+abavq;
+abavr;
+abavs;
+abavt;
+abavu;
+abavv;
+abavw;
+abavx;
+abavy;
+abavz;
+abawa;
+abawb;
+abawc;
+abawd;
+abawe;
+abawf;
+abawg;
+abawh;
+abawi;
+abawj;
+abawk;
+abawl;
+abawm;
+abawn;
+abawo;
+abawp;
+abawq;
+abawr;
+abaws;
+abawt;
+abawu;
+abawv;
+abaww;
+abawx;
+abawy;
+abawz;
+abaxa;
+abaxb;
+abaxc;
+abaxd;
+abaxe;
+abaxf;
+abaxg;
+abaxh;
+abaxi;
+abaxj;
+abaxk;
+abaxl;
+abaxm;
+abaxn;
+abaxo;
+abaxp;
+abaxq;
+abaxr;
+abaxs;
+abaxt;
+abaxu;
+abaxv;
+abaxw;
+abaxx;
+abaxy;
+abaxz;
+abaya;
+abayb;
+abayc;
+abayd;
+abaye;
+abayf;
+abayg;
+abayh;
+abayi;
+abayj;
+abayk;
+abayl;
+abaym;
+abayn;
+abayo;
+abayp;
+abayq;
+abayr;
+abays;
+abayt;
+abayu;
+abayv;
+abayw;
+abayx;
+abayy;
+abayz;
+abaza;
+abazb;
+abazc;
+abazd;
+abaze;
+abazf;
+abazg;
+abazh;
+abazi;
+abazj;
+abazk;
+abazl;
+abazm;
+abazn;
+abazo;
+abazp;
+abazq;
+abazr;
+abazs;
+abazt;
+abazu;
+abazv;
+abazw;
+abazx;
+abazy;
+abazz;
+abbaa;
+abbab;
+abbac;
+abbad;
+abbae;
+abbaf;
+abbag;
+abbah;
+abbai;
+abbaj;
+abbak;
+abbal;
+abbam;
+abban;
+abbao;
+abbap;
+abbaq;
+abbar;
+abbas;
+abbat;
+abbau;
+abbav;
+abbaw;
+abbax;
+abbay;
+abbaz;
+abbba;
+abbbb;
+abbbc;
+abbbd;
+abbbe;
+abbbf;
+abbbg;
+abbbh;
+abbbi;
+abbbj;
+abbbk;
+abbbl;
+abbbm;
+abbbn;
+abbbo;
+abbbp;
+abbbq;
+abbbr;
+abbbs;
+abbbt;
+abbbu;
+abbbv;
+abbbw;
+abbbx;
+abbby;
+abbbz;
+abbca;
+abbcb;
+abbcc;
+abbcd;
+abbce;
+abbcf;
+abbcg;
+abbch;
+abbci;
+abbcj;
+abbck;
+abbcl;
+abbcm;
+abbcn;
+abbco;
+abbcp;
+abbcq;
+abbcr;
+abbcs;
+abbct;
+abbcu;
+abbcv;
+abbcw;
+abbcx;
+abbcy;
+abbcz;
+abbda;
+abbdb;
+abbdc;
+abbdd;
+abbde;
+abbdf;
+abbdg;
+abbdh;
+abbdi;
+abbdj;
+abbdk;
+abbdl;
+abbdm;
+abbdn;
+abbdo;
+abbdp;
+abbdq;
+abbdr;
+abbds;
+abbdt;
+abbdu;
+abbdv;
+abbdw;
+abbdx;
+abbdy;
+abbdz;
+abbea;
+abbeb;
+abbec;
+abbed;
+abbee;
+abbef;
+abbeg;
+abbeh;
+abbei;
+abbej;
+abbek;
+abbel;
+abbem;
+abben;
+abbeo;
+abbep;
+abbeq;
+abber;
+abbes;
+abbet;
+abbeu;
+abbev;
+abbew;
+abbex;
+abbey;
+abbez;
+abbfa;
+abbfb;
+abbfc;
+abbfd;
+abbfe;
+abbff;
+abbfg;
+abbfh;
+abbfi;
+abbfj;
+abbfk;
+abbfl;
+abbfm;
+abbfn;
+abbfo;
+abbfp;
+abbfq;
+abbfr;
+abbfs;
+abbft;
+abbfu;
+abbfv;
+abbfw;
+abbfx;
+abbfy;
+abbfz;
+abbga;
+abbgb;
+abbgc;
+abbgd;
+abbge;
+abbgf;
+abbgg;
+abbgh;
+abbgi;
+abbgj;
+abbgk;
+abbgl;
+abbgm;
+abbgn;
+abbgo;
+abbgp;
+abbgq;
+abbgr;
+abbgs;
+abbgt;
+abbgu;
+abbgv;
+abbgw;
+abbgx;
+abbgy;
+abbgz;
+abbha;
+abbhb;
+abbhc;
+abbhd;
+abbhe;
+abbhf;
+abbhg;
+abbhh;
+abbhi;
+abbhj;
+abbhk;
+abbhl;
+abbhm;
+abbhn;
+abbho;
+abbhp;
+abbhq;
+abbhr;
+abbhs;
+abbht;
+abbhu;
+abbhv;
+abbhw;
+abbhx;
+abbhy;
+abbhz;
+abbia;
+abbib;
+abbic;
+abbid;
+abbie;
+abbif;
+abbig;
+abbih;
+abbii;
+abbij;
+abbik;
+abbil;
+abbim;
+abbin;
+abbio;
+abbip;
+abbiq;
+abbir;
+abbis;
+abbit;
+abbiu;
+abbiv;
+abbiw;
+abbix;
+abbiy;
+abbiz;
+abbja;
+abbjb;
+abbjc;
+abbjd;
+abbje;
+abbjf;
+abbjg;
+abbjh;
+abbji;
+abbjj;
+abbjk;
+abbjl;
+abbjm;
+abbjn;
+abbjo;
+abbjp;
+abbjq;
+abbjr;
+abbjs;
+abbjt;
+abbju;
+abbjv;
+abbjw;
+abbjx;
+abbjy;
+abbjz;
+abbka;
+abbkb;
+abbkc;
+abbkd;
+abbke;
+abbkf;
+abbkg;
+abbkh;
+abbki;
+abbkj;
+abbkk;
+abbkl;
+abbkm;
+abbkn;
+abbko;
+abbkp;
+abbkq;
+abbkr;
+abbks;
+abbkt;
+abbku;
+abbkv;
+abbkw;
+abbkx;
+abbky;
+abbkz;
+abbla;
+abblb;
+abblc;
+abbld;
+abble;
+abblf;
+abblg;
+abblh;
+abbli;
+abblj;
+abblk;
+abbll;
+abblm;
+abbln;
+abblo;
+abblp;
+abblq;
+abblr;
+abbls;
+abblt;
+abblu;
+abblv;
+abblw;
+abblx;
+abbly;
+abblz;
+abbma;
+abbmb;
+abbmc;
+abbmd;
+abbme;
+abbmf;
+abbmg;
+abbmh;
+abbmi;
+abbmj;
+abbmk;
+abbml;
+abbmm;
+abbmn;
+abbmo;
+abbmp;
+abbmq;
+abbmr;
+abbms;
+abbmt;
+abbmu;
+abbmv;
+abbmw;
+abbmx;
+abbmy;
+abbmz;
+abbna;
+abbnb;
+abbnc;
+abbnd;
+abbne;
+abbnf;
+abbng;
+abbnh;
+abbni;
+abbnj;
+abbnk;
+abbnl;
+abbnm;
+abbnn;
+abbno;
+abbnp;
+abbnq;
+abbnr;
+abbns;
+abbnt;
+abbnu;
+abbnv;
+abbnw;
+abbnx;
+abbny;
+abbnz;
+abboa;
+abbob;
+abboc;
+abbod;
+abboe;
+abbof;
+abbog;
+abboh;
+abboi;
+abboj;
+abbok;
+abbol;
+abbom;
+abbon;
+abboo;
+abbop;
+abboq;
+abbor;
+abbos;
+abbot;
+abbou;
+abbov;
+abbow;
+abbox;
+abboy;
+abboz;
+abbpa;
+abbpb;
+abbpc;
+abbpd;
+abbpe;
+abbpf;
+abbpg;
+abbph;
+abbpi;
+abbpj;
+abbpk;
+abbpl;
+abbpm;
+abbpn;
+abbpo;
+abbpp;
+abbpq;
+abbpr;
+abbps;
+abbpt;
+abbpu;
+abbpv;
+abbpw;
+abbpx;
+abbpy;
+abbpz;
+abbqa;
+abbqb;
+abbqc;
+abbqd;
+abbqe;
+abbqf;
+abbqg;
+abbqh;
+abbqi;
+abbqj;
+abbqk;
+abbql;
+abbqm;
+abbqn;
+abbqo;
+abbqp;
+abbqq;
+abbqr;
+abbqs;
+abbqt;
+abbqu;
+abbqv;
+abbqw;
+abbqx;
+abbqy;
+abbqz;
+abbra;
+abbrb;
+abbrc;
+abbrd;
+abbre;
+abbrf;
+abbrg;
+abbrh;
+abbri;
+abbrj;
+abbrk;
+abbrl;
+abbrm;
+abbrn;
+abbro;
+abbrp;
+abbrq;
+abbrr;
+abbrs;
+abbrt;
+abbru;
+abbrv;
+abbrw;
+abbrx;
+abbry;
+abbrz;
+abbsa;
+abbsb;
+abbsc;
+abbsd;
+abbse;
+abbsf;
+abbsg;
+abbsh;
+abbsi;
+abbsj;
+abbsk;
+abbsl;
+abbsm;
+abbsn;
+abbso;
+abbsp;
+abbsq;
+abbsr;
+abbss;
+abbst;
+abbsu;
+abbsv;
+abbsw;
+abbsx;
+abbsy;
+abbsz;
+abbta;
+abbtb;
+abbtc;
+abbtd;
+abbte;
+abbtf;
+abbtg;
+abbth;
+abbti;
+abbtj;
+abbtk;
+abbtl;
+abbtm;
+abbtn;
+abbto;
+abbtp;
+abbtq;
+abbtr;
+abbts;
+abbtt;
+abbtu;
+abbtv;
+abbtw;
+abbtx;
+abbty;
+abbtz;
+abbua;
+abbub;
+abbuc;
+abbud;
+abbue;
+abbuf;
+abbug;
+abbuh;
+abbui;
+abbuj;
+abbuk;
+abbul;
+abbum;
+abbun;
+abbuo;
+abbup;
+abbuq;
+abbur;
+abbus;
+abbut;
+abbuu;
+abbuv;
+abbuw;
+abbux;
+abbuy;
+abbuz;
+abbva;
+abbvb;
+abbvc;
+abbvd;
+abbve;
+abbvf;
+abbvg;
+abbvh;
+abbvi;
+abbvj;
+abbvk;
+abbvl;
+abbvm;
+abbvn;
+abbvo;
+abbvp;
+abbvq;
+abbvr;
+abbvs;
+abbvt;
+abbvu;
+abbvv;
+abbvw;
+abbvx;
+abbvy;
+abbvz;
+abbwa;
+abbwb;
+abbwc;
+abbwd;
+abbwe;
+abbwf;
+abbwg;
+abbwh;
+abbwi;
+abbwj;
+abbwk;
+abbwl;
+abbwm;
+abbwn;
+abbwo;
+abbwp;
+abbwq;
+abbwr;
+abbws;
+abbwt;
+abbwu;
+abbwv;
+abbww;
+abbwx;
+abbwy;
+abbwz;
+abbxa;
+abbxb;
+abbxc;
+abbxd;
+abbxe;
+abbxf;
+abbxg;
+abbxh;
+abbxi;
+abbxj;
+abbxk;
+abbxl;
+abbxm;
+abbxn;
+abbxo;
+abbxp;
+abbxq;
+abbxr;
+abbxs;
+abbxt;
+abbxu;
+abbxv;
+abbxw;
+abbxx;
+abbxy;
+abbxz;
+abbya;
+abbyb;
+abbyc;
+abbyd;
+abbye;
+abbyf;
+abbyg;
+abbyh;
+abbyi;
+abbyj;
+abbyk;
+abbyl;
+abbym;
+abbyn;
+abbyo;
+abbyp;
+abbyq;
+abbyr;
+abbys;
+abbyt;
+abbyu;
+abbyv;
+abbyw;
+abbyx;
+abbyy;
+abbyz;
+abbza;
+abbzb;
+abbzc;
+abbzd;
+abbze;
+abbzf;
+abbzg;
+abbzh;
+abbzi;
+abbzj;
+abbzk;
+abbzl;
+abbzm;
+abbzn;
+abbzo;
+abbzp;
+abbzq;
+abbzr;
+abbzs;
+abbzt;
+abbzu;
+abbzv;
+abbzw;
+abbzx;
+abbzy;
+abbzz;
+abcaa;
+abcab;
+abcac;
+abcad;
+abcae;
+abcaf;
+abcag;
+abcah;
+abcai;
+abcaj;
+abcak;
+abcal;
+abcam;
+abcan;
+abcao;
+abcap;
+abcaq;
+abcar;
+abcas;
+abcat;
+abcau;
+abcav;
+abcaw;
+abcax;
+abcay;
+abcaz;
+abcba;
+abcbb;
+abcbc;
+abcbd;
+abcbe;
+abcbf;
+abcbg;
+abcbh;
+abcbi;
+abcbj;
+abcbk;
+abcbl;
+abcbm;
+abcbn;
+abcbo;
+abcbp;
+abcbq;
+abcbr;
+abcbs;
+abcbt;
+abcbu;
+abcbv;
+abcbw;
+abcbx;
+abcby;
+abcbz;
+abcca;
+abccb;
+abccc;
+abccd;
+abcce;
+abccf;
+abccg;
+abcch;
+abcci;
+abccj;
+abcck;
+abccl;
+abccm;
+abccn;
+abcco;
+abccp;
+abccq;
+abccr;
+abccs;
+abcct;
+abccu;
+abccv;
+abccw;
+abccx;
+abccy;
+abccz;
+abcda;
+abcdb;
+abcdc;
+abcdd;
+abcde;
+abcdf;
+abcdg;
+abcdh;
+abcdi;
+abcdj;
+abcdk;
+abcdl;
+abcdm;
+abcdn;
+abcdo;
+abcdp;
+abcdq;
+abcdr;
+abcds;
+abcdt;
+abcdu;
+abcdv;
+abcdw;
+abcdx;
+abcdy;
+abcdz;
+abcea;
+abceb;
+abcec;
+abced;
+abcee;
+abcef;
+abceg;
+abceh;
+abcei;
+abcej;
+abcek;
+abcel;
+abcem;
+abcen;
+abceo;
+abcep;
+abceq;
+abcer;
+abces;
+abcet;
+abceu;
+abcev;
+abcew;
+abcex;
+abcey;
+abcez;
+abcfa;
+abcfb;
+abcfc;
+abcfd;
+abcfe;
+abcff;
+abcfg;
+abcfh;
+abcfi;
+abcfj;
+abcfk;
+abcfl;
+abcfm;
+abcfn;
+abcfo;
+abcfp;
+abcfq;
+abcfr;
+abcfs;
+abcft;
+abcfu;
+abcfv;
+abcfw;
+abcfx;
+abcfy;
+abcfz;
+abcga;
+abcgb;
+abcgc;
+abcgd;
+abcge;
+abcgf;
+abcgg;
+abcgh;
+abcgi;
+abcgj;
+abcgk;
+abcgl;
+abcgm;
+abcgn;
+abcgo;
+abcgp;
+abcgq;
+abcgr;
+abcgs;
+abcgt;
+abcgu;
+abcgv;
+abcgw;
+abcgx;
+abcgy;
+abcgz;
+abcha;
+abchb;
+abchc;
+abchd;
+abche;
+abchf;
+abchg;
+abchh;
+abchi;
+abchj;
+abchk;
+abchl;
+abchm;
+abchn;
+abcho;
+abchp;
+abchq;
+abchr;
+abchs;
+abcht;
+abchu;
+abchv;
+abchw;
+abchx;
+abchy;
+abchz;
+abcia;
+abcib;
+abcic;
+abcid;
+abcie;
+abcif;
+abcig;
+abcih;
+abcii;
+abcij;
+abcik;
+abcil;
+abcim;
+abcin;
+abcio;
+abcip;
+abciq;
+abcir;
+abcis;
+abcit;
+abciu;
+abciv;
+abciw;
+abcix;
+abciy;
+abciz;
+abcja;
+abcjb;
+abcjc;
+abcjd;
+abcje;
+abcjf;
+abcjg;
+abcjh;
+abcji;
+abcjj;
+abcjk;
+abcjl;
+abcjm;
+abcjn;
+abcjo;
+abcjp;
+abcjq;
+abcjr;
+abcjs;
+abcjt;
+abcju;
+abcjv;
+abcjw;
+abcjx;
+abcjy;
+abcjz;
+abcka;
+abckb;
+abckc;
+abckd;
+abcke;
+abckf;
+abckg;
+abckh;
+abcki;
+abckj;
+abckk;
+abckl;
+abckm;
+abckn;
+abcko;
+abckp;
+abckq;
+abckr;
+abcks;
+abckt;
+abcku;
+abckv;
+abckw;
+abckx;
+abcky;
+abckz;
+abcla;
+abclb;
+abclc;
+abcld;
+abcle;
+abclf;
+abclg;
+abclh;
+abcli;
+abclj;
+abclk;
+abcll;
+abclm;
+abcln;
+abclo;
+abclp;
+abclq;
+abclr;
+abcls;
+abclt;
+abclu;
+abclv;
+abclw;
+abclx;
+abcly;
+abclz;
+abcma;
+abcmb;
+abcmc;
+abcmd;
+abcme;
+abcmf;
+abcmg;
+abcmh;
+abcmi;
+abcmj;
+abcmk;
+abcml;
+abcmm;
+abcmn;
+abcmo;
+abcmp;
+abcmq;
+abcmr;
+abcms;
+abcmt;
+abcmu;
+abcmv;
+abcmw;
+abcmx;
+abcmy;
+abcmz;
+abcna;
+abcnb;
+abcnc;
+abcnd;
+abcne;
+abcnf;
+abcng;
+abcnh;
+abcni;
+abcnj;
+abcnk;
+abcnl;
+abcnm;
+abcnn;
+abcno;
+abcnp;
+abcnq;
+abcnr;
+abcns;
+abcnt;
+abcnu;
+abcnv;
+abcnw;
+abcnx;
+abcny;
+abcnz;
+abcoa;
+abcob;
+abcoc;
+abcod;
+abcoe;
+abcof;
+abcog;
+abcoh;
+abcoi;
+abcoj;
+abcok;
+abcol;
+abcom;
+abcon;
+abcoo;
+abcop;
+abcoq;
+abcor;
+abcos;
+abcot;
+abcou;
+abcov;
+abcow;
+abcox;
+abcoy;
+abcoz;
+abcpa;
+abcpb;
+abcpc;
+abcpd;
+abcpe;
+abcpf;
+abcpg;
+abcph;
+abcpi;
+abcpj;
+abcpk;
+abcpl;
+abcpm;
+abcpn;
+abcpo;
+abcpp;
+abcpq;
+abcpr;
+abcps;
+abcpt;
+abcpu;
+abcpv;
+abcpw;
+abcpx;
+abcpy;
+abcpz;
+abcqa;
+abcqb;
+abcqc;
+abcqd;
+abcqe;
+abcqf;
+abcqg;
+abcqh;
+abcqi;
+abcqj;
+abcqk;
+abcql;
+abcqm;
+abcqn;
+abcqo;
+abcqp;
+abcqq;
+abcqr;
+abcqs;
+abcqt;
+abcqu;
+abcqv;
+abcqw;
+abcqx;
+abcqy;
+abcqz;
+abcra;
+abcrb;
+abcrc;
+abcrd;
+abcre;
+abcrf;
+abcrg;
+abcrh;
+abcri;
+abcrj;
+abcrk;
+abcrl;
+abcrm;
+abcrn;
+abcro;
+abcrp;
+abcrq;
+abcrr;
+abcrs;
+abcrt;
+abcru;
+abcrv;
+abcrw;
+abcrx;
+abcry;
+abcrz;
+abcsa;
+abcsb;
+abcsc;
+abcsd;
+abcse;
+abcsf;
+abcsg;
+abcsh;
+abcsi;
+abcsj;
+abcsk;
+abcsl;
+abcsm;
+abcsn;
+abcso;
+abcsp;
+abcsq;
+abcsr;
+abcss;
+abcst;
+abcsu;
+abcsv;
+abcsw;
+abcsx;
+abcsy;
+abcsz;
+abcta;
+abctb;
+abctc;
+abctd;
+abcte;
+abctf;
+abctg;
+abcth;
+abcti;
+abctj;
+abctk;
+abctl;
+abctm;
+abctn;
+abcto;
+abctp;
+abctq;
+abctr;
+abcts;
+abctt;
+abctu;
+abctv;
+abctw;
+abctx;
+abcty;
+abctz;
+abcua;
+abcub;
+abcuc;
+abcud;
+abcue;
+abcuf;
+abcug;
+abcuh;
+abcui;
+abcuj;
+abcuk;
+abcul;
+abcum;
+abcun;
+abcuo;
+abcup;
+abcuq;
+abcur;
+abcus;
+abcut;
+abcuu;
+abcuv;
+abcuw;
+abcux;
+abcuy;
+abcuz;
+abcva;
+abcvb;
+abcvc;
+abcvd;
+abcve;
+abcvf;
+abcvg;
+abcvh;
+abcvi;
+abcvj;
+abcvk;
+abcvl;
+abcvm;
+abcvn;
+abcvo;
+abcvp;
+abcvq;
+abcvr;
+abcvs;
+abcvt;
+abcvu;
+abcvv;
+abcvw;
+abcvx;
+abcvy;
+abcvz;
+abcwa;
+abcwb;
+abcwc;
+abcwd;
+abcwe;
+abcwf;
+abcwg;
+abcwh;
+abcwi;
+abcwj;
+abcwk;
+abcwl;
+abcwm;
+abcwn;
+abcwo;
+abcwp;
+abcwq;
+abcwr;
+abcws;
+abcwt;
+abcwu;
+abcwv;
+abcww;
+abcwx;
+abcwy;
+abcwz;
+abcxa;
+abcxb;
+abcxc;
+abcxd;
+abcxe;
+abcxf;
+abcxg;
+abcxh;
+abcxi;
+abcxj;
+abcxk;
+abcxl;
+abcxm;
+abcxn;
+abcxo;
+abcxp;
+abcxq;
+abcxr;
+abcxs;
+abcxt;
+abcxu;
+abcxv;
+abcxw;
+abcxx;
+abcxy;
+abcxz;
+abcya;
+abcyb;
+abcyc;
+abcyd;
+abcye;
+abcyf;
+abcyg;
+abcyh;
+abcyi;
+abcyj;
+abcyk;
+abcyl;
+abcym;
+abcyn;
+abcyo;
+abcyp;
+abcyq;
+abcyr;
+abcys;
+abcyt;
+abcyu;
+abcyv;
+abcyw;
+abcyx;
+abcyy;
+abcyz;
+abcza;
+abczb;
+abczc;
+abczd;
+abcze;
+abczf;
+abczg;
+abczh;
+abczi;
+abczj;
+abczk;
+abczl;
+abczm;
+abczn;
+abczo;
+abczp;
+abczq;
+abczr;
+abczs;
+abczt;
+abczu;
+abczv;
+abczw;
+abczx;
+abczy;
+abczz;
+abdaa;
+abdab;
+abdac;
+abdad;
+abdae;
+abdaf;
+abdag;
+abdah;
+abdai;
+abdaj;
+abdak;
+abdal;
+abdam;
+abdan;
+abdao;
+abdap;
+abdaq;
+abdar;
+abdas;
+abdat;
+abdau;
+abdav;
+abdaw;
+abdax;
+abday;
+abdaz;
+abdba;
+abdbb;
+abdbc;
+abdbd;
+abdbe;
+abdbf;
+abdbg;
+abdbh;
+abdbi;
+abdbj;
+abdbk;
+abdbl;
+abdbm;
+abdbn;
+abdbo;
+abdbp;
+abdbq;
+abdbr;
+abdbs;
+abdbt;
+abdbu;
+abdbv;
+abdbw;
+abdbx;
+abdby;
+abdbz;
+abdca;
+abdcb;
+abdcc;
+abdcd;
+abdce;
+abdcf;
+abdcg;
+abdch;
+abdci;
+abdcj;
+abdck;
+abdcl;
+abdcm;
+abdcn;
+abdco;
+abdcp;
+abdcq;
+abdcr;
+abdcs;
+abdct;
+abdcu;
+abdcv;
+abdcw;
+abdcx;
+abdcy;
+abdcz;
+abdda;
+abddb;
+abddc;
+abddd;
+abdde;
+abddf;
+abddg;
+abddh;
+abddi;
+abddj;
+abddk;
+abddl;
+abddm;
+abddn;
+abddo;
+abddp;
+abddq;
+abddr;
+abdds;
+abddt;
+abddu;
+abddv;
+abddw;
+abddx;
+abddy;
+abddz;
+abdea;
+abdeb;
+abdec;
+abded;
+abdee;
+abdef;
+abdeg;
+abdeh;
+abdei;
+abdej;
+abdek;
+abdel;
+abdem;
+abden;
+abdeo;
+abdep;
+abdeq;
+abder;
+abdes;
+abdet;
+abdeu;
+abdev;
+abdew;
+abdex;
+abdey;
+abdez;
+abdfa;
+abdfb;
+abdfc;
+abdfd;
+abdfe;
+abdff;
+abdfg;
+abdfh;
+abdfi;
+abdfj;
+abdfk;
+abdfl;
+abdfm;
+abdfn;
+abdfo;
+abdfp;
+abdfq;
+abdfr;
+abdfs;
+abdft;
+abdfu;
+abdfv;
+abdfw;
+abdfx;
+abdfy;
+abdfz;
+abdga;
+abdgb;
+abdgc;
+abdgd;
+abdge;
+abdgf;
+abdgg;
+abdgh;
+abdgi;
+abdgj;
+abdgk;
+abdgl;
+abdgm;
+abdgn;
+abdgo;
+abdgp;
+abdgq;
+abdgr;
+abdgs;
+abdgt;
+abdgu;
+abdgv;
+abdgw;
+abdgx;
+abdgy;
+abdgz;
+abdha;
+abdhb;
+abdhc;
+abdhd;
+abdhe;
+abdhf;
+abdhg;
+abdhh;
+abdhi;
+abdhj;
+abdhk;
+abdhl;
+abdhm;
+abdhn;
+abdho;
+abdhp;
+abdhq;
+abdhr;
+abdhs;
+abdht;
+abdhu;
+abdhv;
+abdhw;
+abdhx;
+abdhy;
+abdhz;
+abdia;
+abdib;
+abdic;
+abdid;
+abdie;
+abdif;
+abdig;
+abdih;
+abdii;
+abdij;
+abdik;
+abdil;
+abdim;
+abdin;
+abdio;
+abdip;
+abdiq;
+abdir;
+abdis;
+abdit;
+abdiu;
+abdiv;
+abdiw;
+abdix;
+abdiy;
+abdiz;
+abdja;
+abdjb;
+abdjc;
+abdjd;
+abdje;
+abdjf;
+abdjg;
+abdjh;
+abdji;
+abdjj;
+abdjk;
+abdjl;
+abdjm;
+abdjn;
+abdjo;
+abdjp;
+abdjq;
+abdjr;
+abdjs;
+abdjt;
+abdju;
+abdjv;
+abdjw;
+abdjx;
+abdjy;
+abdjz;
+abdka;
+abdkb;
+abdkc;
+abdkd;
+abdke;
+abdkf;
+abdkg;
+abdkh;
+abdki;
+abdkj;
+abdkk;
+abdkl;
+abdkm;
+abdkn;
+abdko;
+abdkp;
+abdkq;
+abdkr;
+abdks;
+abdkt;
+abdku;
+abdkv;
+abdkw;
+abdkx;
+abdky;
+abdkz;
+abdla;
+abdlb;
+abdlc;
+abdld;
+abdle;
+abdlf;
+abdlg;
+abdlh;
+abdli;
+abdlj;
+abdlk;
+abdll;
+abdlm;
+abdln;
+abdlo;
+abdlp;
+abdlq;
+abdlr;
+abdls;
+abdlt;
+abdlu;
+abdlv;
+abdlw;
+abdlx;
+abdly;
+abdlz;
+abdma;
+abdmb;
+abdmc;
+abdmd;
+abdme;
+abdmf;
+abdmg;
+abdmh;
+abdmi;
+abdmj;
+abdmk;
+abdml;
+abdmm;
+abdmn;
+abdmo;
+abdmp;
+abdmq;
+abdmr;
+abdms;
+abdmt;
+abdmu;
+abdmv;
+abdmw;
+abdmx;
+abdmy;
+abdmz;
+abdna;
+abdnb;
+abdnc;
+abdnd;
+abdne;
+abdnf;
+abdng;
+abdnh;
+abdni;
+abdnj;
+abdnk;
+abdnl;
+abdnm;
+abdnn;
+abdno;
+abdnp;
+abdnq;
+abdnr;
+abdns;
+abdnt;
+abdnu;
+abdnv;
+abdnw;
+abdnx;
+abdny;
+abdnz;
+abdoa;
+abdob;
+abdoc;
+abdod;
+abdoe;
+abdof;
+abdog;
+abdoh;
+abdoi;
+abdoj;
+abdok;
+abdol;
+abdom;
+abdon;
+abdoo;
+abdop;
+abdoq;
+abdor;
+abdos;
+abdot;
+abdou;
+abdov;
+abdow;
+abdox;
+abdoy;
+abdoz;
+abdpa;
+abdpb;
+abdpc;
+abdpd;
+aljwf
+|];
--- /dev/null
+let _ = (fun x -> x), 1
+let _ = (x := 1), 2
+let _ = (x <- 1), 2
+let _ = (if true then 1 else 2), 1
--- /dev/null
+match [] with []°-> () | _ -> ();;
--- /dev/null
+fun a -> x <- !x + 1; x <- !x + 2
--- /dev/null
+type t = A of t | B ;;
+let f = function A A B -> B | B | A B | A (A _) -> B ;;
+
+exception True
+let qexists f q =
+ try
+ Queue.iter (fun v -> if f v then raise True) q;
+ false
+ with True -> true
+
+type u = True | False
+let g x = function | True -> () | False -> ()
+
+type v = [`True | `False]
+let h x = function | `True -> () | `False -> ()
--- /dev/null
+(* Some Some Some None;; *)
+(* ((Some None) None) None;; *)
+((Some) None);;
+(* ((Some Some) Some) None;; *)
+type t = A of int * int * int;;
+A (1, 2, 3);;
+(A) (1, 2, 3);;
+(A (1, 2)) 3;;
--- /dev/null
+type t = A of t * t | B;;
+type t2 = C of (t2 * t2) | D;;
+type 'a t3 = S of 'a | T;;
+
+fun B B B -> ();;
+
+fun B (A (B, B)) B -> ();;
+
+fun D (D, D) -> ();;
+
+fun (C (D, D)) -> ();;
+
+let A (b, B) = A (B, B);;
+
+let f (A (B, B)) = ();;
+
+let f B (A (B, B)) = ();;
+
+let (D, d) = (D, D);;
+
+let (C (D, d)) = (C (D, D));;
+
+function S S T -> ();;
+
+function Some (A (B, B)) -> ();;
+
+function S (A (B, B)) -> ();;
+
+function S (D, D) -> ();;
+
+function (C (D, D)) -> ();;
+
+function
+| Some Some Some x -> x
+(* | None None None x -> x *)
+| _ -> assert false;;
+
+fun None None None -> ();;
+
+fun (Some None) None None -> ();;
+
+let Some a = Some 42;;
+let Some a :: y = [Some 42];;
+let Some a, b = Some 42, 43;;
+let (Some a), b = Some 42, 43;;
+let Some a as b = let _ = b = 42 in Some 42;;
+(* let Some (a as b) = let _ = b = None in Some 42;; *)
+(* let Some (a as b) = let _ = b = 42 in Some 42;; *)
+(* let (Some a) as b = let _ = b = 42 in Some 42;; *)
+(* let (Some a) as b = let _ = b = None in Some 42;; *)
+let Some a | Some a = Some 42;;
+let x,y as r = 1,2 ;;
+let ((x, y) as r) = (1, 2);;
+
+type top = Top of (int * int);;
+
+match Top (1,2) with Top min as t -> ();;
+
+match Top (1,2) with Top (min,max) as t -> ();;
+
+(* let Some 'a' .. 'b' = Some 'b';; *)
+
+let rec f x y = ();;
+
+fun x y -> ();;
+
+fun (x, y) -> ();;
+
+function x, y -> ();;
+
+let rec next line pos0 = () in ();;
+
+(* fun Some None None None -> ();; *)
+(* fun x, y -> ();; |+ syntax error +| *)
+
--- /dev/null
+open Camlp4.PreCast;;
+Camlp4_config.antiquotations := true;;
+let expand_my_quot_expr _loc _loc_name_opt quotation_contents =
+ Printf.eprintf "%S\n%!" quotation_contents;
+ <:expr< dummy >>
+;;
+Syntax.Quotation.add "my" Syntax.Quotation.DynAst.expr_tag expand_my_quot_expr;;
--- /dev/null
+<:class_expr< a >>;
+<:class_expr< A.a B.b >>;
+<:class_expr< a [ t ] >>;
+<:class_expr< virtual a >>;
+<:class_expr< virtual $a$ >>;
+<:class_expr< virtual $lid:a$ >>;
+<:class_expr< virtual $lid:a$ [ 't ] >>;
+(* <:class_expr< virtual a [ t ] >>; *)
+<:class_expr< $opt:v$ a >>;
+<:class_expr< $opt:v$ a [ t ] >>;
+<:class_expr< $opt:v$ $a$ >>;
+<:class_expr< $opt:v$ $id:a$ >>;
+<:class_expr< $opt:v$ $a$ [ $t$ ] >>;
+(* <:class_expr< $opt:v$ a [ $t$ ] >>; *)
+(* <:class_expr< $opt:v$ a $opt:t$ >>; *)
+(* <:class_expr< $opt:v$ $a$ $opt:t$ >>; *)
+
+<:class_type< a >>;
+<:class_type< a [ t ] >>;
+<:class_type< virtual a >>;
+<:class_type< virtual $a$ >>;
+<:class_type< virtual $lid:a$ >>;
+<:class_type< virtual $lid:a$ [ 't ] >>;
+<:class_type< $opt:v$ a >>;
+<:class_type< $opt:v$ a [ t ] >>;
+<:class_type< $opt:v$ $a$ >>;
+<:class_type< $opt:v$ $a$ [ $t$ ] >>;
--- /dev/null
+(** The first special comment of the file is the comment associated
+ to the whole module.*)
+
+(** The comment for function f *)
+let f x y = x + y
+
+(** This comment is not attached to any element since there is another
+ special comment just before the next element. *)
+
+(** Comment for exception My_exception, even with a simple comment
+ between the special comment and the exception.*)
+(* A simple comment. *)
+exception My_exception of (int -> int) * int
+
+(** Comment for type weather *)
+type weather =
+| Rain of int (** The comment for constructor Rain *)
+| Sun (** The comment for constructor Sun *)
+
+(** The comment for type my_record *)
+type my_record = {
+ foo : int ; (** Comment for field foo *)
+ bar : string ; (** Comment for field bar *)
+ }
+
+(** The comment for class my_class *)
+class my_class =
+ object
+ (** A comment to describe inheritance from cl *)
+ inherit cl
+
+ (** The comment for the instance variable tutu *)
+ val mutable tutu = "tutu"
+ (** The comment for toto *)
+ val toto = 1
+ val titi = "titi"
+ (** Comment for method toto *)
+ method toto = tutu ^ "!"
+ (** Comment for method m *)
+ method m (f : float) = 1
+ end
+
+(** The comment for class type my_class_type *)
+class type my_class_type =
+ object
+ (** The comment for the instance variable x. *)
+ val mutable x : int
+ (** The commend for method m. *)
+ method m : int -> int
+ end
+
+(** The comment for module Foo *)
+module Foo =
+ struct
+ (** The comment for x *)
+ let x = 42
+ (** A special comment in the class, but not associated to any element. *)
+ end
+
+(** The comment for module type my_module_type. *)
+module type MY_MODULE_TYPE =
+ sig
+ (* Comment for value x. *)
+ val x : int
+ (* ... *)
+ end
--- /dev/null
+(** The first special comment of the file is the comment associated
+ with the whole module.*)
+
+
+(** Special comments can be placed between elements and are kept
+ by the OCamldoc tool, but are not associated to any element.
+ @-tags in these comments are ignored.*)
+
+(*******************************************************************)
+(** Comments like the one above, with more than two asterisks,
+ are ignored. *)
+
+(** The comment for function f. *)
+val f : int -> int -> int
+(** The continuation of the comment for function f. *)
+
+(** Comment for exception My_exception, even with a simple comment
+ between the special comment and the exception.*)
+(* Hello, I'm a simple comment :-) *)
+exception My_exception of (int -> int) * int
+
+(** Comment for type weather *)
+type weather =
+| Rain of int (** The comment for construtor Rain *)
+| Sun (** The comment for constructor Sun *)
+
+(** Comment for type weather2 *)
+type weather2 =
+| Rain of int (** The comment for construtor Rain *)
+| Sun (** The comment for constructor Sun *)
+(** I can continue the comment for type weather2 here
+ because there is already a comment associated to the last constructor.*)
+
+(** The comment for type my_record *)
+type my_record = {
+ foo : int ; (** Comment for field foo *)
+ bar : string ; (** Comment for field bar *)
+ }
+ (** Continuation of comment for type my_record *)
+
+(** Comment for foo *)
+val foo : string
+(** This comment is associated to foo and not to bar. *)
+val bar : string
+(** This comment is assciated to bar. *)
+
+(** The comment for class my_class *)
+class my_class :
+ object
+ (** A comment to describe inheritance from cl *)
+ inherit cl
+
+ (** The comment for attribute tutu *)
+ val mutable tutu : string
+
+ (** The comment for attribute toto. *)
+ val toto : int
+
+ (** This comment is not attached to titi since
+ there is a blank line before titi, but is kept
+ as a comment in the class. *)
+
+ val titi : string
+
+ (** Comment for method toto *)
+ method toto : string
+
+ (** Comment for method m *)
+ method m : float -> int
+ end
+
+(** The comment for the class type my_class_type *)
+class type my_class_type =
+ object
+ (** The comment for variable x. *)
+ val mutable x : int
+
+ (** The commend for method m. *)
+ method m : int -> int
+end
+
+(** The comment for module Foo *)
+module Foo :
+ sig
+ (** The comment for x *)
+ val x : int
+
+ (** A special comment that is kept but not associated to any element *)
+ end
+
+(** The comment for module type my_module_type. *)
+module type MY_MODULE_TYPE =
+ sig
+ (** The comment for value x. *)
+ val x : int
+
+ (** The comment for module M. *)
+ module M :
+ sig
+ (** The comment for value y. *)
+ val y : int
+
+ (* ... *)
+ end
+
+ end
--- /dev/null
+(** The first special comment of the file is the comment associated
+ to the whole module.*)
+
+(** The comment for function f *)
+let f x y = x + y
+
+(** This comment is not attached to any element since there is another
+ special comment just before the next element. *)
+
+(** Comment for exception My_exception, even with a simple comment
+ between the special comment and the exception.*)
+(* A simple comment. *)
+exception My_exception of (int -> int) * int
+
+(** Comment for type weather *)
+type weather =
+ (** The comment for constructor Rain *)
+| Rain of int
+ (** The comment for constructor Sun *)
+| Sun
+
+(** The comment for type my_record *)
+type my_record = {
+ (** Comment for field foo *)
+ foo : int ;
+ (** Comment for field bar *)
+ bar : string ;
+ }
+
+(** The comment for class my_class *)
+class my_class =
+ object
+ (** A comment to describe inheritance from cl *)
+ inherit cl
+
+ (** The comment for the instance variable tutu *)
+ val mutable tutu = "tutu"
+ (** The comment for toto *)
+ val toto = 1
+ val titi = "titi"
+ (** Comment for method toto *)
+ method toto = tutu ^ "!"
+ (** Comment for method m *)
+ method m (f : float) = 1
+ end
+
+(** The comment for class type my_class_type *)
+class type my_class_type =
+ object
+ (** The comment for the instance variable x. *)
+ val mutable x : int
+ (** The commend for method m. *)
+ method m : int -> int
+ end
+
+(** The comment for module Foo *)
+module Foo =
+ struct
+ (** The comment for x *)
+ let x = 42
+ (** A special comment in the class, but not associated to any element. *)
+ end
+
+(** The comment for module type my_module_type. *)
+module type MY_MODULE_TYPE =
+ sig
+ (* Comment for value x. *)
+ val x : int
+ (* ... *)
+ end
--- /dev/null
+open Camlp4
+
+module Id = struct
+ let name = "Camlp4Parsers.LoadCamlp4Ast"
+ let version = Sys.ocaml_version
+end
+
+module Make (Ast : Camlp4.Sig.Camlp4Ast.S) = struct
+ module Ast = Ast
+ open Ast
+
+ let _loc = Loc.ghost
+
+ let parse_implem ?directive_handler:(_) _ _ =
+ let e =
+ Ast.ExApp (_loc,
+ Ast.ExApp (_loc,
+ Ast.ExId (_loc,
+ Ast.IdAcc (_loc, Ast.IdUid (_loc, "G"), Ast.IdLid (_loc, "extend"))),
+ Ast.ExTyc (_loc, Ast.ExId (_loc, Ast.IdLid (_loc, "expr")),
+ Ast.TyApp (_loc,
+ Ast.TyId (_loc,
+ Ast.IdAcc (_loc, Ast.IdUid (_loc, "G"),
+ Ast.IdAcc (_loc, Ast.IdUid (_loc, "Entry"),
+ Ast.IdLid (_loc, "t")))),
+ Ast.TyQuo (_loc, "expr")))),
+ Ast.ExTup (_loc,
+ Ast.ExCom (_loc, Ast.ExId (_loc, Ast.IdUid (_loc, "None")),
+ Ast.ExApp (_loc,
+ Ast.ExApp (_loc, Ast.ExId (_loc, Ast.IdUid (_loc, "::")),
+ Ast.ExTup (_loc,
+ Ast.ExCom (_loc, Ast.ExId (_loc, Ast.IdUid (_loc, "None")),
+ Ast.ExCom (_loc, Ast.ExId (_loc, Ast.IdUid (_loc, "None")),
+ Ast.ExApp (_loc,
+ Ast.ExApp (_loc, Ast.ExId (_loc, Ast.IdUid (_loc, "::")),
+ Ast.ExTup (_loc,
+ Ast.ExCom (_loc,
+ Ast.ExApp (_loc,
+ Ast.ExApp (_loc,
+ Ast.ExId (_loc, Ast.IdUid (_loc, "::")),
+ Ast.ExApp (_loc,
+ Ast.ExId (_loc,
+ Ast.IdAcc (_loc, Ast.IdUid (_loc, "G"),
+ Ast.IdUid (_loc, "Skeyword"))),
+ Ast.ExStr (_loc, "foo"))),
+ Ast.ExId (_loc, Ast.IdUid (_loc, "[]"))),
+ Ast.ExApp (_loc,
+ Ast.ExId (_loc,
+ Ast.IdAcc (_loc, Ast.IdUid (_loc, "G"),
+ Ast.IdAcc (_loc, Ast.IdUid (_loc, "Action"),
+ Ast.IdLid (_loc, "mk")))),
+ Ast.ExFun (_loc,
+ Ast.AsArr (_loc, Ast.PaAny _loc, Ast.ONone,
+ Ast.ExFun (_loc,
+ Ast.AsArr (_loc,
+ Ast.PaTyc (_loc,
+ Ast.PaId (_loc,
+ Ast.IdLid (_loc, "_loc")),
+ Ast.TyId (_loc,
+ Ast.IdAcc (_loc,
+ Ast.IdUid (_loc, "Loc"),
+ Ast.IdLid (_loc, "t")))),
+ Ast.ONone,
+ Ast.ExTyc (_loc,
+ Ast.ExApp (_loc,
+ Ast.ExApp (_loc,
+ Ast.ExId (_loc,
+ Ast.IdAcc (_loc,
+ Ast.IdUid (_loc, "Ast"),
+ Ast.IdUid (_loc, "ExId"))),
+ Ast.ExId (_loc,
+ Ast.IdLid (_loc, "_loc"))),
+ Ast.ExApp (_loc,
+ Ast.ExApp (_loc,
+ Ast.ExId (_loc,
+ Ast.IdAcc (_loc,
+ Ast.IdUid (_loc, "Ast"),
+ Ast.IdUid (_loc, "IdLid"))),
+ Ast.ExId (_loc,
+ Ast.IdLid (_loc, "_loc"))),
+ Ast.ExStr (_loc, "foo"))),
+ Ast.TyQuo (_loc, "expr")))))))))),
+ Ast.ExId (_loc, Ast.IdUid (_loc, "[]"))))))),
+ Ast.ExId (_loc, Ast.IdUid (_loc, "[]"))))))
+ in Ast.StExp (_loc, e)
+ let parse_interf ?directive_handler:(_) _ _ = assert false;;
+
+end;;
+
+let module M = Camlp4.Register.OCamlParser(Id)(Make) in ()
--- /dev/null
+type t = A of int
+type u = B of t
+let f = function B A x -> x
--- /dev/null
+#default_quotation "expr";
+open Camlp4.PreCast;
+fun [ << $x$ - $y$ >> when x = y -> << 0 >>
+ | e -> e ];
--- /dev/null
+exception Foo of string = Bar
--- /dev/null
+external f : 'a -> 'b = "%identity";
--- /dev/null
+value f = fun [];
+value f = fun [ [] -> fun [ 4 -> () ] ];
+value f = fun [];
+value f = fun [];
+value f = fun [];
+value f = g x y;
+value f = (g x) y;
--- /dev/null
+module type S = sig
+(* <%- for i in 0 .. 1000 do -%>
+ val f<%= i %> : int -> int -> int
+<%- end -%> *)
+ val f0 : int -> int -> int
+ val f1 : int -> int -> int
+ val f2 : int -> int -> int
+ val f3 : int -> int -> int
+ val f4 : int -> int -> int
+ val f5 : int -> int -> int
+ val f6 : int -> int -> int
+ val f7 : int -> int -> int
+ val f8 : int -> int -> int
+ val f9 : int -> int -> int
+ val f10 : int -> int -> int
+ val f11 : int -> int -> int
+ val f12 : int -> int -> int
+ val f13 : int -> int -> int
+ val f14 : int -> int -> int
+ val f15 : int -> int -> int
+ val f16 : int -> int -> int
+ val f17 : int -> int -> int
+ val f18 : int -> int -> int
+ val f19 : int -> int -> int
+ val f20 : int -> int -> int
+ val f21 : int -> int -> int
+ val f22 : int -> int -> int
+ val f23 : int -> int -> int
+ val f24 : int -> int -> int
+ val f25 : int -> int -> int
+ val f26 : int -> int -> int
+ val f27 : int -> int -> int
+ val f28 : int -> int -> int
+ val f29 : int -> int -> int
+ val f30 : int -> int -> int
+ val f31 : int -> int -> int
+ val f32 : int -> int -> int
+ val f33 : int -> int -> int
+ val f34 : int -> int -> int
+ val f35 : int -> int -> int
+ val f36 : int -> int -> int
+ val f37 : int -> int -> int
+ val f38 : int -> int -> int
+ val f39 : int -> int -> int
+ val f40 : int -> int -> int
+ val f41 : int -> int -> int
+ val f42 : int -> int -> int
+ val f43 : int -> int -> int
+ val f44 : int -> int -> int
+ val f45 : int -> int -> int
+ val f46 : int -> int -> int
+ val f47 : int -> int -> int
+ val f48 : int -> int -> int
+ val f49 : int -> int -> int
+ val f50 : int -> int -> int
+ val f51 : int -> int -> int
+ val f52 : int -> int -> int
+ val f53 : int -> int -> int
+ val f54 : int -> int -> int
+ val f55 : int -> int -> int
+ val f56 : int -> int -> int
+ val f57 : int -> int -> int
+ val f58 : int -> int -> int
+ val f59 : int -> int -> int
+ val f60 : int -> int -> int
+ val f61 : int -> int -> int
+ val f62 : int -> int -> int
+ val f63 : int -> int -> int
+ val f64 : int -> int -> int
+ val f65 : int -> int -> int
+ val f66 : int -> int -> int
+ val f67 : int -> int -> int
+ val f68 : int -> int -> int
+ val f69 : int -> int -> int
+ val f70 : int -> int -> int
+ val f71 : int -> int -> int
+ val f72 : int -> int -> int
+ val f73 : int -> int -> int
+ val f74 : int -> int -> int
+ val f75 : int -> int -> int
+ val f76 : int -> int -> int
+ val f77 : int -> int -> int
+ val f78 : int -> int -> int
+ val f79 : int -> int -> int
+ val f80 : int -> int -> int
+ val f81 : int -> int -> int
+ val f82 : int -> int -> int
+ val f83 : int -> int -> int
+ val f84 : int -> int -> int
+ val f85 : int -> int -> int
+ val f86 : int -> int -> int
+ val f87 : int -> int -> int
+ val f88 : int -> int -> int
+ val f89 : int -> int -> int
+ val f90 : int -> int -> int
+ val f91 : int -> int -> int
+ val f92 : int -> int -> int
+ val f93 : int -> int -> int
+ val f94 : int -> int -> int
+ val f95 : int -> int -> int
+ val f96 : int -> int -> int
+ val f97 : int -> int -> int
+ val f98 : int -> int -> int
+ val f99 : int -> int -> int
+ val f100 : int -> int -> int
+ val f101 : int -> int -> int
+ val f102 : int -> int -> int
+ val f103 : int -> int -> int
+ val f104 : int -> int -> int
+ val f105 : int -> int -> int
+ val f106 : int -> int -> int
+ val f107 : int -> int -> int
+ val f108 : int -> int -> int
+ val f109 : int -> int -> int
+ val f110 : int -> int -> int
+ val f111 : int -> int -> int
+ val f112 : int -> int -> int
+ val f113 : int -> int -> int
+ val f114 : int -> int -> int
+ val f115 : int -> int -> int
+ val f116 : int -> int -> int
+ val f117 : int -> int -> int
+ val f118 : int -> int -> int
+ val f119 : int -> int -> int
+ val f120 : int -> int -> int
+ val f121 : int -> int -> int
+ val f122 : int -> int -> int
+ val f123 : int -> int -> int
+ val f124 : int -> int -> int
+ val f125 : int -> int -> int
+ val f126 : int -> int -> int
+ val f127 : int -> int -> int
+ val f128 : int -> int -> int
+ val f129 : int -> int -> int
+ val f130 : int -> int -> int
+ val f131 : int -> int -> int
+ val f132 : int -> int -> int
+ val f133 : int -> int -> int
+ val f134 : int -> int -> int
+ val f135 : int -> int -> int
+ val f136 : int -> int -> int
+ val f137 : int -> int -> int
+ val f138 : int -> int -> int
+ val f139 : int -> int -> int
+ val f140 : int -> int -> int
+ val f141 : int -> int -> int
+ val f142 : int -> int -> int
+ val f143 : int -> int -> int
+ val f144 : int -> int -> int
+ val f145 : int -> int -> int
+ val f146 : int -> int -> int
+ val f147 : int -> int -> int
+ val f148 : int -> int -> int
+ val f149 : int -> int -> int
+ val f150 : int -> int -> int
+ val f151 : int -> int -> int
+ val f152 : int -> int -> int
+ val f153 : int -> int -> int
+ val f154 : int -> int -> int
+ val f155 : int -> int -> int
+ val f156 : int -> int -> int
+ val f157 : int -> int -> int
+ val f158 : int -> int -> int
+ val f159 : int -> int -> int
+ val f160 : int -> int -> int
+ val f161 : int -> int -> int
+ val f162 : int -> int -> int
+ val f163 : int -> int -> int
+ val f164 : int -> int -> int
+ val f165 : int -> int -> int
+ val f166 : int -> int -> int
+ val f167 : int -> int -> int
+ val f168 : int -> int -> int
+ val f169 : int -> int -> int
+ val f170 : int -> int -> int
+ val f171 : int -> int -> int
+ val f172 : int -> int -> int
+ val f173 : int -> int -> int
+ val f174 : int -> int -> int
+ val f175 : int -> int -> int
+ val f176 : int -> int -> int
+ val f177 : int -> int -> int
+ val f178 : int -> int -> int
+ val f179 : int -> int -> int
+ val f180 : int -> int -> int
+ val f181 : int -> int -> int
+ val f182 : int -> int -> int
+ val f183 : int -> int -> int
+ val f184 : int -> int -> int
+ val f185 : int -> int -> int
+ val f186 : int -> int -> int
+ val f187 : int -> int -> int
+ val f188 : int -> int -> int
+ val f189 : int -> int -> int
+ val f190 : int -> int -> int
+ val f191 : int -> int -> int
+ val f192 : int -> int -> int
+ val f193 : int -> int -> int
+ val f194 : int -> int -> int
+ val f195 : int -> int -> int
+ val f196 : int -> int -> int
+ val f197 : int -> int -> int
+ val f198 : int -> int -> int
+ val f199 : int -> int -> int
+ val f200 : int -> int -> int
+ val f201 : int -> int -> int
+ val f202 : int -> int -> int
+ val f203 : int -> int -> int
+ val f204 : int -> int -> int
+ val f205 : int -> int -> int
+ val f206 : int -> int -> int
+ val f207 : int -> int -> int
+ val f208 : int -> int -> int
+ val f209 : int -> int -> int
+ val f210 : int -> int -> int
+ val f211 : int -> int -> int
+ val f212 : int -> int -> int
+ val f213 : int -> int -> int
+ val f214 : int -> int -> int
+ val f215 : int -> int -> int
+ val f216 : int -> int -> int
+ val f217 : int -> int -> int
+ val f218 : int -> int -> int
+ val f219 : int -> int -> int
+ val f220 : int -> int -> int
+ val f221 : int -> int -> int
+ val f222 : int -> int -> int
+ val f223 : int -> int -> int
+ val f224 : int -> int -> int
+ val f225 : int -> int -> int
+ val f226 : int -> int -> int
+ val f227 : int -> int -> int
+ val f228 : int -> int -> int
+ val f229 : int -> int -> int
+ val f230 : int -> int -> int
+ val f231 : int -> int -> int
+ val f232 : int -> int -> int
+ val f233 : int -> int -> int
+ val f234 : int -> int -> int
+ val f235 : int -> int -> int
+ val f236 : int -> int -> int
+ val f237 : int -> int -> int
+ val f238 : int -> int -> int
+ val f239 : int -> int -> int
+ val f240 : int -> int -> int
+ val f241 : int -> int -> int
+ val f242 : int -> int -> int
+ val f243 : int -> int -> int
+ val f244 : int -> int -> int
+ val f245 : int -> int -> int
+ val f246 : int -> int -> int
+ val f247 : int -> int -> int
+ val f248 : int -> int -> int
+ val f249 : int -> int -> int
+ val f250 : int -> int -> int
+ val f251 : int -> int -> int
+ val f252 : int -> int -> int
+ val f253 : int -> int -> int
+ val f254 : int -> int -> int
+ val f255 : int -> int -> int
+ val f256 : int -> int -> int
+ val f257 : int -> int -> int
+ val f258 : int -> int -> int
+ val f259 : int -> int -> int
+ val f260 : int -> int -> int
+ val f261 : int -> int -> int
+ val f262 : int -> int -> int
+ val f263 : int -> int -> int
+ val f264 : int -> int -> int
+ val f265 : int -> int -> int
+ val f266 : int -> int -> int
+ val f267 : int -> int -> int
+ val f268 : int -> int -> int
+ val f269 : int -> int -> int
+ val f270 : int -> int -> int
+ val f271 : int -> int -> int
+ val f272 : int -> int -> int
+ val f273 : int -> int -> int
+ val f274 : int -> int -> int
+ val f275 : int -> int -> int
+ val f276 : int -> int -> int
+ val f277 : int -> int -> int
+ val f278 : int -> int -> int
+ val f279 : int -> int -> int
+ val f280 : int -> int -> int
+ val f281 : int -> int -> int
+ val f282 : int -> int -> int
+ val f283 : int -> int -> int
+ val f284 : int -> int -> int
+ val f285 : int -> int -> int
+ val f286 : int -> int -> int
+ val f287 : int -> int -> int
+ val f288 : int -> int -> int
+ val f289 : int -> int -> int
+ val f290 : int -> int -> int
+ val f291 : int -> int -> int
+ val f292 : int -> int -> int
+ val f293 : int -> int -> int
+ val f294 : int -> int -> int
+ val f295 : int -> int -> int
+ val f296 : int -> int -> int
+ val f297 : int -> int -> int
+ val f298 : int -> int -> int
+ val f299 : int -> int -> int
+ val f300 : int -> int -> int
+ val f301 : int -> int -> int
+ val f302 : int -> int -> int
+ val f303 : int -> int -> int
+ val f304 : int -> int -> int
+ val f305 : int -> int -> int
+ val f306 : int -> int -> int
+ val f307 : int -> int -> int
+ val f308 : int -> int -> int
+ val f309 : int -> int -> int
+ val f310 : int -> int -> int
+ val f311 : int -> int -> int
+ val f312 : int -> int -> int
+ val f313 : int -> int -> int
+ val f314 : int -> int -> int
+ val f315 : int -> int -> int
+ val f316 : int -> int -> int
+ val f317 : int -> int -> int
+ val f318 : int -> int -> int
+ val f319 : int -> int -> int
+ val f320 : int -> int -> int
+ val f321 : int -> int -> int
+ val f322 : int -> int -> int
+ val f323 : int -> int -> int
+ val f324 : int -> int -> int
+ val f325 : int -> int -> int
+ val f326 : int -> int -> int
+ val f327 : int -> int -> int
+ val f328 : int -> int -> int
+ val f329 : int -> int -> int
+ val f330 : int -> int -> int
+ val f331 : int -> int -> int
+ val f332 : int -> int -> int
+ val f333 : int -> int -> int
+ val f334 : int -> int -> int
+ val f335 : int -> int -> int
+ val f336 : int -> int -> int
+ val f337 : int -> int -> int
+ val f338 : int -> int -> int
+ val f339 : int -> int -> int
+ val f340 : int -> int -> int
+ val f341 : int -> int -> int
+ val f342 : int -> int -> int
+ val f343 : int -> int -> int
+ val f344 : int -> int -> int
+ val f345 : int -> int -> int
+ val f346 : int -> int -> int
+ val f347 : int -> int -> int
+ val f348 : int -> int -> int
+ val f349 : int -> int -> int
+ val f350 : int -> int -> int
+ val f351 : int -> int -> int
+ val f352 : int -> int -> int
+ val f353 : int -> int -> int
+ val f354 : int -> int -> int
+ val f355 : int -> int -> int
+ val f356 : int -> int -> int
+ val f357 : int -> int -> int
+ val f358 : int -> int -> int
+ val f359 : int -> int -> int
+ val f360 : int -> int -> int
+ val f361 : int -> int -> int
+ val f362 : int -> int -> int
+ val f363 : int -> int -> int
+ val f364 : int -> int -> int
+ val f365 : int -> int -> int
+ val f366 : int -> int -> int
+ val f367 : int -> int -> int
+ val f368 : int -> int -> int
+ val f369 : int -> int -> int
+ val f370 : int -> int -> int
+ val f371 : int -> int -> int
+ val f372 : int -> int -> int
+ val f373 : int -> int -> int
+ val f374 : int -> int -> int
+ val f375 : int -> int -> int
+ val f376 : int -> int -> int
+ val f377 : int -> int -> int
+ val f378 : int -> int -> int
+ val f379 : int -> int -> int
+ val f380 : int -> int -> int
+ val f381 : int -> int -> int
+ val f382 : int -> int -> int
+ val f383 : int -> int -> int
+ val f384 : int -> int -> int
+ val f385 : int -> int -> int
+ val f386 : int -> int -> int
+ val f387 : int -> int -> int
+ val f388 : int -> int -> int
+ val f389 : int -> int -> int
+ val f390 : int -> int -> int
+ val f391 : int -> int -> int
+ val f392 : int -> int -> int
+ val f393 : int -> int -> int
+ val f394 : int -> int -> int
+ val f395 : int -> int -> int
+ val f396 : int -> int -> int
+ val f397 : int -> int -> int
+ val f398 : int -> int -> int
+ val f399 : int -> int -> int
+ val f400 : int -> int -> int
+ val f401 : int -> int -> int
+ val f402 : int -> int -> int
+ val f403 : int -> int -> int
+ val f404 : int -> int -> int
+ val f405 : int -> int -> int
+ val f406 : int -> int -> int
+ val f407 : int -> int -> int
+ val f408 : int -> int -> int
+ val f409 : int -> int -> int
+ val f410 : int -> int -> int
+ val f411 : int -> int -> int
+ val f412 : int -> int -> int
+ val f413 : int -> int -> int
+ val f414 : int -> int -> int
+ val f415 : int -> int -> int
+ val f416 : int -> int -> int
+ val f417 : int -> int -> int
+ val f418 : int -> int -> int
+ val f419 : int -> int -> int
+ val f420 : int -> int -> int
+ val f421 : int -> int -> int
+ val f422 : int -> int -> int
+ val f423 : int -> int -> int
+ val f424 : int -> int -> int
+ val f425 : int -> int -> int
+ val f426 : int -> int -> int
+ val f427 : int -> int -> int
+ val f428 : int -> int -> int
+ val f429 : int -> int -> int
+ val f430 : int -> int -> int
+ val f431 : int -> int -> int
+ val f432 : int -> int -> int
+ val f433 : int -> int -> int
+ val f434 : int -> int -> int
+ val f435 : int -> int -> int
+ val f436 : int -> int -> int
+ val f437 : int -> int -> int
+ val f438 : int -> int -> int
+ val f439 : int -> int -> int
+ val f440 : int -> int -> int
+ val f441 : int -> int -> int
+ val f442 : int -> int -> int
+ val f443 : int -> int -> int
+ val f444 : int -> int -> int
+ val f445 : int -> int -> int
+ val f446 : int -> int -> int
+ val f447 : int -> int -> int
+ val f448 : int -> int -> int
+ val f449 : int -> int -> int
+ val f450 : int -> int -> int
+ val f451 : int -> int -> int
+ val f452 : int -> int -> int
+ val f453 : int -> int -> int
+ val f454 : int -> int -> int
+ val f455 : int -> int -> int
+ val f456 : int -> int -> int
+ val f457 : int -> int -> int
+ val f458 : int -> int -> int
+ val f459 : int -> int -> int
+ val f460 : int -> int -> int
+ val f461 : int -> int -> int
+ val f462 : int -> int -> int
+ val f463 : int -> int -> int
+ val f464 : int -> int -> int
+ val f465 : int -> int -> int
+ val f466 : int -> int -> int
+ val f467 : int -> int -> int
+ val f468 : int -> int -> int
+ val f469 : int -> int -> int
+ val f470 : int -> int -> int
+ val f471 : int -> int -> int
+ val f472 : int -> int -> int
+ val f473 : int -> int -> int
+ val f474 : int -> int -> int
+ val f475 : int -> int -> int
+ val f476 : int -> int -> int
+ val f477 : int -> int -> int
+ val f478 : int -> int -> int
+ val f479 : int -> int -> int
+ val f480 : int -> int -> int
+ val f481 : int -> int -> int
+ val f482 : int -> int -> int
+ val f483 : int -> int -> int
+ val f484 : int -> int -> int
+ val f485 : int -> int -> int
+ val f486 : int -> int -> int
+ val f487 : int -> int -> int
+ val f488 : int -> int -> int
+ val f489 : int -> int -> int
+ val f490 : int -> int -> int
+ val f491 : int -> int -> int
+ val f492 : int -> int -> int
+ val f493 : int -> int -> int
+ val f494 : int -> int -> int
+ val f495 : int -> int -> int
+ val f496 : int -> int -> int
+ val f497 : int -> int -> int
+ val f498 : int -> int -> int
+ val f499 : int -> int -> int
+ val f500 : int -> int -> int
+ val f501 : int -> int -> int
+ val f502 : int -> int -> int
+ val f503 : int -> int -> int
+ val f504 : int -> int -> int
+ val f505 : int -> int -> int
+ val f506 : int -> int -> int
+ val f507 : int -> int -> int
+ val f508 : int -> int -> int
+ val f509 : int -> int -> int
+ val f510 : int -> int -> int
+ val f511 : int -> int -> int
+ val f512 : int -> int -> int
+ val f513 : int -> int -> int
+ val f514 : int -> int -> int
+ val f515 : int -> int -> int
+ val f516 : int -> int -> int
+ val f517 : int -> int -> int
+ val f518 : int -> int -> int
+ val f519 : int -> int -> int
+ val f520 : int -> int -> int
+ val f521 : int -> int -> int
+ val f522 : int -> int -> int
+ val f523 : int -> int -> int
+ val f524 : int -> int -> int
+ val f525 : int -> int -> int
+ val f526 : int -> int -> int
+ val f527 : int -> int -> int
+ val f528 : int -> int -> int
+ val f529 : int -> int -> int
+ val f530 : int -> int -> int
+ val f531 : int -> int -> int
+ val f532 : int -> int -> int
+ val f533 : int -> int -> int
+ val f534 : int -> int -> int
+ val f535 : int -> int -> int
+ val f536 : int -> int -> int
+ val f537 : int -> int -> int
+ val f538 : int -> int -> int
+ val f539 : int -> int -> int
+ val f540 : int -> int -> int
+ val f541 : int -> int -> int
+ val f542 : int -> int -> int
+ val f543 : int -> int -> int
+ val f544 : int -> int -> int
+ val f545 : int -> int -> int
+ val f546 : int -> int -> int
+ val f547 : int -> int -> int
+ val f548 : int -> int -> int
+ val f549 : int -> int -> int
+ val f550 : int -> int -> int
+ val f551 : int -> int -> int
+ val f552 : int -> int -> int
+ val f553 : int -> int -> int
+ val f554 : int -> int -> int
+ val f555 : int -> int -> int
+ val f556 : int -> int -> int
+ val f557 : int -> int -> int
+ val f558 : int -> int -> int
+ val f559 : int -> int -> int
+ val f560 : int -> int -> int
+ val f561 : int -> int -> int
+ val f562 : int -> int -> int
+ val f563 : int -> int -> int
+ val f564 : int -> int -> int
+ val f565 : int -> int -> int
+ val f566 : int -> int -> int
+ val f567 : int -> int -> int
+ val f568 : int -> int -> int
+ val f569 : int -> int -> int
+ val f570 : int -> int -> int
+ val f571 : int -> int -> int
+ val f572 : int -> int -> int
+ val f573 : int -> int -> int
+ val f574 : int -> int -> int
+ val f575 : int -> int -> int
+ val f576 : int -> int -> int
+ val f577 : int -> int -> int
+ val f578 : int -> int -> int
+ val f579 : int -> int -> int
+ val f580 : int -> int -> int
+ val f581 : int -> int -> int
+ val f582 : int -> int -> int
+ val f583 : int -> int -> int
+ val f584 : int -> int -> int
+ val f585 : int -> int -> int
+ val f586 : int -> int -> int
+ val f587 : int -> int -> int
+ val f588 : int -> int -> int
+ val f589 : int -> int -> int
+ val f590 : int -> int -> int
+ val f591 : int -> int -> int
+ val f592 : int -> int -> int
+ val f593 : int -> int -> int
+ val f594 : int -> int -> int
+ val f595 : int -> int -> int
+ val f596 : int -> int -> int
+ val f597 : int -> int -> int
+ val f598 : int -> int -> int
+ val f599 : int -> int -> int
+ val f600 : int -> int -> int
+ val f601 : int -> int -> int
+ val f602 : int -> int -> int
+ val f603 : int -> int -> int
+ val f604 : int -> int -> int
+ val f605 : int -> int -> int
+ val f606 : int -> int -> int
+ val f607 : int -> int -> int
+ val f608 : int -> int -> int
+ val f609 : int -> int -> int
+ val f610 : int -> int -> int
+ val f611 : int -> int -> int
+ val f612 : int -> int -> int
+ val f613 : int -> int -> int
+ val f614 : int -> int -> int
+ val f615 : int -> int -> int
+ val f616 : int -> int -> int
+ val f617 : int -> int -> int
+ val f618 : int -> int -> int
+ val f619 : int -> int -> int
+ val f620 : int -> int -> int
+ val f621 : int -> int -> int
+ val f622 : int -> int -> int
+ val f623 : int -> int -> int
+ val f624 : int -> int -> int
+ val f625 : int -> int -> int
+ val f626 : int -> int -> int
+ val f627 : int -> int -> int
+ val f628 : int -> int -> int
+ val f629 : int -> int -> int
+ val f630 : int -> int -> int
+ val f631 : int -> int -> int
+ val f632 : int -> int -> int
+ val f633 : int -> int -> int
+ val f634 : int -> int -> int
+ val f635 : int -> int -> int
+ val f636 : int -> int -> int
+ val f637 : int -> int -> int
+ val f638 : int -> int -> int
+ val f639 : int -> int -> int
+ val f640 : int -> int -> int
+ val f641 : int -> int -> int
+ val f642 : int -> int -> int
+ val f643 : int -> int -> int
+ val f644 : int -> int -> int
+ val f645 : int -> int -> int
+ val f646 : int -> int -> int
+ val f647 : int -> int -> int
+ val f648 : int -> int -> int
+ val f649 : int -> int -> int
+ val f650 : int -> int -> int
+ val f651 : int -> int -> int
+ val f652 : int -> int -> int
+ val f653 : int -> int -> int
+ val f654 : int -> int -> int
+ val f655 : int -> int -> int
+ val f656 : int -> int -> int
+ val f657 : int -> int -> int
+ val f658 : int -> int -> int
+ val f659 : int -> int -> int
+ val f660 : int -> int -> int
+ val f661 : int -> int -> int
+ val f662 : int -> int -> int
+ val f663 : int -> int -> int
+ val f664 : int -> int -> int
+ val f665 : int -> int -> int
+ val f666 : int -> int -> int
+ val f667 : int -> int -> int
+ val f668 : int -> int -> int
+ val f669 : int -> int -> int
+ val f670 : int -> int -> int
+ val f671 : int -> int -> int
+ val f672 : int -> int -> int
+ val f673 : int -> int -> int
+ val f674 : int -> int -> int
+ val f675 : int -> int -> int
+ val f676 : int -> int -> int
+ val f677 : int -> int -> int
+ val f678 : int -> int -> int
+ val f679 : int -> int -> int
+ val f680 : int -> int -> int
+ val f681 : int -> int -> int
+ val f682 : int -> int -> int
+ val f683 : int -> int -> int
+ val f684 : int -> int -> int
+ val f685 : int -> int -> int
+ val f686 : int -> int -> int
+ val f687 : int -> int -> int
+ val f688 : int -> int -> int
+ val f689 : int -> int -> int
+ val f690 : int -> int -> int
+ val f691 : int -> int -> int
+ val f692 : int -> int -> int
+ val f693 : int -> int -> int
+ val f694 : int -> int -> int
+ val f695 : int -> int -> int
+ val f696 : int -> int -> int
+ val f697 : int -> int -> int
+ val f698 : int -> int -> int
+ val f699 : int -> int -> int
+ val f700 : int -> int -> int
+ val f701 : int -> int -> int
+ val f702 : int -> int -> int
+ val f703 : int -> int -> int
+ val f704 : int -> int -> int
+ val f705 : int -> int -> int
+ val f706 : int -> int -> int
+ val f707 : int -> int -> int
+ val f708 : int -> int -> int
+ val f709 : int -> int -> int
+ val f710 : int -> int -> int
+ val f711 : int -> int -> int
+ val f712 : int -> int -> int
+ val f713 : int -> int -> int
+ val f714 : int -> int -> int
+ val f715 : int -> int -> int
+ val f716 : int -> int -> int
+ val f717 : int -> int -> int
+ val f718 : int -> int -> int
+ val f719 : int -> int -> int
+ val f720 : int -> int -> int
+ val f721 : int -> int -> int
+ val f722 : int -> int -> int
+ val f723 : int -> int -> int
+ val f724 : int -> int -> int
+ val f725 : int -> int -> int
+ val f726 : int -> int -> int
+ val f727 : int -> int -> int
+ val f728 : int -> int -> int
+ val f729 : int -> int -> int
+ val f730 : int -> int -> int
+ val f731 : int -> int -> int
+ val f732 : int -> int -> int
+ val f733 : int -> int -> int
+ val f734 : int -> int -> int
+ val f735 : int -> int -> int
+ val f736 : int -> int -> int
+ val f737 : int -> int -> int
+ val f738 : int -> int -> int
+ val f739 : int -> int -> int
+ val f740 : int -> int -> int
+ val f741 : int -> int -> int
+ val f742 : int -> int -> int
+ val f743 : int -> int -> int
+ val f744 : int -> int -> int
+ val f745 : int -> int -> int
+ val f746 : int -> int -> int
+ val f747 : int -> int -> int
+ val f748 : int -> int -> int
+ val f749 : int -> int -> int
+ val f750 : int -> int -> int
+ val f751 : int -> int -> int
+ val f752 : int -> int -> int
+ val f753 : int -> int -> int
+ val f754 : int -> int -> int
+ val f755 : int -> int -> int
+ val f756 : int -> int -> int
+ val f757 : int -> int -> int
+ val f758 : int -> int -> int
+ val f759 : int -> int -> int
+ val f760 : int -> int -> int
+ val f761 : int -> int -> int
+ val f762 : int -> int -> int
+ val f763 : int -> int -> int
+ val f764 : int -> int -> int
+ val f765 : int -> int -> int
+ val f766 : int -> int -> int
+ val f767 : int -> int -> int
+ val f768 : int -> int -> int
+ val f769 : int -> int -> int
+ val f770 : int -> int -> int
+ val f771 : int -> int -> int
+ val f772 : int -> int -> int
+ val f773 : int -> int -> int
+ val f774 : int -> int -> int
+ val f775 : int -> int -> int
+ val f776 : int -> int -> int
+ val f777 : int -> int -> int
+ val f778 : int -> int -> int
+ val f779 : int -> int -> int
+ val f780 : int -> int -> int
+ val f781 : int -> int -> int
+ val f782 : int -> int -> int
+ val f783 : int -> int -> int
+ val f784 : int -> int -> int
+ val f785 : int -> int -> int
+ val f786 : int -> int -> int
+ val f787 : int -> int -> int
+ val f788 : int -> int -> int
+ val f789 : int -> int -> int
+ val f790 : int -> int -> int
+ val f791 : int -> int -> int
+ val f792 : int -> int -> int
+ val f793 : int -> int -> int
+ val f794 : int -> int -> int
+ val f795 : int -> int -> int
+ val f796 : int -> int -> int
+ val f797 : int -> int -> int
+ val f798 : int -> int -> int
+ val f799 : int -> int -> int
+ val f800 : int -> int -> int
+ val f801 : int -> int -> int
+ val f802 : int -> int -> int
+ val f803 : int -> int -> int
+ val f804 : int -> int -> int
+ val f805 : int -> int -> int
+ val f806 : int -> int -> int
+ val f807 : int -> int -> int
+ val f808 : int -> int -> int
+ val f809 : int -> int -> int
+ val f810 : int -> int -> int
+ val f811 : int -> int -> int
+ val f812 : int -> int -> int
+ val f813 : int -> int -> int
+ val f814 : int -> int -> int
+ val f815 : int -> int -> int
+ val f816 : int -> int -> int
+ val f817 : int -> int -> int
+ val f818 : int -> int -> int
+ val f819 : int -> int -> int
+ val f820 : int -> int -> int
+ val f821 : int -> int -> int
+ val f822 : int -> int -> int
+ val f823 : int -> int -> int
+ val f824 : int -> int -> int
+ val f825 : int -> int -> int
+ val f826 : int -> int -> int
+ val f827 : int -> int -> int
+ val f828 : int -> int -> int
+ val f829 : int -> int -> int
+ val f830 : int -> int -> int
+ val f831 : int -> int -> int
+ val f832 : int -> int -> int
+ val f833 : int -> int -> int
+ val f834 : int -> int -> int
+ val f835 : int -> int -> int
+ val f836 : int -> int -> int
+ val f837 : int -> int -> int
+ val f838 : int -> int -> int
+ val f839 : int -> int -> int
+ val f840 : int -> int -> int
+ val f841 : int -> int -> int
+ val f842 : int -> int -> int
+ val f843 : int -> int -> int
+ val f844 : int -> int -> int
+ val f845 : int -> int -> int
+ val f846 : int -> int -> int
+ val f847 : int -> int -> int
+ val f848 : int -> int -> int
+ val f849 : int -> int -> int
+ val f850 : int -> int -> int
+ val f851 : int -> int -> int
+ val f852 : int -> int -> int
+ val f853 : int -> int -> int
+ val f854 : int -> int -> int
+ val f855 : int -> int -> int
+ val f856 : int -> int -> int
+ val f857 : int -> int -> int
+ val f858 : int -> int -> int
+ val f859 : int -> int -> int
+ val f860 : int -> int -> int
+ val f861 : int -> int -> int
+ val f862 : int -> int -> int
+ val f863 : int -> int -> int
+ val f864 : int -> int -> int
+ val f865 : int -> int -> int
+ val f866 : int -> int -> int
+ val f867 : int -> int -> int
+ val f868 : int -> int -> int
+ val f869 : int -> int -> int
+ val f870 : int -> int -> int
+ val f871 : int -> int -> int
+ val f872 : int -> int -> int
+ val f873 : int -> int -> int
+ val f874 : int -> int -> int
+ val f875 : int -> int -> int
+ val f876 : int -> int -> int
+ val f877 : int -> int -> int
+ val f878 : int -> int -> int
+ val f879 : int -> int -> int
+ val f880 : int -> int -> int
+ val f881 : int -> int -> int
+ val f882 : int -> int -> int
+ val f883 : int -> int -> int
+ val f884 : int -> int -> int
+ val f885 : int -> int -> int
+ val f886 : int -> int -> int
+ val f887 : int -> int -> int
+ val f888 : int -> int -> int
+ val f889 : int -> int -> int
+ val f890 : int -> int -> int
+ val f891 : int -> int -> int
+ val f892 : int -> int -> int
+ val f893 : int -> int -> int
+ val f894 : int -> int -> int
+ val f895 : int -> int -> int
+ val f896 : int -> int -> int
+ val f897 : int -> int -> int
+ val f898 : int -> int -> int
+ val f899 : int -> int -> int
+ val f900 : int -> int -> int
+ val f901 : int -> int -> int
+ val f902 : int -> int -> int
+ val f903 : int -> int -> int
+ val f904 : int -> int -> int
+ val f905 : int -> int -> int
+ val f906 : int -> int -> int
+ val f907 : int -> int -> int
+ val f908 : int -> int -> int
+ val f909 : int -> int -> int
+ val f910 : int -> int -> int
+ val f911 : int -> int -> int
+ val f912 : int -> int -> int
+ val f913 : int -> int -> int
+ val f914 : int -> int -> int
+ val f915 : int -> int -> int
+ val f916 : int -> int -> int
+ val f917 : int -> int -> int
+ val f918 : int -> int -> int
+ val f919 : int -> int -> int
+ val f920 : int -> int -> int
+ val f921 : int -> int -> int
+ val f922 : int -> int -> int
+ val f923 : int -> int -> int
+ val f924 : int -> int -> int
+ val f925 : int -> int -> int
+ val f926 : int -> int -> int
+ val f927 : int -> int -> int
+ val f928 : int -> int -> int
+ val f929 : int -> int -> int
+ val f930 : int -> int -> int
+ val f931 : int -> int -> int
+ val f932 : int -> int -> int
+ val f933 : int -> int -> int
+ val f934 : int -> int -> int
+ val f935 : int -> int -> int
+ val f936 : int -> int -> int
+ val f937 : int -> int -> int
+ val f938 : int -> int -> int
+ val f939 : int -> int -> int
+ val f940 : int -> int -> int
+ val f941 : int -> int -> int
+ val f942 : int -> int -> int
+ val f943 : int -> int -> int
+ val f944 : int -> int -> int
+ val f945 : int -> int -> int
+ val f946 : int -> int -> int
+ val f947 : int -> int -> int
+ val f948 : int -> int -> int
+ val f949 : int -> int -> int
+ val f950 : int -> int -> int
+ val f951 : int -> int -> int
+ val f952 : int -> int -> int
+ val f953 : int -> int -> int
+ val f954 : int -> int -> int
+ val f955 : int -> int -> int
+ val f956 : int -> int -> int
+ val f957 : int -> int -> int
+ val f958 : int -> int -> int
+ val f959 : int -> int -> int
+ val f960 : int -> int -> int
+ val f961 : int -> int -> int
+ val f962 : int -> int -> int
+ val f963 : int -> int -> int
+ val f964 : int -> int -> int
+ val f965 : int -> int -> int
+ val f966 : int -> int -> int
+ val f967 : int -> int -> int
+ val f968 : int -> int -> int
+ val f969 : int -> int -> int
+ val f970 : int -> int -> int
+ val f971 : int -> int -> int
+ val f972 : int -> int -> int
+ val f973 : int -> int -> int
+ val f974 : int -> int -> int
+ val f975 : int -> int -> int
+ val f976 : int -> int -> int
+ val f977 : int -> int -> int
+ val f978 : int -> int -> int
+ val f979 : int -> int -> int
+ val f980 : int -> int -> int
+ val f981 : int -> int -> int
+ val f982 : int -> int -> int
+ val f983 : int -> int -> int
+ val f984 : int -> int -> int
+ val f985 : int -> int -> int
+ val f986 : int -> int -> int
+ val f987 : int -> int -> int
+ val f988 : int -> int -> int
+ val f989 : int -> int -> int
+ val f990 : int -> int -> int
+ val f991 : int -> int -> int
+ val f992 : int -> int -> int
+ val f993 : int -> int -> int
+ val f994 : int -> int -> int
+ val f995 : int -> int -> int
+ val f996 : int -> int -> int
+ val f997 : int -> int -> int
+ val f998 : int -> int -> int
+ val f999 : int -> int -> int
+ val f1000 : int -> int -> int
+end
+
+module Make (M : S) = struct
+ include M
+end
+
+module M = struct
+(* <%- for i in 0 .. 1000 do -%>
+ let f<%= i %> = ( + )
+<%- end -%> *)
+ let f0 = ( + )
+ let f1 = ( + )
+ let f2 = ( + )
+ let f3 = ( + )
+ let f4 = ( + )
+ let f5 = ( + )
+ let f6 = ( + )
+ let f7 = ( + )
+ let f8 = ( + )
+ let f9 = ( + )
+ let f10 = ( + )
+ let f11 = ( + )
+ let f12 = ( + )
+ let f13 = ( + )
+ let f14 = ( + )
+ let f15 = ( + )
+ let f16 = ( + )
+ let f17 = ( + )
+ let f18 = ( + )
+ let f19 = ( + )
+ let f20 = ( + )
+ let f21 = ( + )
+ let f22 = ( + )
+ let f23 = ( + )
+ let f24 = ( + )
+ let f25 = ( + )
+ let f26 = ( + )
+ let f27 = ( + )
+ let f28 = ( + )
+ let f29 = ( + )
+ let f30 = ( + )
+ let f31 = ( + )
+ let f32 = ( + )
+ let f33 = ( + )
+ let f34 = ( + )
+ let f35 = ( + )
+ let f36 = ( + )
+ let f37 = ( + )
+ let f38 = ( + )
+ let f39 = ( + )
+ let f40 = ( + )
+ let f41 = ( + )
+ let f42 = ( + )
+ let f43 = ( + )
+ let f44 = ( + )
+ let f45 = ( + )
+ let f46 = ( + )
+ let f47 = ( + )
+ let f48 = ( + )
+ let f49 = ( + )
+ let f50 = ( + )
+ let f51 = ( + )
+ let f52 = ( + )
+ let f53 = ( + )
+ let f54 = ( + )
+ let f55 = ( + )
+ let f56 = ( + )
+ let f57 = ( + )
+ let f58 = ( + )
+ let f59 = ( + )
+ let f60 = ( + )
+ let f61 = ( + )
+ let f62 = ( + )
+ let f63 = ( + )
+ let f64 = ( + )
+ let f65 = ( + )
+ let f66 = ( + )
+ let f67 = ( + )
+ let f68 = ( + )
+ let f69 = ( + )
+ let f70 = ( + )
+ let f71 = ( + )
+ let f72 = ( + )
+ let f73 = ( + )
+ let f74 = ( + )
+ let f75 = ( + )
+ let f76 = ( + )
+ let f77 = ( + )
+ let f78 = ( + )
+ let f79 = ( + )
+ let f80 = ( + )
+ let f81 = ( + )
+ let f82 = ( + )
+ let f83 = ( + )
+ let f84 = ( + )
+ let f85 = ( + )
+ let f86 = ( + )
+ let f87 = ( + )
+ let f88 = ( + )
+ let f89 = ( + )
+ let f90 = ( + )
+ let f91 = ( + )
+ let f92 = ( + )
+ let f93 = ( + )
+ let f94 = ( + )
+ let f95 = ( + )
+ let f96 = ( + )
+ let f97 = ( + )
+ let f98 = ( + )
+ let f99 = ( + )
+ let f100 = ( + )
+ let f101 = ( + )
+ let f102 = ( + )
+ let f103 = ( + )
+ let f104 = ( + )
+ let f105 = ( + )
+ let f106 = ( + )
+ let f107 = ( + )
+ let f108 = ( + )
+ let f109 = ( + )
+ let f110 = ( + )
+ let f111 = ( + )
+ let f112 = ( + )
+ let f113 = ( + )
+ let f114 = ( + )
+ let f115 = ( + )
+ let f116 = ( + )
+ let f117 = ( + )
+ let f118 = ( + )
+ let f119 = ( + )
+ let f120 = ( + )
+ let f121 = ( + )
+ let f122 = ( + )
+ let f123 = ( + )
+ let f124 = ( + )
+ let f125 = ( + )
+ let f126 = ( + )
+ let f127 = ( + )
+ let f128 = ( + )
+ let f129 = ( + )
+ let f130 = ( + )
+ let f131 = ( + )
+ let f132 = ( + )
+ let f133 = ( + )
+ let f134 = ( + )
+ let f135 = ( + )
+ let f136 = ( + )
+ let f137 = ( + )
+ let f138 = ( + )
+ let f139 = ( + )
+ let f140 = ( + )
+ let f141 = ( + )
+ let f142 = ( + )
+ let f143 = ( + )
+ let f144 = ( + )
+ let f145 = ( + )
+ let f146 = ( + )
+ let f147 = ( + )
+ let f148 = ( + )
+ let f149 = ( + )
+ let f150 = ( + )
+ let f151 = ( + )
+ let f152 = ( + )
+ let f153 = ( + )
+ let f154 = ( + )
+ let f155 = ( + )
+ let f156 = ( + )
+ let f157 = ( + )
+ let f158 = ( + )
+ let f159 = ( + )
+ let f160 = ( + )
+ let f161 = ( + )
+ let f162 = ( + )
+ let f163 = ( + )
+ let f164 = ( + )
+ let f165 = ( + )
+ let f166 = ( + )
+ let f167 = ( + )
+ let f168 = ( + )
+ let f169 = ( + )
+ let f170 = ( + )
+ let f171 = ( + )
+ let f172 = ( + )
+ let f173 = ( + )
+ let f174 = ( + )
+ let f175 = ( + )
+ let f176 = ( + )
+ let f177 = ( + )
+ let f178 = ( + )
+ let f179 = ( + )
+ let f180 = ( + )
+ let f181 = ( + )
+ let f182 = ( + )
+ let f183 = ( + )
+ let f184 = ( + )
+ let f185 = ( + )
+ let f186 = ( + )
+ let f187 = ( + )
+ let f188 = ( + )
+ let f189 = ( + )
+ let f190 = ( + )
+ let f191 = ( + )
+ let f192 = ( + )
+ let f193 = ( + )
+ let f194 = ( + )
+ let f195 = ( + )
+ let f196 = ( + )
+ let f197 = ( + )
+ let f198 = ( + )
+ let f199 = ( + )
+ let f200 = ( + )
+ let f201 = ( + )
+ let f202 = ( + )
+ let f203 = ( + )
+ let f204 = ( + )
+ let f205 = ( + )
+ let f206 = ( + )
+ let f207 = ( + )
+ let f208 = ( + )
+ let f209 = ( + )
+ let f210 = ( + )
+ let f211 = ( + )
+ let f212 = ( + )
+ let f213 = ( + )
+ let f214 = ( + )
+ let f215 = ( + )
+ let f216 = ( + )
+ let f217 = ( + )
+ let f218 = ( + )
+ let f219 = ( + )
+ let f220 = ( + )
+ let f221 = ( + )
+ let f222 = ( + )
+ let f223 = ( + )
+ let f224 = ( + )
+ let f225 = ( + )
+ let f226 = ( + )
+ let f227 = ( + )
+ let f228 = ( + )
+ let f229 = ( + )
+ let f230 = ( + )
+ let f231 = ( + )
+ let f232 = ( + )
+ let f233 = ( + )
+ let f234 = ( + )
+ let f235 = ( + )
+ let f236 = ( + )
+ let f237 = ( + )
+ let f238 = ( + )
+ let f239 = ( + )
+ let f240 = ( + )
+ let f241 = ( + )
+ let f242 = ( + )
+ let f243 = ( + )
+ let f244 = ( + )
+ let f245 = ( + )
+ let f246 = ( + )
+ let f247 = ( + )
+ let f248 = ( + )
+ let f249 = ( + )
+ let f250 = ( + )
+ let f251 = ( + )
+ let f252 = ( + )
+ let f253 = ( + )
+ let f254 = ( + )
+ let f255 = ( + )
+ let f256 = ( + )
+ let f257 = ( + )
+ let f258 = ( + )
+ let f259 = ( + )
+ let f260 = ( + )
+ let f261 = ( + )
+ let f262 = ( + )
+ let f263 = ( + )
+ let f264 = ( + )
+ let f265 = ( + )
+ let f266 = ( + )
+ let f267 = ( + )
+ let f268 = ( + )
+ let f269 = ( + )
+ let f270 = ( + )
+ let f271 = ( + )
+ let f272 = ( + )
+ let f273 = ( + )
+ let f274 = ( + )
+ let f275 = ( + )
+ let f276 = ( + )
+ let f277 = ( + )
+ let f278 = ( + )
+ let f279 = ( + )
+ let f280 = ( + )
+ let f281 = ( + )
+ let f282 = ( + )
+ let f283 = ( + )
+ let f284 = ( + )
+ let f285 = ( + )
+ let f286 = ( + )
+ let f287 = ( + )
+ let f288 = ( + )
+ let f289 = ( + )
+ let f290 = ( + )
+ let f291 = ( + )
+ let f292 = ( + )
+ let f293 = ( + )
+ let f294 = ( + )
+ let f295 = ( + )
+ let f296 = ( + )
+ let f297 = ( + )
+ let f298 = ( + )
+ let f299 = ( + )
+ let f300 = ( + )
+ let f301 = ( + )
+ let f302 = ( + )
+ let f303 = ( + )
+ let f304 = ( + )
+ let f305 = ( + )
+ let f306 = ( + )
+ let f307 = ( + )
+ let f308 = ( + )
+ let f309 = ( + )
+ let f310 = ( + )
+ let f311 = ( + )
+ let f312 = ( + )
+ let f313 = ( + )
+ let f314 = ( + )
+ let f315 = ( + )
+ let f316 = ( + )
+ let f317 = ( + )
+ let f318 = ( + )
+ let f319 = ( + )
+ let f320 = ( + )
+ let f321 = ( + )
+ let f322 = ( + )
+ let f323 = ( + )
+ let f324 = ( + )
+ let f325 = ( + )
+ let f326 = ( + )
+ let f327 = ( + )
+ let f328 = ( + )
+ let f329 = ( + )
+ let f330 = ( + )
+ let f331 = ( + )
+ let f332 = ( + )
+ let f333 = ( + )
+ let f334 = ( + )
+ let f335 = ( + )
+ let f336 = ( + )
+ let f337 = ( + )
+ let f338 = ( + )
+ let f339 = ( + )
+ let f340 = ( + )
+ let f341 = ( + )
+ let f342 = ( + )
+ let f343 = ( + )
+ let f344 = ( + )
+ let f345 = ( + )
+ let f346 = ( + )
+ let f347 = ( + )
+ let f348 = ( + )
+ let f349 = ( + )
+ let f350 = ( + )
+ let f351 = ( + )
+ let f352 = ( + )
+ let f353 = ( + )
+ let f354 = ( + )
+ let f355 = ( + )
+ let f356 = ( + )
+ let f357 = ( + )
+ let f358 = ( + )
+ let f359 = ( + )
+ let f360 = ( + )
+ let f361 = ( + )
+ let f362 = ( + )
+ let f363 = ( + )
+ let f364 = ( + )
+ let f365 = ( + )
+ let f366 = ( + )
+ let f367 = ( + )
+ let f368 = ( + )
+ let f369 = ( + )
+ let f370 = ( + )
+ let f371 = ( + )
+ let f372 = ( + )
+ let f373 = ( + )
+ let f374 = ( + )
+ let f375 = ( + )
+ let f376 = ( + )
+ let f377 = ( + )
+ let f378 = ( + )
+ let f379 = ( + )
+ let f380 = ( + )
+ let f381 = ( + )
+ let f382 = ( + )
+ let f383 = ( + )
+ let f384 = ( + )
+ let f385 = ( + )
+ let f386 = ( + )
+ let f387 = ( + )
+ let f388 = ( + )
+ let f389 = ( + )
+ let f390 = ( + )
+ let f391 = ( + )
+ let f392 = ( + )
+ let f393 = ( + )
+ let f394 = ( + )
+ let f395 = ( + )
+ let f396 = ( + )
+ let f397 = ( + )
+ let f398 = ( + )
+ let f399 = ( + )
+ let f400 = ( + )
+ let f401 = ( + )
+ let f402 = ( + )
+ let f403 = ( + )
+ let f404 = ( + )
+ let f405 = ( + )
+ let f406 = ( + )
+ let f407 = ( + )
+ let f408 = ( + )
+ let f409 = ( + )
+ let f410 = ( + )
+ let f411 = ( + )
+ let f412 = ( + )
+ let f413 = ( + )
+ let f414 = ( + )
+ let f415 = ( + )
+ let f416 = ( + )
+ let f417 = ( + )
+ let f418 = ( + )
+ let f419 = ( + )
+ let f420 = ( + )
+ let f421 = ( + )
+ let f422 = ( + )
+ let f423 = ( + )
+ let f424 = ( + )
+ let f425 = ( + )
+ let f426 = ( + )
+ let f427 = ( + )
+ let f428 = ( + )
+ let f429 = ( + )
+ let f430 = ( + )
+ let f431 = ( + )
+ let f432 = ( + )
+ let f433 = ( + )
+ let f434 = ( + )
+ let f435 = ( + )
+ let f436 = ( + )
+ let f437 = ( + )
+ let f438 = ( + )
+ let f439 = ( + )
+ let f440 = ( + )
+ let f441 = ( + )
+ let f442 = ( + )
+ let f443 = ( + )
+ let f444 = ( + )
+ let f445 = ( + )
+ let f446 = ( + )
+ let f447 = ( + )
+ let f448 = ( + )
+ let f449 = ( + )
+ let f450 = ( + )
+ let f451 = ( + )
+ let f452 = ( + )
+ let f453 = ( + )
+ let f454 = ( + )
+ let f455 = ( + )
+ let f456 = ( + )
+ let f457 = ( + )
+ let f458 = ( + )
+ let f459 = ( + )
+ let f460 = ( + )
+ let f461 = ( + )
+ let f462 = ( + )
+ let f463 = ( + )
+ let f464 = ( + )
+ let f465 = ( + )
+ let f466 = ( + )
+ let f467 = ( + )
+ let f468 = ( + )
+ let f469 = ( + )
+ let f470 = ( + )
+ let f471 = ( + )
+ let f472 = ( + )
+ let f473 = ( + )
+ let f474 = ( + )
+ let f475 = ( + )
+ let f476 = ( + )
+ let f477 = ( + )
+ let f478 = ( + )
+ let f479 = ( + )
+ let f480 = ( + )
+ let f481 = ( + )
+ let f482 = ( + )
+ let f483 = ( + )
+ let f484 = ( + )
+ let f485 = ( + )
+ let f486 = ( + )
+ let f487 = ( + )
+ let f488 = ( + )
+ let f489 = ( + )
+ let f490 = ( + )
+ let f491 = ( + )
+ let f492 = ( + )
+ let f493 = ( + )
+ let f494 = ( + )
+ let f495 = ( + )
+ let f496 = ( + )
+ let f497 = ( + )
+ let f498 = ( + )
+ let f499 = ( + )
+ let f500 = ( + )
+ let f501 = ( + )
+ let f502 = ( + )
+ let f503 = ( + )
+ let f504 = ( + )
+ let f505 = ( + )
+ let f506 = ( + )
+ let f507 = ( + )
+ let f508 = ( + )
+ let f509 = ( + )
+ let f510 = ( + )
+ let f511 = ( + )
+ let f512 = ( + )
+ let f513 = ( + )
+ let f514 = ( + )
+ let f515 = ( + )
+ let f516 = ( + )
+ let f517 = ( + )
+ let f518 = ( + )
+ let f519 = ( + )
+ let f520 = ( + )
+ let f521 = ( + )
+ let f522 = ( + )
+ let f523 = ( + )
+ let f524 = ( + )
+ let f525 = ( + )
+ let f526 = ( + )
+ let f527 = ( + )
+ let f528 = ( + )
+ let f529 = ( + )
+ let f530 = ( + )
+ let f531 = ( + )
+ let f532 = ( + )
+ let f533 = ( + )
+ let f534 = ( + )
+ let f535 = ( + )
+ let f536 = ( + )
+ let f537 = ( + )
+ let f538 = ( + )
+ let f539 = ( + )
+ let f540 = ( + )
+ let f541 = ( + )
+ let f542 = ( + )
+ let f543 = ( + )
+ let f544 = ( + )
+ let f545 = ( + )
+ let f546 = ( + )
+ let f547 = ( + )
+ let f548 = ( + )
+ let f549 = ( + )
+ let f550 = ( + )
+ let f551 = ( + )
+ let f552 = ( + )
+ let f553 = ( + )
+ let f554 = ( + )
+ let f555 = ( + )
+ let f556 = ( + )
+ let f557 = ( + )
+ let f558 = ( + )
+ let f559 = ( + )
+ let f560 = ( + )
+ let f561 = ( + )
+ let f562 = ( + )
+ let f563 = ( + )
+ let f564 = ( + )
+ let f565 = ( + )
+ let f566 = ( + )
+ let f567 = ( + )
+ let f568 = ( + )
+ let f569 = ( + )
+ let f570 = ( + )
+ let f571 = ( + )
+ let f572 = ( + )
+ let f573 = ( + )
+ let f574 = ( + )
+ let f575 = ( + )
+ let f576 = ( + )
+ let f577 = ( + )
+ let f578 = ( + )
+ let f579 = ( + )
+ let f580 = ( + )
+ let f581 = ( + )
+ let f582 = ( + )
+ let f583 = ( + )
+ let f584 = ( + )
+ let f585 = ( + )
+ let f586 = ( + )
+ let f587 = ( + )
+ let f588 = ( + )
+ let f589 = ( + )
+ let f590 = ( + )
+ let f591 = ( + )
+ let f592 = ( + )
+ let f593 = ( + )
+ let f594 = ( + )
+ let f595 = ( + )
+ let f596 = ( + )
+ let f597 = ( + )
+ let f598 = ( + )
+ let f599 = ( + )
+ let f600 = ( + )
+ let f601 = ( + )
+ let f602 = ( + )
+ let f603 = ( + )
+ let f604 = ( + )
+ let f605 = ( + )
+ let f606 = ( + )
+ let f607 = ( + )
+ let f608 = ( + )
+ let f609 = ( + )
+ let f610 = ( + )
+ let f611 = ( + )
+ let f612 = ( + )
+ let f613 = ( + )
+ let f614 = ( + )
+ let f615 = ( + )
+ let f616 = ( + )
+ let f617 = ( + )
+ let f618 = ( + )
+ let f619 = ( + )
+ let f620 = ( + )
+ let f621 = ( + )
+ let f622 = ( + )
+ let f623 = ( + )
+ let f624 = ( + )
+ let f625 = ( + )
+ let f626 = ( + )
+ let f627 = ( + )
+ let f628 = ( + )
+ let f629 = ( + )
+ let f630 = ( + )
+ let f631 = ( + )
+ let f632 = ( + )
+ let f633 = ( + )
+ let f634 = ( + )
+ let f635 = ( + )
+ let f636 = ( + )
+ let f637 = ( + )
+ let f638 = ( + )
+ let f639 = ( + )
+ let f640 = ( + )
+ let f641 = ( + )
+ let f642 = ( + )
+ let f643 = ( + )
+ let f644 = ( + )
+ let f645 = ( + )
+ let f646 = ( + )
+ let f647 = ( + )
+ let f648 = ( + )
+ let f649 = ( + )
+ let f650 = ( + )
+ let f651 = ( + )
+ let f652 = ( + )
+ let f653 = ( + )
+ let f654 = ( + )
+ let f655 = ( + )
+ let f656 = ( + )
+ let f657 = ( + )
+ let f658 = ( + )
+ let f659 = ( + )
+ let f660 = ( + )
+ let f661 = ( + )
+ let f662 = ( + )
+ let f663 = ( + )
+ let f664 = ( + )
+ let f665 = ( + )
+ let f666 = ( + )
+ let f667 = ( + )
+ let f668 = ( + )
+ let f669 = ( + )
+ let f670 = ( + )
+ let f671 = ( + )
+ let f672 = ( + )
+ let f673 = ( + )
+ let f674 = ( + )
+ let f675 = ( + )
+ let f676 = ( + )
+ let f677 = ( + )
+ let f678 = ( + )
+ let f679 = ( + )
+ let f680 = ( + )
+ let f681 = ( + )
+ let f682 = ( + )
+ let f683 = ( + )
+ let f684 = ( + )
+ let f685 = ( + )
+ let f686 = ( + )
+ let f687 = ( + )
+ let f688 = ( + )
+ let f689 = ( + )
+ let f690 = ( + )
+ let f691 = ( + )
+ let f692 = ( + )
+ let f693 = ( + )
+ let f694 = ( + )
+ let f695 = ( + )
+ let f696 = ( + )
+ let f697 = ( + )
+ let f698 = ( + )
+ let f699 = ( + )
+ let f700 = ( + )
+ let f701 = ( + )
+ let f702 = ( + )
+ let f703 = ( + )
+ let f704 = ( + )
+ let f705 = ( + )
+ let f706 = ( + )
+ let f707 = ( + )
+ let f708 = ( + )
+ let f709 = ( + )
+ let f710 = ( + )
+ let f711 = ( + )
+ let f712 = ( + )
+ let f713 = ( + )
+ let f714 = ( + )
+ let f715 = ( + )
+ let f716 = ( + )
+ let f717 = ( + )
+ let f718 = ( + )
+ let f719 = ( + )
+ let f720 = ( + )
+ let f721 = ( + )
+ let f722 = ( + )
+ let f723 = ( + )
+ let f724 = ( + )
+ let f725 = ( + )
+ let f726 = ( + )
+ let f727 = ( + )
+ let f728 = ( + )
+ let f729 = ( + )
+ let f730 = ( + )
+ let f731 = ( + )
+ let f732 = ( + )
+ let f733 = ( + )
+ let f734 = ( + )
+ let f735 = ( + )
+ let f736 = ( + )
+ let f737 = ( + )
+ let f738 = ( + )
+ let f739 = ( + )
+ let f740 = ( + )
+ let f741 = ( + )
+ let f742 = ( + )
+ let f743 = ( + )
+ let f744 = ( + )
+ let f745 = ( + )
+ let f746 = ( + )
+ let f747 = ( + )
+ let f748 = ( + )
+ let f749 = ( + )
+ let f750 = ( + )
+ let f751 = ( + )
+ let f752 = ( + )
+ let f753 = ( + )
+ let f754 = ( + )
+ let f755 = ( + )
+ let f756 = ( + )
+ let f757 = ( + )
+ let f758 = ( + )
+ let f759 = ( + )
+ let f760 = ( + )
+ let f761 = ( + )
+ let f762 = ( + )
+ let f763 = ( + )
+ let f764 = ( + )
+ let f765 = ( + )
+ let f766 = ( + )
+ let f767 = ( + )
+ let f768 = ( + )
+ let f769 = ( + )
+ let f770 = ( + )
+ let f771 = ( + )
+ let f772 = ( + )
+ let f773 = ( + )
+ let f774 = ( + )
+ let f775 = ( + )
+ let f776 = ( + )
+ let f777 = ( + )
+ let f778 = ( + )
+ let f779 = ( + )
+ let f780 = ( + )
+ let f781 = ( + )
+ let f782 = ( + )
+ let f783 = ( + )
+ let f784 = ( + )
+ let f785 = ( + )
+ let f786 = ( + )
+ let f787 = ( + )
+ let f788 = ( + )
+ let f789 = ( + )
+ let f790 = ( + )
+ let f791 = ( + )
+ let f792 = ( + )
+ let f793 = ( + )
+ let f794 = ( + )
+ let f795 = ( + )
+ let f796 = ( + )
+ let f797 = ( + )
+ let f798 = ( + )
+ let f799 = ( + )
+ let f800 = ( + )
+ let f801 = ( + )
+ let f802 = ( + )
+ let f803 = ( + )
+ let f804 = ( + )
+ let f805 = ( + )
+ let f806 = ( + )
+ let f807 = ( + )
+ let f808 = ( + )
+ let f809 = ( + )
+ let f810 = ( + )
+ let f811 = ( + )
+ let f812 = ( + )
+ let f813 = ( + )
+ let f814 = ( + )
+ let f815 = ( + )
+ let f816 = ( + )
+ let f817 = ( + )
+ let f818 = ( + )
+ let f819 = ( + )
+ let f820 = ( + )
+ let f821 = ( + )
+ let f822 = ( + )
+ let f823 = ( + )
+ let f824 = ( + )
+ let f825 = ( + )
+ let f826 = ( + )
+ let f827 = ( + )
+ let f828 = ( + )
+ let f829 = ( + )
+ let f830 = ( + )
+ let f831 = ( + )
+ let f832 = ( + )
+ let f833 = ( + )
+ let f834 = ( + )
+ let f835 = ( + )
+ let f836 = ( + )
+ let f837 = ( + )
+ let f838 = ( + )
+ let f839 = ( + )
+ let f840 = ( + )
+ let f841 = ( + )
+ let f842 = ( + )
+ let f843 = ( + )
+ let f844 = ( + )
+ let f845 = ( + )
+ let f846 = ( + )
+ let f847 = ( + )
+ let f848 = ( + )
+ let f849 = ( + )
+ let f850 = ( + )
+ let f851 = ( + )
+ let f852 = ( + )
+ let f853 = ( + )
+ let f854 = ( + )
+ let f855 = ( + )
+ let f856 = ( + )
+ let f857 = ( + )
+ let f858 = ( + )
+ let f859 = ( + )
+ let f860 = ( + )
+ let f861 = ( + )
+ let f862 = ( + )
+ let f863 = ( + )
+ let f864 = ( + )
+ let f865 = ( + )
+ let f866 = ( + )
+ let f867 = ( + )
+ let f868 = ( + )
+ let f869 = ( + )
+ let f870 = ( + )
+ let f871 = ( + )
+ let f872 = ( + )
+ let f873 = ( + )
+ let f874 = ( + )
+ let f875 = ( + )
+ let f876 = ( + )
+ let f877 = ( + )
+ let f878 = ( + )
+ let f879 = ( + )
+ let f880 = ( + )
+ let f881 = ( + )
+ let f882 = ( + )
+ let f883 = ( + )
+ let f884 = ( + )
+ let f885 = ( + )
+ let f886 = ( + )
+ let f887 = ( + )
+ let f888 = ( + )
+ let f889 = ( + )
+ let f890 = ( + )
+ let f891 = ( + )
+ let f892 = ( + )
+ let f893 = ( + )
+ let f894 = ( + )
+ let f895 = ( + )
+ let f896 = ( + )
+ let f897 = ( + )
+ let f898 = ( + )
+ let f899 = ( + )
+ let f900 = ( + )
+ let f901 = ( + )
+ let f902 = ( + )
+ let f903 = ( + )
+ let f904 = ( + )
+ let f905 = ( + )
+ let f906 = ( + )
+ let f907 = ( + )
+ let f908 = ( + )
+ let f909 = ( + )
+ let f910 = ( + )
+ let f911 = ( + )
+ let f912 = ( + )
+ let f913 = ( + )
+ let f914 = ( + )
+ let f915 = ( + )
+ let f916 = ( + )
+ let f917 = ( + )
+ let f918 = ( + )
+ let f919 = ( + )
+ let f920 = ( + )
+ let f921 = ( + )
+ let f922 = ( + )
+ let f923 = ( + )
+ let f924 = ( + )
+ let f925 = ( + )
+ let f926 = ( + )
+ let f927 = ( + )
+ let f928 = ( + )
+ let f929 = ( + )
+ let f930 = ( + )
+ let f931 = ( + )
+ let f932 = ( + )
+ let f933 = ( + )
+ let f934 = ( + )
+ let f935 = ( + )
+ let f936 = ( + )
+ let f937 = ( + )
+ let f938 = ( + )
+ let f939 = ( + )
+ let f940 = ( + )
+ let f941 = ( + )
+ let f942 = ( + )
+ let f943 = ( + )
+ let f944 = ( + )
+ let f945 = ( + )
+ let f946 = ( + )
+ let f947 = ( + )
+ let f948 = ( + )
+ let f949 = ( + )
+ let f950 = ( + )
+ let f951 = ( + )
+ let f952 = ( + )
+ let f953 = ( + )
+ let f954 = ( + )
+ let f955 = ( + )
+ let f956 = ( + )
+ let f957 = ( + )
+ let f958 = ( + )
+ let f959 = ( + )
+ let f960 = ( + )
+ let f961 = ( + )
+ let f962 = ( + )
+ let f963 = ( + )
+ let f964 = ( + )
+ let f965 = ( + )
+ let f966 = ( + )
+ let f967 = ( + )
+ let f968 = ( + )
+ let f969 = ( + )
+ let f970 = ( + )
+ let f971 = ( + )
+ let f972 = ( + )
+ let f973 = ( + )
+ let f974 = ( + )
+ let f975 = ( + )
+ let f976 = ( + )
+ let f977 = ( + )
+ let f978 = ( + )
+ let f979 = ( + )
+ let f980 = ( + )
+ let f981 = ( + )
+ let f982 = ( + )
+ let f983 = ( + )
+ let f984 = ( + )
+ let f985 = ( + )
+ let f986 = ( + )
+ let f987 = ( + )
+ let f988 = ( + )
+ let f989 = ( + )
+ let f990 = ( + )
+ let f991 = ( + )
+ let f992 = ( + )
+ let f993 = ( + )
+ let f994 = ( + )
+ let f995 = ( + )
+ let f996 = ( + )
+ let f997 = ( + )
+ let f998 = ( + )
+ let f999 = ( + )
+ let f1000 = ( + )
+end
+
+module X = Make(Make(Make(M)))
--- /dev/null
+
+
+module type S = sig
+ type t0
+ type t1
+ type t2
+ type t3
+ type t4
+ type t5
+ type t6
+ type t7
+ type t8
+ type t9
+ type t10
+ type t11
+ type t12
+ type t13
+ type t14
+ type t15
+ type t16
+ type t17
+ type t18
+ type t19
+ type t20
+ type t21
+ type t22
+ type t23
+ type t24
+ type t25
+ type t26
+ type t27
+ type t28
+ type t29
+ type t30
+ type t31
+ type t32
+ type t33
+ type t34
+ type t35
+ type t36
+ type t37
+ type t38
+ type t39
+ type t40
+ type t41
+ type t42
+ type t43
+ type t44
+ type t45
+ type t46
+ type t47
+ type t48
+ type t49
+ type t50
+ type t51
+ type t52
+ type t53
+ type t54
+ type t55
+ type t56
+ type t57
+ type t58
+ type t59
+ type t60
+ type t61
+ type t62
+ type t63
+ type t64
+ type t65
+ type t66
+ type t67
+ type t68
+ type t69
+ type t70
+ type t71
+ type t72
+ type t73
+ type t74
+ type t75
+ type t76
+ type t77
+ type t78
+ type t79
+ type t80
+ type t81
+ type t82
+ type t83
+ type t84
+ type t85
+ type t86
+ type t87
+ type t88
+ type t89
+ type t90
+ type t91
+ type t92
+ type t93
+ type t94
+ type t95
+ type t96
+ type t97
+ type t98
+ type t99
+ type t100
+ type t101
+ type t102
+ type t103
+ type t104
+ type t105
+ type t106
+ type t107
+ type t108
+ type t109
+ type t110
+ type t111
+ type t112
+ type t113
+ type t114
+ type t115
+ type t116
+ type t117
+ type t118
+ type t119
+ type t120
+ type t121
+ type t122
+ type t123
+ type t124
+ type t125
+ type t126
+ type t127
+ type t128
+ type t129
+ type t130
+ type t131
+ type t132
+ type t133
+ type t134
+ type t135
+ type t136
+ type t137
+ type t138
+ type t139
+ type t140
+ type t141
+ type t142
+ type t143
+ type t144
+ type t145
+ type t146
+ type t147
+ type t148
+ type t149
+ type t150
+ type t151
+ type t152
+ type t153
+ type t154
+ type t155
+ type t156
+ type t157
+ type t158
+ type t159
+ type t160
+ type t161
+ type t162
+ type t163
+ type t164
+ type t165
+ type t166
+ type t167
+ type t168
+ type t169
+ type t170
+ type t171
+ type t172
+ type t173
+ type t174
+ type t175
+ type t176
+ type t177
+ type t178
+ type t179
+ type t180
+ type t181
+ type t182
+ type t183
+ type t184
+ type t185
+ type t186
+ type t187
+ type t188
+ type t189
+ type t190
+ type t191
+ type t192
+ type t193
+ type t194
+ type t195
+ type t196
+ type t197
+ type t198
+ type t199
+ type t200
+ type t201
+ type t202
+ type t203
+ type t204
+ type t205
+ type t206
+ type t207
+ type t208
+ type t209
+ type t210
+ type t211
+ type t212
+ type t213
+ type t214
+ type t215
+ type t216
+ type t217
+ type t218
+ type t219
+ type t220
+ type t221
+ type t222
+ type t223
+ type t224
+ type t225
+ type t226
+ type t227
+ type t228
+ type t229
+ type t230
+ type t231
+ type t232
+ type t233
+ type t234
+ type t235
+ type t236
+ type t237
+ type t238
+ type t239
+ type t240
+ type t241
+ type t242
+ type t243
+ type t244
+ type t245
+ type t246
+ type t247
+ type t248
+ type t249
+ type t250
+ type t251
+ type t252
+ type t253
+ type t254
+ type t255
+ type t256
+ type t257
+ type t258
+ type t259
+ type t260
+ type t261
+ type t262
+ type t263
+ type t264
+ type t265
+ type t266
+ type t267
+ type t268
+ type t269
+ type t270
+ type t271
+ type t272
+ type t273
+ type t274
+ type t275
+ type t276
+ type t277
+ type t278
+ type t279
+ type t280
+ type t281
+ type t282
+ type t283
+ type t284
+ type t285
+ type t286
+ type t287
+ type t288
+ type t289
+ type t290
+ type t291
+ type t292
+ type t293
+ type t294
+ type t295
+ type t296
+ type t297
+ type t298
+ type t299
+ type t300
+ type t301
+ type t302
+ type t303
+ type t304
+ type t305
+ type t306
+ type t307
+ type t308
+ type t309
+ type t310
+ type t311
+ type t312
+ type t313
+ type t314
+ type t315
+ type t316
+ type t317
+ type t318
+ type t319
+ type t320
+ type t321
+ type t322
+ type t323
+ type t324
+ type t325
+ type t326
+ type t327
+ type t328
+ type t329
+ type t330
+ type t331
+ type t332
+ type t333
+ type t334
+ type t335
+ type t336
+ type t337
+ type t338
+ type t339
+ type t340
+ type t341
+ type t342
+ type t343
+ type t344
+ type t345
+ type t346
+ type t347
+ type t348
+ type t349
+ type t350
+ type t351
+ type t352
+ type t353
+ type t354
+ type t355
+ type t356
+ type t357
+ type t358
+ type t359
+ type t360
+ type t361
+ type t362
+ type t363
+ type t364
+ type t365
+ type t366
+ type t367
+ type t368
+ type t369
+ type t370
+ type t371
+ type t372
+ type t373
+ type t374
+ type t375
+ type t376
+ type t377
+ type t378
+ type t379
+ type t380
+ type t381
+ type t382
+ type t383
+ type t384
+ type t385
+ type t386
+ type t387
+ type t388
+ type t389
+ type t390
+ type t391
+ type t392
+ type t393
+ type t394
+ type t395
+ type t396
+ type t397
+ type t398
+ type t399
+ type t400
+ type t401
+ type t402
+ type t403
+ type t404
+ type t405
+ type t406
+ type t407
+ type t408
+ type t409
+ type t410
+ type t411
+ type t412
+ type t413
+ type t414
+ type t415
+ type t416
+ type t417
+ type t418
+ type t419
+ type t420
+ type t421
+ type t422
+ type t423
+ type t424
+ type t425
+ type t426
+ type t427
+ type t428
+ type t429
+ type t430
+ type t431
+ type t432
+ type t433
+ type t434
+ type t435
+ type t436
+ type t437
+ type t438
+ type t439
+ type t440
+ type t441
+ type t442
+ type t443
+ type t444
+ type t445
+ type t446
+ type t447
+ type t448
+ type t449
+ type t450
+ type t451
+ type t452
+ type t453
+ type t454
+ type t455
+ type t456
+ type t457
+ type t458
+ type t459
+ type t460
+ type t461
+ type t462
+ type t463
+ type t464
+ type t465
+ type t466
+ type t467
+ type t468
+ type t469
+ type t470
+ type t471
+ type t472
+ type t473
+ type t474
+ type t475
+ type t476
+ type t477
+ type t478
+ type t479
+ type t480
+ type t481
+ type t482
+ type t483
+ type t484
+ type t485
+ type t486
+ type t487
+ type t488
+ type t489
+ type t490
+ type t491
+ type t492
+ type t493
+ type t494
+ type t495
+ type t496
+ type t497
+ type t498
+ type t499
+ type t500
+ type t501
+ type t502
+ type t503
+ type t504
+ type t505
+ type t506
+ type t507
+ type t508
+ type t509
+ type t510
+ type t511
+ type t512
+ type t513
+ type t514
+ type t515
+ type t516
+ type t517
+ type t518
+ type t519
+ type t520
+ type t521
+ type t522
+ type t523
+ type t524
+ type t525
+ type t526
+ type t527
+ type t528
+ type t529
+ type t530
+ type t531
+ type t532
+ type t533
+ type t534
+ type t535
+ type t536
+ type t537
+ type t538
+ type t539
+ type t540
+ type t541
+ type t542
+ type t543
+ type t544
+ type t545
+ type t546
+ type t547
+ type t548
+ type t549
+ type t550
+ type t551
+ type t552
+ type t553
+ type t554
+ type t555
+ type t556
+ type t557
+ type t558
+ type t559
+ type t560
+ type t561
+ type t562
+ type t563
+ type t564
+ type t565
+ type t566
+ type t567
+ type t568
+ type t569
+ type t570
+ type t571
+ type t572
+ type t573
+ type t574
+ type t575
+ type t576
+ type t577
+ type t578
+ type t579
+ type t580
+ type t581
+ type t582
+ type t583
+ type t584
+ type t585
+ type t586
+ type t587
+ type t588
+ type t589
+ type t590
+ type t591
+ type t592
+ type t593
+ type t594
+ type t595
+ type t596
+ type t597
+ type t598
+ type t599
+ type t600
+ type t601
+ type t602
+ type t603
+ type t604
+ type t605
+ type t606
+ type t607
+ type t608
+ type t609
+ type t610
+ type t611
+ type t612
+ type t613
+ type t614
+ type t615
+ type t616
+ type t617
+ type t618
+ type t619
+ type t620
+ type t621
+ type t622
+ type t623
+ type t624
+ type t625
+ type t626
+ type t627
+ type t628
+ type t629
+ type t630
+ type t631
+ type t632
+ type t633
+ type t634
+ type t635
+ type t636
+ type t637
+ type t638
+ type t639
+ type t640
+ type t641
+ type t642
+ type t643
+ type t644
+ type t645
+ type t646
+ type t647
+ type t648
+ type t649
+ type t650
+ type t651
+ type t652
+ type t653
+ type t654
+ type t655
+ type t656
+ type t657
+ type t658
+ type t659
+ type t660
+ type t661
+ type t662
+ type t663
+ type t664
+ type t665
+ type t666
+ type t667
+ type t668
+ type t669
+ type t670
+ type t671
+ type t672
+ type t673
+ type t674
+ type t675
+ type t676
+ type t677
+ type t678
+ type t679
+ type t680
+ type t681
+ type t682
+ type t683
+ type t684
+ type t685
+ type t686
+ type t687
+ type t688
+ type t689
+ type t690
+ type t691
+ type t692
+ type t693
+ type t694
+ type t695
+ type t696
+ type t697
+ type t698
+ type t699
+ type t700
+ type t701
+ type t702
+ type t703
+ type t704
+ type t705
+ type t706
+ type t707
+ type t708
+ type t709
+ type t710
+ type t711
+ type t712
+ type t713
+ type t714
+ type t715
+ type t716
+ type t717
+ type t718
+ type t719
+ type t720
+ type t721
+ type t722
+ type t723
+ type t724
+ type t725
+ type t726
+ type t727
+ type t728
+ type t729
+ type t730
+ type t731
+ type t732
+ type t733
+ type t734
+ type t735
+ type t736
+ type t737
+ type t738
+ type t739
+ type t740
+ type t741
+ type t742
+ type t743
+ type t744
+ type t745
+ type t746
+ type t747
+ type t748
+ type t749
+ type t750
+ type t751
+ type t752
+ type t753
+ type t754
+ type t755
+ type t756
+ type t757
+ type t758
+ type t759
+ type t760
+ type t761
+ type t762
+ type t763
+ type t764
+ type t765
+ type t766
+ type t767
+ type t768
+ type t769
+ type t770
+ type t771
+ type t772
+ type t773
+ type t774
+ type t775
+ type t776
+ type t777
+ type t778
+ type t779
+ type t780
+ type t781
+ type t782
+ type t783
+ type t784
+ type t785
+ type t786
+ type t787
+ type t788
+ type t789
+ type t790
+ type t791
+ type t792
+ type t793
+ type t794
+ type t795
+ type t796
+ type t797
+ type t798
+ type t799
+ type t800
+ type t801
+ type t802
+ type t803
+ type t804
+ type t805
+ type t806
+ type t807
+ type t808
+ type t809
+ type t810
+ type t811
+ type t812
+ type t813
+ type t814
+ type t815
+ type t816
+ type t817
+ type t818
+ type t819
+ type t820
+ type t821
+ type t822
+ type t823
+ type t824
+ type t825
+ type t826
+ type t827
+ type t828
+ type t829
+ type t830
+ type t831
+ type t832
+ type t833
+ type t834
+ type t835
+ type t836
+ type t837
+ type t838
+ type t839
+ type t840
+ type t841
+ type t842
+ type t843
+ type t844
+ type t845
+ type t846
+ type t847
+ type t848
+ type t849
+ type t850
+ type t851
+ type t852
+ type t853
+ type t854
+ type t855
+ type t856
+ type t857
+ type t858
+ type t859
+ type t860
+ type t861
+ type t862
+ type t863
+ type t864
+ type t865
+ type t866
+ type t867
+ type t868
+ type t869
+ type t870
+ type t871
+ type t872
+ type t873
+ type t874
+ type t875
+ type t876
+ type t877
+ type t878
+ type t879
+ type t880
+ type t881
+ type t882
+ type t883
+ type t884
+ type t885
+ type t886
+ type t887
+ type t888
+ type t889
+ type t890
+ type t891
+ type t892
+ type t893
+ type t894
+ type t895
+ type t896
+ type t897
+ type t898
+ type t899
+ type t900
+ type t901
+ type t902
+ type t903
+ type t904
+ type t905
+ type t906
+ type t907
+ type t908
+ type t909
+ type t910
+ type t911
+ type t912
+ type t913
+ type t914
+ type t915
+ type t916
+ type t917
+ type t918
+ type t919
+ type t920
+ type t921
+ type t922
+ type t923
+ type t924
+ type t925
+ type t926
+ type t927
+ type t928
+ type t929
+ type t930
+ type t931
+ type t932
+ type t933
+ type t934
+ type t935
+ type t936
+ type t937
+ type t938
+ type t939
+ type t940
+ type t941
+ type t942
+ type t943
+ type t944
+ type t945
+ type t946
+ type t947
+ type t948
+ type t949
+ type t950
+ type t951
+ type t952
+ type t953
+ type t954
+ type t955
+ type t956
+ type t957
+ type t958
+ type t959
+ type t960
+ type t961
+ type t962
+ type t963
+ type t964
+ type t965
+ type t966
+ type t967
+ type t968
+ type t969
+ type t970
+ type t971
+ type t972
+ type t973
+ type t974
+ type t975
+ type t976
+ type t977
+ type t978
+ type t979
+ type t980
+ type t981
+ type t982
+ type t983
+ type t984
+ type t985
+ type t986
+ type t987
+ type t988
+ type t989
+ type t990
+ type t991
+ type t992
+ type t993
+ type t994
+ type t995
+ type t996
+ type t997
+ type t998
+ type t999
+ type t1000
+end
+
+module Make (M : S)
+: S with type t0 = M.t0
+ and type t1 = M.t1
+ and type t2 = M.t2
+ and type t3 = M.t3
+ and type t4 = M.t4
+ and type t5 = M.t5
+ and type t6 = M.t6
+ and type t7 = M.t7
+ and type t8 = M.t8
+ and type t9 = M.t9
+ and type t10 = M.t10
+ and type t11 = M.t11
+ and type t12 = M.t12
+ and type t13 = M.t13
+ and type t14 = M.t14
+ and type t15 = M.t15
+ and type t16 = M.t16
+ and type t17 = M.t17
+ and type t18 = M.t18
+ and type t19 = M.t19
+ and type t20 = M.t20
+ and type t21 = M.t21
+ and type t22 = M.t22
+ and type t23 = M.t23
+ and type t24 = M.t24
+ and type t25 = M.t25
+ and type t26 = M.t26
+ and type t27 = M.t27
+ and type t28 = M.t28
+ and type t29 = M.t29
+ and type t30 = M.t30
+ and type t31 = M.t31
+ and type t32 = M.t32
+ and type t33 = M.t33
+ and type t34 = M.t34
+ and type t35 = M.t35
+ and type t36 = M.t36
+ and type t37 = M.t37
+ and type t38 = M.t38
+ and type t39 = M.t39
+ and type t40 = M.t40
+ and type t41 = M.t41
+ and type t42 = M.t42
+ and type t43 = M.t43
+ and type t44 = M.t44
+ and type t45 = M.t45
+ and type t46 = M.t46
+ and type t47 = M.t47
+ and type t48 = M.t48
+ and type t49 = M.t49
+ and type t50 = M.t50
+ and type t51 = M.t51
+ and type t52 = M.t52
+ and type t53 = M.t53
+ and type t54 = M.t54
+ and type t55 = M.t55
+ and type t56 = M.t56
+ and type t57 = M.t57
+ and type t58 = M.t58
+ and type t59 = M.t59
+ and type t60 = M.t60
+ and type t61 = M.t61
+ and type t62 = M.t62
+ and type t63 = M.t63
+ and type t64 = M.t64
+ and type t65 = M.t65
+ and type t66 = M.t66
+ and type t67 = M.t67
+ and type t68 = M.t68
+ and type t69 = M.t69
+ and type t70 = M.t70
+ and type t71 = M.t71
+ and type t72 = M.t72
+ and type t73 = M.t73
+ and type t74 = M.t74
+ and type t75 = M.t75
+ and type t76 = M.t76
+ and type t77 = M.t77
+ and type t78 = M.t78
+ and type t79 = M.t79
+ and type t80 = M.t80
+ and type t81 = M.t81
+ and type t82 = M.t82
+ and type t83 = M.t83
+ and type t84 = M.t84
+ and type t85 = M.t85
+ and type t86 = M.t86
+ and type t87 = M.t87
+ and type t88 = M.t88
+ and type t89 = M.t89
+ and type t90 = M.t90
+ and type t91 = M.t91
+ and type t92 = M.t92
+ and type t93 = M.t93
+ and type t94 = M.t94
+ and type t95 = M.t95
+ and type t96 = M.t96
+ and type t97 = M.t97
+ and type t98 = M.t98
+ and type t99 = M.t99
+ and type t100 = M.t100
+ and type t101 = M.t101
+ and type t102 = M.t102
+ and type t103 = M.t103
+ and type t104 = M.t104
+ and type t105 = M.t105
+ and type t106 = M.t106
+ and type t107 = M.t107
+ and type t108 = M.t108
+ and type t109 = M.t109
+ and type t110 = M.t110
+ and type t111 = M.t111
+ and type t112 = M.t112
+ and type t113 = M.t113
+ and type t114 = M.t114
+ and type t115 = M.t115
+ and type t116 = M.t116
+ and type t117 = M.t117
+ and type t118 = M.t118
+ and type t119 = M.t119
+ and type t120 = M.t120
+ and type t121 = M.t121
+ and type t122 = M.t122
+ and type t123 = M.t123
+ and type t124 = M.t124
+ and type t125 = M.t125
+ and type t126 = M.t126
+ and type t127 = M.t127
+ and type t128 = M.t128
+ and type t129 = M.t129
+ and type t130 = M.t130
+ and type t131 = M.t131
+ and type t132 = M.t132
+ and type t133 = M.t133
+ and type t134 = M.t134
+ and type t135 = M.t135
+ and type t136 = M.t136
+ and type t137 = M.t137
+ and type t138 = M.t138
+ and type t139 = M.t139
+ and type t140 = M.t140
+ and type t141 = M.t141
+ and type t142 = M.t142
+ and type t143 = M.t143
+ and type t144 = M.t144
+ and type t145 = M.t145
+ and type t146 = M.t146
+ and type t147 = M.t147
+ and type t148 = M.t148
+ and type t149 = M.t149
+ and type t150 = M.t150
+ and type t151 = M.t151
+ and type t152 = M.t152
+ and type t153 = M.t153
+ and type t154 = M.t154
+ and type t155 = M.t155
+ and type t156 = M.t156
+ and type t157 = M.t157
+ and type t158 = M.t158
+ and type t159 = M.t159
+ and type t160 = M.t160
+ and type t161 = M.t161
+ and type t162 = M.t162
+ and type t163 = M.t163
+ and type t164 = M.t164
+ and type t165 = M.t165
+ and type t166 = M.t166
+ and type t167 = M.t167
+ and type t168 = M.t168
+ and type t169 = M.t169
+ and type t170 = M.t170
+ and type t171 = M.t171
+ and type t172 = M.t172
+ and type t173 = M.t173
+ and type t174 = M.t174
+ and type t175 = M.t175
+ and type t176 = M.t176
+ and type t177 = M.t177
+ and type t178 = M.t178
+ and type t179 = M.t179
+ and type t180 = M.t180
+ and type t181 = M.t181
+ and type t182 = M.t182
+ and type t183 = M.t183
+ and type t184 = M.t184
+ and type t185 = M.t185
+ and type t186 = M.t186
+ and type t187 = M.t187
+ and type t188 = M.t188
+ and type t189 = M.t189
+ and type t190 = M.t190
+ and type t191 = M.t191
+ and type t192 = M.t192
+ and type t193 = M.t193
+ and type t194 = M.t194
+ and type t195 = M.t195
+ and type t196 = M.t196
+ and type t197 = M.t197
+ and type t198 = M.t198
+ and type t199 = M.t199
+ and type t200 = M.t200
+ and type t201 = M.t201
+ and type t202 = M.t202
+ and type t203 = M.t203
+ and type t204 = M.t204
+ and type t205 = M.t205
+ and type t206 = M.t206
+ and type t207 = M.t207
+ and type t208 = M.t208
+ and type t209 = M.t209
+ and type t210 = M.t210
+ and type t211 = M.t211
+ and type t212 = M.t212
+ and type t213 = M.t213
+ and type t214 = M.t214
+ and type t215 = M.t215
+ and type t216 = M.t216
+ and type t217 = M.t217
+ and type t218 = M.t218
+ and type t219 = M.t219
+ and type t220 = M.t220
+ and type t221 = M.t221
+ and type t222 = M.t222
+ and type t223 = M.t223
+ and type t224 = M.t224
+ and type t225 = M.t225
+ and type t226 = M.t226
+ and type t227 = M.t227
+ and type t228 = M.t228
+ and type t229 = M.t229
+ and type t230 = M.t230
+ and type t231 = M.t231
+ and type t232 = M.t232
+ and type t233 = M.t233
+ and type t234 = M.t234
+ and type t235 = M.t235
+ and type t236 = M.t236
+ and type t237 = M.t237
+ and type t238 = M.t238
+ and type t239 = M.t239
+ and type t240 = M.t240
+ and type t241 = M.t241
+ and type t242 = M.t242
+ and type t243 = M.t243
+ and type t244 = M.t244
+ and type t245 = M.t245
+ and type t246 = M.t246
+ and type t247 = M.t247
+ and type t248 = M.t248
+ and type t249 = M.t249
+ and type t250 = M.t250
+ and type t251 = M.t251
+ and type t252 = M.t252
+ and type t253 = M.t253
+ and type t254 = M.t254
+ and type t255 = M.t255
+ and type t256 = M.t256
+ and type t257 = M.t257
+ and type t258 = M.t258
+ and type t259 = M.t259
+ and type t260 = M.t260
+ and type t261 = M.t261
+ and type t262 = M.t262
+ and type t263 = M.t263
+ and type t264 = M.t264
+ and type t265 = M.t265
+ and type t266 = M.t266
+ and type t267 = M.t267
+ and type t268 = M.t268
+ and type t269 = M.t269
+ and type t270 = M.t270
+ and type t271 = M.t271
+ and type t272 = M.t272
+ and type t273 = M.t273
+ and type t274 = M.t274
+ and type t275 = M.t275
+ and type t276 = M.t276
+ and type t277 = M.t277
+ and type t278 = M.t278
+ and type t279 = M.t279
+ and type t280 = M.t280
+ and type t281 = M.t281
+ and type t282 = M.t282
+ and type t283 = M.t283
+ and type t284 = M.t284
+ and type t285 = M.t285
+ and type t286 = M.t286
+ and type t287 = M.t287
+ and type t288 = M.t288
+ and type t289 = M.t289
+ and type t290 = M.t290
+ and type t291 = M.t291
+ and type t292 = M.t292
+ and type t293 = M.t293
+ and type t294 = M.t294
+ and type t295 = M.t295
+ and type t296 = M.t296
+ and type t297 = M.t297
+ and type t298 = M.t298
+ and type t299 = M.t299
+ and type t300 = M.t300
+ and type t301 = M.t301
+ and type t302 = M.t302
+ and type t303 = M.t303
+ and type t304 = M.t304
+ and type t305 = M.t305
+ and type t306 = M.t306
+ and type t307 = M.t307
+ and type t308 = M.t308
+ and type t309 = M.t309
+ and type t310 = M.t310
+ and type t311 = M.t311
+ and type t312 = M.t312
+ and type t313 = M.t313
+ and type t314 = M.t314
+ and type t315 = M.t315
+ and type t316 = M.t316
+ and type t317 = M.t317
+ and type t318 = M.t318
+ and type t319 = M.t319
+ and type t320 = M.t320
+ and type t321 = M.t321
+ and type t322 = M.t322
+ and type t323 = M.t323
+ and type t324 = M.t324
+ and type t325 = M.t325
+ and type t326 = M.t326
+ and type t327 = M.t327
+ and type t328 = M.t328
+ and type t329 = M.t329
+ and type t330 = M.t330
+ and type t331 = M.t331
+ and type t332 = M.t332
+ and type t333 = M.t333
+ and type t334 = M.t334
+ and type t335 = M.t335
+ and type t336 = M.t336
+ and type t337 = M.t337
+ and type t338 = M.t338
+ and type t339 = M.t339
+ and type t340 = M.t340
+ and type t341 = M.t341
+ and type t342 = M.t342
+ and type t343 = M.t343
+ and type t344 = M.t344
+ and type t345 = M.t345
+ and type t346 = M.t346
+ and type t347 = M.t347
+ and type t348 = M.t348
+ and type t349 = M.t349
+ and type t350 = M.t350
+ and type t351 = M.t351
+ and type t352 = M.t352
+ and type t353 = M.t353
+ and type t354 = M.t354
+ and type t355 = M.t355
+ and type t356 = M.t356
+ and type t357 = M.t357
+ and type t358 = M.t358
+ and type t359 = M.t359
+ and type t360 = M.t360
+ and type t361 = M.t361
+ and type t362 = M.t362
+ and type t363 = M.t363
+ and type t364 = M.t364
+ and type t365 = M.t365
+ and type t366 = M.t366
+ and type t367 = M.t367
+ and type t368 = M.t368
+ and type t369 = M.t369
+ and type t370 = M.t370
+ and type t371 = M.t371
+ and type t372 = M.t372
+ and type t373 = M.t373
+ and type t374 = M.t374
+ and type t375 = M.t375
+ and type t376 = M.t376
+ and type t377 = M.t377
+ and type t378 = M.t378
+ and type t379 = M.t379
+ and type t380 = M.t380
+ and type t381 = M.t381
+ and type t382 = M.t382
+ and type t383 = M.t383
+ and type t384 = M.t384
+ and type t385 = M.t385
+ and type t386 = M.t386
+ and type t387 = M.t387
+ and type t388 = M.t388
+ and type t389 = M.t389
+ and type t390 = M.t390
+ and type t391 = M.t391
+ and type t392 = M.t392
+ and type t393 = M.t393
+ and type t394 = M.t394
+ and type t395 = M.t395
+ and type t396 = M.t396
+ and type t397 = M.t397
+ and type t398 = M.t398
+ and type t399 = M.t399
+ and type t400 = M.t400
+ and type t401 = M.t401
+ and type t402 = M.t402
+ and type t403 = M.t403
+ and type t404 = M.t404
+ and type t405 = M.t405
+ and type t406 = M.t406
+ and type t407 = M.t407
+ and type t408 = M.t408
+ and type t409 = M.t409
+ and type t410 = M.t410
+ and type t411 = M.t411
+ and type t412 = M.t412
+ and type t413 = M.t413
+ and type t414 = M.t414
+ and type t415 = M.t415
+ and type t416 = M.t416
+ and type t417 = M.t417
+ and type t418 = M.t418
+ and type t419 = M.t419
+ and type t420 = M.t420
+ and type t421 = M.t421
+ and type t422 = M.t422
+ and type t423 = M.t423
+ and type t424 = M.t424
+ and type t425 = M.t425
+ and type t426 = M.t426
+ and type t427 = M.t427
+ and type t428 = M.t428
+ and type t429 = M.t429
+ and type t430 = M.t430
+ and type t431 = M.t431
+ and type t432 = M.t432
+ and type t433 = M.t433
+ and type t434 = M.t434
+ and type t435 = M.t435
+ and type t436 = M.t436
+ and type t437 = M.t437
+ and type t438 = M.t438
+ and type t439 = M.t439
+ and type t440 = M.t440
+ and type t441 = M.t441
+ and type t442 = M.t442
+ and type t443 = M.t443
+ and type t444 = M.t444
+ and type t445 = M.t445
+ and type t446 = M.t446
+ and type t447 = M.t447
+ and type t448 = M.t448
+ and type t449 = M.t449
+ and type t450 = M.t450
+ and type t451 = M.t451
+ and type t452 = M.t452
+ and type t453 = M.t453
+ and type t454 = M.t454
+ and type t455 = M.t455
+ and type t456 = M.t456
+ and type t457 = M.t457
+ and type t458 = M.t458
+ and type t459 = M.t459
+ and type t460 = M.t460
+ and type t461 = M.t461
+ and type t462 = M.t462
+ and type t463 = M.t463
+ and type t464 = M.t464
+ and type t465 = M.t465
+ and type t466 = M.t466
+ and type t467 = M.t467
+ and type t468 = M.t468
+ and type t469 = M.t469
+ and type t470 = M.t470
+ and type t471 = M.t471
+ and type t472 = M.t472
+ and type t473 = M.t473
+ and type t474 = M.t474
+ and type t475 = M.t475
+ and type t476 = M.t476
+ and type t477 = M.t477
+ and type t478 = M.t478
+ and type t479 = M.t479
+ and type t480 = M.t480
+ and type t481 = M.t481
+ and type t482 = M.t482
+ and type t483 = M.t483
+ and type t484 = M.t484
+ and type t485 = M.t485
+ and type t486 = M.t486
+ and type t487 = M.t487
+ and type t488 = M.t488
+ and type t489 = M.t489
+ and type t490 = M.t490
+ and type t491 = M.t491
+ and type t492 = M.t492
+ and type t493 = M.t493
+ and type t494 = M.t494
+ and type t495 = M.t495
+ and type t496 = M.t496
+ and type t497 = M.t497
+ and type t498 = M.t498
+ and type t499 = M.t499
+ and type t500 = M.t500
+ and type t501 = M.t501
+ and type t502 = M.t502
+ and type t503 = M.t503
+ and type t504 = M.t504
+ and type t505 = M.t505
+ and type t506 = M.t506
+ and type t507 = M.t507
+ and type t508 = M.t508
+ and type t509 = M.t509
+ and type t510 = M.t510
+ and type t511 = M.t511
+ and type t512 = M.t512
+ and type t513 = M.t513
+ and type t514 = M.t514
+ and type t515 = M.t515
+ and type t516 = M.t516
+ and type t517 = M.t517
+ and type t518 = M.t518
+ and type t519 = M.t519
+ and type t520 = M.t520
+ and type t521 = M.t521
+ and type t522 = M.t522
+ and type t523 = M.t523
+ and type t524 = M.t524
+ and type t525 = M.t525
+ and type t526 = M.t526
+ and type t527 = M.t527
+ and type t528 = M.t528
+ and type t529 = M.t529
+ and type t530 = M.t530
+ and type t531 = M.t531
+ and type t532 = M.t532
+ and type t533 = M.t533
+ and type t534 = M.t534
+ and type t535 = M.t535
+ and type t536 = M.t536
+ and type t537 = M.t537
+ and type t538 = M.t538
+ and type t539 = M.t539
+ and type t540 = M.t540
+ and type t541 = M.t541
+ and type t542 = M.t542
+ and type t543 = M.t543
+ and type t544 = M.t544
+ and type t545 = M.t545
+ and type t546 = M.t546
+ and type t547 = M.t547
+ and type t548 = M.t548
+ and type t549 = M.t549
+ and type t550 = M.t550
+ and type t551 = M.t551
+ and type t552 = M.t552
+ and type t553 = M.t553
+ and type t554 = M.t554
+ and type t555 = M.t555
+ and type t556 = M.t556
+ and type t557 = M.t557
+ and type t558 = M.t558
+ and type t559 = M.t559
+ and type t560 = M.t560
+ and type t561 = M.t561
+ and type t562 = M.t562
+ and type t563 = M.t563
+ and type t564 = M.t564
+ and type t565 = M.t565
+ and type t566 = M.t566
+ and type t567 = M.t567
+ and type t568 = M.t568
+ and type t569 = M.t569
+ and type t570 = M.t570
+ and type t571 = M.t571
+ and type t572 = M.t572
+ and type t573 = M.t573
+ and type t574 = M.t574
+ and type t575 = M.t575
+ and type t576 = M.t576
+ and type t577 = M.t577
+ and type t578 = M.t578
+ and type t579 = M.t579
+ and type t580 = M.t580
+ and type t581 = M.t581
+ and type t582 = M.t582
+ and type t583 = M.t583
+ and type t584 = M.t584
+ and type t585 = M.t585
+ and type t586 = M.t586
+ and type t587 = M.t587
+ and type t588 = M.t588
+ and type t589 = M.t589
+ and type t590 = M.t590
+ and type t591 = M.t591
+ and type t592 = M.t592
+ and type t593 = M.t593
+ and type t594 = M.t594
+ and type t595 = M.t595
+ and type t596 = M.t596
+ and type t597 = M.t597
+ and type t598 = M.t598
+ and type t599 = M.t599
+ and type t600 = M.t600
+ and type t601 = M.t601
+ and type t602 = M.t602
+ and type t603 = M.t603
+ and type t604 = M.t604
+ and type t605 = M.t605
+ and type t606 = M.t606
+ and type t607 = M.t607
+ and type t608 = M.t608
+ and type t609 = M.t609
+ and type t610 = M.t610
+ and type t611 = M.t611
+ and type t612 = M.t612
+ and type t613 = M.t613
+ and type t614 = M.t614
+ and type t615 = M.t615
+ and type t616 = M.t616
+ and type t617 = M.t617
+ and type t618 = M.t618
+ and type t619 = M.t619
+ and type t620 = M.t620
+ and type t621 = M.t621
+ and type t622 = M.t622
+ and type t623 = M.t623
+ and type t624 = M.t624
+ and type t625 = M.t625
+ and type t626 = M.t626
+ and type t627 = M.t627
+ and type t628 = M.t628
+ and type t629 = M.t629
+ and type t630 = M.t630
+ and type t631 = M.t631
+ and type t632 = M.t632
+ and type t633 = M.t633
+ and type t634 = M.t634
+ and type t635 = M.t635
+ and type t636 = M.t636
+ and type t637 = M.t637
+ and type t638 = M.t638
+ and type t639 = M.t639
+ and type t640 = M.t640
+ and type t641 = M.t641
+ and type t642 = M.t642
+ and type t643 = M.t643
+ and type t644 = M.t644
+ and type t645 = M.t645
+ and type t646 = M.t646
+ and type t647 = M.t647
+ and type t648 = M.t648
+ and type t649 = M.t649
+ and type t650 = M.t650
+ and type t651 = M.t651
+ and type t652 = M.t652
+ and type t653 = M.t653
+ and type t654 = M.t654
+ and type t655 = M.t655
+ and type t656 = M.t656
+ and type t657 = M.t657
+ and type t658 = M.t658
+ and type t659 = M.t659
+ and type t660 = M.t660
+ and type t661 = M.t661
+ and type t662 = M.t662
+ and type t663 = M.t663
+ and type t664 = M.t664
+ and type t665 = M.t665
+ and type t666 = M.t666
+ and type t667 = M.t667
+ and type t668 = M.t668
+ and type t669 = M.t669
+ and type t670 = M.t670
+ and type t671 = M.t671
+ and type t672 = M.t672
+ and type t673 = M.t673
+ and type t674 = M.t674
+ and type t675 = M.t675
+ and type t676 = M.t676
+ and type t677 = M.t677
+ and type t678 = M.t678
+ and type t679 = M.t679
+ and type t680 = M.t680
+ and type t681 = M.t681
+ and type t682 = M.t682
+ and type t683 = M.t683
+ and type t684 = M.t684
+ and type t685 = M.t685
+ and type t686 = M.t686
+ and type t687 = M.t687
+ and type t688 = M.t688
+ and type t689 = M.t689
+ and type t690 = M.t690
+ and type t691 = M.t691
+ and type t692 = M.t692
+ and type t693 = M.t693
+ and type t694 = M.t694
+ and type t695 = M.t695
+ and type t696 = M.t696
+ and type t697 = M.t697
+ and type t698 = M.t698
+ and type t699 = M.t699
+ and type t700 = M.t700
+ and type t701 = M.t701
+ and type t702 = M.t702
+ and type t703 = M.t703
+ and type t704 = M.t704
+ and type t705 = M.t705
+ and type t706 = M.t706
+ and type t707 = M.t707
+ and type t708 = M.t708
+ and type t709 = M.t709
+ and type t710 = M.t710
+ and type t711 = M.t711
+ and type t712 = M.t712
+ and type t713 = M.t713
+ and type t714 = M.t714
+ and type t715 = M.t715
+ and type t716 = M.t716
+ and type t717 = M.t717
+ and type t718 = M.t718
+ and type t719 = M.t719
+ and type t720 = M.t720
+ and type t721 = M.t721
+ and type t722 = M.t722
+ and type t723 = M.t723
+ and type t724 = M.t724
+ and type t725 = M.t725
+ and type t726 = M.t726
+ and type t727 = M.t727
+ and type t728 = M.t728
+ and type t729 = M.t729
+ and type t730 = M.t730
+ and type t731 = M.t731
+ and type t732 = M.t732
+ and type t733 = M.t733
+ and type t734 = M.t734
+ and type t735 = M.t735
+ and type t736 = M.t736
+ and type t737 = M.t737
+ and type t738 = M.t738
+ and type t739 = M.t739
+ and type t740 = M.t740
+ and type t741 = M.t741
+ and type t742 = M.t742
+ and type t743 = M.t743
+ and type t744 = M.t744
+ and type t745 = M.t745
+ and type t746 = M.t746
+ and type t747 = M.t747
+ and type t748 = M.t748
+ and type t749 = M.t749
+ and type t750 = M.t750
+ and type t751 = M.t751
+ and type t752 = M.t752
+ and type t753 = M.t753
+ and type t754 = M.t754
+ and type t755 = M.t755
+ and type t756 = M.t756
+ and type t757 = M.t757
+ and type t758 = M.t758
+ and type t759 = M.t759
+ and type t760 = M.t760
+ and type t761 = M.t761
+ and type t762 = M.t762
+ and type t763 = M.t763
+ and type t764 = M.t764
+ and type t765 = M.t765
+ and type t766 = M.t766
+ and type t767 = M.t767
+ and type t768 = M.t768
+ and type t769 = M.t769
+ and type t770 = M.t770
+ and type t771 = M.t771
+ and type t772 = M.t772
+ and type t773 = M.t773
+ and type t774 = M.t774
+ and type t775 = M.t775
+ and type t776 = M.t776
+ and type t777 = M.t777
+ and type t778 = M.t778
+ and type t779 = M.t779
+ and type t780 = M.t780
+ and type t781 = M.t781
+ and type t782 = M.t782
+ and type t783 = M.t783
+ and type t784 = M.t784
+ and type t785 = M.t785
+ and type t786 = M.t786
+ and type t787 = M.t787
+ and type t788 = M.t788
+ and type t789 = M.t789
+ and type t790 = M.t790
+ and type t791 = M.t791
+ and type t792 = M.t792
+ and type t793 = M.t793
+ and type t794 = M.t794
+ and type t795 = M.t795
+ and type t796 = M.t796
+ and type t797 = M.t797
+ and type t798 = M.t798
+ and type t799 = M.t799
+ and type t800 = M.t800
+ and type t801 = M.t801
+ and type t802 = M.t802
+ and type t803 = M.t803
+ and type t804 = M.t804
+ and type t805 = M.t805
+ and type t806 = M.t806
+ and type t807 = M.t807
+ and type t808 = M.t808
+ and type t809 = M.t809
+ and type t810 = M.t810
+ and type t811 = M.t811
+ and type t812 = M.t812
+ and type t813 = M.t813
+ and type t814 = M.t814
+ and type t815 = M.t815
+ and type t816 = M.t816
+ and type t817 = M.t817
+ and type t818 = M.t818
+ and type t819 = M.t819
+ and type t820 = M.t820
+ and type t821 = M.t821
+ and type t822 = M.t822
+ and type t823 = M.t823
+ and type t824 = M.t824
+ and type t825 = M.t825
+ and type t826 = M.t826
+ and type t827 = M.t827
+ and type t828 = M.t828
+ and type t829 = M.t829
+ and type t830 = M.t830
+ and type t831 = M.t831
+ and type t832 = M.t832
+ and type t833 = M.t833
+ and type t834 = M.t834
+ and type t835 = M.t835
+ and type t836 = M.t836
+ and type t837 = M.t837
+ and type t838 = M.t838
+ and type t839 = M.t839
+ and type t840 = M.t840
+ and type t841 = M.t841
+ and type t842 = M.t842
+ and type t843 = M.t843
+ and type t844 = M.t844
+ and type t845 = M.t845
+ and type t846 = M.t846
+ and type t847 = M.t847
+ and type t848 = M.t848
+ and type t849 = M.t849
+ and type t850 = M.t850
+ and type t851 = M.t851
+ and type t852 = M.t852
+ and type t853 = M.t853
+ and type t854 = M.t854
+ and type t855 = M.t855
+ and type t856 = M.t856
+ and type t857 = M.t857
+ and type t858 = M.t858
+ and type t859 = M.t859
+ and type t860 = M.t860
+ and type t861 = M.t861
+ and type t862 = M.t862
+ and type t863 = M.t863
+ and type t864 = M.t864
+ and type t865 = M.t865
+ and type t866 = M.t866
+ and type t867 = M.t867
+ and type t868 = M.t868
+ and type t869 = M.t869
+ and type t870 = M.t870
+ and type t871 = M.t871
+ and type t872 = M.t872
+ and type t873 = M.t873
+ and type t874 = M.t874
+ and type t875 = M.t875
+ and type t876 = M.t876
+ and type t877 = M.t877
+ and type t878 = M.t878
+ and type t879 = M.t879
+ and type t880 = M.t880
+ and type t881 = M.t881
+ and type t882 = M.t882
+ and type t883 = M.t883
+ and type t884 = M.t884
+ and type t885 = M.t885
+ and type t886 = M.t886
+ and type t887 = M.t887
+ and type t888 = M.t888
+ and type t889 = M.t889
+ and type t890 = M.t890
+ and type t891 = M.t891
+ and type t892 = M.t892
+ and type t893 = M.t893
+ and type t894 = M.t894
+ and type t895 = M.t895
+ and type t896 = M.t896
+ and type t897 = M.t897
+ and type t898 = M.t898
+ and type t899 = M.t899
+ and type t900 = M.t900
+ and type t901 = M.t901
+ and type t902 = M.t902
+ and type t903 = M.t903
+ and type t904 = M.t904
+ and type t905 = M.t905
+ and type t906 = M.t906
+ and type t907 = M.t907
+ and type t908 = M.t908
+ and type t909 = M.t909
+ and type t910 = M.t910
+ and type t911 = M.t911
+ and type t912 = M.t912
+ and type t913 = M.t913
+ and type t914 = M.t914
+ and type t915 = M.t915
+ and type t916 = M.t916
+ and type t917 = M.t917
+ and type t918 = M.t918
+ and type t919 = M.t919
+ and type t920 = M.t920
+ and type t921 = M.t921
+ and type t922 = M.t922
+ and type t923 = M.t923
+ and type t924 = M.t924
+ and type t925 = M.t925
+ and type t926 = M.t926
+ and type t927 = M.t927
+ and type t928 = M.t928
+ and type t929 = M.t929
+ and type t930 = M.t930
+ and type t931 = M.t931
+ and type t932 = M.t932
+ and type t933 = M.t933
+ and type t934 = M.t934
+ and type t935 = M.t935
+ and type t936 = M.t936
+ and type t937 = M.t937
+ and type t938 = M.t938
+ and type t939 = M.t939
+ and type t940 = M.t940
+ and type t941 = M.t941
+ and type t942 = M.t942
+ and type t943 = M.t943
+ and type t944 = M.t944
+ and type t945 = M.t945
+ and type t946 = M.t946
+ and type t947 = M.t947
+ and type t948 = M.t948
+ and type t949 = M.t949
+ and type t950 = M.t950
+ and type t951 = M.t951
+ and type t952 = M.t952
+ and type t953 = M.t953
+ and type t954 = M.t954
+ and type t955 = M.t955
+ and type t956 = M.t956
+ and type t957 = M.t957
+ and type t958 = M.t958
+ and type t959 = M.t959
+ and type t960 = M.t960
+ and type t961 = M.t961
+ and type t962 = M.t962
+ and type t963 = M.t963
+ and type t964 = M.t964
+ and type t965 = M.t965
+ and type t966 = M.t966
+ and type t967 = M.t967
+ and type t968 = M.t968
+ and type t969 = M.t969
+ and type t970 = M.t970
+ and type t971 = M.t971
+ and type t972 = M.t972
+ and type t973 = M.t973
+ and type t974 = M.t974
+ and type t975 = M.t975
+ and type t976 = M.t976
+ and type t977 = M.t977
+ and type t978 = M.t978
+ and type t979 = M.t979
+ and type t980 = M.t980
+ and type t981 = M.t981
+ and type t982 = M.t982
+ and type t983 = M.t983
+ and type t984 = M.t984
+ and type t985 = M.t985
+ and type t986 = M.t986
+ and type t987 = M.t987
+ and type t988 = M.t988
+ and type t989 = M.t989
+ and type t990 = M.t990
+ and type t991 = M.t991
+ and type t992 = M.t992
+ and type t993 = M.t993
+ and type t994 = M.t994
+ and type t995 = M.t995
+ and type t996 = M.t996
+ and type t997 = M.t997
+ and type t998 = M.t998
+ and type t999 = M.t999
+ and type t1000 = M.t1000
+= struct
+ include M
+end
+
+module M = struct
+ type t0 = int -> int -> int
+ type t1 = int -> int -> int
+ type t2 = int -> int -> int
+ type t3 = int -> int -> int
+ type t4 = int -> int -> int
+ type t5 = int -> int -> int
+ type t6 = int -> int -> int
+ type t7 = int -> int -> int
+ type t8 = int -> int -> int
+ type t9 = int -> int -> int
+ type t10 = int -> int -> int
+ type t11 = int -> int -> int
+ type t12 = int -> int -> int
+ type t13 = int -> int -> int
+ type t14 = int -> int -> int
+ type t15 = int -> int -> int
+ type t16 = int -> int -> int
+ type t17 = int -> int -> int
+ type t18 = int -> int -> int
+ type t19 = int -> int -> int
+ type t20 = int -> int -> int
+ type t21 = int -> int -> int
+ type t22 = int -> int -> int
+ type t23 = int -> int -> int
+ type t24 = int -> int -> int
+ type t25 = int -> int -> int
+ type t26 = int -> int -> int
+ type t27 = int -> int -> int
+ type t28 = int -> int -> int
+ type t29 = int -> int -> int
+ type t30 = int -> int -> int
+ type t31 = int -> int -> int
+ type t32 = int -> int -> int
+ type t33 = int -> int -> int
+ type t34 = int -> int -> int
+ type t35 = int -> int -> int
+ type t36 = int -> int -> int
+ type t37 = int -> int -> int
+ type t38 = int -> int -> int
+ type t39 = int -> int -> int
+ type t40 = int -> int -> int
+ type t41 = int -> int -> int
+ type t42 = int -> int -> int
+ type t43 = int -> int -> int
+ type t44 = int -> int -> int
+ type t45 = int -> int -> int
+ type t46 = int -> int -> int
+ type t47 = int -> int -> int
+ type t48 = int -> int -> int
+ type t49 = int -> int -> int
+ type t50 = int -> int -> int
+ type t51 = int -> int -> int
+ type t52 = int -> int -> int
+ type t53 = int -> int -> int
+ type t54 = int -> int -> int
+ type t55 = int -> int -> int
+ type t56 = int -> int -> int
+ type t57 = int -> int -> int
+ type t58 = int -> int -> int
+ type t59 = int -> int -> int
+ type t60 = int -> int -> int
+ type t61 = int -> int -> int
+ type t62 = int -> int -> int
+ type t63 = int -> int -> int
+ type t64 = int -> int -> int
+ type t65 = int -> int -> int
+ type t66 = int -> int -> int
+ type t67 = int -> int -> int
+ type t68 = int -> int -> int
+ type t69 = int -> int -> int
+ type t70 = int -> int -> int
+ type t71 = int -> int -> int
+ type t72 = int -> int -> int
+ type t73 = int -> int -> int
+ type t74 = int -> int -> int
+ type t75 = int -> int -> int
+ type t76 = int -> int -> int
+ type t77 = int -> int -> int
+ type t78 = int -> int -> int
+ type t79 = int -> int -> int
+ type t80 = int -> int -> int
+ type t81 = int -> int -> int
+ type t82 = int -> int -> int
+ type t83 = int -> int -> int
+ type t84 = int -> int -> int
+ type t85 = int -> int -> int
+ type t86 = int -> int -> int
+ type t87 = int -> int -> int
+ type t88 = int -> int -> int
+ type t89 = int -> int -> int
+ type t90 = int -> int -> int
+ type t91 = int -> int -> int
+ type t92 = int -> int -> int
+ type t93 = int -> int -> int
+ type t94 = int -> int -> int
+ type t95 = int -> int -> int
+ type t96 = int -> int -> int
+ type t97 = int -> int -> int
+ type t98 = int -> int -> int
+ type t99 = int -> int -> int
+ type t100 = int -> int -> int
+ type t101 = int -> int -> int
+ type t102 = int -> int -> int
+ type t103 = int -> int -> int
+ type t104 = int -> int -> int
+ type t105 = int -> int -> int
+ type t106 = int -> int -> int
+ type t107 = int -> int -> int
+ type t108 = int -> int -> int
+ type t109 = int -> int -> int
+ type t110 = int -> int -> int
+ type t111 = int -> int -> int
+ type t112 = int -> int -> int
+ type t113 = int -> int -> int
+ type t114 = int -> int -> int
+ type t115 = int -> int -> int
+ type t116 = int -> int -> int
+ type t117 = int -> int -> int
+ type t118 = int -> int -> int
+ type t119 = int -> int -> int
+ type t120 = int -> int -> int
+ type t121 = int -> int -> int
+ type t122 = int -> int -> int
+ type t123 = int -> int -> int
+ type t124 = int -> int -> int
+ type t125 = int -> int -> int
+ type t126 = int -> int -> int
+ type t127 = int -> int -> int
+ type t128 = int -> int -> int
+ type t129 = int -> int -> int
+ type t130 = int -> int -> int
+ type t131 = int -> int -> int
+ type t132 = int -> int -> int
+ type t133 = int -> int -> int
+ type t134 = int -> int -> int
+ type t135 = int -> int -> int
+ type t136 = int -> int -> int
+ type t137 = int -> int -> int
+ type t138 = int -> int -> int
+ type t139 = int -> int -> int
+ type t140 = int -> int -> int
+ type t141 = int -> int -> int
+ type t142 = int -> int -> int
+ type t143 = int -> int -> int
+ type t144 = int -> int -> int
+ type t145 = int -> int -> int
+ type t146 = int -> int -> int
+ type t147 = int -> int -> int
+ type t148 = int -> int -> int
+ type t149 = int -> int -> int
+ type t150 = int -> int -> int
+ type t151 = int -> int -> int
+ type t152 = int -> int -> int
+ type t153 = int -> int -> int
+ type t154 = int -> int -> int
+ type t155 = int -> int -> int
+ type t156 = int -> int -> int
+ type t157 = int -> int -> int
+ type t158 = int -> int -> int
+ type t159 = int -> int -> int
+ type t160 = int -> int -> int
+ type t161 = int -> int -> int
+ type t162 = int -> int -> int
+ type t163 = int -> int -> int
+ type t164 = int -> int -> int
+ type t165 = int -> int -> int
+ type t166 = int -> int -> int
+ type t167 = int -> int -> int
+ type t168 = int -> int -> int
+ type t169 = int -> int -> int
+ type t170 = int -> int -> int
+ type t171 = int -> int -> int
+ type t172 = int -> int -> int
+ type t173 = int -> int -> int
+ type t174 = int -> int -> int
+ type t175 = int -> int -> int
+ type t176 = int -> int -> int
+ type t177 = int -> int -> int
+ type t178 = int -> int -> int
+ type t179 = int -> int -> int
+ type t180 = int -> int -> int
+ type t181 = int -> int -> int
+ type t182 = int -> int -> int
+ type t183 = int -> int -> int
+ type t184 = int -> int -> int
+ type t185 = int -> int -> int
+ type t186 = int -> int -> int
+ type t187 = int -> int -> int
+ type t188 = int -> int -> int
+ type t189 = int -> int -> int
+ type t190 = int -> int -> int
+ type t191 = int -> int -> int
+ type t192 = int -> int -> int
+ type t193 = int -> int -> int
+ type t194 = int -> int -> int
+ type t195 = int -> int -> int
+ type t196 = int -> int -> int
+ type t197 = int -> int -> int
+ type t198 = int -> int -> int
+ type t199 = int -> int -> int
+ type t200 = int -> int -> int
+ type t201 = int -> int -> int
+ type t202 = int -> int -> int
+ type t203 = int -> int -> int
+ type t204 = int -> int -> int
+ type t205 = int -> int -> int
+ type t206 = int -> int -> int
+ type t207 = int -> int -> int
+ type t208 = int -> int -> int
+ type t209 = int -> int -> int
+ type t210 = int -> int -> int
+ type t211 = int -> int -> int
+ type t212 = int -> int -> int
+ type t213 = int -> int -> int
+ type t214 = int -> int -> int
+ type t215 = int -> int -> int
+ type t216 = int -> int -> int
+ type t217 = int -> int -> int
+ type t218 = int -> int -> int
+ type t219 = int -> int -> int
+ type t220 = int -> int -> int
+ type t221 = int -> int -> int
+ type t222 = int -> int -> int
+ type t223 = int -> int -> int
+ type t224 = int -> int -> int
+ type t225 = int -> int -> int
+ type t226 = int -> int -> int
+ type t227 = int -> int -> int
+ type t228 = int -> int -> int
+ type t229 = int -> int -> int
+ type t230 = int -> int -> int
+ type t231 = int -> int -> int
+ type t232 = int -> int -> int
+ type t233 = int -> int -> int
+ type t234 = int -> int -> int
+ type t235 = int -> int -> int
+ type t236 = int -> int -> int
+ type t237 = int -> int -> int
+ type t238 = int -> int -> int
+ type t239 = int -> int -> int
+ type t240 = int -> int -> int
+ type t241 = int -> int -> int
+ type t242 = int -> int -> int
+ type t243 = int -> int -> int
+ type t244 = int -> int -> int
+ type t245 = int -> int -> int
+ type t246 = int -> int -> int
+ type t247 = int -> int -> int
+ type t248 = int -> int -> int
+ type t249 = int -> int -> int
+ type t250 = int -> int -> int
+ type t251 = int -> int -> int
+ type t252 = int -> int -> int
+ type t253 = int -> int -> int
+ type t254 = int -> int -> int
+ type t255 = int -> int -> int
+ type t256 = int -> int -> int
+ type t257 = int -> int -> int
+ type t258 = int -> int -> int
+ type t259 = int -> int -> int
+ type t260 = int -> int -> int
+ type t261 = int -> int -> int
+ type t262 = int -> int -> int
+ type t263 = int -> int -> int
+ type t264 = int -> int -> int
+ type t265 = int -> int -> int
+ type t266 = int -> int -> int
+ type t267 = int -> int -> int
+ type t268 = int -> int -> int
+ type t269 = int -> int -> int
+ type t270 = int -> int -> int
+ type t271 = int -> int -> int
+ type t272 = int -> int -> int
+ type t273 = int -> int -> int
+ type t274 = int -> int -> int
+ type t275 = int -> int -> int
+ type t276 = int -> int -> int
+ type t277 = int -> int -> int
+ type t278 = int -> int -> int
+ type t279 = int -> int -> int
+ type t280 = int -> int -> int
+ type t281 = int -> int -> int
+ type t282 = int -> int -> int
+ type t283 = int -> int -> int
+ type t284 = int -> int -> int
+ type t285 = int -> int -> int
+ type t286 = int -> int -> int
+ type t287 = int -> int -> int
+ type t288 = int -> int -> int
+ type t289 = int -> int -> int
+ type t290 = int -> int -> int
+ type t291 = int -> int -> int
+ type t292 = int -> int -> int
+ type t293 = int -> int -> int
+ type t294 = int -> int -> int
+ type t295 = int -> int -> int
+ type t296 = int -> int -> int
+ type t297 = int -> int -> int
+ type t298 = int -> int -> int
+ type t299 = int -> int -> int
+ type t300 = int -> int -> int
+ type t301 = int -> int -> int
+ type t302 = int -> int -> int
+ type t303 = int -> int -> int
+ type t304 = int -> int -> int
+ type t305 = int -> int -> int
+ type t306 = int -> int -> int
+ type t307 = int -> int -> int
+ type t308 = int -> int -> int
+ type t309 = int -> int -> int
+ type t310 = int -> int -> int
+ type t311 = int -> int -> int
+ type t312 = int -> int -> int
+ type t313 = int -> int -> int
+ type t314 = int -> int -> int
+ type t315 = int -> int -> int
+ type t316 = int -> int -> int
+ type t317 = int -> int -> int
+ type t318 = int -> int -> int
+ type t319 = int -> int -> int
+ type t320 = int -> int -> int
+ type t321 = int -> int -> int
+ type t322 = int -> int -> int
+ type t323 = int -> int -> int
+ type t324 = int -> int -> int
+ type t325 = int -> int -> int
+ type t326 = int -> int -> int
+ type t327 = int -> int -> int
+ type t328 = int -> int -> int
+ type t329 = int -> int -> int
+ type t330 = int -> int -> int
+ type t331 = int -> int -> int
+ type t332 = int -> int -> int
+ type t333 = int -> int -> int
+ type t334 = int -> int -> int
+ type t335 = int -> int -> int
+ type t336 = int -> int -> int
+ type t337 = int -> int -> int
+ type t338 = int -> int -> int
+ type t339 = int -> int -> int
+ type t340 = int -> int -> int
+ type t341 = int -> int -> int
+ type t342 = int -> int -> int
+ type t343 = int -> int -> int
+ type t344 = int -> int -> int
+ type t345 = int -> int -> int
+ type t346 = int -> int -> int
+ type t347 = int -> int -> int
+ type t348 = int -> int -> int
+ type t349 = int -> int -> int
+ type t350 = int -> int -> int
+ type t351 = int -> int -> int
+ type t352 = int -> int -> int
+ type t353 = int -> int -> int
+ type t354 = int -> int -> int
+ type t355 = int -> int -> int
+ type t356 = int -> int -> int
+ type t357 = int -> int -> int
+ type t358 = int -> int -> int
+ type t359 = int -> int -> int
+ type t360 = int -> int -> int
+ type t361 = int -> int -> int
+ type t362 = int -> int -> int
+ type t363 = int -> int -> int
+ type t364 = int -> int -> int
+ type t365 = int -> int -> int
+ type t366 = int -> int -> int
+ type t367 = int -> int -> int
+ type t368 = int -> int -> int
+ type t369 = int -> int -> int
+ type t370 = int -> int -> int
+ type t371 = int -> int -> int
+ type t372 = int -> int -> int
+ type t373 = int -> int -> int
+ type t374 = int -> int -> int
+ type t375 = int -> int -> int
+ type t376 = int -> int -> int
+ type t377 = int -> int -> int
+ type t378 = int -> int -> int
+ type t379 = int -> int -> int
+ type t380 = int -> int -> int
+ type t381 = int -> int -> int
+ type t382 = int -> int -> int
+ type t383 = int -> int -> int
+ type t384 = int -> int -> int
+ type t385 = int -> int -> int
+ type t386 = int -> int -> int
+ type t387 = int -> int -> int
+ type t388 = int -> int -> int
+ type t389 = int -> int -> int
+ type t390 = int -> int -> int
+ type t391 = int -> int -> int
+ type t392 = int -> int -> int
+ type t393 = int -> int -> int
+ type t394 = int -> int -> int
+ type t395 = int -> int -> int
+ type t396 = int -> int -> int
+ type t397 = int -> int -> int
+ type t398 = int -> int -> int
+ type t399 = int -> int -> int
+ type t400 = int -> int -> int
+ type t401 = int -> int -> int
+ type t402 = int -> int -> int
+ type t403 = int -> int -> int
+ type t404 = int -> int -> int
+ type t405 = int -> int -> int
+ type t406 = int -> int -> int
+ type t407 = int -> int -> int
+ type t408 = int -> int -> int
+ type t409 = int -> int -> int
+ type t410 = int -> int -> int
+ type t411 = int -> int -> int
+ type t412 = int -> int -> int
+ type t413 = int -> int -> int
+ type t414 = int -> int -> int
+ type t415 = int -> int -> int
+ type t416 = int -> int -> int
+ type t417 = int -> int -> int
+ type t418 = int -> int -> int
+ type t419 = int -> int -> int
+ type t420 = int -> int -> int
+ type t421 = int -> int -> int
+ type t422 = int -> int -> int
+ type t423 = int -> int -> int
+ type t424 = int -> int -> int
+ type t425 = int -> int -> int
+ type t426 = int -> int -> int
+ type t427 = int -> int -> int
+ type t428 = int -> int -> int
+ type t429 = int -> int -> int
+ type t430 = int -> int -> int
+ type t431 = int -> int -> int
+ type t432 = int -> int -> int
+ type t433 = int -> int -> int
+ type t434 = int -> int -> int
+ type t435 = int -> int -> int
+ type t436 = int -> int -> int
+ type t437 = int -> int -> int
+ type t438 = int -> int -> int
+ type t439 = int -> int -> int
+ type t440 = int -> int -> int
+ type t441 = int -> int -> int
+ type t442 = int -> int -> int
+ type t443 = int -> int -> int
+ type t444 = int -> int -> int
+ type t445 = int -> int -> int
+ type t446 = int -> int -> int
+ type t447 = int -> int -> int
+ type t448 = int -> int -> int
+ type t449 = int -> int -> int
+ type t450 = int -> int -> int
+ type t451 = int -> int -> int
+ type t452 = int -> int -> int
+ type t453 = int -> int -> int
+ type t454 = int -> int -> int
+ type t455 = int -> int -> int
+ type t456 = int -> int -> int
+ type t457 = int -> int -> int
+ type t458 = int -> int -> int
+ type t459 = int -> int -> int
+ type t460 = int -> int -> int
+ type t461 = int -> int -> int
+ type t462 = int -> int -> int
+ type t463 = int -> int -> int
+ type t464 = int -> int -> int
+ type t465 = int -> int -> int
+ type t466 = int -> int -> int
+ type t467 = int -> int -> int
+ type t468 = int -> int -> int
+ type t469 = int -> int -> int
+ type t470 = int -> int -> int
+ type t471 = int -> int -> int
+ type t472 = int -> int -> int
+ type t473 = int -> int -> int
+ type t474 = int -> int -> int
+ type t475 = int -> int -> int
+ type t476 = int -> int -> int
+ type t477 = int -> int -> int
+ type t478 = int -> int -> int
+ type t479 = int -> int -> int
+ type t480 = int -> int -> int
+ type t481 = int -> int -> int
+ type t482 = int -> int -> int
+ type t483 = int -> int -> int
+ type t484 = int -> int -> int
+ type t485 = int -> int -> int
+ type t486 = int -> int -> int
+ type t487 = int -> int -> int
+ type t488 = int -> int -> int
+ type t489 = int -> int -> int
+ type t490 = int -> int -> int
+ type t491 = int -> int -> int
+ type t492 = int -> int -> int
+ type t493 = int -> int -> int
+ type t494 = int -> int -> int
+ type t495 = int -> int -> int
+ type t496 = int -> int -> int
+ type t497 = int -> int -> int
+ type t498 = int -> int -> int
+ type t499 = int -> int -> int
+ type t500 = int -> int -> int
+ type t501 = int -> int -> int
+ type t502 = int -> int -> int
+ type t503 = int -> int -> int
+ type t504 = int -> int -> int
+ type t505 = int -> int -> int
+ type t506 = int -> int -> int
+ type t507 = int -> int -> int
+ type t508 = int -> int -> int
+ type t509 = int -> int -> int
+ type t510 = int -> int -> int
+ type t511 = int -> int -> int
+ type t512 = int -> int -> int
+ type t513 = int -> int -> int
+ type t514 = int -> int -> int
+ type t515 = int -> int -> int
+ type t516 = int -> int -> int
+ type t517 = int -> int -> int
+ type t518 = int -> int -> int
+ type t519 = int -> int -> int
+ type t520 = int -> int -> int
+ type t521 = int -> int -> int
+ type t522 = int -> int -> int
+ type t523 = int -> int -> int
+ type t524 = int -> int -> int
+ type t525 = int -> int -> int
+ type t526 = int -> int -> int
+ type t527 = int -> int -> int
+ type t528 = int -> int -> int
+ type t529 = int -> int -> int
+ type t530 = int -> int -> int
+ type t531 = int -> int -> int
+ type t532 = int -> int -> int
+ type t533 = int -> int -> int
+ type t534 = int -> int -> int
+ type t535 = int -> int -> int
+ type t536 = int -> int -> int
+ type t537 = int -> int -> int
+ type t538 = int -> int -> int
+ type t539 = int -> int -> int
+ type t540 = int -> int -> int
+ type t541 = int -> int -> int
+ type t542 = int -> int -> int
+ type t543 = int -> int -> int
+ type t544 = int -> int -> int
+ type t545 = int -> int -> int
+ type t546 = int -> int -> int
+ type t547 = int -> int -> int
+ type t548 = int -> int -> int
+ type t549 = int -> int -> int
+ type t550 = int -> int -> int
+ type t551 = int -> int -> int
+ type t552 = int -> int -> int
+ type t553 = int -> int -> int
+ type t554 = int -> int -> int
+ type t555 = int -> int -> int
+ type t556 = int -> int -> int
+ type t557 = int -> int -> int
+ type t558 = int -> int -> int
+ type t559 = int -> int -> int
+ type t560 = int -> int -> int
+ type t561 = int -> int -> int
+ type t562 = int -> int -> int
+ type t563 = int -> int -> int
+ type t564 = int -> int -> int
+ type t565 = int -> int -> int
+ type t566 = int -> int -> int
+ type t567 = int -> int -> int
+ type t568 = int -> int -> int
+ type t569 = int -> int -> int
+ type t570 = int -> int -> int
+ type t571 = int -> int -> int
+ type t572 = int -> int -> int
+ type t573 = int -> int -> int
+ type t574 = int -> int -> int
+ type t575 = int -> int -> int
+ type t576 = int -> int -> int
+ type t577 = int -> int -> int
+ type t578 = int -> int -> int
+ type t579 = int -> int -> int
+ type t580 = int -> int -> int
+ type t581 = int -> int -> int
+ type t582 = int -> int -> int
+ type t583 = int -> int -> int
+ type t584 = int -> int -> int
+ type t585 = int -> int -> int
+ type t586 = int -> int -> int
+ type t587 = int -> int -> int
+ type t588 = int -> int -> int
+ type t589 = int -> int -> int
+ type t590 = int -> int -> int
+ type t591 = int -> int -> int
+ type t592 = int -> int -> int
+ type t593 = int -> int -> int
+ type t594 = int -> int -> int
+ type t595 = int -> int -> int
+ type t596 = int -> int -> int
+ type t597 = int -> int -> int
+ type t598 = int -> int -> int
+ type t599 = int -> int -> int
+ type t600 = int -> int -> int
+ type t601 = int -> int -> int
+ type t602 = int -> int -> int
+ type t603 = int -> int -> int
+ type t604 = int -> int -> int
+ type t605 = int -> int -> int
+ type t606 = int -> int -> int
+ type t607 = int -> int -> int
+ type t608 = int -> int -> int
+ type t609 = int -> int -> int
+ type t610 = int -> int -> int
+ type t611 = int -> int -> int
+ type t612 = int -> int -> int
+ type t613 = int -> int -> int
+ type t614 = int -> int -> int
+ type t615 = int -> int -> int
+ type t616 = int -> int -> int
+ type t617 = int -> int -> int
+ type t618 = int -> int -> int
+ type t619 = int -> int -> int
+ type t620 = int -> int -> int
+ type t621 = int -> int -> int
+ type t622 = int -> int -> int
+ type t623 = int -> int -> int
+ type t624 = int -> int -> int
+ type t625 = int -> int -> int
+ type t626 = int -> int -> int
+ type t627 = int -> int -> int
+ type t628 = int -> int -> int
+ type t629 = int -> int -> int
+ type t630 = int -> int -> int
+ type t631 = int -> int -> int
+ type t632 = int -> int -> int
+ type t633 = int -> int -> int
+ type t634 = int -> int -> int
+ type t635 = int -> int -> int
+ type t636 = int -> int -> int
+ type t637 = int -> int -> int
+ type t638 = int -> int -> int
+ type t639 = int -> int -> int
+ type t640 = int -> int -> int
+ type t641 = int -> int -> int
+ type t642 = int -> int -> int
+ type t643 = int -> int -> int
+ type t644 = int -> int -> int
+ type t645 = int -> int -> int
+ type t646 = int -> int -> int
+ type t647 = int -> int -> int
+ type t648 = int -> int -> int
+ type t649 = int -> int -> int
+ type t650 = int -> int -> int
+ type t651 = int -> int -> int
+ type t652 = int -> int -> int
+ type t653 = int -> int -> int
+ type t654 = int -> int -> int
+ type t655 = int -> int -> int
+ type t656 = int -> int -> int
+ type t657 = int -> int -> int
+ type t658 = int -> int -> int
+ type t659 = int -> int -> int
+ type t660 = int -> int -> int
+ type t661 = int -> int -> int
+ type t662 = int -> int -> int
+ type t663 = int -> int -> int
+ type t664 = int -> int -> int
+ type t665 = int -> int -> int
+ type t666 = int -> int -> int
+ type t667 = int -> int -> int
+ type t668 = int -> int -> int
+ type t669 = int -> int -> int
+ type t670 = int -> int -> int
+ type t671 = int -> int -> int
+ type t672 = int -> int -> int
+ type t673 = int -> int -> int
+ type t674 = int -> int -> int
+ type t675 = int -> int -> int
+ type t676 = int -> int -> int
+ type t677 = int -> int -> int
+ type t678 = int -> int -> int
+ type t679 = int -> int -> int
+ type t680 = int -> int -> int
+ type t681 = int -> int -> int
+ type t682 = int -> int -> int
+ type t683 = int -> int -> int
+ type t684 = int -> int -> int
+ type t685 = int -> int -> int
+ type t686 = int -> int -> int
+ type t687 = int -> int -> int
+ type t688 = int -> int -> int
+ type t689 = int -> int -> int
+ type t690 = int -> int -> int
+ type t691 = int -> int -> int
+ type t692 = int -> int -> int
+ type t693 = int -> int -> int
+ type t694 = int -> int -> int
+ type t695 = int -> int -> int
+ type t696 = int -> int -> int
+ type t697 = int -> int -> int
+ type t698 = int -> int -> int
+ type t699 = int -> int -> int
+ type t700 = int -> int -> int
+ type t701 = int -> int -> int
+ type t702 = int -> int -> int
+ type t703 = int -> int -> int
+ type t704 = int -> int -> int
+ type t705 = int -> int -> int
+ type t706 = int -> int -> int
+ type t707 = int -> int -> int
+ type t708 = int -> int -> int
+ type t709 = int -> int -> int
+ type t710 = int -> int -> int
+ type t711 = int -> int -> int
+ type t712 = int -> int -> int
+ type t713 = int -> int -> int
+ type t714 = int -> int -> int
+ type t715 = int -> int -> int
+ type t716 = int -> int -> int
+ type t717 = int -> int -> int
+ type t718 = int -> int -> int
+ type t719 = int -> int -> int
+ type t720 = int -> int -> int
+ type t721 = int -> int -> int
+ type t722 = int -> int -> int
+ type t723 = int -> int -> int
+ type t724 = int -> int -> int
+ type t725 = int -> int -> int
+ type t726 = int -> int -> int
+ type t727 = int -> int -> int
+ type t728 = int -> int -> int
+ type t729 = int -> int -> int
+ type t730 = int -> int -> int
+ type t731 = int -> int -> int
+ type t732 = int -> int -> int
+ type t733 = int -> int -> int
+ type t734 = int -> int -> int
+ type t735 = int -> int -> int
+ type t736 = int -> int -> int
+ type t737 = int -> int -> int
+ type t738 = int -> int -> int
+ type t739 = int -> int -> int
+ type t740 = int -> int -> int
+ type t741 = int -> int -> int
+ type t742 = int -> int -> int
+ type t743 = int -> int -> int
+ type t744 = int -> int -> int
+ type t745 = int -> int -> int
+ type t746 = int -> int -> int
+ type t747 = int -> int -> int
+ type t748 = int -> int -> int
+ type t749 = int -> int -> int
+ type t750 = int -> int -> int
+ type t751 = int -> int -> int
+ type t752 = int -> int -> int
+ type t753 = int -> int -> int
+ type t754 = int -> int -> int
+ type t755 = int -> int -> int
+ type t756 = int -> int -> int
+ type t757 = int -> int -> int
+ type t758 = int -> int -> int
+ type t759 = int -> int -> int
+ type t760 = int -> int -> int
+ type t761 = int -> int -> int
+ type t762 = int -> int -> int
+ type t763 = int -> int -> int
+ type t764 = int -> int -> int
+ type t765 = int -> int -> int
+ type t766 = int -> int -> int
+ type t767 = int -> int -> int
+ type t768 = int -> int -> int
+ type t769 = int -> int -> int
+ type t770 = int -> int -> int
+ type t771 = int -> int -> int
+ type t772 = int -> int -> int
+ type t773 = int -> int -> int
+ type t774 = int -> int -> int
+ type t775 = int -> int -> int
+ type t776 = int -> int -> int
+ type t777 = int -> int -> int
+ type t778 = int -> int -> int
+ type t779 = int -> int -> int
+ type t780 = int -> int -> int
+ type t781 = int -> int -> int
+ type t782 = int -> int -> int
+ type t783 = int -> int -> int
+ type t784 = int -> int -> int
+ type t785 = int -> int -> int
+ type t786 = int -> int -> int
+ type t787 = int -> int -> int
+ type t788 = int -> int -> int
+ type t789 = int -> int -> int
+ type t790 = int -> int -> int
+ type t791 = int -> int -> int
+ type t792 = int -> int -> int
+ type t793 = int -> int -> int
+ type t794 = int -> int -> int
+ type t795 = int -> int -> int
+ type t796 = int -> int -> int
+ type t797 = int -> int -> int
+ type t798 = int -> int -> int
+ type t799 = int -> int -> int
+ type t800 = int -> int -> int
+ type t801 = int -> int -> int
+ type t802 = int -> int -> int
+ type t803 = int -> int -> int
+ type t804 = int -> int -> int
+ type t805 = int -> int -> int
+ type t806 = int -> int -> int
+ type t807 = int -> int -> int
+ type t808 = int -> int -> int
+ type t809 = int -> int -> int
+ type t810 = int -> int -> int
+ type t811 = int -> int -> int
+ type t812 = int -> int -> int
+ type t813 = int -> int -> int
+ type t814 = int -> int -> int
+ type t815 = int -> int -> int
+ type t816 = int -> int -> int
+ type t817 = int -> int -> int
+ type t818 = int -> int -> int
+ type t819 = int -> int -> int
+ type t820 = int -> int -> int
+ type t821 = int -> int -> int
+ type t822 = int -> int -> int
+ type t823 = int -> int -> int
+ type t824 = int -> int -> int
+ type t825 = int -> int -> int
+ type t826 = int -> int -> int
+ type t827 = int -> int -> int
+ type t828 = int -> int -> int
+ type t829 = int -> int -> int
+ type t830 = int -> int -> int
+ type t831 = int -> int -> int
+ type t832 = int -> int -> int
+ type t833 = int -> int -> int
+ type t834 = int -> int -> int
+ type t835 = int -> int -> int
+ type t836 = int -> int -> int
+ type t837 = int -> int -> int
+ type t838 = int -> int -> int
+ type t839 = int -> int -> int
+ type t840 = int -> int -> int
+ type t841 = int -> int -> int
+ type t842 = int -> int -> int
+ type t843 = int -> int -> int
+ type t844 = int -> int -> int
+ type t845 = int -> int -> int
+ type t846 = int -> int -> int
+ type t847 = int -> int -> int
+ type t848 = int -> int -> int
+ type t849 = int -> int -> int
+ type t850 = int -> int -> int
+ type t851 = int -> int -> int
+ type t852 = int -> int -> int
+ type t853 = int -> int -> int
+ type t854 = int -> int -> int
+ type t855 = int -> int -> int
+ type t856 = int -> int -> int
+ type t857 = int -> int -> int
+ type t858 = int -> int -> int
+ type t859 = int -> int -> int
+ type t860 = int -> int -> int
+ type t861 = int -> int -> int
+ type t862 = int -> int -> int
+ type t863 = int -> int -> int
+ type t864 = int -> int -> int
+ type t865 = int -> int -> int
+ type t866 = int -> int -> int
+ type t867 = int -> int -> int
+ type t868 = int -> int -> int
+ type t869 = int -> int -> int
+ type t870 = int -> int -> int
+ type t871 = int -> int -> int
+ type t872 = int -> int -> int
+ type t873 = int -> int -> int
+ type t874 = int -> int -> int
+ type t875 = int -> int -> int
+ type t876 = int -> int -> int
+ type t877 = int -> int -> int
+ type t878 = int -> int -> int
+ type t879 = int -> int -> int
+ type t880 = int -> int -> int
+ type t881 = int -> int -> int
+ type t882 = int -> int -> int
+ type t883 = int -> int -> int
+ type t884 = int -> int -> int
+ type t885 = int -> int -> int
+ type t886 = int -> int -> int
+ type t887 = int -> int -> int
+ type t888 = int -> int -> int
+ type t889 = int -> int -> int
+ type t890 = int -> int -> int
+ type t891 = int -> int -> int
+ type t892 = int -> int -> int
+ type t893 = int -> int -> int
+ type t894 = int -> int -> int
+ type t895 = int -> int -> int
+ type t896 = int -> int -> int
+ type t897 = int -> int -> int
+ type t898 = int -> int -> int
+ type t899 = int -> int -> int
+ type t900 = int -> int -> int
+ type t901 = int -> int -> int
+ type t902 = int -> int -> int
+ type t903 = int -> int -> int
+ type t904 = int -> int -> int
+ type t905 = int -> int -> int
+ type t906 = int -> int -> int
+ type t907 = int -> int -> int
+ type t908 = int -> int -> int
+ type t909 = int -> int -> int
+ type t910 = int -> int -> int
+ type t911 = int -> int -> int
+ type t912 = int -> int -> int
+ type t913 = int -> int -> int
+ type t914 = int -> int -> int
+ type t915 = int -> int -> int
+ type t916 = int -> int -> int
+ type t917 = int -> int -> int
+ type t918 = int -> int -> int
+ type t919 = int -> int -> int
+ type t920 = int -> int -> int
+ type t921 = int -> int -> int
+ type t922 = int -> int -> int
+ type t923 = int -> int -> int
+ type t924 = int -> int -> int
+ type t925 = int -> int -> int
+ type t926 = int -> int -> int
+ type t927 = int -> int -> int
+ type t928 = int -> int -> int
+ type t929 = int -> int -> int
+ type t930 = int -> int -> int
+ type t931 = int -> int -> int
+ type t932 = int -> int -> int
+ type t933 = int -> int -> int
+ type t934 = int -> int -> int
+ type t935 = int -> int -> int
+ type t936 = int -> int -> int
+ type t937 = int -> int -> int
+ type t938 = int -> int -> int
+ type t939 = int -> int -> int
+ type t940 = int -> int -> int
+ type t941 = int -> int -> int
+ type t942 = int -> int -> int
+ type t943 = int -> int -> int
+ type t944 = int -> int -> int
+ type t945 = int -> int -> int
+ type t946 = int -> int -> int
+ type t947 = int -> int -> int
+ type t948 = int -> int -> int
+ type t949 = int -> int -> int
+ type t950 = int -> int -> int
+ type t951 = int -> int -> int
+ type t952 = int -> int -> int
+ type t953 = int -> int -> int
+ type t954 = int -> int -> int
+ type t955 = int -> int -> int
+ type t956 = int -> int -> int
+ type t957 = int -> int -> int
+ type t958 = int -> int -> int
+ type t959 = int -> int -> int
+ type t960 = int -> int -> int
+ type t961 = int -> int -> int
+ type t962 = int -> int -> int
+ type t963 = int -> int -> int
+ type t964 = int -> int -> int
+ type t965 = int -> int -> int
+ type t966 = int -> int -> int
+ type t967 = int -> int -> int
+ type t968 = int -> int -> int
+ type t969 = int -> int -> int
+ type t970 = int -> int -> int
+ type t971 = int -> int -> int
+ type t972 = int -> int -> int
+ type t973 = int -> int -> int
+ type t974 = int -> int -> int
+ type t975 = int -> int -> int
+ type t976 = int -> int -> int
+ type t977 = int -> int -> int
+ type t978 = int -> int -> int
+ type t979 = int -> int -> int
+ type t980 = int -> int -> int
+ type t981 = int -> int -> int
+ type t982 = int -> int -> int
+ type t983 = int -> int -> int
+ type t984 = int -> int -> int
+ type t985 = int -> int -> int
+ type t986 = int -> int -> int
+ type t987 = int -> int -> int
+ type t988 = int -> int -> int
+ type t989 = int -> int -> int
+ type t990 = int -> int -> int
+ type t991 = int -> int -> int
+ type t992 = int -> int -> int
+ type t993 = int -> int -> int
+ type t994 = int -> int -> int
+ type t995 = int -> int -> int
+ type t996 = int -> int -> int
+ type t997 = int -> int -> int
+ type t998 = int -> int -> int
+ type t999 = int -> int -> int
+ type t1000 = int -> int -> int
+end
+
+module X =
+ Make
+ (Make
+ (Make
+ (Make
+ (Make
+ (Make
+ (Make
+ (Make
+ (Make
+ (Make
+ (Make
+ (M)))))))))))
--- /dev/null
+<% types, with_constrs, module_application = ARGV.map { |x| x.to_i } %>
+
+module type S = sig
+<%- for i in 0 .. types do -%>
+ type t<%= i %>
+<%- end -%>
+end
+
+module Make (M : S)
+: S with type t0 = M.t0
+ <%- for i in 1 .. with_constrs do -%>
+ and type t<%= i %> = M.t<%= i %>
+ <%- end -%>
+= struct
+ include M
+end
+
+module M = struct
+<%- for i in 0 .. types do -%>
+ type t<%= i %> = int -> int -> int
+<%- end -%>
+end
+
+module X =
+ Make
+<%- module_application.times do -%>
+ (Make
+<%- end -%>
+ (M)<%= ')' * module_application %>
--- /dev/null
+<% types, with_constrs, make, make2 = ARGV.map { |x| x.to_i } %>
+
+module type S = sig
+<%- for i in 0 .. types do -%>
+ type t<%= i %>
+<%- end -%>
+end
+
+module Make (M : S)
+: S with type t0 = M.t0
+ <%- for i in 1 .. with_constrs do -%>
+ and type t<%= i %> = M.t<%= i %>
+ <%- end -%>
+= struct
+ include M
+end
+
+module type S2 = sig
+ module M : S
+end
+
+module Make2 (M2 : S2)
+: S2 with module M = M2.M
+= struct
+ include M2
+end
+
+module M = struct
+<%- for i in 0 .. types do -%>
+ type t<%= i %> = int -> int -> int
+<%- end -%>
+end
+
+module M1 =
+ Make
+<%- make.times do -%>
+ (Make
+<%- end -%>
+ (M)<%= ')' * make %>
+
+module M2 = struct
+ module M = M1
+end
+
+module X =
+ Make2
+<%- make2.times do -%>
+ (Make2
+<%- end -%>
+ (M2)<%= ')' * make2 %>
--- /dev/null
+type t =
+ A of int * t * t
+| B of int list
+| C of option t
+
+module Map = struct
+ module T = Camlp4Filters.GenerateMap.Generated
+end
--- /dev/null
+open Camlp4.PreCast;
+module G = MakeGram Lexer;
+type t = [ A of t and t | B of string | C ];
+value main = G.Entry.mk "main";
+value rec length x acc =
+ match x with
+ [ A x y -> length x (length y acc)
+ | B _ -> succ acc
+ | C -> acc ];
+EXTEND G
+ GLOBAL: main;
+ main:
+ [ [
+ l = FOLD1 (fun a b -> A (B a) b) (C) ident -> l
+ ] ];
+ ident:
+ [ [ `LIDENT s -> s ] ];
+END;
+let f = Sys.argv.(1) in
+Format.printf "%d@."
+ (length (G.parse main (Loc.mk f) (Stream.of_channel (open_in f))) 0);
--- /dev/null
+open Camlp4.PreCast;
+module G = MakeGram Lexer;
+value main = G.Entry.mk "main";
+EXTEND G
+ GLOBAL: main;
+ main:
+ [ [ l = LIST1 ident -> l ] ];
+ ident:
+ [ [ `LIDENT s -> s ] ];
+END;
+let f = Sys.argv.(1) in
+Format.printf "%d@."
+ (List.length (G.parse main (Loc.mk f) (Stream.of_channel (open_in f))));
--- /dev/null
+open Camlp4.PreCast;
+module G = MakeGram Lexer;
+(* type t = [ A of Loc.t and t and t | B of Loc.t and string ]; *)
+value main = G.Entry.mk "main";
+(* value rec length x acc =
+ match x with
+ [ A x y -> length x (length y acc)
+ | B _ -> succ acc ];
+value length _ _ = -1; *)
+EXTEND G
+ GLOBAL: main;
+ main:
+ [ RIGHTA
+ [ x = SELF; y = SELF ->
+ let l = Loc.merge x y in
+ if l = _loc then _loc
+ else do {
+ Format.eprintf "bad loc: %a <> %a + %a@."
+ Loc.dump _loc Loc.dump x Loc.dump y;
+ _loc
+ }
+ | i = ident -> i ] ];
+ ident:
+ [ [ `LIDENT _ -> _loc ] ];
+END;
+try
+ let f = Sys.argv.(1) in
+ Format.printf "%a@."
+ Loc.dump (G.parse main (Loc.mk f) (Stream.of_channel (open_in f)))
+with e -> Format.eprintf "error: %a@." Camlp4.ErrorHandler.print e;
--- /dev/null
+open Camlp4.PreCast.Syntax;
+
+value mo _loc =
+ fun
+ [ None -> <:expr< None >>
+ | Some e -> <:expr< Some $e$ >> ];
+
+EXTEND Gram
+GLOBAL: expr;
+expr:
+ [ [ "testbegin";
+ lb = [ "("; l = LIST0 a_LIDENT SEP ","; ")" -> l | "()" -> [] ];
+ b = bar;
+ "testend" ->
+ let e =
+ List.fold_right (fun i acc -> <:expr< [ $lid:i$ :: $acc$ ] >>) lb <:expr< [] >>
+ in <:expr< ($e$, $b$) >>
+ ] ];
+bar:
+ [ [ x = OPT [ o = OPT [ x = "testb" ->
+ <:expr< $str:Token.extract_string x$ >> ]; "testc"; b = baz ->
+ <:expr< ($mo _loc o$, $b$) >> ] -> mo _loc x
+ ] ];
+(* bar:
+ [ [ o = OPT [ o = OPT [ "bar" -> <:expr< bar >> ]; b = baz -> <:expr< ($mo _loc o$, $b$) >> ] ->
+ mo _loc o
+ ] ]; *)
+(* bar:
+ [ [ o = OPT [ "bar" -> <:expr< bar >> ]; b = baz -> <:expr< ($mo _loc o$, $b$) >>
+ ] ]; *)
+baz:
+ [ [ "baz" -> <:expr< baz >> ] ];
+END;
--- /dev/null
+open Camlp4.PreCast;
+module G = MakeGram Lexer;
+type t = [ A of t and t | B of string ];
+value main = G.Entry.mk "main";
+(* value rec length x acc =
+ match x with
+ [ A x y -> length x (length y acc)
+ | B _ -> succ acc ]; *)
+value length _ _ = -1;
+EXTEND G
+ GLOBAL: main;
+ main:
+ [ [ x = SELF; y = SELF -> A x y
+ | i = ident -> B i ] ];
+ ident:
+ [ [ `LIDENT s -> s ] ];
+END;
+try
+ let f = Sys.argv.(1) in
+ Format.printf "%d@."
+ (length (G.parse main (Loc.mk f) (Stream.of_channel (open_in f))) 0)
+with e -> Format.eprintf "error: %a@." Camlp4.ErrorHandler.print e;
--- /dev/null
+open Camlp4.PreCast;
+module G = MakeGram Lexer;
+type t = [ A of t and t | B of string ];
+value main = G.Entry.mk "main";
+(* value rec length x acc =
+ match x with
+ [ A x y -> length x (length y acc)
+ | B _ -> succ acc ]; *)
+value length _ _ = -1;
+EXTEND G
+ GLOBAL: main;
+ main:
+ [ [ i = ident; x = SELF -> A (B i) x
+ | i = ident -> B i ] ];
+ ident:
+ [ [ `LIDENT s -> s ] ];
+END;
+try
+ let f = Sys.argv.(1) in
+ Format.printf "%d@."
+ (length (G.parse main (Loc.mk f) (Stream.of_channel (open_in f))) 0)
+with e -> Format.eprintf "error: %a@." Camlp4.ErrorHandler.print e;
--- /dev/null
+open Camlp4.PreCast;
+module G = MakeGram Lexer;
+type t = [ A of t and t | B of string ];
+value main = G.Entry.mk "main";
+(* value rec length x acc =
+ match x with
+ [ A x y -> length x (length y acc)
+ | B _ -> succ acc ]; *)
+value length _ _ = -1;
+EXTEND G
+ GLOBAL: main;
+ main:
+ [ RIGHTA
+ [ x = SELF; y = SELF -> A x y
+ | i = ident -> B i ] ];
+ ident:
+ [ [ `LIDENT s -> s ] ];
+END;
+try
+ let f = Sys.argv.(1) in
+ Format.printf "%d@."
+ (length (G.parse main (Loc.mk f) (Stream.of_channel (open_in f))) 0)
+with e -> Format.eprintf "error: %a@." Camlp4.ErrorHandler.print e;
--- /dev/null
+EXTEND G expr: [[ l = LIST0 STRING -> l ]]; END;
+EXTEND G expr: [[ l = LIST0 [ x = STRING -> x ] -> l ]]; END;
--- /dev/null
+aaa aab aac aad aae aaf aag aah aai aaj aak aal aam aan aao aap aaq aar aas
+aat aau aav aaw aax aay aaz aba abb abc abd abe abf abg abh abi abj abk abl
+abm abn abo abp abq abr abs abt abu abv abw abx aby abz aca acb acc acd ace
+acf acg ach aci acj ack acl acm acn aco acp acq acr acs act acu acv acw acx
+acy acz ada adb adc add ade adf adg adh adi adj adk adl adm adn ado adp adq
+adr ads adt adu adv adw adx ady adz aea aeb aec aed aee aef aeg aeh aei aej
+aek ael aem aen aeo aep aeq aer aes aet aeu aev aew aex aey aez afa afb afc
+afd afe aff afg afh afi afj afk afl afm afn afo afp afq afr afs aft afu afv
+afw afx afy afz aga agb agc agd age agf agg agh agi agj agk agl agm agn ago
+agp agq agr ags agt agu agv agw agx agy agz aha ahb ahc ahd ahe ahf ahg ahh
+ahi ahj ahk ahl ahm ahn aho ahp ahq ahr ahs aht ahu ahv ahw ahx ahy ahz aia
+aib aic aid aie aif aig aih aii aij aik ail aim ain aio aip aiq air ais ait
+aiu aiv aiw aix aiy aiz aja ajb ajc ajd aje ajf ajg ajh aji ajj ajk ajl ajm
+ajn ajo ajp ajq ajr ajs ajt aju ajv ajw ajx ajy ajz aka akb akc akd ake akf
+akg akh aki akj akk akl akm akn ako akp akq akr aks akt aku akv akw akx aky
+akz ala alb alc ald ale alf alg alh ali alj alk all alm aln alo alp alq alr
+als alt alu alv alw alx aly alz ama amb amc amd ame amf amg amh ami amj amk
+aml amm amn amo amp amq amr ams amt amu amv amw amx amy amz ana anb anc and
+ane anf ang anh ani anj ank anl anm ann ano anp anq anr ans ant anu anv anw
+anx any anz aoa aob aoc aod aoe aof aog aoh aoi aoj aok aol aom aon aoo aop
+aoq aor aos aot aou aov aow aox aoy aoz apa apb apc apd ape apf apg aph api
+apj apk apl apm apn apo app apq apr aps apt apu apv apw apx apy apz aqa aqb
+aqc aqd aqe aqf aqg aqh aqi aqj aqk aql aqm aqn aqo aqp aqq aqr aqs aqt aqu
+aqv aqw aqx aqy aqz ara arb arc ard are arf arg arh ari arj ark arl arm arn
+aro arp arq arr ars art aru arv arw arx ary arz asa asb asc asd ase asf asg
+ash asi asj ask asl asm asn aso asp asq asr ass ast asu asv asw asx asy asz
+ata atb atc atd ate atf atg ath ati atj atk atl atm atn ato atp atq atr ats
+att atu atv atw atx aty atz aua aub auc aud aue auf aug auh aui auj auk aul
+aum aun auo aup auq aur aus aut auu auv auw aux auy auz ava avb avc avd ave
+avf avg avh avi avj avk avl avm avn avo avp avq avr avs avt avu avv avw avx
+avy avz awa awb awc awd awe awf awg awh awi awj awk awl awm awn awo awp awq
+awr aws awt awu awv aww awx awy awz axa axb axc axd axe axf axg axh axi axj
+axk axl axm axn axo axp axq axr axs axt axu axv axw axx axy axz aya ayb ayc
+ayd aye ayf ayg ayh ayi ayj ayk ayl aym ayn ayo ayp ayq ayr ays ayt ayu ayv
+ayw ayx ayy ayz aza azb azc azd aze azf azg azh azi azj azk azl azm azn azo
+azp azq azr azs azt azu azv azw azx azy azz baa bab bac bad bae baf bag bah
+bai baj bak bal bam ban bao bap baq bar bas bat bau bav baw bax bay baz bba
+bbb
--- /dev/null
+aaaa aaab aaac aaad aaae aaaf aaag aaah aaai aaaj aaak aaal aaam aaan aaao
+aaap aaaq aaar aaas aaat aaau aaav aaaw aaax aaay aaaz aaba aabb aabc aabd
+aabe aabf aabg aabh aabi aabj aabk aabl aabm aabn aabo aabp aabq aabr aabs
+aabt aabu aabv aabw aabx aaby aabz aaca aacb aacc aacd aace aacf aacg aach
+aaci aacj aack aacl aacm aacn aaco aacp aacq aacr aacs aact aacu aacv aacw
+aacx aacy aacz aada aadb aadc aadd aade aadf aadg aadh aadi aadj aadk aadl
+aadm aadn aado aadp aadq aadr aads aadt aadu aadv aadw aadx aady aadz aaea
+aaeb aaec aaed aaee aaef aaeg aaeh aaei aaej aaek aael aaem aaen aaeo aaep
+aaeq aaer aaes aaet aaeu aaev aaew aaex aaey aaez aafa aafb aafc aafd aafe
+aaff aafg aafh aafi aafj aafk aafl aafm aafn aafo aafp aafq aafr aafs aaft
+aafu aafv aafw aafx aafy aafz aaga aagb aagc aagd aage aagf aagg aagh aagi
+aagj aagk aagl aagm aagn aago aagp aagq aagr aags aagt aagu aagv aagw aagx
+aagy aagz aaha aahb aahc aahd aahe aahf aahg aahh aahi aahj aahk aahl aahm
+aahn aaho aahp aahq aahr aahs aaht aahu aahv aahw aahx aahy aahz aaia aaib
+aaic aaid aaie aaif aaig aaih aaii aaij aaik aail aaim aain aaio aaip aaiq
+aair aais aait aaiu aaiv aaiw aaix aaiy aaiz aaja aajb aajc aajd aaje aajf
+aajg aajh aaji aajj aajk aajl aajm aajn aajo aajp aajq aajr aajs aajt aaju
+aajv aajw aajx aajy aajz aaka aakb aakc aakd aake aakf aakg aakh aaki aakj
+aakk aakl aakm aakn aako aakp aakq aakr aaks aakt aaku aakv aakw aakx aaky
+aakz aala aalb aalc aald aale aalf aalg aalh aali aalj aalk aall aalm aaln
+aalo aalp aalq aalr aals aalt aalu aalv aalw aalx aaly aalz aama aamb aamc
+aamd aame aamf aamg aamh aami aamj aamk aaml aamm aamn aamo aamp aamq aamr
+aams aamt aamu aamv aamw aamx aamy aamz aana aanb aanc aand aane aanf aang
+aanh aani aanj aank aanl aanm aann aano aanp aanq aanr aans aant aanu aanv
+aanw aanx aany aanz aaoa aaob aaoc aaod aaoe aaof aaog aaoh aaoi aaoj aaok
+aaol aaom aaon aaoo aaop aaoq aaor aaos aaot aaou aaov aaow aaox aaoy aaoz
+aapa aapb aapc aapd aape aapf aapg aaph aapi aapj aapk aapl aapm aapn aapo
+aapp aapq aapr aaps aapt aapu aapv aapw aapx aapy aapz aaqa aaqb aaqc aaqd
+aaqe aaqf aaqg aaqh aaqi aaqj aaqk aaql aaqm aaqn aaqo aaqp aaqq aaqr aaqs
+aaqt aaqu aaqv aaqw aaqx aaqy aaqz aara aarb aarc aard aare aarf aarg aarh
+aari aarj aark aarl aarm aarn aaro aarp aarq aarr aars aart aaru aarv aarw
+aarx aary aarz aasa aasb aasc aasd aase aasf aasg aash aasi aasj aask aasl
+aasm aasn aaso aasp aasq aasr aass aast aasu aasv aasw aasx aasy aasz aata
+aatb aatc aatd aate aatf aatg aath aati aatj aatk aatl aatm aatn aato aatp
+aatq aatr aats aatt aatu aatv aatw aatx aaty aatz aaua aaub aauc aaud aaue
+aauf aaug aauh aaui aauj aauk aaul aaum aaun aauo aaup aauq aaur aaus aaut
+aauu aauv aauw aaux aauy aauz aava aavb aavc aavd aave aavf aavg aavh aavi
+aavj aavk aavl aavm aavn aavo aavp aavq aavr aavs aavt aavu aavv aavw aavx
+aavy aavz aawa aawb aawc aawd aawe aawf aawg aawh aawi aawj aawk aawl aawm
+aawn aawo aawp aawq aawr aaws aawt aawu aawv aaww aawx aawy aawz aaxa aaxb
+aaxc aaxd aaxe aaxf aaxg aaxh aaxi aaxj aaxk aaxl aaxm aaxn aaxo aaxp aaxq
+aaxr aaxs aaxt aaxu aaxv aaxw aaxx aaxy aaxz aaya aayb aayc aayd aaye aayf
+aayg aayh aayi aayj aayk aayl aaym aayn aayo aayp aayq aayr aays aayt aayu
+aayv aayw aayx aayy aayz aaza aazb aazc aazd aaze aazf aazg aazh aazi aazj
+aazk aazl aazm aazn aazo aazp aazq aazr aazs aazt aazu aazv aazw aazx aazy
+aazz abaa abab abac abad abae abaf abag abah abai abaj abak abal abam aban
+abao abap abaq abar abas abat abau abav abaw abax abay abaz abba abbb abbc
+abbd abbe abbf abbg abbh abbi abbj abbk abbl abbm abbn abbo abbp abbq abbr
+abbs abbt abbu abbv abbw abbx abby abbz abca abcb abcc abcd abce abcf abcg
+abch abci abcj abck abcl abcm abcn abco abcp abcq abcr abcs abct abcu abcv
+abcw abcx abcy abcz abda abdb abdc abdd abde abdf abdg abdh abdi abdj abdk
+abdl abdm abdn abdo abdp abdq abdr abds abdt abdu abdv abdw abdx abdy abdz
+abea abeb abec abed abee abef abeg abeh abei abej abek abel abem aben abeo
+abep abeq aber abes abet abeu abev abew abex abey abez abfa abfb abfc abfd
+abfe abff abfg abfh abfi abfj abfk abfl abfm abfn abfo abfp abfq abfr abfs
+abft abfu abfv abfw abfx abfy abfz abga abgb abgc abgd abge abgf abgg abgh
+abgi abgj abgk abgl abgm abgn abgo abgp abgq abgr abgs abgt abgu abgv abgw
+abgx abgy abgz abha abhb abhc abhd abhe abhf abhg abhh abhi abhj abhk abhl
+abhm abhn abho abhp abhq abhr abhs abht abhu abhv abhw abhx abhy abhz abia
+abib abic abid abie abif abig abih abii abij abik abil abim abin abio abip
+abiq abir abis abit abiu abiv abiw abix abiy abiz abja abjb abjc abjd abje
+abjf abjg abjh abji abjj abjk abjl abjm abjn abjo abjp abjq abjr abjs abjt
+abju abjv abjw abjx abjy abjz abka abkb abkc abkd abke abkf abkg abkh abki
+abkj abkk abkl abkm abkn abko abkp abkq abkr abks abkt abku abkv abkw abkx
+abky abkz abla ablb ablc abld able ablf ablg ablh abli ablj ablk abll ablm
+abln ablo ablp ablq ablr abls ablt ablu ablv ablw ablx ably ablz abma abmb
+abmc abmd abme abmf abmg abmh abmi abmj abmk abml abmm abmn abmo abmp abmq
+abmr abms abmt abmu abmv abmw abmx abmy abmz abna abnb abnc abnd abne abnf
+abng abnh abni abnj abnk abnl abnm abnn abno abnp abnq abnr abns abnt abnu
+abnv abnw abnx abny abnz aboa abob aboc abod aboe abof abog aboh aboi aboj
+abok abol abom abon aboo abop aboq abor abos abot abou abov abow abox aboy
+aboz abpa abpb abpc abpd abpe abpf abpg abph abpi abpj abpk abpl abpm abpn
+abpo abpp abpq abpr abps abpt abpu abpv abpw abpx abpy abpz abqa abqb abqc
+abqd abqe abqf abqg abqh abqi abqj abqk abql abqm abqn abqo abqp abqq abqr
+abqs abqt abqu abqv abqw abqx abqy abqz abra abrb abrc abrd abre abrf abrg
+abrh abri abrj abrk abrl abrm abrn abro abrp abrq abrr abrs abrt abru abrv
+abrw abrx abry abrz absa absb absc absd abse absf absg absh absi absj absk
+absl absm absn abso absp absq absr abss abst absu absv absw absx absy absz
+abta abtb abtc abtd abte abtf abtg abth abti abtj abtk abtl abtm abtn abto
+abtp abtq abtr abts abtt abtu abtv abtw abtx abty abtz abua abub abuc abud
+abue abuf abug abuh abui abuj abuk abul abum abun abuo abup abuq abur abus
+abut abuu abuv abuw abux abuy abuz abva abvb abvc abvd abve abvf abvg abvh
+abvi abvj abvk abvl abvm abvn abvo abvp abvq abvr abvs abvt abvu abvv abvw
+abvx abvy abvz abwa abwb abwc abwd abwe abwf abwg abwh abwi abwj abwk abwl
+abwm abwn abwo abwp abwq abwr abws abwt abwu abwv abww abwx abwy abwz abxa
+abxb abxc abxd abxe abxf abxg abxh abxi abxj abxk abxl abxm abxn abxo abxp
+abxq abxr abxs abxt abxu abxv abxw abxx abxy abxz abya abyb abyc abyd abye
+abyf abyg abyh abyi abyj abyk abyl abym abyn abyo abyp abyq abyr abys abyt
+abyu abyv abyw abyx abyy abyz abza abzb abzc abzd abze abzf abzg abzh abzi
+abzj abzk abzl abzm abzn abzo abzp abzq abzr abzs abzt abzu abzv abzw abzx
+abzy abzz acaa acab acac acad acae acaf acag acah acai acaj acak acal acam
+acan acao acap acaq acar acas acat acau acav acaw acax acay acaz acba acbb
+acbc acbd acbe acbf acbg acbh acbi acbj acbk acbl acbm acbn acbo acbp acbq
+acbr acbs acbt acbu acbv acbw acbx acby acbz acca accb accc accd acce accf
+accg acch acci accj acck accl accm accn acco accp accq accr accs acct accu
+accv accw accx accy accz acda acdb acdc acdd acde acdf acdg acdh acdi acdj
+acdk acdl acdm acdn acdo acdp acdq acdr acds acdt acdu acdv acdw acdx acdy
+acdz acea aceb acec aced acee acef aceg aceh acei acej acek acel acem acen
+aceo acep aceq acer aces acet aceu acev acew acex acey acez acfa acfb acfc
+acfd acfe acff acfg acfh acfi acfj acfk acfl acfm acfn acfo acfp acfq acfr
+acfs acft acfu acfv acfw acfx acfy acfz acga acgb acgc acgd acge acgf acgg
+acgh acgi acgj acgk acgl acgm acgn acgo acgp acgq acgr acgs acgt acgu acgv
+acgw acgx acgy acgz acha achb achc achd ache achf achg achh achi achj achk
+achl achm achn acho achp achq achr achs acht achu achv achw achx achy achz
+acia acib acic acid acie acif acig acih acii acij acik acil acim acin acio
+acip aciq acir acis acit aciu aciv aciw acix aciy aciz acja acjb acjc acjd
+acje acjf acjg acjh acji acjj acjk acjl acjm acjn acjo acjp acjq acjr acjs
+acjt acju acjv acjw acjx acjy acjz acka ackb ackc ackd acke ackf ackg ackh
+acki ackj ackk ackl ackm ackn acko ackp ackq ackr acks ackt acku ackv ackw
+ackx acky ackz acla aclb aclc acld acle aclf aclg aclh acli aclj aclk acll
+aclm acln aclo aclp aclq aclr acls aclt aclu aclv aclw aclx acly aclz acma
+acmb acmc acmd acme acmf acmg acmh acmi acmj acmk acml acmm acmn acmo acmp
+acmq acmr acms acmt acmu acmv acmw acmx acmy acmz acna acnb acnc acnd acne
+acnf acng acnh acni acnj acnk acnl acnm acnn acno acnp acnq acnr acns acnt
+acnu acnv acnw acnx acny acnz acoa acob acoc acod acoe acof acog acoh acoi
+acoj acok acol acom acon acoo acop acoq acor acos acot acou acov acow acox
+acoy acoz acpa acpb acpc acpd acpe acpf acpg acph acpi acpj acpk acpl acpm
+acpn acpo acpp acpq acpr acps acpt acpu acpv acpw acpx acpy acpz acqa acqb
+acqc acqd acqe acqf acqg acqh acqi acqj acqk acql acqm acqn acqo acqp acqq
+acqr acqs acqt acqu acqv acqw acqx acqy acqz acra acrb acrc acrd acre acrf
+acrg acrh acri acrj acrk acrl acrm acrn acro acrp acrq acrr acrs acrt acru
+acrv acrw acrx acry acrz acsa acsb acsc acsd acse acsf acsg acsh acsi acsj
+acsk acsl acsm acsn acso acsp acsq acsr acss acst acsu acsv acsw acsx acsy
+acsz acta actb actc actd acte actf actg acth acti actj actk actl actm actn
+acto actp actq actr acts actt actu actv actw actx acty actz acua acub acuc
+acud acue acuf acug acuh acui acuj acuk acul acum acun acuo acup acuq acur
+acus acut acuu acuv acuw acux acuy acuz acva acvb acvc acvd acve acvf acvg
+acvh acvi acvj acvk acvl acvm acvn acvo acvp acvq acvr acvs acvt acvu acvv
+acvw acvx acvy acvz acwa acwb acwc acwd acwe acwf acwg acwh acwi acwj acwk
+acwl acwm acwn acwo acwp acwq acwr acws acwt acwu acwv acww acwx acwy acwz
+acxa acxb acxc acxd acxe acxf acxg acxh acxi acxj acxk acxl acxm acxn acxo
+acxp acxq acxr acxs acxt acxu acxv acxw acxx acxy acxz acya acyb acyc acyd
+acye acyf acyg acyh acyi acyj acyk acyl acym acyn acyo acyp acyq acyr acys
+acyt acyu acyv acyw acyx acyy acyz acza aczb aczc aczd acze aczf aczg aczh
+aczi aczj aczk aczl aczm aczn aczo aczp aczq aczr aczs aczt aczu aczv aczw
+aczx aczy aczz adaa adab adac adad adae adaf adag adah adai adaj adak adal
+adam adan adao adap adaq adar adas adat adau adav adaw adax aday adaz adba
+adbb adbc adbd adbe adbf adbg adbh adbi adbj adbk adbl adbm adbn adbo adbp
+adbq adbr adbs adbt adbu adbv adbw adbx adby adbz adca adcb adcc adcd adce
+adcf adcg adch adci adcj adck adcl adcm adcn adco adcp adcq adcr adcs adct
+adcu adcv adcw adcx adcy adcz adda addb addc addd adde addf addg addh addi
+addj addk addl addm addn addo addp addq addr adds addt addu addv addw addx
+addy addz adea adeb adec aded adee adef adeg adeh adei adej adek adel adem
+aden adeo adep adeq ader ades adet adeu adev adew adex adey adez adfa adfb
+adfc adfd adfe adff adfg adfh adfi adfj adfk adfl adfm adfn adfo adfp adfq
+adfr adfs adft adfu adfv adfw adfx adfy adfz adga adgb adgc adgd adge adgf
+adgg adgh adgi adgj adgk adgl adgm adgn adgo adgp adgq adgr adgs adgt adgu
+adgv adgw adgx adgy adgz adha adhb adhc adhd adhe adhf adhg adhh adhi adhj
+adhk adhl adhm adhn adho adhp adhq adhr adhs adht adhu adhv adhw adhx adhy
+adhz adia adib adic adid adie adif adig adih adii adij adik adil adim adin
+adio adip adiq adir adis adit adiu adiv adiw adix adiy adiz adja adjb adjc
+adjd adje adjf adjg adjh adji adjj adjk adjl adjm adjn adjo adjp adjq adjr
+adjs adjt adju adjv adjw adjx adjy adjz adka adkb adkc adkd adke adkf adkg
+adkh adki adkj adkk adkl adkm adkn adko adkp adkq adkr adks adkt adku adkv
+adkw adkx adky adkz adla adlb adlc adld adle adlf adlg adlh adli adlj adlk
+adll adlm adln adlo adlp adlq adlr adls adlt adlu adlv adlw adlx adly adlz
+adma admb admc admd adme admf admg admh admi admj admk adml admm admn admo
+admp admq admr adms admt admu admv admw admx admy admz adna adnb adnc adnd
+adne adnf adng adnh adni adnj adnk adnl adnm adnn adno adnp adnq adnr adns
+adnt adnu adnv adnw adnx adny adnz adoa adob adoc adod adoe adof adog adoh
+adoi adoj adok adol adom adon adoo adop adoq ador ados adot adou adov adow
+adox adoy adoz adpa adpb adpc adpd adpe adpf adpg adph adpi adpj adpk adpl
+adpm adpn adpo adpp adpq adpr adps adpt adpu adpv adpw adpx adpy adpz adqa
+adqb adqc adqd adqe adqf adqg adqh adqi adqj adqk adql adqm adqn adqo adqp
+adqq adqr adqs adqt adqu adqv adqw adqx adqy adqz adra adrb adrc adrd adre
+adrf adrg adrh adri adrj adrk adrl adrm adrn adro adrp adrq adrr adrs adrt
+adru adrv adrw adrx adry adrz adsa adsb adsc adsd adse adsf adsg adsh adsi
+adsj adsk adsl adsm adsn adso adsp adsq adsr adss adst adsu adsv adsw adsx
+adsy adsz adta adtb adtc adtd adte adtf adtg adth adti adtj adtk adtl adtm
+adtn adto adtp adtq adtr adts adtt adtu adtv adtw adtx adty adtz adua adub
+aduc adud adue aduf adug aduh adui aduj aduk adul adum adun aduo adup aduq
+adur adus adut aduu aduv aduw adux aduy aduz adva advb advc advd adve advf
+advg advh advi advj advk advl advm advn advo advp advq advr advs advt advu
+advv advw advx advy advz adwa adwb adwc adwd adwe adwf adwg adwh adwi adwj
+adwk adwl adwm adwn adwo adwp adwq adwr adws adwt adwu adwv adww adwx adwy
+adwz adxa adxb adxc adxd adxe adxf adxg adxh adxi adxj adxk adxl adxm adxn
+adxo adxp adxq adxr adxs adxt adxu adxv adxw adxx adxy adxz adya adyb adyc
+adyd adye adyf adyg adyh adyi adyj adyk adyl adym adyn adyo adyp adyq adyr
+adys adyt adyu adyv adyw adyx adyy adyz adza adzb adzc adzd adze adzf adzg
+adzh adzi adzj adzk adzl adzm adzn adzo adzp adzq adzr adzs adzt adzu adzv
+adzw adzx adzy adzz aeaa aeab aeac aead aeae aeaf aeag aeah aeai aeaj aeak
+aeal aeam aean aeao aeap aeaq aear aeas aeat aeau aeav aeaw aeax aeay aeaz
+aeba aebb aebc aebd aebe aebf aebg aebh aebi aebj aebk aebl aebm aebn aebo
+aebp aebq aebr aebs aebt aebu aebv aebw aebx aeby aebz aeca aecb aecc aecd
+aece aecf aecg aech aeci aecj aeck aecl aecm aecn aeco aecp aecq aecr aecs
+aect aecu aecv aecw aecx aecy aecz aeda aedb aedc aedd aede aedf aedg aedh
+aedi aedj aedk aedl aedm aedn aedo aedp aedq aedr aeds aedt aedu aedv aedw
+aedx aedy aedz aeea aeeb aeec aeed aeee aeef aeeg aeeh aeei aeej aeek aeel
+aeem aeen aeeo aeep aeeq aeer aees aeet aeeu aeev aeew aeex aeey aeez aefa
+aefb aefc aefd aefe aeff aefg aefh aefi aefj aefk aefl aefm aefn aefo aefp
+aefq aefr aefs aeft aefu aefv aefw aefx aefy aefz aega aegb aegc aegd aege
+aegf aegg aegh aegi aegj aegk aegl aegm aegn aego aegp aegq aegr aegs aegt
+aegu aegv aegw aegx aegy aegz aeha aehb aehc aehd aehe aehf aehg aehh aehi
+aehj aehk aehl aehm aehn aeho aehp aehq aehr aehs aeht aehu aehv aehw aehx
+aehy aehz aeia aeib aeic aeid aeie aeif aeig aeih aeii aeij aeik aeil aeim
+aein aeio aeip aeiq aeir aeis aeit aeiu aeiv aeiw aeix aeiy aeiz aeja aejb
+aejc aejd aeje aejf aejg aejh aeji aejj aejk aejl aejm aejn aejo aejp aejq
+aejr aejs aejt aeju aejv aejw aejx aejy aejz aeka aekb aekc aekd aeke aekf
+aekg aekh aeki aekj aekk aekl aekm aekn aeko aekp aekq aekr aeks aekt aeku
+aekv aekw aekx aeky aekz aela aelb aelc aeld aele aelf aelg aelh aeli aelj
+aelk aell aelm aeln aelo aelp aelq aelr aels aelt aelu aelv aelw aelx aely
+aelz aema aemb aemc aemd aeme aemf aemg aemh aemi aemj aemk aeml aemm aemn
+aemo aemp aemq aemr aems aemt aemu aemv aemw aemx aemy aemz aena aenb aenc
+aend aene aenf aeng aenh aeni aenj aenk aenl aenm aenn aeno aenp aenq aenr
+aens aent aenu aenv aenw aenx aeny aenz aeoa aeob aeoc aeod aeoe aeof aeog
+aeoh aeoi aeoj aeok aeol aeom aeon aeoo aeop aeoq aeor aeos aeot aeou aeov
+aeow aeox aeoy aeoz aepa aepb aepc aepd aepe aepf aepg aeph aepi aepj aepk
+aepl aepm aepn aepo aepp aepq aepr aeps aept aepu aepv aepw aepx aepy aepz
+aeqa aeqb aeqc aeqd aeqe aeqf aeqg aeqh aeqi aeqj aeqk aeql aeqm aeqn aeqo
+aeqp aeqq aeqr aeqs aeqt aequ aeqv aeqw aeqx aeqy aeqz aera aerb aerc aerd
+aere aerf aerg aerh aeri aerj aerk aerl aerm aern aero aerp aerq aerr aers
+aert aeru aerv aerw aerx aery aerz aesa aesb aesc aesd aese aesf aesg aesh
+aesi aesj aesk aesl aesm aesn aeso aesp aesq aesr aess aest aesu aesv aesw
+aesx aesy aesz aeta aetb aetc aetd aete aetf aetg aeth aeti aetj aetk aetl
+aetm aetn aeto aetp aetq aetr aets aett aetu aetv aetw aetx aety aetz aeua
+aeub aeuc aeud aeue aeuf aeug aeuh aeui aeuj aeuk aeul aeum aeun aeuo aeup
+aeuq aeur aeus aeut aeuu aeuv aeuw aeux aeuy aeuz aeva aevb aevc aevd aeve
+aevf aevg aevh aevi aevj aevk aevl aevm aevn aevo aevp aevq aevr aevs aevt
+aevu aevv aevw aevx aevy aevz aewa aewb aewc aewd aewe aewf aewg aewh aewi
+aewj aewk aewl aewm aewn aewo aewp aewq aewr aews aewt aewu aewv aeww aewx
+aewy aewz aexa aexb aexc aexd aexe aexf aexg aexh aexi aexj aexk aexl aexm
+aexn aexo aexp aexq aexr aexs aext aexu aexv aexw aexx aexy aexz aeya aeyb
+aeyc aeyd aeye aeyf aeyg aeyh aeyi aeyj aeyk aeyl aeym aeyn aeyo aeyp aeyq
+aeyr aeys aeyt aeyu aeyv aeyw aeyx aeyy aeyz aeza aezb aezc aezd aeze aezf
+aezg aezh aezi aezj aezk aezl aezm aezn aezo aezp aezq aezr aezs aezt aezu
+aezv aezw aezx aezy aezz afaa afab afac afad afae afaf afag afah afai afaj
+afak afal afam afan afao afap afaq afar afas afat afau afav afaw afax afay
+afaz afba afbb afbc afbd afbe afbf afbg afbh afbi afbj afbk afbl afbm afbn
+afbo afbp afbq afbr afbs afbt afbu afbv afbw afbx afby afbz afca afcb afcc
+afcd afce afcf afcg afch afci afcj afck afcl afcm afcn afco afcp afcq afcr
+afcs afct afcu afcv afcw afcx afcy afcz afda afdb afdc afdd afde afdf afdg
+afdh afdi afdj afdk afdl afdm afdn afdo afdp afdq afdr afds afdt afdu afdv
+afdw afdx afdy afdz afea afeb afec afed afee afef afeg afeh afei afej afek
+afel afem afen afeo afep afeq afer afes afet afeu afev afew afex afey afez
+affa affb affc affd affe afff affg affh affi affj affk affl affm affn affo
+affp affq affr affs afft affu affv affw affx affy affz afga afgb afgc afgd
+afge afgf afgg afgh afgi afgj afgk afgl afgm afgn afgo afgp afgq afgr afgs
+afgt afgu afgv afgw afgx afgy afgz afha afhb afhc afhd afhe afhf afhg afhh
+afhi afhj afhk afhl afhm afhn afho afhp afhq afhr afhs afht afhu afhv afhw
+afhx afhy afhz afia afib afic afid afie afif afig afih afii afij afik afil
+afim afin afio afip afiq afir afis afit afiu afiv afiw afix afiy afiz afja
+afjb afjc afjd afje afjf afjg afjh afji afjj afjk afjl afjm afjn afjo afjp
+afjq afjr afjs afjt afju afjv afjw afjx afjy afjz afka afkb afkc afkd afke
+afkf afkg afkh afki afkj afkk afkl afkm afkn afko afkp afkq afkr afks afkt
+afku afkv afkw afkx afky afkz afla aflb aflc afld afle aflf aflg aflh afli
+aflj aflk afll aflm afln aflo aflp aflq aflr afls aflt aflu aflv aflw aflx
+afly aflz afma afmb afmc afmd afme afmf afmg afmh afmi afmj afmk afml afmm
+afmn afmo afmp afmq afmr afms afmt afmu afmv afmw afmx afmy afmz afna afnb
+afnc afnd afne afnf afng afnh afni afnj afnk afnl afnm afnn afno afnp afnq
+afnr afns afnt afnu afnv afnw afnx afny afnz afoa afob afoc afod afoe afof
+afog afoh afoi afoj afok afol afom afon afoo afop afoq afor afos afot afou
+afov afow afox afoy afoz afpa afpb afpc afpd afpe afpf afpg afph afpi afpj
+afpk afpl afpm afpn afpo afpp afpq afpr afps afpt afpu afpv afpw afpx afpy
+afpz afqa afqb afqc afqd afqe afqf afqg afqh afqi afqj afqk afql afqm afqn
+afqo afqp afqq afqr afqs afqt afqu afqv afqw afqx afqy afqz afra afrb afrc
+afrd afre afrf afrg afrh afri afrj afrk afrl afrm afrn afro afrp afrq afrr
+afrs afrt afru afrv afrw afrx afry afrz afsa afsb afsc afsd afse afsf afsg
+afsh afsi afsj afsk afsl afsm afsn afso afsp afsq afsr afss afst afsu afsv
+afsw afsx afsy afsz afta aftb aftc aftd afte aftf aftg afth afti aftj aftk
+aftl aftm aftn afto aftp aftq aftr afts aftt aftu aftv aftw aftx afty aftz
+afua afub afuc afud afue afuf afug afuh afui afuj afuk aful afum afun afuo
+afup afuq afur afus afut afuu afuv afuw afux afuy afuz afva afvb afvc afvd
+afve afvf afvg afvh afvi afvj afvk afvl afvm afvn afvo afvp afvq afvr afvs
+afvt afvu afvv afvw afvx afvy afvz afwa afwb afwc afwd afwe afwf afwg afwh
+afwi afwj afwk afwl afwm afwn afwo afwp afwq afwr afws afwt afwu afwv afww
+afwx afwy afwz afxa afxb afxc afxd afxe afxf afxg afxh afxi afxj afxk afxl
+afxm afxn afxo afxp afxq afxr afxs afxt afxu afxv afxw afxx afxy afxz afya
+afyb afyc afyd afye afyf afyg afyh afyi afyj afyk afyl afym afyn afyo afyp
+afyq afyr afys afyt afyu afyv afyw afyx afyy afyz afza afzb afzc afzd afze
+afzf afzg afzh afzi afzj afzk afzl afzm afzn afzo afzp afzq afzr afzs afzt
+afzu afzv afzw afzx afzy afzz agaa agab agac agad agae agaf agag agah agai
+agaj agak agal agam agan agao agap agaq agar agas agat agau agav agaw agax
+agay agaz agba agbb agbc agbd agbe agbf agbg agbh agbi agbj agbk agbl agbm
+agbn agbo agbp agbq agbr agbs agbt agbu agbv agbw agbx agby agbz agca agcb
+agcc agcd agce agcf agcg agch agci agcj agck agcl agcm agcn agco agcp agcq
+agcr agcs agct agcu agcv agcw agcx agcy agcz agda agdb agdc agdd agde agdf
+agdg agdh agdi agdj agdk agdl agdm agdn agdo agdp agdq agdr agds agdt agdu
+agdv agdw agdx agdy agdz agea ageb agec aged agee agef ageg ageh agei agej
+agek agel agem agen ageo agep ageq ager ages aget ageu agev agew agex agey
+agez agfa agfb agfc agfd agfe agff agfg agfh agfi agfj agfk agfl agfm agfn
+agfo agfp agfq agfr agfs agft agfu agfv agfw agfx agfy agfz agga aggb aggc
+aggd agge aggf aggg aggh aggi aggj aggk aggl aggm aggn aggo aggp aggq aggr
+aggs aggt aggu aggv aggw aggx aggy aggz agha aghb aghc aghd aghe aghf aghg
+aghh aghi aghj aghk aghl aghm aghn agho aghp aghq aghr aghs aght aghu aghv
+aghw aghx aghy aghz agia agib agic agid agie agif agig agih agii agij agik
+agil agim agin agio agip agiq agir agis agit agiu agiv agiw agix agiy agiz
+agja agjb agjc agjd agje agjf agjg agjh agji agjj agjk agjl agjm agjn agjo
+agjp agjq agjr agjs agjt agju agjv agjw agjx agjy agjz agka agkb agkc agkd
+agke agkf agkg agkh agki agkj agkk agkl agkm agkn agko agkp agkq agkr agks
+agkt agku agkv agkw agkx agky agkz agla aglb aglc agld agle aglf aglg aglh
+agli aglj aglk agll aglm agln aglo aglp aglq aglr agls aglt aglu aglv aglw
+aglx agly aglz agma agmb agmc agmd agme agmf agmg agmh agmi agmj agmk agml
+agmm agmn agmo agmp agmq agmr agms agmt agmu agmv agmw agmx agmy agmz agna
+agnb agnc agnd agne agnf agng agnh agni agnj agnk agnl agnm agnn agno agnp
+agnq agnr agns agnt agnu agnv agnw agnx agny agnz agoa agob agoc agod agoe
+agof agog agoh agoi agoj agok agol agom agon agoo agop agoq agor agos agot
+agou agov agow agox agoy agoz agpa agpb agpc agpd agpe agpf agpg agph agpi
+agpj agpk agpl agpm agpn agpo agpp agpq agpr agps agpt agpu agpv agpw agpx
+agpy agpz agqa agqb agqc agqd agqe agqf agqg agqh agqi agqj agqk agql agqm
+agqn agqo agqp agqq agqr agqs agqt agqu agqv agqw agqx agqy agqz agra agrb
+agrc agrd agre agrf agrg agrh agri agrj agrk agrl agrm agrn agro agrp agrq
+agrr agrs agrt agru agrv agrw agrx agry agrz agsa agsb agsc agsd agse agsf
+agsg agsh agsi agsj agsk agsl agsm agsn agso agsp agsq agsr agss agst agsu
+agsv agsw agsx agsy agsz agta agtb agtc agtd agte agtf agtg agth agti agtj
+agtk agtl agtm agtn agto agtp agtq agtr agts agtt agtu agtv agtw agtx agty
+agtz agua agub aguc agud ague aguf agug aguh agui aguj aguk agul agum agun
+aguo agup aguq agur agus agut aguu aguv aguw agux aguy aguz agva agvb agvc
+agvd agve agvf agvg agvh agvi agvj agvk agvl agvm agvn agvo agvp agvq agvr
+agvs agvt agvu agvv agvw agvx agvy agvz agwa agwb agwc agwd agwe agwf agwg
+agwh agwi agwj agwk agwl agwm agwn agwo agwp agwq agwr agws agwt agwu agwv
+agww agwx agwy agwz agxa agxb agxc agxd agxe agxf agxg agxh agxi agxj agxk
+agxl agxm agxn agxo agxp agxq agxr agxs agxt agxu agxv agxw agxx agxy agxz
+agya agyb agyc agyd agye agyf agyg agyh agyi agyj agyk agyl agym agyn agyo
+agyp agyq agyr agys agyt agyu agyv agyw agyx agyy agyz agza agzb agzc agzd
+agze agzf agzg agzh agzi agzj agzk agzl agzm agzn agzo agzp agzq agzr agzs
+agzt agzu agzv agzw agzx agzy agzz ahaa ahab ahac ahad ahae ahaf ahag ahah
+ahai ahaj ahak ahal aham ahan ahao ahap ahaq ahar ahas ahat ahau ahav ahaw
+ahax ahay ahaz ahba ahbb ahbc ahbd ahbe ahbf ahbg ahbh ahbi ahbj ahbk ahbl
+ahbm ahbn ahbo ahbp ahbq ahbr ahbs ahbt ahbu ahbv ahbw ahbx ahby ahbz ahca
+ahcb ahcc ahcd ahce ahcf ahcg ahch ahci ahcj ahck ahcl ahcm ahcn ahco ahcp
+ahcq ahcr ahcs ahct ahcu ahcv ahcw ahcx ahcy ahcz ahda ahdb ahdc ahdd ahde
+ahdf ahdg ahdh ahdi ahdj ahdk ahdl ahdm ahdn ahdo ahdp ahdq ahdr ahds ahdt
+ahdu ahdv ahdw ahdx ahdy ahdz ahea aheb ahec ahed ahee ahef aheg aheh ahei
+ahej ahek ahel ahem ahen aheo ahep aheq aher ahes ahet aheu ahev ahew ahex
+ahey ahez ahfa ahfb ahfc ahfd ahfe ahff ahfg ahfh ahfi ahfj ahfk ahfl ahfm
+ahfn ahfo ahfp ahfq ahfr ahfs ahft ahfu ahfv ahfw ahfx ahfy ahfz ahga ahgb
+ahgc ahgd ahge ahgf ahgg ahgh ahgi ahgj ahgk ahgl ahgm ahgn ahgo ahgp ahgq
+ahgr ahgs ahgt ahgu ahgv ahgw ahgx ahgy ahgz ahha ahhb ahhc ahhd ahhe ahhf
+ahhg ahhh ahhi ahhj ahhk ahhl ahhm ahhn ahho ahhp ahhq ahhr ahhs ahht ahhu
+ahhv ahhw ahhx ahhy ahhz ahia ahib ahic ahid ahie ahif ahig ahih ahii ahij
+ahik ahil ahim ahin ahio ahip ahiq ahir ahis ahit ahiu ahiv ahiw ahix ahiy
+ahiz ahja ahjb ahjc ahjd ahje ahjf ahjg ahjh ahji ahjj ahjk ahjl ahjm ahjn
+ahjo ahjp ahjq ahjr ahjs ahjt ahju ahjv ahjw ahjx ahjy ahjz ahka ahkb ahkc
+ahkd ahke ahkf ahkg ahkh ahki ahkj ahkk ahkl ahkm ahkn ahko ahkp ahkq ahkr
+ahks ahkt ahku ahkv ahkw ahkx ahky ahkz ahla ahlb ahlc ahld ahle ahlf ahlg
+ahlh ahli ahlj ahlk ahll ahlm ahln ahlo ahlp ahlq ahlr ahls ahlt ahlu ahlv
+ahlw ahlx ahly ahlz ahma ahmb ahmc ahmd ahme ahmf ahmg ahmh ahmi ahmj ahmk
+ahml ahmm ahmn ahmo ahmp ahmq ahmr ahms ahmt ahmu ahmv ahmw ahmx ahmy ahmz
+ahna ahnb ahnc ahnd ahne ahnf ahng ahnh ahni ahnj ahnk ahnl ahnm ahnn ahno
+ahnp ahnq ahnr ahns ahnt ahnu ahnv ahnw ahnx ahny ahnz ahoa ahob ahoc ahod
+ahoe ahof ahog ahoh ahoi ahoj ahok ahol ahom ahon ahoo ahop ahoq ahor ahos
+ahot ahou ahov ahow ahox ahoy ahoz ahpa ahpb ahpc ahpd ahpe ahpf ahpg ahph
+ahpi ahpj ahpk ahpl ahpm ahpn ahpo ahpp ahpq ahpr ahps ahpt ahpu ahpv ahpw
+ahpx ahpy ahpz ahqa ahqb ahqc ahqd ahqe ahqf ahqg ahqh ahqi ahqj ahqk ahql
+ahqm ahqn ahqo ahqp ahqq ahqr ahqs ahqt ahqu ahqv ahqw ahqx ahqy ahqz ahra
+ahrb ahrc ahrd ahre ahrf ahrg ahrh ahri ahrj ahrk ahrl ahrm ahrn ahro ahrp
+ahrq ahrr ahrs ahrt ahru ahrv ahrw ahrx ahry ahrz ahsa ahsb ahsc ahsd ahse
+ahsf ahsg ahsh ahsi ahsj ahsk ahsl ahsm ahsn ahso ahsp ahsq ahsr ahss ahst
+ahsu ahsv ahsw ahsx ahsy ahsz ahta ahtb ahtc ahtd ahte ahtf ahtg ahth ahti
+ahtj ahtk ahtl ahtm ahtn ahto ahtp ahtq ahtr ahts ahtt ahtu ahtv ahtw ahtx
+ahty ahtz ahua ahub ahuc ahud ahue ahuf ahug ahuh ahui ahuj ahuk ahul ahum
+ahun ahuo ahup ahuq ahur ahus ahut ahuu ahuv ahuw ahux ahuy ahuz ahva ahvb
+ahvc ahvd ahve ahvf ahvg ahvh ahvi ahvj ahvk ahvl ahvm ahvn ahvo ahvp ahvq
+ahvr ahvs ahvt ahvu ahvv ahvw ahvx ahvy ahvz ahwa ahwb ahwc ahwd ahwe ahwf
+ahwg ahwh ahwi ahwj ahwk ahwl ahwm ahwn ahwo ahwp ahwq ahwr ahws ahwt ahwu
+ahwv ahww ahwx ahwy ahwz ahxa ahxb ahxc ahxd ahxe ahxf ahxg ahxh ahxi ahxj
+ahxk ahxl ahxm ahxn ahxo ahxp ahxq ahxr ahxs ahxt ahxu ahxv ahxw ahxx ahxy
+ahxz ahya ahyb ahyc ahyd ahye ahyf ahyg ahyh ahyi ahyj ahyk ahyl ahym ahyn
+ahyo ahyp ahyq ahyr ahys ahyt ahyu ahyv ahyw ahyx ahyy ahyz ahza ahzb ahzc
+ahzd ahze ahzf ahzg ahzh ahzi ahzj ahzk ahzl ahzm ahzn ahzo ahzp ahzq ahzr
+ahzs ahzt ahzu ahzv ahzw ahzx ahzy ahzz aiaa aiab aiac aiad aiae aiaf aiag
+aiah aiai aiaj aiak aial aiam aian aiao aiap aiaq aiar aias aiat aiau aiav
+aiaw aiax aiay aiaz aiba aibb aibc aibd aibe aibf aibg aibh aibi aibj aibk
+aibl aibm aibn aibo aibp aibq aibr aibs aibt aibu aibv aibw aibx aiby aibz
+aica aicb aicc aicd aice aicf aicg aich aici aicj aick aicl aicm aicn aico
+aicp aicq aicr aics aict aicu aicv aicw aicx aicy aicz aida aidb aidc aidd
+aide aidf aidg aidh aidi aidj aidk aidl aidm aidn aido aidp aidq aidr aids
+aidt aidu aidv aidw aidx aidy aidz aiea aieb aiec aied aiee aief aieg aieh
+aiei aiej aiek aiel aiem aien aieo aiep aieq aier aies aiet aieu aiev aiew
+aiex aiey aiez aifa aifb aifc aifd aife aiff aifg aifh aifi aifj aifk aifl
+aifm aifn aifo aifp aifq aifr aifs aift aifu aifv aifw aifx aify aifz aiga
+aigb aigc aigd aige aigf aigg aigh aigi aigj aigk aigl aigm aign aigo aigp
+aigq aigr aigs aigt aigu aigv aigw aigx aigy aigz aiha aihb aihc aihd aihe
+aihf aihg aihh aihi aihj aihk aihl aihm aihn aiho aihp aihq aihr aihs aiht
+aihu aihv aihw aihx aihy aihz aiia aiib aiic aiid aiie aiif aiig aiih aiii
+aiij aiik aiil aiim aiin aiio aiip aiiq aiir aiis aiit aiiu aiiv aiiw aiix
+aiiy aiiz aija aijb aijc aijd aije aijf aijg aijh aiji aijj aijk aijl aijm
+aijn aijo aijp aijq aijr aijs aijt aiju aijv aijw aijx aijy aijz aika aikb
+aikc aikd aike aikf aikg aikh aiki aikj aikk aikl aikm aikn aiko aikp aikq
+aikr aiks aikt aiku aikv aikw aikx aiky aikz aila ailb ailc aild aile ailf
+ailg ailh aili ailj ailk aill ailm ailn ailo ailp ailq ailr ails ailt ailu
+ailv ailw ailx aily ailz aima aimb aimc aimd aime aimf aimg aimh aimi aimj
+aimk aiml aimm aimn aimo aimp aimq aimr aims aimt aimu aimv aimw aimx aimy
+aimz aina ainb ainc aind aine ainf aing ainh aini ainj aink ainl ainm ainn
+aino ainp ainq ainr ains aint ainu ainv ainw ainx ainy ainz aioa aiob aioc
+aiod aioe aiof aiog aioh aioi aioj aiok aiol aiom aion aioo aiop aioq aior
+aios aiot aiou aiov aiow aiox aioy aioz aipa aipb aipc aipd aipe aipf aipg
+aiph aipi aipj aipk aipl aipm aipn aipo aipp aipq aipr aips aipt aipu aipv
+aipw aipx aipy aipz aiqa aiqb aiqc aiqd aiqe aiqf aiqg aiqh aiqi aiqj aiqk
+aiql aiqm aiqn aiqo aiqp aiqq aiqr aiqs aiqt aiqu aiqv aiqw aiqx aiqy aiqz
+aira airb airc aird aire airf airg airh airi airj airk airl airm airn airo
+airp airq airr airs airt airu airv airw airx airy airz aisa aisb aisc aisd
+aise aisf aisg aish aisi aisj aisk aisl aism aisn aiso aisp aisq aisr aiss
+aist aisu aisv aisw aisx aisy aisz aita aitb aitc aitd aite aitf aitg aith
+aiti aitj aitk aitl aitm aitn aito aitp aitq aitr aits aitt aitu aitv aitw
+aitx aity aitz aiua aiub aiuc aiud aiue aiuf aiug aiuh aiui aiuj aiuk aiul
+aium aiun aiuo aiup aiuq aiur aius aiut aiuu aiuv aiuw aiux aiuy aiuz aiva
+aivb aivc aivd aive aivf aivg aivh aivi aivj aivk aivl aivm aivn aivo aivp
+aivq aivr aivs aivt aivu aivv aivw aivx aivy aivz aiwa aiwb aiwc aiwd aiwe
+aiwf aiwg aiwh aiwi aiwj aiwk aiwl aiwm aiwn aiwo aiwp aiwq aiwr aiws aiwt
+aiwu aiwv aiww aiwx aiwy aiwz aixa aixb aixc aixd aixe aixf aixg aixh aixi
+aixj aixk aixl aixm aixn aixo aixp aixq aixr aixs aixt aixu aixv aixw aixx
+aixy aixz aiya aiyb aiyc aiyd aiye aiyf aiyg aiyh aiyi aiyj aiyk aiyl aiym
+aiyn aiyo aiyp aiyq aiyr aiys aiyt aiyu aiyv aiyw aiyx aiyy aiyz aiza aizb
+aizc aizd aize aizf aizg aizh aizi aizj aizk aizl aizm aizn aizo aizp aizq
+aizr aizs aizt aizu aizv aizw aizx aizy aizz ajaa ajab ajac ajad ajae ajaf
+ajag ajah ajai ajaj ajak ajal ajam ajan ajao ajap ajaq ajar ajas ajat ajau
+ajav ajaw ajax ajay ajaz ajba ajbb ajbc ajbd ajbe ajbf ajbg ajbh ajbi ajbj
+ajbk ajbl ajbm ajbn ajbo ajbp ajbq ajbr ajbs ajbt ajbu ajbv ajbw ajbx ajby
+ajbz ajca ajcb ajcc ajcd ajce ajcf ajcg ajch ajci ajcj ajck ajcl ajcm ajcn
+ajco ajcp ajcq ajcr ajcs ajct ajcu ajcv ajcw ajcx ajcy ajcz ajda ajdb ajdc
+ajdd ajde ajdf ajdg ajdh ajdi ajdj ajdk ajdl ajdm ajdn ajdo ajdp ajdq ajdr
+ajds ajdt ajdu ajdv ajdw ajdx ajdy ajdz ajea ajeb ajec ajed ajee ajef ajeg
+ajeh ajei ajej ajek ajel ajem ajen ajeo ajep ajeq ajer ajes ajet ajeu ajev
+ajew ajex ajey ajez ajfa ajfb ajfc ajfd ajfe ajff ajfg ajfh ajfi ajfj ajfk
+ajfl ajfm ajfn ajfo ajfp ajfq ajfr ajfs ajft ajfu ajfv ajfw ajfx ajfy ajfz
+ajga ajgb ajgc ajgd ajge ajgf ajgg ajgh ajgi ajgj ajgk ajgl ajgm ajgn ajgo
+ajgp ajgq ajgr ajgs ajgt ajgu ajgv ajgw ajgx ajgy ajgz ajha ajhb ajhc ajhd
+ajhe ajhf ajhg ajhh ajhi ajhj ajhk ajhl ajhm ajhn ajho ajhp ajhq ajhr ajhs
+ajht ajhu ajhv ajhw ajhx ajhy ajhz ajia ajib ajic ajid ajie ajif ajig ajih
+ajii ajij ajik ajil ajim ajin ajio ajip ajiq ajir ajis ajit ajiu ajiv ajiw
+ajix ajiy ajiz ajja ajjb ajjc ajjd ajje ajjf ajjg ajjh ajji ajjj ajjk ajjl
+ajjm ajjn ajjo ajjp ajjq ajjr ajjs ajjt ajju ajjv ajjw ajjx ajjy ajjz ajka
+ajkb ajkc ajkd ajke ajkf ajkg ajkh ajki ajkj ajkk ajkl ajkm ajkn ajko ajkp
+ajkq ajkr ajks ajkt ajku ajkv ajkw ajkx ajky ajkz ajla ajlb ajlc ajld ajle
+ajlf ajlg ajlh ajli ajlj ajlk ajll ajlm ajln ajlo ajlp ajlq ajlr ajls ajlt
+ajlu ajlv ajlw ajlx ajly ajlz ajma ajmb ajmc ajmd ajme ajmf ajmg ajmh ajmi
+ajmj ajmk ajml ajmm ajmn ajmo ajmp ajmq ajmr ajms ajmt ajmu ajmv ajmw ajmx
+ajmy ajmz ajna ajnb ajnc ajnd ajne ajnf ajng ajnh ajni ajnj ajnk ajnl ajnm
+ajnn ajno ajnp ajnq ajnr ajns ajnt ajnu ajnv ajnw ajnx ajny ajnz ajoa ajob
+ajoc ajod ajoe ajof ajog ajoh ajoi ajoj ajok ajol ajom ajon ajoo ajop ajoq
+ajor ajos ajot ajou ajov ajow ajox ajoy ajoz ajpa ajpb ajpc ajpd ajpe ajpf
+ajpg ajph ajpi ajpj ajpk ajpl ajpm ajpn ajpo ajpp ajpq ajpr ajps ajpt ajpu
+ajpv ajpw ajpx ajpy ajpz ajqa ajqb ajqc ajqd ajqe ajqf ajqg ajqh ajqi ajqj
+ajqk ajql ajqm ajqn ajqo ajqp ajqq ajqr ajqs ajqt ajqu ajqv ajqw ajqx ajqy
+ajqz ajra ajrb ajrc ajrd ajre ajrf ajrg ajrh ajri ajrj ajrk ajrl ajrm ajrn
+ajro ajrp ajrq ajrr ajrs ajrt ajru ajrv ajrw ajrx ajry ajrz ajsa ajsb ajsc
+ajsd ajse ajsf ajsg ajsh ajsi ajsj ajsk ajsl ajsm ajsn ajso ajsp ajsq ajsr
+ajss ajst ajsu ajsv ajsw ajsx ajsy ajsz ajta ajtb ajtc ajtd ajte ajtf ajtg
+ajth ajti ajtj ajtk ajtl ajtm ajtn ajto ajtp ajtq ajtr ajts ajtt ajtu ajtv
+ajtw ajtx ajty ajtz ajua ajub ajuc ajud ajue ajuf ajug ajuh ajui ajuj ajuk
+ajul ajum ajun ajuo ajup ajuq ajur ajus ajut ajuu ajuv ajuw ajux ajuy ajuz
+ajva ajvb ajvc ajvd ajve ajvf ajvg ajvh ajvi ajvj ajvk ajvl ajvm ajvn ajvo
+ajvp ajvq ajvr ajvs ajvt ajvu ajvv ajvw ajvx ajvy ajvz ajwa ajwb ajwc ajwd
+ajwe ajwf ajwg ajwh ajwi ajwj ajwk ajwl ajwm ajwn ajwo ajwp ajwq ajwr ajws
+ajwt ajwu ajwv ajww ajwx ajwy ajwz ajxa ajxb ajxc ajxd ajxe ajxf ajxg ajxh
+ajxi ajxj ajxk ajxl ajxm ajxn ajxo ajxp ajxq ajxr ajxs ajxt ajxu ajxv ajxw
+ajxx ajxy ajxz ajya ajyb ajyc ajyd ajye ajyf ajyg ajyh ajyi ajyj ajyk ajyl
+ajym ajyn ajyo ajyp ajyq ajyr ajys ajyt ajyu ajyv ajyw ajyx ajyy ajyz ajza
+ajzb ajzc ajzd ajze ajzf ajzg ajzh ajzi ajzj ajzk ajzl ajzm ajzn ajzo ajzp
+ajzq ajzr ajzs ajzt ajzu ajzv ajzw ajzx ajzy ajzz akaa akab akac akad akae
+akaf akag akah akai akaj akak akal akam akan akao akap akaq akar akas akat
+akau akav akaw akax akay akaz akba akbb akbc akbd akbe akbf akbg akbh akbi
+akbj akbk akbl akbm akbn akbo akbp akbq akbr akbs akbt akbu akbv akbw akbx
+akby akbz akca akcb akcc akcd akce akcf akcg akch akci akcj akck akcl akcm
+akcn akco akcp akcq akcr akcs akct akcu akcv akcw akcx akcy akcz akda akdb
+akdc akdd akde akdf akdg akdh akdi akdj akdk akdl akdm akdn akdo akdp akdq
+akdr akds akdt akdu akdv akdw akdx akdy akdz akea akeb akec aked akee akef
+akeg akeh akei akej akek akel akem aken akeo akep akeq aker akes aket akeu
+akev akew akex akey akez akfa akfb akfc akfd akfe akff akfg akfh akfi akfj
+akfk akfl akfm akfn akfo akfp akfq akfr akfs akft akfu akfv akfw akfx akfy
+akfz akga akgb akgc akgd akge akgf akgg akgh akgi akgj akgk akgl akgm akgn
+akgo akgp akgq akgr akgs akgt akgu akgv akgw akgx akgy akgz akha akhb akhc
+akhd akhe akhf akhg akhh akhi akhj akhk akhl akhm akhn akho akhp akhq akhr
+akhs akht akhu akhv akhw akhx akhy akhz akia akib akic akid akie akif akig
+akih akii akij akik akil akim akin akio akip akiq akir akis akit akiu akiv
+akiw akix akiy akiz akja akjb akjc akjd akje akjf akjg akjh akji akjj akjk
+akjl akjm akjn akjo akjp akjq akjr akjs akjt akju akjv akjw akjx akjy akjz
+akka akkb akkc akkd akke akkf akkg akkh akki akkj akkk akkl akkm akkn akko
+akkp akkq akkr akks akkt akku akkv akkw akkx akky akkz akla aklb aklc akld
+akle aklf aklg aklh akli aklj aklk akll aklm akln aklo aklp aklq aklr akls
+aklt aklu aklv aklw aklx akly aklz akma akmb akmc akmd akme akmf akmg akmh
+akmi akmj akmk akml akmm akmn akmo akmp akmq akmr akms akmt akmu akmv akmw
+akmx akmy akmz akna aknb aknc aknd akne aknf akng aknh akni aknj aknk aknl
+aknm aknn akno aknp aknq aknr akns aknt aknu aknv aknw aknx akny aknz akoa
+akob akoc akod akoe akof akog akoh akoi akoj akok akol akom akon akoo akop
+akoq akor akos akot akou akov akow akox akoy akoz akpa akpb akpc akpd akpe
+akpf akpg akph akpi akpj akpk akpl akpm akpn akpo akpp akpq akpr akps akpt
+akpu akpv akpw akpx akpy akpz akqa akqb akqc akqd akqe akqf akqg akqh akqi
+akqj akqk akql akqm akqn akqo akqp akqq akqr akqs akqt akqu akqv akqw akqx
+akqy akqz akra akrb akrc akrd akre akrf akrg akrh akri akrj akrk akrl akrm
+akrn akro akrp akrq akrr akrs akrt akru akrv akrw akrx akry akrz aksa aksb
+aksc aksd akse aksf aksg aksh aksi aksj aksk aksl aksm aksn akso aksp aksq
+aksr akss akst aksu aksv aksw aksx aksy aksz akta aktb aktc aktd akte aktf
+aktg akth akti aktj aktk aktl aktm aktn akto aktp aktq aktr akts aktt aktu
+aktv aktw aktx akty aktz akua akub akuc akud akue akuf akug akuh akui akuj
+akuk akul akum akun akuo akup akuq akur akus akut akuu akuv akuw akux akuy
+akuz akva akvb akvc akvd akve akvf akvg akvh akvi akvj akvk akvl akvm akvn
+akvo akvp akvq akvr akvs akvt akvu akvv akvw akvx akvy akvz akwa akwb akwc
+akwd akwe akwf akwg akwh akwi akwj akwk akwl akwm akwn akwo akwp akwq akwr
+akws akwt akwu akwv akww akwx akwy akwz akxa akxb akxc akxd akxe akxf akxg
+akxh akxi akxj akxk akxl akxm akxn akxo akxp akxq akxr akxs akxt akxu akxv
+akxw akxx akxy akxz akya akyb akyc akyd akye akyf akyg akyh akyi akyj akyk
+akyl akym akyn akyo akyp akyq akyr akys akyt akyu akyv akyw akyx akyy akyz
+akza akzb akzc akzd akze akzf akzg akzh akzi akzj akzk akzl akzm akzn akzo
+akzp akzq akzr akzs akzt akzu akzv akzw akzx akzy akzz alaa alab alac alad
+alae alaf alag alah alai alaj alak alal alam alan alao alap alaq alar alas
+alat alau alav alaw alax alay alaz alba albb albc albd albe albf albg albh
+albi albj albk albl albm albn albo albp albq albr albs albt albu albv albw
--- /dev/null
+aaaa aaab aaac aaad aaae aaaf aaag aaah aaai aaaj aaak aaal aaam aaan aaao
+aaap aaaq aaar aaas aaat aaau aaav aaaw aaax aaay aaaz aaba aabb aabc aabd
+aabe aabf aabg aabh aabi aabj aabk aabl aabm aabn aabo aabp aabq aabr aabs
+aabt aabu aabv aabw aabx aaby aabz aaca aacb aacc aacd aace aacf aacg aach
+aaci aacj aack aacl aacm aacn aaco aacp aacq aacr aacs aact aacu aacv aacw
+aacx aacy aacz aada aadb aadc aadd aade aadf aadg aadh aadi aadj aadk aadl
+aadm aadn aado aadp aadq aadr aads aadt aadu aadv aadw aadx aady aadz aaea
+aaeb aaec aaed aaee aaef aaeg aaeh aaei aaej aaek aael aaem aaen aaeo aaep
+aaeq aaer aaes aaet aaeu aaev aaew aaex aaey aaez aafa aafb aafc aafd aafe
+aaff aafg aafh aafi aafj aafk aafl aafm aafn aafo aafp aafq aafr aafs aaft
+aafu aafv aafw aafx aafy aafz aaga aagb aagc aagd aage aagf aagg aagh aagi
+aagj aagk aagl aagm aagn aago aagp aagq aagr aags aagt aagu aagv aagw aagx
+aagy aagz aaha aahb aahc aahd aahe aahf aahg aahh aahi aahj aahk aahl aahm
+aahn aaho aahp aahq aahr aahs aaht aahu aahv aahw aahx aahy aahz aaia aaib
+aaic aaid aaie aaif aaig aaih aaii aaij aaik aail aaim aain aaio aaip aaiq
+aair aais aait aaiu aaiv aaiw aaix aaiy aaiz aaja aajb aajc aajd aaje aajf
+aajg aajh aaji aajj aajk aajl aajm aajn aajo aajp aajq aajr aajs aajt aaju
+aajv aajw aajx aajy aajz aaka aakb aakc aakd aake aakf aakg aakh aaki aakj
+aakk aakl aakm aakn aako aakp aakq aakr aaks aakt aaku aakv aakw aakx aaky
+aakz aala aalb aalc aald aale aalf aalg aalh aali aalj aalk aall aalm aaln
+aalo aalp aalq aalr aals aalt aalu aalv aalw aalx aaly aalz aama aamb aamc
+aamd aame aamf aamg aamh aami aamj aamk aaml aamm aamn aamo aamp aamq aamr
+aams aamt aamu aamv aamw aamx aamy aamz aana aanb aanc aand aane aanf aang
+aanh aani aanj aank aanl aanm aann aano aanp aanq aanr aans aant aanu aanv
+aanw aanx aany aanz aaoa aaob aaoc aaod aaoe aaof aaog aaoh aaoi aaoj aaok
+aaol aaom aaon aaoo aaop aaoq aaor aaos aaot aaou aaov aaow aaox aaoy aaoz
+aapa aapb aapc aapd aape aapf aapg aaph aapi aapj aapk aapl aapm aapn aapo
+aapp aapq aapr aaps aapt aapu aapv aapw aapx aapy aapz aaqa aaqb aaqc aaqd
+aaqe aaqf aaqg aaqh aaqi aaqj aaqk aaql aaqm aaqn aaqo aaqp aaqq aaqr aaqs
+aaqt aaqu aaqv aaqw aaqx aaqy aaqz aara aarb aarc aard aare aarf aarg aarh
+aari aarj aark aarl aarm aarn aaro aarp aarq aarr aars aart aaru aarv aarw
+aarx aary aarz aasa aasb aasc aasd aase aasf aasg aash aasi aasj aask aasl
+aasm aasn aaso aasp aasq aasr aass aast aasu aasv aasw aasx aasy aasz aata
+aatb aatc aatd aate aatf aatg aath aati aatj aatk aatl aatm aatn aato aatp
+aatq aatr aats aatt aatu aatv aatw aatx aaty aatz aaua aaub aauc aaud aaue
+aauf aaug aauh aaui aauj aauk aaul aaum aaun aauo aaup aauq aaur aaus aaut
+aauu aauv aauw aaux aauy aauz aava aavb aavc aavd aave aavf aavg aavh aavi
+aavj aavk aavl aavm aavn aavo aavp aavq aavr aavs aavt aavu aavv aavw aavx
+aavy aavz aawa aawb aawc aawd aawe aawf aawg aawh aawi aawj aawk aawl aawm
+aawn aawo aawp aawq aawr aaws aawt aawu aawv aaww aawx aawy aawz aaxa aaxb
+aaxc aaxd aaxe aaxf aaxg aaxh aaxi aaxj aaxk aaxl aaxm aaxn aaxo aaxp aaxq
+aaxr aaxs aaxt aaxu aaxv aaxw aaxx aaxy aaxz aaya aayb aayc aayd aaye aayf
+aayg aayh aayi aayj aayk aayl aaym aayn aayo aayp aayq aayr aays aayt aayu
+aayv aayw aayx aayy aayz aaza aazb aazc aazd aaze aazf aazg aazh aazi aazj
+aazk aazl aazm aazn aazo aazp aazq aazr aazs aazt aazu aazv aazw aazx aazy
+aazz abaa abab abac abad abae abaf abag abah abai abaj abak abal abam aban
+abao abap abaq abar abas abat abau abav abaw abax abay abaz abba abbb abbc
+abbd abbe abbf abbg abbh abbi abbj abbk abbl abbm abbn abbo abbp abbq abbr
+abbs abbt abbu abbv abbw abbx abby abbz abca abcb abcc abcd abce abcf abcg
+abch abci abcj abck abcl abcm abcn abco abcp abcq abcr abcs abct abcu abcv
+abcw abcx abcy abcz abda abdb abdc abdd abde abdf abdg abdh abdi abdj abdk
+abdl abdm abdn abdo abdp abdq abdr abds abdt abdu abdv abdw abdx abdy abdz
+abea abeb abec abed abee abef abeg abeh abei abej abek abel abem aben abeo
+abep abeq aber abes abet abeu abev abew abex abey abez abfa abfb abfc abfd
+abfe abff abfg abfh abfi abfj abfk abfl abfm abfn abfo abfp abfq abfr abfs
+abft abfu abfv abfw abfx abfy abfz abga abgb abgc abgd abge abgf abgg abgh
+abgi abgj abgk abgl abgm abgn abgo abgp abgq abgr abgs abgt abgu abgv abgw
+abgx abgy abgz abha abhb abhc abhd abhe abhf abhg abhh abhi abhj abhk abhl
+abhm abhn abho abhp abhq abhr abhs abht abhu abhv abhw abhx abhy abhz abia
+abib abic abid abie abif abig abih abii abij abik abil abim abin abio abip
+abiq abir abis abit abiu abiv abiw abix abiy abiz abja abjb abjc abjd abje
+abjf abjg abjh abji abjj abjk abjl abjm abjn abjo abjp abjq abjr abjs abjt
+abju abjv abjw abjx abjy abjz abka abkb abkc abkd abke abkf abkg abkh abki
+abkj abkk abkl abkm abkn abko abkp abkq abkr abks abkt abku abkv abkw abkx
+abky abkz abla ablb ablc abld able ablf ablg ablh abli ablj ablk abll ablm
+abln ablo ablp ablq ablr abls ablt ablu ablv ablw ablx ably ablz abma abmb
+abmc abmd abme abmf abmg abmh abmi abmj abmk abml abmm abmn abmo abmp abmq
+abmr abms abmt abmu abmv abmw abmx abmy abmz abna abnb abnc abnd abne abnf
+abng abnh abni abnj abnk abnl abnm abnn abno abnp abnq abnr abns abnt abnu
+abnv abnw abnx abny abnz aboa abob aboc abod aboe abof abog aboh aboi aboj
+abok abol abom abon aboo abop aboq abor abos abot abou abov abow abox aboy
+aboz abpa abpb abpc abpd abpe abpf abpg abph abpi abpj abpk abpl abpm abpn
+abpo abpp abpq abpr abps abpt abpu abpv abpw abpx abpy abpz abqa abqb abqc
+abqd abqe abqf abqg abqh abqi abqj abqk abql abqm abqn abqo abqp abqq abqr
+abqs abqt abqu abqv abqw abqx abqy abqz abra abrb abrc abrd abre abrf abrg
+abrh abri abrj abrk abrl abrm abrn abro abrp abrq abrr abrs abrt abru abrv
+abrw abrx abry abrz absa absb absc absd abse absf absg absh absi absj absk
+absl absm absn abso absp absq absr abss abst absu absv absw absx absy absz
+abta abtb abtc abtd abte abtf abtg abth abti abtj abtk abtl abtm abtn abto
+abtp abtq abtr abts abtt abtu abtv abtw abtx abty abtz abua abub abuc abud
+abue abuf abug abuh abui abuj abuk abul abum abun abuo abup abuq abur abus
+abut abuu abuv abuw abux abuy abuz abva abvb abvc abvd abve abvf abvg abvh
+abvi abvj abvk abvl abvm abvn abvo abvp abvq abvr abvs abvt abvu abvv abvw
+abvx abvy abvz abwa abwb abwc abwd abwe abwf abwg abwh abwi abwj abwk abwl
+abwm abwn abwo abwp abwq abwr abws abwt abwu abwv abww abwx abwy abwz abxa
+abxb abxc abxd abxe abxf abxg abxh abxi abxj abxk abxl abxm abxn abxo abxp
+abxq abxr abxs abxt abxu abxv abxw abxx abxy abxz abya abyb abyc abyd abye
+abyf abyg abyh abyi abyj abyk abyl abym abyn abyo abyp abyq abyr abys abyt
+abyu abyv abyw abyx abyy abyz abza abzb abzc abzd abze abzf abzg abzh abzi
+abzj abzk abzl abzm abzn abzo abzp abzq abzr abzs abzt abzu abzv abzw abzx
+abzy abzz acaa acab acac acad acae acaf acag acah acai acaj acak acal acam
+acan acao acap acaq acar acas acat acau acav acaw acax acay acaz acba acbb
+acbc acbd acbe acbf acbg acbh acbi acbj acbk acbl acbm acbn acbo acbp acbq
+acbr acbs acbt acbu acbv acbw acbx acby acbz acca accb accc accd acce accf
+accg acch acci accj acck accl accm accn acco accp accq accr accs acct accu
+accv accw accx accy accz acda acdb acdc acdd acde acdf acdg acdh acdi acdj
+acdk acdl acdm acdn acdo acdp acdq acdr acds acdt acdu acdv acdw acdx acdy
+acdz acea aceb acec aced acee acef aceg aceh acei acej acek acel acem acen
+aceo acep aceq acer aces acet aceu acev acew acex acey acez acfa acfb acfc
+acfd acfe acff acfg acfh acfi acfj acfk acfl acfm acfn acfo acfp acfq acfr
+acfs acft acfu acfv acfw acfx acfy acfz acga acgb acgc acgd acge acgf acgg
+acgh acgi acgj acgk acgl acgm acgn acgo acgp acgq acgr acgs acgt acgu acgv
+acgw acgx acgy acgz acha achb achc achd ache achf achg achh achi achj achk
+achl achm achn acho achp achq achr achs acht achu achv achw achx achy achz
+acia acib acic acid acie acif acig acih acii acij acik acil acim acin acio
+acip aciq acir acis acit aciu aciv aciw acix aciy aciz acja acjb acjc acjd
+acje acjf acjg acjh acji acjj acjk acjl acjm acjn acjo acjp acjq acjr acjs
+acjt acju acjv acjw acjx acjy acjz acka ackb ackc ackd acke ackf ackg ackh
+acki ackj ackk ackl ackm ackn acko ackp ackq ackr acks ackt acku ackv ackw
+ackx acky ackz acla aclb aclc acld acle aclf aclg aclh acli aclj aclk acll
+aclm acln aclo aclp aclq aclr acls aclt aclu aclv aclw aclx acly aclz acma
+acmb acmc acmd acme acmf acmg acmh acmi acmj acmk acml acmm acmn acmo acmp
+acmq acmr acms acmt acmu acmv acmw acmx acmy acmz acna acnb acnc acnd acne
+acnf acng acnh acni acnj acnk acnl acnm acnn acno acnp acnq acnr acns acnt
+acnu acnv acnw acnx acny acnz acoa acob acoc acod acoe acof acog acoh acoi
+acoj acok acol acom acon acoo acop acoq acor acos acot acou acov acow acox
+acoy acoz acpa acpb acpc acpd acpe acpf acpg acph acpi acpj acpk acpl acpm
+acpn acpo acpp acpq acpr acps acpt acpu acpv acpw acpx acpy acpz acqa acqb
+acqc acqd acqe acqf acqg acqh acqi acqj acqk acql acqm acqn acqo acqp acqq
+acqr acqs acqt acqu acqv acqw acqx acqy acqz acra acrb acrc acrd acre acrf
+acrg acrh acri acrj acrk acrl acrm acrn acro acrp acrq acrr acrs acrt acru
+acrv acrw acrx acry acrz acsa acsb acsc acsd acse acsf acsg acsh acsi acsj
+acsk acsl acsm acsn acso acsp acsq acsr acss acst acsu acsv acsw acsx acsy
+acsz acta actb actc actd acte actf actg acth acti actj actk actl actm actn
+acto actp actq actr acts actt actu actv actw actx acty actz acua acub acuc
+acud acue acuf acug acuh acui acuj acuk acul acum acun acuo acup acuq acur
+acus acut acuu acuv acuw acux acuy acuz acva acvb acvc acvd acve acvf acvg
+acvh acvi acvj acvk acvl acvm acvn acvo acvp acvq acvr acvs acvt acvu acvv
+acvw acvx acvy acvz acwa acwb acwc acwd acwe acwf acwg acwh acwi acwj acwk
+acwl acwm acwn acwo acwp acwq acwr acws acwt acwu acwv acww acwx acwy acwz
+acxa acxb acxc acxd acxe acxf acxg acxh acxi acxj acxk acxl acxm acxn acxo
+acxp acxq acxr acxs acxt acxu acxv acxw acxx acxy acxz acya acyb acyc acyd
+acye acyf acyg acyh acyi acyj acyk acyl acym acyn acyo acyp acyq acyr acys
+acyt acyu acyv acyw acyx acyy acyz acza aczb aczc aczd acze aczf aczg aczh
+aczi aczj aczk aczl aczm aczn aczo aczp aczq aczr aczs aczt aczu aczv aczw
+aczx aczy aczz adaa adab adac adad adae adaf adag adah adai adaj adak adal
+adam adan adao adap adaq adar adas adat adau adav adaw adax aday adaz adba
+adbb adbc adbd adbe adbf adbg adbh adbi adbj adbk adbl adbm adbn adbo adbp
+adbq adbr adbs adbt adbu adbv adbw adbx adby adbz adca adcb adcc adcd adce
+adcf adcg adch adci adcj adck adcl adcm adcn adco adcp adcq adcr adcs adct
+adcu adcv adcw adcx adcy adcz adda addb addc addd adde addf addg addh addi
+addj addk addl addm addn addo addp addq addr adds addt addu addv addw addx
+addy addz adea adeb adec aded adee adef adeg adeh adei adej adek adel adem
+aden adeo adep adeq ader ades adet adeu adev adew adex adey adez adfa adfb
+adfc adfd adfe adff adfg adfh adfi adfj adfk adfl adfm adfn adfo adfp adfq
+adfr adfs adft adfu adfv adfw adfx adfy adfz adga adgb adgc adgd adge adgf
+adgg adgh adgi adgj adgk adgl adgm adgn adgo adgp adgq adgr adgs adgt adgu
+adgv adgw adgx adgy adgz adha adhb adhc adhd adhe adhf adhg adhh adhi adhj
+adhk adhl adhm adhn adho adhp adhq adhr adhs adht adhu adhv adhw adhx adhy
+adhz adia adib adic adid adie adif adig adih adii adij adik adil adim adin
+adio adip adiq adir adis adit adiu adiv adiw adix adiy adiz adja adjb adjc
+adjd adje adjf adjg adjh adji adjj adjk adjl adjm adjn adjo adjp adjq adjr
+adjs adjt adju adjv adjw adjx adjy adjz adka adkb adkc adkd adke adkf adkg
+adkh adki adkj adkk adkl adkm adkn adko adkp adkq adkr adks adkt adku adkv
+adkw adkx adky adkz adla adlb adlc adld adle adlf adlg adlh adli adlj adlk
+adll adlm adln adlo adlp adlq adlr adls adlt adlu adlv adlw adlx adly adlz
+adma admb admc admd adme admf admg admh admi admj admk adml admm admn admo
+admp admq admr adms admt admu admv admw admx admy admz adna adnb adnc adnd
+adne adnf adng adnh adni adnj adnk adnl adnm adnn adno adnp adnq adnr adns
+adnt adnu adnv adnw adnx adny adnz adoa adob adoc adod adoe adof adog adoh
+adoi adoj adok adol adom adon adoo adop adoq ador ados adot adou adov adow
+adox adoy adoz adpa adpb adpc adpd adpe adpf adpg adph adpi adpj adpk adpl
+adpm adpn adpo adpp adpq adpr adps adpt adpu adpv adpw adpx adpy adpz adqa
+adqb adqc adqd adqe adqf adqg adqh adqi adqj adqk adql adqm adqn adqo adqp
+adqq adqr adqs adqt adqu adqv adqw adqx adqy adqz adra adrb adrc adrd adre
+adrf adrg adrh adri adrj adrk adrl adrm adrn adro adrp adrq adrr adrs adrt
+adru adrv adrw adrx adry adrz adsa adsb adsc adsd adse adsf adsg adsh adsi
+adsj adsk adsl adsm adsn adso adsp adsq adsr adss adst adsu adsv adsw adsx
+adsy adsz adta adtb adtc adtd adte adtf adtg adth adti adtj adtk adtl adtm
+adtn adto adtp adtq adtr adts adtt adtu adtv adtw adtx adty adtz adua adub
+aduc adud adue aduf adug aduh adui aduj aduk adul adum adun aduo adup aduq
+adur adus adut aduu aduv aduw adux aduy aduz adva advb advc advd adve advf
+advg advh advi advj advk advl advm advn advo advp advq advr advs advt advu
+advv advw advx advy advz adwa adwb adwc adwd adwe adwf adwg adwh adwi adwj
+adwk adwl adwm adwn adwo adwp adwq adwr adws adwt adwu adwv adww adwx adwy
+adwz adxa adxb adxc adxd adxe adxf adxg adxh adxi adxj adxk adxl adxm adxn
+adxo adxp adxq adxr adxs adxt adxu adxv adxw adxx adxy adxz adya adyb adyc
+adyd adye adyf adyg adyh adyi adyj adyk adyl adym adyn adyo adyp adyq adyr
+adys adyt adyu adyv adyw adyx adyy adyz adza adzb adzc adzd adze adzf adzg
+adzh adzi adzj adzk adzl adzm adzn adzo adzp adzq adzr adzs adzt adzu adzv
+adzw adzx adzy adzz aeaa aeab aeac aead aeae aeaf aeag aeah aeai aeaj aeak
+aeal aeam aean aeao aeap aeaq aear aeas aeat aeau aeav aeaw aeax aeay aeaz
+aeba aebb aebc aebd aebe aebf aebg aebh aebi aebj aebk aebl aebm aebn aebo
+aebp aebq aebr aebs aebt aebu aebv aebw aebx aeby aebz aeca aecb aecc aecd
+aece aecf aecg aech aeci aecj aeck aecl aecm aecn aeco aecp aecq aecr aecs
+aect aecu aecv aecw aecx aecy aecz aeda aedb aedc aedd aede aedf aedg aedh
+aedi aedj aedk aedl aedm aedn aedo aedp aedq aedr aeds aedt aedu aedv aedw
+aedx aedy aedz aeea aeeb aeec aeed aeee aeef aeeg aeeh aeei aeej aeek aeel
+aeem aeen aeeo aeep aeeq aeer aees aeet aeeu aeev aeew aeex aeey aeez aefa
+aefb aefc aefd aefe aeff aefg aefh aefi aefj aefk aefl aefm aefn aefo aefp
+aefq aefr aefs aeft aefu aefv aefw aefx aefy aefz aega aegb aegc aegd aege
+aegf aegg aegh aegi aegj aegk aegl aegm aegn aego aegp aegq aegr aegs aegt
+aegu aegv aegw aegx aegy aegz aeha aehb aehc aehd aehe aehf aehg aehh aehi
+aehj aehk aehl aehm aehn aeho aehp aehq aehr aehs aeht aehu aehv aehw aehx
+aehy aehz aeia aeib aeic aeid aeie aeif aeig aeih aeii aeij aeik aeil aeim
+aein aeio aeip aeiq aeir aeis aeit aeiu aeiv aeiw aeix aeiy aeiz aeja aejb
+aejc aejd aeje aejf aejg aejh aeji aejj aejk aejl aejm aejn aejo aejp aejq
+aejr aejs aejt aeju aejv aejw aejx aejy aejz aeka aekb aekc aekd aeke aekf
+aekg aekh aeki aekj aekk aekl aekm aekn aeko aekp aekq aekr aeks aekt aeku
+aekv aekw aekx aeky aekz aela aelb aelc aeld aele aelf aelg aelh aeli aelj
+aelk aell aelm aeln aelo aelp aelq aelr aels aelt aelu aelv aelw aelx aely
+aelz aema aemb aemc aemd aeme aemf aemg aemh aemi aemj aemk aeml aemm aemn
+aemo aemp aemq aemr aems aemt aemu aemv aemw aemx aemy aemz aena aenb aenc
+aend aene aenf aeng aenh aeni aenj aenk aenl aenm aenn aeno aenp aenq aenr
+aens aent aenu aenv aenw aenx aeny aenz aeoa aeob aeoc aeod aeoe aeof aeog
+aeoh aeoi aeoj aeok aeol aeom aeon aeoo aeop aeoq aeor aeos aeot aeou aeov
+aeow aeox aeoy aeoz aepa aepb aepc aepd aepe aepf aepg aeph aepi aepj aepk
+aepl aepm aepn aepo aepp aepq aepr aeps aept aepu aepv aepw aepx aepy aepz
+aeqa aeqb aeqc aeqd aeqe aeqf aeqg aeqh aeqi aeqj aeqk aeql aeqm aeqn aeqo
+aeqp aeqq aeqr aeqs aeqt aequ aeqv aeqw aeqx aeqy aeqz aera aerb aerc aerd
+aere aerf aerg aerh aeri aerj aerk aerl aerm aern aero aerp aerq aerr aers
+aert aeru aerv aerw aerx aery aerz aesa aesb aesc aesd aese aesf aesg aesh
+aesi aesj aesk aesl aesm aesn aeso aesp aesq aesr aess aest aesu aesv aesw
+aesx aesy aesz aeta aetb aetc aetd aete aetf aetg aeth aeti aetj aetk aetl
+aetm aetn aeto aetp aetq aetr aets aett aetu aetv aetw aetx aety aetz aeua
+aeub aeuc aeud aeue aeuf aeug aeuh aeui aeuj aeuk aeul aeum aeun aeuo aeup
+aeuq aeur aeus aeut aeuu aeuv aeuw aeux aeuy aeuz aeva aevb aevc aevd aeve
+aevf aevg aevh aevi aevj aevk aevl aevm aevn aevo aevp aevq aevr aevs aevt
+aevu aevv aevw aevx aevy aevz aewa aewb aewc aewd aewe aewf aewg aewh aewi
+aewj aewk aewl aewm aewn aewo aewp aewq aewr aews aewt aewu aewv aeww aewx
+aewy aewz aexa aexb aexc aexd aexe aexf aexg aexh aexi aexj aexk aexl aexm
+aexn aexo aexp aexq aexr aexs aext aexu aexv aexw aexx aexy aexz aeya aeyb
+aeyc aeyd aeye aeyf aeyg aeyh aeyi aeyj aeyk aeyl aeym aeyn aeyo aeyp aeyq
+aeyr aeys aeyt aeyu aeyv aeyw aeyx aeyy aeyz aeza aezb aezc aezd aeze aezf
+aezg aezh aezi aezj aezk aezl aezm aezn aezo aezp aezq aezr aezs aezt aezu
+aezv aezw aezx aezy aezz afaa afab afac afad afae afaf afag afah afai afaj
+afak afal afam afan afao afap afaq afar afas afat afau afav afaw afax afay
+afaz afba afbb afbc afbd afbe afbf afbg afbh afbi afbj afbk afbl afbm afbn
+afbo afbp afbq afbr afbs afbt afbu afbv afbw afbx afby afbz afca afcb afcc
+afcd afce afcf afcg afch afci afcj afck afcl afcm afcn afco afcp afcq afcr
+afcs afct afcu afcv afcw afcx afcy afcz afda afdb afdc afdd afde afdf afdg
+afdh afdi afdj afdk afdl afdm afdn afdo afdp afdq afdr afds afdt afdu afdv
+afdw afdx afdy afdz afea afeb afec afed afee afef afeg afeh afei afej afek
+afel afem afen afeo afep afeq afer afes afet afeu afev afew afex afey afez
+affa affb affc affd affe afff affg affh affi affj affk affl affm affn affo
+affp affq affr affs afft affu affv affw affx affy affz afga afgb afgc afgd
+afge afgf afgg afgh afgi afgj afgk afgl afgm afgn afgo afgp afgq afgr afgs
+afgt afgu afgv afgw afgx afgy afgz afha afhb afhc afhd afhe afhf afhg afhh
+afhi afhj afhk afhl afhm afhn afho afhp afhq afhr afhs afht afhu afhv afhw
+afhx afhy afhz afia afib afic afid afie afif afig afih afii afij afik afil
+afim afin afio afip afiq afir afis afit afiu afiv afiw afix afiy afiz afja
+afjb afjc afjd afje afjf afjg afjh afji afjj afjk afjl afjm afjn afjo afjp
+afjq afjr afjs afjt afju afjv afjw afjx afjy afjz afka afkb afkc afkd afke
+afkf afkg afkh afki afkj afkk afkl afkm afkn afko afkp afkq afkr afks afkt
+afku afkv afkw afkx afky afkz afla aflb aflc afld afle aflf aflg aflh afli
+aflj aflk afll aflm afln aflo aflp aflq aflr afls aflt aflu aflv aflw aflx
+afly aflz afma afmb afmc afmd afme afmf afmg afmh afmi afmj afmk afml afmm
+afmn afmo afmp afmq afmr afms afmt afmu afmv afmw afmx afmy afmz afna afnb
+afnc afnd afne afnf afng afnh afni afnj afnk afnl afnm afnn afno afnp afnq
+afnr afns afnt afnu afnv afnw afnx afny afnz afoa afob afoc afod afoe afof
+afog afoh afoi afoj afok afol afom afon afoo afop afoq afor afos afot afou
+afov afow afox afoy afoz afpa afpb afpc afpd afpe afpf afpg afph afpi afpj
+afpk afpl afpm afpn afpo afpp afpq afpr afps afpt afpu afpv afpw afpx afpy
+afpz afqa afqb afqc afqd afqe afqf afqg afqh afqi afqj afqk afql afqm afqn
+afqo afqp afqq afqr afqs afqt afqu afqv afqw afqx afqy afqz afra afrb afrc
+afrd afre afrf afrg afrh afri afrj afrk afrl afrm afrn afro afrp afrq afrr
+afrs afrt afru afrv afrw afrx afry afrz afsa afsb afsc afsd afse afsf afsg
+afsh afsi afsj afsk afsl afsm afsn afso afsp afsq afsr afss afst afsu afsv
+afsw afsx afsy afsz afta aftb aftc aftd afte aftf aftg afth afti aftj aftk
+aftl aftm aftn afto aftp aftq aftr afts aftt aftu aftv aftw aftx afty aftz
+afua afub afuc afud afue afuf afug afuh afui afuj afuk aful afum afun afuo
+afup afuq afur afus afut afuu afuv afuw afux afuy afuz afva afvb afvc afvd
+afve afvf afvg afvh afvi afvj afvk afvl afvm afvn afvo afvp afvq afvr afvs
+afvt afvu afvv afvw afvx afvy afvz afwa afwb afwc afwd afwe afwf afwg afwh
+afwi afwj afwk afwl afwm afwn afwo afwp afwq afwr afws afwt afwu afwv afww
+afwx afwy afwz afxa afxb afxc afxd afxe afxf afxg afxh afxi afxj afxk afxl
+afxm afxn afxo afxp afxq afxr afxs afxt afxu afxv afxw afxx afxy afxz afya
+afyb afyc afyd afye afyf afyg afyh afyi afyj afyk afyl afym afyn afyo afyp
+afyq afyr afys afyt afyu afyv afyw afyx afyy afyz afza afzb afzc afzd afze
+afzf afzg afzh afzi afzj afzk afzl afzm afzn afzo afzp afzq afzr afzs afzt
+afzu afzv afzw afzx afzy afzz agaa agab agac agad agae agaf agag agah agai
+agaj agak agal agam agan agao agap agaq agar agas agat agau agav agaw agax
+agay agaz agba agbb agbc agbd agbe agbf agbg agbh agbi agbj agbk agbl agbm
+agbn agbo agbp agbq agbr agbs agbt agbu agbv agbw agbx agby agbz agca agcb
+agcc agcd agce agcf agcg agch agci agcj agck agcl agcm agcn agco agcp agcq
+agcr agcs agct agcu agcv agcw agcx agcy agcz agda agdb agdc agdd agde agdf
+agdg agdh agdi agdj agdk agdl agdm agdn agdo agdp agdq agdr agds agdt agdu
+agdv agdw agdx agdy agdz agea ageb agec aged agee agef ageg ageh agei agej
+agek agel agem agen ageo agep ageq ager ages aget ageu agev agew agex agey
+agez agfa agfb agfc agfd agfe agff agfg agfh agfi agfj agfk agfl agfm agfn
+agfo agfp agfq agfr agfs agft agfu agfv agfw agfx agfy agfz agga aggb aggc
+aggd agge aggf aggg aggh aggi aggj aggk aggl aggm aggn aggo aggp aggq aggr
+aggs aggt aggu aggv aggw aggx aggy aggz agha aghb aghc aghd aghe aghf aghg
+aghh aghi aghj aghk aghl aghm aghn agho aghp aghq aghr aghs aght aghu aghv
+aghw aghx aghy aghz agia agib agic agid agie agif agig agih agii agij agik
+agil agim agin agio agip agiq agir agis agit agiu agiv agiw agix agiy agiz
+agja agjb agjc agjd agje agjf agjg agjh agji agjj agjk agjl agjm agjn agjo
+agjp agjq agjr agjs agjt agju agjv agjw agjx agjy agjz agka agkb agkc agkd
+agke agkf agkg agkh agki agkj agkk agkl agkm agkn agko agkp agkq agkr agks
+agkt agku agkv agkw agkx agky agkz agla aglb aglc agld agle aglf aglg aglh
+agli aglj aglk agll aglm agln aglo aglp aglq aglr agls aglt aglu aglv aglw
+aglx agly aglz agma agmb agmc agmd agme agmf agmg agmh agmi agmj agmk agml
+agmm agmn agmo agmp agmq agmr agms agmt agmu agmv agmw agmx agmy agmz agna
+agnb agnc agnd agne agnf agng agnh agni agnj agnk agnl agnm agnn agno agnp
+agnq agnr agns agnt agnu agnv agnw agnx agny agnz agoa agob agoc agod agoe
+agof agog agoh agoi agoj agok agol agom agon agoo agop agoq agor agos agot
+agou agov agow agox agoy agoz agpa agpb agpc agpd agpe agpf agpg agph agpi
+agpj agpk agpl agpm agpn agpo agpp agpq agpr agps agpt agpu agpv agpw agpx
+agpy agpz agqa agqb agqc agqd agqe agqf agqg agqh agqi agqj agqk agql agqm
+agqn agqo agqp agqq agqr agqs agqt agqu agqv agqw agqx agqy agqz agra agrb
+agrc agrd agre agrf agrg agrh agri agrj agrk agrl agrm agrn agro agrp agrq
+agrr agrs agrt agru agrv agrw agrx agry agrz agsa agsb agsc agsd agse agsf
+agsg agsh agsi agsj agsk agsl agsm agsn agso agsp agsq agsr agss agst agsu
+agsv agsw agsx agsy agsz agta agtb agtc agtd agte agtf agtg agth agti agtj
+agtk agtl agtm agtn agto agtp agtq agtr agts agtt agtu agtv agtw agtx agty
+agtz agua agub aguc agud ague aguf agug aguh agui aguj aguk agul agum agun
+aguo agup aguq agur agus agut aguu aguv aguw agux aguy aguz agva agvb agvc
+agvd agve agvf agvg agvh agvi agvj agvk agvl agvm agvn agvo agvp agvq agvr
+agvs agvt agvu agvv agvw agvx agvy agvz agwa agwb agwc agwd agwe agwf agwg
+agwh agwi agwj agwk agwl agwm agwn agwo agwp agwq agwr agws agwt agwu agwv
+agww agwx agwy agwz agxa agxb agxc agxd agxe agxf agxg agxh agxi agxj agxk
+agxl agxm agxn agxo agxp agxq agxr agxs agxt agxu agxv agxw agxx agxy agxz
+agya agyb agyc agyd agye agyf agyg agyh agyi agyj agyk agyl agym agyn agyo
+agyp agyq agyr agys agyt agyu agyv agyw agyx agyy agyz agza agzb agzc agzd
+agze agzf agzg agzh agzi agzj agzk agzl agzm agzn agzo agzp agzq agzr agzs
+agzt agzu agzv agzw agzx agzy agzz ahaa ahab ahac ahad ahae ahaf ahag ahah
+ahai ahaj ahak ahal aham ahan ahao ahap ahaq ahar ahas ahat ahau ahav ahaw
+ahax ahay ahaz ahba ahbb ahbc ahbd ahbe ahbf ahbg ahbh ahbi ahbj ahbk ahbl
+ahbm ahbn ahbo ahbp ahbq ahbr ahbs ahbt ahbu ahbv ahbw ahbx ahby ahbz ahca
+ahcb ahcc ahcd ahce ahcf ahcg ahch ahci ahcj ahck ahcl ahcm ahcn ahco ahcp
+ahcq ahcr ahcs ahct ahcu ahcv ahcw ahcx ahcy ahcz ahda ahdb ahdc ahdd ahde
+ahdf ahdg ahdh ahdi ahdj ahdk ahdl ahdm ahdn ahdo ahdp ahdq ahdr ahds ahdt
+ahdu ahdv ahdw ahdx ahdy ahdz ahea aheb ahec ahed ahee ahef aheg aheh ahei
+ahej ahek ahel ahem ahen aheo ahep aheq aher ahes ahet aheu ahev ahew ahex
+ahey ahez ahfa ahfb ahfc ahfd ahfe ahff ahfg ahfh ahfi ahfj ahfk ahfl ahfm
+ahfn ahfo ahfp ahfq ahfr ahfs ahft ahfu ahfv ahfw ahfx ahfy ahfz ahga ahgb
+ahgc ahgd ahge ahgf ahgg ahgh ahgi ahgj ahgk ahgl ahgm ahgn ahgo ahgp ahgq
+ahgr ahgs ahgt ahgu ahgv ahgw ahgx ahgy ahgz ahha ahhb ahhc ahhd ahhe ahhf
+ahhg ahhh ahhi ahhj ahhk ahhl ahhm ahhn ahho ahhp ahhq ahhr ahhs ahht ahhu
+ahhv ahhw ahhx ahhy ahhz ahia ahib ahic ahid ahie ahif ahig ahih ahii ahij
+ahik ahil ahim ahin ahio ahip ahiq ahir ahis ahit ahiu ahiv ahiw ahix ahiy
+ahiz ahja ahjb ahjc ahjd ahje ahjf ahjg ahjh ahji ahjj ahjk ahjl ahjm ahjn
+ahjo ahjp ahjq ahjr ahjs ahjt ahju ahjv ahjw ahjx ahjy ahjz ahka ahkb ahkc
+ahkd ahke ahkf ahkg ahkh ahki ahkj ahkk ahkl ahkm ahkn ahko ahkp ahkq ahkr
+ahks ahkt ahku ahkv ahkw ahkx ahky ahkz ahla ahlb ahlc ahld ahle ahlf ahlg
+ahlh ahli ahlj ahlk ahll ahlm ahln ahlo ahlp ahlq ahlr ahls ahlt ahlu ahlv
+ahlw ahlx ahly ahlz ahma ahmb ahmc ahmd ahme ahmf ahmg ahmh ahmi ahmj ahmk
+ahml ahmm ahmn ahmo ahmp ahmq ahmr ahms ahmt ahmu ahmv ahmw ahmx ahmy ahmz
+ahna ahnb ahnc ahnd ahne ahnf ahng ahnh ahni ahnj ahnk ahnl ahnm ahnn ahno
+ahnp ahnq ahnr ahns ahnt ahnu ahnv ahnw ahnx ahny ahnz ahoa ahob ahoc ahod
+ahoe ahof ahog ahoh ahoi ahoj ahok ahol ahom ahon ahoo ahop ahoq ahor ahos
+ahot ahou ahov ahow ahox ahoy ahoz ahpa ahpb ahpc ahpd ahpe ahpf ahpg ahph
+ahpi ahpj ahpk ahpl ahpm ahpn ahpo ahpp ahpq ahpr ahps ahpt ahpu ahpv ahpw
+ahpx ahpy ahpz ahqa ahqb ahqc ahqd ahqe ahqf ahqg ahqh ahqi ahqj ahqk ahql
+ahqm ahqn ahqo ahqp ahqq ahqr ahqs ahqt ahqu ahqv ahqw ahqx ahqy ahqz ahra
+ahrb ahrc ahrd ahre ahrf ahrg ahrh ahri ahrj ahrk ahrl ahrm ahrn ahro ahrp
+ahrq ahrr ahrs ahrt ahru ahrv ahrw ahrx ahry ahrz ahsa ahsb ahsc ahsd ahse
+ahsf ahsg ahsh ahsi ahsj ahsk ahsl ahsm ahsn ahso ahsp ahsq ahsr ahss ahst
+ahsu ahsv ahsw ahsx ahsy ahsz ahta ahtb ahtc ahtd ahte ahtf ahtg ahth ahti
+ahtj ahtk ahtl ahtm ahtn ahto ahtp ahtq ahtr ahts ahtt ahtu ahtv ahtw ahtx
+ahty ahtz ahua ahub ahuc ahud ahue ahuf ahug ahuh ahui ahuj ahuk ahul ahum
+ahun ahuo ahup ahuq ahur ahus ahut ahuu ahuv ahuw ahux ahuy ahuz ahva ahvb
+ahvc ahvd ahve ahvf ahvg ahvh ahvi ahvj ahvk ahvl ahvm ahvn ahvo ahvp ahvq
+ahvr ahvs ahvt ahvu ahvv ahvw ahvx ahvy ahvz ahwa ahwb ahwc ahwd ahwe ahwf
+ahwg ahwh ahwi ahwj ahwk ahwl ahwm ahwn ahwo ahwp ahwq ahwr ahws ahwt ahwu
+ahwv ahww ahwx ahwy ahwz ahxa ahxb ahxc ahxd ahxe ahxf ahxg ahxh ahxi ahxj
+ahxk ahxl ahxm ahxn ahxo ahxp ahxq ahxr ahxs ahxt ahxu ahxv ahxw ahxx ahxy
+ahxz ahya ahyb ahyc ahyd ahye ahyf ahyg ahyh ahyi ahyj ahyk ahyl ahym ahyn
+ahyo ahyp ahyq ahyr ahys ahyt ahyu ahyv ahyw ahyx ahyy ahyz ahza ahzb ahzc
+ahzd ahze ahzf ahzg ahzh ahzi ahzj ahzk ahzl ahzm ahzn ahzo ahzp ahzq ahzr
+ahzs ahzt ahzu ahzv ahzw ahzx ahzy ahzz aiaa aiab aiac aiad aiae aiaf aiag
+aiah aiai aiaj aiak aial aiam aian aiao aiap aiaq aiar aias aiat aiau aiav
+aiaw aiax aiay aiaz aiba aibb aibc aibd aibe aibf aibg aibh aibi aibj aibk
+aibl aibm aibn aibo aibp aibq aibr aibs aibt aibu aibv aibw aibx aiby aibz
+aica aicb aicc aicd aice aicf aicg aich aici aicj aick aicl aicm aicn aico
+aicp aicq aicr aics aict aicu aicv aicw aicx aicy aicz aida aidb aidc aidd
+aide aidf aidg aidh aidi aidj aidk aidl aidm aidn aido aidp aidq aidr aids
+aidt aidu aidv aidw aidx aidy aidz aiea aieb aiec aied aiee aief aieg aieh
+aiei aiej aiek aiel aiem aien aieo aiep aieq aier aies aiet aieu aiev aiew
+aiex aiey aiez aifa aifb aifc aifd aife aiff aifg aifh aifi aifj aifk aifl
+aifm aifn aifo aifp aifq aifr aifs aift aifu aifv aifw aifx aify aifz aiga
+aigb aigc aigd aige aigf aigg aigh aigi aigj aigk aigl aigm aign aigo aigp
+aigq aigr aigs aigt aigu aigv aigw aigx aigy aigz aiha aihb aihc aihd aihe
+aihf aihg aihh aihi aihj aihk aihl aihm aihn aiho aihp aihq aihr aihs aiht
+aihu aihv aihw aihx aihy aihz aiia aiib aiic aiid aiie aiif aiig aiih aiii
+aiij aiik aiil aiim aiin aiio aiip aiiq aiir aiis aiit aiiu aiiv aiiw aiix
+aiiy aiiz aija aijb aijc aijd aije aijf aijg aijh aiji aijj aijk aijl aijm
+aijn aijo aijp aijq aijr aijs aijt aiju aijv aijw aijx aijy aijz aika aikb
+aikc aikd aike aikf aikg aikh aiki aikj aikk aikl aikm aikn aiko aikp aikq
+aikr aiks aikt aiku aikv aikw aikx aiky aikz aila ailb ailc aild aile ailf
+ailg ailh aili ailj ailk aill ailm ailn ailo ailp ailq ailr ails ailt ailu
+ailv ailw ailx aily ailz aima aimb aimc aimd aime aimf aimg aimh aimi aimj
+aimk aiml aimm aimn aimo aimp aimq aimr aims aimt aimu aimv aimw aimx aimy
+aimz aina ainb ainc aind aine ainf aing ainh aini ainj aink ainl ainm ainn
+aino ainp ainq ainr ains aint ainu ainv ainw ainx ainy ainz aioa aiob aioc
+aiod aioe aiof aiog aioh aioi aioj aiok aiol aiom aion aioo aiop aioq aior
+aios aiot aiou aiov aiow aiox aioy aioz aipa aipb aipc aipd aipe aipf aipg
+aiph aipi aipj aipk aipl aipm aipn aipo aipp aipq aipr aips aipt aipu aipv
+aipw aipx aipy aipz aiqa aiqb aiqc aiqd aiqe aiqf aiqg aiqh aiqi aiqj aiqk
+aiql aiqm aiqn aiqo aiqp aiqq aiqr aiqs aiqt aiqu aiqv aiqw aiqx aiqy aiqz
+aira airb airc aird aire airf airg airh airi airj airk airl airm airn airo
+airp airq airr airs airt airu airv airw airx airy airz aisa aisb aisc aisd
+aise aisf aisg aish aisi aisj aisk aisl aism aisn aiso aisp aisq aisr aiss
+aist aisu aisv aisw aisx aisy aisz aita aitb aitc aitd aite aitf aitg aith
+aiti aitj aitk aitl aitm aitn aito aitp aitq aitr aits aitt aitu aitv aitw
+aitx aity aitz aiua aiub aiuc aiud aiue aiuf aiug aiuh aiui aiuj aiuk aiul
+aium aiun aiuo aiup aiuq aiur aius aiut aiuu aiuv aiuw aiux aiuy aiuz aiva
+aivb aivc aivd aive aivf aivg aivh aivi aivj aivk aivl aivm aivn aivo aivp
+aivq aivr aivs aivt aivu aivv aivw aivx aivy aivz aiwa aiwb aiwc aiwd aiwe
+aiwf aiwg aiwh aiwi aiwj aiwk aiwl aiwm aiwn aiwo aiwp aiwq aiwr aiws aiwt
+aiwu aiwv aiww aiwx aiwy aiwz aixa aixb aixc aixd aixe aixf aixg aixh aixi
+aixj aixk aixl aixm aixn aixo aixp aixq aixr aixs aixt aixu aixv aixw aixx
+aixy aixz aiya aiyb aiyc aiyd aiye aiyf aiyg aiyh aiyi aiyj aiyk aiyl aiym
+aiyn aiyo aiyp aiyq aiyr aiys aiyt aiyu aiyv aiyw aiyx aiyy aiyz aiza aizb
+aizc aizd aize aizf aizg aizh aizi aizj aizk aizl aizm aizn aizo aizp aizq
+aizr aizs aizt aizu aizv aizw aizx aizy aizz ajaa ajab ajac ajad ajae ajaf
+ajag ajah ajai ajaj ajak ajal ajam ajan ajao ajap ajaq ajar ajas ajat ajau
+ajav ajaw ajax ajay ajaz ajba ajbb ajbc ajbd ajbe ajbf ajbg ajbh ajbi ajbj
+ajbk ajbl ajbm ajbn ajbo ajbp ajbq ajbr ajbs ajbt ajbu ajbv ajbw ajbx ajby
+ajbz ajca ajcb ajcc ajcd ajce ajcf ajcg ajch ajci ajcj ajck ajcl ajcm ajcn
+ajco ajcp ajcq ajcr ajcs ajct ajcu ajcv ajcw ajcx ajcy ajcz ajda ajdb ajdc
+ajdd ajde ajdf ajdg ajdh ajdi ajdj ajdk ajdl ajdm ajdn ajdo ajdp ajdq ajdr
+ajds ajdt ajdu ajdv ajdw ajdx ajdy ajdz ajea ajeb ajec ajed ajee ajef ajeg
+ajeh ajei ajej ajek ajel ajem ajen ajeo ajep ajeq ajer ajes ajet ajeu ajev
+ajew ajex ajey ajez ajfa ajfb ajfc ajfd ajfe ajff ajfg ajfh ajfi ajfj ajfk
+ajfl ajfm ajfn ajfo ajfp ajfq ajfr ajfs ajft ajfu ajfv ajfw ajfx ajfy ajfz
+ajga ajgb ajgc ajgd ajge ajgf ajgg ajgh ajgi ajgj ajgk ajgl ajgm ajgn ajgo
+ajgp ajgq ajgr ajgs ajgt ajgu ajgv ajgw ajgx ajgy ajgz ajha ajhb ajhc ajhd
+ajhe ajhf ajhg ajhh ajhi ajhj ajhk ajhl ajhm ajhn ajho ajhp ajhq ajhr ajhs
+ajht ajhu ajhv ajhw ajhx ajhy ajhz ajia ajib ajic ajid ajie ajif ajig ajih
+ajii ajij ajik ajil ajim ajin ajio ajip ajiq ajir ajis ajit ajiu ajiv ajiw
+ajix ajiy ajiz ajja ajjb ajjc ajjd ajje ajjf ajjg ajjh ajji ajjj ajjk ajjl
+ajjm ajjn ajjo ajjp ajjq ajjr ajjs ajjt ajju ajjv ajjw ajjx ajjy ajjz ajka
+ajkb ajkc ajkd ajke ajkf ajkg ajkh ajki ajkj ajkk ajkl ajkm ajkn ajko ajkp
+ajkq ajkr ajks ajkt ajku ajkv ajkw ajkx ajky ajkz ajla ajlb ajlc ajld ajle
+ajlf ajlg ajlh ajli ajlj ajlk ajll ajlm ajln ajlo ajlp ajlq ajlr ajls ajlt
+ajlu ajlv ajlw ajlx ajly ajlz ajma ajmb ajmc ajmd ajme ajmf ajmg ajmh ajmi
+ajmj ajmk ajml ajmm ajmn ajmo ajmp ajmq ajmr ajms ajmt ajmu ajmv ajmw ajmx
+ajmy ajmz ajna ajnb ajnc ajnd ajne ajnf ajng ajnh ajni ajnj ajnk ajnl ajnm
+ajnn ajno ajnp ajnq ajnr ajns ajnt ajnu ajnv ajnw ajnx ajny ajnz ajoa ajob
+ajoc ajod ajoe ajof ajog ajoh ajoi ajoj ajok ajol ajom ajon ajoo ajop ajoq
+ajor ajos ajot ajou ajov ajow ajox ajoy ajoz ajpa ajpb ajpc ajpd ajpe ajpf
+ajpg ajph ajpi ajpj ajpk ajpl ajpm ajpn ajpo ajpp ajpq ajpr ajps ajpt ajpu
+ajpv ajpw ajpx ajpy ajpz ajqa ajqb ajqc ajqd ajqe ajqf ajqg ajqh ajqi ajqj
+ajqk ajql ajqm ajqn ajqo ajqp ajqq ajqr ajqs ajqt ajqu ajqv ajqw ajqx ajqy
+ajqz ajra ajrb ajrc ajrd ajre ajrf ajrg ajrh ajri ajrj ajrk ajrl ajrm ajrn
+ajro ajrp ajrq ajrr ajrs ajrt ajru ajrv ajrw ajrx ajry ajrz ajsa ajsb ajsc
+ajsd ajse ajsf ajsg ajsh ajsi ajsj ajsk ajsl ajsm ajsn ajso ajsp ajsq ajsr
+ajss ajst ajsu ajsv ajsw ajsx ajsy ajsz ajta ajtb ajtc ajtd ajte ajtf ajtg
+ajth ajti ajtj ajtk ajtl ajtm ajtn ajto ajtp ajtq ajtr ajts ajtt ajtu ajtv
+ajtw ajtx ajty ajtz ajua ajub ajuc ajud ajue ajuf ajug ajuh ajui ajuj ajuk
+ajul ajum ajun ajuo ajup ajuq ajur ajus ajut ajuu ajuv ajuw ajux ajuy ajuz
+ajva ajvb ajvc ajvd ajve ajvf ajvg ajvh ajvi ajvj ajvk ajvl ajvm ajvn ajvo
+ajvp ajvq ajvr ajvs ajvt ajvu ajvv ajvw ajvx ajvy ajvz ajwa ajwb ajwc ajwd
+ajwe ajwf ajwg ajwh ajwi ajwj ajwk ajwl ajwm ajwn ajwo ajwp ajwq ajwr ajws
+ajwt ajwu ajwv ajww ajwx ajwy ajwz ajxa ajxb ajxc ajxd ajxe ajxf ajxg ajxh
+ajxi ajxj ajxk ajxl ajxm ajxn ajxo ajxp ajxq ajxr ajxs ajxt ajxu ajxv ajxw
+ajxx ajxy ajxz ajya ajyb ajyc ajyd ajye ajyf ajyg ajyh ajyi ajyj ajyk ajyl
+ajym ajyn ajyo ajyp ajyq ajyr ajys ajyt ajyu ajyv ajyw ajyx ajyy ajyz ajza
+ajzb ajzc ajzd ajze ajzf ajzg ajzh ajzi ajzj ajzk ajzl ajzm ajzn ajzo ajzp
+ajzq ajzr ajzs ajzt ajzu ajzv ajzw ajzx ajzy ajzz akaa akab akac akad akae
+akaf akag akah akai akaj akak akal akam akan akao akap akaq akar akas akat
+akau akav akaw akax akay akaz akba akbb akbc akbd akbe akbf akbg akbh akbi
+akbj akbk akbl akbm akbn akbo akbp akbq akbr akbs akbt akbu akbv akbw akbx
+akby akbz akca akcb akcc akcd akce akcf akcg akch akci akcj akck akcl akcm
+akcn akco akcp akcq akcr akcs akct akcu akcv akcw akcx akcy akcz akda akdb
+akdc akdd akde akdf akdg akdh akdi akdj akdk akdl akdm akdn akdo akdp akdq
+akdr akds akdt akdu akdv akdw akdx akdy akdz akea akeb akec aked akee akef
+akeg akeh akei akej akek akel akem aken akeo akep akeq aker akes aket akeu
+akev akew akex akey akez akfa akfb akfc akfd akfe akff akfg akfh akfi akfj
+akfk akfl akfm akfn akfo akfp akfq akfr akfs akft akfu akfv akfw akfx akfy
+akfz akga akgb akgc akgd akge akgf akgg akgh akgi akgj akgk akgl akgm akgn
+akgo akgp akgq akgr akgs akgt akgu akgv akgw akgx akgy akgz akha akhb akhc
+akhd akhe akhf akhg akhh akhi akhj akhk akhl akhm akhn akho akhp akhq akhr
+akhs akht akhu akhv akhw akhx akhy akhz akia akib akic akid akie akif akig
+akih akii akij akik akil akim akin akio akip akiq akir akis akit akiu akiv
+akiw akix akiy akiz akja akjb akjc akjd akje akjf akjg akjh akji akjj akjk
+akjl akjm akjn akjo akjp akjq akjr akjs akjt akju akjv akjw akjx akjy akjz
+akka akkb akkc akkd akke akkf akkg akkh akki akkj akkk akkl akkm akkn akko
+akkp akkq akkr akks akkt akku akkv akkw akkx akky akkz akla aklb aklc akld
+akle aklf aklg aklh akli aklj aklk akll aklm akln aklo aklp aklq aklr akls
+aklt aklu aklv aklw aklx akly aklz akma akmb akmc akmd akme akmf akmg akmh
+akmi akmj akmk akml akmm akmn akmo akmp akmq akmr akms akmt akmu akmv akmw
+akmx akmy akmz akna aknb aknc aknd akne aknf akng aknh akni aknj aknk aknl
+aknm aknn akno aknp aknq aknr akns aknt aknu aknv aknw aknx akny aknz akoa
+akob akoc akod akoe akof akog akoh akoi akoj akok akol akom akon akoo akop
+akoq akor akos akot akou akov akow akox akoy akoz akpa akpb akpc akpd akpe
+akpf akpg akph akpi akpj akpk akpl akpm akpn akpo akpp akpq akpr akps akpt
+akpu akpv akpw akpx akpy akpz akqa akqb akqc akqd akqe akqf akqg akqh akqi
+akqj akqk akql akqm akqn akqo akqp akqq akqr akqs akqt akqu akqv akqw akqx
+akqy akqz akra akrb akrc akrd akre akrf akrg akrh akri akrj akrk akrl akrm
+akrn akro akrp akrq akrr akrs akrt akru akrv akrw akrx akry akrz aksa aksb
+aksc aksd akse aksf aksg aksh aksi aksj aksk aksl aksm aksn akso aksp aksq
+aksr akss akst aksu aksv aksw aksx aksy aksz akta aktb aktc aktd akte aktf
+aktg akth akti aktj aktk aktl aktm aktn akto aktp aktq aktr akts aktt aktu
+aktv aktw aktx akty aktz akua akub akuc akud akue akuf akug akuh akui akuj
+akuk akul akum akun akuo akup akuq akur akus akut akuu akuv akuw akux akuy
+akuz akva akvb akvc akvd akve akvf akvg akvh akvi akvj akvk akvl akvm akvn
+akvo akvp akvq akvr akvs akvt akvu akvv akvw akvx akvy akvz akwa akwb akwc
+akwd akwe akwf akwg akwh akwi akwj akwk akwl akwm akwn akwo akwp akwq akwr
+akws akwt akwu akwv akww akwx akwy akwz akxa akxb akxc akxd akxe akxf akxg
+akxh akxi akxj akxk akxl akxm akxn akxo akxp akxq akxr akxs akxt akxu akxv
+akxw akxx akxy akxz akya akyb akyc akyd akye akyf akyg akyh akyi akyj akyk
+akyl akym akyn akyo akyp akyq akyr akys akyt akyu akyv akyw akyx akyy akyz
+akza akzb akzc akzd akze akzf akzg akzh akzi akzj akzk akzl akzm akzn akzo
+akzp akzq akzr akzs akzt akzu akzv akzw akzx akzy akzz alaa alab alac alad
+alae alaf alag alah alai alaj alak alal alam alan alao alap alaq alar alas
+alat alau alav alaw alax alay alaz alba albb albc albd albe albf albg albh
+albi albj albk albl albm albn albo albp albq albr albs albt albu albv albw
+albx alby albz alca alcb alcc alcd alce alcf alcg alch alci alcj alck alcl
+alcm alcn alco alcp alcq alcr alcs alct alcu alcv alcw alcx alcy alcz alda
+aldb aldc aldd alde aldf aldg aldh aldi aldj aldk aldl aldm aldn aldo aldp
+aldq aldr alds aldt aldu aldv aldw aldx aldy aldz alea aleb alec aled alee
+alef aleg aleh alei alej alek alel alem alen aleo alep aleq aler ales alet
+aleu alev alew alex aley alez alfa alfb alfc alfd alfe alff alfg alfh alfi
+alfj alfk alfl alfm alfn alfo alfp alfq alfr alfs alft alfu alfv alfw alfx
+alfy alfz alga algb algc algd alge algf algg algh algi algj algk algl algm
+algn algo algp algq algr algs algt algu algv algw algx algy algz alha alhb
+alhc alhd alhe alhf alhg alhh alhi alhj alhk alhl alhm alhn alho alhp alhq
+alhr alhs alht alhu alhv alhw alhx alhy alhz alia alib alic alid alie alif
+alig alih alii alij alik alil alim alin alio alip aliq alir alis alit aliu
+aliv aliw alix aliy aliz alja aljb aljc aljd alje aljf aljg aljh alji aljj
+aljk aljl aljm aljn aljo aljp aljq aljr aljs aljt alju aljv aljw aljx aljy
+aljz alka alkb alkc alkd alke alkf alkg alkh alki alkj alkk alkl alkm alkn
+alko alkp alkq alkr alks alkt alku alkv alkw alkx alky alkz alla allb allc
+alld alle allf allg allh alli allj allk alll allm alln allo allp allq allr
+alls allt allu allv allw allx ally allz alma almb almc almd alme almf almg
+almh almi almj almk alml almm almn almo almp almq almr alms almt almu almv
+almw almx almy almz alna alnb alnc alnd alne alnf alng alnh alni alnj alnk
+alnl alnm alnn alno alnp alnq alnr alns alnt alnu alnv alnw alnx alny alnz
+aloa alob aloc alod aloe alof alog aloh aloi aloj alok alol alom alon aloo
+alop aloq alor alos alot alou alov alow alox aloy aloz alpa alpb alpc alpd
+alpe alpf alpg alph alpi alpj alpk alpl alpm alpn alpo alpp alpq alpr alps
+alpt alpu alpv alpw alpx alpy alpz alqa alqb alqc alqd alqe alqf alqg alqh
+alqi alqj alqk alql alqm alqn alqo alqp alqq alqr alqs alqt alqu alqv alqw
+alqx alqy alqz alra alrb alrc alrd alre alrf alrg alrh alri alrj alrk alrl
+alrm alrn alro alrp alrq alrr alrs alrt alru alrv alrw alrx alry alrz alsa
+alsb alsc alsd alse alsf alsg alsh alsi alsj alsk alsl alsm alsn also alsp
+alsq alsr alss alst alsu alsv alsw alsx alsy alsz alta altb altc altd alte
+altf altg alth alti altj altk altl altm altn alto altp altq altr alts altt
+altu altv altw altx alty altz alua alub aluc alud alue aluf alug aluh alui
+aluj aluk alul alum alun aluo alup aluq alur alus alut aluu aluv aluw alux
+aluy aluz alva alvb alvc alvd alve alvf alvg alvh alvi alvj alvk alvl alvm
+alvn alvo alvp alvq alvr alvs alvt alvu alvv alvw alvx alvy alvz alwa alwb
+alwc alwd alwe alwf alwg alwh alwi alwj alwk alwl alwm alwn alwo alwp alwq
+alwr alws alwt alwu alwv alww alwx alwy alwz alxa alxb alxc alxd alxe alxf
+alxg alxh alxi alxj alxk alxl alxm alxn alxo alxp alxq alxr alxs alxt alxu
+alxv alxw alxx alxy alxz alya alyb alyc alyd alye alyf alyg alyh alyi alyj
+alyk alyl alym alyn alyo alyp alyq alyr alys alyt alyu alyv alyw alyx alyy
+alyz alza alzb alzc alzd alze alzf alzg alzh alzi alzj alzk alzl alzm alzn
+alzo alzp alzq alzr alzs alzt alzu alzv alzw alzx alzy alzz amaa amab amac
+amad amae amaf amag amah amai amaj amak amal amam aman amao amap amaq amar
+amas amat amau amav amaw amax amay amaz amba ambb ambc ambd ambe ambf ambg
+ambh ambi ambj ambk ambl ambm ambn ambo ambp ambq ambr ambs ambt ambu ambv
+ambw ambx amby ambz amca amcb amcc amcd amce amcf amcg amch amci amcj amck
+amcl amcm amcn amco amcp amcq amcr amcs amct amcu amcv amcw amcx amcy amcz
+amda amdb amdc amdd amde amdf amdg amdh amdi amdj amdk amdl amdm amdn amdo
+amdp amdq amdr amds amdt amdu amdv amdw amdx amdy amdz amea ameb amec amed
+amee amef ameg ameh amei amej amek amel amem amen ameo amep ameq amer ames
+amet ameu amev amew amex amey amez amfa amfb amfc amfd amfe amff amfg amfh
+amfi amfj amfk amfl amfm amfn amfo amfp amfq amfr amfs amft amfu amfv amfw
+amfx amfy amfz amga amgb amgc amgd amge amgf amgg amgh amgi amgj amgk amgl
+amgm amgn amgo amgp amgq amgr amgs amgt amgu amgv amgw amgx amgy amgz amha
+amhb amhc amhd amhe amhf amhg amhh amhi amhj amhk amhl amhm amhn amho amhp
+amhq amhr amhs amht amhu amhv amhw amhx amhy amhz amia amib amic amid amie
+amif amig amih amii amij amik amil amim amin amio amip amiq amir amis amit
+amiu amiv amiw amix amiy amiz amja amjb amjc amjd amje amjf amjg amjh amji
+amjj amjk amjl amjm amjn amjo amjp amjq amjr amjs amjt amju amjv amjw amjx
+amjy amjz amka amkb amkc amkd amke amkf amkg amkh amki amkj amkk amkl amkm
+amkn amko amkp amkq amkr amks amkt amku amkv amkw amkx amky amkz amla amlb
+amlc amld amle amlf amlg amlh amli amlj amlk amll amlm amln amlo amlp amlq
+amlr amls amlt amlu amlv amlw amlx amly amlz amma ammb ammc ammd amme ammf
+ammg ammh ammi ammj ammk amml ammm ammn ammo ammp ammq ammr amms ammt ammu
+ammv ammw ammx ammy ammz amna amnb amnc amnd amne amnf amng amnh amni amnj
+amnk amnl amnm amnn amno amnp amnq amnr amns amnt amnu amnv amnw amnx amny
+amnz amoa amob amoc amod amoe amof amog amoh amoi amoj amok amol amom amon
+amoo amop amoq amor amos amot amou amov amow amox amoy amoz ampa ampb ampc
+ampd ampe ampf ampg amph ampi ampj ampk ampl ampm ampn ampo ampp ampq ampr
+amps ampt ampu ampv ampw ampx ampy ampz amqa amqb amqc amqd amqe amqf amqg
+amqh amqi amqj amqk amql amqm amqn amqo amqp amqq amqr amqs amqt amqu amqv
+amqw amqx amqy amqz amra amrb amrc amrd amre amrf amrg amrh amri amrj amrk
+amrl amrm amrn amro amrp amrq amrr amrs amrt amru amrv amrw amrx amry amrz
+amsa amsb amsc amsd amse amsf amsg amsh amsi amsj amsk amsl amsm amsn amso
+amsp amsq amsr amss amst amsu amsv amsw amsx amsy amsz amta amtb amtc amtd
+amte amtf amtg amth amti amtj amtk amtl amtm amtn amto amtp amtq amtr amts
+amtt amtu amtv amtw amtx amty amtz amua amub amuc amud amue amuf amug amuh
+amui amuj amuk amul amum amun amuo amup amuq amur amus amut amuu amuv amuw
+amux amuy amuz amva amvb amvc amvd amve amvf amvg amvh amvi amvj amvk amvl
+amvm amvn amvo amvp amvq amvr amvs amvt amvu amvv amvw amvx amvy amvz amwa
+amwb amwc amwd amwe amwf amwg amwh amwi amwj amwk amwl amwm amwn amwo amwp
+amwq amwr amws amwt amwu amwv amww amwx amwy amwz amxa amxb amxc amxd amxe
+amxf amxg amxh amxi amxj amxk amxl amxm amxn amxo amxp amxq amxr amxs amxt
+amxu amxv amxw amxx amxy amxz amya amyb amyc amyd amye amyf amyg amyh amyi
+amyj amyk amyl amym amyn amyo amyp amyq amyr amys amyt amyu amyv amyw amyx
+amyy amyz amza amzb amzc amzd amze amzf amzg amzh amzi amzj amzk amzl amzm
+amzn amzo amzp amzq amzr amzs amzt amzu amzv amzw amzx amzy amzz anaa anab
+anac anad anae anaf anag anah anai anaj anak anal anam anan anao anap anaq
+anar anas anat anau anav anaw anax anay anaz anba anbb anbc anbd anbe anbf
+anbg anbh anbi anbj anbk anbl anbm anbn anbo anbp anbq anbr anbs anbt anbu
+anbv anbw anbx anby anbz anca ancb ancc ancd ance ancf ancg anch anci ancj
+anck ancl ancm ancn anco ancp ancq ancr ancs anct ancu ancv ancw ancx ancy
+ancz anda andb andc andd ande andf andg andh andi andj andk andl andm andn
+ando andp andq andr ands andt andu andv andw andx andy andz anea aneb anec
+aned anee anef aneg aneh anei anej anek anel anem anen aneo anep aneq aner
+anes anet aneu anev anew anex aney anez anfa anfb anfc anfd anfe anff anfg
+anfh anfi anfj anfk anfl anfm anfn anfo anfp anfq anfr anfs anft anfu anfv
+anfw anfx anfy anfz anga angb angc angd ange angf angg angh angi angj angk
+angl angm angn ango angp angq angr angs angt angu angv angw angx angy angz
+anha anhb anhc anhd anhe anhf anhg anhh anhi anhj anhk anhl anhm anhn anho
+anhp anhq anhr anhs anht anhu anhv anhw anhx anhy anhz ania anib anic anid
+anie anif anig anih anii anij anik anil anim anin anio anip aniq anir anis
+anit aniu aniv aniw anix aniy aniz anja anjb anjc anjd anje anjf anjg anjh
+anji anjj anjk anjl anjm anjn anjo anjp anjq anjr anjs anjt anju anjv anjw
+anjx anjy anjz anka ankb ankc ankd anke ankf ankg ankh anki ankj ankk ankl
+ankm ankn anko ankp ankq ankr anks ankt anku ankv ankw ankx anky ankz anla
+anlb anlc anld anle anlf anlg anlh anli anlj anlk anll anlm anln anlo anlp
+anlq anlr anls anlt anlu anlv anlw anlx anly anlz anma anmb anmc anmd anme
+anmf anmg anmh anmi anmj anmk anml anmm anmn anmo anmp anmq anmr anms anmt
+anmu anmv anmw anmx anmy anmz anna annb annc annd anne annf anng annh anni
+annj annk annl annm annn anno annp annq annr anns annt annu annv annw annx
+anny annz anoa anob anoc anod anoe anof anog anoh anoi anoj anok anol anom
+anon anoo anop anoq anor anos anot anou anov anow anox anoy anoz anpa anpb
+anpc anpd anpe anpf anpg anph anpi anpj anpk anpl anpm anpn anpo anpp anpq
+anpr anps anpt anpu anpv anpw anpx anpy anpz anqa anqb anqc anqd anqe anqf
+anqg anqh anqi anqj anqk anql anqm anqn anqo anqp anqq anqr anqs anqt anqu
+anqv anqw anqx anqy anqz anra anrb anrc anrd anre anrf anrg anrh anri anrj
+anrk anrl anrm anrn anro anrp anrq anrr anrs anrt anru anrv anrw anrx anry
+anrz ansa ansb ansc ansd anse ansf ansg ansh ansi ansj ansk ansl ansm ansn
+anso ansp ansq ansr anss anst ansu ansv answ ansx ansy ansz anta antb antc
+antd ante antf antg anth anti antj antk antl antm antn anto antp antq antr
+ants antt antu antv antw antx anty antz anua anub anuc anud anue anuf anug
+anuh anui anuj anuk anul anum anun anuo anup anuq anur anus anut anuu anuv
+anuw anux anuy anuz anva anvb anvc anvd anve anvf anvg anvh anvi anvj anvk
+anvl anvm anvn anvo anvp anvq anvr anvs anvt anvu anvv anvw anvx anvy anvz
+anwa anwb anwc anwd anwe anwf anwg anwh anwi anwj anwk anwl anwm anwn anwo
+anwp anwq anwr anws anwt anwu anwv anww anwx anwy anwz anxa anxb anxc anxd
+anxe anxf anxg anxh anxi anxj anxk anxl anxm anxn anxo anxp anxq anxr anxs
+anxt anxu anxv anxw anxx anxy anxz anya anyb anyc anyd anye anyf anyg anyh
+anyi anyj anyk anyl anym anyn anyo anyp anyq anyr anys anyt anyu anyv anyw
+anyx anyy anyz anza anzb anzc anzd anze anzf anzg anzh anzi anzj anzk anzl
+anzm anzn anzo anzp anzq anzr anzs anzt anzu anzv anzw anzx anzy anzz aoaa
+aoab aoac aoad aoae aoaf aoag aoah aoai aoaj aoak aoal aoam aoan aoao aoap
+aoaq aoar aoas aoat aoau aoav aoaw aoax aoay aoaz aoba aobb aobc aobd aobe
+aobf aobg aobh aobi aobj aobk aobl aobm aobn aobo aobp aobq aobr aobs aobt
+aobu aobv aobw aobx aoby aobz aoca aocb aocc aocd aoce aocf aocg aoch aoci
+aocj aock aocl aocm aocn aoco aocp aocq aocr aocs aoct aocu aocv aocw aocx
+aocy aocz aoda aodb aodc aodd aode aodf aodg aodh aodi aodj aodk aodl aodm
+aodn aodo aodp aodq aodr aods aodt aodu aodv aodw aodx aody aodz aoea aoeb
+aoec aoed aoee aoef aoeg aoeh aoei aoej aoek aoel aoem aoen aoeo aoep aoeq
+aoer aoes aoet aoeu aoev aoew aoex aoey aoez aofa aofb aofc aofd aofe aoff
+aofg aofh aofi aofj aofk aofl aofm aofn aofo aofp aofq aofr aofs aoft aofu
+aofv aofw aofx aofy aofz aoga aogb aogc aogd aoge aogf aogg aogh aogi aogj
+aogk aogl aogm aogn aogo aogp aogq aogr aogs aogt aogu aogv aogw aogx aogy
+aogz aoha aohb aohc aohd aohe aohf aohg aohh aohi aohj aohk aohl aohm aohn
+aoho aohp aohq aohr aohs aoht aohu aohv aohw aohx aohy aohz aoia aoib aoic
+aoid aoie aoif aoig aoih aoii aoij aoik aoil aoim aoin aoio aoip aoiq aoir
+aois aoit aoiu aoiv aoiw aoix aoiy aoiz aoja aojb aojc aojd aoje aojf aojg
+aojh aoji aojj aojk aojl aojm aojn aojo aojp aojq aojr aojs aojt aoju aojv
+aojw aojx aojy aojz aoka aokb aokc aokd aoke aokf aokg aokh aoki aokj aokk
+aokl aokm aokn aoko aokp aokq aokr aoks aokt aoku aokv aokw aokx aoky aokz
+aola aolb aolc aold aole aolf aolg aolh aoli aolj aolk aoll aolm aoln aolo
+aolp aolq aolr aols aolt aolu aolv aolw aolx aoly aolz aoma aomb aomc aomd
+aome aomf aomg aomh aomi aomj aomk aoml aomm aomn aomo aomp aomq aomr aoms
+aomt aomu aomv aomw aomx aomy aomz aona aonb aonc aond aone aonf aong aonh
+aoni aonj aonk aonl aonm aonn aono aonp aonq aonr aons aont aonu aonv aonw
+aonx aony aonz aooa aoob aooc aood aooe aoof aoog aooh aooi aooj aook aool
+aoom aoon aooo aoop aooq aoor aoos aoot aoou aoov aoow aoox aooy aooz aopa
+aopb aopc aopd aope aopf aopg aoph aopi aopj aopk aopl aopm aopn aopo aopp
+aopq aopr aops aopt aopu aopv aopw aopx aopy aopz aoqa aoqb aoqc aoqd aoqe
+aoqf aoqg aoqh aoqi aoqj aoqk aoql aoqm aoqn aoqo aoqp aoqq aoqr aoqs aoqt
+aoqu aoqv aoqw aoqx aoqy aoqz aora aorb aorc aord aore aorf aorg aorh aori
+aorj aork aorl aorm aorn aoro aorp aorq aorr aors aort aoru aorv aorw aorx
+aory aorz aosa aosb aosc aosd aose aosf aosg aosh aosi aosj aosk aosl aosm
+aosn aoso aosp aosq aosr aoss aost aosu aosv aosw aosx aosy aosz aota aotb
+aotc aotd aote aotf aotg aoth aoti aotj aotk aotl aotm aotn aoto aotp aotq
+aotr aots aott aotu aotv aotw aotx aoty aotz aoua aoub aouc aoud aoue aouf
+aoug aouh aoui aouj aouk aoul aoum aoun aouo aoup aouq aour aous aout aouu
+aouv aouw aoux aouy aouz aova aovb aovc aovd aove aovf aovg aovh aovi aovj
+aovk aovl aovm aovn aovo aovp aovq aovr aovs aovt aovu aovv aovw aovx aovy
+aovz aowa aowb aowc aowd aowe aowf aowg aowh aowi aowj aowk aowl aowm aown
+aowo aowp aowq aowr aows aowt aowu aowv aoww aowx aowy aowz aoxa aoxb aoxc
+aoxd aoxe aoxf aoxg aoxh aoxi aoxj aoxk aoxl aoxm aoxn aoxo aoxp aoxq aoxr
+aoxs aoxt aoxu aoxv aoxw aoxx aoxy aoxz aoya aoyb aoyc aoyd aoye aoyf aoyg
+aoyh aoyi aoyj aoyk aoyl aoym aoyn aoyo aoyp aoyq aoyr aoys aoyt aoyu aoyv
+aoyw aoyx aoyy aoyz aoza aozb aozc aozd aoze aozf aozg aozh aozi aozj aozk
+aozl aozm aozn aozo aozp aozq aozr aozs aozt aozu aozv aozw aozx aozy aozz
+apaa apab apac apad apae apaf apag apah apai apaj apak apal apam apan apao
+apap apaq apar apas apat apau apav apaw apax apay apaz apba apbb apbc apbd
+apbe apbf apbg apbh apbi apbj apbk apbl apbm apbn apbo apbp apbq apbr apbs
+apbt apbu apbv apbw apbx apby apbz apca apcb apcc apcd apce apcf apcg apch
+apci apcj apck apcl apcm apcn apco apcp apcq apcr apcs apct apcu apcv apcw
+apcx apcy apcz apda apdb apdc apdd apde apdf apdg apdh apdi apdj apdk apdl
+apdm apdn apdo apdp apdq apdr apds apdt apdu apdv apdw apdx apdy apdz apea
+apeb apec aped apee apef apeg apeh apei apej apek apel apem apen apeo apep
+apeq aper apes apet apeu apev apew apex apey apez apfa apfb apfc apfd apfe
+apff apfg apfh apfi apfj apfk apfl apfm apfn apfo apfp apfq apfr apfs apft
+apfu apfv apfw apfx apfy apfz apga apgb apgc apgd apge apgf apgg apgh apgi
+apgj apgk apgl apgm apgn apgo apgp apgq apgr apgs apgt apgu apgv apgw apgx
+apgy apgz apha aphb aphc aphd aphe aphf aphg aphh aphi aphj aphk aphl aphm
+aphn apho aphp aphq aphr aphs apht aphu aphv aphw aphx aphy aphz apia apib
+apic apid apie apif apig apih apii apij apik apil apim apin apio apip apiq
+apir apis apit apiu apiv apiw apix apiy apiz apja apjb apjc apjd apje apjf
+apjg apjh apji apjj apjk apjl apjm apjn apjo apjp apjq apjr apjs apjt apju
+apjv apjw apjx apjy apjz apka apkb apkc apkd apke apkf apkg apkh apki apkj
+apkk apkl apkm apkn apko apkp apkq apkr apks apkt apku apkv apkw apkx apky
+apkz apla aplb aplc apld aple aplf aplg aplh apli aplj aplk apll aplm apln
+aplo aplp aplq aplr apls aplt aplu aplv aplw aplx aply aplz apma apmb apmc
+apmd apme apmf apmg apmh apmi apmj apmk apml apmm apmn apmo apmp apmq apmr
+apms apmt apmu apmv apmw apmx apmy apmz apna apnb apnc apnd apne apnf apng
+apnh apni apnj apnk apnl apnm apnn apno apnp apnq apnr apns apnt apnu apnv
+apnw apnx apny apnz apoa apob apoc apod apoe apof apog apoh apoi apoj apok
+apol apom apon apoo apop apoq apor apos apot apou apov apow apox apoy apoz
+appa appb appc appd appe appf appg apph appi appj appk appl appm appn appo
+appp appq appr apps appt appu appv appw appx appy appz apqa apqb apqc apqd
+apqe apqf apqg apqh apqi apqj apqk apql apqm apqn apqo apqp apqq apqr apqs
+apqt apqu apqv apqw apqx apqy apqz apra aprb aprc aprd apre aprf aprg aprh
+apri aprj aprk aprl aprm aprn apro aprp aprq aprr aprs aprt apru aprv aprw
+aprx apry aprz apsa apsb apsc apsd apse apsf apsg apsh apsi apsj apsk apsl
+apsm apsn apso apsp apsq apsr apss apst apsu apsv apsw apsx apsy apsz apta
+aptb aptc aptd apte aptf aptg apth apti aptj aptk aptl aptm aptn apto aptp
+aptq aptr apts aptt aptu aptv aptw aptx apty aptz apua apub apuc apud apue
+apuf apug apuh apui apuj apuk apul apum apun apuo apup apuq apur apus aput
+apuu apuv apuw apux apuy apuz apva apvb apvc apvd apve apvf apvg apvh apvi
+apvj apvk apvl apvm apvn apvo apvp apvq apvr apvs apvt apvu apvv apvw apvx
+apvy apvz apwa apwb apwc apwd apwe apwf apwg apwh apwi apwj apwk apwl apwm
+apwn apwo apwp apwq apwr apws apwt apwu apwv apww apwx apwy apwz apxa apxb
+apxc apxd apxe apxf apxg apxh apxi apxj apxk apxl apxm apxn apxo apxp apxq
+apxr apxs apxt apxu apxv apxw apxx apxy apxz apya apyb apyc apyd apye apyf
+apyg apyh apyi apyj apyk apyl apym apyn apyo apyp apyq apyr apys apyt apyu
+apyv apyw apyx apyy apyz apza apzb apzc apzd apze apzf apzg apzh apzi apzj
+apzk apzl apzm apzn apzo apzp apzq apzr apzs apzt apzu apzv apzw apzx apzy
+apzz aqaa aqab aqac aqad aqae aqaf aqag aqah aqai aqaj aqak aqal aqam aqan
+aqao aqap aqaq aqar aqas aqat aqau aqav aqaw aqax aqay aqaz aqba aqbb aqbc
+aqbd aqbe aqbf aqbg aqbh aqbi aqbj aqbk aqbl aqbm aqbn aqbo aqbp aqbq aqbr
+aqbs aqbt aqbu aqbv aqbw aqbx aqby aqbz aqca aqcb aqcc aqcd aqce aqcf aqcg
+aqch aqci aqcj aqck aqcl aqcm aqcn aqco aqcp aqcq aqcr aqcs aqct aqcu aqcv
+aqcw aqcx aqcy aqcz aqda aqdb aqdc aqdd aqde aqdf aqdg aqdh aqdi aqdj aqdk
+aqdl aqdm aqdn aqdo aqdp aqdq aqdr aqds aqdt aqdu aqdv aqdw aqdx aqdy aqdz
+aqea aqeb aqec aqed aqee aqef aqeg aqeh aqei aqej aqek aqel aqem aqen aqeo
+aqep aqeq aqer aqes aqet aqeu aqev aqew aqex aqey aqez aqfa aqfb aqfc aqfd
+aqfe aqff aqfg aqfh aqfi aqfj aqfk aqfl aqfm aqfn aqfo aqfp aqfq aqfr aqfs
+aqft aqfu aqfv aqfw aqfx aqfy aqfz aqga aqgb aqgc aqgd aqge aqgf aqgg aqgh
+aqgi aqgj aqgk aqgl aqgm aqgn aqgo aqgp aqgq aqgr aqgs aqgt aqgu aqgv aqgw
+aqgx aqgy aqgz aqha aqhb aqhc aqhd aqhe aqhf aqhg aqhh aqhi aqhj aqhk aqhl
+aqhm aqhn aqho aqhp aqhq aqhr aqhs aqht aqhu aqhv aqhw aqhx aqhy aqhz aqia
+aqib aqic aqid aqie aqif aqig aqih aqii aqij aqik aqil aqim aqin aqio aqip
+aqiq aqir aqis aqit aqiu aqiv aqiw aqix aqiy aqiz aqja aqjb aqjc aqjd aqje
+aqjf aqjg aqjh aqji aqjj aqjk aqjl aqjm aqjn aqjo aqjp aqjq aqjr aqjs aqjt
+aqju aqjv aqjw aqjx aqjy aqjz aqka aqkb aqkc aqkd aqke aqkf aqkg aqkh aqki
+aqkj aqkk aqkl aqkm aqkn aqko aqkp aqkq aqkr aqks aqkt aqku aqkv aqkw aqkx
+aqky aqkz aqla aqlb aqlc aqld aqle aqlf aqlg aqlh aqli aqlj aqlk aqll aqlm
+aqln aqlo aqlp aqlq aqlr aqls aqlt aqlu aqlv aqlw aqlx aqly aqlz aqma aqmb
+aqmc aqmd aqme aqmf aqmg aqmh aqmi aqmj aqmk aqml aqmm aqmn aqmo aqmp aqmq
+aqmr aqms aqmt aqmu aqmv aqmw aqmx aqmy aqmz aqna aqnb aqnc aqnd aqne aqnf
+aqng aqnh aqni aqnj aqnk aqnl aqnm aqnn aqno aqnp aqnq aqnr aqns aqnt aqnu
+aqnv aqnw aqnx aqny aqnz aqoa aqob aqoc aqod aqoe aqof aqog aqoh aqoi aqoj
+aqok aqol aqom aqon aqoo aqop aqoq aqor aqos aqot aqou aqov aqow aqox aqoy
+aqoz aqpa aqpb aqpc aqpd aqpe aqpf aqpg aqph aqpi aqpj aqpk aqpl aqpm aqpn
+aqpo aqpp aqpq aqpr aqps aqpt aqpu aqpv aqpw aqpx aqpy aqpz aqqa aqqb aqqc
+aqqd aqqe aqqf aqqg aqqh aqqi aqqj aqqk aqql aqqm aqqn aqqo aqqp aqqq aqqr
+aqqs aqqt aqqu aqqv aqqw aqqx aqqy aqqz aqra aqrb aqrc aqrd aqre aqrf aqrg
+aqrh aqri aqrj aqrk aqrl aqrm aqrn aqro aqrp aqrq aqrr aqrs aqrt aqru aqrv
+aqrw aqrx aqry aqrz aqsa aqsb aqsc aqsd aqse aqsf aqsg aqsh aqsi aqsj aqsk
+aqsl aqsm aqsn aqso aqsp aqsq aqsr aqss aqst aqsu aqsv aqsw aqsx aqsy aqsz
+aqta aqtb aqtc aqtd aqte aqtf aqtg aqth aqti aqtj aqtk aqtl aqtm aqtn aqto
+aqtp aqtq aqtr aqts aqtt aqtu aqtv aqtw aqtx aqty aqtz aqua aqub aquc aqud
+aque aquf aqug aquh aqui aquj aquk aqul aqum aqun aquo aqup aquq aqur aqus
+aqut aquu aquv aquw aqux aquy aquz aqva aqvb aqvc aqvd aqve aqvf aqvg aqvh
+aqvi aqvj aqvk aqvl aqvm aqvn aqvo aqvp aqvq aqvr aqvs aqvt aqvu aqvv aqvw
+aqvx aqvy aqvz aqwa aqwb aqwc aqwd aqwe aqwf aqwg aqwh aqwi aqwj aqwk aqwl
+aqwm aqwn aqwo aqwp aqwq aqwr aqws aqwt aqwu aqwv aqww aqwx aqwy aqwz aqxa
+aqxb aqxc aqxd aqxe aqxf aqxg aqxh aqxi aqxj aqxk aqxl aqxm aqxn aqxo aqxp
+aqxq aqxr aqxs aqxt aqxu aqxv aqxw aqxx aqxy aqxz aqya aqyb aqyc aqyd aqye
+aqyf aqyg aqyh aqyi aqyj aqyk aqyl aqym aqyn aqyo aqyp aqyq aqyr aqys aqyt
+aqyu aqyv aqyw aqyx aqyy aqyz aqza aqzb aqzc aqzd aqze aqzf aqzg aqzh aqzi
+aqzj aqzk aqzl aqzm aqzn aqzo aqzp aqzq aqzr aqzs aqzt aqzu aqzv aqzw aqzx
+aqzy aqzz araa arab arac arad arae araf arag arah arai araj arak aral aram
+aran arao arap araq arar aras arat arau arav araw arax aray araz arba arbb
+arbc arbd arbe arbf arbg arbh arbi arbj arbk arbl arbm arbn arbo arbp arbq
+arbr arbs arbt arbu arbv arbw arbx arby arbz arca arcb arcc arcd arce arcf
+arcg arch arci arcj arck arcl arcm arcn arco arcp arcq arcr arcs arct arcu
+arcv arcw arcx arcy arcz arda ardb ardc ardd arde ardf ardg ardh ardi ardj
+ardk ardl ardm ardn ardo ardp ardq ardr ards ardt ardu ardv ardw ardx ardy
+ardz area areb arec ared aree aref areg areh arei arej arek arel arem aren
+areo arep areq arer ares aret areu arev arew arex arey arez arfa arfb arfc
+arfd arfe arff arfg arfh arfi arfj arfk arfl arfm arfn arfo arfp arfq arfr
+arfs arft arfu arfv arfw arfx arfy arfz arga argb argc argd arge argf argg
+argh argi argj argk argl argm argn argo argp argq argr args argt argu argv
+argw argx argy argz arha arhb arhc arhd arhe arhf arhg arhh arhi arhj arhk
+arhl arhm arhn arho arhp arhq arhr arhs arht arhu arhv arhw arhx arhy arhz
+aria arib aric arid arie arif arig arih arii arij arik aril arim arin ario
+arip ariq arir aris arit ariu ariv ariw arix ariy ariz arja arjb arjc arjd
+arje arjf arjg arjh arji arjj arjk arjl arjm arjn arjo arjp arjq arjr arjs
+arjt arju arjv arjw arjx arjy arjz arka arkb arkc arkd arke arkf arkg arkh
+arki arkj arkk arkl arkm arkn arko arkp arkq arkr arks arkt arku arkv arkw
+arkx arky arkz arla arlb arlc arld arle arlf arlg arlh arli arlj arlk arll
+arlm arln arlo arlp arlq arlr arls arlt arlu arlv arlw arlx arly arlz arma
+armb armc armd arme armf armg armh armi armj armk arml armm armn armo armp
+armq armr arms armt armu armv armw armx army armz arna arnb arnc arnd arne
+arnf arng arnh arni arnj arnk arnl arnm arnn arno arnp arnq arnr arns arnt
+arnu arnv arnw arnx arny arnz aroa arob aroc arod aroe arof arog aroh aroi
+aroj arok arol arom aron aroo arop aroq aror aros arot arou arov arow arox
+aroy aroz arpa arpb arpc arpd arpe arpf arpg arph arpi arpj arpk arpl arpm
+arpn arpo arpp arpq arpr arps arpt arpu arpv arpw arpx arpy arpz arqa arqb
+arqc arqd arqe arqf arqg arqh arqi arqj arqk arql arqm arqn arqo arqp arqq
+arqr arqs arqt arqu arqv arqw arqx arqy arqz arra arrb arrc arrd arre arrf
+arrg arrh arri arrj arrk arrl arrm arrn arro arrp arrq arrr arrs arrt arru
+arrv arrw arrx arry arrz arsa arsb arsc arsd arse arsf arsg arsh arsi arsj
+arsk arsl arsm arsn arso arsp arsq arsr arss arst arsu arsv arsw arsx arsy
+arsz arta artb artc artd arte artf artg arth arti artj artk artl artm artn
+arto artp artq artr arts artt artu artv artw artx arty artz arua arub aruc
+arud arue aruf arug aruh arui aruj aruk arul arum arun aruo arup aruq arur
+arus arut aruu aruv aruw arux aruy aruz arva arvb arvc arvd arve arvf arvg
+arvh arvi arvj arvk arvl arvm arvn arvo arvp arvq arvr arvs arvt arvu arvv
+arvw arvx arvy arvz arwa arwb arwc arwd arwe arwf arwg arwh arwi arwj arwk
+arwl arwm arwn arwo arwp arwq arwr arws arwt arwu arwv arww arwx arwy arwz
+arxa arxb arxc arxd arxe arxf arxg arxh arxi arxj arxk arxl arxm arxn arxo
+arxp arxq arxr arxs arxt arxu arxv arxw arxx arxy arxz arya aryb aryc aryd
+arye aryf aryg aryh aryi aryj aryk aryl arym aryn aryo aryp aryq aryr arys
+aryt aryu aryv aryw aryx aryy aryz arza arzb arzc arzd arze arzf arzg arzh
+arzi arzj arzk arzl arzm arzn arzo arzp arzq arzr arzs arzt arzu arzv arzw
+arzx arzy arzz asaa asab asac asad asae asaf asag asah asai asaj asak asal
+asam asan asao asap asaq asar asas asat asau asav asaw asax asay asaz asba
+asbb asbc asbd asbe asbf asbg asbh asbi asbj asbk asbl asbm asbn asbo asbp
+asbq asbr asbs asbt asbu asbv asbw asbx asby asbz asca ascb ascc ascd asce
+ascf ascg asch asci ascj asck ascl ascm ascn asco ascp ascq ascr ascs asct
+ascu ascv ascw ascx ascy ascz asda asdb asdc asdd asde asdf asdg asdh asdi
+asdj asdk asdl asdm asdn asdo asdp asdq asdr asds asdt asdu asdv asdw asdx
+asdy asdz asea aseb asec ased asee asef aseg aseh asei asej asek asel asem
+asen aseo asep aseq aser ases aset aseu asev asew asex asey asez asfa asfb
+asfc asfd asfe asff asfg asfh asfi asfj asfk asfl asfm asfn asfo asfp asfq
+asfr asfs asft asfu asfv asfw asfx asfy asfz asga asgb asgc asgd asge asgf
+asgg asgh asgi asgj asgk asgl asgm asgn asgo asgp asgq asgr asgs asgt asgu
+asgv asgw asgx asgy asgz asha ashb ashc ashd ashe ashf ashg ashh ashi ashj
+ashk ashl ashm ashn asho ashp ashq ashr ashs asht ashu ashv ashw ashx ashy
+ashz asia asib asic asid asie asif asig asih asii asij asik asil asim asin
+asio asip asiq asir asis asit asiu asiv asiw asix asiy asiz asja asjb asjc
+asjd asje asjf asjg asjh asji asjj asjk asjl asjm asjn asjo asjp asjq asjr
+asjs asjt asju asjv asjw asjx asjy asjz aska askb askc askd aske askf askg
+askh aski askj askk askl askm askn asko askp askq askr asks askt asku askv
+askw askx asky askz asla aslb aslc asld asle aslf aslg aslh asli aslj aslk
+asll aslm asln aslo aslp aslq aslr asls aslt aslu aslv aslw aslx asly aslz
+asma asmb asmc asmd asme asmf asmg asmh asmi asmj asmk asml asmm asmn asmo
+asmp asmq asmr asms asmt asmu asmv asmw asmx asmy asmz asna asnb asnc asnd
+asne asnf asng asnh asni asnj asnk asnl asnm asnn asno asnp asnq asnr asns
+asnt asnu asnv asnw asnx asny asnz asoa asob asoc asod asoe asof asog asoh
+asoi asoj asok asol asom ason asoo asop asoq asor asos asot asou asov asow
+asox asoy asoz aspa aspb aspc aspd aspe aspf aspg asph aspi aspj aspk aspl
+aspm aspn aspo aspp aspq aspr asps aspt aspu aspv aspw aspx aspy aspz asqa
+asqb asqc asqd asqe asqf asqg asqh asqi asqj asqk asql asqm asqn asqo asqp
+asqq asqr asqs asqt asqu asqv asqw asqx asqy asqz asra asrb asrc asrd asre
+asrf asrg asrh asri asrj asrk asrl asrm asrn asro asrp asrq asrr asrs asrt
+asru asrv asrw asrx asry asrz assa assb assc assd asse assf assg assh assi
+assj assk assl assm assn asso assp assq assr asss asst assu assv assw assx
+assy assz asta astb astc astd aste astf astg asth asti astj astk astl astm
+astn asto astp astq astr asts astt astu astv astw astx asty astz asua asub
+asuc asud asue asuf asug asuh asui asuj asuk asul asum asun asuo asup asuq
+asur asus asut asuu asuv asuw asux asuy asuz asva asvb asvc asvd asve asvf
+asvg asvh asvi asvj asvk asvl asvm asvn asvo asvp asvq asvr asvs asvt asvu
+asvv asvw asvx asvy asvz aswa aswb aswc aswd aswe aswf aswg aswh aswi aswj
+aswk aswl aswm aswn aswo aswp aswq aswr asws aswt aswu aswv asww aswx aswy
+aswz asxa asxb asxc asxd asxe asxf asxg asxh asxi asxj asxk asxl asxm asxn
+asxo asxp asxq asxr asxs asxt asxu asxv asxw asxx asxy asxz asya asyb asyc
+asyd asye asyf asyg asyh asyi asyj asyk asyl asym asyn asyo asyp asyq asyr
+asys asyt asyu asyv asyw asyx asyy asyz asza aszb aszc aszd asze aszf aszg
+aszh aszi aszj aszk aszl aszm aszn aszo aszp aszq aszr aszs aszt aszu aszv
+aszw aszx aszy aszz ataa atab atac atad atae ataf atag atah atai ataj atak
+atal atam atan atao atap ataq atar atas atat atau atav ataw atax atay ataz
+atba atbb atbc atbd atbe atbf atbg atbh atbi atbj atbk atbl atbm atbn atbo
+atbp atbq atbr atbs atbt atbu atbv atbw atbx atby atbz atca atcb atcc atcd
+atce atcf atcg atch atci atcj atck atcl atcm atcn atco atcp atcq atcr atcs
+atct atcu atcv atcw atcx atcy atcz atda atdb atdc atdd atde atdf atdg atdh
+atdi atdj atdk atdl atdm atdn atdo atdp atdq atdr atds atdt atdu atdv atdw
+atdx atdy atdz atea ateb atec ated atee atef ateg ateh atei atej atek atel
+atem aten ateo atep ateq ater ates atet ateu atev atew atex atey atez atfa
+atfb atfc atfd atfe atff atfg atfh atfi atfj atfk atfl atfm atfn atfo atfp
+atfq atfr atfs atft atfu atfv atfw atfx atfy atfz atga atgb atgc atgd atge
+atgf atgg atgh atgi atgj atgk atgl atgm atgn atgo atgp atgq atgr atgs atgt
+atgu atgv atgw atgx atgy atgz atha athb athc athd athe athf athg athh athi
+athj athk athl athm athn atho athp athq athr aths atht athu athv athw athx
+athy athz atia atib atic atid atie atif atig atih atii atij atik atil atim
+atin atio atip atiq atir atis atit atiu ativ atiw atix atiy atiz atja atjb
+atjc atjd atje atjf atjg atjh atji atjj atjk atjl atjm atjn atjo atjp atjq
+atjr atjs atjt atju atjv atjw atjx atjy atjz atka atkb atkc atkd atke atkf
+atkg atkh atki atkj atkk atkl atkm atkn atko atkp atkq atkr atks atkt atku
+atkv atkw atkx atky atkz atla atlb atlc atld atle atlf atlg atlh atli atlj
+atlk atll atlm atln atlo atlp atlq atlr atls atlt atlu atlv atlw atlx atly
+atlz atma atmb atmc atmd atme atmf atmg atmh atmi atmj atmk atml atmm atmn
+atmo atmp atmq atmr atms atmt atmu atmv atmw atmx atmy atmz atna atnb atnc
+atnd atne atnf atng atnh atni atnj atnk atnl atnm atnn atno atnp atnq atnr
+atns atnt atnu atnv atnw atnx atny atnz atoa atob atoc atod atoe atof atog
+atoh atoi atoj atok atol atom aton atoo atop atoq ator atos atot atou atov
+atow atox atoy atoz atpa atpb atpc atpd atpe atpf atpg atph atpi atpj atpk
+atpl atpm atpn atpo atpp atpq atpr atps atpt atpu atpv atpw atpx atpy atpz
+atqa atqb atqc atqd atqe atqf atqg atqh atqi atqj atqk atql atqm atqn atqo
+atqp atqq atqr atqs atqt atqu atqv atqw atqx atqy atqz atra atrb atrc atrd
+atre atrf atrg atrh atri atrj atrk atrl atrm atrn atro atrp atrq atrr atrs
+atrt atru atrv atrw atrx atry atrz atsa atsb atsc atsd atse atsf atsg atsh
+atsi atsj atsk atsl atsm atsn atso atsp atsq atsr atss atst atsu atsv atsw
+atsx atsy atsz atta attb attc attd atte attf attg atth atti attj attk attl
+attm attn atto attp attq attr atts attt attu attv attw attx atty attz atua
+atub atuc atud atue atuf atug atuh atui atuj atuk atul atum atun atuo atup
+atuq atur atus atut atuu atuv atuw atux atuy atuz atva atvb atvc atvd atve
+atvf atvg atvh atvi atvj atvk atvl atvm atvn atvo atvp atvq atvr atvs atvt
+atvu atvv atvw atvx atvy atvz atwa atwb atwc atwd atwe atwf atwg atwh atwi
+atwj atwk atwl atwm atwn atwo atwp atwq atwr atws atwt atwu atwv atww atwx
+atwy atwz atxa atxb atxc atxd atxe atxf atxg atxh atxi atxj atxk atxl atxm
+atxn atxo atxp atxq atxr atxs atxt atxu atxv atxw atxx atxy atxz atya atyb
+atyc atyd atye atyf atyg atyh atyi atyj atyk atyl atym atyn atyo atyp atyq
+atyr atys atyt atyu atyv atyw atyx atyy atyz atza atzb atzc atzd atze atzf
+atzg atzh atzi atzj atzk atzl atzm atzn atzo atzp atzq atzr atzs atzt atzu
+atzv atzw atzx atzy atzz auaa auab auac auad auae auaf auag auah auai auaj
+auak aual auam auan auao auap auaq auar auas auat auau auav auaw auax auay
+auaz auba aubb aubc aubd aube aubf aubg aubh aubi aubj aubk aubl aubm aubn
+aubo aubp aubq aubr aubs aubt aubu aubv aubw aubx auby aubz auca aucb aucc
+aucd auce aucf aucg auch auci aucj auck aucl aucm aucn auco aucp aucq aucr
+aucs auct aucu aucv aucw aucx aucy aucz auda audb audc audd aude audf audg
+audh audi audj audk audl audm audn audo audp audq audr auds audt audu audv
+audw audx audy audz auea aueb auec aued auee auef aueg aueh auei auej auek
+auel auem auen aueo auep aueq auer aues auet aueu auev auew auex auey auez
+aufa aufb aufc aufd aufe auff aufg aufh aufi aufj aufk aufl aufm aufn aufo
+aufp aufq aufr aufs auft aufu aufv aufw aufx aufy aufz auga augb augc augd
+auge augf augg augh augi augj augk augl augm augn augo augp augq augr augs
+augt augu augv augw augx augy augz auha auhb auhc auhd auhe auhf auhg auhh
+auhi auhj auhk auhl auhm auhn auho auhp auhq auhr auhs auht auhu auhv auhw
+auhx auhy auhz auia auib auic auid auie auif auig auih auii auij auik auil
+auim auin auio auip auiq auir auis auit auiu auiv auiw auix auiy auiz auja
+aujb aujc aujd auje aujf aujg aujh auji aujj aujk aujl aujm aujn aujo aujp
+aujq aujr aujs aujt auju aujv aujw aujx aujy aujz auka aukb aukc aukd auke
+aukf aukg aukh auki aukj aukk aukl aukm aukn auko aukp aukq aukr auks aukt
+auku aukv aukw aukx auky aukz aula aulb aulc auld aule aulf aulg aulh auli
+aulj aulk aull aulm auln aulo aulp aulq aulr auls ault aulu aulv aulw aulx
+auly aulz auma aumb aumc aumd aume aumf aumg aumh aumi aumj aumk auml aumm
+aumn aumo aump aumq aumr aums aumt aumu aumv aumw aumx aumy aumz auna aunb
+aunc aund aune aunf aung aunh auni aunj aunk aunl aunm aunn auno aunp aunq
+aunr auns aunt aunu aunv aunw aunx auny aunz auoa auob auoc auod auoe auof
+auog auoh auoi auoj auok auol auom auon auoo auop auoq auor auos auot auou
+auov auow auox auoy auoz aupa aupb aupc aupd aupe aupf aupg auph aupi aupj
+aupk aupl aupm aupn aupo aupp aupq aupr aups aupt aupu aupv aupw aupx aupy
+aupz auqa auqb auqc auqd auqe auqf auqg auqh auqi auqj auqk auql auqm auqn
+auqo auqp auqq auqr auqs auqt auqu auqv auqw auqx auqy auqz aura aurb aurc
+aurd aure aurf aurg aurh auri aurj aurk aurl aurm aurn auro aurp aurq aurr
+aurs aurt auru aurv aurw aurx aury aurz ausa ausb ausc ausd ause ausf ausg
+aush ausi ausj ausk ausl ausm ausn auso ausp ausq ausr auss aust ausu ausv
+ausw ausx ausy ausz auta autb autc autd aute autf autg auth auti autj autk
+autl autm autn auto autp autq autr auts autt autu autv autw autx auty autz
+auua auub auuc auud auue auuf auug auuh auui auuj auuk auul auum auun auuo
+auup auuq auur auus auut auuu auuv auuw auux auuy auuz auva auvb auvc auvd
+auve auvf auvg auvh auvi auvj auvk auvl auvm auvn auvo auvp auvq auvr auvs
+auvt auvu auvv auvw auvx auvy auvz auwa auwb auwc auwd auwe auwf auwg auwh
+auwi auwj auwk auwl auwm auwn auwo auwp auwq auwr auws auwt auwu auwv auww
+auwx auwy auwz auxa auxb auxc auxd auxe auxf auxg auxh auxi auxj auxk auxl
+auxm auxn auxo auxp auxq auxr auxs auxt auxu auxv auxw auxx auxy auxz auya
+auyb auyc auyd auye auyf auyg auyh auyi auyj auyk auyl auym auyn auyo auyp
+auyq auyr auys auyt auyu auyv auyw auyx auyy auyz auza auzb auzc auzd auze
+auzf auzg auzh auzi auzj auzk auzl auzm auzn auzo auzp auzq auzr auzs auzt
+auzu auzv auzw auzx auzy auzz avaa avab avac avad avae avaf avag avah avai
+avaj avak aval avam avan avao avap avaq avar avas avat avau avav avaw avax
+avay avaz avba avbb avbc avbd avbe avbf avbg avbh avbi avbj avbk avbl avbm
+avbn avbo avbp avbq avbr avbs avbt avbu avbv avbw avbx avby avbz avca avcb
+avcc avcd avce avcf avcg avch avci avcj avck avcl avcm avcn avco avcp avcq
+avcr avcs avct avcu avcv avcw avcx avcy avcz avda avdb avdc avdd avde avdf
+avdg avdh avdi avdj avdk avdl avdm avdn avdo avdp avdq avdr avds avdt avdu
+avdv avdw avdx avdy avdz avea aveb avec aved avee avef aveg aveh avei avej
+avek avel avem aven aveo avep aveq aver aves avet aveu avev avew avex avey
+avez avfa avfb avfc avfd avfe avff avfg avfh avfi avfj avfk avfl avfm avfn
+avfo avfp avfq avfr avfs avft avfu avfv avfw avfx avfy avfz avga avgb avgc
+avgd avge avgf avgg avgh avgi avgj avgk avgl avgm avgn avgo avgp avgq avgr
+avgs avgt avgu avgv avgw avgx avgy avgz avha avhb avhc avhd avhe avhf avhg
+avhh avhi avhj avhk avhl avhm avhn avho avhp avhq avhr avhs avht avhu avhv
+avhw avhx avhy avhz avia avib avic avid avie avif avig avih avii avij avik
+avil avim avin avio avip aviq avir avis avit aviu aviv aviw avix aviy aviz
+avja avjb avjc avjd avje avjf avjg avjh avji avjj avjk avjl avjm avjn avjo
+avjp avjq avjr avjs avjt avju avjv avjw avjx avjy avjz avka avkb avkc avkd
+avke avkf avkg avkh avki avkj avkk avkl avkm avkn avko avkp avkq avkr avks
+avkt avku avkv avkw avkx avky avkz avla avlb avlc avld avle avlf avlg avlh
+avli avlj avlk avll avlm avln avlo avlp avlq avlr avls avlt avlu avlv avlw
+avlx avly avlz avma avmb avmc avmd avme avmf avmg avmh avmi avmj avmk avml
+avmm avmn avmo avmp avmq avmr avms avmt avmu avmv avmw avmx avmy avmz avna
+avnb avnc avnd avne avnf avng avnh avni avnj avnk avnl avnm avnn avno avnp
+avnq avnr avns avnt avnu avnv avnw avnx avny avnz avoa avob avoc avod avoe
+avof avog avoh avoi avoj avok avol avom avon avoo avop avoq avor avos avot
+avou avov avow avox avoy avoz avpa avpb avpc avpd avpe avpf avpg avph avpi
+avpj avpk avpl avpm avpn avpo avpp avpq avpr avps avpt avpu avpv avpw avpx
+avpy avpz avqa avqb avqc avqd avqe avqf avqg avqh avqi avqj avqk avql avqm
+avqn avqo avqp avqq avqr avqs avqt avqu avqv avqw avqx avqy avqz avra avrb
+avrc avrd avre avrf avrg avrh avri avrj avrk avrl avrm avrn avro avrp avrq
+avrr avrs avrt avru avrv avrw avrx avry avrz avsa avsb avsc avsd avse avsf
+avsg avsh avsi avsj avsk avsl avsm avsn avso avsp avsq avsr avss avst avsu
+avsv avsw avsx avsy avsz avta avtb avtc avtd avte avtf avtg avth avti avtj
+avtk avtl avtm avtn avto avtp avtq avtr avts avtt avtu avtv avtw avtx avty
+avtz avua avub avuc avud avue avuf avug avuh avui avuj avuk avul avum avun
+avuo avup avuq avur avus avut avuu avuv avuw avux avuy avuz avva avvb avvc
+avvd avve avvf avvg avvh avvi avvj avvk avvl avvm avvn avvo avvp avvq avvr
+avvs avvt avvu avvv avvw avvx avvy avvz avwa avwb avwc avwd avwe avwf avwg
+avwh avwi avwj avwk avwl avwm avwn avwo avwp avwq avwr avws avwt avwu avwv
+avww avwx avwy avwz avxa avxb avxc avxd avxe avxf avxg avxh avxi avxj avxk
+avxl avxm avxn avxo avxp avxq avxr avxs avxt avxu avxv avxw avxx avxy avxz
+avya avyb avyc avyd avye avyf avyg avyh avyi avyj avyk avyl avym avyn avyo
+avyp avyq avyr avys avyt avyu avyv avyw avyx avyy avyz avza avzb avzc avzd
+avze avzf avzg avzh avzi avzj avzk avzl avzm avzn avzo avzp avzq avzr avzs
+avzt avzu avzv avzw avzx avzy avzz awaa awab awac awad awae awaf awag awah
+awai awaj awak awal awam awan awao awap awaq awar awas awat awau awav awaw
+awax away awaz awba awbb awbc awbd awbe awbf awbg awbh awbi awbj awbk awbl
+awbm awbn awbo awbp awbq awbr awbs awbt awbu awbv awbw awbx awby awbz awca
+awcb awcc awcd awce awcf awcg awch awci awcj awck awcl awcm awcn awco awcp
+awcq awcr awcs awct awcu awcv awcw awcx awcy awcz awda awdb awdc awdd awde
+awdf awdg awdh awdi awdj awdk awdl awdm awdn awdo awdp awdq awdr awds awdt
+awdu awdv awdw awdx awdy awdz awea aweb awec awed awee awef aweg aweh awei
+awej awek awel awem awen aweo awep aweq awer awes awet aweu awev awew awex
+awey awez awfa awfb awfc awfd awfe awff awfg awfh awfi awfj awfk awfl awfm
+awfn awfo awfp awfq awfr awfs awft awfu awfv awfw awfx awfy awfz awga awgb
+awgc awgd awge awgf awgg awgh awgi awgj awgk awgl awgm awgn awgo awgp awgq
+awgr awgs awgt awgu awgv awgw awgx awgy awgz awha awhb awhc awhd awhe awhf
+awhg awhh awhi awhj awhk awhl awhm awhn awho awhp awhq awhr awhs awht awhu
+awhv awhw awhx awhy awhz awia awib awic awid awie awif awig awih awii awij
+awik awil awim awin awio awip awiq awir awis awit awiu awiv awiw awix awiy
+awiz awja awjb awjc awjd awje awjf awjg awjh awji awjj awjk awjl awjm awjn
+awjo awjp awjq awjr awjs awjt awju awjv awjw awjx awjy awjz awka awkb awkc
+awkd awke awkf awkg awkh awki awkj awkk awkl awkm awkn awko awkp awkq awkr
+awks awkt awku awkv awkw awkx awky awkz awla awlb awlc awld awle awlf awlg
+awlh awli awlj awlk awll awlm awln awlo awlp awlq awlr awls awlt awlu awlv
+awlw awlx awly awlz awma awmb awmc awmd awme awmf awmg awmh awmi awmj awmk
+awml awmm awmn awmo awmp awmq awmr awms awmt awmu awmv awmw awmx awmy awmz
+awna awnb awnc awnd awne awnf awng awnh awni awnj awnk awnl awnm awnn awno
+awnp awnq awnr awns awnt awnu awnv awnw awnx awny awnz awoa awob awoc awod
+awoe awof awog awoh awoi awoj awok awol awom awon awoo awop awoq awor awos
+awot awou awov awow awox awoy awoz awpa awpb awpc awpd awpe awpf awpg awph
+awpi awpj awpk awpl awpm awpn awpo awpp awpq awpr awps awpt awpu awpv awpw
+awpx awpy awpz awqa awqb awqc awqd awqe awqf awqg awqh awqi awqj awqk awql
+awqm awqn awqo awqp awqq awqr awqs awqt awqu awqv awqw awqx awqy awqz awra
+awrb awrc awrd awre awrf awrg awrh awri awrj awrk awrl awrm awrn awro awrp
+awrq awrr awrs awrt awru awrv awrw awrx awry awrz awsa awsb awsc awsd awse
+awsf awsg awsh awsi awsj awsk awsl awsm awsn awso awsp awsq awsr awss awst
+awsu awsv awsw awsx awsy awsz awta awtb awtc awtd awte awtf awtg awth awti
+awtj awtk awtl awtm awtn awto awtp awtq awtr awts awtt awtu awtv awtw awtx
+awty awtz awua awub awuc awud awue awuf awug awuh awui awuj awuk awul awum
+awun awuo awup awuq awur awus awut awuu awuv awuw awux awuy awuz awva awvb
+awvc awvd awve awvf awvg awvh awvi awvj awvk awvl awvm awvn awvo awvp awvq
+awvr awvs awvt awvu awvv awvw awvx awvy awvz awwa awwb awwc awwd awwe awwf
+awwg awwh awwi awwj awwk awwl awwm awwn awwo awwp awwq awwr awws awwt awwu
+awwv awww awwx awwy awwz awxa awxb awxc awxd awxe awxf awxg awxh awxi awxj
+awxk awxl awxm awxn awxo awxp awxq awxr awxs awxt awxu awxv awxw awxx awxy
+awxz awya awyb awyc awyd awye awyf awyg awyh awyi awyj awyk awyl awym awyn
+awyo awyp awyq awyr awys awyt awyu awyv awyw awyx awyy awyz awza awzb awzc
+awzd awze awzf awzg awzh awzi awzj awzk awzl awzm awzn awzo awzp awzq awzr
+awzs awzt awzu awzv awzw awzx awzy awzz axaa axab axac axad axae axaf axag
+axah axai axaj axak axal axam axan axao axap axaq axar axas axat axau axav
+axaw axax axay axaz axba axbb axbc axbd axbe axbf axbg axbh axbi axbj axbk
+axbl axbm axbn axbo axbp axbq axbr axbs axbt axbu axbv axbw axbx axby axbz
+axca axcb axcc axcd axce axcf axcg axch axci axcj axck axcl axcm axcn axco
+axcp axcq axcr axcs axct axcu axcv axcw axcx axcy axcz axda axdb axdc axdd
+axde axdf axdg axdh axdi axdj axdk axdl axdm axdn axdo axdp axdq axdr axds
+axdt axdu axdv axdw axdx axdy axdz axea axeb axec axed axee axef axeg axeh
+axei axej axek axel axem axen axeo axep axeq axer axes axet axeu axev axew
+axex axey axez axfa axfb axfc axfd axfe axff axfg axfh axfi axfj axfk axfl
+axfm axfn axfo axfp axfq axfr axfs axft axfu axfv axfw axfx axfy axfz axga
+axgb axgc axgd axge axgf axgg axgh axgi axgj axgk axgl axgm axgn axgo axgp
+axgq axgr axgs axgt axgu axgv axgw axgx axgy axgz axha axhb axhc axhd axhe
+axhf axhg axhh axhi axhj axhk axhl axhm axhn axho axhp axhq axhr axhs axht
+axhu axhv axhw axhx axhy axhz axia axib axic axid axie axif axig axih axii
+axij axik axil axim axin axio axip axiq axir axis axit axiu axiv axiw axix
+axiy axiz axja axjb axjc axjd axje axjf axjg axjh axji axjj axjk axjl axjm
+axjn axjo axjp axjq axjr axjs axjt axju axjv axjw axjx axjy axjz axka axkb
+axkc axkd axke axkf axkg axkh axki axkj axkk axkl axkm axkn axko axkp axkq
+axkr axks axkt axku axkv axkw axkx axky axkz axla axlb axlc axld axle axlf
+axlg axlh axli axlj axlk axll axlm axln axlo axlp axlq axlr axls axlt axlu
+axlv axlw axlx axly axlz axma axmb axmc axmd axme axmf axmg axmh axmi axmj
+axmk axml axmm axmn axmo axmp axmq axmr axms axmt axmu axmv axmw axmx axmy
+axmz axna axnb axnc axnd axne axnf axng axnh axni axnj axnk axnl axnm axnn
+axno axnp axnq axnr axns axnt axnu axnv axnw axnx axny axnz axoa axob axoc
+axod axoe axof axog axoh axoi axoj axok axol axom axon axoo axop axoq axor
+axos axot axou axov axow axox axoy axoz axpa axpb axpc axpd axpe axpf axpg
+axph axpi axpj axpk axpl axpm axpn axpo axpp axpq axpr axps axpt axpu axpv
+axpw axpx axpy axpz axqa axqb axqc axqd axqe axqf axqg axqh axqi axqj axqk
+axql axqm axqn axqo axqp axqq axqr axqs axqt axqu axqv axqw axqx axqy axqz
+axra axrb axrc axrd axre axrf axrg axrh axri axrj axrk axrl axrm axrn axro
+axrp axrq axrr axrs axrt axru axrv axrw axrx axry axrz axsa axsb axsc axsd
+axse axsf axsg axsh axsi axsj axsk axsl axsm axsn axso axsp axsq axsr axss
+axst axsu axsv axsw axsx axsy axsz axta axtb axtc axtd axte axtf axtg axth
+axti axtj axtk axtl axtm axtn axto axtp axtq axtr axts axtt axtu axtv axtw
+axtx axty axtz axua axub axuc axud axue axuf axug axuh axui axuj axuk axul
+axum axun axuo axup axuq axur axus axut axuu axuv axuw axux axuy axuz axva
+axvb axvc axvd axve axvf axvg axvh axvi axvj axvk axvl axvm axvn axvo axvp
+axvq axvr axvs axvt axvu axvv axvw axvx axvy axvz axwa axwb axwc axwd axwe
+axwf axwg axwh axwi axwj axwk axwl axwm axwn axwo axwp axwq axwr axws axwt
+axwu axwv axww axwx axwy axwz axxa axxb axxc axxd axxe axxf axxg axxh axxi
+axxj axxk axxl axxm axxn axxo axxp axxq axxr axxs axxt axxu axxv axxw axxx
+axxy axxz axya axyb axyc axyd axye axyf axyg axyh axyi axyj axyk axyl axym
+axyn axyo axyp axyq axyr axys axyt axyu axyv axyw axyx axyy axyz axza axzb
+axzc axzd axze axzf axzg axzh axzi axzj axzk axzl axzm axzn axzo axzp axzq
+axzr axzs axzt axzu axzv axzw axzx axzy axzz ayaa ayab ayac ayad ayae ayaf
+ayag ayah ayai ayaj ayak ayal ayam ayan ayao ayap ayaq ayar ayas ayat ayau
+ayav ayaw ayax ayay ayaz ayba aybb aybc aybd aybe aybf aybg aybh aybi aybj
+aybk aybl aybm aybn aybo aybp aybq aybr aybs aybt aybu aybv aybw aybx ayby
+aybz ayca aycb aycc aycd ayce aycf aycg aych ayci aycj ayck aycl aycm aycn
+ayco aycp aycq aycr aycs ayct aycu aycv aycw aycx aycy aycz ayda aydb aydc
+aydd ayde aydf aydg aydh aydi aydj aydk aydl aydm aydn aydo aydp aydq aydr
+ayds aydt aydu aydv aydw aydx aydy aydz ayea ayeb ayec ayed ayee ayef ayeg
+ayeh ayei ayej ayek ayel ayem ayen ayeo ayep ayeq ayer ayes ayet ayeu ayev
+ayew ayex ayey ayez ayfa ayfb ayfc ayfd ayfe ayff ayfg ayfh ayfi ayfj ayfk
+ayfl ayfm ayfn ayfo ayfp ayfq ayfr ayfs ayft ayfu ayfv ayfw ayfx ayfy ayfz
+ayga aygb aygc aygd ayge aygf aygg aygh aygi aygj aygk aygl aygm aygn aygo
+aygp aygq aygr aygs aygt aygu aygv aygw aygx aygy aygz ayha ayhb ayhc ayhd
+ayhe ayhf ayhg ayhh ayhi ayhj ayhk ayhl ayhm ayhn ayho ayhp ayhq ayhr ayhs
+ayht ayhu ayhv ayhw ayhx ayhy ayhz ayia ayib ayic ayid ayie ayif ayig ayih
+ayii ayij ayik ayil ayim ayin ayio ayip ayiq ayir ayis ayit ayiu ayiv ayiw
+ayix ayiy ayiz ayja ayjb ayjc ayjd ayje ayjf ayjg ayjh ayji ayjj ayjk ayjl
+ayjm ayjn ayjo ayjp ayjq ayjr ayjs ayjt ayju ayjv ayjw ayjx ayjy ayjz ayka
+aykb aykc aykd ayke aykf aykg aykh ayki aykj aykk aykl aykm aykn ayko aykp
+aykq aykr ayks aykt ayku aykv aykw aykx ayky aykz ayla aylb aylc ayld ayle
+aylf aylg aylh ayli aylj aylk ayll aylm ayln aylo aylp aylq aylr ayls aylt
+aylu aylv aylw aylx ayly aylz ayma aymb aymc aymd ayme aymf aymg aymh aymi
+aymj aymk ayml aymm aymn aymo aymp aymq aymr ayms aymt aymu aymv aymw aymx
+aymy aymz ayna aynb aync aynd ayne aynf ayng aynh ayni aynj aynk aynl aynm
+aynn ayno aynp aynq aynr ayns aynt aynu aynv aynw aynx ayny aynz ayoa ayob
+ayoc ayod ayoe ayof ayog ayoh ayoi ayoj ayok ayol ayom ayon ayoo ayop ayoq
+ayor ayos ayot ayou ayov ayow ayox ayoy ayoz aypa aypb aypc aypd aype aypf
+aypg ayph aypi aypj aypk aypl aypm aypn aypo aypp aypq aypr ayps aypt aypu
+aypv aypw aypx aypy aypz ayqa ayqb ayqc ayqd ayqe ayqf ayqg ayqh ayqi ayqj
+ayqk ayql ayqm ayqn ayqo ayqp ayqq ayqr ayqs ayqt ayqu ayqv ayqw ayqx ayqy
+ayqz ayra ayrb ayrc ayrd ayre ayrf ayrg ayrh ayri ayrj ayrk ayrl ayrm ayrn
+ayro ayrp ayrq ayrr ayrs ayrt ayru ayrv ayrw ayrx ayry ayrz aysa aysb aysc
+aysd ayse aysf aysg aysh aysi aysj aysk aysl aysm aysn ayso aysp aysq aysr
+ayss ayst aysu aysv aysw aysx aysy aysz ayta aytb aytc aytd ayte aytf aytg
+ayth ayti aytj aytk aytl aytm aytn ayto aytp aytq aytr ayts aytt aytu aytv
+aytw aytx ayty aytz ayua ayub ayuc ayud ayue ayuf ayug ayuh ayui ayuj ayuk
+ayul ayum ayun ayuo ayup ayuq ayur ayus ayut ayuu ayuv ayuw ayux ayuy ayuz
+ayva ayvb ayvc ayvd ayve ayvf ayvg ayvh ayvi ayvj ayvk ayvl ayvm ayvn ayvo
+ayvp ayvq ayvr ayvs ayvt ayvu ayvv ayvw ayvx ayvy ayvz aywa aywb aywc aywd
+aywe aywf aywg aywh aywi aywj aywk aywl aywm aywn aywo aywp aywq aywr ayws
+aywt aywu aywv ayww aywx aywy aywz ayxa ayxb ayxc ayxd ayxe ayxf ayxg ayxh
+ayxi ayxj ayxk ayxl ayxm ayxn ayxo ayxp ayxq ayxr ayxs ayxt ayxu ayxv ayxw
+ayxx ayxy ayxz ayya ayyb ayyc ayyd ayye ayyf ayyg ayyh ayyi ayyj ayyk ayyl
+ayym ayyn ayyo ayyp ayyq ayyr ayys ayyt ayyu ayyv ayyw ayyx ayyy ayyz ayza
+ayzb ayzc ayzd ayze ayzf ayzg ayzh ayzi ayzj ayzk ayzl ayzm ayzn ayzo ayzp
+ayzq ayzr ayzs ayzt ayzu ayzv ayzw ayzx ayzy ayzz azaa azab azac azad azae
+azaf azag azah azai azaj azak azal azam azan azao azap azaq azar azas azat
+azau azav azaw azax azay azaz azba azbb azbc azbd azbe azbf azbg azbh azbi
+azbj azbk azbl azbm azbn azbo azbp azbq azbr azbs azbt azbu azbv azbw azbx
+azby azbz azca azcb azcc azcd azce azcf azcg azch azci azcj azck azcl azcm
+azcn azco azcp azcq azcr azcs azct azcu azcv azcw azcx azcy azcz azda azdb
+azdc azdd azde azdf azdg azdh azdi azdj azdk azdl azdm azdn azdo azdp azdq
+azdr azds azdt azdu azdv azdw azdx azdy azdz azea azeb azec azed azee azef
+azeg azeh azei azej azek azel azem azen azeo azep azeq azer azes azet azeu
+azev azew azex azey azez azfa azfb azfc azfd azfe azff azfg azfh azfi azfj
+azfk azfl azfm azfn azfo azfp azfq azfr azfs azft azfu azfv azfw azfx azfy
+azfz azga azgb azgc azgd azge azgf azgg azgh azgi azgj azgk azgl azgm azgn
+azgo azgp azgq azgr azgs azgt azgu azgv azgw azgx azgy azgz azha azhb azhc
+azhd azhe azhf azhg azhh azhi azhj azhk azhl azhm azhn azho azhp azhq azhr
+azhs azht azhu azhv azhw azhx azhy azhz azia azib azic azid azie azif azig
+azih azii azij azik azil azim azin azio azip aziq azir azis azit aziu aziv
+aziw azix aziy aziz azja azjb azjc azjd azje azjf azjg azjh azji azjj azjk
+azjl azjm azjn azjo azjp azjq azjr azjs azjt azju azjv azjw azjx azjy azjz
+azka azkb azkc azkd azke azkf azkg azkh azki azkj azkk azkl azkm azkn azko
+azkp azkq azkr azks azkt azku azkv azkw azkx azky azkz azla azlb azlc azld
+azle azlf azlg azlh azli azlj azlk azll azlm azln azlo azlp azlq azlr azls
+azlt azlu azlv azlw azlx azly azlz azma azmb azmc azmd azme azmf azmg azmh
+azmi azmj azmk azml azmm azmn azmo azmp azmq azmr azms azmt azmu azmv azmw
+azmx azmy azmz azna aznb aznc aznd azne aznf azng aznh azni aznj aznk aznl
+aznm aznn azno aznp aznq aznr azns aznt aznu aznv aznw aznx azny aznz azoa
+azob azoc azod azoe azof azog azoh azoi azoj azok azol azom azon azoo azop
+azoq azor azos azot azou azov azow azox azoy azoz azpa azpb azpc azpd azpe
+azpf azpg azph azpi azpj azpk azpl azpm azpn azpo azpp azpq azpr azps azpt
+azpu azpv azpw azpx azpy azpz azqa azqb azqc azqd azqe azqf azqg azqh azqi
+azqj azqk azql azqm azqn azqo azqp azqq azqr azqs azqt azqu azqv azqw azqx
+azqy azqz azra azrb azrc azrd azre azrf azrg azrh azri azrj azrk azrl azrm
+azrn azro azrp azrq azrr azrs azrt azru azrv azrw azrx azry azrz azsa azsb
+azsc azsd azse azsf azsg azsh azsi azsj azsk azsl azsm azsn azso azsp azsq
+azsr azss azst azsu azsv azsw azsx azsy azsz azta aztb aztc aztd azte aztf
+aztg azth azti aztj aztk aztl aztm aztn azto aztp aztq aztr azts aztt aztu
+aztv aztw aztx azty aztz azua azub azuc azud azue azuf azug azuh azui azuj
+azuk azul azum azun azuo azup azuq azur azus azut azuu azuv azuw azux azuy
+azuz azva azvb azvc azvd azve azvf azvg azvh azvi azvj azvk azvl azvm azvn
+azvo azvp azvq azvr azvs azvt azvu azvv azvw azvx azvy azvz azwa azwb azwc
+azwd azwe azwf azwg azwh azwi azwj azwk azwl azwm azwn azwo azwp azwq azwr
+azws azwt azwu azwv azww azwx azwy azwz azxa azxb azxc azxd azxe azxf azxg
+azxh azxi azxj azxk azxl azxm azxn azxo azxp azxq azxr azxs azxt azxu azxv
+azxw azxx azxy azxz azya azyb azyc azyd azye azyf azyg azyh azyi azyj azyk
+azyl azym azyn azyo azyp azyq azyr azys azyt azyu azyv azyw azyx azyy azyz
+azza azzb azzc azzd azze azzf azzg azzh azzi azzj azzk azzl azzm azzn azzo
+azzp azzq azzr azzs azzt azzu azzv azzw azzx azzy azzz baaa baab baac baad
+baae baaf baag baah baai baaj baak baal baam baan baao baap baaq baar baas
+baat baau baav baaw baax baay baaz baba babb babc babd babe babf babg babh
+babi babj babk babl babm babn babo babp babq babr babs babt babu babv babw
+babx baby babz baca bacb bacc bacd bace bacf bacg bach baci bacj back bacl
+bacm bacn baco bacp bacq bacr bacs bact bacu bacv bacw bacx bacy bacz bada
+badb badc badd bade badf badg badh badi badj badk badl badm badn bado badp
+badq badr bads badt badu badv badw badx bady badz baea baeb baec baed baee
+baef baeg baeh baei baej baek bael baem baen baeo baep baeq baer baes baet
+baeu baev baew baex baey baez bafa bafb bafc bafd bafe baff bafg bafh bafi
+bafj bafk bafl bafm bafn bafo bafp bafq bafr bafs baft bafu bafv bafw bafx
+bafy bafz baga bagb bagc bagd bage bagf bagg bagh bagi bagj bagk bagl bagm
+bagn bago bagp bagq bagr bags bagt bagu bagv bagw bagx bagy bagz baha bahb
+bahc bahd bahe bahf bahg bahh bahi bahj bahk bahl bahm bahn baho bahp bahq
+bahr bahs baht bahu bahv bahw bahx bahy bahz baia baib baic baid baie baif
+baig baih baii baij baik bail baim bain baio baip baiq bair bais bait baiu
+baiv baiw baix baiy baiz baja bajb bajc bajd baje bajf bajg bajh baji bajj
+bajk bajl bajm bajn bajo bajp bajq bajr bajs bajt baju bajv bajw bajx bajy
+bajz baka bakb bakc bakd bake bakf bakg bakh baki bakj bakk bakl bakm bakn
+bako bakp bakq bakr baks bakt baku bakv bakw bakx baky bakz bala balb balc
+bald bale balf balg balh bali balj balk ball balm baln balo balp balq balr
+bals balt balu balv balw balx baly balz bama bamb bamc bamd bame bamf bamg
+bamh bami bamj bamk baml bamm bamn bamo bamp bamq bamr bams bamt bamu bamv
+bamw bamx bamy bamz bana banb banc band bane banf bang banh bani banj bank
+banl banm bann bano banp banq banr bans bant banu banv banw banx bany banz
+baoa baob baoc baod baoe baof baog baoh baoi baoj baok baol baom baon baoo
+baop baoq baor baos baot baou baov baow baox baoy baoz bapa bapb bapc bapd
+bape bapf bapg baph bapi bapj bapk bapl bapm bapn bapo bapp bapq bapr baps
+bapt bapu bapv bapw bapx bapy bapz baqa baqb baqc baqd baqe baqf baqg baqh
+baqi baqj baqk baql baqm baqn baqo baqp baqq baqr baqs baqt baqu baqv baqw
+baqx baqy baqz bara barb barc bard bare barf barg barh bari barj bark barl
+barm barn baro barp barq barr bars bart baru barv barw barx bary barz basa
+basb basc basd base basf basg bash basi basj bask basl basm basn baso basp
+basq basr bass bast basu basv basw basx basy basz bata batb batc batd bate
+batf batg bath bati batj batk batl batm batn bato batp batq batr bats batt
+batu batv batw batx baty batz baua baub bauc baud baue bauf baug bauh baui
+bauj bauk baul baum baun bauo baup bauq baur baus baut bauu bauv bauw baux
+bauy bauz bava bavb bavc bavd bave bavf bavg bavh bavi bavj bavk bavl bavm
+bavn bavo bavp bavq bavr bavs bavt bavu bavv bavw bavx bavy bavz bawa bawb
+bawc bawd bawe bawf bawg bawh bawi bawj bawk bawl bawm bawn bawo bawp bawq
+bawr baws bawt bawu bawv baww bawx bawy bawz baxa baxb baxc baxd baxe baxf
+baxg baxh baxi baxj baxk baxl baxm baxn baxo baxp baxq baxr baxs baxt baxu
+baxv baxw baxx baxy baxz baya bayb bayc bayd baye bayf bayg bayh bayi bayj
+bayk bayl baym bayn bayo bayp bayq bayr bays bayt bayu bayv bayw bayx bayy
+bayz baza bazb bazc bazd baze bazf bazg bazh bazi bazj bazk bazl bazm bazn
+bazo bazp bazq bazr bazs bazt bazu bazv bazw bazx bazy bazz bbaa bbab bbac
+bbad bbae bbaf bbag bbah bbai bbaj bbak bbal bbam bban bbao bbap bbaq bbar
+bbas bbat bbau bbav bbaw bbax bbay bbaz bbba bbbb
--- /dev/null
+let x = if x then a else b in x
+
+let x = if StringSet.mem "*" sections then a else b in x
+
+let x =
+if StringSet.mem "*" sections then fun _ -> true else
+ fun x -> StringSet.mem x sections
+in x
--- /dev/null
+value f ~a:_ ?b:_ = ();
--- /dev/null
+open Format;
+
+module S = Set.Make String;
+
+type term =
+ [ Lambda of string and term
+ | Atom of string
+ | App of term and term
+ | Opt of term and option term and term
+ ];
+
+value free_vars =
+ let rec fv t env free =
+ match t with
+ [ Lambda x t -> fv t (S.add x env) free
+ | Atom x -> if S.mem x env then free else S.add x free
+ | App t1 t2 -> fv t1 env (fv t2 env free)
+ | Opt _ _ _ -> assert False ]
+ in fun t -> fv t S.empty S.empty;
+
+value print_set f s = do {
+ fprintf f "@[<2>{ ";
+ S.iter (fprintf f "%s@ ") s;
+ fprintf f "}@]";
+};
+
+value t1 = Lambda "x" (App (Lambda "y" (App (Atom "y") (Atom "x"))) (Lambda "x" (Atom "x")));
+value t2 = Lambda "x" (App (Lambda "y" (App (Atom "y") (Atom "x"))) (Lambda "z" (Atom "z")));
+value t3 = Lambda "x" (App (Lambda "y" (App (Atom "y") (Atom "x"))) (Lambda "x" (Atom "z")));
+value t4 = Lambda "a" (App (Lambda "y" (App (Atom "y") (Atom "x"))) (Lambda "x" (Atom "z")));
+
+printf "t1: %a@." print_set (free_vars t1);
+printf "t2: %a@." print_set (free_vars t2);
+printf "t3: %a@." print_set (free_vars t3);
+printf "t4: %a@." print_set (free_vars t4);
+
+class fold ['accu] init =
+ object (o : 'self_type)
+ value accu : 'accu = init;
+ method accu = accu;
+ method term t =
+ match t with
+ [ Lambda x t -> (o#string x)#term t
+ | Atom x -> o#string x
+ | App t1 t2 -> (o#term t1)#term t2
+ | Opt t1 ot t2 -> ((o#term t1)#option (fun o -> o#term) ot)#term t2 ];
+ method string : string -> 'self_type = fun _ -> o;
+ method option : ! 'a. ('self_type -> 'a -> 'self_type) -> option 'a -> 'self_type =
+ fun f opt ->
+ match opt with
+ [ None -> o
+ | Some x -> f o x ];
+ end;
+
+class fold_atoms ['accu] f init =
+ object (o : 'self_type)
+ inherit fold ['accu] init as super;
+ method term t =
+ match t with
+ [ Atom x -> {< accu = f x accu >}
+ | _ -> super#term t ];
+ end;
+
+value t5 = Opt (Atom "a") (Some (Atom "b")) (Atom "c");
+
+value atoms = ((new fold_atoms S.add S.empty)#term t5)#accu;
+
+printf "atoms: %a@." print_set atoms;
--- /dev/null
+#default_quotation "expr";;
+Lwt.return
+ << 3 + >>
--- /dev/null
+DEFINE A = 42;
+DEFINE B = 51;
+
+IFDEF A THEN
+ value a_should_be_present = B + 2;
+ print_int (a_should_be_present + 1);
+ENDIF;
+
+print_int (a_should_be_present + 2);
+
+IFNDEF C THEN
+ print_int (a_should_be_present + 3);
+ENDIF;
+
+IFNDEF C THEN
+ print_int (a_should_be_present + 4);
+ELSE
+ print_int (c_should_not_be_present + 1);
+ENDIF;
+
+IFDEF C THEN
+ print_int (c_should_not_be_present + 2);
+ELSIF
+ print_int (A * a_should_be_present + 5);
+ENDIF;
+
+IFDEF DNE THEN
+ print_int (c_should_not_be_present + 2);
+ELSIF
+ print_int (A * a_should_be_present + 5);
+ENDIF;
+
+IFDEF OPT THEN
+ print_int (c_should_not_be_present + 2);
+ELSIF
+ print_int (A * a_should_be_present + 5);
+ENDIF;
+
+value e =
+ IFDEF DNE THEN
+ print_int (c_should_not_be_present + 2)
+ ELSE
+ print_int (A * a_should_be_present + 5)
+ ENDIF;
+
+value f =
+ fun _ ->
+ IFDEF DNE THEN
+ print_int (c_should_not_be_present + 2)
+ ELSE
+ print_int (A * a_should_be_present + 5)
+ ENDIF;
+
+IFDEF A THEN
+ DEFINE Z = "ok";
+ELSE
+ DEFINE Z = "ko";
+ENDIF;
+
+Z;
+
+IFDEF DNE THEN
+ DEFINE Z = "ko2";
+ELSE
+ DEFINE Z = "ok2";
+ENDIF;
+
+Z;
+
+pouet;
--- /dev/null
+DEFINE A;
+DEFINE B;
+
+IFDEF A THEN
+ value a_should_be_present : int;
+ENDIF;
+
+IFNDEF C THEN
+ value b_should_be_present : int;
+ENDIF;
+
+IFNDEF C THEN
+ value c_should_be_present : int;
+ELSE
+ value a_should_NOT_be_present : int;
+END;
+
+IFDEF C THEN
+ value b_should_NOT_be_present : int;
+ELSE
+ value d_should_be_present : int;
+ value e_should_be_present : int;
+ENDIF;
+
+value f_should_be_present : int;
--- /dev/null
+IFNDEF UNDEFINED_VARIABLE THEN
+ DEFINE SQUARE (x) = x * x ;;
+ DEFINE DOUBLE_SQUARE (x) = (SQUARE x) * 2 ;;
+END;;
+
+Printf.printf "%d\n" (DOUBLE_SQUARE(42)) ;;
--- /dev/null
+IFNDEF UNDEFINED_VARIABLE THEN
+ DEFINE UNDEFINED_VARIABLE
+
+ IFDEF UNDEFINED_VARIABLE THEN
+ DEFINE SQUARE (x) = x * x ;;
+ DEFINE DOUBLE_SQUARE (x) = (SQUARE x) * 2 ;;
+ END
+END;;
+
+Printf.printf "%d\n" (DOUBLE_SQUARE(42)) ;;
+
--- /dev/null
+<:expr< EXTEND G expr: [[ "foo" -> <:expr< foo >> ]]; END >>;
--- /dev/null
+let x =
+ match y with
+ | A z -> z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z z
+ | B l ->
+ (match l with
+ | [] -> ()
+ | x::xs -> p x; self xs)
+ | C -> ()
+in x
--- /dev/null
+open Camlp4.PreCast;
+
+let _loc = Loc.ghost in
+let e = <:expr< parser [: `"a" :] -> t >> in
+let a =
+ match e with
+ [ <:expr< parser [: `$str:x$ :] -> t >> -> x
+ | _ -> assert False ]
+in Format.printf "a: %S@." a;
+
--- /dev/null
+open Camlp4.PreCast;
+value _loc = Loc.ghost;
+
+module Term = struct
+ type patt =
+ [ PApp of patt and patt
+ | PAny
+ | PVar of string
+ | POlb of string and expr ]
+ and expr =
+ [ EApp of expr and expr
+ | EVar of string
+ | ELam of patt and expr ];
+end;
+
+module MetaTerm = MetaGenerator Term;
--- /dev/null
+#load "camlp4of.cma";;
+open Camlp4.PreCast;;
+module M = Ast.Meta.Make(Ast.Meta.MetaGhostLoc);;
+let ghost = Loc.ghost;;
+M.Expr.meta_ctyp ghost <:ctyp@ghost< int >>;;
--- /dev/null
+class virtual c1 = object method virtual private f : unit end;;
+class virtual c2 = object method private virtual f : unit end;;
+
+<:str_item< class virtual c1 = object method virtual private f : unit; end >>;;
+<:str_item< class virtual c2 = object method private virtual f : unit; end >>;;
+<:str_item< class virtual c2 = object method $private:p$ virtual f : unit; end >>;;
+<:str_item< class virtual c2 = object method virtual $private:p$ f : unit; end >>;;
+<:str_item< class $virtual:v$ c2 [$t1$] =
+ object ($pat:self$) method virtual $private:p$ $lid:f$ : $t2$; end >>;;
--- /dev/null
+module type S = sig type t end
+module F (A : S) = struct
+ type t2 = A.t
+ module A = A
+end
+
+module A = struct type t = int end
+
+module type S3 = sig
+ module M : S
+end
+
+module type S2 = S with type t = F(A).t2
+
+module type S4 = S3 with module M = F(A).A
--- /dev/null
+module type S = sig type t = 'a; end;
+module F (A : S) = struct
+ type t2 = A.t;
+end;
+
+module A = struct type t = int; end;
+
+module type S2 = S with type t = (F A).t2;
--- /dev/null
+let _ : int = 42
+let (+) = M.(+)
+let (+) = M.(+) in 42
+let (+) : int -> int -> int = (+)
+let (+) : int -> int -> int = (+) in 42
+let None = None
+let None : int option = None
--- /dev/null
+val (+) : int -> int -> int
--- /dev/null
+fun x when x <> 0 -> x / 42
+;;
+object val virtual mutable x : int val mutable virtual y : int end
+;;
+- !r
+;;
+! -r
+;;
+-32
+;;
+- - 32
+;;
+!(r.b)
+;;
+(!r).b = !r.b
+;;
+let l : (unit -> int) list = [(fun _ -> 42); (fun _ -> 42)]
--- /dev/null
+type t 'a = [ Nil | Cons of 'a and t 'a ];
+
+module A : sig
+ value app_hd : t 'a -> ('a -> 'a) -> option 'a;
+end = struct
+ value app_hd x f =
+ match x with
+ [ Nil -> None
+ | Cons x _ -> Some (f x) ];
+end;
+open A;
+
+module M = struct
+ external mk_nil : unit -> t 'a = "%identity";
+ value nil = mk_nil ();
+ (* value is_nil x = x = nil; *)
+end;
+
+(* M.app_hd succ (M.Cons 1 M.Nil); *)
+(* M.hd (M.Cons 1 M.Nil); *)
+app_hd (M.nil : t 'a) (fun (x : int) -> (x : 'a));
--- /dev/null
+open Camlp4.PreCast;
+type t = [ A of t and t | B of string ];
+value lex = Lexer.mk ();
+
+ (* value list0 symb =
+ let rec loop al =
+ parser
+ [ [: a = symb; s :] -> loop [a :: al] s
+ | [: :] -> al ]
+ in
+ parser [: a = loop [] :] -> List.rev a
+ ;
+ value list0sep symb sep =
+ let rec kont al =
+ parser
+ [ [: v = sep; a = symb; s :] -> kont [a :: al] s
+ | [: :] -> al ]
+ in
+ parser
+ [ [: a = symb; s :] -> List.rev (kont [a] s)
+ | [: :] -> [] ]
+ ;
+ value list1 symb =
+ let rec loop al =
+ parser
+ [ [: a = symb; s :] -> loop [a :: al] s
+ | [: :] -> al ]
+ in
+ parser [: a = symb; s :] -> List.rev (loop [a] s)
+ ;
+ value list1sep symb sep =
+ let rec kont al =
+ parser
+ [ [: v = sep; a = symb; s :] -> kont [a :: al] s
+ | [: :] -> al ]
+ in
+ parser [: a = symb; s :] -> List.rev (kont [a] s)
+ ; *)
+
+value list1 =
+ let rec self stream acc =
+ match stream with parser
+ [ [: `(EOI, _) :] -> acc
+ | [: `(LIDENT x, _); xs :] -> self xs (A acc (B x))
+ | [: `(BLANKS _ | NEWLINE, _); xs :] -> self xs acc ]
+ in
+ parser [: `(LIDENT x, _); xs :] -> self xs (B x);
+value rec length x acc =
+ match x with
+ [ A x y -> length x (length y acc)
+ | B _ -> succ acc ];
+(* value length _ _ = -1; *)
+open Format;
+try
+ let f = Sys.argv.(1) in
+ let () = printf "parsing...@." in
+ let a = list1 (lex (Loc.mk f) (Stream.of_channel (open_in f))) in
+ let () = printf "counting...@." in
+ let n = length a 0 in
+ printf "%d@." n
+with e -> eprintf "error: %a@." Camlp4.ErrorHandler.print e;
--- /dev/null
+let i = "toto" in do { (let i = 42 in print_int i); print_string i };
+let i = "toto" in do { print_string i; let i = 42 in print_int i; print_int i };
+let i = "toto" in do {
+ (let i = 42 in print_int i);
+ let i = i ^ i;
+ let i = i ^ i;
+ print_string i;
+ print_string i;
+ let i = i ^ i;
+ print_string i };
--- /dev/null
+let i = "toto" in ((let i = 42 in print_int i); print_string i)
--- /dev/null
+
+type xml = Elt of string * xml list | Pcdata of string
+
+let pp = Format.fprintf
+
+let rec print_elt f =
+ function
+ | Elt (tag, contents) ->
+ pp f "@[<hv0>@[<hv2><%s>@,%a@]@,</%s>@]"
+ tag print_list_elts contents tag
+ | Pcdata s ->
+ Format.pp_print_string f s
+
+and print_list_elts f =
+ let rec loop =
+ function
+ | [] -> ()
+ | x::xs -> (pp f "@,"; print_elt f x; loop xs) in
+ function
+ | [] -> ()
+ | [x] -> print_elt f x
+ | x::xs -> (print_elt f x; loop xs)
+
+let tree =
+ Elt ("div", [
+ Elt ("p", [Pcdata "a short text"]);
+ Elt ("p", [Pcdata "a looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong text"])
+ ])
+
+let () = Format.printf "%a@." print_elt tree
+
--- /dev/null
+open Camlp4.PreCast
+
+let _loc = Loc.mk "?"
+
+let base base fields ty =
+ let fields = List.fold_right (fun field acc ->
+ let c = <:ctyp< $lid:field$ : $uid:field$.record >> in
+ <:ctyp< $c$ ; $acc$ >>) fields <:ctyp< >>
+ in
+ <:module_binding< $uid:base$ :
+ sig type record = {
+ key : $ty$;
+ $fields$
+ } end = struct
+ type record = {
+ key : $ty$;
+ $fields$
+ } end
+ >>
+
+module CleanAst = Camlp4.Struct.CleanAst.Make(Ast)
+let _ =
+ let b = base "b" ["f1"; "f2"] <:ctyp< int >> in
+ Camlp4.PreCast.Printers.OCaml.print_implem
+ ((new CleanAst.clean_ast)#str_item
+ <:str_item< module rec $b$ >>)
--- /dev/null
+(int_of_string "1" : unit);
--- /dev/null
+open Camlp4.PreCast ;
+module G = Camlp4.PreCast.Gram ;
+
+value exp = G.Entry.mk "exp" ;
+value prog = G.Entry.mk "prog" ;
+
+EXTEND G
+exp:
+[ "apply"
+ [ e1 = SELF; e2 = SELF ->
+ let p = Loc.dump in
+ let () =
+ Format.eprintf "e1: %a,@.e2: %a,@.e1-e2: %a,@._loc: %a@."
+ p e1 p e2 p (Loc.merge e1 e2) p _loc
+ in
+ _loc
+ ]
+| "simple"
+ [ _ = LIDENT -> _loc ]
+];
+prog: [[ e = exp; `EOI -> e ]];
+END ;
+
+(* and the following function: *)
+
+value parse_string entry s =
+try
+ G.parse_string entry (Loc.mk "<string>") s
+with [ Loc.Exc_located loc exn ->
+begin
+ print_endline (Loc.to_string loc);
+ print_endline (Printexc.to_string exn);
+ failwith "Syntax Error"
+end ] ;
+
+parse_string prog "f x";
--- /dev/null
+open Camlp4.PreCast ;
+module G = Camlp4.PreCast.Gram ;
+
+value exp = G.Entry.mk "exp" ;
+value prog = G.Entry.mk "prog" ;
+
+EXTEND G
+exp:
+[ "apply"
+ [ e1 = exp LEVEL "simple"; e2 = SELF ->
+ let p = Loc.dump in
+ let () =
+ Format.eprintf "e1: %a,@.e2: %a,@.e1-e2: %a,@._loc: %a@."
+ p e1 p e2 p (Loc.merge e1 e2) p _loc
+ in
+ _loc
+ ]
+| "simple"
+ [ _ = LIDENT -> _loc ]
+];
+prog: [[ e = exp; `EOI -> e ]];
+END ;
+
+(* and the following function: *)
+
+value parse_string entry s =
+try
+ G.parse_string entry (Loc.mk "<string>") s
+with [ Loc.Exc_located loc exn ->
+begin
+ print_endline (Loc.to_string loc);
+ print_endline (Printexc.to_string exn);
+ failwith "Syntax Error"
+end ] ;
+
+parse_string prog "f x";
--- /dev/null
+open Camlp4.PreCast ;
+module G = Camlp4.PreCast.Gram ;
+
+value exp = G.Entry.mk "exp" ;
+value prog = G.Entry.mk "prog" ;
+
+EXTEND G
+exp:
+[ "apply"
+ [ e1 = SELF; e2 = exp LEVEL "simple" ->
+ let p = Loc.dump in
+ let () =
+ Format.eprintf "e1: %a,@.e2: %a,@.e1-e2: %a,@._loc: %a@."
+ p e1 p e2 p (Loc.merge e1 e2) p _loc
+ in
+ _loc
+ ]
+| "simple"
+ [ _ = LIDENT -> _loc ]
+];
+prog: [[ e = exp; `EOI -> e ]];
+END ;
+
+(* and the following function: *)
+
+value parse_string entry s =
+try
+ G.parse_string entry (Loc.mk "<string>") s
+with [ Loc.Exc_located loc exn ->
+begin
+ print_endline (Loc.to_string loc);
+ print_endline (Printexc.to_string exn);
+ failwith "Syntax Error"
+end ] ;
+
+parse_string prog "f x";
--- /dev/null
+open Camlp4.PreCast ;
+module G = Camlp4.PreCast.Gram ;
+
+value exp = G.Entry.mk "exp" ;
+value prog = G.Entry.mk "prog" ;
+
+EXTEND G
+exp:
+[ "apply"
+ [ e1 = SELF; e2 = exp LEVEL "simple"; e3 = exp LEVEL "simple" ->
+ let p = Loc.dump in
+ let () =
+ Format.eprintf "e1: %a,@.e2: %a,@.e3: %a,@._loc: %a@."
+ p e1 p e2 p e3 p _loc
+ in
+ _loc
+ ]
+| "simple"
+ [ _ = LIDENT -> _loc ]
+];
+prog: [[ e = exp; `EOI -> e ]];
+END ;
+
+(* and the following function: *)
+
+value parse_string entry s =
+try
+ G.parse_string entry (Loc.mk "<string>") s
+with [ Loc.Exc_located loc exn ->
+begin
+ print_endline (Loc.to_string loc);
+ print_endline (Printexc.to_string exn);
+ failwith "Syntax Error"
+end ] ;
+
+parse_string prog "f x y";
--- /dev/null
+open Camlp4.PreCast ;
+module G = Camlp4.PreCast.Gram ;
+
+value exp = G.Entry.mk "exp" ;
+value prog = G.Entry.mk "prog" ;
+
+EXTEND G
+exp:
+[ "apply"
+[ e1 = SELF; e2 = exp LEVEL "simple"; e3 = SELF ->
+ let p = Loc.dump in
+ let () =
+ Format.eprintf "e1: %a,@.e2: %a,@.e3: %a,@._loc: %a@."
+ p e1 p e2 p e3 p _loc
+ in
+ _loc
+ ]
+| "simple"
+[ x = LIDENT; y = LIDENT ->
+ let () = Format.eprintf "reduce expr simple (%S, %S) at %a@." x y Loc.dump _loc in _loc ]
+];
+prog: [[ e = exp; `EOI -> e ]];
+END ;
+
+(* and the following function: *)
+
+value parse_string entry s =
+try
+ print_endline s;
+ G.parse_string entry (Loc.mk "<string>") s
+with [ Loc.Exc_located loc exn ->
+begin
+ print_endline (Loc.to_string loc);
+ print_endline (Printexc.to_string exn);
+ failwith "Syntax Error"
+end ] ;
+
+parse_string prog "f1 f2 x1 x2 y1 y2";
--- /dev/null
+open Camlp4.PreCast ;
+module G = Camlp4.PreCast.Gram;
+
+value ab_eoi = G.Entry.mk "ab_eoi" ;
+value a_or_ab = G.Entry.mk "a_or_ab" ;
+value a_or_ab_eoi = G.Entry.mk "a_or_ab_eoi" ;
+value c_a_or_ab_eoi = G.Entry.mk "c_a_or_ab_eoi" ;
+
+EXTEND G
+ab_eoi: [[ "a"; "b"; `EOI -> () ]];
+a_or_ab: [[ "a" -> () | "a"; "b" -> () ]];
+a_or_ab_eoi: [[ a_or_ab; `EOI -> () ]];
+c_a_or_ab_eoi: [[ "c"; a_or_ab; `EOI -> () ]];
+END ;
+
+value parse_string entry s =
+try
+ G.parse_string entry (Loc.mk "<string>") s
+with [ Loc.Exc_located loc exn ->
+begin
+ print_endline (Loc.to_string loc);
+ print_endline (Printexc.to_string exn);
+ (* failwith "Syntax Error" *)
+end ] ;
+
+(* Consider the following syntax errors: *)
+parse_string ab_eoi "a c" ;
+(* File "<string>", line 1, characters 2-3
+Stream.Error("illegal begin of ab_eoi")
+Exception: Failure "Syntax Error".
+--> "Illegal begin": at least the first symbol was correct
+--> nevertheless, the reported position is correct
+--> The message used to be: "b" then EOI expected after "a" in [ab_eoi] *)
+
+parse_string a_or_ab_eoi "a c" ;
+(* File "<string>", line 1, characters 0-1
+Stream.Error("illegal begin of a_or_ab_eoi")
+Exception: Failure "Syntax Error".
+--> "Illegal begin": at least the first non-terminal was correct
+--> the reported position is weird
+--> I think the message used to be either: "b" expected after "a" in
+[a_or_ab]
+or: EOI expected after [a_or_ab] in [a_or_ab_eoi] *)
+
+parse_string c_a_or_ab_eoi "c a c" ;
+(* File "<string>", line 1, characters 2-3
+Stream.Error("[a_or_ab] expected after \"c\" (in [c_a_or_ab_eoi])")
+Exception: Failure "Syntax Error".
+--> "[a_or_ab] expected": this is very confusing: there is a valid a_or_ab
+there, namely "a" *)
--- /dev/null
+open Camlp4.PreCast ;
+module G = Camlp4.PreCast.Gram ;
+
+value a = G.Entry.mk "a" ;
+value a_eoi = G.Entry.mk "a_eoi" ;
+
+EXTEND G
+a: [[ "one" -> 1 | x = a; "plus"; y = a -> x+y ]];
+a_eoi: [[ x = a; `EOI -> x ]];
+END ;
+
+(* and the following function: *)
+
+value parse_string entry s o =
+try
+ Printf.eprintf "Parsing %S\n%!" s;
+ assert (o = Some (G.parse_string entry (Loc.mk "<string>") s))
+with [ Loc.Exc_located loc exn when o <> None ->
+begin
+ print_endline (Loc.to_string loc);
+ print_endline (Printexc.to_string exn);
+ assert (o = None)
+end
+| exn when o = None -> Printf.eprintf "Fail as expected\n%!"
+| exn -> begin
+ Printf.eprintf "Unexpected exception: \n%!";
+ print_endline (Printexc.to_string exn);
+ assert (o = None)
+end ] ;
+
+(* The following is correct: *)
+
+parse_string a_eoi "one plus one" (Some 2);
+
+(* While all of the following inputs should be rejected because they are not *)
+(* legal according to the grammar: *)
+
+parse_string a_eoi "one plus" None;
+(* - : int = 1 *)
+parse_string a_eoi "one plus plus" None;
+(* - : int = 1 *)
+parse_string a_eoi "one plus one plus" None;
+(* - : int = 2 *)
+parse_string a_eoi "one plus one plus plus" None;
+(* - : int = 2 *)
+
+(* Curiously, you may only repeat the operator twice. If you specify it three
+times, gramlib complains. *)
+
+parse_string a_eoi "one plus plus plus" None ;
+(* File "<string>", line 1, characters 9-13 *)
+(* Stream.Error("EOI expected after [a] (in [a_eoi])") *)
+(* Exception: Failure "Syntax Error". *)
+parse_string a_eoi "one plus one plus plus plus" None ;
+(* File "<string>", line 1, characters 18-22 *)
+(* Stream.Error("EOI expected after [a] (in [a_eoi])") *)
+(* Exception: Failure "Syntax Error". *)
--- /dev/null
+open Camlp4.PreCast
+
+let sample_expr _loc _loc_name s =
+ Printf.eprintf "file=%s line=%d offset=%d bol=%d\n%!"
+ (Loc.file_name _loc)
+ (Loc.start_line _loc)
+ (Loc.start_off _loc)
+ (Loc.start_bol _loc);
+ <:expr< $lid:s$ >>
+;;
+
+Quotation.add
+ "sample"
+ Syntax.Quotation.DynAst.expr_tag
+ sample_expr
+;;
--- /dev/null
+let u = "Hello";;
+let s = <:sample<u>>;;
+print_string s
--- /dev/null
+#default_quotation "sample";;
+let u = "Hello";;
+let s = <<u>>;;
+let s = <:sample<u>>;;
+print_string s
--- /dev/null
+open Camlp4.PreCast
+
+let _loc = Loc.mk "?"
+
+let base base fields ty =
+ let fields = List.fold_right (fun field acc ->
+ let c = <:ctyp< $lid:field$ : $uid:field$.record >> in
+ <:ctyp< $c$ ; $acc$ >>) fields <:ctyp< >>
+ in
+ <:module_binding< $uid:base$ :
+ sig type record = {
+ key : $ty$;
+ $fields$
+ } end = struct
+ type record = {
+ key : $ty$;
+ $fields$
+ } end
+ >>
+
+let _ =
+ let b = base "b" ["f1"; "f2"] <:ctyp< int >> in
+ Camlp4.PreCast.Printers.OCaml.print_implem
+ <:str_item< module rec $b$ >>
--- /dev/null
+
+
+module type Ops = sig
+ type expr
+ val eval : expr -> int
+ end
+ ;;
+
+
+module Plus = struct
+ type 'a expr0 = [`Num of int | `Plus of 'a * 'a ]
+ module F(X : Ops with type expr = private ([> 'a expr0] as 'a)) =
+ struct
+ type expr = X.expr expr0
+ let eval : expr -> int = function
+ `Num n -> n
+ |`Plus(e1,e2) -> X.eval e1 + X.eval e2
+ end
+ module rec L : (Ops with type expr = L.expr expr0) = F(L)
+ end
+ ;;
+
+
+open Printf
+;;
+
+let _ = Printf.printf "%d\n%!" (Plus.L.eval (`Plus ((`Num 5),(`Num 2))));;
--- /dev/null
+(* rec.ml *)
+value rec x = 42;
--- /dev/null
+module M = struct
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+end;
--- /dev/null
+module M = struct
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+ foo bar;
+end;
--- /dev/null
+open Camlp4.PreCast
+
+let simplify =
+ object
+ inherit Ast.map as super
+ method expr e =
+ match super#expr e with
+ | <:expr< $x$ + 0 >> | <:expr< 0 + $x$ >> -> x
+ | x -> x
+ end
+in AstFilters.register_str_item_filter simplify#str_item
--- /dev/null
+open Camlp4.PreCast;
+
+let simplify =
+ object
+ inherit Ast.map as super;
+ method expr e =
+ match super#expr e with
+ [ <:expr< $x$ + 0 >> | <:expr< 0 + $x$ >> -> x
+ | x -> x ];
+ end
+in AstFilters.register_str_item_filter simplify#str_item;
--- /dev/null
+let foo = parser
+ | [< '42; ps >] ->
+ let ps = ps + 42 in
+ type_phrases ps
+ | [< >] -> [< >]
+
--- /dev/null
+open Camlp4.PreCast;;
+open Syntax;;
+
+let _loc = Loc.ghost;;
+let st = <:str_item< >>;;
+let e = <:expr< 1 >>
+let bi = <:binding< x = 0 >>;;
+
+(* none of these holds due to superfluous StSem and StNil *)
+assert (Ast.StSem (_loc, st, st) = <:str_item< $st$ $st$ >>);;
+assert (Ast.StExp (_loc, e) = <:str_item< $exp:e$ >>);;
+assert (Ast.StVal (_loc, bi) = <:str_item< let $bi$ >>);;
--- /dev/null
+<:expr< $x$ + $y$ - $z$ >> -> <:expr< plus_minus $x$ $y$ $z$ >>
+
+<< List.rev (List.rev $l$) >> -> l
--- /dev/null
+try
+ let f = Sys.getenv "CAMLP4_DEBUG_FILE"
+ in
+ foo bar foo bar foo bar foo bar foo bar foo bar foo bar foo bar foo bar foo bar foo bar foo bar
+with Not_found -> stderr
+
--- /dev/null
+EXTEND Gram
+ abc: [ [ (x,y) = foo -> x+y ] ];
+END;
--- /dev/null
+type t = [ A of int | B of t ];
+type t2 = [ A of int | B of t ];
+type t3 = [ A of int | B of t ];
--- /dev/null
+module M = struct
+ type t = A of int * int * int * int * int * int * int * int * int * int
+ | B | B | B | B | B | B | B | B
+ and t2 =
+ | B | B | B | B | B | B | B | B
+ and t3 =
+ | B | B | B of a * a * a * a * a * a * a * a * a * a * a | B | B | B | B | B
+ and t4 =
+ | B | B | B | B | B | B | B | B
+ and t5 =
+ | B | B | B | B | B | B | B | B
+ and t6 =
+ | B | B | B | A of int * int * int * int * int * int * int * int * int * int * int * int * int * int * int * int * int * int * int | B | B | B | B | B
+ and t7 =
+ | B | B | B | B | B | B | B | B
+ and t8 =
+ | B | B | B | B | B | B | B | B
+ and t9 =
+ | B | B | B | B | B | B | B | B
+ and t10 =
+ | A of (a * a)
+end
--- /dev/null
+type t1 = ();;
+type t2 = unit;;
+let x : t1 = ();;
+let y : t2 = ();;
--- /dev/null
+(* use.ml *)
+#use "test/fixtures/rec.ml";
+(* value use *)
+value use = 3;
--- /dev/null
+let where = 42
--- /dev/null
+x where x = 42;
--- /dev/null
+#########################################################################
+# #
+# Objective Caml #
+# #
+# Camlp4 #
+# #
+# Copyright 2004 Institut National de Recherche en Informatique et #
+# en Automatique. All rights reserved. This file is distributed #
+# under the terms of the Q Public License version 1.0. #
+# #
+#########################################################################
+#
+# The unmaintained directory
+#
+
+include ../config/Makefile.cnf
+
+DIRS=format lefteval ocamllex olabl scheme sml
+
+include ../config/Makefile.base
--- /dev/null
+*.fast
+*.fast.opt
+o_fast.ml
+pa_o_fast.ml
--- /dev/null
+
+
+include ../config/Makefile.cnf
+
+INCLUDES=-I ../camlp4 -I ../lib
+SRC=../etc/pa_o.ml ../etc/pa_op.ml # FIXME and why not pa_$D.ml?
+D=o
+COMP_OPT=-strict_parsing -e "Grammar.Entry.obj Pcaml.interf" -e "Grammar.Entry.obj Pcaml.implem" -e "Grammar.Entry.obj Pcaml.top_phrase" -e "Grammar.Entry.obj Pcaml.use_file"
+CLEANFILES=pa_*_fast.ml *_fast.ml
+
+# FIXME
+EXECUTABLES=#camlp4$D.fast
+
+include ../config/Makefile.base
+
+WARNINGS=Ay
+
+camlp4$D.fast: pa_$D_fast.cmo
+ rm -f camlp4$D.fast
+ cd ../camlp4; $(MAKE) CAMLP4=../compile/camlp4$D.fast CAMLP4M="../compile/pa_$D_fast.cmo ../meta/pr_dump.cmo"
+
+camlp4$D.fast.opt: pa_$D_fast.cmx
+ rm -f camlp4$D.fast.opt
+ cd ../camlp4; $(MAKE) ../compile/camlp4$D.fast.opt CAMLP4OPT=../compile/camlp4$D.fast.opt CAMLP4M="../compile/pa_$D_fast.cmx ../meta/pr_dump.cmx"
+
+pa_$D_fast.ml: comp_head.ml $D_fast.ml comp_trail.ml
+ cat $(SRC) | sed -e "s/Plexer.make_lexer *()/P.lexer_pos/" -e "/EXTEND/,/END/d" -e "/Grammar.Entry.of_parser/d" -e "/Grammar.Entry.gcreate/d" | cat comp_head.ml - $D_fast.ml comp_trail.ml > pa_$D_fast.ml
+
+$D_fast.ml: compile.cmo $(SRC)
+ echo '(* camlp4r *)' >$D_fast.ml
+ OTOP=$(OTOP) EXE=$(EXE) ./compile.sh $(COMP_OPT) $(SRC) >> $D_fast.ml
+
+install-local:
+ if test -f camlp4$D.fast.opt; then cp camlp4$D.fast.opt $(BINDIR)/camlp4$D.opt$(EXE); fi
+ for TARG in pa_$D_fast.cmi pa_$D_fast.cmo pa_$D_fast.cmx ; do if test -f $$TARG; then cp $$TARG "$(LIBDIR)/camlp4/."; fi; done
+
+include .depend
--- /dev/null
+(* camlp4r q_MLast.cmo pa_extend.cmo *)
+
+
+module P =
+ struct
+ value gloc bp strm = Grammar.loc_of_token_interval bp (Stream.count strm);
+ value list0 symb =
+ let rec loop al =
+ parser
+ [ [: a = symb; s :] -> loop [a :: al] s
+ | [: :] -> al ]
+ in
+ parser [: a = loop [] :] -> List.rev a
+ ;
+ value list0sep symb sep =
+ let rec kont al =
+ parser
+ [ [: v = sep; a = symb; s :] -> kont [a :: al] s
+ | [: :] -> al ]
+ in
+ parser
+ [ [: a = symb; s :] -> List.rev (kont [a] s)
+ | [: :] -> [] ]
+ ;
+ value list1 symb =
+ let rec loop al =
+ parser
+ [ [: a = symb; s :] -> loop [a :: al] s
+ | [: :] -> al ]
+ in
+ parser [: a = symb; s :] -> List.rev (loop [a] s)
+ ;
+ value list1sep symb sep =
+ let rec kont al =
+ parser
+ [ [: v = sep; a = symb; s :] -> kont [a :: al] s
+ | [: :] -> al ]
+ in
+ parser [: a = symb; s :] -> List.rev (kont [a] s)
+ ;
+ value option f =
+ parser
+ [ [: x = f :] -> Some x
+ | [: :] -> None ]
+ ;
+ value token (p_con, p_prm) =
+ if p_prm = "" then parser [: `(con, prm) when con = p_con :] -> prm
+ else parser [: `(con, prm) when con = p_con && prm = p_prm :] -> prm
+ ;
+ value orzero f f0 =
+ parser bp
+ [ [: x = f :] -> x
+ | [: x = f0 :] ep ->
+(*
+let (loc1, loc2) = Grammar.loc_of_token_interval bp ep in
+let _ = do { Printf.eprintf "recovered or_zero at loc (%d, %d)\n" loc1 loc2; flush stderr } in
+*)
+ x ]
+ ;
+ value error entry prev_symb symb =
+ symb ^ " expected" ^
+ (if prev_symb = "" then "" else " after " ^ prev_symb) ^
+ " (in [" ^ entry ^ "])"
+ ;
+ value lexer = Plexer.gmake();
+ end
+;
+
+(****************************************)
+
--- /dev/null
+(* camlp4r pa_extend.cmo *)
+(****************************************)
+
+value interf_p =
+ Grammar.Entry.of_parser Pcaml.gram "interf" interf_0
+;
+
+value implem_p =
+ Grammar.Entry.of_parser Pcaml.gram "implem" implem_0
+;
+
+value top_phrase_p =
+ Grammar.Entry.of_parser Pcaml.gram "top_phrase" top_phrase_0
+;
+
+value use_file_p =
+ Grammar.Entry.of_parser Pcaml.gram "use_file" use_file_0
+;
+
+EXTEND
+ interf:
+ [ [ x = interf_p -> x ] ]
+ ;
+ implem:
+ [ [ x = implem_p -> x ] ]
+ ;
+ top_phrase:
+ [ [ x = top_phrase_p -> x ] ]
+ ;
+ use_file:
+ [ [ x = use_file_p -> x ] ]
+ ;
+END;
--- /dev/null
+(* camlp4r *)
+
+
+open Gramext;
+
+value strict_parsing = ref False;
+value keywords = ref [];
+
+value _loc = Loc.ghost;
+
+(* Watch the segmentation faults here! the compiled file must have been
+ loaded in camlp4 with the option pa_extend.cmo -meta_action. *)
+value magic_act (act : Obj.t) : MLast.expr = Obj.magic act;
+
+(* Names of symbols for error messages; code borrowed to grammar.ml *)
+
+value rec name_of_symbol entry =
+ fun
+ [ Snterm e -> "[" ^ e.ename ^ "]"
+ | Snterml e l -> "[" ^ e.ename ^ " level " ^ l ^ "]"
+ | Sself | Snext -> "[" ^ entry.ename ^ "]"
+ | Stoken tok -> entry.egram.glexer.Token.tok_text tok
+ | _ -> "???" ]
+;
+
+value rec name_of_symbol_failed entry =
+ fun
+ [ Slist0 s -> name_of_symbol_failed entry s
+ | Slist0sep s _ -> name_of_symbol_failed entry s
+ | Slist1 s -> name_of_symbol_failed entry s
+ | Slist1sep s _ -> name_of_symbol_failed entry s
+ | Sopt s -> name_of_symbol_failed entry s
+ | Stree t -> name_of_tree_failed entry t
+ | s -> name_of_symbol entry s ]
+and name_of_tree_failed entry =
+ fun
+ [ Node {node = s; brother = bro; son = son} ->
+ let txt = name_of_symbol_failed entry s in
+ let txt =
+ match (s, son) with
+ [ (Sopt _, Node _) -> txt ^ " or " ^ name_of_tree_failed entry son
+ | _ -> txt ]
+ in
+ let txt =
+ match bro with
+ [ DeadEnd | LocAct _ _ -> txt
+ | _ -> txt ^ " or " ^ name_of_tree_failed entry bro ]
+ in
+ txt
+ | DeadEnd | LocAct _ _ -> "???" ]
+;
+
+value tree_failed entry prev_symb tree =
+ let (s2, s3) =
+ let txt = name_of_tree_failed entry tree in
+ match prev_symb with
+ [ Slist0 s ->
+ let txt1 = name_of_symbol_failed entry s in
+ ("", txt1 ^ " or " ^ txt)
+ | Slist1 s ->
+ let txt1 = name_of_symbol_failed entry s in
+ ("", txt1 ^ " or " ^ txt)
+ | Slist0sep s sep ->
+ let txt1 = name_of_symbol_failed entry s in
+ ("", txt1 ^ " or " ^ txt)
+ | Slist1sep s sep ->
+ let txt1 = name_of_symbol_failed entry s in
+ ("", txt1 ^ " or " ^ txt)
+ | Sopt _ | Stree _ -> ("", txt)
+ | _ -> (name_of_symbol entry prev_symb, txt) ]
+ in
+ <:expr<
+ P.error $str:entry.ename$ $`str:s2$ $`str:s3$
+ >>
+;
+
+(* Compilation *)
+
+value rec find_act =
+ fun
+ [ DeadEnd -> failwith "find_act"
+ | LocAct act _ -> (magic_act act, 0)
+ | Node {son = son; brother = bro} ->
+ let (act, n) = try find_act son with [ Failure _ -> find_act bro ] in
+ (act, n + 1) ]
+;
+
+value level_number e l =
+ match e.edesc with
+ [ Dlevels elevs ->
+ loop 0 elevs where rec loop n =
+ fun
+ [ [lev :: levs] -> if lev.lname = Some l then n else loop (n + 1) levs
+ | [] -> failwith ("level " ^ l ^ " not found in entry " ^ e.ename) ]
+ | Dparser _ -> 0 ]
+;
+
+value nth_patt_of_act (e, n) =
+ let patt_list =
+ loop e where rec loop =
+ fun
+ [ <:expr< fun (_loc : Locaction.t) -> $_$ >> ->
+ []
+ | <:expr< fun ($p$ : $_$) -> $e$ >> -> [p :: loop e]
+ | <:expr< fun $p$ -> $e$ >> -> [p :: loop e]
+ | _ -> failwith "nth_patt_of_act" ]
+ in
+ List.nth patt_list n
+;
+
+value rec last_patt_of_act =
+ fun
+ [ <:expr< fun ($p$ : $_$) (_loc : Locaction.t) ->
+ $_$ >> -> p
+ | <:expr< fun $_$ -> $e$ >> -> last_patt_of_act e
+ | _ -> failwith "last_patt_of_act" ]
+;
+
+#load "pr_r.cmo";
+value rec final_action =
+ fun
+ [
+ <:expr< fun (_loc : Loc.t) -> ($e$ : $_$) >> -> e
+ | <:expr< fun $_$ -> $e$ >> -> final_action e
+ | ast -> do {
+ print_endline "final_action failed";
+ Pcaml.print_implem.val [(MLast.StExp _loc ast, _loc)];
+ failwith "final_action";
+ } ]
+;
+
+value parse_standard_symbol e rkont fkont ending_act =
+ <:expr<
+ match try Some ($e$ __strm) with [ Stream.Failure -> None ] with
+ [ Some $nth_patt_of_act ending_act$ -> $rkont$
+ | _ -> $fkont$ ]
+ >>
+;
+
+value parse_symbol_no_failure e rkont fkont ending_act =
+ <:expr<
+ let $nth_patt_of_act ending_act$ =
+ try $e$ __strm with [ Stream.Failure -> raise (Stream.Error "") ]
+ in
+ $rkont$
+ >>
+;
+
+value rec contain_loc =
+ fun
+ [ <:expr< $lid:s$ >> -> (s = "loc") || (s = "_loc")
+ | <:expr< $uid:_$ >> -> False
+ | <:expr< $str:_$ >> -> False
+ | <:expr< ($list:el$) >> -> List.exists contain_loc el
+ | <:expr< $e1$ $e2$ >> -> contain_loc e1 || contain_loc e2
+ | _ -> True ]
+;
+
+value gen_let_loc _loc e =
+ if contain_loc e then <:expr< let _loc = P.gloc bp __strm in $e$ >> else e
+;
+
+value phony_entry = Grammar.Entry.obj Pcaml.implem;
+
+value rec parse_tree entry nlevn alevn (tree, fst_symb) act_kont kont =
+ match tree with
+ [ DeadEnd -> kont
+ | LocAct act _ ->
+ let act = magic_act act in
+ act_kont False act
+ | Node {node = Sself; son = LocAct act _; brother = bro} ->
+ let act = magic_act act in
+ let n = entry.ename ^ "_" ^ string_of_int alevn in
+ let e =
+ if strict_parsing.val || alevn = 0 || fst_symb then <:expr< $lid:n$ >>
+ else <:expr< P.orzero $lid:n$ $lid:entry.ename ^ "_0"$ >>
+ in
+ let p2 =
+ match bro with
+ [ DeadEnd -> kont
+ | _ -> parse_tree entry nlevn alevn (bro, fst_symb) act_kont kont ]
+ in
+ let p1 = act_kont True act in
+ parse_standard_symbol e p1 p2 (act, 0)
+ | Node {node = s; son = LocAct act _; brother = bro} ->
+ let act = magic_act act in
+ let p2 = parse_tree entry nlevn alevn (bro, fst_symb) act_kont kont in
+ let p1 = act_kont False act in
+ parse_symbol entry nlevn s p1 p2 (act, 0)
+ | Node {node = s; son = son; brother = bro} ->
+ let p2 = parse_tree entry nlevn alevn (bro, fst_symb) act_kont kont in
+ let p1 =
+ let err =
+ let txt = tree_failed entry s son in
+ <:expr< raise (Stream.Error $txt$) >>
+ in
+ match son with
+ [ Node {brother = DeadEnd} ->
+ parse_tree entry nlevn alevn (son, False) act_kont err
+ | _ ->
+ let p1 =
+ parse_tree entry nlevn alevn (son, True) act_kont
+ <:expr< raise Stream.Failure >>
+ in
+ <:expr< try $p1$ with [ Stream.Failure -> $err$ ] >> ]
+ in
+ parse_symbol entry nlevn s p1 p2 (find_act son) ]
+and parse_symbol entry nlevn s rkont fkont ending_act =
+ match s with
+ [ Slist0 s ->
+ let e = <:expr< P.list0 $symbol_parser entry nlevn s$ >> in
+ parse_symbol_no_failure e rkont fkont ending_act
+ | Slist1 s ->
+ let e = <:expr< P.list1 $symbol_parser entry nlevn s$ >> in
+ parse_standard_symbol e rkont fkont ending_act
+ | Slist0sep s sep ->
+ let e =
+ <:expr<
+ P.list0sep $symbol_parser entry nlevn s$
+ $symbol_parser entry nlevn sep$ >>
+ in
+ parse_symbol_no_failure e rkont fkont ending_act
+ | Slist1sep s sep ->
+ let e =
+ <:expr<
+ P.list1sep $symbol_parser entry nlevn s$
+ $symbol_parser entry nlevn sep$ >>
+ in
+ parse_standard_symbol e rkont fkont ending_act
+ | Sopt s ->
+ let e = <:expr< P.option $symbol_parser entry nlevn s$ >> in
+ parse_symbol_no_failure e rkont fkont ending_act
+ | Stree tree ->
+ let kont = <:expr< raise Stream.Failure >> in
+ let act_kont _ act = gen_let_loc _loc (final_action act) in
+ let e = parse_tree phony_entry 0 0 (tree, True) act_kont kont in
+ parse_standard_symbol <:expr< fun __strm -> $e$ >> rkont fkont ending_act
+ | Snterm e ->
+ let n =
+ match e.edesc with
+ [ Dparser _ -> e.ename
+ | Dlevels _ -> e.ename ^ "_0" ]
+ in
+ parse_standard_symbol <:expr< $lid:n$ >> rkont fkont ending_act
+ | Snterml e l ->
+ let n = e.ename ^ "_" ^ string_of_int (level_number e l) in
+ parse_standard_symbol <:expr< $lid:n$ >> rkont fkont ending_act
+ | Sself ->
+ let n = entry.ename ^ "_0" in
+ parse_standard_symbol <:expr< $lid:n$ >> rkont fkont ending_act
+ | Snext ->
+ let n = entry.ename ^ "_" ^ string_of_int nlevn in
+ parse_standard_symbol <:expr< $lid:n$ >> rkont fkont ending_act
+ | Stoken tok ->
+ let _ =
+ do {
+ if fst tok = "" && not (List.mem (snd tok) keywords.val) then
+ keywords.val := [snd tok :: keywords.val]
+ else ()
+ }
+ in
+ let p =
+ let patt = nth_patt_of_act ending_act in
+ let p_con = fst tok in
+ let p_prm = snd tok in
+ if snd tok = "" then
+ if fst tok = "ANY" then <:patt< (_, $patt$) >>
+ else <:patt< ($`str:p_con$, $patt$) >>
+ else
+ match patt with
+ [ <:patt< _ >> -> <:patt< ($`str:p_con$, $`str:p_prm$) >>
+ | _ -> <:patt< ($`str:p_con$, ($`str:p_prm$ as $patt$)) >> ]
+ in
+ <:expr<
+ match Stream.peek __strm with
+ [ Some $p$ -> do { Stream.junk __strm; $rkont$ }
+ | _ -> $fkont$ ]
+ >>
+ | _ ->
+ parse_standard_symbol <:expr< not_impl >> rkont fkont ending_act ]
+and symbol_parser entry nlevn =
+ fun
+ [ Snterm e ->
+ let n = e.ename ^ "_0" in
+ <:expr< $lid:n$ >>
+ | Snterml e l ->
+ let n = e.ename ^ "_" ^ string_of_int (level_number e l) in
+ <:expr< $lid:n$ >>
+ | Snext ->
+ let n = entry.ename ^ "_" ^ string_of_int nlevn in
+ if strict_parsing.val then <:expr< $lid:n$ >>
+ else
+ let n0 = entry.ename ^ "_0" in
+ <:expr< P.orzero $lid:n$ $lid:n0$ >>
+ | Stoken tok ->
+ let _ =
+ do {
+ if fst tok = "" && not (List.mem (snd tok) keywords.val) then
+ keywords.val := [snd tok :: keywords.val]
+ else ()
+ }
+ in
+ <:expr< P.token ($`str:fst tok$, $`str:snd tok$) >>
+ | Stree tree ->
+ let kont = <:expr< raise Stream.Failure >> in
+ let act_kont _ act = final_action act in
+ <:expr<
+ fun __strm ->
+ $parse_tree phony_entry 0 0 (tree, True) act_kont kont$
+ >>
+ | _ ->
+ <:expr< aaa >> ]
+;
+
+value rec start_parser_of_levels entry clevn levs =
+ let n = entry.ename ^ "_" ^ string_of_int clevn in
+ let next = entry.ename ^ "_" ^ string_of_int (clevn + 1) in
+ let p = <:patt< $lid:n$ >> in
+ match levs with
+ [ [] -> [Some (p, <:expr< fun __strm -> raise Stream.Failure >>)]
+ | [lev :: levs] ->
+ let pel = start_parser_of_levels entry (succ clevn) levs in
+ match lev.lprefix with
+ [ DeadEnd ->
+ let ncont =
+ if not strict_parsing.val && clevn = 0 then
+ entry.ename ^ "_gen_cont"
+ else entry.ename ^ "_" ^ string_of_int clevn ^ "_cont"
+ in
+ let curr =
+ <:expr< let a = $lid:next$ __strm in $lid:ncont$ bp a __strm >>
+ in
+ let curr = <:expr< let bp = Stream.count __strm in $curr$ >> in
+ let e = <:expr< fun __strm -> $curr$ >> in
+ let pel = if levs = [] then [] else pel in
+ [Some (p, e) :: pel]
+ | tree ->
+ let alevn = clevn in
+ let (kont, pel) =
+ match levs with
+ [ [] -> (<:expr< raise Stream.Failure >>, [])
+ | _ ->
+ let e =
+ match (lev.assoc, lev.lsuffix) with
+ [ (NonA, _) | (_, DeadEnd) -> <:expr< $lid:next$ __strm >>
+ | _ ->
+ let ncont =
+ entry.ename ^ "_" ^ string_of_int clevn ^ "_cont"
+ in
+ <:expr<
+ let a = $lid:next$ __strm in
+ $lid:ncont$ bp a __strm
+ >> ]
+ in
+ (e, pel) ]
+ in
+ let act_kont end_with_self act =
+ if lev.lsuffix = DeadEnd then gen_let_loc _loc (final_action act)
+ else
+ let ncont = entry.ename ^ "_" ^ string_of_int clevn ^ "_cont" in
+ gen_let_loc _loc
+ <:expr< $lid:ncont$ bp $final_action act$ __strm >>
+ in
+ let curr =
+ parse_tree entry (succ clevn) alevn (tree, True) act_kont kont
+ in
+ let curr = <:expr< let bp = Stream.count __strm in $curr$ >> in
+ let e = <:expr< fun __strm -> $curr$ >> in
+ [Some (p, e) :: pel] ] ]
+;
+
+value rec continue_parser_of_levels entry clevn levs =
+ let n = entry.ename ^ "_" ^ string_of_int clevn ^ "_cont" in
+ let p = <:patt< $lid:n$ >> in
+ match levs with
+ [ [] -> [None]
+ | [lev :: levs] ->
+ let pel = continue_parser_of_levels entry (succ clevn) levs in
+ match lev.lsuffix with
+ [ DeadEnd ->
+ [None :: pel]
+ | tree ->
+ let alevn =
+ match lev.assoc with
+ [ LeftA | NonA -> succ clevn
+ | RightA -> clevn ]
+ in
+ let (kont, pel) =
+ match levs with
+ [ [] -> (<:expr< a__ >>, [])
+ | _ -> (<:expr< a__ >>, pel) ]
+ in
+ let act_kont end_with_self act =
+ let p = last_patt_of_act act in
+ match lev.assoc with
+ [ RightA | NonA ->
+ <:expr<
+ let $p$ = a__ in
+ $gen_let_loc _loc (final_action act)$
+ >>
+ | LeftA ->
+ let ncont =
+ entry.ename ^ "_" ^ string_of_int clevn ^ "_cont"
+ in
+ gen_let_loc _loc
+ <:expr<
+ let $p$ = a__ in
+ $lid:ncont$ bp $final_action act$ __strm
+ >> ]
+ in
+ let curr =
+ parse_tree entry (succ clevn) alevn (tree, True) act_kont kont
+ in
+ let e = <:expr< fun bp a__ __strm -> $curr$ >> in
+ [Some (p, e) :: pel] ] ]
+;
+
+value continue_parser_of_levels_again entry levs =
+ let n = entry.ename ^ "_gen_cont" in
+ let e =
+ loop <:expr< a__ >> 0 levs where rec loop var levn =
+ fun
+ [ [] -> <:expr< if x == a__ then x else $lid:n$ bp x __strm >>
+ | [lev :: levs] ->
+ match lev.lsuffix with
+ [ DeadEnd -> loop var (levn + 1) levs
+ | _ ->
+ let n = entry.ename ^ "_" ^ string_of_int levn ^ "_cont" in
+ let rest = loop <:expr< x >> (levn + 1) levs in
+ <:expr< let x = $lid:n$ bp $var$ __strm in $rest$ >> ] ]
+ in
+ (<:patt< $lid:n$ >>, <:expr< fun bp a__ __strm -> $e$ >>)
+;
+
+value empty_entry ename =
+ let p = <:patt< $lid:ename$ >> in
+ let e =
+ <:expr<
+ fun __strm ->
+ raise (Stream.Error $str:"entry [" ^ ename ^ "] is empty"$) >>
+ in
+ [Some (p, e)]
+;
+
+value start_parser_of_entry entry =
+ match entry.edesc with
+ [ Dlevels [] -> empty_entry entry.ename
+ | Dlevels elev -> start_parser_of_levels entry 0 elev
+ | Dparser p -> [] ]
+;
+
+value continue_parser_of_entry entry =
+ match entry.edesc with
+ [ Dlevels elev -> continue_parser_of_levels entry 0 elev
+ | Dparser p -> [] ]
+;
+
+value continue_parser_of_entry_again entry =
+ if strict_parsing.val then []
+ else
+ match entry.edesc with
+ [ Dlevels ([_; _ :: _] as levs) ->
+ [continue_parser_of_levels_again entry levs]
+ | _ -> [] ]
+;
+
+value rec list_alternate l1 l2 =
+ match (l1, l2) with
+ [ ([x1 :: l1], [x2 :: l2]) -> [x1; x2 :: list_alternate l1 l2]
+ | ([], l2) -> l2
+ | (l1, []) -> l1 ]
+;
+
+value compile_entry entry =
+ let pel1 = start_parser_of_entry entry in
+ let pel2 = continue_parser_of_entry entry in
+ let pel = list_alternate pel1 pel2 in
+ List.fold_right
+ (fun pe list ->
+ match pe with
+ [ Some pe -> [pe :: list]
+ | None -> list ])
+ pel (continue_parser_of_entry_again entry)
+;
+
+(* get all entries connected together *)
+
+value rec scan_tree list =
+ fun
+ [ Node {node = n; son = son; brother = bro} ->
+ let list = scan_symbol list n in
+ let list = scan_tree list son in
+ let list = scan_tree list bro in
+ list
+ | LocAct _ _ | DeadEnd -> list ]
+and scan_symbol list =
+ fun
+ [ Snterm e -> scan_entry list e
+ | Snterml e l -> scan_entry list e
+ | Slist0 s -> scan_symbol list s
+ | Slist0sep s sep -> scan_symbol (scan_symbol list s) sep
+ | Slist1 s -> scan_symbol list s
+ | Slist1sep s sep -> scan_symbol (scan_symbol list s) sep
+ | Sopt s -> scan_symbol list s
+ | Stree t -> scan_tree list t
+ | Smeta _ _ _ | Sself | Snext | Stoken _ -> list ]
+and scan_level list lev =
+ let list = scan_tree list lev.lsuffix in
+ let list = scan_tree list lev.lprefix in
+ list
+and scan_levels list levs = List.fold_left scan_level list levs
+and scan_entry list entry =
+ if List.memq entry list then list
+ else
+ match entry.edesc with
+ [ Dlevels levs -> scan_levels [entry :: list] levs
+ | Dparser _ -> list ]
+;
+
+value all_entries_in_graph list entry =
+ List.rev (scan_entry list entry)
+;
+
+(* main *)
+
+value entries = ref [];
+
+value rec list_mem_right_assoc x =
+ fun
+ [ [] -> False
+ | [(a, b) :: l] -> x = b || list_mem_right_assoc x l ]
+;
+
+value rec expr_list =
+ fun
+ [ [] -> <:expr< [] >>
+ | [x :: l] -> <:expr< [$`str:x$ :: $expr_list l$] >> ]
+;
+
+value compile () =
+ let _ = do { keywords.val := []; } in
+ let list = List.fold_left all_entries_in_graph [] entries.val in
+ let list =
+ List.filter (fun e -> List.memq e list) entries.val @
+ List.filter (fun e -> not (List.memq e entries.val)) list
+ in
+ let list =
+ let set = ref [] in
+ List.fold_right
+ (fun entry list ->
+ if List.mem entry.ename set.val then
+ list
+ else do { set.val := [entry.ename :: set.val]; [entry :: list] })
+ list []
+ in
+ let pell = List.map compile_entry list in
+ let pel = List.flatten pell in
+ let si1 = <:str_item< value rec $list:pel$ >> in
+ let si2 =
+ let list = List.sort compare keywords.val in
+ <:str_item<
+ List.iter (fun kw -> P.lexer.Token.tok_using ("", kw))
+ $expr_list list$
+ >>
+ in
+ let loc = Loc.ghost in
+ ([(si1, loc); (si2, loc)], False)
+;
+
+Pcaml.parse_implem.val := fun _ _ -> compile ();
+
+Pcaml.add_option "-strict_parsing" (Arg.Set strict_parsing)
+ "Don't generate error recovering by trying continuations or first levels"
+;
--- /dev/null
+#!/bin/sh -e
+
+ARGS=
+FILES=
+ENTRIES=
+while test "" != "$1"; do
+ case $1 in
+ -e)
+ shift;
+ if test "$ENTRIES" != ""; then ENTRIES="$ENTRIES; "; fi
+ ENTRIES="$ENTRIES$1";;
+ *.ml*) FILES="$FILES $1";;
+ *) ARGS="$ARGS $1";;
+ esac
+ shift
+done
+
+cat $FILES | sed -e 's/Pcaml.parse_i.*$//' > tmp.ml
+echo "Compile.entries.val := [$ENTRIES];" >> tmp.ml
+> tmp.mli
+set -x
+$OTOP/boot/ocamlrun$EXE $OTOP/boot/ocamlc -I $OTOP/boot -c tmp.mli
+$OTOP/boot/ocamlrun$EXE ../boot/camlp4boot$EXE -meta_action tmp.ml -o tmp.ppo
+$OTOP/boot/ocamlrun$EXE $OTOP/boot/ocamlc -I $OTOP/boot -I ../lib -I ../camlp4 -c -impl tmp.ppo
+rm tmp.ppo
+> tmp.null
+$OTOP/boot/ocamlrun$EXE ../camlp4/camlp4$EXE ./compile.cmo ./tmp.cmo ../etc/pr_r.cmo ../etc/pr_rp.cmo $ARGS -sep "\n\n" -impl tmp.null && rm tmp.*
--- /dev/null
+*.cm[oia]
+camlp4o
+camlp4sch
+camlp4o.opt
+version.sh
+mkcamlp4.sh
+mkcamlp4.mpw
--- /dev/null
+parserify.cmo: parserify.cmi
+parserify.cmx: parserify.cmi
+pr_op_main.cmo: parserify.cmi
+pr_op_main.cmx: parserify.cmx
+pr_rp_main.cmo: parserify.cmi
+pr_rp_main.cmx: parserify.cmx
--- /dev/null
+
+
+include ../config/Makefile.cnf
+
+INCLUDES=-I ../camlp4 -I ../lib -I ../meta -I $(OTOP)/lex -I $(OTOP)/parsing
+OBJS=q_phony.cmo pa_o.cmo pa_op.cmo pa_oop.cmo pa_ru.cmo pa_extfun.cmo pa_fstream.cmo pa_ifdef.cmo pr_r.cmo pr_rp.cmo pr_o.cmo pr_op.cmo pr_extend.cmo pr_extfun.cmo pr_null.cmo pr_depend.cmo genTraversal.cmo fi_exc_tracer.cmo
+INTF=pa_o.cmi
+CAMLP4OM=pa_o.cmo pa_op.cmo ../meta/pr_dump.cmo
+CAMLP4OMX=$(CAMLP4OM:.cmo=.cmx)
+EXECUTABLES=camlp4o
+
+include ../config/Makefile.base
+
+all-local: mkcamlp4.sh
+
+pr_rp.cmo: parserify.cmo pr_rp_main.cmo
+ $(OCAMLC) parserify.cmo pr_rp_main.cmo -a -o $@
+
+pr_op.cmo: parserify.cmo pr_op_main.cmo
+ $(OCAMLC) parserify.cmo pr_op_main.cmo -a -o $@
+
+pr_rp.cmx: parserify.cmx pr_rp_main.cmx
+ $(OCAMLOPT) parserify.cmx pr_rp_main.cmx -a -o pr_rp.cmxa
+ mv pr_rp.cmxa pr_rp.cmx
+ mv pr_rp.$(A) pr_rp.$(O)
+
+pr_op.cmx: parserify.cmx pr_op_main.cmx
+ $(OCAMLOPT) parserify.cmx pr_op_main.cmx -a -o pr_op.cmxa
+ mv pr_op.cmxa pr_op.cmx
+ mv pr_op.$(A) pr_op.$(O)
+
+camlp4o$(EXE): ../camlp4/camlp4$(EXE) $(CAMLP4OM)
+ rm -f camlp4o$(EXE)
+ cd ../camlp4; $(MAKE) CAMLP4=../etc/camlp4o$(EXE) CAMLP4M="-I ../etc $(CAMLP4OM)"
+
+camlp4o.opt: $(CAMLP4OMX)
+ rm -f camlp4o.opt
+ cd ../camlp4; $(MAKE) ../etc/camlp4o.opt CAMLP4OPT=../etc/camlp4o.opt CAMLP4M="-I ../etc $(CAMLP4OMX)"
+
+mkcamlp4.sh: mkcamlp4.sh.tpl version.sh
+ sed -e "s!LIBDIR!$(LIBDIR)!g" -e "/define VERSION/r version.sh" \
+ mkcamlp4.sh.tpl > mkcamlp4.sh
+
+version.sh : $(OTOP)/VERSION
+ echo "VERSION=\"`sed -e 1q ../VERSION`\"" >version.sh
+
+install-local:
+ -$(MKDIR) "$(LIBDIR)/camlp4" "$(BINDIR)"
+ cp $(OBJS) "$(LIBDIR)/camlp4/."
+ cp $(INTF) "$(LIBDIR)/camlp4/."
+ cp camlp4o$(EXE) "$(BINDIR)/."
+ if test -f camlp4o.opt; then \
+ cp camlp4o.opt "$(BINDIR)/camlp4o.opt$(EXE)"; \
+ cp $(OBJSX) "$(LIBDIR)/camlp4/."; \
+ for file in $(OBJSX); do \
+ cp "`echo $$file | sed -e 's/\.cmx$$/.$(O)/'`" "$(LIBDIR)/camlp4/."; \
+ done ; \
+ fi
+ cp mkcamlp4.sh "$(BINDIR)/mkcamlp4"
+ chmod a+x "$(BINDIR)/mkcamlp4"
+
+include .depend
--- /dev/null
+(* camlp4r pa_extend.cmo q_MLast.cmo *)
+
+
+open Pcaml;
+
+type spat_comp =
+ [ SpTrm of Loc.t and MLast.patt and option MLast.expr
+ | SpNtr of Loc.t and MLast.patt and MLast.expr
+ | SpStr of Loc.t and MLast.patt ]
+;
+type sexp_comp =
+ [ SeTrm of Loc.t and MLast.expr
+ | SeNtr of Loc.t and MLast.expr ]
+;
+
+(* parsers *)
+
+value strm_n = "__strm";
+value next_fun _loc = <:expr< Fstream.next >>;
+
+value rec pattern_eq_expression p e =
+ match (p, e) with
+ [ (<:patt< $lid:a$ >>, <:expr< $lid:b$ >>) -> a = b
+ | (<:patt< $uid:a$ >>, <:expr< $uid:b$ >>) -> a = b
+ | (<:patt< $p1$ $p2$ >>, <:expr< $e1$ $e2$ >>) ->
+ pattern_eq_expression p1 e1 && pattern_eq_expression p2 e2
+ | (<:patt< ($list:pl$) >>, <:expr< ($list:el$) >>) ->
+ loop pl el where rec loop pl el =
+ match (pl, el) with
+ [ ([p :: pl], [e :: el]) ->
+ pattern_eq_expression p e && loop pl el
+ | ([], []) -> True
+ | _ -> False ]
+ | _ -> False ]
+;
+
+value stream_pattern_component skont =
+ fun
+ [ SpTrm _loc p wo ->
+ let p = <:patt< Some ($p$, $lid:strm_n$) >> in
+ if wo = None && pattern_eq_expression p skont then
+ <:expr< $next_fun _loc$ $lid:strm_n$ >>
+ else
+ <:expr< match $next_fun _loc$ $lid:strm_n$ with
+ [ $p$ $when:wo$ -> $skont$
+ | _ -> None ] >>
+ | SpNtr _loc p e ->
+ let p = <:patt< Some ($p$, $lid:strm_n$) >> in
+ if pattern_eq_expression p skont then <:expr< $e$ $lid:strm_n$ >>
+ else
+ <:expr< match $e$ $lid:strm_n$ with
+ [ $p$ -> $skont$
+ | _ -> None ] >>
+ | SpStr _loc p ->
+ <:expr< let $p$ = $lid:strm_n$ in $skont$ >> ]
+;
+
+value rec stream_pattern _loc epo e =
+ fun
+ [ [] ->
+ let e =
+ match epo with
+ [ Some ep -> <:expr< let $ep$ = Fstream.count $lid:strm_n$ in $e$ >>
+ | None -> e ]
+ in
+ <:expr< Some ($e$, $lid:strm_n$) >>
+ | [spc :: spcl] ->
+ let skont = stream_pattern _loc epo e spcl in
+ stream_pattern_component skont spc ]
+;
+
+value rec parser_cases _loc =
+ fun
+ [ [] -> <:expr< None >>
+ | [(spcl, epo, e) :: spel] ->
+ match parser_cases _loc spel with
+ [ <:expr< None >> -> stream_pattern _loc epo e spcl
+ | pc ->
+ <:expr< match $stream_pattern _loc epo e spcl$ with
+ [ Some _ as x -> x
+ | None -> $pc$ ] >> ] ]
+;
+
+value cparser_match _loc me bpo pc =
+ let pc = parser_cases _loc pc in
+ let e =
+ match bpo with
+ [ Some bp -> <:expr< let $bp$ = Stream.count $lid:strm_n$ in $pc$ >>
+ | None -> pc ]
+ in
+ <:expr< let ($lid:strm_n$ : Stream.t _) = $me$ in $e$ >>
+;
+
+value cparser _loc bpo pc =
+ let e = parser_cases _loc pc in
+ let e =
+ match bpo with
+ [ Some bp -> <:expr< let $bp$ = Fstream.count $lid:strm_n$ in $e$ >>
+ | None -> e ]
+ in
+ let p = <:patt< ($lid:strm_n$ : Fstream.t _) >> in <:expr< fun $p$ -> $e$ >>
+;
+
+(* streams *)
+
+value slazy _loc x = <:expr< fun () -> $x$ >>;
+
+value rec cstream _loc =
+ fun
+ [ [] -> <:expr< Fstream.nil >>
+ | [SeTrm _loc e :: sel] ->
+ let e2 = cstream _loc sel in
+ let x = <:expr< Fstream.cons $e$ $e2$ >> in
+ <:expr< Fstream.flazy $slazy _loc x$ >>
+ | [SeNtr _loc e] ->
+ e
+ | [SeNtr _loc e :: sel] ->
+ let e2 = cstream _loc sel in
+ let x = <:expr< Fstream.app $e$ $e2$ >> in
+ <:expr< Fstream.flazy $slazy _loc x$ >> ]
+;
+
+EXTEND
+ GLOBAL: expr;
+ expr: LEVEL "top"
+ [ [ "fparser"; po = OPT ipatt; "["; pcl = LIST0 parser_case SEP "|"; "]" ->
+ <:expr< $cparser _loc po pcl$ >>
+ | "fparser"; po = OPT ipatt; pc = parser_case ->
+ <:expr< $cparser _loc po [pc]$ >>
+ | "match"; e = SELF; "with"; "parser"; po = OPT ipatt; "[";
+ pcl = LIST0 parser_case SEP "|"; "]" ->
+ <:expr< $cparser_match _loc e po pcl$ >>
+ | "match"; e = SELF; "with"; "parser"; po = OPT ipatt;
+ pc = parser_case ->
+ <:expr< $cparser_match _loc e po [pc]$ >> ] ]
+ ;
+ parser_case:
+ [ [ "[:"; sp = stream_patt; ":]"; po = OPT ipatt; "->"; e = expr ->
+ (sp, po, e) ] ]
+ ;
+ stream_patt:
+ [ [ spc = stream_patt_comp -> [spc]
+ | spc = stream_patt_comp; ";"; sp = LIST1 stream_patt_comp SEP ";" ->
+ [spc :: sp]
+ | -> [] ] ]
+ ;
+ stream_patt_comp:
+ [ [ "`"; p = patt; eo = OPT [ "when"; e = expr -> e ] -> SpTrm _loc p eo
+ | p = patt; "="; e = expr -> SpNtr _loc p e
+ | p = patt -> SpStr _loc p ] ]
+ ;
+ ipatt:
+ [ [ i = LIDENT -> <:patt< $lid:i$ >> ] ]
+ ;
+ expr: LEVEL "simple"
+ [ [ "fstream"; "[:"; se = LIST0 stream_expr_comp SEP ";"; ":]" ->
+ <:expr< $cstream _loc se$ >> ] ]
+ ;
+ stream_expr_comp:
+ [ [ "`"; e = expr -> SeTrm _loc e
+ | e = expr -> SeNtr _loc e ] ]
+ ;
+END;
--- /dev/null
+(* camlp4r pa_extend.cmo q_MLast.cmo *)
+
+
+(* This module is deprecated since version 3.07; use pa_macro.ml instead *)
+
+value _ =
+ prerr_endline "Warning: pa_ifdef is deprecated since OCaml 3.07. Use pa_macro instead."
+;
+
+type item_or_def 'a =
+ [ SdStr of 'a | SdDef of string | SdUnd of string | SdNop ]
+;
+
+value list_remove x l =
+ List.fold_right (fun e l -> if e = x then l else [e :: l]) l []
+;
+
+value defined = ref ["OCAML_308"; "OCAML_307"; "OCAML_305"; "CAMLP4_300"; "NEWSEQ"];
+value define x = defined.val := [x :: defined.val];
+value undef x = defined.val := list_remove x defined.val;
+
+EXTEND
+ GLOBAL: Pcaml.expr Pcaml.str_item Pcaml.sig_item;
+ Pcaml.expr: LEVEL "top"
+ [ [ "ifdef"; c = UIDENT; "then"; e1 = Pcaml.expr; "else";
+ e2 = Pcaml.expr ->
+ if List.mem c defined.val then e1 else e2
+ | "ifndef"; c = UIDENT; "then"; e1 = Pcaml.expr; "else";
+ e2 = Pcaml.expr ->
+ if List.mem c defined.val then e2 else e1 ] ]
+ ;
+ Pcaml.str_item: FIRST
+ [ [ x = def_undef_str ->
+ match x with
+ [ SdStr si -> si
+ | SdDef x -> do { define x; <:str_item< declare end >> }
+ | SdUnd x -> do { undef x; <:str_item< declare end >> }
+ | SdNop -> <:str_item< declare end >> ] ] ]
+ ;
+ def_undef_str:
+ [ [ "ifdef"; c = UIDENT; "then"; e1 = str_item_def_undef;
+ "else"; e2 = str_item_def_undef ->
+ if List.mem c defined.val then e1 else e2
+ | "ifdef"; c = UIDENT; "then"; e1 = str_item_def_undef ->
+ if List.mem c defined.val then e1 else SdNop
+ | "ifndef"; c = UIDENT; "then"; e1 = str_item_def_undef;
+ "else"; e2 = str_item_def_undef ->
+ if List.mem c defined.val then e2 else e1
+ | "ifndef"; c = UIDENT; "then"; e1 = str_item_def_undef ->
+ if List.mem c defined.val then SdNop else e1
+ | "define"; c = UIDENT -> SdDef c
+ | "undef"; c = UIDENT -> SdUnd c ] ]
+ ;
+ str_item_def_undef:
+ [ [ d = def_undef_str -> d
+ | si = Pcaml.str_item -> SdStr si ] ]
+ ;
+ Pcaml.sig_item: FIRST
+ [ [ x = def_undef_sig ->
+ match x with
+ [ SdStr si -> si
+ | SdDef x -> do { define x; <:sig_item< declare end >> }
+ | SdUnd x -> do { undef x; <:sig_item< declare end >> }
+ | SdNop -> <:sig_item< declare end >> ] ] ]
+ ;
+ def_undef_sig:
+ [ [ "ifdef"; c = UIDENT; "then"; e1 = sig_item_def_undef;
+ "else"; e2 = sig_item_def_undef ->
+ if List.mem c defined.val then e1 else e2
+ | "ifdef"; c = UIDENT; "then"; e1 = sig_item_def_undef ->
+ if List.mem c defined.val then e1 else SdNop
+ | "ifndef"; c = UIDENT; "then"; e1 = sig_item_def_undef;
+ "else"; e2 = sig_item_def_undef ->
+ if List.mem c defined.val then e2 else e1
+ | "ifndef"; c = UIDENT; "then"; e1 = sig_item_def_undef ->
+ if List.mem c defined.val then SdNop else e1
+ | "define"; c = UIDENT -> SdDef c
+ | "undef"; c = UIDENT -> SdUnd c ] ]
+ ;
+ sig_item_def_undef:
+ [ [ d = def_undef_sig -> d
+ | si = Pcaml.sig_item -> SdStr si ] ]
+ ;
+END;
+
+Pcaml.add_option "-D" (Arg.String define)
+ "<string> Define for ifdef instruction."
+;
+Pcaml.add_option "-U" (Arg.String undef)
+ "<string> Undefine for ifdef instruction."
+;
--- /dev/null
+(* camlp4r pa_extend.cmo q_MLast.cmo *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 1998 Institut National de Recherche en Informatique et *)
+(* Automatique. Distributed only by permission. *)
+(* *)
+(***********************************************************************)
+
+
+
+open Pcaml;
+
+type spat_comp =
+ [ SpTrm of Loc.t and MLast.patt and option MLast.expr
+ | SpNtr of Loc.t and MLast.patt and MLast.expr
+ | SpStr of Loc.t and MLast.patt ]
+;
+type sexp_comp =
+ [ SeTrm of Loc.t and MLast.expr | SeNtr of Loc.t and MLast.expr ]
+;
+
+value strm_n = "__strm";
+value peek_fun _loc = <:expr< Stream.peek >>;
+value junk_fun _loc = <:expr< Stream.junk >>;
+
+(* Parsers. *)
+
+value stream_pattern_component skont =
+ fun
+ [ SpTrm _loc p wo ->
+ (<:expr< $peek_fun _loc$ $lid:strm_n$ >>, p, wo,
+ <:expr< do { $junk_fun _loc$ $lid:strm_n$; $skont$ } >>)
+ | SpNtr _loc p e ->
+ (<:expr< try Some ($e$ $lid:strm_n$) with
+ [ Stream.Failure -> None ] >>,
+ p, None, skont)
+ | SpStr _loc p ->
+ (<:expr< Some $lid:strm_n$ >>, p, None, skont) ]
+;
+
+value rec stream_pattern _loc epo e ekont =
+ fun
+ [ [] ->
+ match epo with
+ [ Some ep -> <:expr< let $ep$ = Stream.count $lid:strm_n$ in $e$ >>
+ | _ -> e ]
+ | [(spc, err) :: spcl] ->
+ let skont =
+ let ekont err =
+ let str =
+ match err with
+ [ Some estr -> estr
+ | _ -> <:expr< "" >> ]
+ in
+ <:expr< raise (Stream.Error $str$) >>
+ in
+ stream_pattern _loc epo e ekont spcl
+ in
+ let (tst, p, wo, e) = stream_pattern_component skont spc in
+ let ckont = ekont err in
+ <:expr< match $tst$ with
+ [ Some $p$ $when:wo$ -> $e$ | _ -> $ckont$ ] >> ]
+;
+
+value rec parser_cases _loc =
+ fun
+ [ [] -> <:expr< raise Stream.Failure >>
+ | [(spcl, epo, e) :: spel] ->
+ stream_pattern _loc epo e (fun _ -> parser_cases _loc spel) spcl ]
+;
+
+value cparser _loc bpo pc =
+ let e = parser_cases _loc pc in
+ let e =
+ match bpo with
+ [ Some bp -> <:expr< let $bp$ = Stream.count $lid:strm_n$ in $e$ >>
+ | None -> e ]
+ in
+ let p = <:patt< ($lid:strm_n$ : Stream.t _) >> in
+ <:expr< fun $p$ -> $e$ >>
+;
+
+value cparser_match _loc me bpo pc =
+ let pc = parser_cases _loc pc in
+ let e =
+ match bpo with
+ [ Some bp -> <:expr< let $bp$ = Stream.count $lid:strm_n$ in $pc$ >>
+ | None -> pc ]
+ in
+ <:expr< let $lid:strm_n$ = $me$ in $e$ >>
+;
+
+(* streams *)
+
+value slazy _loc e = <:expr< fun _ -> $e$ >>;
+
+value rec cstream gloc =
+ fun
+ [ [] -> let _loc = gloc in <:expr< Stream.sempty >>
+ | [SeTrm _loc e :: secl] ->
+ <:expr< Stream.lcons $slazy _loc e$ $cstream gloc secl$ >>
+ | [SeNtr _loc e :: secl] ->
+ <:expr< Stream.lapp $slazy _loc e$ $cstream gloc secl$ >> ]
+;
+
+(* Syntax extensions in Ocaml grammar *)
+
+
+EXTEND
+ GLOBAL: expr;
+ expr: LEVEL "expr1"
+ [ [ "parser"; po = OPT ipatt; OPT "|"; pcl = LIST1 parser_case SEP "|" ->
+ <:expr< $cparser _loc po pcl$ >>
+ | "match"; e = expr; "with"; "parser"; po = OPT ipatt; OPT "|";
+ pcl = LIST1 parser_case SEP "|" ->
+ <:expr< $cparser_match _loc e po pcl$ >> ] ]
+ ;
+ parser_case:
+ [ [ "[<"; sp = stream_patt; ">]"; po = OPT ipatt; "->"; e = expr ->
+ (sp, po, e) ] ]
+ ;
+ stream_patt:
+ [ [ spc = stream_patt_comp -> [(spc, None)]
+ | spc = stream_patt_comp; ";"; sp = LIST1 stream_patt_comp_err SEP ";" ->
+ [(spc, None) :: sp]
+ | (* empty *) -> [] ] ]
+ ;
+ stream_patt_comp_err:
+ [ [ spc = stream_patt_comp;
+ eo = OPT [ "??"; e = expr LEVEL "expr1" -> e ] ->
+ (spc, eo) ] ]
+ ;
+ stream_patt_comp:
+ [ [ "'"; p = patt; eo = OPT [ "when"; e = (expr LEVEL "expr1") -> e ] ->
+ SpTrm _loc p eo
+ | p = patt; "="; e = (expr LEVEL "expr1") -> SpNtr _loc p e
+ | p = patt -> SpStr _loc p ] ]
+ ;
+ ipatt:
+ [ [ i = LIDENT -> <:patt< $lid:i$ >> ] ]
+ ;
+
+ expr: LEVEL "simple"
+ [ [ "[<"; se = LIST0 stream_expr_comp SEP ";"; ">]" ->
+ <:expr< $cstream _loc se$ >> ] ]
+ ;
+ stream_expr_comp:
+ [ [ "'"; e = expr LEVEL "expr1" -> SeTrm _loc e
+ | e = expr LEVEL "expr1" -> SeNtr _loc e ] ]
+ ;
+END;
--- /dev/null
+(* camlp4r pa_extend.cmo q_MLast.cmo *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 1998 Institut National de Recherche en Informatique et *)
+(* Automatique. Distributed only by permission. *)
+(* *)
+(***********************************************************************)
+
+
+
+open Pcaml;
+
+value o2b =
+ fun
+ [ Some _ -> True
+ | None -> False ]
+;
+
+EXTEND
+ GLOBAL: expr;
+ expr: LEVEL "top"
+ [ [ "do"; "{"; seq = sequence; "}" ->
+ match seq with
+ [ [e] -> e
+ | _ -> <:expr< do { $list:seq$ } >> ] ] ]
+ ;
+ sequence:
+ [ [ "let"; o = OPT "rec"; l = LIST1 let_binding SEP "and"; [ "in" | ";" ];
+ el = SELF ->
+ let e =
+ match el with
+ [ [e] -> e
+ | _ -> <:expr< do { $list:el$ } >> ]
+ in
+ [ <:expr< let $opt:o2b o$ $list:l$ in $e$ >> ]
+ | e = expr; ";"; el = SELF ->
+ let e = let _loc = MLast.loc_of_expr e in <:expr< ($e$ : unit) >> in
+ [e :: el]
+ | e = expr; ";" -> [e]
+ | e = expr -> [e] ] ]
+ ;
+END;
--- /dev/null
+(* camlp4r q_MLast.cmo *)
+
+
+(* FIXME FIXME *)
+value _loc = Loc.mk "FIXME parserify.ml";
+
+type spc =
+ [ SPCterm of (MLast.patt * option MLast.expr)
+ | SPCnterm of MLast.patt and MLast.expr
+ | SPCsterm of MLast.patt ]
+;
+
+exception NotImpl;
+
+value rec subst v =
+ MLast.Map.Expr.expr (fun [ <:expr@_loc< __strm >> -> <:expr< $lid:v$ >>
+ | e -> e ])
+(* FIXME FIXME *)
+ (* match e with
+ [ <:expr< $lid:x$ >> -> if x = "__strm" then <:expr< $lid:v$ >> else e
+ | <:expr< $uid:_$ >> -> e
+ | <:expr< $int:_$ >> -> e
+ | <:expr< $chr:_$ >> -> e
+ | <:expr< $str:_$ >> -> e
+ | <:expr@_loc< $e1$ . $lab$ >> -> <:expr< $subst v e1$ . $lab$ >>
+ | <:expr@_loc< $x$ $y$ >> -> <:expr< $subst v x$ $subst v y$ >>
+ | <:expr@_loc< let $lid:s1$ = $e1$ in $e2$ >> ->
+ if s1 = v then <:expr< let $lid:s1$ = $subst v e1$ in $e2$ >>
+ else <:expr< let $lid:s1$ = $subst v e1$ in $subst v e2$ >>
+ | <:expr@_loc< let _ = $e1$ in $e2$ >> ->
+ <:expr< let _ = $subst v e1$ in $subst v e2$ >>
+ | <:expr@_loc< ($list:el$) >> -> <:expr< ($list:List.map (subst v) el$) >>
+ | _ -> raise NotImpl ] *)
+;
+
+value rec is_free v =
+ fun
+ [ <:expr< $lid:x$ >> -> x <> v
+ | <:expr< $uid:_$ >> -> True
+ | <:expr< $int:_$ >> -> True
+ | <:expr< $chr:_$ >> -> True
+ | <:expr< $str:_$ >> -> True
+ | <:expr< $e$ . $_$ >> -> is_free v e
+ | <:expr< $x$ $y$ >> -> is_free v x && is_free v y
+ | <:expr< let $lid:s1$ = $e1$ in $e2$ >> ->
+ is_free v e1 && (s1 = v || is_free v e2)
+ | <:expr< let _ = $e1$ in $e2$ >> -> is_free v e1 && is_free v e2
+ | <:expr< ($list:el$) >> -> List.for_all (is_free v) el
+ | _ -> raise NotImpl ]
+;
+
+value gensym =
+ let cnt = ref 0 in
+ fun () ->
+ do { incr cnt; "pr_rp_symb_" ^ string_of_int cnt.val }
+;
+
+value free_var_in_expr c e =
+ let rec loop_alpha v =
+ let x = String.make 1 v in
+ if is_free x e then Some x
+ else if v = 'z' then None
+ else loop_alpha (Char.chr (Char.code v + 1))
+ in
+ let rec loop_count cnt =
+ let x = String.make 1 c ^ string_of_int cnt in
+ if is_free x e then x else loop_count (succ cnt)
+ in
+ try
+ match loop_alpha c with
+ [ Some v -> v
+ | None -> loop_count 1 ]
+ with
+ [ NotImpl -> gensym () ]
+;
+
+value parserify _loc =
+ fun
+ [ <:expr< $e$ __strm >> -> e
+ | e -> <:expr< fun __strm -> $e$ >> ]
+;
+
+value is_raise_failure =
+ fun
+ [ <:expr< raise Stream.Failure >> -> True
+ | _ -> False ]
+;
+
+value is_raise_error =
+ fun
+ [ <:expr< raise (Stream.Error $_$) >> -> True
+ | _ -> False ]
+;
+
+value semantic _loc e =
+ try
+ if is_free "__strm" e then e
+ else
+ let v = free_var_in_expr 's' e in
+ <:expr< let $lid:v$ = __strm in $subst v e$ >>
+ with
+ [ NotImpl -> e ]
+;
+
+value rewrite_parser =
+ rewrite True where rec rewrite top ge =
+ match ge with
+ [ <:expr@_loc< let $p$ = try $e$ with [ Stream.Failure -> raise $exc$ ] in
+ $sp_kont$ >> ->
+ let f = parserify _loc e in
+ <:expr<
+ match try Some ($f$ __strm) with [ Stream.Failure -> None ] with
+ [ Some $p$ -> $rewrite False sp_kont$
+ | _ -> raise $exc$ ]
+ >>
+ | <:expr@_loc< let $p$ = Stream.count __strm in $f$ >> ->
+ try
+ if is_free "__strm" f then ge
+ else
+ let v = free_var_in_expr 's' f in
+ <:expr<
+ let $lid:v$ = __strm in
+ let $p$ = Stream.count __strm in $subst v f$
+ >>
+ with
+ [ NotImpl -> ge ]
+ | <:expr@_loc< let $p$ = __strm in $e$ >> ->
+ <:expr< let $p$ = __strm in $rewrite False e$ >>
+ | <:expr@_loc< let $p$ = $f$ __strm in $sp_kont$ >> when top ->
+ <:expr<
+ match try Some ($f$ __strm) with [ Stream.Failure -> None ] with
+ [ Some $p$ -> $rewrite False sp_kont$
+ | _ -> raise Stream.Failure ]
+ >>
+ | <:expr@_loc< let $p$ = $e$ in $sp_kont$ >> ->
+ if match e with
+ [ <:expr< match try Some $_$ with [ Stream.Failure -> None ] with
+ [ $list:_$ ] >>
+ | <:expr< match Stream.peek __strm with [ $list:_$ ] >>
+ | <:expr< try $_$ with [ Stream.Failure -> $_$ ] >>
+ | <:expr< let $_$ = Stream.count __strm in $_$ >> -> True
+ | _ -> False ]
+ then
+ let f = rewrite True <:expr< fun __strm -> $e$ >> in
+ let exc =
+ if top then <:expr< Stream.Failure >>
+ else <:expr< Stream.Error "" >>
+ in
+ <:expr<
+ match try Some ($f$ __strm) with [ Stream.Failure -> None ] with
+ [ Some $p$ -> $rewrite False sp_kont$
+ | _ -> raise $exc$ ]
+ >>
+ else semantic _loc ge
+ | <:expr@_loc< match try Some $e$ with [ Stream.Failure -> None ] with
+ [ Some $p$ -> $sp_kont$
+ | _ -> $p_kont$ ] >> ->
+ let f = parserify _loc e in
+ if not top && is_raise_failure p_kont then semantic _loc ge
+ else
+ let (p, f, sp_kont, p_kont) =
+ if top || is_raise_error p_kont then
+ (p, f, rewrite False sp_kont, rewrite top p_kont)
+ else
+ let f =
+ <:expr<
+ fun __strm ->
+ match
+ try Some ($f$ __strm) with [ Stream.Failure -> None ]
+ with
+ [ Some $p$ -> $rewrite False sp_kont$
+ | _ -> $rewrite top p_kont$ ]
+ >>
+ in
+ (<:patt< a >>, f, <:expr< a >>,
+ <:expr< raise (Stream.Error "") >>)
+ in
+ <:expr<
+ match try Some ($f$ __strm) with [ Stream.Failure -> None ] with
+ [ Some $p$ -> $sp_kont$
+ | _ -> $p_kont$ ]
+ >>
+ | <:expr< match Stream.peek __strm with [ $list:pel$ ] >> ->
+ let rec iter pel =
+ match pel with
+ [ [(<:patt< Some $p$ >>, eo,
+ <:expr< do { Stream.junk __strm; $sp_kont$ } >>);
+ (<:patt< _ >>, None, p_kont) :: _] ->
+ <:expr<
+ match Stream.peek __strm with
+ [ Some $p$ $when:eo$ ->
+ do { Stream.junk __strm; $rewrite False sp_kont$ }
+ | _ -> $rewrite top p_kont$ ]
+ >>
+ | [(<:patt< Some $p$ >>, eo,
+ <:expr< do { Stream.junk __strm; $sp_kont$ } >>) :: pel] ->
+ let p_kont = iter pel in
+ <:expr<
+ match Stream.peek __strm with
+ [ Some $p$ $when:eo$ ->
+ do { Stream.junk __strm; $rewrite False sp_kont$ }
+ | _ -> $p_kont$ ]
+ >>
+ | _ ->
+ <:expr< match Stream.peek __strm with [ $list:pel$ ] >> ]
+ in
+ iter pel
+ | <:expr@_loc< try Some $e$ with [ Stream.Failure -> $p_kont$ ] >> ->
+ let f = parserify _loc e in
+ let e =
+ <:expr<
+ match try Some ($f$ __strm) with [ Stream.Failure -> None ] with
+ [ Some a -> Some a
+ | _ -> $p_kont$ ]
+ >>
+ in
+ rewrite top e
+ | <:expr@_loc< try $e$ with [ Stream.Failure -> $p_kont$ ] >> ->
+ let f = parserify _loc e in
+ let e =
+ <:expr<
+ match try Some ($f$ __strm) with [ Stream.Failure -> None ] with
+ [ Some a -> a
+ | _ -> $rewrite top p_kont$ ]
+ >>
+ in
+ rewrite top e
+ | <:expr< $f$ __strm >> ->
+ if top then
+ <:expr<
+ match try Some ($f$ __strm) with [ Stream.Failure -> None ] with
+ [ Some a -> a
+ | _ -> raise Stream.Failure ]
+ >>
+ else
+ let v = free_var_in_expr 's' f in
+ <:expr< let $lid:v$ = __strm in $subst v f$ $lid:v$ >>
+ | e -> let loc = MLast.loc_of_expr e in semantic loc e ]
+;
+
+value spc_of_parser =
+ let rec parser_cases e =
+ match e with
+ [ <:expr<
+ match try Some ($f$ __strm) with [ Stream.Failure -> None ] with
+ [ Some $p$ -> $sp_kont$
+ | _ -> $p_kont$ ]
+ >> ->
+ let spc = (SPCnterm p f, None) in
+ let (sp, epo, e) = kont sp_kont in
+ [([spc :: sp], epo, e) :: parser_cases p_kont]
+ | <:expr<
+ match Stream.peek __strm with
+ [ Some $p$ $when:wo$ -> do { Stream.junk __strm; $sp_kont$ }
+ | _ -> $p_kont$ ]
+ >> ->
+ let spc = (SPCterm (p, wo), None) in
+ let (sp, epo, e) = kont sp_kont in
+ [([spc :: sp], epo, e) :: parser_cases p_kont]
+ | <:expr< let $p$ = __strm in $sp_kont$ >> ->
+ let spc = (SPCsterm p, None) in
+ let (sp, epo, e) = kont sp_kont in
+ [([spc :: sp], epo, e)]
+ | <:expr< let $p$ = Stream.count __strm in $e$ >> -> [([], Some p, e)]
+ | <:expr< raise Stream.Failure >> -> []
+ | _ -> [([], None, e)] ]
+ and kont e =
+ match e with
+ [ <:expr<
+ match try Some ($f$ __strm) with [ Stream.Failure -> None ] with
+ [ Some $p$ -> $sp_kont$
+ | _ -> raise (Stream.Error $err$) ]
+ >> ->
+ let err =
+ match err with
+ [ <:expr< "" >> -> None
+ | _ -> Some err ]
+ in
+ let spc = (SPCnterm p f, err) in
+ let (sp, epo, e) = kont sp_kont in
+ ([spc :: sp], epo, e)
+ | <:expr<
+ match Stream.peek __strm with
+ [ Some $p$ $when:wo$ -> do { Stream.junk __strm; $sp_kont$ }
+ | _ -> raise (Stream.Error $err$) ]
+ >> ->
+ let err =
+ match err with
+ [ <:expr< "" >> -> None
+ | _ -> Some err ]
+ in
+ let spc = (SPCterm (p, wo), err) in
+ let (sp, epo, e) = kont sp_kont in
+ ([spc :: sp], epo, e)
+ | <:expr< let $p$ = __strm in $sp_kont$ >> ->
+ let spc = (SPCsterm p, None) in
+ let (sp, epo, e) = kont sp_kont in
+ ([spc :: sp], epo, e)
+ | <:expr< let $p$ = Stream.count __strm in $e$ >> -> ([], Some p, e)
+ | _ -> ([], None, e) ]
+ in
+ parser_cases
+;
+
+value parser_of_expr e = spc_of_parser (rewrite_parser e);
--- /dev/null
+(* camlp4r *)
+
+
+type spc =
+ [ SPCterm of (MLast.patt * option MLast.expr)
+ | SPCnterm of MLast.patt and MLast.expr
+ | SPCsterm of MLast.patt ]
+;
+
+value parser_of_expr :
+ MLast.expr ->
+ list (list (spc * option MLast.expr) * option MLast.patt * MLast.expr);
--- /dev/null
+(* camlp4r *)
+
+
+open MLast;
+
+value not_impl name x =
+ Format.eprintf "pr_depend: not impl: %s; %a@." name ObjTools.print (Obj.repr x)
+;
+
+module StrSet =
+ Set.Make (struct type t = string; value compare = compare; end)
+;
+
+value fset = ref StrSet.empty;
+value addmodule s = fset.val := StrSet.add s fset.val;
+
+value list = List.iter;
+
+value option f =
+ fun
+ [ Some x -> f x
+ | None -> () ]
+;
+
+value longident =
+ fun
+ [ [s; _ :: _] -> addmodule s
+ | _ -> () ]
+;
+
+value rec ctyp =
+ fun
+ [ TyAcc _ t _ -> ctyp_module t
+ | TyAli _ t1 t2 -> do { ctyp t1; ctyp t2; }
+ | TyApp _ t1 t2 -> do { ctyp t1; ctyp t2; }
+ | TyAny _ -> ()
+ | TyArr _ t1 t2 -> do { ctyp t1; ctyp t2; }
+ | TyCls _ li -> longident li
+ | TyLab _ _ t -> ctyp t
+ | TyLid _ _ -> ()
+ | TyMan _ t1 t2 -> do { ctyp t1; ctyp t2; }
+ | TyOlb _ _ t -> ctyp t
+ | TyQuo _ _ -> ()
+ | TyRec _ ldl -> list label_decl ldl
+ | TySum _ cdl -> list constr_decl cdl
+ | TyPrv _ t -> ctyp t
+ | TyTup _ tl -> list ctyp tl
+ | TyVrn _ sbtll _ -> list variant sbtll
+ | x -> not_impl "ctyp" x ]
+and constr_decl (_, _, tl) = list ctyp tl
+and label_decl (_, _, _, t) = ctyp t
+and variant =
+ fun
+ [ RfTag _ _ tl -> list ctyp tl
+ | RfInh t -> ctyp t ]
+and ctyp_module =
+ fun
+ [ TyAcc _ t _ -> ctyp_module t
+ | TyApp _ t1 t2 -> do { ctyp t1; ctyp t2; }
+ | TyUid _ m -> addmodule m
+ | x -> not_impl "ctyp_module" x ]
+;
+
+value rec patt =
+ fun
+ [ PaAcc _ p _ -> patt_module p
+ | PaAli _ p1 p2 -> do { patt p1; patt p2; }
+ | PaAny _ -> ()
+ | PaApp _ p1 p2 -> do { patt p1; patt p2; }
+ | PaArr _ pl -> list patt pl
+ | PaChr _ _ -> ()
+ | PaInt _ _ -> ()
+ | PaLab _ _ po -> option patt po
+ | PaLid _ _ -> ()
+ | PaOlb _ _ peoo ->
+ option (fun (p, eo) -> do { patt p; option expr eo }) peoo
+ | PaOrp _ p1 p2 -> do { patt p1; patt p2; }
+ | PaRec _ lpl -> list label_patt lpl
+ | PaRng _ p1 p2 -> do { patt p1; patt p2; }
+ | PaStr _ _ -> ()
+ | PaTup _ pl -> list patt pl
+ | PaTyc _ p t -> do { patt p; ctyp t; }
+ | PaUid _ _ -> ()
+ | PaVrn _ _ -> ()
+ | x -> not_impl "patt" x ]
+and patt_module =
+ fun
+ [ PaUid _ m -> addmodule m
+ | PaAcc _ p _ -> patt_module p
+ | x -> not_impl "patt_module" x ]
+and label_patt (p1, p2) = do { patt p1; patt p2; }
+and expr =
+ fun
+ [ ExAcc _ e1 e2 -> do { expr_module e1; expr e2; }
+ | ExApp _ e1 e2 -> do { expr e1; expr e2; }
+ | ExAre _ e1 e2 -> do { expr e1; expr e2; }
+ | ExArr _ el -> list expr el
+ | ExAsf _ -> ()
+ | ExAsr _ e -> do { expr e; }
+ | ExAss _ e1 e2 -> do { expr e1; expr e2; }
+ | ExChr _ _ -> ()
+ | ExCoe _ e t1 t2 -> do { expr e; option ctyp t1; ctyp t2 }
+ | ExFor _ _ e1 e2 _ el -> do { expr e1; expr e2; list expr el; }
+ | ExFun _ pwel -> list match_case pwel
+ | ExIfe _ e1 e2 e3 -> do { expr e1; expr e2; expr e3; }
+ | ExInt _ _ -> ()
+ | ExInt32 _ _ -> ()
+ | ExInt64 _ _ -> ()
+ | ExNativeInt _ _ -> ()
+ | ExFlo _ _ -> ()
+ | ExLab _ _ eo -> option expr eo
+ | ExLaz _ e -> expr e
+ | ExLet _ _ pel e -> do { list let_binding pel; expr e; }
+ | ExLid _ _ -> ()
+ | ExLmd _ _ me e -> do { module_expr me; expr e; }
+ | ExMat _ e pwel -> do { expr e; list match_case pwel; }
+ | ExNew _ li -> longident li
+ | ExOlb _ _ eo -> option expr eo
+ | ExRec _ lel w -> do { list label_expr lel; option expr w; }
+ | ExSeq _ el -> list expr el
+ | ExSnd _ e _ -> expr e
+ | ExSte _ e1 e2 -> do { expr e1; expr e2; }
+ | ExStr _ _ -> ()
+ | ExTry _ e pwel -> do { expr e; list match_case pwel; }
+ | ExTup _ el -> list expr el
+ | ExTyc _ e t -> do { expr e; ctyp t; }
+ | ExUid _ _ -> ()
+ | ExVrn _ _ -> ()
+ | ExWhi _ e el -> do { expr e; list expr el; }
+ | x -> not_impl "expr" x ]
+and expr_module =
+ fun
+ [ ExUid _ m -> addmodule m
+ | e -> expr e ]
+and let_binding (p, e) = do { patt p; expr e }
+and label_expr (p, e) = do { patt p; expr e }
+and match_case (p, w, e) = do { patt p; option expr w; expr e; }
+and module_type =
+ fun
+ [ MtAcc _ (MtUid _ m) _ -> addmodule m
+ | MtFun _ _ mt1 mt2 -> do { module_type mt1; module_type mt2; }
+ | MtSig _ sil -> list sig_item sil
+ | MtUid _ _ -> ()
+ | MtWit _ mt wc -> do { module_type mt; list with_constr wc; }
+ | x -> not_impl "module_type" x ]
+and with_constr =
+ fun
+ [ WcTyp _ _ _ t -> ctyp t
+ | x -> not_impl "with_constr" x ]
+and sig_item =
+ fun
+ [ SgDcl _ sil -> list sig_item sil
+ | SgExc _ _ tl -> list ctyp tl
+ | SgExt _ _ t _ -> ctyp t
+ | SgMod _ _ mt -> module_type mt
+ | SgRecMod _ mts -> list (fun (_, mt) -> module_type mt) mts
+ | SgMty _ _ mt -> module_type mt
+ | SgOpn _ [s :: _] -> addmodule s
+ | SgTyp _ tdl -> list type_decl tdl
+ | SgVal _ _ t -> ctyp t
+ | x -> not_impl "sig_item" x ]
+and module_expr =
+ fun
+ [ MeAcc _ (MeUid _ m) _ -> addmodule m
+ | MeApp _ me1 me2 -> do { module_expr me1; module_expr me2; }
+ | MeFun _ _ mt me -> do { module_type mt; module_expr me; }
+ | MeStr _ sil -> list str_item sil
+ | MeTyc _ me mt -> do { module_expr me; module_type mt; }
+ | MeUid _ _ -> ()
+ | x -> not_impl "module_expr" x ]
+and str_item =
+ fun
+ [ StCls _ cil -> list (fun ci -> class_expr ci.ciExp) cil
+ | StDcl _ sil -> list str_item sil
+ | StDir _ _ _ -> ()
+ | StExc _ _ tl _ -> list ctyp tl
+ | StExp _ e -> expr e
+ | StExt _ _ t _ -> ctyp t
+ | StMod _ _ me -> module_expr me
+ | StRecMod _ nmtmes -> list (fun (_, mt, me) -> do { module_expr me; module_type mt; }) nmtmes
+ | StMty _ _ mt -> module_type mt
+ | StOpn _ [s :: _] -> addmodule s
+ | StTyp _ tdl -> list type_decl tdl
+ | StVal _ _ pel -> list let_binding pel
+ | x -> not_impl "str_item" x ]
+and type_decl (_, _, t, _) = ctyp t
+and class_expr =
+ fun
+ [ CeApp _ ce e -> do { class_expr ce; expr e; }
+ | CeCon _ li tl -> do { longident li; list ctyp tl; }
+ | CeFun _ p ce -> do { patt p; class_expr ce; }
+ | CeLet _ _ pel ce -> do { list let_binding pel; class_expr ce; }
+ | CeStr _ po csil -> do { option patt po; list class_str_item csil; }
+ | x -> not_impl "class_expr" x ]
+and class_str_item =
+ fun
+ [ CrInh _ ce _ -> class_expr ce
+ | CrIni _ e -> expr e
+ | CrMth _ _ _ e None -> expr e
+ | CrMth _ _ _ e (Some t) -> do { expr e; ctyp t }
+ | CrVal _ _ _ e -> expr e
+ | CrVir _ _ _ t -> ctyp t
+ | x -> not_impl "class_str_item" x ]
+;
+
+(* Print dependencies *)
+
+value load_path = ref [""];
+
+value find_in_path path name =
+ if not (Filename.is_implicit name) then
+ if Sys.file_exists name then name else raise Not_found
+ else
+ let rec try_dir =
+ fun
+ [ [] -> raise Not_found
+ | [dir :: rem] ->
+ let fullname = Filename.concat dir name in
+ if Sys.file_exists fullname then fullname else try_dir rem ]
+ in
+ try_dir path
+;
+
+value find_depend modname (byt_deps, opt_deps) =
+ let name = String.uncapitalize modname in
+ try
+ let filename = find_in_path load_path.val (name ^ ".mli") in
+ let basename = Filename.chop_suffix filename ".mli" in
+ let byt_dep = basename ^ ".cmi" in
+ let opt_dep =
+ if Sys.file_exists (basename ^ ".ml") then basename ^ ".cmx"
+ else basename ^ ".cmi"
+ in
+ ([byt_dep :: byt_deps], [opt_dep :: opt_deps])
+ with
+ [ Not_found ->
+ try
+ let filename = find_in_path load_path.val (name ^ ".ml") in
+ let basename = Filename.chop_suffix filename ".ml" in
+ ([basename ^ ".cmo" :: byt_deps], [basename ^ ".cmx" :: opt_deps])
+ with
+ [ Not_found -> (byt_deps, opt_deps) ] ]
+;
+
+value (depends_on, escaped_eol) =
+ match Sys.os_type with
+ [ "Unix" | "Win32" | "Cygwin" -> (": ", "\\\n ")
+ | "MacOS" -> ("\196 ", "\182\n ")
+ | _ -> assert False ]
+;
+
+value print_depend target_file deps =
+ match deps with
+ [ [] -> ()
+ | _ ->
+ do {
+ print_string target_file;
+ print_string depends_on;
+ let rec print_items pos =
+ fun
+ [ [] -> print_string "\n"
+ | [dep :: rem] ->
+ if pos + String.length dep <= 77 then do {
+ print_string dep;
+ print_string " ";
+ print_items (pos + String.length dep + 1) rem
+ }
+ else do {
+ print_string escaped_eol;
+ print_string dep;
+ print_string " ";
+ print_items (String.length dep + 5) rem
+ } ]
+ in
+ print_items (String.length target_file + 2) deps
+ } ]
+;
+
+(* Main *)
+
+value depend_sig ast =
+ do {
+ fset.val := StrSet.empty;
+ List.iter (fun (si, _) -> sig_item si) ast;
+ let basename = Filename.chop_suffix Pcaml.input_file.val ".mli" in
+ let (byt_deps, _) = StrSet.fold find_depend fset.val ([], []) in
+ print_depend (basename ^ ".cmi") byt_deps;
+ }
+;
+
+value depend_str ast =
+ do {
+ fset.val := StrSet.empty;
+ List.iter (fun (si, _) -> str_item si) ast;
+ let basename =
+ if Filename.check_suffix Pcaml.input_file.val ".ml" then
+ Filename.chop_suffix Pcaml.input_file.val ".ml"
+ else
+ try
+ let len = String.rindex Pcaml.input_file.val '.' in
+ String.sub Pcaml.input_file.val 0 len
+ with
+ [ Failure _ | Not_found -> Pcaml.input_file.val ]
+ in
+ let init_deps =
+ if Sys.file_exists (basename ^ ".mli") then
+ let cmi_name = basename ^ ".cmi" in ([cmi_name], [cmi_name])
+ else ([], [])
+ in
+ let (byt_deps, opt_deps) = StrSet.fold find_depend fset.val init_deps in
+ print_depend (basename ^ ".cmo") byt_deps;
+ print_depend (basename ^ ".cmx") opt_deps;
+ }
+;
+
+Pcaml.print_interf.val := depend_sig;
+Pcaml.print_implem.val := depend_str;
+
+Pcaml.add_option "-I"
+ (Arg.String (fun dir -> load_path.val := load_path.val @ [dir]))
+ "<dir> Add <dir> to the list of include directories.";
--- /dev/null
+(* camlp4r q_MLast.cmo ./pa_extfun.cmo *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 2002 Institut National de Recherche en Informatique et *)
+(* Automatique. Distributed only by permission. *)
+(* *)
+(***********************************************************************)
+
+
+
+open Pcaml;
+open Spretty;
+
+value no_slist = ref False;
+
+value expr e dg k = pr_expr.pr_fun "top" e dg k;
+value patt e dg k = pr_patt.pr_fun "top" e dg k;
+
+(* Utilities *)
+
+value rec list elem el k =
+ match el with
+ [ [] -> k
+ | [x] -> [: `elem x k :]
+ | [x :: l] -> [: `elem x [: :]; list elem l k :] ]
+;
+
+value rec listws elem sep el k =
+ match el with
+ [ [] -> k
+ | [x] -> [: `elem x k :]
+ | [x :: l] -> [: `elem x [: `sep :]; listws elem sep l k :] ]
+;
+
+value rec listwbws elem b sep el dg k =
+ match el with
+ [ [] -> [: b; k :]
+ | [x] -> [: `elem b x dg k :]
+ | [x :: l] ->
+ let sdg =
+ match sep with
+ [ S _ x -> x
+ | _ -> "" ]
+ in
+ [: `elem b x sdg [: :]; listwbws elem [: `sep :] sep l dg k :] ]
+;
+
+(* Extracting *)
+
+value rec get_globals =
+ fun
+ [ [(<:patt< _ >>, <:expr< ($e$ : $uid:gmod1$.Entry.e '$_$) >>) :: pel] ->
+ let (gmod, gl) = get_globals pel in
+ if gmod = "" || gmod = gmod1 then (gmod1, [e :: gl])
+ else raise Not_found
+ | [] -> ("", [])
+ | _ -> raise Not_found ]
+;
+
+value rec get_locals =
+ fun
+ [ [(<:patt< $_$ >>,
+ <:expr< (grammar_entry_create $_$ : $_$) >>) :: pel] ->
+ get_locals pel
+ | [] -> ()
+ | _ -> raise Not_found ]
+;
+
+value unposition =
+ fun
+ [ <:expr< None >> -> None
+ | <:expr< Some Gramext.First >> -> Some Gramext.First
+ | <:expr< Some Gramext.Last >> -> Some Gramext.Last
+ | <:expr< Some (Gramext.Before $str:s$) >> -> Some (Gramext.Before s)
+ | <:expr< Some (Gramext.After $str:s$) >> -> Some (Gramext.After s)
+ | <:expr< Some (Gramext.Level $str:s$) >> -> Some (Gramext.Level s)
+ | _ -> raise Not_found ]
+;
+
+value unlabel =
+ fun
+ [ <:expr< None >> -> None
+ | <:expr< Some $str:s$ >> -> Some s
+ | _ -> raise Not_found ]
+;
+
+value unassoc =
+ fun
+ [ <:expr< None >> -> None
+ | <:expr< Some Gramext.NonA >> -> Some Gramext.NonA
+ | <:expr< Some Gramext.LeftA >> -> Some Gramext.LeftA
+ | <:expr< Some Gramext.RightA >> -> Some Gramext.RightA
+ | _ -> raise Not_found ]
+;
+
+value rec unaction =
+ fun
+ [ <:expr< fun ($lid:locp$ : Loc.t) -> ($a$ : $_$) >>
+ when locp = Stdpp.loc_name.val ->
+ let ao =
+ match a with
+ [ <:expr< () >> -> None
+ | _ -> Some a ]
+ in
+ ([], ao)
+ | <:expr< fun ($p$ : $_$) -> $e$ >> ->
+ let (pl, a) = unaction e in ([p :: pl], a)
+ | <:expr@_loc< fun _ -> $e$ >> ->
+ let (pl, a) = unaction e in ([ <:patt< _ >> :: pl ], a)
+ | _ -> raise Not_found ]
+;
+
+value untoken =
+ fun
+ [ <:expr< ($str:x$, $str:y$) >> -> (x, y)
+ | _ -> raise Not_found ]
+;
+
+type symbol =
+ [ Snterm of MLast.expr
+ | Snterml of MLast.expr and string
+ | Slist0 of symbol
+ | Slist0sep of symbol and symbol
+ | Slist1 of symbol
+ | Slist1sep of symbol and symbol
+ | Sopt of symbol
+ | Sself
+ | Snext
+ | Stoken of Token.pattern
+ | Srules of list (list (option MLast.patt * symbol) * option MLast.expr) ]
+;
+
+value rec unsymbol =
+ fun
+ [ <:expr< Gramext.Snterm ($uid:_$.Entry.obj ($e$ : $_$)) >> -> Snterm e
+ | <:expr< Gramext.Snterml ($uid:_$.Entry.obj ($e$ : $_$)) $str:s$ >> ->
+ Snterml e s
+ | <:expr< Gramext.Snterml ($uid:_$.Entry.obj ($e$ : $_$), $str:s$) >> ->
+ Snterml e s
+ | <:expr< Gramext.Slist0 $e$ >> -> Slist0 (unsymbol e)
+ | <:expr< Gramext.Slist0sep $e1$ $e2$ >> ->
+ Slist0sep (unsymbol e1) (unsymbol e2)
+ | <:expr< Gramext.Slist0sep ($e1$, $e2$) >> ->
+ Slist0sep (unsymbol e1) (unsymbol e2)
+ | <:expr< Gramext.Slist1 $e$ >> -> Slist1 (unsymbol e)
+ | <:expr< Gramext.Slist1sep $e1$ $e2$ >> ->
+ Slist1sep (unsymbol e1) (unsymbol e2)
+ | <:expr< Gramext.Slist1sep ($e1$, $e2$) >> ->
+ Slist1sep (unsymbol e1) (unsymbol e2)
+ | <:expr< Gramext.Sopt $e$ >> -> Sopt (unsymbol e)
+ | <:expr< Gramext.Sself >> -> Sself
+ | <:expr< Gramext.Snext >> -> Snext
+ | <:expr< Gramext.Stoken $e$ >> -> Stoken (untoken e)
+ | <:expr< Gramext.srules $e$ >> -> Srules (unrule_list [] e)
+ | _ -> raise Not_found ]
+and unpsymbol_list pl e =
+ match (pl, e) with
+ [ ([], <:expr< [] >>) -> []
+ | ([p :: pl], <:expr< [$e$ :: $el$] >>) ->
+ let op =
+ match p with
+ [ <:patt< _ >> -> None
+ | _ -> Some p ]
+ in
+ [(op, unsymbol e) :: unpsymbol_list pl el]
+ | _ -> raise Not_found ]
+and unrule =
+ fun
+ [ <:expr@_loc< ($e1$, Gramext.action $e2$) >> ->
+ let (pl, a) =
+ match unaction e2 with
+ [ ([], None) -> ([], Some <:expr< () >>)
+ | x -> x ]
+ in
+ let sl = unpsymbol_list (List.rev pl) e1 in
+ (sl, a)
+ | _ -> raise Not_found ]
+and unrule_list rl =
+ fun
+ [ <:expr< [$e$ :: $el$] >> -> unrule_list [unrule e :: rl] el
+ | <:expr< [] >> -> rl
+ | _ -> raise Not_found ]
+;
+
+value unlevel =
+ fun
+ [ <:expr< ($e1$, $e2$, $e3$) >> ->
+ (unlabel e1, unassoc e2, unrule_list [] e3)
+ | _ -> raise Not_found ]
+;
+
+value rec unlevel_list =
+ fun
+ [ <:expr< [$e$ :: $el$] >> -> [unlevel e :: unlevel_list el]
+ | <:expr< [] >> -> []
+ | _ -> raise Not_found ]
+;
+
+value unentry =
+ fun
+ [ <:expr< (Grammar.Entry.obj ($e$ : Grammar.Entry.e '$_$), $pos$, $ll$) >> ->
+ (e, unposition pos, unlevel_list ll)
+ | _ -> raise Not_found ]
+;
+
+value rec unentry_list =
+ fun
+ [ <:expr< [$e$ :: $el$] >> -> [unentry e :: unentry_list el]
+ | <:expr< [] >> -> []
+ | _ -> raise Not_found ]
+;
+
+value unextend_body e =
+ let ((_, globals), e) =
+ match e with
+ [ <:expr< let $list:pel$ in $e1$ >> ->
+ try (get_globals pel, e1) with
+ [ Not_found -> (("", []), e) ]
+ | _ -> (("", []), e) ]
+ in
+ let e =
+ match e with
+ [ <:expr<
+ let grammar_entry_create s =
+ Grammar.Entry.create (Grammar.of_entry $_$) s
+ in
+ $e$ >> ->
+ let e =
+ match e with
+ [ <:expr< let $list:pel$ in $e1$ >> ->
+ try let _ = get_locals pel in e1 with
+ [ Not_found -> e ]
+ | _ -> e ]
+ in
+ e
+ | _ -> e ]
+ in
+ let el = unentry_list e in
+ (globals, el)
+;
+
+value ungextend_body e =
+ let e =
+ match e with
+ [ <:expr<
+ let grammar_entry_create = Gram.Entry.create in
+ let $list:ll$ in $e$
+ >> ->
+ let _ = get_locals ll in e
+ | _ -> e ]
+ in
+ match e with
+ [ <:expr< do { $list:el$ } >> ->
+ List.map
+ (fun
+ [ <:expr< $uid:_$.extend ($e$ : $uid:_$.Entry.e '$_$) $pos$ $ll$ >> ->
+ (e, unposition pos, unlevel_list ll)
+ | _ -> raise Not_found ])
+ el
+ | _ -> raise Not_found ]
+;
+
+(* Printing *)
+
+value ident s k = HVbox [: `S LR s; k :];
+value string s k = HVbox [: `S LR ("\"" ^ s ^ "\""); k :];
+
+value position =
+ fun
+ [ None -> [: :]
+ | Some Gramext.First -> [: `S LR "FIRST" :]
+ | Some Gramext.Last -> [: `S LR "LAST" :]
+ | Some (Gramext.Before s) -> [: `S LR "BEFORE"; `string s [: :] :]
+ | Some (Gramext.After s) -> [: `S LR "AFTER"; `string s [: :] :]
+ | Some (Gramext.Level s) -> [: `S LR "LEVEL"; `string s [: :] :] ]
+;
+
+value action expr a dg k =
+ expr a dg k
+;
+
+value token (con, prm) k =
+ if con = "" then string prm k
+ else if prm = "" then HVbox [: `S LR con; k :]
+ else HVbox [: `S LR con; `string prm k :]
+;
+
+value simplify_rules rl =
+ try
+ List.map
+ (fun
+ [ ([(Some <:patt< $lid:x$ >>, s)], Some <:expr< $lid:y$ >>) ->
+ if x = y then ([(None, s)], None) else raise Exit
+ | ([], _) as r -> r
+ | _ -> raise Exit ])
+ rl
+ with
+ [ Exit -> rl ]
+;
+
+value rec symbol s k =
+ match s with
+ [ Snterm e -> expr e "" k
+ | Snterml e s -> HVbox [: `expr e "" [: :]; `S LR "LEVEL"; `string s k :]
+ | Slist0 s -> HVbox [: `S LR "LIST0"; `symbol s k :]
+ | Slist0sep s sep ->
+ HVbox
+ [: `S LR "LIST0"; `symbol s [: :]; `S LR "SEP";
+ `symbol sep k :]
+ | Slist1 s -> HVbox [: `S LR "LIST1"; `symbol s k :]
+ | Slist1sep s sep ->
+ HVbox
+ [: `S LR "LIST1"; `symbol s [: :]; `S LR "SEP";
+ `symbol sep k :]
+ | Sopt s -> HVbox [: `S LR "OPT"; `symbol s k :]
+ | Sself -> HVbox [: `S LR "SELF"; k :]
+ | Snext -> HVbox [: `S LR "NEXT"; k :]
+ | Stoken tok -> token tok k
+ | Srules
+ [([(Some <:patt< a >>, Snterm <:expr< a_list >>)], Some <:expr< a >>);
+ ([(Some <:patt< a >>,
+ ((Slist0 _ | Slist1 _ | Slist0sep _ _ | Slist1sep _ _) as s))],
+ Some <:expr< Qast.List a >>)]
+ when not no_slist.val
+ ->
+ match s with
+ [ Slist0 s -> HVbox [: `S LR "SLIST0"; `simple_symbol s k :]
+ | Slist1 s -> HVbox [: `S LR "SLIST1"; `simple_symbol s k :]
+ | Slist0sep s sep ->
+ HVbox
+ [: `S LR "SLIST0"; `simple_symbol s [: :]; `S LR "SEP";
+ `symbol sep k :]
+ | Slist1sep s sep ->
+ HVbox
+ [: `S LR "SLIST1"; `simple_symbol s [: :]; `S LR "SEP";
+ `simple_symbol sep k :]
+ | _ -> assert False ]
+ | Srules
+ [([(Some <:patt< a >>, Snterm <:expr< a_opt >>)], Some <:expr< a >>);
+ ([(Some <:patt< a >>, Sopt s)], Some <:expr< Qast.Option a >>)]
+ when not no_slist.val
+ ->
+ let s =
+ match s with
+ [ Srules
+ [([(Some <:patt< x >>, Stoken ("", str))],
+ Some <:expr< Qast.Str x >>)] ->
+ Stoken ("", str)
+ | s -> s ]
+ in
+ HVbox [: `S LR "SOPT"; `simple_symbol s k :]
+ | Srules rl ->
+ let rl = simplify_rules rl in
+ HVbox [: `HVbox [: :]; rule_list rl k :] ]
+and simple_symbol s k =
+ match s with
+ [ Snterml _ _ -> HVbox [: `S LO "("; `symbol s [: `S RO ")"; k :] :]
+ | s -> symbol s k ]
+and psymbol (p, s) k =
+ match p with
+ [ None -> symbol s k
+ | Some p -> HVbox [: `patt p "" [: `S LR "=" :]; `symbol s k :] ]
+and psymbol_list sl k =
+ listws psymbol (S RO ";") sl k
+and rule b (sl, a) dg k =
+ match a with
+ [ None -> HVbox [: b; `HOVbox [: psymbol_list sl k :] :]
+ | Some a ->
+ HVbox
+ [: b;
+ `HOVbox
+ [: `HOVbox
+ [: `HVbox [: :];
+ psymbol_list sl [: `S LR "->" :] :];
+ `action expr a dg k :] :] ]
+and rule_list ll k =
+ listwbws rule [: `S LR "[" :] (S LR "|") ll ""
+ [: `S LR "]"; k :]
+;
+
+value label =
+ fun
+ [ Some s -> [: `S LR ("\"" ^ s ^ "\"") :]
+ | None -> [: :] ]
+;
+
+value intloc loc = ((Loc.start_off loc), (Loc.stop_off loc));
+
+value intloc2 (bp, ep) = (bp.Lexing.pos_cnum, ep.Lexing.pos_cnum);
+
+
+value assoc =
+ fun
+ [ Some Gramext.NonA -> [: `S LR "NONA" :]
+ | Some Gramext.LeftA -> [: `S LR "LEFTA" :]
+ | Some Gramext.RightA -> [: `S LR "RIGHTA" :]
+ | None -> [: :] ]
+;
+
+value level b (lab, ass, rl) _ k =
+ let s =
+ if rl = [] then [: `S LR "[ ]"; k :]
+ else [: `Vbox [: `HVbox [: :]; rule_list rl k :] :]
+ in
+ match (lab, ass) with
+ [ (None, None) -> HVbox [: b; s :]
+ | _ ->
+ Vbox
+ [: `HVbox [: b; label lab; assoc ass :];
+ `HVbox [: `HVbox [: :]; s :] :] ]
+;
+
+value level_list ll k =
+ Vbox
+ [: `HVbox [: :];
+ listwbws level [: `S LR "[" :] (S LR "|") ll ""
+ [: `S LR "]"; k :] :]
+;
+
+value entry (e, pos, ll) k =
+ BEbox
+ [: `LocInfo (intloc(MLast.loc_of_expr e))
+ (HVbox [: `expr e "" [: `S RO ":" :]; position pos :]);
+ `level_list ll [: :];
+ `HVbox [: `S RO ";"; k :] :]
+;
+
+value entry_list el k =
+ Vbox [: `HVbox [: :]; list entry el k :]
+;
+
+value extend_body (globals, e) k =
+ let s = entry_list e k in
+ match globals with
+ [ [] -> s
+ | sl ->
+ HVbox
+ [: `HVbox [: :];
+ `HOVbox
+ [: `S LR "GLOBAL"; `S RO ":";
+ list (fun e k -> HVbox [: `expr e "" k :]) sl
+ [: `S RO ";" :] :];
+ `s :] ]
+;
+
+value extend e _ k =
+ match e with
+ [ <:expr< Grammar.extend $e$ >> ->
+ try
+ let ex = unextend_body e in
+ BEbox
+ [: `S LR "EXTEND"; `extend_body ex [: :];
+ `HVbox [: `S LR "END"; k :] :]
+ with
+ [ Not_found ->
+ HVbox
+ [: `S LR "Grammar.extend";
+ `HOVbox
+ [: `S LO "(";
+ `expr e "" [: `HVbox [: `S RO ")"; k :] :] :] :] ]
+ | _ -> expr e "" k ]
+;
+
+value get_gextend =
+ fun
+ [ <:expr< let $list:gl$ in $e$ >> ->
+ try
+ let (gmod, gl) = get_globals gl in
+ let el = ungextend_body e in
+ Some (gmod, gl, el)
+ with
+ [ Not_found -> None ]
+ | _ -> None ]
+;
+
+value gextend e _ k =
+ match get_gextend e with
+ [ Some (gmod, gl, el) ->
+ BEbox
+ [: `HVbox [: `S LR "GEXTEND"; `S LR gmod :];
+ `extend_body (gl, el) [: :];
+ `HVbox [: `S LR "END"; k :] :]
+ | None -> expr e "" k ]
+;
+
+value is_gextend e = get_gextend e <> None;
+
+(* Printer extensions *)
+
+let lev =
+ try find_pr_level "expr1" pr_expr.pr_levels with
+ [ Failure _ -> find_pr_level "top" pr_expr.pr_levels ]
+in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< let $list:_$ in $_$ >> as e when is_gextend e ->
+ fun _ next _ k -> [: `next e "" k :] ];
+
+let lev = find_pr_level "apply" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Grammar.extend $_$ >> as e ->
+ fun _ next _ k -> [: `next e "" k :] ];
+
+let lev = find_pr_level "simple" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Grammar.extend $_$ >> as e ->
+ fun _ _ _ k -> [: `extend e "" k :]
+ | <:expr< let $list:_$ in $_$ >> as e when is_gextend e ->
+ fun _ _ _ k -> [: `gextend e "" k :] ];
+
+Pcaml.add_option "-no_slist" (Arg.Set no_slist)
+ "Don't reconstruct SLIST and SOPT";
--- /dev/null
+(* camlp4r q_MLast.cmo ./pa_extfun.cmo *)
+
+
+open Pcaml;
+open Spretty;
+
+value _loc = Loc.mk "FIXME pr_extfun.ml";
+
+value expr e dg k = pr_expr.pr_fun "top" e dg k;
+value patt e dg k = pr_patt.pr_fun "top" e dg k;
+
+value rec un_extfun rpel =
+ fun
+ [ <:expr< [ ($_$, $_$, fun [ $list:pel$ ]) :: $el$ ] >> ->
+ let (p, wo, e) =
+ match pel with
+ [ [(p, wo, <:expr< Some $e$ >>);
+ (<:patt< _ >>, None, <:expr< None >>)] ->
+ (p, wo, e)
+ | [(p, wo, <:expr< Some $e$ >>)] -> (p, wo, e)
+ | _ -> raise Not_found ]
+ in
+ let rpel =
+ match rpel with
+ [ [(p1, wo1, e1) :: pel] ->
+ if wo1 = wo && e1 = e then
+ let p =
+ match (p1, p) with
+ [ (<:patt< ($x1$ as $x2$) >>, <:patt< ($y1$ as $y2$) >>) ->
+ if x2 = y2 then <:patt< ($x1$ | $y1$ as $x2$) >>
+ else <:patt< $p1$ | $p$ >>
+ | _ -> <:patt< $p1$ | $p$ >> ]
+ in
+ [(p, wo, e) :: pel]
+ else [(p, wo, e) :: rpel]
+ | [] -> [(p, wo, e)] ]
+ in
+ un_extfun rpel el
+ | <:expr< [] >> -> List.rev rpel
+ | _ -> raise Not_found ]
+;
+
+value rec listwbws elem b sep el k =
+ match el with
+ [ [] -> [: b; k :]
+ | [x] -> [: `elem b x k :]
+ | [x :: l] -> [: `elem b x [: :]; listwbws elem [: `sep :] sep l k :] ]
+;
+
+value rec match_assoc_list pwel k =
+ match pwel with
+ [ [pwe] -> match_assoc [: `S LR "[" :] pwe [: `S LR "]"; k :]
+ | pel ->
+ Vbox
+ [: `HVbox [: :];
+ listwbws match_assoc [: `S LR "[" :] (S LR "|") pel
+ [: `S LR "]"; k :] :] ]
+and match_assoc b (p, w, e) k =
+ let s =
+ let (p, k) =
+ match p with
+ [ <:patt< ($p$ as $p2$) >> -> (p, [: `S LR "as"; `patt p2 "" [: :] :])
+ | _ -> (p, [: :]) ]
+ in
+ match w with
+ [ Some e1 ->
+ [: `HVbox
+ [: `HVbox [: :]; `patt p "" k;
+ `HVbox [: `S LR "when"; `expr e1 "" [: `S LR "->" :] :] :] :]
+ | _ -> [: `patt p "" [: k; `S LR "->" :] :] ]
+ in
+ HVbox [: b; `HVbox [: `HVbox s; `expr e "" k :] :]
+;
+
+let lev = find_pr_level "top" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Extfun.extend $e$ $list$ >> as ge ->
+ fun _ next dg k ->
+ try
+ let pel = un_extfun [] list in
+ [: `HVbox [: :];
+ `BEbox [: `S LR "extfun"; `expr e "" [: :]; `S LR "with" :];
+ `match_assoc_list pel k :]
+ with
+ [ Not_found -> [: `next ge dg k :] ] ];
+
+let lev = find_pr_level "apply" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Extfun.extend $_$ $_$ >> as ge ->
+ fun _ next dg k -> [: `next ge dg k :] ];
--- /dev/null
+(* camlp4r *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 1998 Institut National de Recherche en Informatique et *)
+(* Automatique. Distributed only by permission. *)
+(* *)
+(***********************************************************************)
+
+
+
+Pcaml.print_interf.val := fun _ -> ();
+Pcaml.print_implem.val := fun _ -> ();
--- /dev/null
+(* camlp4r q_MLast.cmo ./pa_extfun.cmo *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 1998 Institut National de Recherche en Informatique et *)
+(* Automatique. Distributed only by permission. *)
+(* *)
+(***********************************************************************)
+
+
+
+open Pcaml;
+open Spretty;
+
+value expr e dg k = pr_expr.pr_fun "top" e dg k;
+value patt e dg k = pr_patt.pr_fun "top" e dg k;
+
+value spatt p dg k =
+ match p with
+ [ <:patt< $lid:s$ >> ->
+ if String.length s >= 2 && s.[1] == ''' then
+ HVbox [: `S LR (" " ^ s); k :]
+ else patt p dg k
+ | _ -> patt p dg k ]
+;
+
+(* Streams *)
+
+value stream e _ k =
+ let rec get =
+ fun
+ [ <:expr< Stream.iapp $x$ $y$ >> -> [(False, x) :: get y]
+ | <:expr< Stream.icons $x$ $y$ >> -> [(True, x) :: get y]
+ | <:expr< Stream.ising $x$ >> -> [(True, x)]
+ | <:expr< Stream.lapp (fun _ -> $x$) $y$ >> -> [(False, x) :: get y]
+ | <:expr< Stream.lcons (fun _ -> $x$) $y$ >> -> [(True, x) :: get y]
+ | <:expr< Stream.lsing (fun _ -> $x$) >> -> [(True, x)]
+ | <:expr< Stream.sempty >> -> []
+ | <:expr< Stream.slazy (fun _ -> $x$) >> -> [(False, x)]
+ | <:expr< Stream.slazy $x$ >> -> [(False, <:expr< $x$ () >>)]
+ | e -> [(False, e)] ]
+ in
+ let elem e dg k =
+ match e with
+ [ (True, e) -> [: `HOVbox [: `S LO "'"; `expr e dg k :] :]
+ | (False, e) -> [: `expr e dg k :] ]
+ in
+ let rec glop e k =
+ match e with
+ [ [] -> k
+ | [e] -> [: elem e "" k :]
+ | [e :: el] -> [: elem e ";" [: `S RO ";" :]; glop el k :] ]
+ in
+ HOVbox [: `S LR "[<"; glop (get e) [: `S LR ">]"; k :] :]
+;
+
+(* Parsers *)
+
+value parser_cases b spel dg k =
+ let rec parser_cases b spel dg k =
+ match spel with
+ [ [] -> [: `HVbox [: b; k :] :]
+ | [(sp, epo, e)] -> [: `parser_case b sp epo e dg k :]
+ | [(sp, epo, e) :: spel] ->
+ [: `parser_case b sp epo e "|" [: :];
+ parser_cases [: `S LR "|" :] spel dg k :] ]
+ and parser_case b sp epo e dg k =
+ let epo =
+ match epo with
+ [ Some p -> [: `patt p "" [: `S LR "->" :] :]
+ | _ -> [: `S LR "->" :] ]
+ in
+ HVbox
+ [: b;
+ `HOVbox
+ [: `HOVbox
+ [: `S LR "[<";
+ stream_patt [: :] sp [: `S LR ">]"; epo :] :];
+ `expr e dg k :] :]
+ and stream_patt b sp k =
+ match sp with
+ [ [] -> [: `HVbox [: b; k :] :]
+ | [(spc, None)] -> [: `stream_patt_comp b spc "" k :]
+ | [(spc, Some e)] ->
+ [: `HVbox
+ [: `stream_patt_comp b spc "" [: :];
+ `HVbox [: `S LR "??"; `expr e "" k :] :] :]
+ | [(spc, None) :: spcl] ->
+ [: `stream_patt_comp b spc ";" [: `S RO ";" :];
+ stream_patt [: :] spcl k :]
+ | [(spc, Some e) :: spcl] ->
+ [: `HVbox
+ [: `stream_patt_comp b spc "" [: :];
+ `HVbox [: `S LR "??"; `expr e ";" [: `S RO ";" :] :] :];
+ stream_patt [: :] spcl k :] ]
+ and stream_patt_comp b spc dg k =
+ match spc with
+ [ SPCterm (p, w) ->
+ HVbox [: b; `S LO "'"; `spatt p "" (when_opt w k) :]
+ | SPCnterm p e ->
+ HVbox [: b; `HVbox [: `patt p "" [: `S LR "=" :]; `expr e dg k :] :]
+ | SPCsterm p -> HVbox [: b; `patt p "" k :] ]
+ and when_opt wo k =
+ match wo with
+ [ Some e -> [: `S LR "when"; `expr e "" k :]
+ | _ -> k ]
+ in
+ parser_cases b spel dg k
+;
+
+value parser_body e dg k =
+ let (bp, e) =
+ match e with
+ [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e)
+ | e -> (None, e) ]
+ in
+ match Parserify.parser_of_expr e with
+ [ [] ->
+ let spe = ([], None, <:expr< raise Stream.Failure >>) in
+ HVbox
+ [: `HVbox
+ [: `S LR "parser";
+ match bp with
+ [ Some p -> [: `patt p "" [: :] :]
+ | _ -> [: :] ] :];
+ parser_cases [: :] [spe] dg k :]
+ | spel ->
+ BEVbox
+ [: `HVbox
+ [: `S LR "parser";
+ match bp with
+ [ Some p -> [: `patt p "" [: :] :]
+ | _ -> [: :] ] :];
+ parser_cases [: :] spel dg k :] ]
+;
+
+value pmatch e dg k =
+ let (me, e) =
+ match e with
+ [ <:expr< let (__strm : Stream.t _) = $me$ in $e$ >> -> (me, e)
+ | _ -> failwith "Pr_op.pmatch" ]
+ in
+ let (bp, e) =
+ match e with
+ [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e)
+ | e -> (None, e) ]
+ in
+ let spel = Parser_of_expr.parser_of_expr e in
+ Vbox
+ [: `HVbox [: :];
+ `HVbox
+ [: `S LR "match"; `expr me "" [: `S LR "with" :]; `S LR "parser";
+ match bp with
+ [ Some p -> [: `patt p "" [: :] :]
+ | _ -> [: :] ] :];
+ `BEbox [: `HVbox [: :]; parser_cases [: :] spel dg k :] :]
+;
+
+(* Printer extensions *)
+
+pr_expr_fun_args.val :=
+ extfun pr_expr_fun_args.val with
+ [ <:expr< fun __strm -> $_$ >> as ge -> ([], ge)
+ | <:expr< fun [(__strm : $_$) -> $_$] >> as ge -> ([], ge) ];
+
+let lev = find_pr_level "expr1" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< let (__strm : Stream.t _) = $_$ in $_$ >> as e ->
+ fun curr next dg k ->
+ if not (List.mem dg ["|"; ";"]) then [: `pmatch e dg k :]
+ else [: `S LO "("; `pmatch e "" [: `S RO ")"; k :] :]
+ | <:expr< fun __strm -> $x$ >> ->
+ fun curr next dg k ->
+ if not (List.mem dg ["|"; ";"]) then [: `parser_body x dg k :]
+ else [: `S LO "("; `parser_body x "" [: `S RO ")"; k :] :]
+ | <:expr< fun [ (__strm : $_$) -> $x$ ] >> ->
+ fun curr next dg k ->
+ if not (List.mem dg ["|"; ";"]) then [: `parser_body x dg k :]
+ else [: `S LO "("; `parser_body x "" [: `S RO ")"; k :] :] ];
+
+let lev = find_pr_level "apply" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> |
+ <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lcons (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> |
+ <:expr< Stream.slazy $_$ >> as e ->
+ fun curr next dg k -> [: `next e "" k :] ];
+
+let lev = find_pr_level "dot" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Stream.sempty >> as e ->
+ fun curr next dg k -> [: `next e "" k :] ];
+
+let lev = find_pr_level "simple" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> |
+ <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lcons (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> |
+ <:expr< Stream.slazy $_$ >> as e ->
+ fun curr next dg k ->
+ [: `stream e "" k :] ];
--- /dev/null
+(* camlp4r q_MLast.cmo ./pa_extfun.cmo *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 1998 Institut National de Recherche en Informatique et *)
+(* Automatique. Distributed only by permission. *)
+(* *)
+(***********************************************************************)
+
+
+
+open Pcaml;
+open Spretty;
+
+value _loc = Loc.mk "FIXME pr_op_main.ml";
+
+value expr e dg k = pr_expr.pr_fun "top" e dg k;
+value patt e dg k = pr_patt.pr_fun "top" e dg k;
+
+value spatt p dg k =
+ match p with
+ [ <:patt< $lid:s$ >> ->
+ if String.length s >= 2 && s.[1] == ''' then
+ HVbox [: `S LR (" " ^ s); k :]
+ else patt p dg k
+ | _ -> patt p dg k ]
+;
+
+(* Streams *)
+
+value stream e _ k =
+ let rec get =
+ fun
+ [ <:expr< Stream.iapp $x$ $y$ >> -> [(False, x) :: get y]
+ | <:expr< Stream.icons $x$ $y$ >> -> [(True, x) :: get y]
+ | <:expr< Stream.ising $x$ >> -> [(True, x)]
+ | <:expr< Stream.lapp (fun _ -> $x$) $y$ >> -> [(False, x) :: get y]
+ | <:expr< Stream.lcons (fun _ -> $x$) $y$ >> -> [(True, x) :: get y]
+ | <:expr< Stream.lsing (fun _ -> $x$) >> -> [(True, x)]
+ | <:expr< Stream.sempty >> -> []
+ | <:expr< Stream.slazy (fun _ -> $x$) >> -> [(False, x)]
+ | <:expr< Stream.slazy $x$ >> -> [(False, <:expr< $x$ () >>)]
+ | e -> [(False, e)] ]
+ in
+ let elem e dg k =
+ match e with
+ [ (True, e) -> [: `HOVbox [: `S LO "'"; `expr e dg k :] :]
+ | (False, e) -> [: `expr e dg k :] ]
+ in
+ let rec glop e k =
+ match e with
+ [ [] -> k
+ | [e] -> [: elem e "" k :]
+ | [e :: el] -> [: elem e ";" [: `S RO ";" :]; glop el k :] ]
+ in
+ HOVbox [: `S LR "[<"; glop (get e) [: `S LR ">]"; k :] :]
+;
+
+(* Parsers *)
+
+open Parserify;
+
+value parser_cases b spel dg k =
+ let rec parser_cases b spel dg k =
+ match spel with
+ [ [] -> [: `HVbox [: b; k :] :]
+ | [(sp, epo, e)] -> [: `parser_case b sp epo e dg k :]
+ | [(sp, epo, e) :: spel] ->
+ [: `parser_case b sp epo e "|" [: :];
+ parser_cases [: `S LR "|" :] spel dg k :] ]
+ and parser_case b sp epo e dg k =
+ let epo =
+ match epo with
+ [ Some p -> [: `patt p "" [: `S LR "->" :] :]
+ | _ -> [: `S LR "->" :] ]
+ in
+ HVbox
+ [: b;
+ `HOVbox
+ [: `HOVbox
+ [: `S LR "[<";
+ stream_patt [: :] sp [: `S LR ">]"; epo :] :];
+ `expr e dg k :] :]
+ and stream_patt b sp k =
+ match sp with
+ [ [] -> [: `HVbox [: b; k :] :]
+ | [(spc, None)] -> [: `stream_patt_comp b spc "" k :]
+ | [(spc, Some e)] ->
+ [: `HVbox
+ [: `stream_patt_comp b spc "" [: :];
+ `HVbox [: `S LR "??"; `expr e "" k :] :] :]
+ | [(spc, None) :: spcl] ->
+ [: `stream_patt_comp b spc ";" [: `S RO ";" :];
+ stream_patt [: :] spcl k :]
+ | [(spc, Some e) :: spcl] ->
+ [: `HVbox
+ [: `stream_patt_comp b spc "" [: :];
+ `HVbox [: `S LR "??"; `expr e ";" [: `S RO ";" :] :] :];
+ stream_patt [: :] spcl k :] ]
+ and stream_patt_comp b spc dg k =
+ match spc with
+ [ SPCterm (p, w) ->
+ HVbox [: b; `S LO "'"; `spatt p "" (when_opt w k) :]
+ | SPCnterm p e ->
+ HVbox [: b; `HVbox [: `patt p "" [: `S LR "=" :]; `expr e dg k :] :]
+ | SPCsterm p -> HVbox [: b; `patt p "" k :] ]
+ and when_opt wo k =
+ match wo with
+ [ Some e -> [: `S LR "when"; `expr e "" k :]
+ | _ -> k ]
+ in
+ parser_cases b spel dg k
+;
+
+value parser_body e dg k =
+ let (bp, e) =
+ match e with
+ [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e)
+ | e -> (None, e) ]
+ in
+ match parser_of_expr e with
+ [ [] ->
+ let spe = ([], None, <:expr< raise Stream.Failure >>) in
+ HVbox
+ [: `HVbox
+ [: `S LR "parser";
+ match bp with
+ [ Some p -> [: `patt p "" [: :] :]
+ | _ -> [: :] ] :];
+ parser_cases [: :] [spe] dg k :]
+ | spel ->
+ BEVbox
+ [: `HVbox
+ [: `S LR "parser";
+ match bp with
+ [ Some p -> [: `patt p "" [: :] :]
+ | _ -> [: :] ] :];
+ parser_cases [: :] spel dg k :] ]
+;
+
+value pmatch e dg k =
+ let (me, e) =
+ match e with
+ [ <:expr< let (__strm : Stream.t _) = $me$ in $e$ >> -> (me, e)
+ | _ -> failwith "Pr_op.pmatch" ]
+ in
+ let (bp, e) =
+ match e with
+ [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e)
+ | e -> (None, e) ]
+ in
+ let spel = parser_of_expr e in
+ Vbox
+ [: `HVbox [: :];
+ `HVbox
+ [: `S LR "match"; `expr me "" [: `S LR "with" :]; `S LR "parser";
+ match bp with
+ [ Some p -> [: `patt p "" [: :] :]
+ | _ -> [: :] ] :];
+ `BEbox [: `HVbox [: :]; parser_cases [: :] spel dg k :] :]
+;
+
+(* Printer extensions *)
+
+pr_expr_fun_args.val :=
+ extfun pr_expr_fun_args.val with
+ [ <:expr< fun __strm -> $_$ >> as ge -> ([], ge)
+ | <:expr< fun [(__strm : $_$) -> $_$] >> as ge -> ([], ge) ];
+
+let lev = find_pr_level "expr1" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< let (__strm : Stream.t _) = $_$ in $_$ >> as e ->
+ fun _ _ dg k ->
+ if not (List.mem dg ["|"; ";"]) then [: `pmatch e dg k :]
+ else [: `S LO "("; `pmatch e "" [: `S RO ")"; k :] :]
+ | <:expr< fun __strm -> $x$ >> ->
+ fun _ _ dg k ->
+ if not (List.mem dg ["|"; ";"]) then [: `parser_body x dg k :]
+ else [: `S LO "("; `parser_body x "" [: `S RO ")"; k :] :]
+ | <:expr< fun [ (__strm : $_$) -> $x$ ] >> ->
+ fun _ _ dg k ->
+ if not (List.mem dg ["|"; ";"]) then [: `parser_body x dg k :]
+ else [: `S LO "("; `parser_body x "" [: `S RO ")"; k :] :] ];
+
+let lev = find_pr_level "apply" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> |
+ <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lcons (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> |
+ <:expr< Stream.slazy $_$ >> as e ->
+ fun _ next _ k -> [: `next e "" k :] ];
+
+let lev = find_pr_level "dot" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Stream.sempty >> as e ->
+ fun _ next _ k -> [: `next e "" k :] ];
+
+let lev = find_pr_level "simple" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> |
+ <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lcons (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> |
+ <:expr< Stream.slazy $_$ >> as e ->
+ fun _ _ _ k ->
+ [: `stream e "" k :] ];
--- /dev/null
+(* camlp4r q_MLast.cmo ./pa_extfun.cmo *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 1998 Institut National de Recherche en Informatique et *)
+(* Automatique. Distributed only by permission. *)
+(* *)
+(***********************************************************************)
+
+
+
+open Pcaml;
+open Spretty;
+
+value _loc = (Token.nowhere, Token.nowhere);
+
+value expr e dg k = pr_expr.pr_fun "top" e dg k;
+value patt e dg k = pr_patt.pr_fun "top" e dg k;
+
+(* Streams *)
+
+value stream e dg k =
+ let rec get =
+ fun
+ [ <:expr< Stream.iapp $x$ $y$ >> -> [(False, x) :: get y]
+ | <:expr< Stream.icons $x$ $y$ >> -> [(True, x) :: get y]
+ | <:expr< Stream.ising $x$ >> -> [(True, x)]
+ | <:expr< Stream.lapp (fun _ -> $x$) $y$ >> -> [(False, x) :: get y]
+ | <:expr< Stream.lcons (fun _ -> $x$) $y$ >> -> [(True, x) :: get y]
+ | <:expr< Stream.lsing (fun _ -> $x$) >> -> [(True, x)]
+ | <:expr< Stream.sempty >> -> []
+ | <:expr< Stream.slazy (fun _ -> $x$) >> -> [(False, x)]
+ | <:expr< Stream.slazy $x$ >> -> [(False, <:expr< $x$ () >>)]
+ | e -> [(False, e)] ]
+ in
+ let elem e k =
+ match e with
+ [ (True, e) -> [: `HOVbox [: `S LO "`"; `expr e "" k :] :]
+ | (False, e) -> [: `expr e "" k :] ]
+ in
+ let rec glop e k =
+ match e with
+ [ [] -> k
+ | [e] -> [: elem e k :]
+ | [e :: el] -> [: elem e [: `S RO ";" :]; glop el k :] ]
+ in
+ HOVbox [: `S LR "[:"; glop (get e) [: `S LR ":]"; k :] :]
+;
+
+(* Parsers *)
+
+value parser_cases b spel k =
+ let rec parser_cases b spel k =
+ match spel with
+ [ [] -> [: `HVbox [: b; k :] :]
+ | [(sp, epo, e)] -> [: `parser_case b sp epo e k :]
+ | [(sp, epo, e) :: spel] ->
+ [: `parser_case b sp epo e [: :];
+ parser_cases [: `S LR "|" :] spel k :] ]
+ and parser_case b sp epo e k =
+ let epo =
+ match epo with
+ [ Some p -> [: `patt p "" [: `S LR "->" :] :]
+ | _ -> [: `S LR "->" :] ]
+ in
+ HVbox
+ [: b;
+ `HOVbox
+ [: `HOVbox
+ [: `S LR "[:";
+ stream_patt [: :] sp [: `S LR ":]"; epo :] :];
+ `expr e "" k :] :]
+ and stream_patt b sp k =
+ match sp with
+ [ [] -> [: `HVbox [: b; k :] :]
+ | [(spc, None)] -> [: `stream_patt_comp b spc k :]
+ | [(spc, Some e)] ->
+ [: `HVbox
+ [: `stream_patt_comp b spc [: :];
+ `HVbox [: `S LR "?"; `expr e "" k :] :] :]
+ | [(spc, None) :: spcl] ->
+ [: `stream_patt_comp b spc [: `S RO ";" :];
+ stream_patt [: :] spcl k :]
+ | [(spc, Some e) :: spcl] ->
+ [: `HVbox
+ [: `stream_patt_comp b spc [: :];
+ `HVbox [: `S LR "?"; `expr e "" [: `S RO ";" :] :] :];
+ stream_patt [: :] spcl k :] ]
+ and stream_patt_comp b spc k =
+ match spc with
+ [ SPCterm (p, w) ->
+ HVbox [: b; `S LO "`"; `patt p "" [: :]; `HVbox [: when_opt w k :] :]
+ | SPCnterm p e ->
+ HVbox [: b; `HVbox [: `patt p "" [: `S LR "=" :]; `expr e "" k :] :]
+ | SPCsterm p -> HVbox [: b; `patt p "" k :] ]
+ and when_opt wo k =
+ match wo with
+ [ Some e -> [: `S LR "when"; `expr e "" k :]
+ | _ -> k ]
+ in
+ parser_cases b spel k
+;
+
+value parser_body e dg k =
+ let (bp, e) =
+ match e with
+ [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e)
+ | e -> (None, e) ]
+ in
+ match Parserify.parser_of_expr e with
+ [ [] ->
+ HVbox
+ [: `HVbox
+ [: `S LR "parser";
+ match bp with
+ [ Some p -> [: `patt p "" [: :] :]
+ | _ -> [: :] ] :];
+ `HVbox [: `S LR "[]"; k :] :]
+ | [spe] ->
+ HVbox
+ [: `HVbox
+ [: `S LR "parser";
+ match bp with
+ [ Some p -> [: `patt p "" [: :] :]
+ | _ -> [: :] ] :];
+ parser_cases [: :] [spe] k :]
+ | spel ->
+ Vbox
+ [: `HVbox [: :];
+ `HVbox
+ [: `S LR "parser";
+ match bp with
+ [ Some p -> [: `patt p "" [: :] :]
+ | _ -> [: :] ] :];
+ parser_cases [: `S LR "[" :] spel [: `S LR "]"; k :] :] ]
+;
+
+value pmatch e dg k =
+ let (me, e) =
+ match e with
+ [ <:expr< let (__strm : Stream.t _) = $me$ in $e$ >> -> (me, e)
+ | <:expr< match $_$ __strm with [ $list:_$ ] >> -> (<:expr< __strm >>, e)
+ | _ -> failwith "Pr_rp.pmatch" ]
+ in
+ let (bp, e) =
+ match e with
+ [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e)
+ | e -> (None, e) ]
+ in
+ let spel = Parserify.parser_of_expr e in
+ Vbox
+ [: `HVbox [: :];
+ `HVbox
+ [: `S LR "match"; `expr me "" [: `S LR "with" :]; `S LR "parser";
+ match bp with
+ [ Some p -> [: `patt p "" [: :] :]
+ | _ -> [: :] ] :];
+ parser_cases [: `S LR "[" :] spel [: `S LR "]"; k :] :]
+;
+
+(* Printer extensions *)
+
+pr_expr_fun_args.val :=
+ extfun pr_expr_fun_args.val with
+ [ <:expr< fun __strm -> $_$ >> as ge -> ([], ge)
+ | <:expr< fun [(__strm : $_$) -> $_$] >> as ge -> ([], ge) ];
+
+let lev = find_pr_level "top" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< let (__strm : Stream.t _) = $_$ in $_$ >> as e ->
+ fun curr next _ k -> [: `pmatch e "" k :]
+ | <:expr< match $_$ __strm with [ $list:_$ ] >> as e ->
+ fun curr next _ k -> [: `pmatch e "" k :]
+ | <:expr< fun __strm -> $x$ >> ->
+ fun curr next _ k -> [: `parser_body x "" k :]
+ | <:expr< fun (__strm : $_$) -> $x$ >> ->
+ fun curr next _ k -> [: `parser_body x "" k :] ];
+
+let lev = find_pr_level "apply" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> |
+ <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lcons (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> |
+ <:expr< Stream.slazy $_$ >> as e ->
+ fun curr next _ k -> [: `next e "" k :] ];
+
+let lev = find_pr_level "dot" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Stream.sempty >> as e ->
+ fun curr next _ k -> [: `next e "" k :] ];
+
+let lev = find_pr_level "simple" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> |
+ <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lcons (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> |
+ <:expr< Stream.slazy $_$ >> as e ->
+ fun curr next _ k -> [: `stream e "" k :] ];
--- /dev/null
+(* camlp4r q_MLast.cmo ./pa_extfun.cmo *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 1998 Institut National de Recherche en Informatique et *)
+(* Automatique. Distributed only by permission. *)
+(* *)
+(***********************************************************************)
+
+
+
+open Pcaml;
+open Spretty;
+
+value _loc = Loc.mk "FIXME pr_rp_main.ml";
+
+value expr e dg k = pr_expr.pr_fun "top" e dg k;
+value patt e dg k = pr_patt.pr_fun "top" e dg k;
+
+(* Streams *)
+
+value stream e _ k =
+ let rec get =
+ fun
+ [ <:expr< Stream.iapp $x$ $y$ >> -> [(False, x) :: get y]
+ | <:expr< Stream.icons $x$ $y$ >> -> [(True, x) :: get y]
+ | <:expr< Stream.ising $x$ >> -> [(True, x)]
+ | <:expr< Stream.lapp (fun _ -> $x$) $y$ >> -> [(False, x) :: get y]
+ | <:expr< Stream.lcons (fun _ -> $x$) $y$ >> -> [(True, x) :: get y]
+ | <:expr< Stream.lsing (fun _ -> $x$) >> -> [(True, x)]
+ | <:expr< Stream.sempty >> -> []
+ | <:expr< Stream.slazy (fun _ -> $x$) >> -> [(False, x)]
+ | <:expr< Stream.slazy $x$ >> -> [(False, <:expr< $x$ () >>)]
+ | e -> [(False, e)] ]
+ in
+ let elem e k =
+ match e with
+ [ (True, e) -> [: `HOVbox [: `S LO "`"; `expr e "" k :] :]
+ | (False, e) -> [: `expr e "" k :] ]
+ in
+ let rec glop e k =
+ match e with
+ [ [] -> k
+ | [e] -> [: elem e k :]
+ | [e :: el] -> [: elem e [: `S RO ";" :]; glop el k :] ]
+ in
+ HOVbox [: `S LR "[:"; glop (get e) [: `S LR ":]"; k :] :]
+;
+
+(* Parsers *)
+
+open Parserify;
+
+value parser_cases b spel k =
+ let rec parser_cases b spel k =
+ match spel with
+ [ [] -> [: `HVbox [: b; k :] :]
+ | [(sp, epo, e)] -> [: `parser_case b sp epo e k :]
+ | [(sp, epo, e) :: spel] ->
+ [: `parser_case b sp epo e [: :];
+ parser_cases [: `S LR "|" :] spel k :] ]
+ and parser_case b sp epo e k =
+ let epo =
+ match epo with
+ [ Some p -> [: `patt p "" [: `S LR "->" :] :]
+ | _ -> [: `S LR "->" :] ]
+ in
+ HVbox
+ [: b;
+ `HOVbox
+ [: `HOVbox
+ [: `S LR "[:";
+ stream_patt [: :] sp [: `S LR ":]"; epo :] :];
+ `expr e "" k :] :]
+ and stream_patt b sp k =
+ match sp with
+ [ [] -> [: `HVbox [: b; k :] :]
+ | [(spc, None)] -> [: `stream_patt_comp b spc k :]
+ | [(spc, Some e)] ->
+ [: `HVbox
+ [: `stream_patt_comp b spc [: :];
+ `HVbox [: `S LR "?"; `expr e "" k :] :] :]
+ | [(spc, None) :: spcl] ->
+ [: `stream_patt_comp b spc [: `S RO ";" :];
+ stream_patt [: :] spcl k :]
+ | [(spc, Some e) :: spcl] ->
+ [: `HVbox
+ [: `stream_patt_comp b spc [: :];
+ `HVbox [: `S LR "?"; `expr e "" [: `S RO ";" :] :] :];
+ stream_patt [: :] spcl k :] ]
+ and stream_patt_comp b spc k =
+ match spc with
+ [ SPCterm (p, w) ->
+ HVbox [: b; `S LO "`"; `patt p "" [: :]; `HVbox [: when_opt w k :] :]
+ | SPCnterm p e ->
+ HVbox [: b; `HVbox [: `patt p "" [: `S LR "=" :]; `expr e "" k :] :]
+ | SPCsterm p -> HVbox [: b; `patt p "" k :] ]
+ and when_opt wo k =
+ match wo with
+ [ Some e -> [: `S LR "when"; `expr e "" k :]
+ | _ -> k ]
+ in
+ parser_cases b spel k
+;
+
+value parser_body e _ k =
+ let (bp, e) =
+ match e with
+ [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e)
+ | e -> (None, e) ]
+ in
+ match parser_of_expr e with
+ [ [] ->
+ HVbox
+ [: `HVbox
+ [: `S LR "parser";
+ match bp with
+ [ Some p -> [: `patt p "" [: :] :]
+ | _ -> [: :] ] :];
+ `HVbox [: `S LR "[]"; k :] :]
+ | [spe] ->
+ HVbox
+ [: `HVbox
+ [: `S LR "parser";
+ match bp with
+ [ Some p -> [: `patt p "" [: :] :]
+ | _ -> [: :] ] :];
+ parser_cases [: :] [spe] k :]
+ | spel ->
+ Vbox
+ [: `HVbox [: :];
+ `HVbox
+ [: `S LR "parser";
+ match bp with
+ [ Some p -> [: `patt p "" [: :] :]
+ | _ -> [: :] ] :];
+ parser_cases [: `S LR "[" :] spel [: `S LR "]"; k :] :] ]
+;
+
+value pmatch e _ k =
+ let (me, e) =
+ match e with
+ [ <:expr< let (__strm : Stream.t _) = $me$ in $e$ >> -> (me, e)
+ | _ -> failwith "Pr_rp.pmatch" ]
+ in
+ let (bp, e) =
+ match e with
+ [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e)
+ | e -> (None, e) ]
+ in
+ let spel = parser_of_expr e in
+ Vbox
+ [: `HVbox [: :];
+ `HVbox
+ [: `S LR "match"; `expr me "" [: `S LR "with" :]; `S LR "parser";
+ match bp with
+ [ Some p -> [: `patt p "" [: :] :]
+ | _ -> [: :] ] :];
+ parser_cases [: `S LR "[" :] spel [: `S LR "]"; k :] :]
+;
+
+(* Printer extensions *)
+
+pr_expr_fun_args.val :=
+ extfun pr_expr_fun_args.val with
+ [ <:expr< fun __strm -> $_$ >> as ge -> ([], ge)
+ | <:expr< fun [(__strm : $_$) -> $_$] >> as ge -> ([], ge) ];
+
+let lev = find_pr_level "top" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< let (__strm : Stream.t _) = $_$ in $_$ >> as e ->
+ fun _ _ _ k -> [: `pmatch e "" k :]
+ | <:expr< fun __strm -> $x$ >> ->
+ fun _ _ _ k -> [: `parser_body x "" k :]
+ | <:expr< fun (__strm : $_$) -> $x$ >> ->
+ fun _ _ _ k -> [: `parser_body x "" k :] ];
+
+let lev = find_pr_level "apply" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> |
+ <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lcons (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> |
+ <:expr< Stream.slazy $_$ >> as e ->
+ fun _ next _ k -> [: `next e "" k :] ];
+
+let lev = find_pr_level "dot" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Stream.sempty >> as e ->
+ fun _ next _ k -> [: `next e "" k :] ];
+
+let lev = find_pr_level "simple" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< Stream.iapp $_$ $_$ >> | <:expr< Stream.icons $_$ $_$ >> |
+ <:expr< Stream.ising $_$ >> | <:expr< Stream.lapp (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lcons (fun _ -> $_$) $_$ >> |
+ <:expr< Stream.lsing (fun _ -> $_$) >> | <:expr< Stream.sempty >> |
+ <:expr< Stream.slazy $_$ >> as e ->
+ fun _ _ _ k -> [: `stream e "" k :] ];
--- /dev/null
+(* camlp4r pa_extend.cmo q_MLast.cmo *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 2001 Institut National de Recherche en Informatique et *)
+(* Automatique. Distributed only by permission. *)
+(* *)
+(***********************************************************************)
+
+
+
+open Pcaml;
+
+value t = ref "";
+
+Quotation.add ""
+ (Quotation.ExAst
+ (fun c s ->
+ let _loc = c.Quotation.loc in
+ let t =
+ if t.val = "" then "<<" ^ s ^ ">>"
+ else "<:" ^ t.val ^ "<" ^ s ^ ">>"
+ in
+ <:expr< $uid:t$ >>,
+ fun c s ->
+ let _loc = c.Quotation.loc in
+ let t =
+ if t.val = "" then "<<" ^ s ^ ">>"
+ else "<:" ^ t.val ^ "<" ^ s ^ ">>"
+ in
+ <:patt< $uid:t$ >>))
+;
+
+Quotation.default.val := "";
+Quotation.translate.val := fun s -> do { t.val := s; "" };
--- /dev/null
+This is an application of or an extension for Camlp4. Although it is
+currently distributed with OCaml/Camlp4, it may or may not be
+actively maintained.
+
+It probably won't be part of future OCaml/Camlp4 distributions but be
+accessible from the Camlp4 hump. If you are interested in developing
+this package further and/or actively maintain it, please let us know
+(caml@inria.fr)
+
+This package is distributed under the same license as the Objective
+Caml Library (that is, LGPL with a special exception allowing both
+static and dynamic link).
+
+-- Michel Mauny
+ Nicolas Pouillard
--- /dev/null
+(* camlp4r pa_extend.cmo q_MLast.cmo *)
+
+
+open Pcaml;
+open Pa_extend;
+
+value sfold _loc n foldfun f e s =
+ let styp = STquo _loc (new_type_var ()) in
+ let e = <:expr< Extfold.$lid:foldfun$ $f$ $e$ >> in
+ let t = STapp _loc (STapp _loc (STtyp <:ctyp< Extfold.t _ >>) s.styp) styp in
+ {used = s.used; text = TXmeta _loc n [s.text] e t; styp = styp}
+;
+
+value sfoldsep _loc n foldfun f e s sep =
+ let styp = STquo _loc (new_type_var ()) in
+ let e = <:expr< Extfold.$lid:foldfun$ $f$ $e$ >> in
+ let t =
+ STapp _loc (STapp _loc (STtyp <:ctyp< Extfold.tsep _ >>) s.styp) styp
+ in
+ {used = s.used @ sep.used; text = TXmeta _loc n [s.text; sep.text] e t;
+ styp = styp}
+;
+
+EXTEND
+ GLOBAL: symbol;
+ symbol: LEVEL "top"
+ [ [ UIDENT "FOLD0"; f = simple_expr; e = simple_expr; s = SELF ->
+ sfold _loc "FOLD0" "sfold0" f e s
+ | UIDENT "FOLD1"; f = simple_expr; e = simple_expr; s = SELF ->
+ sfold _loc "FOLD1" "sfold1" f e s
+ | UIDENT "FOLD0"; f = simple_expr; e = simple_expr; s = SELF;
+ UIDENT "SEP"; sep = symbol ->
+ sfoldsep _loc "FOLD0 SEP" "sfold0sep" f e s sep
+ | UIDENT "FOLD1"; f = simple_expr; e = simple_expr; s = SELF;
+ UIDENT "SEP"; sep = symbol ->
+ sfoldsep _loc "FOLD1 SEP" "sfold1sep" f e s sep ] ]
+ ;
+ simple_expr:
+ [ [ i = LIDENT -> <:expr< $lid:i$ >>
+ | "("; e = expr; ")" -> e ] ]
+ ;
+END;
--- /dev/null
+#########################################################################
+# #
+# Objective Caml #
+# #
+# Camlp4 #
+# #
+# Copyright 2004 Institut National de Recherche en Informatique et #
+# en Automatique. All rights reserved. This file is distributed #
+# under the terms of the Q Public License version 1.0. #
+# #
+#########################################################################
+#
+# Makefile for pa_format
+# M.Mauny
+#
+
+include ../../config/Makefile.cnf
+
+OCAMLTOP=../../..
+CAMLP4=../../camlp4/camlp4$(EXE)
+
+OCAMLC=$(OCAMLTOP)/ocamlc$(EXE)
+OCAMLOPT=$(OCAMLTOP)/ocamlopt$(EXE)
+
+P4INCLUDES= -nolib -I ../../lib -I ../../meta -I ../../etc
+OCAMLINCLUDES= -nostdlib -I $(OCAMLTOP)/stdlib -I ../../lib -I ../../camlp4
+OCAMLCFLAGS=-warn-error A $(OCAMLINCLUDES)
+
+SRC=pa_format.ml
+OBJS=$(SRC:.ml=.cmo)
+OBJSX=$(SRC:.ml=.cmx)
+
+all: $(OBJS)
+
+opt: $(OBJSX)
+
+depend:
+ cp .depend .depend.bak
+ > .depend
+ for file in $(SRC); do \
+ $(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $$file` pr_depend.cmo $$i | \
+ sed -e 's| \.\./\.\./\.\.| $$(OCAMLTOP)|g' >> .depend; \
+ done
+
+clean:
+ rm -f *.cm* *.$(O) *.bak .*.bak
+
+
+.SUFFIXES: .cmx .cmo .cmi .ml .mli
+
+.mli.cmi:
+ $(OCAMLC) $(OCAMLCFLAGS) -c $<
+
+
+.ml.cmo:
+ $(OCAMLC) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $<
+
+.ml.cmx:
+ $(OCAMLOPT) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $<
+
+include .depend
--- /dev/null
+This is an application of or an extension for Camlp4. Although it is
+currently distributed with OCaml/Camlp4, it may or may not be
+actively maintained.
+
+It probably won't be part of future OCaml/Camlp4 distributions but be
+accessible from the Camlp4 hump. If you are interested in developing
+this package further and/or actively maintain it, please let us know
+(caml@inria.fr)
+
+This package is distributed under the same license as the Objective
+Caml Library (that is, LGPL with a special exception allowing both
+static and dynamic link).
+
+-- Michel Mauny
+
--- /dev/null
+(* pa_r.cmo pa_extend.cmo q_MLast.cmo pr_dump.cmo *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 2002 Institut National de Recherche en Informatique et *)
+(* en Automatique. All rights reserved. This file is distributed *)
+(* under the terms of the GNU Library General Public License, with *)
+(* the special exception on linking described in file *)
+(* ../../../LICENSE. *)
+(* *)
+(***********************************************************************)
+
+
+open Pcaml;
+
+EXTEND
+ GLOBAL: expr;
+ expr: LEVEL "top"
+ [ [ n = box_type; d = SELF; "begin";
+ el = LIST0 [ e = box_expr; ";" -> e ]; "end" ->
+ let el = [<:expr< Format.$lid:"open_" ^ n$ $d$ >> :: el] in
+ let el = el @ [<:expr< Format.close_box () >>] in
+ <:expr< do { $list:el$ } >>
+ | "hbox"; "begin"; el = LIST0 [ e = box_expr; ";" -> e ]; "end" ->
+ let el = [<:expr< Format.open_hbox () >> :: el] in
+ let el = el @ [<:expr< Format.close_box () >>] in
+ <:expr< do { $list:el$ } >>
+ | "nobox"; "begin"; el = LIST0 [ e = box_expr; ";" -> e ]; "end" ->
+ match el with
+ [ [e] -> e
+ | _ -> <:expr< do { $list:el$ } >> ] ] ]
+ ;
+ box_type:
+ [ [ n = "hovbox" -> n
+ | n = "hvbox" -> n
+ | n = "vbox" -> n
+ | n = "box" -> n ] ]
+ ;
+ box_expr:
+ [ [ s = STRING -> <:expr< Format.print_string $str:s$ >>
+ | UIDENT "STRING"; e = expr -> <:expr< Format.print_string $e$ >>
+ | UIDENT "INT"; e = expr -> <:expr< Format.print_int $e$ >>
+ | "/-" -> <:expr< Format.print_space () >>
+ | "//" -> <:expr< Format.print_cut () >>
+ | "!/" -> <:expr< Format.force_newline () >>
+ | "?/" -> <:expr< Format.print_if_newline () >>
+ | e = expr -> e ] ]
+ ;
+END;
--- /dev/null
+#########################################################################
+# #
+# Objective Caml #
+# #
+# Camlp4 #
+# #
+# Copyright 2004 Institut National de Recherche en Informatique et #
+# en Automatique. All rights reserved. This file is distributed #
+# under the terms of the Q Public License version 1.0. #
+# #
+#########################################################################
+#
+# Makefile for pa_lefteval
+# M.Mauny
+#
+
+include ../../config/Makefile.cnf
+
+OCAMLTOP=../../..
+CAMLP4=../../camlp4/camlp4$(EXE)
+
+OCAMLC=$(OCAMLTOP)/ocamlc$(EXE)
+OCAMLOPT=$(OCAMLTOP)/ocamlopt$(EXE)
+
+P4INCLUDES= -nolib -I ../../meta -I ../../etc
+OCAMLINCLUDES= -nostdlib -I $(OCAMLTOP)/stdlib -I ../../camlp4
+OCAMLCFLAGS=-warn-error A $(OCAMLINCLUDES)
+
+SRC=pa_lefteval.ml
+OBJS=$(SRC:.ml=.cmo)
+OBJSX=$(SRC:.ml=.cmx)
+
+all: $(OBJS)
+
+opt: $(OBJSX)
+
+depend:
+ cp .depend .depend.bak
+ > .depend
+ for file in $(SRC); do \
+ $(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $$file` pr_depend.cmo $$i | \
+ sed -e 's| \.\./\.\./\.\.| $$(OCAMLTOP)|g' >> .depend; \
+ done
+
+clean:
+ rm -f *.cm* *.$(O) *.bak .*.bak
+
+
+.SUFFIXES: .cmx .cmo .cmi .ml .mli
+
+.mli.cmi:
+ $(OCAMLC) $(OCAMLCFLAGS) -c $<
+
+
+.ml.cmo:
+ $(OCAMLC) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $<
+
+.ml.cmx:
+ $(OCAMLOPT) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $<
+
+include .depend
--- /dev/null
+This is an application of or an extension for Camlp4. Although it is
+currently distributed with OCaml/Camlp4, it may or may not be
+actively maintained.
+
+It probably won't be part of future OCaml/Camlp4 distributions but be
+accessible from the Camlp4 hump. If you are interested in developing
+this package further and/or actively maintain it, please let us know
+(caml@inria.fr)
+
+This package is distributed under the same license as the Objective
+Caml Library (that is, LGPL with a special exception allowing both
+static and dynamic link).
+
+-- Michel Mauny
+
--- /dev/null
+(* pa_r.cmo q_MLast.cmo pr_dump.cmo *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 2002 Institut National de Recherche en Informatique et *)
+(* en Automatique. All rights reserved. This file is distributed *)
+(* under the terms of the GNU Library General Public License, with *)
+(* the special exception on linking described in file *)
+(* ../../../LICENSE. *)
+(* *)
+(***********************************************************************)
+
+
+value not_impl name x =
+ let desc =
+ if Obj.is_block (Obj.repr x) then
+ "tag = " ^ string_of_int (Obj.tag (Obj.repr x))
+ else "int_val = " ^ string_of_int (Obj.magic x)
+ in
+ failwith ("pa_lefteval: not impl: " ^ name ^ "; " ^ desc ^ ">")
+;
+
+value rec expr_fa al =
+ fun
+ [ <:expr< $f$ $a$ >> -> expr_fa [a :: al] f
+ | f -> (f, al) ]
+;
+
+(* generating let..in before functions calls which evaluates
+ several (more than one) of their arguments *)
+
+value no_side_effects_ht =
+ let ht = Hashtbl.create 73 in
+ do {
+ List.iter (fun s -> Hashtbl.add ht s True)
+ ["<"; "="; "@"; "^"; "+"; "-"; "ref"];
+ ht
+ }
+;
+
+value no_side_effects =
+ fun
+ [ <:expr< $uid:_$ >> -> True
+ | <:expr< $uid:_$ . $uid:_$ >> -> True
+ | <:expr< $lid:s$ >> ->
+ try Hashtbl.find no_side_effects_ht s with [ Not_found -> False ]
+ | _ -> False ]
+;
+
+value rec may_side_effect =
+ fun
+ [ <:expr< $lid:_$ >> | <:expr< $uid:_$ >> | <:expr< $str:_$ >> |
+ <:expr< $chr:_$ >> | <:expr< $int:_$ >> | <:expr< $flo:_$ >> |
+ <:expr< $_$ . $_$ >> | <:expr< fun [ $list:_$ ] >> ->
+ False
+ | <:expr< ($list:el$) >> -> List.exists may_side_effect el
+ | <:expr< $_$ $_$ >> as e ->
+ let (f, el) = expr_fa [] e in
+ not (no_side_effects f) || List.exists may_side_effect el
+ | _ -> True ]
+;
+
+value rec may_be_side_effect_victim =
+ fun
+ [ <:expr< $lid:_$ . $_$ >> -> True
+ | <:expr< $uid:_$ . $e$ >> -> may_be_side_effect_victim e
+ | _ -> False ]
+;
+
+value rec may_depend_on_order el =
+ loop False False el where rec loop
+ side_effect_found side_effect_victim_found =
+ fun
+ [ [e :: el] ->
+ if may_side_effect e then
+ if side_effect_found || side_effect_victim_found then True
+ else loop True True el
+ else if may_be_side_effect_victim e then
+ if side_effect_found then True else loop False True el
+ else loop side_effect_found side_effect_victim_found el
+ | [] -> False ]
+;
+
+value gen_let_in loc expr el =
+ let (pel, el) =
+ loop 0 (List.rev el) where rec loop n =
+ fun
+ [ [e :: el] ->
+ if may_side_effect e || may_be_side_effect_victim e then
+ if n = 0 then
+ let (pel, el) = loop 1 el in
+ (pel, [expr e :: el])
+ else
+ let id = "xxx" ^ string_of_int n in
+ let (pel, el) = loop (n + 1) el in
+ ([(<:patt< $lid:id$ >>, expr e) :: pel],
+ [<:expr< $lid:id$ >> :: el])
+ else
+ let (pel, el) = loop n el in
+ (pel, [expr e :: el])
+ | [] -> ([], []) ]
+ in
+ match List.rev el with
+ [ [e :: el] -> (pel, e, el)
+ | _ -> assert False ]
+;
+
+value left_eval_apply loc expr e1 e2 =
+ let (f, el) = expr_fa [] <:expr< $e1$ $e2$ >> in
+ if not (may_depend_on_order [f :: el]) then <:expr< $expr e1$ $expr e2$ >>
+ else
+ let (pel, e, el) = gen_let_in loc expr [f :: el] in
+ let e = List.fold_left (fun e e1 -> <:expr< $e$ $e1$ >>) e el in
+ List.fold_left (fun e (p1, e1) -> <:expr< let $p1$ = $e1$ in $e$ >>) e pel
+;
+
+value left_eval_tuple loc expr el =
+ if not (may_depend_on_order el) then <:expr< ($list:List.map expr el$) >>
+ else
+ let (pel, e, el) = gen_let_in loc expr el in
+ List.fold_left (fun e (p1, e1) -> <:expr< let $p1$ = $e1$ in $e$ >>)
+ <:expr< ($list:[e :: el]$) >> pel
+;
+
+value left_eval_record loc expr lel =
+ let el = List.map snd lel in
+ if not (may_depend_on_order el) then
+ let lel = List.map (fun (p, e) -> (p, expr e)) lel in
+ <:expr< { $list:lel$ } >>
+ else
+ let (pel, e, el) = gen_let_in loc expr el in
+ let e =
+ let lel = List.combine (List.map fst lel) [e :: el] in
+ <:expr< { $list:lel$ } >>
+ in
+ List.fold_left (fun e (p1, e1) -> <:expr< let $p1$ = $e1$ in $e$ >>) e pel
+;
+
+value left_eval_assign loc expr e1 e2 = <:expr< $e1$ := $expr e2$ >>;
+
+(* scanning the input tree, calling "left_eval_*" functions if necessary *)
+
+value map_option f =
+ fun
+ [ Some x -> Some (f x)
+ | None -> None ]
+;
+
+value class_infos f ci =
+ {MLast.ciLoc = ci.MLast.ciLoc; MLast.ciVir = ci.MLast.ciVir;
+ MLast.ciPrm = ci.MLast.ciPrm; MLast.ciNam = ci.MLast.ciNam;
+ MLast.ciExp = f ci.MLast.ciExp}
+;
+
+value rec expr x =
+ let loc = MLast.loc_of_expr x in
+ match x with
+ [ <:expr< fun [ $list:pwel$ ] >> ->
+ <:expr< fun [ $list:List.map match_assoc pwel$ ] >>
+ | <:expr< match $e$ with [ $list:pwel$ ] >> ->
+ <:expr< match $expr e$ with [ $list:List.map match_assoc pwel$ ] >>
+ | <:expr< try $e$ with [ $list:pwel$ ] >> ->
+ <:expr< try $expr e$ with [ $list:List.map match_assoc pwel$ ] >>
+ | <:expr< let $opt:rf$ $list:pel$ in $e$ >> ->
+ <:expr< let $opt:rf$ $list:List.map let_binding pel$ in $expr e$ >>
+ | <:expr< let module $s$ = $me$ in $e$ >> ->
+ <:expr< let module $s$ = $module_expr me$ in $expr e$ >>
+ | <:expr< if $e1$ then $e2$ else $e3$ >> ->
+ <:expr< if $expr e1$ then $expr e2$ else $expr e3$ >>
+ | <:expr< while $e$ do { $list:el$ } >> ->
+ <:expr< while $expr e$ do { $list:List.map expr el$ } >>
+ | <:expr< do { $list:el$ } >> -> <:expr< do { $list:List.map expr el$ } >>
+ | <:expr< $e$ # $s$ >> -> <:expr< $expr e$ # $s$ >>
+ | <:expr< ($e$ : $t$) >> -> <:expr< ($expr e$ : $t$) >>
+ | <:expr< $e1$ || $e2$ >> -> <:expr< $expr e1$ || $expr e2$ >>
+ | <:expr< $e1$ && $e2$ >> -> <:expr< $expr e1$ && $expr e2$ >>
+ | <:expr< $e1$ $e2$ >> -> left_eval_apply loc expr e1 e2
+ | <:expr< ($list:el$) >> -> left_eval_tuple loc expr el
+ | <:expr< { $list:lel$ } >> -> left_eval_record loc expr lel
+ | <:expr< $e1$ := $e2$ >> -> left_eval_assign loc expr e1 e2
+ | <:expr< $_$ . $_$ >> | <:expr< $uid:_$ >> | <:expr< $lid:_$ >> |
+ <:expr< $str:_$ >> | <:expr< $chr:_$ >> | <:expr< $int:_$ >> |
+ <:expr< $flo:_$ >> | <:expr< new $list:_$ >> ->
+ x
+ | x -> not_impl "expr" x ]
+and let_binding (p, e) = (p, expr e)
+and match_assoc (p, eo, e) = (p, map_option expr eo, expr e)
+and module_expr x =
+ let loc = MLast.loc_of_module_expr x in
+ match x with
+ [ <:module_expr< functor ($s$ : $mt$) -> $me$ >> ->
+ <:module_expr< functor ($s$ : $mt$) -> $module_expr me$ >>
+ | <:module_expr< ($me$ : $mt$) >> ->
+ <:module_expr< ($module_expr me$ : $mt$) >>
+ | <:module_expr< struct $list:sil$ end >> ->
+ <:module_expr< struct $list:List.map str_item sil$ end >>
+ | <:module_expr< $_$ . $_$ >> | <:module_expr< $_$ $_$ >> |
+ <:module_expr< $uid:_$ >> ->
+ x ]
+and str_item x =
+ let loc = MLast.loc_of_str_item x in
+ match x with
+ [ <:str_item< module $s$ = $me$ >> ->
+ <:str_item< module $s$ = $module_expr me$ >>
+ | <:str_item< value $opt:rf$ $list:pel$ >> ->
+ <:str_item< value $opt:rf$ $list:List.map let_binding pel$ >>
+ | <:str_item< declare $list:sil$ end >> ->
+ <:str_item< declare $list:List.map str_item sil$ end >>
+ | <:str_item< class $list:ce$ >> ->
+ <:str_item< class $list:List.map (class_infos class_expr) ce$ >>
+ | <:str_item< $exp:e$ >> -> <:str_item< $exp:expr e$ >>
+ | <:str_item< open $_$ >> | <:str_item< type $list:_$ >> |
+ <:str_item< exception $_$ of $list:_$ = $_$ >> |
+ <:str_item< module type $_$ = $_$ >> | <:str_item< # $_$ $opt:_$ >> ->
+ x
+ | x -> not_impl "str_item" x ]
+and class_expr x =
+ let loc = MLast.loc_of_class_expr x in
+ match x with
+ [ <:class_expr< object $opt:p$ $list:csil$ end >> ->
+ <:class_expr< object $opt:p$ $list:List.map class_str_item csil$ end >>
+ | x -> not_impl "class_expr" x ]
+and class_str_item x =
+ let loc = MLast.loc_of_class_str_item x in
+ match x with
+ [ <:class_str_item< value $opt:mf$ $s$ = $e$ >> ->
+ <:class_str_item< value $opt:mf$ $s$ = $expr e$ >>
+ | <:class_str_item< method $s$ = $e$ >> ->
+ <:class_str_item< method $s$ = $expr e$ >>
+ | x -> not_impl "class_str_item" x ]
+;
+
+value parse_implem = Pcaml.parse_implem.val;
+value parse_implem_with_left_eval strm =
+ let (r, b) = parse_implem strm in
+ (List.map (fun (si, loc) -> (str_item si, loc)) r, b)
+;
+Pcaml.parse_implem.val := parse_implem_with_left_eval;
--- /dev/null
+*.cm[oiax]
+*.cmxa
+*.lib
--- /dev/null
+debug.cmo: debug.cmi
+debug.cmx: debug.cmi
+extfun.cmo: extfun.cmi
+extfun.cmx: extfun.cmi
+fstream.cmo: fstream.cmi
+fstream.cmx: fstream.cmi
+grammar.cmo: token.cmi plexer.cmi loc.cmi
+grammar.cmx: token.cmx plexer.cmi loc.cmx
+loc.cmo: loc.cmi
+loc.cmx: loc.cmi
+token.cmo: loc.cmi token.cmi
+token.cmx: loc.cmx token.cmi
+plexer.cmi: token.cmi loc.cmi
+token.cmi: loc.cmi
--- /dev/null
+
+
+include ../config/Makefile.cnf
+
+INCLUDES=-I $(OTOP)/parsing -I $(OTOP)/utils
+LIBRARIES=gramlib.cma
+OBJS=$(OTOP)/utils/misc.cmo $(OTOP)/parsing/linenum.cmo \
+ $(OTOP)/utils/warnings.cmo $(OTOP)/parsing/location.cmo \
+ $(OTOP)/utils/config.cmo debug.cmo loc.cmo \
+ token.cmo lexer_token.cmo lexer_error.cmo \
+ plexer.cmo grammar.cmo extfun.cmo \
+ fstream.cmo
+CLEANFILES=plexer.ml
+
+include ../config/Makefile.base
+
+debug.cmo: debug.cmi
+debug.cmo: debug.ml
+ $(OCAMLC) -pp '$(CAMLP4BOOT)' -rectypes $(OCAMLCFLAGS) $< -c -o $@
+
+plexer.cmo: plexer.ml plexer.cmi
+ $(OCAMLC) $(OCAMLCFLAGS) $< -c -o $@
+
+plexer.cmx: plexer.ml plexer.cmi
+ $(OCAMLOPT) $(OCAMLCFLAGS) $< -c -o $@
+
+$(LIBRARIES): $(OBJS)
+ $(OCAMLC) -linkall $(OBJS) -a -o $(LIBRARIES)
+
+$(LIBRARIESX): $(OBJSX)
+ $(OCAMLOPT) -linkall $(OBJSX) -a -o $(LIBRARIESX)
+
+$(LIBRARIESP): $(OBJSP)
+ $(OCAMLOPT) -linkall $(OBJSP) -a -o $(LIBRARIESP)
+
+install-local:
+ -$(MKDIR) "$(LIBDIR)/camlp4"
+ cp $(LIBRARIES) *.mli "$(LIBDIR)/camlp4/."
+ cp *.cmi "$(LIBDIR)/camlp4/."
+ test -f $(LIBRARIESX) && $(MAKE) installopt LIBDIR="$(LIBDIR)" || true
+
+installopt:
+ for f in $(LIBRARIESX) $(LIBRARIESP) *.cmx ; do \
+ test -f $$f && cp $$f "$(LIBDIR)/camlp4/." || true ; \
+ done
+ # Special treatment for this one: some versions of make don't like $(A) in $(TARGET:.cma=.$(A))
+ target="`echo $(LIBRARIES) | sed -e 's/\.cma$$/.$(A)/'`" ; \
+ if test -f $$target ; then \
+ cp $$target "$(LIBDIR)/camlp4/." && ( cd "$(LIBDIR)/camlp4/." && $(RANLIB) $$target ) \
+ fi
+
+include .depend
--- /dev/null
+(* camlp4r *)
+
+(* Copyright 2001 INRIA *)
+
+(* Extensible Functions *)
+
+type t 'a 'b = list (matching 'a 'b)
+and matching 'a 'b = { patt : patt; has_when : bool; expr : expr 'a 'b }
+and patt =
+ [ Eapp of list patt
+ | Eacc of list patt
+ | Econ of string
+ | Estr of string
+ | Eint of string
+ | Etup of list patt
+ | Evar of unit ]
+and expr 'a 'b = 'a -> option 'b
+;
+
+exception Failure;
+
+value empty = [];
+
+(*** Apply ***)
+
+value rec apply_matchings a =
+ fun
+ [ [m :: ml] ->
+ match m.expr a with
+ [ None -> apply_matchings a ml
+ | x -> x ]
+ | [] -> None ]
+;
+
+value apply ef a =
+ match apply_matchings a ef with
+ [ Some x -> x
+ | None -> raise Failure ]
+;
+
+(*** Trace ***)
+
+value rec list_iter_sep f s =
+ fun
+ [ [] -> ()
+ | [x] -> f x
+ | [x :: l] -> do { f x; s (); list_iter_sep f s l } ]
+;
+
+value rec print_patt =
+ fun
+ [ Eapp pl -> list_iter_sep print_patt2 (fun () -> print_string " ") pl
+ | p -> print_patt2 p ]
+and print_patt2 =
+ fun
+ [ Eacc pl -> list_iter_sep print_patt1 (fun () -> print_string ".") pl
+ | p -> print_patt1 p ]
+and print_patt1 =
+ fun
+ [ Econ s -> print_string s
+ | Estr s -> do { print_string "\""; print_string s; print_string "\"" }
+ | Eint s -> print_string s
+ | Evar () -> print_string "_"
+ | Etup pl ->
+ do {
+ print_string "(";
+ list_iter_sep print_patt (fun () -> print_string ", ") pl;
+ print_string ")"
+ }
+ | Eapp _ | Eacc _ as p ->
+ do { print_string "("; print_patt p; print_string ")" } ]
+;
+
+value print ef =
+ List.iter
+ (fun m ->
+ do {
+ print_patt m.patt;
+ if m.has_when then print_string " when ..." else ();
+ print_newline ()
+ })
+ ef
+;
+
+(*** Extension ***)
+
+value insert_matching matchings (patt, has_when, expr) =
+ let m1 = {patt = patt; has_when = has_when; expr = expr} in
+ let rec loop =
+ fun
+ [ [m :: ml] as gml ->
+ if m1.has_when && not m.has_when then [m1 :: gml] else
+ if not m1.has_when && m.has_when then [m :: loop ml] else
+ (* either both or none have a when clause *)
+ if compare m1.patt m.patt = 0 then
+ if not m1.has_when then [m1 :: ml] else [m1 :: gml]
+ else [m :: loop ml]
+ | [] -> [m1] ]
+ in
+ loop matchings
+;
+
+(* available extension function *)
+
+value extend ef matchings_def =
+ List.fold_left insert_matching ef matchings_def
+;
--- /dev/null
+(* camlp4r *)
+
+
+(** Extensible functions.
+
+ This module implements pattern matching extensible functions.
+ To extend, use syntax [pa_extfun.cmo]:
+
+ [extfun e with [ pattern_matching ]] *)
+
+type t 'a 'b = 'x;
+ (** The type of the extensible functions of type ['a -> 'b] *)
+value empty : t 'a 'b;
+ (** Empty extensible function *)
+value apply : t 'a 'b -> 'a -> 'b;
+ (** Apply an extensible function *)
+exception Failure;
+ (** Match failure while applying an extensible function *)
+value print : t 'a 'b -> unit;
+ (** Print patterns in the order they are recorded *)
+
+(**/**)
+
+type patt =
+ [ Eapp of list patt
+ | Eacc of list patt
+ | Econ of string
+ | Estr of string
+ | Eint of string
+ | Etup of list patt
+ | Evar of unit ]
+and expr 'a 'b = 'a -> option 'b
+;
+
+value extend : t 'a 'b -> list (patt * bool * expr 'a 'b) -> t 'a 'b;
--- /dev/null
+(* camlp4r *)
+
+(* Copyright 2001 INRIA *)
+
+type t 'a = { count : int; data : Lazy.t (data 'a) }
+and data 'a =
+ [ Nil
+ | Cons of 'a and t 'a
+ | App of t 'a and t 'a ]
+;
+
+value from f =
+ loop 0 where rec loop i =
+ {count = 0;
+ data =
+ lazy
+ (match f i with
+ [ Some x -> Cons x (loop (i + 1))
+ | None -> Nil ])}
+;
+
+value rec next s =
+ let count = s.count + 1 in
+ match Lazy.force s.data with
+ [ Nil -> None
+ | Cons a s -> Some (a, {count = count; data = s.data})
+ | App s1 s2 ->
+ match next s1 with
+ [ Some (a, s1) -> Some (a, {count = count; data = lazy (App s1 s2)})
+ | None ->
+ match next s2 with
+ [ Some (a, s2) -> Some (a, {count = count; data = s2.data})
+ | None -> None ] ] ]
+;
+
+value empty s =
+ match next s with
+ [ Some _ -> None
+ | None -> Some ((), s) ]
+;
+
+value nil = {count = 0; data = lazy Nil};
+value cons a s = Cons a s;
+value app s1 s2 = App s1 s2;
+value flazy f = {count = 0; data = Lazy.lazy_from_fun f};
+
+value of_list l =
+ List.fold_right (fun x s -> flazy (fun () -> cons x s)) l nil
+;
+
+value of_string s =
+ from (fun c -> if c < String.length s then Some s.[c] else None)
+;
+
+value of_channel ic =
+ from (fun _ -> try Some (input_char ic) with [ End_of_file -> None ])
+;
+
+value iter f =
+ do_rec where rec do_rec strm =
+ match next strm with
+ [ Some (a, strm) ->
+ let _ = f a in
+ do_rec strm
+ | None -> () ]
+;
+
+value count s = s.count;
+
+value count_unfrozen s =
+ loop 0 s where rec loop cnt s =
+ if Lazy.lazy_is_val s.data then
+ match Lazy.force s.data with
+ [ Cons _ s -> loop (cnt + 1) s
+ | _ -> cnt ]
+ else cnt
+;
--- /dev/null
+(* camlp4r *)
+
+
+(* Module [Fstream]: functional streams *)
+
+(* This module implement functional streams.
+ To be used with syntax [pa_fstream.cmo]. The syntax is:
+- stream: [fstream [: ... :]]
+- parser: [parser [ [: ... :] -> ... | ... ]]
+
+ Functional parsers are of type: [Fstream.t 'a -> option ('a * Fstream.t 'a)]
+
+ They have limited backtrack, i.e if a rule fails, the next rule is tested
+ with the initial stream; limited because when in case of a rule with two
+ consecutive symbols [a] and [b], if [b] fails, the rule fails: there is
+ no try with the next rule of [a].
+*)
+
+type t 'a = 'x;
+ (* The type of 'a functional streams *)
+value from : (int -> option 'a) -> t 'a;
+ (* [Fstream.from f] returns a stream built from the function [f].
+ To create a new stream element, the function [f] is called with
+ the current stream count. The user function [f] must return either
+ [Some <value>] for a value or [None] to specify the end of the
+ stream. *)
+
+value of_list : list 'a -> t 'a;
+ (* Return the stream holding the elements of the list in the same
+ order. *)
+value of_string : string -> t char;
+ (* Return the stream of the characters of the string parameter. *)
+value of_channel : in_channel -> t char;
+ (* Return the stream of the characters read from the input channel. *)
+
+value iter : ('a -> unit) -> t 'a -> unit;
+ (* [Fstream.iter f s] scans the whole stream s, applying function [f]
+ in turn to each stream element encountered. *)
+
+value next : t 'a -> option ('a * t 'a);
+ (* Return [Some (a, s)] where [a] is the first element of the stream
+ and [s] the remaining stream, or [None] if the stream is empty. *)
+value empty : t 'a -> option (unit * t 'a);
+ (* Return [Some ((), s)] if the stream is empty where [s] is itself,
+ else [None] *)
+value count : t 'a -> int;
+ (* Return the current count of the stream elements, i.e. the number
+ of the stream elements discarded. *)
+value count_unfrozen : t 'a -> int;
+ (* Return the number of unfrozen elements in the beginning of the
+ stream; useful to determine the position of a parsing error (longuest
+ path). *)
+
+(*--*)
+
+value nil : t 'a;
+type data 'a = 'x;
+value cons : 'a -> t 'a -> data 'a;
+value app : t 'a -> t 'a -> data 'a;
+value flazy : (unit -> data 'a) -> t 'a;
--- /dev/null
+#########################################################################
+# #
+# Objective Caml #
+# #
+# Camlp4 #
+# #
+# Copyright 2004 Institut National de Recherche en Informatique et #
+# en Automatique. All rights reserved. This file is distributed #
+# under the terms of the Q Public License version 1.0. #
+# #
+#########################################################################
+#
+# Makefile for pa_ocamllex
+# M.Mauny
+#
+
+include ../../config/Makefile.cnf
+
+OCAMLTOP=../../..
+
+CAMLP4=../../camlp4/camlp4$(EXE)
+
+OCAMLC=$(OCAMLTOP)/ocamlc$(EXE)
+OCAMLOPT=$(OCAMLTOP)/ocamlopt$(EXE)
+
+P4INCLUDES= -nolib -I ../../etc -I ../../meta
+OCAMLINCLUDES= -nostdlib -I $(OCAMLTOP)/stdlib -I ../../camlp4 -I ../../lib -I $(OCAMLTOP)/lex
+OCAMLCFLAGS=-warn-error A $(OCAMLINCLUDES)
+
+SRC=pa_ocamllex.ml
+OBJS=pa_ocamllex.cmo
+OBJSX=$(OBJS:.cmo=.cmx)
+
+all: $(OBJS) pa_ocamllex.cma
+
+opt: $(OBJSX) pa_ocamllex.cmxa
+
+pa_ocamllex.cma: pa_ocamllex.cmo
+ $(OCAMLC) $(OCAMLCFLAGS) cset.cmo syntax.cmo table.cmo lexgen.cmo compact.cmo pa_ocamllex.cmo -a -o pa_ocamllex.cma
+
+pa_ocamllex.cmxa: pa_ocamllex.cmo
+ $(OCAMLOPT) $(OCAMLCFLAGS) cset.cmx syntax.cmx table.cmx lexgen.cmx compact.cmx pa_ocamllex.cmx -a -o pa_ocamllex.cmxa
+
+clean:
+ rm -f *.cm* *.$(O) *.$(A) *.bak .*.bak
+
+depend:
+
+.SUFFIXES: .cmx .cmo .cmi .ml .mli
+
+.mli.cmi:
+ $(OCAMLC) $(OCAMLCFLAGS) -c $<
+
+
+.ml.cmo:
+ $(OCAMLC) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $<
+
+.ml.cmx:
+ $(OCAMLOPT) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $<
--- /dev/null
+This is an application of or an extension for Camlp4. Although it is
+currently distributed with OCaml/Camlp4, it may or may not be
+actively maintained.
+
+It probably won't be part of future OCaml/Camlp4 distributions but be
+accessible from the Camlp4 hump. If you are interested in developing
+this package further and/or actively maintain it, please let us know
+(caml@inria.fr)
+
+This package is distributed under the same license as the Objective
+Caml Library (that is, LGPL with a special exception allowing both
+static and dynamic link).
+
+-- Michel Mauny
+
--- /dev/null
+(* pa_o.cmo q_MLast.cmo pa_extend.cmo pr_dump.cmo *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Alain Frisch, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 2002 Institut National de Recherche en Informatique et *)
+(* en Automatique. All rights reserved. This file is distributed *)
+(* under the terms of the GNU Library General Public License, with *)
+(* the special exception on linking described in file *)
+(* ../../../LICENSE. *)
+(* *)
+(***********************************************************************)
+
+
+open Syntax
+open Lexgen
+open Compact
+
+(* Adapted from output.ml *)
+(**************************)
+
+(* Output the DFA tables and its entry points *)
+
+(* To output an array of short ints, encoded as a string *)
+
+let output_byte buf b =
+ Buffer.add_char buf '\\';
+ Buffer.add_char buf (Char.chr(48 + b / 100));
+ Buffer.add_char buf (Char.chr(48 + (b / 10) mod 10));
+ Buffer.add_char buf (Char.chr(48 + b mod 10))
+
+let loc = (Lexing.dummy_pos,Lexing.dummy_pos)
+
+let output_array v =
+ let b = Buffer.create (Array.length v * 3) in
+ for i = 0 to Array.length v - 1 do
+ output_byte b (v.(i) land 0xFF);
+ output_byte b ((v.(i) asr 8) land 0xFF);
+ if i land 7 = 7 then Buffer.add_string b "\\\n "
+ done;
+ let s = Buffer.contents b in
+ <:expr< $str:s$ >>
+
+let output_byte_array v =
+ let b = Buffer.create (Array.length v * 2) in
+ for i = 0 to Array.length v - 1 do
+ output_byte b (v.(i) land 0xFF);
+ if i land 15 = 15 then Buffer.add_string b "\\\n "
+ done;
+ let s = Buffer.contents b in
+ <:expr< $str:s$ >>
+
+
+
+(* Output the tables *)
+
+let output_tables tbl =
+ <:str_item< value lex_tables = {
+ Lexing.lex_base = $output_array tbl.tbl_base$;
+ Lexing.lex_backtrk = $output_array tbl.tbl_backtrk$;
+ Lexing.lex_default = $output_array tbl.tbl_default$;
+ Lexing.lex_trans = $output_array tbl.tbl_trans$;
+ Lexing.lex_check = $output_array tbl.tbl_check$;
+ Lexing.lex_base_code = $output_array tbl.tbl_base_code$;
+ Lexing.lex_backtrk_code = $output_array tbl.tbl_backtrk_code$;
+ Lexing.lex_default_code = $output_array tbl.tbl_default_code$;
+ Lexing.lex_trans_code = $output_array tbl.tbl_trans_code$;
+ Lexing.lex_check_code = $output_array tbl.tbl_check_code$;
+ Lexing.lex_code = $output_byte_array tbl.tbl_code$
+ } >>
+
+(* Output the entries *)
+
+let rec make_alias n = function
+ | [] -> []
+ | h::t ->
+ (h, "__ocaml_lex_arg_" ^ (string_of_int n)) :: (make_alias (succ n) t)
+
+let abstraction =
+ List.fold_right (fun (p,a) e -> <:expr< fun ($p$ as $lid:a$) -> $e$ >>)
+
+
+let application =
+ List.fold_left (fun f (_,a) -> <:expr< $f$ $lid:a$ >>)
+
+let int i = <:expr< $int:string_of_int i$ >>
+
+let output_memory_actions acts =
+ let aux = function
+ | Copy (tgt, src) ->
+ <:expr< lexbuf.Lexing.lex_mem.($int tgt$) :=
+ lexbuf.Lexing.lex_mem.($int src$) >>
+ | Set tgt ->
+ <:expr< lexbuf.Lexing.lex_mem.($int tgt$) :=
+ lexbuf.Lexing.lex_curr_pos >>
+ in
+ <:expr< do { $list:List.map aux acts$ } >>
+
+let output_base_mem = function
+ | Mem i -> <:expr< lexbuf.Lexing.lex_mem.($int i$) >>
+ | Start -> <:expr< lexbuf.Lexing.lex_start_pos >>
+ | End -> <:expr< lexbuf.Lexing.lex_curr_pos >>
+
+let output_tag_access = function
+ | Sum (a,0) -> output_base_mem a
+ | Sum (a,i) -> <:expr< $output_base_mem a$ + $int i$ >>
+
+let rec output_env e = function
+ | [] -> e
+ | (x, Ident_string (o,nstart,nend)) :: rem ->
+ <:expr<
+ let $lid:x$ =
+ Lexing.$lid:if o then "sub_lexeme_opt" else "sub_lexeme"$
+ lexbuf $output_tag_access nstart$ $output_tag_access nend$
+ in $output_env e rem$
+ >>
+ | (x, Ident_char (o,nstart)) :: rem ->
+ <:expr<
+ let $lid:x$ =
+ Lexing.$lid: if o then "sub_lexeme_char_opt" else "sub_lexeme_char"$
+ lexbuf $output_tag_access nstart$
+ in $output_env e rem$
+ >>
+
+let output_entry e =
+ let init_num, init_moves = e.auto_initial_state in
+ let args = make_alias 0 (e.auto_args @ [ <:patt< lexbuf >> ]) in
+ let f = "__ocaml_lex_rec_" ^ e.auto_name ^ "_rec" in
+ let call_f = application <:expr< $lid:f$ >> args in
+ let body_wrapper =
+ <:expr<
+ do {
+ lexbuf.Lexing.lex_mem := Array.create $int e.auto_mem_size$ (-1) ;
+ $output_memory_actions init_moves$;
+ $call_f$ $int init_num$
+ } >> in
+ let cases =
+ List.map
+ (fun (num, env, (loc,e)) ->
+ <:patt< $int:string_of_int num$ >>,
+ None,
+ output_env <:expr< $e$ >> env
+ (* Note: the <:expr<...>> above is there to set the location *)
+ ) e.auto_actions @
+ [ <:patt< __ocaml_lex_n >>,
+ None,
+ <:expr< do
+ { lexbuf.Lexing.refill_buff lexbuf; $call_f$ __ocaml_lex_n }>> ]
+ in
+ let engine =
+ if e.auto_mem_size = 0
+ then <:expr< Lexing.engine >>
+ else <:expr< Lexing.new_engine >> in
+ let body =
+ <:expr< fun state ->
+ match $engine$ lex_tables state lexbuf with [ $list:cases$ ] >> in
+ [
+ <:patt< $lid:e.auto_name$ >>, (abstraction args body_wrapper);
+ <:patt< $lid:f$ >>, (abstraction args body)
+ ]
+
+(* Main output function *)
+
+exception Table_overflow
+
+let output_lexdef tables entry_points =
+ Printf.eprintf
+ "pa_ocamllex: lexer found; %d states, %d transitions, table size %d bytes\n"
+ (Array.length tables.tbl_base)
+ (Array.length tables.tbl_trans)
+ (2 * (Array.length tables.tbl_base + Array.length tables.tbl_backtrk +
+ Array.length tables.tbl_default + Array.length tables.tbl_trans +
+ Array.length tables.tbl_check));
+ let size_groups =
+ (2 * (Array.length tables.tbl_base_code +
+ Array.length tables.tbl_backtrk_code +
+ Array.length tables.tbl_default_code +
+ Array.length tables.tbl_trans_code +
+ Array.length tables.tbl_check_code) +
+ Array.length tables.tbl_code) in
+ if size_groups > 0 then
+ Printf.eprintf "pa_ocamllex: %d additional bytes used for bindings\n"
+ size_groups ;
+ flush stderr;
+ if Array.length tables.tbl_trans > 0x8000 then raise Table_overflow;
+
+ let entries = List.map output_entry entry_points in
+ [output_tables tables; <:str_item< value rec $list:List.flatten entries$ >> ]
+
+
+(* Adapted from parser.mly and main.ml *)
+(***************************************)
+
+(* Auxiliaries for the parser. *)
+
+let char s = Char.code (Token.eval_char s)
+
+let named_regexps =
+ (Hashtbl.create 13 : (string, regular_expression) Hashtbl.t)
+
+let regexp_for_string s =
+ let rec re_string n =
+ if n >= String.length s then Epsilon
+ else if succ n = String.length s then
+ Characters (Cset.singleton (Char.code s.[n]))
+ else
+ Sequence
+ (Characters(Cset.singleton (Char.code s.[n])),
+ re_string (succ n))
+ in re_string 0
+
+let char_class c1 c2 = Cset.interval c1 c2
+
+let all_chars = Cset.all_chars
+
+let rec remove_as = function
+ | Bind (e,_) -> remove_as e
+ | Epsilon|Eof|Characters _ as e -> e
+ | Sequence (e1, e2) -> Sequence (remove_as e1, remove_as e2)
+ | Alternative (e1, e2) -> Alternative (remove_as e1, remove_as e2)
+ | Repetition e -> Repetition (remove_as e)
+
+let () =
+ Hashtbl.add named_regexps "eof" (Characters Cset.eof)
+
+(* The parser *)
+
+let let_regexp = Grammar.Entry.create Pcaml.gram "pa_ocamllex let"
+let header = Grammar.Entry.create Pcaml.gram "pa_ocamllex header"
+let lexer_def = Grammar.Entry.create Pcaml.gram "pa_ocaml lexerdef"
+
+EXTEND
+ GLOBAL: Pcaml.str_item let_regexp header lexer_def;
+
+ let_regexp: [
+ [ x = LIDENT; "="; r = regexp ->
+ if Hashtbl.mem named_regexps x then
+ Printf.eprintf
+ "pa_ocamllex (warning): multiple definition of named regexp '%s'\n"
+ x;
+ Hashtbl.add named_regexps x r;
+ ]
+ ];
+
+ lexer_def: [
+ [ def = LIST0 definition SEP "and" ->
+ (try
+ let (entries, transitions) = make_dfa def in
+ let tables = compact_tables transitions in
+ let output = output_lexdef tables entries in
+ <:str_item< declare $list: output$ end >>
+ with
+ |Table_overflow ->
+ failwith "Transition table overflow in lexer, automaton is too big"
+ | Lexgen.Memory_overflow ->
+ failwith "Position memory overflow in lexer, too many as variables")
+ ]
+ ];
+
+
+ Pcaml.str_item: [
+ [ "pa_ocamllex"; LIDENT "rule"; d = lexer_def -> d
+ | "pa_ocamllex"; "let"; let_regexp ->
+ <:str_item< declare $list: []$ end >>
+ ]
+ ];
+
+ definition: [
+ [ x=LIDENT; pl = LIST0 Pcaml.patt LEVEL "simple"; "=";
+ short=[ LIDENT "parse" -> false | LIDENT "shortest" -> true ];
+ OPT "|"; l = LIST0 [ r=regexp; a=action -> (r,a) ] SEP "|" ->
+ { name=x ; shortest=short ; args=pl ; clauses = l } ]
+ ];
+
+ action: [
+ [ "{"; e = OPT Pcaml.expr; "}" ->
+ let e = match e with
+ | Some e -> e
+ | None -> <:expr< () >>
+ in
+ (loc,e)
+ ]
+ ];
+
+ header: [
+ [ "{"; e = LIST0 [ si = Pcaml.str_item; OPT ";;" -> si ]; "}" ->
+ [<:str_item< declare $list:e$ end>>, loc] ]
+ | [ -> [] ]
+ ];
+
+ regexp: [
+ [ r = regexp; "as"; i = LIDENT -> Bind (r,i) ]
+ | [ r1 = regexp; "|"; r2 = regexp -> Alternative(r1,r2) ]
+ | [ r1 = regexp; r2 = regexp -> Sequence(r1,r2) ]
+ | [ r = regexp; "*" -> Repetition r
+ | r = regexp; "+" -> Sequence(Repetition (remove_as r), r)
+ | r = regexp; "?" -> Alternative(Epsilon, r)
+ | "("; r = regexp; ")" -> r
+ | "_" -> Characters all_chars
+ | c = CHAR -> Characters (Cset.singleton (char c))
+ | s = STRING -> regexp_for_string (Token.eval_string loc s)
+ | "["; cc = ch_class; "]" -> Characters cc
+ | x = LIDENT ->
+ try Hashtbl.find named_regexps x
+ with Not_found ->
+ failwith
+ ("pa_ocamllex (error): reference to unbound regexp name `"^x^"'")
+ ]
+ ];
+
+ ch_class: [
+ [ "^"; cc = ch_class -> Cset.complement cc]
+ | [ c1 = CHAR; "-"; c2 = CHAR -> Cset.interval (char c1) (char c2)
+ | c = CHAR -> Cset.singleton (char c)
+ | cc1 = ch_class; cc2 = ch_class -> Cset.union cc1 cc2
+ ]
+ ];
+END
+
+(* We have to be careful about "rule"; in standalone mode,
+ it is used as a keyword (otherwise, there is a conflict
+ with named regexp); in normal mode, it is used as LIDENT
+ (we do not want to reserve such an useful identifier).
+
+ Plexer does not like identifiers used as keyword _and_
+ as LIDENT ...
+*)
+
+let standalone =
+ let already = ref false in
+ fun () ->
+ if not (!already) then
+ begin
+ already := true;
+ Printf.eprintf "pa_ocamllex: stand-alone mode\n";
+
+ DELETE_RULE Pcaml.str_item: "pa_ocamllex"; LIDENT "rule";lexer_def END;
+ DELETE_RULE Pcaml.str_item: "pa_ocamllex"; "let"; let_regexp END;
+ let ocamllex = Grammar.Entry.create Pcaml.gram "pa_ocamllex" in
+ EXTEND GLOBAL: ocamllex let_regexp header lexer_def;
+ ocamllex: [
+ [ h = header;
+ l = [LIST0 ["let"; let_regexp]; "rule"; d = lexer_def -> (d,loc)];
+ t = header; EOI -> h @ (l :: t) ,false
+ ]
+ ];
+ END;
+ Pcaml.parse_implem := Grammar.Entry.parse ocamllex
+ end
+
+let () =
+ Pcaml.add_option "-ocamllex" (Arg.Unit standalone)
+ "Activate (standalone) ocamllex emulation mode."
+
--- /dev/null
+*.cm[oia]
+ocpp
+crc.ml
--- /dev/null
+
+
+include ../config/Makefile.cnf
+
+EXECUTABLES=ocpp
+OBJS=ocpp.cmo
+INCLUDES=-I ../camlp4 -I ../lib -I ../odyl -I $(OTOP)/otherlibs/dynlink
+OCPPM=../lib/debug.cmo ../lib/loc.cmo ../lib/stdpp.cmo ../camlp4/quotation.cmo
+
+include ../config/Makefile.base
+
+ocpp$(EXE): $(OBJS)
+ $(OCAMLC) $(LINKFLAGS) $(OCPPM) ../odyl/odyl.cma $(OBJS) ../odyl/odyl.cmo -linkall -o $@
+
+ocpp.opt: $(OBJSX)
+ $(OCAMLOPT) $(LINKFLAGS) $(OCPPM:.cmo=.cmx) ../odyl/odyl.cmxa $(OBJSX) ../odyl/odyl.cmx -linkall -o $@
+
+install-local:
+ -$(MKDIR) "$(LIBDIR)/camlp4" "$(BINDIR)"
+ cp $(OBJS) "$(LIBDIR)/camlp4/."
+ cp ocpp$(EXE) "$(BINDIR)/."
+ if test -f ocpp.opt ; then \
+ cp ocpp.opt "$(LIBDIR)/camlp4/." ; \
+ fi
--- /dev/null
+(* camlp4r *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 2002 Institut National de Recherche en Informatique et *)
+(* Automatique. Distributed only by permission. *)
+(* *)
+(***********************************************************************)
+
+
+
+
+value buff = ref (String.create 80);
+value store len x =
+ do {
+ if len >= String.length buff.val then
+ buff.val := buff.val ^ String.create (String.length buff.val)
+ else ();
+ buff.val.[len] := x;
+ succ len
+ }
+;
+value get_buff len = String.sub buff.val 0 len;
+
+value rec copy_strip_locate cs =
+ match cs with parser
+ [ [: `'$' :] -> maybe_locate cs
+ | [: `c :] -> do { print_char c; copy_strip_locate cs }
+ | [: :] -> () ]
+and maybe_locate cs =
+ match cs with parser
+ [ [: `'1'..'9' :] -> locate cs
+ | [: :] -> do { print_char '$'; copy_strip_locate cs } ]
+and locate cs =
+ match cs with parser
+ [ [: `'0'..'9' :] -> locate cs
+ | [: `':' :] -> inside_locate cs
+ | [: :] -> raise (Stream.Error "colon char expected") ]
+and inside_locate cs =
+ match cs with parser
+ [ [: `'$' :] -> copy_strip_locate cs
+ | [: `'\\'; `c :] -> do { print_char c; inside_locate cs }
+ | [: `c :] -> do { print_char c; inside_locate cs }
+ | [: :] -> raise (Stream.Error "end of file in locate directive") ]
+;
+
+value file = ref "";
+
+value quot name loc str =
+ let loc = Loc.move `stop (String.length str) loc in
+ let exp =
+ try
+ match Quotation.find name with
+ [ Quotation.ExStr f -> f
+ | _ -> raise Not_found ]
+ with
+ [ Not_found -> Stdpp.raise_with_loc loc Not_found ]
+ in
+ let new_str =
+ try exp True { Quotation.loc = Loc.mk file.val ; loc_name_opt = None } str with
+ [ Loc.Exc_located loc exc -> Stdpp.raise_with_loc loc exc
+ | exc -> Stdpp.raise_with_loc loc exc ]
+ in
+ let cs = Stream.of_string new_str in copy_strip_locate cs
+;
+
+value rec ident len =
+ parser
+ [ [: `('A'..'Z' | 'a'..'z' | '0'..'9' | '_' | ''' as c); s :] ->
+ ident (store len c) s
+ | [: :] -> get_buff len ]
+;
+
+value loc_of_ep ep =
+ Loc.set_all `start 1 0 ep (Loc.mk file.val);
+
+value rec copy cs =
+ match cs with parser
+ [ [: `'<' :] -> maybe_quot cs
+ | [: `'"' :] -> do { print_char '"'; inside_string cs }
+ | [: `c :] -> do { print_char c; copy cs }
+ | [: :] -> () ]
+and maybe_quot cs =
+ match cs with parser
+ [ [: `'<' :] ep -> inside_quot "" (loc_of_ep ep) 0 cs
+ | [: `':'; i = ident 0; `'<' ?? "less char expected" :] ep ->
+ inside_quot i (loc_of_ep ep) 0 cs
+ | [: :] -> do { print_char '<'; copy cs } ]
+and inside_quot name loc len cs =
+ match cs with parser
+ [ [: `'>' :] -> maybe_end_quot name loc len cs
+ | [: `c :] -> inside_quot name loc (store len c) cs
+ | [: :] -> raise (Stream.Error "end of file in quotation") ]
+and maybe_end_quot name loc len cs =
+ match cs with parser
+ [ [: `'>' :] -> do { quot name loc (get_buff len); copy cs }
+ | [: :] -> inside_quot name loc (store len '>') cs ]
+and inside_string cs =
+ match cs with parser
+ [ [: `'"' :] -> do { print_char '"'; copy cs }
+ | [: `c :] -> do { print_char c; inside_string cs }
+ | [: :] -> raise (Stream.Error "end of file in string") ]
+;
+
+value copy_quot cs = do { copy cs; flush stdout; };
+
+Arg.parse [] (fun x -> file.val := x) "ocpp <objects> <file>";
+
+value main () =
+ try
+ if file.val <> "" then
+ copy_quot (Stream.of_channel (open_in_bin file.val))
+ else ()
+ with exc ->
+ do {
+ Format.printf "@.";
+ raise
+ (match exc with
+ [ Loc.Exc_located loc exc ->
+ do { Format.eprintf "%a@." Loc.print loc; exc }
+ | exc -> exc ])
+ }
+;
+
+Odyl_main.name.val := "ocpp";
+Odyl_main.go.val := main;
--- /dev/null
+*.cm[oia]
+odyl
+*.lib
+odyl_config.ml
--- /dev/null
+odyl.cmo: odyl_main.cmi odyl_config.cmo
+odyl.cmx: odyl_main.cmx odyl_config.cmx
+odyl_main.cmo: odyl_config.cmo odyl_main.cmi
+odyl_main.cmx: odyl_config.cmx odyl_main.cmi
--- /dev/null
+
+
+include ../config/Makefile.cnf
+
+EXECUTABLES=odyl
+INCLUDES=-I $(OTOP)/otherlibs/dynlink
+OBJS=odyl_config.cmo odyl_main.cmo
+OBJSX=odyl.cmx odyl.cmxa
+CLEANFILES=odyl_config.ml
+
+include ../config/Makefile.base
+
+odyl$(EXE): odyl.cma odyl.cmo
+ $(OCAMLC) odyl.cma odyl.cmo -o $@
+
+odyl.opt: odyl.cmxa odyl.cmx
+ $(OCAMLOPT) odyl.cmxa odyl.cmx -o $@
+
+odyl.cma: $(OBJS)
+ $(OCAMLC) $(LINKFLAGS) dynlink.cma $(OBJS) -a -o $@
+
+odyl.cmxa: $(OBJSX)
+ $(OCAMLOPT) $(LINKFLAGS) $(OBJSX) -a -o $@
+
+odyl.p.cmxa: $(OBJSP)
+ $(OCAMLOPT) $(LINKFLAGS) $(OBJSP) -a -o $@
+
+odyl_main.cmx: odyl_main.ml
+ $(CAMLP4BOOT) -nolib -DOPT -o odyl_main.ppo odyl_main.ml
+ $(OCAMLOPT) -c -impl odyl_main.ppo
+ rm -f odyl_main.ppo
+
+odyl_main.p.cmx: odyl_main.ml
+ $(CAMLP4BOOT) -nolib -DOPT -o odyl_main.ppo odyl_main.ml
+ $(OCAMLOPT) -p -c -o $@ -impl odyl_main.ppo
+ rm -f odyl_main.ppo
+
+odyl_config.ml:
+ (echo '(* camlp4r *)'; \
+ echo 'value standard_library ='; \
+ echo ' try Sys.getenv "CAMLP4LIB" with [ Not_found -> '; \
+ echo ' try Sys.getenv "OCAMLLIB" ^ "/camlp4" with [ Not_found -> '; \
+ echo ' try Sys.getenv "CAMLLIB" ^ "/camlp4" with [ Not_found -> '; \
+ echo ' "$(LIBDIR)/camlp4"]]];') \
+ | sed -e 's|\\|/|g' > odyl_config.ml
+
+install-local:
+ -$(MKDIR) "$(LIBDIR)/camlp4" "$(BINDIR)"
+ cp odyl.cmo odyl.cma odyl_main.cmi $(LIBDIR)/camlp4/.
+ for f in odyl.$(A) odyl.p.$(A) ; do \
+ if test -f $$f ; then \
+ cp $$f "$(LIBDIR)/camlp4/." && ( cd "$(LIBDIR)/camlp4/." && $(RANLIB) $$f ) ; \
+ fi ; \
+ done
+ for f in odyl.cmx odyl.o odyl.p.cmx odyl.p.o odyl.cmxa odyl.p.cmxa ; do \
+ if test -f $$f ; then \
+ cp $$f "$(LIBDIR)/camlp4/." ; \
+ fi ; \
+ done
+
+include .depend
--- /dev/null
+(* camlp4r *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 2001 Institut National de Recherche en Informatique et *)
+(* Automatique. Distributed only by permission. *)
+(* *)
+(***********************************************************************)
+
+
+
+value apply_load () =
+ let i = ref 1 in
+ let stop = ref False in
+ while not stop.val && i.val < Array.length Sys.argv do {
+ let s = Sys.argv.(i.val) in
+ if s = "-I" && i.val + 1 < Array.length Sys.argv then do {
+ Odyl_main.directory Sys.argv.(i.val + 1);
+ i.val := i.val + 2
+ }
+ else if s = "-nolib" then do { Odyl_main.nolib.val := True; incr i }
+ else if s = "-where" then do {
+ print_string Odyl_config.standard_library;
+ print_newline ();
+ flush stdout;
+ exit 0
+ }
+ else if s = "-version" then do {
+ print_string Sys.ocaml_version;
+ print_newline ();
+ flush stdout;
+ exit 0
+ }
+ else if s = "--" then do { incr i; stop.val := True; () }
+ else if String.length s > 0 && s.[0] == '-' then stop.val := True
+ else if Filename.check_suffix s ".cmo" || Filename.check_suffix s ".cma"
+ then do { Odyl_main.loadfile s; incr i }
+ else stop.val := True
+ }
+;
+
+value main () =
+ try do { apply_load () ; Odyl_main.go.val () } with
+ [ Odyl_main.Error fname str ->
+ do {
+ flush stdout;
+ Printf.eprintf "Error while loading \"%s\": " fname;
+ Printf.eprintf "%s.\n" str;
+ flush stderr;
+ exit 2
+ } ]
+;
+
+Printexc.catch main ();
--- /dev/null
+(* camlp4r *)
+
+
+exception Error of string and string;
+
+value nolib : ref bool;
+value initialized : ref bool;
+value path : ref (list string);
+value loadfile : string -> unit;
+value directory : string -> unit;
+
+value go : ref (unit -> unit);
+value name : ref string;
--- /dev/null
+#########################################################################
+# #
+# Objective Caml #
+# #
+# Camlp4 #
+# #
+# Copyright 2004 Institut National de Recherche en Informatique et #
+# en Automatique. All rights reserved. This file is distributed #
+# under the terms of the Q Public License version 1.0. #
+# #
+#########################################################################
+#
+# Makefile for pa_lefteval
+# M.Mauny
+#
+
+include ../../config/Makefile.cnf
+
+OCAMLTOP=../../..
+CAMLP4=../../camlp4/camlp4$(EXE)
+
+OCAMLC=$(OCAMLTOP)/ocamlc$(EXE)
+OCAMLOPT=$(OCAMLTOP)/ocamlopt$(EXE)
+
+P4INCLUDES= -nolib -I ../../meta -I ../../lib -I ../../etc
+OCAMLINCLUDES= -nostdlib -I $(OCAMLTOP)/stdlib -I ../../lib -I ../../camlp4
+OCAMLCFLAGS=-warn-error A $(OCAMLINCLUDES)
+
+SRC=pa_olabl.ml
+OBJS=$(SRC:.ml=.cmo)
+OBJSX=$(SRC:.ml=.cmx)
+
+all: $(OBJS)
+
+opt: $(OBJSX)
+
+depend:
+ cp .depend .depend.bak
+ > .depend
+ for file in $(SRC); do \
+ $(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $$file` pr_depend.cmo $$i | \
+ sed -e 's| \.\./\.\./\.\.| $$(OCAMLTOP)|g' >> .depend; \
+ done
+
+clean:
+ rm -f *.cm* *.$(O) *.bak .*.bak
+
+
+.SUFFIXES: .cmx .cmo .cmi .ml .mli
+
+.mli.cmi:
+ $(OCAMLC) $(OCAMLCFLAGS) -c $<
+
+
+.ml.cmo:
+ $(OCAMLC) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $<
+
+.ml.cmx:
+ $(OCAMLOPT) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $<
+
+include .depend
--- /dev/null
+This is an application of or an extension for Camlp4. Although it is
+currently distributed with OCaml/Camlp4, it may or may not be
+actively maintained.
+
+It probably won't be part of future OCaml/Camlp4 distributions but be
+accessible from the Camlp4 hump. If you are interested in developing
+this package further and/or actively maintain it, please let us know
+(caml@inria.fr)
+
+This package is distributed under the same license as the Objective
+Caml Library (that is, LGPL with a special exception allowing both
+static and dynamic link).
+
+-- Michel Mauny
+
--- /dev/null
+(* pa_r.cmo pa_rp.cmo pa_extend.cmo q_MLast.cmo pr_dump.cmo *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 2002 Institut National de Recherche en Informatique et *)
+(* en Automatique. All rights reserved. This file is distributed *)
+(* under the terms of the GNU Library General Public License, with *)
+(* the special exception on linking described in file *)
+(* ../../../LICENSE. *)
+(* *)
+(***********************************************************************)
+
+
+
+module Plexer =
+ struct
+ open Stdpp;
+ open Token;
+ value buff = ref (String.create 80);
+ value store len x =
+ do {
+ if len >= String.length buff.val then
+ buff.val := buff.val ^ String.create (String.length buff.val)
+ else ();
+ buff.val.[len] := x;
+ succ len
+ }
+ ;
+ value mstore len s =
+ add_rec len 0 where rec add_rec len i =
+ if i == String.length s then len
+ else add_rec (store len s.[i]) (succ i)
+ ;
+ value get_buff len = String.sub buff.val 0 len;
+ value rec ident len =
+ parser
+ [ [: `('A'..'Z' | 'a'..'z' | '\192'..'\214' | '\216'..'\246' |
+ '\248'..'\255' | '0'..'9' | '_' | ''' as
+ c)
+ ;
+ s :] ->
+ ident (store len c) s
+ | [: :] -> len ]
+ and ident2 len =
+ parser
+ [ [: `('!' | '?' | '~' | '=' | '@' | '^' | '&' | '+' | '-' | '*' | '/' |
+ '%' | '.' | ':' | '<' | '>' | '|' as
+ c)
+ ;
+ s :] ->
+ ident2 (store len c) s
+ | [: :] -> len ]
+ and ident3 len =
+ parser
+ [ [: `('0'..'9' | 'A'..'Z' | 'a'..'z' | '\192'..'\214' |
+ '\216'..'\246' | '\248'..'\255' | '_' | '!' | '%' | '&' | '*' |
+ '+' | '-' | '.' | '/' | ':' | '<' | '=' | '>' | '?' | '@' | '^' |
+ '|' | '~' | ''' | '$' as
+ c)
+ ;
+ s :] ->
+ ident3 (store len c) s
+ | [: :] -> len ]
+ and ident4 len =
+ parser
+ [ [: `('!' | '?' | '~' | '=' | '@' | '^' | '&' | '+' | '-' | '*' | '/' |
+ '%' | '.' | '<' | '>' | '|' as
+ c)
+ ;
+ s :] ->
+ ident4 (store len c) s
+ | [: :] -> len ]
+ and base_number len =
+ parser
+ [ [: `'o' | 'O'; s :] -> octal_digits (store len 'o') s
+ | [: `'x' | 'X'; s :] -> hexa_digits (store len 'x') s
+ | [: `'b' | 'B'; s :] -> binary_digits (store len 'b') s
+ | [: a = number len :] -> a ]
+ and octal_digits len =
+ parser
+ [ [: `('0'..'7' as d); s :] -> octal_digits (store len d) s
+ | [: :] -> ("INT", get_buff len) ]
+ and hexa_digits len =
+ parser
+ [ [: `('0'..'9' | 'a'..'f' | 'A'..'F' as d); s :] ->
+ hexa_digits (store len d) s
+ | [: :] -> ("INT", get_buff len) ]
+ and binary_digits len =
+ parser
+ [ [: `('0'..'1' as d); s :] -> binary_digits (store len d) s
+ | [: :] -> ("INT", get_buff len) ]
+ and number len =
+ parser
+ [ [: `('0'..'9' as c); s :] -> number (store len c) s
+ | [: `'.'; s :] -> decimal_part (store len '.') s
+ | [: `'e' | 'E'; s :] -> exponent_part (store len 'E') s
+ | [: :] -> ("INT", get_buff len) ]
+ and decimal_part len =
+ parser
+ [ [: `('0'..'9' as c); s :] -> decimal_part (store len c) s
+ | [: `'e' | 'E'; s :] -> exponent_part (store len 'E') s
+ | [: :] -> ("FLOAT", get_buff len) ]
+ and exponent_part len =
+ parser
+ [ [: `('+' | '-' as c); s :] -> end_exponent_part (store len c) s
+ | [: a = end_exponent_part len :] -> a ]
+ and end_exponent_part len =
+ parser
+ [ [: `('0'..'9' as c); s :] -> end_exponent_part (store len c) s
+ | [: :] -> ("FLOAT", get_buff len) ]
+ ;
+ value valch x = Char.code x - Char.code '0';
+ value rec backslash s i =
+ if i = String.length s then raise Not_found
+ else
+ match s.[i] with
+ [ 'n' -> ('\n', i + 1)
+ | 'r' -> ('\r', i + 1)
+ | 't' -> ('\t', i + 1)
+ | 'b' -> ('\b', i + 1)
+ | '\\' -> ('\\', i + 1)
+ | '0'..'9' as c -> backslash1 (valch c) s (i + 1)
+ | _ -> raise Not_found ]
+ and backslash1 cod s i =
+ if i = String.length s then (Char.chr cod, i)
+ else
+ match s.[i] with
+ [ '0'..'9' as c -> backslash2 (10 * cod + valch c) s (i + 1)
+ | _ -> (Char.chr cod, i) ]
+ and backslash2 cod s i =
+ if i = String.length s then (Char.chr cod, i)
+ else
+ match s.[i] with
+ [ '0'..'9' as c -> (Char.chr (10 * cod + valch c), i + 1)
+ | _ -> (Char.chr cod, i) ]
+ ;
+ value rec skip_indent s i =
+ if i = String.length s then i
+ else
+ match s.[i] with
+ [ ' ' | '\t' -> skip_indent s (i + 1)
+ | _ -> i ]
+ ;
+ value skip_opt_linefeed s i =
+ if i = String.length s then i else if s.[i] = '\010' then i + 1 else i
+ ;
+ value char_of_char_token s =
+ if String.length s = 1 then s.[0]
+ else if String.length s = 0 then failwith "invalid char token"
+ else if s.[0] = '\\' then
+ if String.length s = 2 && s.[1] = ''' then '''
+ else
+ try
+ let (c, i) = backslash s 1 in
+ if i = String.length s then c else raise Not_found
+ with
+ [ Not_found -> failwith "invalid char token" ]
+ else failwith "invalid char token"
+ ;
+ value string_of_string_token s =
+ loop 0 0 where rec loop len i =
+ if i = String.length s then get_buff len
+ else
+ let (len, i) =
+ if s.[i] = '\\' then
+ let i = i + 1 in
+ if i = String.length s then failwith "invalid string token"
+ else if s.[i] = '"' then (store len '"', i + 1)
+ else
+ match s.[i] with
+ [ '\010' -> (len, skip_indent s (i + 1))
+ | '\013' -> (len, skip_indent s (skip_opt_linefeed s (i + 1)))
+ | c ->
+ try
+ let (c, i) = backslash s i in
+ (store len c, i)
+ with
+ [ Not_found -> (store (store len '\\') c, i + 1) ] ]
+ else (store len s.[i], i + 1)
+ in
+ loop len i
+ ;
+ value rec skip_spaces =
+ parser
+ [ [: `' ' | '\n' | '\r' | '\t' | '\026' | '\012'; s :] -> skip_spaces s
+ | [: :] -> () ]
+ ;
+ value error_on_unknown_keywords = ref False;
+ value next_token_fun find_id_kwd find_spe_kwd fname lnum bolpos =
+ let make_pos p =
+ {Lexing.pos_fname = fname.val; Lexing.pos_lnum = lnum.val;
+ Lexing.pos_bol = bolpos.val; Lexing.pos_cnum = p} in
+ let mkloc (bp, ep) = (make_pos bp, make_pos ep) in
+
+ let err loc msg = raise_with_loc loc (Token.Error msg) in
+ let keyword_or_error (bp,ep) s =
+ try ("", find_spe_kwd s) with
+ [ Not_found ->
+ if error_on_unknown_keywords.val then
+ err (mkloc (bp, ep)) ("illegal token: " ^ s)
+ else ("", s) ]
+ in
+ let rec next_token =
+ parser bp
+ [ [: `('A'..'Z' | 'À'..'Ö' | 'Ø'..'Þ' as c); s :] ->
+ let id = get_buff (ident (store 0 c) s) in
+ try ("", find_id_kwd id) with [ Not_found -> ("UIDENT", id) ]
+ | [: `('a'..'z' | 'ß'..'ö' | 'ø'..'ÿ' | '_' as c); s :] ->
+ let id = get_buff (ident (store 0 c) s) in
+ let is_label =
+ match Stream.peek s with
+ [ Some ':' ->
+ match Stream.npeek 2 s with
+ [ [_; ':' | '=' | '>'] -> False
+ | _ -> True ]
+ | _ -> False ]
+ in
+ if is_label then do { Stream.junk s; ("LABEL", id) }
+ else try ("", find_id_kwd id) with [ Not_found -> ("LIDENT", id) ]
+ | [: `('1'..'9' as c); s :] -> number (store 0 c) s
+ | [: `'0'; s :] -> base_number (store 0 '0') s
+ | [: `'''; s :] ep ->
+ match Stream.npeek 2 s with
+ [ [_; '''] | ['\\'; _] -> ("CHAR", char bp 0 s)
+ | _ -> keyword_or_error (bp, ep) "'" ]
+ | [: `'"'; s :] -> ("STRING", string bp 0 s)
+ | [: `'$'; s :] -> locate_or_antiquot bp 0 s
+ | [: `('!' | '~' | '=' | '@' | '^' | '&' | '+' | '-' | '*' | '/' |
+ '%' as
+ c)
+ ;
+ s :] ->
+ let id = get_buff (ident2 (store 0 c) s) in
+ keyword_or_error (bp, Stream.count s) id
+ | [: `('?' as c); s :] ->
+ let id = get_buff (ident4 (store 0 c) s) in
+ keyword_or_error (bp, Stream.count s) id
+ | [: `'<'; s :] -> less bp s
+ | [: `(':' as c1);
+ (is_label, len) =
+ parser
+ [ [: `(']' | ':' | '=' | '>' as c2) :] ->
+ (False, store (store 0 c1) c2)
+ | [: `('a'..'z' | 'ß'..'ö' | 'ø'..'ÿ' | '_' as c); s :] ->
+ (True, ident (store 0 c) s)
+ | [: :] -> (False, store 0 c1) ] :] ep ->
+ let id = get_buff len in
+ if is_label then ("ELABEL", id) else keyword_or_error (bp, ep) id
+ | [: `('>' | '|' as c1);
+ len =
+ parser
+ [ [: `(']' | '}' as c2) :] -> store (store 0 c1) c2
+ | [: a = ident2 (store 0 c1) :] -> a ] :] ep ->
+ let id = get_buff len in
+ keyword_or_error (bp, ep) id
+ | [: `('[' | '{' as c1); s :] ->
+ let len =
+ match Stream.npeek 2 s with
+ [ ['<'; '<' | ':'] -> store 0 c1
+ | _ ->
+ match s with parser
+ [ [: `('|' | '<' | ':' as c2) :] -> store (store 0 c1) c2
+ | [: :] -> store 0 c1 ] ]
+ in
+ let ep = Stream.count s in
+ let id = get_buff len in
+ keyword_or_error (bp, ep) id
+ | [: `'.'; id = parser [ [: `'.' :] -> ".." | [: :] -> "." ] :] ep ->
+ keyword_or_error (bp, ep) id
+ | [: `';'; id = parser [ [: `';' :] -> ";;" | [: :] -> ";" ] :] ep ->
+ keyword_or_error (bp, ep) id
+ | [: `'\\'; s :] -> ("LIDENT", get_buff (ident3 0 s))
+ | [: `c :] ep -> keyword_or_error (bp, ep) (String.make 1 c) ]
+ and less bp =
+ parser
+ [ [: `'<'; s :] -> ("QUOTATION", ":" ^ get_buff (quotation bp 0 s))
+ | [: `':'; i = parser [: len = ident 0 :] -> get_buff len;
+ `'<' ? "character '<' expected"; s :] ->
+ ("QUOTATION", i ^ ":" ^ get_buff (quotation bp 0 s))
+ | [: s :] ep ->
+ let id = get_buff (ident2 (store 0 '<') s) in
+ keyword_or_error (bp, ep) id ]
+ and string bp len =
+ parser
+ [ [: `'"' :] -> get_buff len
+ | [: `'\\'; `c; s :] -> string bp (store (store len '\\') c) s
+ | [: `c; s :] -> string bp (store len c) s
+ | [: :] ep -> err (mkloc (bp, ep)) "string not terminated" ]
+ and char bp len =
+ parser
+ [ [: `'''; s :] ->
+ if len = 0 then char bp (store len ''') s else get_buff len
+ | [: `'\\'; `c; s :] -> char bp (store (store len '\\') c) s
+ | [: `c; s :] -> char bp (store len c) s
+ | [: :] ep -> err (mkloc(bp,ep)) "char not terminated" ]
+ and locate_or_antiquot bp len =
+ parser
+ [ [: `'$' :] -> ("ANTIQUOT", ":" ^ get_buff len)
+ | [: `('a'..'z' | 'A'..'Z' as c); s :] -> antiquot bp (store len c) s
+ | [: `('0'..'9' as c); s :] -> maybe_locate bp (store len c) s
+ | [: `':'; s :] ->
+ let k = get_buff len in
+ ("ANTIQUOT", k ^ ":" ^ locate_or_antiquot_rest bp 0 s)
+ | [: `'\\'; `c; s :] ->
+ ("ANTIQUOT", ":" ^ locate_or_antiquot_rest bp (store len c) s)
+ | [: `c; s :] ->
+ ("ANTIQUOT", ":" ^ locate_or_antiquot_rest bp (store len c) s)
+ | [: :] ep -> err (mkloc(bp,ep)) "antiquotation not terminated" ]
+ and maybe_locate bp len =
+ parser
+ [ [: `'$' :] -> ("ANTIQUOT", ":" ^ get_buff len)
+ | [: `('0'..'9' as c); s :] -> maybe_locate bp (store len c) s
+ | [: `':'; s :] ->
+ ("LOCATE", get_buff len ^ ":" ^ locate_or_antiquot_rest bp 0 s)
+ | [: `'\\'; `c; s :] ->
+ ("ANTIQUOT", ":" ^ locate_or_antiquot_rest bp (store len c) s)
+ | [: `c; s :] ->
+ ("ANTIQUOT", ":" ^ locate_or_antiquot_rest bp (store len c) s)
+ | [: :] ep -> err (mkloc(bp,ep)) "antiquotation not terminated" ]
+ and antiquot bp len =
+ parser
+ [ [: `'$' :] -> ("ANTIQUOT", ":" ^ get_buff len)
+ | [: `('a'..'z' | 'A'..'Z' | '0'..'9' as c); s :] ->
+ antiquot bp (store len c) s
+ | [: `':'; s :] ->
+ let k = get_buff len in
+ ("ANTIQUOT", k ^ ":" ^ locate_or_antiquot_rest bp 0 s)
+ | [: `'\\'; `c; s :] ->
+ ("ANTIQUOT", ":" ^ locate_or_antiquot_rest bp (store len c) s)
+ | [: `c; s :] ->
+ ("ANTIQUOT", ":" ^ locate_or_antiquot_rest bp (store len c) s)
+ | [: :] ep -> err (mkloc(bp,ep)) "antiquotation not terminated" ]
+ and locate_or_antiquot_rest bp len =
+ parser
+ [ [: `'$' :] -> get_buff len
+ | [: `'\\'; `c; s :] -> locate_or_antiquot_rest bp (store len c) s
+ | [: `c; s :] -> locate_or_antiquot_rest bp (store len c) s
+ | [: :] ep -> err (mkloc(bp,ep)) "antiquotation not terminated" ]
+ and quotation bp len =
+ parser
+ [ [: `'>'; s :] -> maybe_end_quotation bp len s
+ | [: `'<'; s :] ->
+ quotation bp (maybe_nested_quotation bp (store len '<') __strm) s
+ | [: `'\\';
+ len =
+ parser
+ [ [: `('>' | '<' | '\\' as c) :] -> store len c
+ | [: :] -> store len '\\' ];
+ s :] ->
+ quotation bp len s
+ | [: `c; s :] -> quotation bp (store len c) s
+ | [: :] ep -> err (mkloc(bp,ep)) "quotation not terminated" ]
+ and maybe_nested_quotation bp len =
+ parser
+ [ [: `'<'; s :] -> mstore (quotation bp (store len '<') s) ">>"
+ | [: `':'; len = ident (store len ':');
+ a =
+ parser
+ [ [: `'<'; s :] -> mstore (quotation bp (store len '<') s) ">>"
+ | [: :] -> len ] :] ->
+ a
+ | [: :] -> len ]
+ and maybe_end_quotation bp len =
+ parser
+ [ [: `'>' :] -> len
+ | [: a = quotation bp (store len '>') :] -> a ]
+ in
+ let rec next_token_loc =
+ parser bp
+ [ [: `' ' | '\n' | '\r' | '\t' | '\026' | '\012'; s :] ->
+ next_token_loc s
+ | [: `'('; s :] -> maybe_comment bp s
+ | [: `'#'; _ = spaces_tabs; a = linenum bp :] -> a
+ | [: tok = next_token :] ep -> (tok, mkloc(bp, ep))
+ | [: _ = Stream.empty :] -> (("EOI", ""), mkloc(bp, succ bp)) ]
+ and maybe_comment bp =
+ parser
+ [ [: `'*'; s :] -> do { comment bp s; next_token_loc s }
+ | [: :] ep ->
+ let tok = keyword_or_error (bp, ep) "(" in
+ (tok, mkloc(bp, ep)) ]
+ and comment bp =
+ parser
+ [ [: `'('; s :] -> maybe_nested_comment bp s
+ | [: `'*'; s :] -> maybe_end_comment bp s
+ | [: `c; s :] -> comment bp s
+ | [: :] ep -> err (mkloc(bp,ep)) "comment not terminated" ]
+ and maybe_nested_comment bp =
+ parser
+ [ [: `'*'; s :] -> do { comment bp s; comment bp s }
+ | [: a = comment bp :] -> a ]
+ and maybe_end_comment bp =
+ parser [ [: `')' :] -> () | [: a = comment bp :] -> a ]
+ and linenum bp =
+ parser
+ [ [: `'0'..'9'; _ = digits; _ = spaces_tabs; `'"'; _ = any_to_nl;
+ s :] ->
+ next_token_loc s
+ | [: :] -> (keyword_or_error (bp, bp + 1) "#", mkloc(bp, bp + 1)) ]
+ and spaces_tabs =
+ parser [ [: `' ' | '\t'; s :] -> spaces_tabs s | [: :] -> () ]
+ and digits = parser [ [: `'0'..'9'; s :] -> digits s | [: :] -> () ]
+ and any_to_nl =
+ parser
+ [ [: `'\r' | '\n' :] -> ()
+ | [: `_; s :] -> any_to_nl s
+ | [: :] -> () ]
+ in
+ fun cstrm ->
+ try next_token_loc cstrm with
+ [ Stream.Error str ->
+ err (mkloc(Stream.count cstrm, Stream.count cstrm + 1)) str ]
+ ;
+ value locerr () = invalid_arg "Lexer: location function";
+ value loct_create () = ref (Array.create 1024 None);
+ value loct_func loct i =
+ match
+ if i < 0 || i >= Array.length loct.val then None
+ else Array.unsafe_get loct.val i
+ with
+ [ Some loc -> loc
+ | _ -> locerr () ]
+ ;
+ value loct_add loct i loc =
+ do {
+ if i >= Array.length loct.val then do {
+ let new_tmax = Array.length loct.val * 2 in
+ let new_loct = Array.create new_tmax None in
+ Array.blit loct.val 0 new_loct 0 (Array.length loct.val);
+ loct.val := new_loct
+ }
+ else ();
+ loct.val.(i) := Some loc
+ }
+ ;
+ value func kwd_table =
+ let bolpos = ref 0 in
+ let lnum = ref 0 in
+ let fname = ref "" in
+ let find = Hashtbl.find kwd_table in
+ let lex cstrm =
+ let next_token_loc = next_token_fun find find fname lnum bolpos in
+ let loct = loct_create () in
+ let ts =
+ Stream.from
+ (fun i ->
+ let (tok, loc) = next_token_loc cstrm in
+ do { loct_add loct i loc; Some tok })
+ in
+ let locf = loct_func loct in
+ (ts, locf)
+ in
+ lex
+ ;
+ value rec check_keyword_stream =
+ parser [: _ = check; _ = Stream.empty :] -> True
+ and check =
+ parser
+ [ [: `'A'..'Z' | 'a'..'z' | 'À'..'Ö' | 'Ø'..'ö' | 'ø'..'ÿ'; s :] ->
+ check_ident s
+ | [: `'!' | '?' | '~' | '=' | '@' | '^' | '&' | '+' | '-' | '*' | '/' |
+ '%' | '.'
+ ;
+ s :] ->
+ check_ident2 s
+ | [: `'<'; s :] ->
+ match Stream.npeek 1 s with
+ [ [':' | '<'] -> ()
+ | _ -> check_ident2 s ]
+ | [: `':';
+ _ =
+ parser
+ [ [: `']' | ':' | '=' | '>' :] -> ()
+ | [: :] -> () ] :] ep ->
+ ()
+ | [: `'>' | '|';
+ _ =
+ parser
+ [ [: `']' | '}' :] -> ()
+ | [: a = check_ident2 :] -> a ] :] ->
+ ()
+ | [: `'[' | '{'; s :] ->
+ match Stream.npeek 2 s with
+ [ ['<'; '<' | ':'] -> ()
+ | _ ->
+ match s with parser
+ [ [: :] ->
+ match Stream.peek __strm with
+ [ Some ('|' | '<' | ':') -> Stream.junk __strm
+ | _ -> () ] ] ]
+ | [: `';'; _ = parser [ [: `';' :] -> () | [: :] -> () ] :] -> ()
+ | [: `_ :] -> () ]
+ and check_ident =
+ parser
+ [ [: `'A'..'Z' | 'a'..'z' | 'À'..'Ö' | 'Ø'..'ö' | 'ø'..'ÿ' | '0'..'9' |
+ '_' | '''
+ ;
+ s :] ->
+ check_ident s
+ | [: :] -> () ]
+ and check_ident2 =
+ parser
+ [ [: `'!' | '?' | '~' | '=' | '@' | '^' | '&' | '+' | '-' | '*' | '/' |
+ '%' | '.' | ':' | '<' | '>' | '|'
+ ;
+ s :] ->
+ check_ident2 s
+ | [: :] -> () ]
+ ;
+ value check_keyword s =
+ try check_keyword_stream (Stream.of_string s) with _ -> False
+ ;
+ value using_token kwd_table (p_con, p_prm) =
+ match p_con with
+ [ "" ->
+ try
+ let _ = Hashtbl.find kwd_table p_prm in
+ ()
+ with
+ [ Not_found ->
+ if check_keyword p_prm then Hashtbl.add kwd_table p_prm p_prm
+ else
+ raise
+ (Token.Error
+ ("the token \"" ^ p_prm ^
+ "\" does not respect Plexer rules")) ]
+ | "LIDENT" | "UIDENT" | "INT" | "FLOAT" | "CHAR" | "STRING" |
+ "QUOTATION" | "ANTIQUOT" | "LOCATE" | "LABEL" | "ELABEL" | "EOI" ->
+ ()
+ | _ ->
+ raise
+ (Token.Error
+ ("the constructor \"" ^ p_con ^
+ "\" is not recognized by Llexer")) ]
+ ;
+ value removing_token kwd_table (p_con, p_prm) =
+ if p_con = "" then Hashtbl.remove kwd_table p_prm else ()
+ ;
+ value text =
+ fun
+ [ ("", t) -> "'" ^ t ^ "'"
+ | ("LIDENT", "") -> "lowercase identifier"
+ | ("LIDENT", t) -> "'" ^ t ^ "'"
+ | ("UIDENT", "") -> "uppercase identifier"
+ | ("UIDENT", t) -> "'" ^ t ^ "'"
+ | ("INT", "") -> "integer"
+ | ("INT", s) -> "'" ^ s ^ "'"
+ | ("FLOAT", "") -> "float"
+ | ("STRING", "") -> "string"
+ | ("CHAR", "") -> "char"
+ | ("QUOTATION", "") -> "quotation"
+ | ("ANTIQUOT", k) -> "antiquot \"" ^ k ^ "\""
+ | ("LOCATE", "") -> "locate"
+ | ("LABEL", "") -> "label"
+ | ("ELABEL", "") -> "elabel"
+ | ("EOI", "") -> "end of input"
+ | (con, "") -> con
+ | (con, prm) -> con ^ " \"" ^ prm ^ "\"" ]
+ ;
+ value eq_before_colon p e =
+ loop 0 where rec loop i =
+ if i == String.length e then
+ failwith "Internal error in Plexer: incorrect ANTIQUOT"
+ else if i == String.length p then e.[i] == ':'
+ else if p.[i] == e.[i] then loop (i + 1)
+ else False
+ ;
+ value after_colon e =
+ try
+ let i = String.index e ':' in
+ String.sub e (i + 1) (String.length e - i - 1)
+ with
+ [ Not_found -> "" ]
+ ;
+ value gmake () =
+ let kwd_table = Hashtbl.create 301 in
+ {tok_func = func kwd_table; tok_using = using_token kwd_table;
+ tok_removing = removing_token kwd_table;
+ tok_match = Token.default_match; tok_text = text; tok_comm = None}
+ ;
+ end
+;
+
+open Stdpp;
+open Pcaml;
+
+Pcaml.no_constructors_arity.val := True;
+
+do {
+ Grammar.Unsafe.gram_reinit gram (Plexer.gmake ());
+ Grammar.Unsafe.clear_entry interf;
+ Grammar.Unsafe.clear_entry implem;
+ Grammar.Unsafe.clear_entry top_phrase;
+ Grammar.Unsafe.clear_entry use_file;
+ Grammar.Unsafe.clear_entry module_type;
+ Grammar.Unsafe.clear_entry module_expr;
+ Grammar.Unsafe.clear_entry sig_item;
+ Grammar.Unsafe.clear_entry str_item;
+ Grammar.Unsafe.clear_entry expr;
+ Grammar.Unsafe.clear_entry patt;
+ Grammar.Unsafe.clear_entry ctyp;
+ Grammar.Unsafe.clear_entry let_binding;
+ Grammar.Unsafe.clear_entry class_type;
+ Grammar.Unsafe.clear_entry class_expr;
+ Grammar.Unsafe.clear_entry class_sig_item;
+ Grammar.Unsafe.clear_entry class_str_item
+};
+
+Pcaml.parse_interf.val := Grammar.Entry.parse interf;
+Pcaml.parse_implem.val := Grammar.Entry.parse implem;
+
+value o2b =
+ fun
+ [ Some _ -> True
+ | None -> False ]
+;
+
+value mkumin loc f arg =
+ match arg with
+ [ <:expr< $int:n$ >> when int_of_string n > 0 ->
+ let n = "-" ^ n in
+ <:expr< $int:n$ >>
+ | <:expr< $flo:n$ >> when float_of_string n > 0.0 ->
+ let n = "-" ^ n in
+ <:expr< $flo:n$ >>
+ | _ ->
+ let f = "~" ^ f in
+ <:expr< $lid:f$ $arg$ >> ]
+;
+
+external loc_of_node : 'a -> Loc.t = "%field0";
+
+value mklistexp loc last =
+ loop True where rec loop top =
+ fun
+ [ [] ->
+ match last with
+ [ Some e -> e
+ | None -> <:expr< [] >> ]
+ | [e1 :: el] ->
+ let loc = if top then loc else (fst (loc_of_node e1), snd loc) in
+ <:expr< [$e1$ :: $loop False el$] >> ]
+;
+
+value mklistpat loc last =
+ loop True where rec loop top =
+ fun
+ [ [] ->
+ match last with
+ [ Some p -> p
+ | None -> <:patt< [] >> ]
+ | [p1 :: pl] ->
+ let loc = if top then loc else (fst (loc_of_node p1), snd loc) in
+ <:patt< [$p1$ :: $loop False pl$] >> ]
+;
+
+value neg s = string_of_int (- int_of_string s);
+
+value is_operator =
+ let ht = Hashtbl.create 73 in
+ let ct = Hashtbl.create 73 in
+ do {
+ List.iter (fun x -> Hashtbl.add ht x True)
+ ["asr"; "land"; "lor"; "lsl"; "lsr"; "lxor"; "mod"; "or"];
+ List.iter (fun x -> Hashtbl.add ct x True)
+ ['!'; '&'; '*'; '+'; '-'; '/'; ':'; '<'; '='; '>'; '@'; '^'; '|'; '~';
+ '?'; '%'; '.'];
+ fun x ->
+ try Hashtbl.find ht x with
+ [ Not_found -> try Hashtbl.find ct x.[0] with _ -> False ]
+ }
+;
+
+(*
+value p_operator strm =
+ match Stream.peek strm with
+ [ Some (Token.Tterm "(") ->
+ match Stream.npeek 3 strm with
+ [ [_; Token.Tterm x; Token.Tterm ")"] when is_operator x ->
+ do { Stream.junk strm; Stream.junk strm; Stream.junk strm; x }
+ | _ -> raise Stream.Failure ]
+ | _ -> raise Stream.Failure ]
+;
+
+value operator = Grammar.Entry.of_parser gram "operator" p_operator;
+*)
+
+value operator =
+ Grammar.Entry.of_parser gram "operator"
+ (parser [: `("", x) when is_operator x :] -> x)
+;
+
+value symbolchar =
+ let list =
+ ['!'; '$'; '%'; '&'; '*'; '+'; '-'; '.'; '/'; ':'; '<'; '='; '>'; '?';
+ '@'; '^'; '|'; '~']
+ in
+ let rec loop s i =
+ if i == String.length s then True
+ else if List.mem s.[i] list then loop s (i + 1)
+ else False
+ in
+ loop
+;
+
+value prefixop =
+ let list = ['!'; '?'; '~'] in
+ let excl = ["!="] in
+ Grammar.Entry.of_parser gram "prefixop"
+ (parser
+ [: `("", x)
+ when
+ not (List.mem x excl) && String.length x >= 2 &&
+ List.mem x.[0] list && symbolchar x 1 :] ->
+ x)
+;
+
+value infixop0 =
+ let list = ['='; '<'; '>'; '|'; '&'; '$'] in
+ let excl = ["<-"; "||"; "&&"] in
+ Grammar.Entry.of_parser gram "infixop0"
+ (parser
+ [: `("", x)
+ when
+ not (List.mem x excl) && String.length x >= 2 &&
+ List.mem x.[0] list && symbolchar x 1 :] ->
+ x)
+;
+
+value infixop1 =
+ let list = ['@'; '^'] in
+ Grammar.Entry.of_parser gram "infixop1"
+ (parser
+ [: `("", x)
+ when
+ String.length x >= 2 && List.mem x.[0] list &&
+ symbolchar x 1 :] ->
+ x)
+;
+
+value infixop2 =
+ let list = ['+'; '-'] in
+ Grammar.Entry.of_parser gram "infixop2"
+ (parser
+ [: `("", x)
+ when
+ x <> "->" && String.length x >= 2 && List.mem x.[0] list &&
+ symbolchar x 1 :] ->
+ x)
+;
+
+value infixop3 =
+ let list = ['*'; '/'; '%'] in
+ Grammar.Entry.of_parser gram "infixop3"
+ (parser
+ [: `("", x)
+ when
+ String.length x >= 2 && List.mem x.[0] list &&
+ symbolchar x 1 :] ->
+ x)
+;
+
+value infixop4 =
+ Grammar.Entry.of_parser gram "infixop4"
+ (parser
+ [: `("", x)
+ when
+ String.length x >= 3 && x.[0] == '*' && x.[1] == '*' &&
+ symbolchar x 2 :] ->
+ x)
+;
+
+value test_constr_decl =
+ Grammar.Entry.of_parser gram "test_constr_decl"
+ (fun strm ->
+ match Stream.npeek 1 strm with
+ [ [("UIDENT", _)] ->
+ match Stream.npeek 2 strm with
+ [ [_; ("", ".")] -> raise Stream.Failure
+ | [_; ("", "(")] -> raise Stream.Failure
+ | [_ :: _] -> ()
+ | _ -> raise Stream.Failure ]
+ | [("", "|")] -> ()
+ | _ -> raise Stream.Failure ])
+;
+
+value stream_peek_nth n strm =
+ loop n (Stream.npeek n strm) where rec loop n =
+ fun
+ [ [] -> None
+ | [x] -> if n == 1 then Some x else None
+ | [_ :: l] -> loop (n - 1) l ]
+;
+
+value test_label_eq =
+ let rec test lev strm =
+ match stream_peek_nth lev strm with
+ [ Some (("UIDENT", _) | ("LIDENT", _) | ("", ".")) -> test (lev + 1) strm
+ | Some ("", "=") -> ()
+ | _ -> raise Stream.Failure ]
+ in
+ Grammar.Entry.of_parser gram "test_label_eq" (test 1)
+;
+
+value constr_arity = ref [("Some", 1); ("Match_Failure", 1)];
+
+value rec constr_expr_arity =
+ fun
+ [ <:expr< $uid:c$ >> ->
+ try List.assoc c constr_arity.val with [ Not_found -> 0 ]
+ | <:expr< $uid:_$.$e$ >> -> constr_expr_arity e
+ | _ -> 1 ]
+;
+
+value rec constr_patt_arity =
+ fun
+ [ <:patt< $uid:c$ >> ->
+ try List.assoc c constr_arity.val with [ Not_found -> 0 ]
+ | <:patt< $uid:_$.$p$ >> -> constr_patt_arity p
+ | _ -> 1 ]
+;
+
+value rec get_seq =
+ fun
+ [ <:expr< do { $list:el$ } >> -> el
+ | e -> [e] ]
+;
+
+value choose_tvar tpl =
+ let rec find_alpha v =
+ let s = String.make 1 v in
+ if List.mem_assoc s tpl then
+ if v = 'z' then None else find_alpha (Char.chr (Char.code v + 1))
+ else Some (String.make 1 v)
+ in
+ let rec make_n n =
+ let v = "a" ^ string_of_int n in
+ if List.mem_assoc v tpl then make_n (succ n) else v
+ in
+ match find_alpha 'a' with
+ [ Some x -> x
+ | None -> make_n 1 ]
+;
+
+value rec patt_lid =
+ fun
+ [ <:patt< $lid:i$ $p$ >> -> Some (i, [p])
+ | <:patt< $p1$ $p2$ >> ->
+ match patt_lid p1 with
+ [ Some (i, pl) -> Some (i, [p2 :: pl])
+ | None -> None ]
+ | _ -> None ]
+;
+
+value type_parameter = Grammar.Entry.create gram "type_parameter";
+value fun_def = Grammar.Entry.create gram "fun_def";
+value fun_binding = Grammar.Entry.create gram "fun_binding";
+
+EXTEND
+ GLOBAL: interf implem top_phrase use_file sig_item str_item ctyp patt expr
+ module_type module_expr let_binding type_parameter fun_def fun_binding;
+ (* Main entry points *)
+ interf:
+ [ [ st = LIST0 [ s = sig_item; OPT ";;" -> (s, loc) ]; EOI ->
+ (st, False) ] ]
+ ;
+ implem:
+ [ [ st = LIST0 [ s = str_item; OPT ";;" -> (s, loc) ]; EOI ->
+ (st, False) ] ]
+ ;
+ top_phrase:
+ [ [ ph = phrase; ";;" -> Some ph
+ | EOI -> None ] ]
+ ;
+ use_file:
+ [ [ l = LIST0 [ ph = phrase; OPT ";;" -> ph ]; EOI -> (l, False) ] ]
+ ;
+ phrase:
+ [ [ sti = str_item -> sti
+ | "#"; n = LIDENT; dp = dir_param -> MLast.StDir loc n dp ] ]
+ ;
+ dir_param:
+ [ [ -> None
+ | e = expr -> Some e ] ]
+ ;
+ (* Module expressions *)
+ module_expr:
+ [ [ "functor"; "("; i = UIDENT; ":"; t = module_type; ")"; "->";
+ me = SELF ->
+ <:module_expr< functor ( $i$ : $t$ ) -> $me$ >>
+ | "struct"; st = LIST0 [ s = str_item; OPT ";;" -> s ]; "end" ->
+ <:module_expr< struct $list:st$ end >> ]
+ | [ me1 = SELF; me2 = SELF -> <:module_expr< $me1$ $me2$ >> ]
+ | [ i = mod_expr_ident -> i
+ | "("; me = SELF; ":"; mt = module_type; ")" ->
+ <:module_expr< ( $me$ : $mt$ ) >>
+ | "("; me = SELF; ")" -> <:module_expr< $me$ >> ] ]
+ ;
+ mod_expr_ident:
+ [ LEFTA
+ [ m1 = SELF; "."; m2 = SELF -> <:module_expr< $m1$ . $m2$ >> ]
+ | [ m = UIDENT -> <:module_expr< $uid:m$ >> ] ]
+ ;
+ str_item:
+ [ "top"
+ [ "exception"; (_, c, tl) = constructor_declaration ->
+ <:str_item< exception $c$ of $list:tl$ >>
+ | "external"; i = LIDENT; ":"; t = ctyp; "="; pd = LIST1 STRING ->
+ <:str_item< external $i$ : $t$ = $list:pd$ >>
+ | "external"; i = LABEL; t = ctyp; "="; pd = LIST1 STRING ->
+ <:str_item< external $i$ : $t$ = $list:pd$ >>
+ | "external"; "("; i = operator; ")"; ":"; t = ctyp; "=";
+ pd = LIST1 STRING ->
+ <:str_item< external $i$ : $t$ = $list:pd$ >>
+ | "module"; i = UIDENT; mb = module_binding ->
+ <:str_item< module $i$ = $mb$ >>
+ | "module"; "type"; i = UIDENT; "="; mt = module_type ->
+ <:str_item< module type $i$ = $mt$ >>
+ | "open"; i = mod_ident -> <:str_item< open $i$ >>
+ | "type"; tdl = LIST1 type_declaration SEP "and" ->
+ <:str_item< type $list:tdl$ >>
+ | "let"; r = OPT "rec"; l = LIST1 let_binding SEP "and"; "in";
+ x = expr ->
+ let e = <:expr< let $opt:o2b r$ $list:l$ in $x$ >> in
+ <:str_item< $exp:e$ >>
+ | "let"; r = OPT "rec"; l = LIST1 let_binding SEP "and" ->
+ match l with
+ [ [(<:patt< _ >>, e)] -> <:str_item< $exp:e$ >>
+ | _ -> <:str_item< value $opt:o2b r$ $list:l$ >> ]
+ | "let"; "module"; m = UIDENT; mb = module_binding; "in"; e = expr ->
+ <:str_item< let module $m$ = $mb$ in $e$ >>
+ | e = expr -> <:str_item< $exp:e$ >> ] ]
+ ;
+ module_binding:
+ [ RIGHTA
+ [ "("; m = UIDENT; ":"; mt = module_type; ")"; mb = SELF ->
+ <:module_expr< functor ( $m$ : $mt$ ) -> $mb$ >>
+ | ":"; mt = module_type; "="; me = module_expr ->
+ <:module_expr< ( $me$ : $mt$ ) >>
+ | "="; me = module_expr -> <:module_expr< $me$ >> ] ]
+ ;
+ (* Module types *)
+ module_type:
+ [ [ "functor"; "("; i = UIDENT; ":"; t = SELF; ")"; "->"; mt = SELF ->
+ <:module_type< functor ( $i$ : $t$ ) -> $mt$ >> ]
+ | [ mt = SELF; "with"; wcl = LIST1 with_constr SEP "and" ->
+ <:module_type< $mt$ with $list:wcl$ >> ]
+ | [ "sig"; sg = LIST0 [ s = sig_item; OPT ";;" -> s ]; "end" ->
+ <:module_type< sig $list:sg$ end >>
+ | i = mod_type_ident -> i
+ | "("; mt = SELF; ")" -> <:module_type< $mt$ >> ] ]
+ ;
+ mod_type_ident:
+ [ LEFTA
+ [ m1 = SELF; "."; m2 = SELF -> <:module_type< $m1$ . $m2$ >>
+ | m1 = SELF; "("; m2 = SELF; ")" -> <:module_type< $m1$ $m2$ >> ]
+ | [ m = UIDENT -> <:module_type< $uid:m$ >>
+ | m = LIDENT -> <:module_type< $lid:m$ >> ] ]
+ ;
+ sig_item:
+ [ "top"
+ [ "exception"; (_, c, tl) = constructor_declaration ->
+ <:sig_item< exception $c$ of $list:tl$ >>
+ | "external"; i = LIDENT; ":"; t = ctyp; "="; pd = LIST1 STRING ->
+ <:sig_item< external $i$ : $t$ = $list:pd$ >>
+ | "external"; i = LABEL; t = ctyp; "="; pd = LIST1 STRING ->
+ <:sig_item< external $i$ : $t$ = $list:pd$ >>
+ | "external"; "("; i = operator; ")"; ":"; t = ctyp; "=";
+ pd = LIST1 STRING ->
+ <:sig_item< external $i$ : $t$ = $list:pd$ >>
+ | "include"; mt = module_type -> <:sig_item< include $mt$ >>
+ | "module"; i = UIDENT; mt = module_declaration ->
+ <:sig_item< module $i$ : $mt$ >>
+ | "module"; "type"; i = UIDENT; "="; mt = module_type ->
+ <:sig_item< module type $i$ = $mt$ >>
+ | "open"; i = mod_ident -> <:sig_item< open $i$ >>
+ | "type"; tdl = LIST1 type_declaration SEP "and" ->
+ <:sig_item< type $list:tdl$ >>
+ | "val"; i = LIDENT; ":"; t = ctyp -> <:sig_item< value $i$ : $t$ >>
+ | "val"; i = LABEL; t = ctyp -> <:sig_item< value $i$ : $t$ >>
+ | "val"; "("; i = operator; ")"; ":"; t = ctyp ->
+ <:sig_item< value $i$ : $t$ >> ] ]
+ ;
+ module_declaration:
+ [ RIGHTA
+ [ ":"; mt = module_type -> <:module_type< $mt$ >>
+ | "("; i = UIDENT; ":"; t = module_type; ")"; mt = SELF ->
+ <:module_type< functor ( $i$ : $t$ ) -> $mt$ >> ] ]
+ ;
+ (* "with" constraints (additional type equations over signature
+ components) *)
+ with_constr:
+ [ [ "type"; tp = type_parameters; i = mod_ident; "="; t = ctyp ->
+ MLast.WcTyp loc i tp t
+ | "module"; i = mod_ident; "="; me = module_expr ->
+ MLast.WcMod loc i me ] ]
+ ;
+ (* Core expressions *)
+ expr:
+ [ "top" LEFTA
+ [ e1 = SELF; ";"; e2 = SELF ->
+ <:expr< do { $list:[e1 :: get_seq e2]$ } >>
+ | e1 = SELF; ";" -> e1 ]
+ | "expr1"
+ [ "let"; o = OPT "rec"; l = LIST1 let_binding SEP "and"; "in";
+ x = expr LEVEL "top" ->
+ <:expr< let $opt:o2b o$ $list:l$ in $x$ >>
+ | "let"; "module"; m = UIDENT; mb = module_binding; "in";
+ e = expr LEVEL "top" ->
+ <:expr< let module $m$ = $mb$ in $e$ >>
+ | "function"; OPT "|"; l = LIST1 match_case SEP "|" ->
+ <:expr< fun [ $list:l$ ] >>
+ | "fun"; p = patt LEVEL "simple"; e = fun_def ->
+ <:expr< fun [$p$ -> $e$] >>
+ | "match"; x = SELF; "with"; OPT "|"; l = LIST1 match_case SEP "|" ->
+ <:expr< match $x$ with [ $list:l$ ] >>
+ | "try"; x = SELF; "with"; OPT "|"; l = LIST1 match_case SEP "|" ->
+ <:expr< try $x$ with [ $list:l$ ] >>
+ | "if"; e1 = SELF; "then"; e2 = expr LEVEL "expr1";
+ e3 = [ "else"; e = expr LEVEL "expr1" -> e | -> <:expr< () >> ] ->
+ <:expr< if $e1$ then $e2$ else $e3$ >>
+ | "for"; i = LIDENT; "="; e1 = SELF; df = direction_flag; e2 = SELF;
+ "do"; e = SELF; "done" ->
+ <:expr< for $i$ = $e1$ $to:df$ $e2$ do { $list:get_seq e$ } >>
+ | "while"; e1 = SELF; "do"; e2 = SELF; "done" ->
+ <:expr< while $e1$ do { $list:get_seq e2$ } >> ]
+ | [ e = SELF; ","; el = LIST1 NEXT SEP "," ->
+ <:expr< ( $list:[e :: el]$ ) >> ]
+ | ":=" NONA
+ [ e1 = SELF; ":="; e2 = expr LEVEL "expr1" ->
+ <:expr< $e1$.val := $e2$ >>
+ | e1 = SELF; "<-"; e2 = expr LEVEL "expr1" -> <:expr< $e1$ := $e2$ >> ]
+ | "||" RIGHTA
+ [ e1 = SELF; f = [ op = "or" -> op | op = "||" -> op ]; e2 = SELF ->
+ <:expr< $lid:f$ $e1$ $e2$ >> ]
+ | "&&" RIGHTA
+ [ e1 = SELF; f = [ op = "&" -> op | op = "&&" -> op ]; e2 = SELF ->
+ <:expr< $lid:f$ $e1$ $e2$ >> ]
+ | "<" LEFTA
+ [ e1 = SELF;
+ f =
+ [ op = "<" -> op
+ | op = ">" -> op
+ | op = "<=" -> op
+ | op = ">=" -> op
+ | op = "=" -> op
+ | op = "<>" -> op
+ | op = "==" -> op
+ | op = "!=" -> op
+ | op = infixop0 -> op ];
+ e2 = SELF ->
+ <:expr< $lid:f$ $e1$ $e2$ >> ]
+ | "^" RIGHTA
+ [ e1 = SELF;
+ f = [ op = "^" -> op | op = "@" -> op | op = infixop1 -> op ];
+ e2 = SELF ->
+ <:expr< $lid:f$ $e1$ $e2$ >> ]
+ | RIGHTA
+ [ e1 = SELF; "::"; e2 = SELF -> <:expr< [$e1$ :: $e2$] >> ]
+ | "+" LEFTA
+ [ e1 = SELF;
+ f =
+ [ op = "+" -> op
+ | op = "-" -> op
+ | op = "+." -> op
+ | op = "-." -> op
+ | op = infixop2 -> op ];
+ e2 = SELF ->
+ <:expr< $lid:f$ $e1$ $e2$ >> ]
+ | "*" LEFTA
+ [ e1 = SELF;
+ f =
+ [ op = "*" -> op
+ | op = "/" -> op
+ | op = "*." -> op
+ | op = "/." -> op
+ | op = "land" -> op
+ | op = "lor" -> op
+ | op = "lxor" -> op
+ | op = "mod" -> op
+ | op = infixop3 -> op ];
+ e2 = SELF ->
+ <:expr< $lid:f$ $e1$ $e2$ >> ]
+ | "**" RIGHTA
+ [ e1 = SELF;
+ f =
+ [ op = "**" -> op
+ | op = "asr" -> op
+ | op = "lsl" -> op
+ | op = "lsr" -> op
+ | op = infixop4 -> op ];
+ e2 = SELF ->
+ <:expr< $lid:f$ $e1$ $e2$ >> ]
+ | "unary minus" NONA
+ [ f = [ op = "-" -> op | op = "-." -> op ]; e = SELF ->
+ <:expr< $mkumin loc f e$ >> ]
+ | "apply" LEFTA
+ [ e1 = SELF; e2 = SELF ->
+ match constr_expr_arity e1 with
+ [ 1 -> <:expr< $e1$ $e2$ >>
+ | _ ->
+ match e2 with
+ [ <:expr< ( $list:el$ ) >> ->
+ List.fold_left (fun e1 e2 -> <:expr< $e1$ $e2$ >>) e1 el
+ | _ -> <:expr< $e1$ $e2$ >> ] ]
+ | "assert"; e = expr LEVEL "simple" ->
+ match e with
+ [ <:expr< False >> -> MLast.ExAsf loc
+ | _ -> MLast.ExAsr loc e ]
+ | "lazy"; e = SELF ->
+ <:expr< lazy ($e$) >> ]
+ | "simple" LEFTA
+ [ e1 = SELF; "."; "("; e2 = SELF; ")" -> <:expr< $e1$ .( $e2$ ) >>
+ | e1 = SELF; "."; "["; e2 = SELF; "]" -> <:expr< $e1$ .[ $e2$ ] >>
+ | e1 = SELF; "."; e2 = SELF -> <:expr< $e1$ . $e2$ >>
+ | "!"; e = SELF -> <:expr< $e$ . val>>
+ | f =
+ [ op = "~-" -> op
+ | op = "~-." -> op
+ | op = "~" -> op
+ | op = prefixop -> op ];
+ e = SELF ->
+ <:expr< $lid:f$ $e$ >>
+ | s = INT -> <:expr< $int:s$ >>
+ | s = FLOAT -> <:expr< $flo:s$ >>
+ | s = STRING -> <:expr< $str:s$ >>
+ | c = CHAR -> <:expr< $chr:c$ >>
+ | i = expr_ident -> i
+ | s = "false" -> <:expr< False >>
+ | s = "true" -> <:expr< True >>
+ | "["; "]" -> <:expr< [] >>
+ | "["; el = expr1_semi_list; "]" -> <:expr< $mklistexp loc None el$ >>
+ | "[|"; "|]" -> <:expr< [| |] >>
+ | "[|"; el = expr1_semi_list; "|]" -> <:expr< [| $list:el$ |] >>
+ | "{"; test_label_eq; lel = lbl_expr_list; "}" ->
+ <:expr< { $list:lel$ } >>
+ | "{"; e = expr LEVEL "simple"; "with"; lel = lbl_expr_list; "}" ->
+ <:expr< { ($e$) with $list:lel$ } >>
+ | "("; ")" -> <:expr< () >>
+ | "("; e = SELF; ":"; t = ctyp; ")" -> <:expr< ($e$ : $t$) >>
+ | "("; e = SELF; ")" -> <:expr< $e$ >>
+ | "("; "-"; ")" -> <:expr< $lid:"-"$ >>
+ | "("; "-."; ")" -> <:expr< $lid:"-."$ >>
+ | "("; op = operator; ")" -> <:expr< $lid:op$ >>
+ | "begin"; e = SELF; "end" -> <:expr< $e$ >>
+ | x = LOCATE ->
+ let x =
+ try
+ let i = String.index x ':' in
+ ({Lexing.pos_fname = "";
+ Lexing.pos_lnum = 0;
+ Lexing.pos_bol = 0;
+ Lexing.pos_cnum = int_of_string (String.sub x 0 i)},
+ String.sub x (i + 1) (String.length x - i - 1))
+ with
+ [ Not_found | Failure _ -> (Token.nowhere, x) ]
+ in
+ Pcaml.handle_expr_locate loc x
+ | x = QUOTATION ->
+ let x =
+ try
+ let i = String.index x ':' in
+ (String.sub x 0 i,
+ String.sub x (i + 1) (String.length x - i - 1))
+ with
+ [ Not_found -> ("", x) ]
+ in
+ Pcaml.handle_expr_quotation loc x ] ]
+ ;
+ let_binding:
+ [ [ p = patt; e = fun_binding ->
+ match patt_lid p with
+ [ Some (i, pl) ->
+ let e =
+ List.fold_left (fun e p -> <:expr< fun $p$ -> $e$ >>) e pl
+ in
+ (<:patt< $lid:i$ >>, e)
+ | None -> (p, e) ] ] ]
+ ;
+ fun_binding:
+ [ RIGHTA
+ [ p = patt LEVEL "simple"; e = SELF -> <:expr< fun $p$ -> $e$ >>
+ | "="; e = expr -> <:expr< $e$ >>
+ | ":"; t = ctyp; "="; e = expr -> <:expr< ($e$ : $t$) >> ] ]
+ ;
+ match_case:
+ [ [ x1 = patt; w = OPT [ "when"; e = expr -> e ]; "->"; x2 = expr ->
+ (x1, w, x2) ] ]
+ ;
+ lbl_expr_list:
+ [ [ le = lbl_expr; ";"; lel = SELF -> [le :: lel]
+ | le = lbl_expr; ";" -> [le]
+ | le = lbl_expr -> [le] ] ]
+ ;
+ lbl_expr:
+ [ [ i = patt_label_ident; "="; e = expr LEVEL "expr1" -> (i, e) ] ]
+ ;
+ expr1_semi_list:
+ [ [ e = expr LEVEL "expr1"; ";"; el = SELF -> [e :: el]
+ | e = expr LEVEL "expr1"; ";" -> [e]
+ | e = expr LEVEL "expr1" -> [e] ] ]
+ ;
+ fun_def:
+ [ RIGHTA
+ [ p = patt LEVEL "simple"; e = SELF -> <:expr< fun $p$ -> $e$ >>
+ | "->"; e = expr -> <:expr< $e$ >> ] ]
+ ;
+ expr_ident:
+ [ RIGHTA
+ [ i = LIDENT -> <:expr< $lid:i$ >>
+ | i = UIDENT -> <:expr< $uid:i$ >>
+ | m = UIDENT; "."; i = SELF ->
+ let rec loop m =
+ fun
+ [ <:expr< $x$ . $y$ >> -> loop <:expr< $m$ . $x$ >> y
+ | e -> <:expr< $m$ . $e$ >> ]
+ in
+ loop <:expr< $uid:m$ >> i
+ | m = UIDENT; "."; "("; i = operator; ")" ->
+ <:expr< $uid:m$ . $lid:i$ >> ] ]
+ ;
+ (* Patterns *)
+ patt:
+ [ LEFTA
+ [ p1 = SELF; "as"; i = LIDENT -> <:patt< ($p1$ as $lid:i$) >> ]
+ | LEFTA
+ [ p1 = SELF; "|"; p2 = SELF -> <:patt< $p1$ | $p2$ >> ]
+ | [ p = SELF; ","; pl = LIST1 NEXT SEP "," ->
+ <:patt< ( $list:[p :: pl]$) >> ]
+ | NONA
+ [ p1 = SELF; ".."; p2 = SELF -> <:patt< $p1$ .. $p2$ >> ]
+ | RIGHTA
+ [ p1 = SELF; "::"; p2 = SELF -> <:patt< [$p1$ :: $p2$] >> ]
+ | LEFTA
+ [ p1 = SELF; p2 = SELF ->
+ match constr_patt_arity p1 with
+ [ 1 -> <:patt< $p1$ $p2$ >>
+ | n ->
+ let p2 =
+ match p2 with
+ [ <:patt< _ >> when n > 1 ->
+ let pl =
+ loop n where rec loop n =
+ if n = 0 then [] else [<:patt< _ >> :: loop (n - 1)]
+ in
+ <:patt< ( $list:pl$ ) >>
+ | _ -> p2 ]
+ in
+ match p2 with
+ [ <:patt< ( $list:pl$ ) >> ->
+ List.fold_left (fun p1 p2 -> <:patt< $p1$ $p2$ >>) p1 pl
+ | _ -> <:patt< $p1$ $p2$ >> ] ] ]
+ | LEFTA
+ [ p1 = SELF; "."; p2 = SELF -> <:patt< $p1$ . $p2$ >> ]
+ | "simple"
+ [ s = LIDENT -> <:patt< $lid:s$ >>
+ | s = UIDENT -> <:patt< $uid:s$ >>
+ | s = INT -> <:patt< $int:s$ >>
+ | "-"; s = INT -> <:patt< $int:neg s$ >>
+ | s = STRING -> <:patt< $str:s$ >>
+ | s = CHAR -> <:patt< $chr:s$ >>
+ | s = "false" -> <:patt< False >>
+ | s = "true" -> <:patt< True >>
+ | "["; "]" -> <:patt< [] >>
+ | "["; pl = patt_semi_list; "]" -> <:patt< $mklistpat loc None pl$ >>
+ | "[|"; "|]" -> <:patt< [| |] >>
+ | "[|"; pl = patt_semi_list; "|]" -> <:patt< [| $list:pl$ |] >>
+ | "{"; lpl = lbl_patt_list; "}" -> <:patt< { $list:lpl$ } >>
+ | "("; ")" -> <:patt< () >>
+ | "("; p = SELF; ":"; t = ctyp; ")" -> <:patt< ($p$ : $t$) >>
+ | "("; p = SELF; ")" -> <:patt< $p$ >>
+ | "("; "-"; ")" -> <:patt< $lid:"-"$ >>
+ | "("; op = operator; ")" -> <:patt< $lid:op$ >>
+ | "_" -> <:patt< _ >>
+ | x = LOCATE ->
+ let x =
+ try
+ let i = String.index x ':' in
+ ({Lexing.pos_fname = "";
+ Lexing.pos_lnum = 0;
+ Lexing.pos_bol = 0;
+ Lexing.pos_cnum = int_of_string (String.sub x 0 i)},
+ String.sub x (i + 1) (String.length x - i - 1))
+ with
+ [ Not_found | Failure _ -> (Token.nowhere, x) ]
+ in
+ Pcaml.handle_patt_locate loc x
+ | x = QUOTATION ->
+ let x =
+ try
+ let i = String.index x ':' in
+ (String.sub x 0 i,
+ String.sub x (i + 1) (String.length x - i - 1))
+ with
+ [ Not_found -> ("", x) ]
+ in
+ Pcaml.handle_patt_quotation loc x ] ]
+ ;
+ patt_semi_list:
+ [ [ p = patt; ";"; pl = SELF -> [p :: pl]
+ | p = patt; ";" -> [p]
+ | p = patt -> [p] ] ]
+ ;
+ lbl_patt_list:
+ [ [ le = lbl_patt; ";"; lel = SELF -> [le :: lel]
+ | le = lbl_patt; ";" -> [le]
+ | le = lbl_patt -> [le] ] ]
+ ;
+ lbl_patt:
+ [ [ i = patt_label_ident; "="; p = patt -> (i, p) ] ]
+ ;
+ patt_label_ident:
+ [ RIGHTA
+ [ i = UIDENT -> <:patt< $uid:i$ >>
+ | i = LIDENT -> <:patt< $lid:i$ >>
+ | m = UIDENT; "."; i = SELF -> <:patt< $uid:m$ . $i$ >> ] ]
+ ;
+ (* Type declaration *)
+ type_declaration:
+ [ [ tpl = type_parameters; n = type_patt; "="; tk = type_kind;
+ cl = LIST0 constrain ->
+ (n, tpl, tk, cl)
+ | tpl = type_parameters; n = type_patt; cl = LIST0 constrain ->
+ (n, tpl, <:ctyp< '$choose_tvar tpl$ >>, cl) ] ]
+ ;
+ type_patt:
+ [ [ n = LIDENT -> (loc, n) ] ]
+ ;
+ constrain:
+ [ [ "constraint"; t1 = ctyp; "="; t2 = ctyp -> (t1, t2) ] ]
+ ;
+ type_kind:
+ [ [ test_constr_decl; OPT "|";
+ cdl = LIST1 constructor_declaration SEP "|" ->
+ <:ctyp< [ $list:cdl$ ] >>
+ | t = ctyp -> <:ctyp< $t$ >>
+ | t = ctyp; "="; "{"; ldl = label_declarations; "}" ->
+ <:ctyp< $t$ == { $list:ldl$ } >>
+ | t = ctyp; "="; OPT "|"; cdl = LIST1 constructor_declaration SEP "|" ->
+ <:ctyp< $t$ == [ $list:cdl$ ] >>
+ | "{"; ldl = label_declarations; "}" -> <:ctyp< { $list:ldl$ } >> ] ]
+ ;
+ type_parameters:
+ [ [ -> (* empty *) []
+ | tp = type_parameter -> [tp]
+ | "("; tpl = LIST1 type_parameter SEP ","; ")" -> tpl ] ]
+ ;
+ type_parameter:
+ [ [ "'"; i = ident -> (i, (False, False)) ] ]
+ ;
+ constructor_declaration:
+ [ [ ci = UIDENT; "of"; cal = LIST1 ctyp LEVEL "ctyp1" SEP "*" ->
+ (loc, ci, cal)
+ | ci = UIDENT -> (loc, ci, []) ] ]
+ ;
+ label_declarations:
+ [ [ ld = label_declaration; ";"; ldl = SELF -> [ld :: ldl]
+ | ld = label_declaration; ";" -> [ld]
+ | ld = label_declaration -> [ld] ] ]
+ ;
+ label_declaration:
+ [ [ i = LIDENT; ":"; t = ctyp -> (loc, i, False, t)
+ | i = LABEL; t = ctyp -> (loc, i, False, t)
+ | "mutable"; i = LIDENT; ":"; t = ctyp -> (loc, i, True, t)
+ | "mutable"; i = LABEL; t = ctyp -> (loc, i, True, t) ] ]
+ ;
+ (* Core types *)
+ ctyp:
+ [ [ t1 = SELF; "as"; "'"; i = ident -> <:ctyp< $t1$ as '$i$ >> ]
+ | "arrow" RIGHTA
+ [ t1 = SELF; "->"; t2 = SELF -> <:ctyp< $t1$ -> $t2$ >> ]
+ | [ t = SELF; "*"; tl = LIST1 ctyp LEVEL "ctyp1" SEP "*" ->
+ <:ctyp< ( $list:[t :: tl]$ ) >> ]
+ | "ctyp1"
+ [ t1 = SELF; t2 = SELF -> <:ctyp< $t2$ $t1$ >> ]
+ | "ctyp2"
+ [ t1 = SELF; "."; t2 = SELF -> <:ctyp< $t1$ . $t2$ >>
+ | t1 = SELF; "("; t2 = SELF; ")" -> <:ctyp< $t1$ $t2$ >> ]
+ | "simple"
+ [ "'"; i = ident -> <:ctyp< '$i$ >>
+ | "_" -> <:ctyp< _ >>
+ | i = LIDENT -> <:ctyp< $lid:i$ >>
+ | i = UIDENT -> <:ctyp< $uid:i$ >>
+ | "("; t = SELF; ","; tl = LIST1 ctyp SEP ","; ")";
+ i = ctyp LEVEL "ctyp2" ->
+ List.fold_left (fun c a -> <:ctyp< $c$ $a$ >>) i [t :: tl]
+ | "("; t = SELF; ")" -> <:ctyp< $t$ >> ] ]
+ ;
+ (* Identifiers *)
+ ident:
+ [ [ i = LIDENT -> i
+ | i = UIDENT -> i ] ]
+ ;
+ mod_ident:
+ [ RIGHTA
+ [ i = UIDENT -> [i]
+ | i = LIDENT -> [i]
+ | m = UIDENT; "."; i = SELF -> [m :: i] ] ]
+ ;
+ (* Miscellaneous *)
+ direction_flag:
+ [ [ "to" -> True
+ | "downto" -> False ] ]
+ ;
+END;
+
+(* Objects and Classes *)
+
+value rec class_type_of_ctyp loc t =
+ match t with
+ [ <:ctyp< $lid:i$ >> -> <:class_type< $list:[i]$ >>
+ | <:ctyp< $uid:m$.$t$ >> -> <:class_type< $list:[m :: type_id_list t]$ >>
+ | _ -> raise_with_loc loc (Stream.Error "lowercase identifier expected") ]
+and type_id_list =
+ fun
+ [ <:ctyp< $uid:m$.$t$ >> -> [m :: type_id_list t]
+ | <:ctyp< $lid:i$ >> -> [i]
+ | t ->
+ raise_with_loc (loc_of_node t)
+ (Stream.Error "lowercase identifier expected") ]
+;
+
+value class_fun_binding = Grammar.Entry.create gram "class_fun_binding";
+
+EXTEND
+ GLOBAL: str_item sig_item expr ctyp class_sig_item class_str_item class_type
+ class_expr class_fun_binding;
+ str_item:
+ [ [ "class"; cd = LIST1 class_declaration SEP "and" ->
+ <:str_item< class $list:cd$ >>
+ | "class"; "type"; ctd = LIST1 class_type_declaration SEP "and" ->
+ <:str_item< class type $list:ctd$ >> ] ]
+ ;
+ sig_item:
+ [ [ "class"; cd = LIST1 class_description SEP "and" ->
+ <:sig_item< class $list:cd$ >>
+ | "class"; "type"; ctd = LIST1 class_type_declaration SEP "and" ->
+ <:sig_item< class type $list:ctd$ >> ] ]
+ ;
+ (* Class expressions *)
+ class_declaration:
+ [ [ vf = OPT "virtual"; ctp = class_type_parameters; i = LIDENT;
+ cfb = class_fun_binding ->
+ {MLast.ciLoc = loc; MLast.ciVir = o2b vf; MLast.ciPrm = ctp;
+ MLast.ciNam = i; MLast.ciExp = cfb} ] ]
+ ;
+ class_fun_binding:
+ [ [ "="; ce = class_expr -> ce
+ | ":"; ct = class_type; "="; ce = class_expr ->
+ <:class_expr< ($ce$ : $ct$) >>
+ | p = patt LEVEL "simple"; cfb = SELF ->
+ <:class_expr< fun $p$ -> $cfb$ >> ] ]
+ ;
+ class_type_parameters:
+ [ [ -> (loc, [])
+ | "["; tpl = LIST1 type_parameter SEP ","; "]" -> (loc, tpl) ] ]
+ ;
+ class_fun_def:
+ [ [ p = patt LEVEL "simple"; "->"; ce = class_expr ->
+ <:class_expr< fun $p$ -> $ce$ >>
+ | p = patt LEVEL "simple"; cfd = SELF ->
+ <:class_expr< fun $p$ -> $cfd$ >> ] ]
+ ;
+ class_expr:
+ [ "top"
+ [ "fun"; cfd = class_fun_def -> cfd
+ | "let"; rf = OPT "rec"; lb = LIST1 let_binding SEP "and"; "in";
+ ce = SELF ->
+ <:class_expr< let $opt:o2b rf$ $list:lb$ in $ce$ >> ]
+ | "apply" NONA
+ [ ce = SELF; e = expr LEVEL "label" ->
+ <:class_expr< $ce$ $e$ >> ]
+ | "simple"
+ [ "["; ct = ctyp; ","; ctcl = LIST1 ctyp SEP ","; "]";
+ ci = class_longident ->
+ <:class_expr< $list:ci$ [ $list:[ct :: ctcl]$ ] >>
+ | "["; ct = ctyp; "]"; ci = class_longident ->
+ <:class_expr< $list:ci$ [ $ct$ ] >>
+ | ci = class_longident -> <:class_expr< $list:ci$ >>
+ | "object"; cspo = OPT class_self_patt; cf = class_structure; "end" ->
+ <:class_expr< object $opt:cspo$ $list:cf$ end >>
+ | "("; ce = SELF; ":"; ct = class_type; ")" ->
+ <:class_expr< ($ce$ : $ct$) >>
+ | "("; ce = SELF; ")" -> ce ] ]
+ ;
+ class_structure:
+ [ [ cf = LIST0 class_str_item -> cf ] ]
+ ;
+ class_self_patt:
+ [ [ "("; p = patt; ")" -> p
+ | "("; p = patt; ":"; t = ctyp; ")" -> <:patt< ($p$ : $t$) >> ] ]
+ ;
+ class_str_item:
+ [ [ "inherit"; ce = class_expr; pb = OPT [ "as"; i = LIDENT -> i ] ->
+ <:class_str_item< inherit $ce$ $opt:pb$ >>
+ | "val"; (lab, mf, e) = cvalue ->
+ <:class_str_item< value $opt:mf$ $lab$ = $e$ >>
+ | "method"; "private"; "virtual"; l = label; ":"; t = ctyp ->
+ <:class_str_item< method virtual private $l$ : $t$ >>
+ | "method"; "virtual"; "private"; l = label; ":"; t = ctyp ->
+ <:class_str_item< method virtual private $l$ : $t$ >>
+ | "method"; "virtual"; l = label; ":"; t = ctyp ->
+ <:class_str_item< method virtual $l$ : $t$ >>
+ | "method"; "private"; l = label; fb = fun_binding ->
+ <:class_str_item< method private $l$ = $fb$ >>
+ | "method"; l = label; fb = fun_binding ->
+ <:class_str_item< method $l$ = $fb$ >>
+ | "constraint"; t1 = ctyp; "="; t2 = ctyp ->
+ <:class_str_item< type $t1$ = $t2$ >>
+ | "initializer"; se = expr -> <:class_str_item< initializer $se$ >> ] ]
+ ;
+ cvalue:
+ [ [ mf = OPT "mutable"; l = label; "="; e = expr -> (l, o2b mf, e)
+ | mf = OPT "mutable"; l = label; ":"; t = ctyp; "="; e = expr ->
+ (l, o2b mf, <:expr< ($e$ : $t$) >>)
+ | mf = OPT "mutable"; l = label; ":"; t1 = ctyp; ":>"; t2 = ctyp; "=";
+ e = expr ->
+ (l, o2b mf, <:expr< ($e$ : $t1$ :> $t2$) >>)
+ | mf = OPT "mutable"; l = label; ":>"; t = ctyp; "="; e = expr ->
+ (l, o2b mf, <:expr< ($e$ :> $t$) >>) ] ]
+ ;
+ label:
+ [ [ i = LIDENT -> i ] ]
+ ;
+ (* Class types *)
+ class_type:
+ [ [ t = ctyp LEVEL "ctyp1" -> class_type_of_ctyp loc t
+ | t = ctyp LEVEL "ctyp1"; "->"; ct = SELF ->
+ <:class_type< [ $t$ ] -> $ct$ >>
+ | t = ctyp LEVEL "ctyp1"; "*"; tl = LIST1 ctyp LEVEL "simple" SEP "*";
+ "->"; ct = SELF ->
+ <:class_type< [ ($t$ * $list:tl$) ] -> $ct$ >>
+ | cs = class_signature -> cs ] ]
+ ;
+ class_signature:
+ [ [ "["; tl = LIST1 ctyp SEP ","; "]"; id = clty_longident ->
+ <:class_type< $list:id$ [ $list:tl$ ] >>
+ | id = clty_longident -> <:class_type< $list:id$ >>
+ | "object"; cst = OPT class_self_type; csf = LIST0 class_sig_item;
+ "end" ->
+ <:class_type< object $opt:cst$ $list:csf$ end >> ] ]
+ ;
+ class_self_type:
+ [ [ "("; t = ctyp; ")" -> t ] ]
+ ;
+ class_sig_item:
+ [ [ "inherit"; cs = class_signature -> <:class_sig_item< inherit $cs$ >>
+ | "val"; mf = OPT "mutable"; l = label; ":"; t = ctyp ->
+ <:class_sig_item< value $opt:o2b mf$ $l$ : $t$ >>
+ | "method"; "private"; "virtual"; l = label; ":"; t = ctyp ->
+ <:class_sig_item< method virtual private $l$ : $t$ >>
+ | "method"; "virtual"; "private"; l = label; ":"; t = ctyp ->
+ <:class_sig_item< method virtual private $l$ : $t$ >>
+ | "method"; "virtual"; l = label; ":"; t = ctyp ->
+ <:class_sig_item< method virtual $l$ : $t$ >>
+ | "method"; "private"; l = label; ":"; t = ctyp ->
+ <:class_sig_item< method private $l$ : $t$ >>
+ | "method"; l = label; ":"; t = ctyp ->
+ <:class_sig_item< method $l$ : $t$ >>
+ | "constraint"; t1 = ctyp; "="; t2 = ctyp ->
+ <:class_sig_item< type $t1$ = $t2$ >> ] ]
+ ;
+ class_description:
+ [ [ vf = OPT "virtual"; ctp = class_type_parameters; n = LIDENT; ":";
+ ct = class_type ->
+ {MLast.ciLoc = loc; MLast.ciVir = o2b vf; MLast.ciPrm = ctp;
+ MLast.ciNam = n; MLast.ciExp = ct}
+ | vf = OPT "virtual"; ctp = class_type_parameters; n = LABEL;
+ ct = class_type ->
+ {MLast.ciLoc = loc; MLast.ciVir = o2b vf; MLast.ciPrm = ctp;
+ MLast.ciNam = n; MLast.ciExp = ct} ] ]
+ ;
+ class_type_declaration:
+ [ [ vf = OPT "virtual"; ctp = class_type_parameters; n = LIDENT; "=";
+ cs = class_signature ->
+ {MLast.ciLoc = loc; MLast.ciVir = o2b vf; MLast.ciPrm = ctp;
+ MLast.ciNam = n; MLast.ciExp = cs} ] ]
+ ;
+ (* Expressions *)
+ expr: LEVEL "apply"
+ [ LEFTA
+ [ "new"; i = class_longident -> <:expr< new $list:i$ >> ] ]
+ ;
+ expr: LEVEL "simple"
+ [ [ e = SELF; "#"; lab = label -> <:expr< $e$ # $lab$ >> ] ]
+ ;
+ expr: LEVEL "simple"
+ [ [ "("; e = SELF; ":"; t1 = ctyp; ":>"; t2 = ctyp; ")" ->
+ <:expr< ($e$ : $t1$ :> $t2$) >>
+ | "("; e = SELF; ":>"; t = ctyp; ")" -> <:expr< ($e$ :> $t$) >>
+ | "{<"; ">}" -> <:expr< {< >} >>
+ | "{<"; fel = field_expr_list; ">}" -> <:expr< {< $list:fel$ >} >> ] ]
+ ;
+ field_expr_list:
+ [ [ l = label; "="; e = expr LEVEL "expr1"; ";"; fel = SELF ->
+ [(l, e) :: fel]
+ | l = label; "="; e = expr LEVEL "expr1"; ";" -> [(l, e)]
+ | l = label; "="; e = expr LEVEL "expr1" -> [(l, e)] ] ]
+ ;
+ (* Core types *)
+ ctyp: LEVEL "simple"
+ [ [ "#"; id = class_longident -> <:ctyp< # $list:id$ >>
+ | "<"; (ml, v) = meth_list; ">" -> <:ctyp< < $list:ml$ $opt:v$ > >>
+ | "<"; ">" -> <:ctyp< < > >> ] ]
+ ;
+ meth_list:
+ [ [ f = field; ";"; (ml, v) = SELF -> ([f :: ml], v)
+ | f = field; ";" -> ([f], False)
+ | f = field -> ([f], False)
+ | ".." -> ([], True) ] ]
+ ;
+ field:
+ [ [ lab = LIDENT; ":"; t = ctyp -> (lab, t)
+ | lab = LABEL; t = ctyp -> (lab, t) ] ]
+ ;
+ (* Identifiers *)
+ clty_longident:
+ [ [ m = UIDENT; "."; l = SELF -> [m :: l]
+ | i = LIDENT -> [i] ] ]
+ ;
+ class_longident:
+ [ [ m = UIDENT; "."; l = SELF -> [m :: l]
+ | i = LIDENT -> [i] ] ]
+ ;
+END;
+
+(* Labels *)
+
+EXTEND
+ GLOBAL: ctyp expr patt fun_def fun_binding class_type class_fun_binding;
+ ctyp: AFTER "arrow"
+ [ NONA
+ [ i = LABEL; t = SELF -> <:ctyp< ~ $i$ : $t$ >>
+ | "?"; i = LABEL; t = SELF -> <:ctyp< ? $i$ : $t$ >> ] ]
+ ;
+ ctyp: LEVEL "simple"
+ [ [ "["; OPT "|"; rfl = LIST0 row_field SEP "|"; "]" ->
+ <:ctyp< [ = $list:rfl$ ] >>
+ | "["; ">"; OPT "|"; rfl = LIST1 row_field SEP "|"; "]" ->
+ <:ctyp< [ > $list:rfl$ ] >>
+ | "[<"; OPT "|"; rfl = LIST1 row_field SEP "|"; "]" ->
+ <:ctyp< [ < $list:rfl$ ] >>
+ | "[<"; OPT "|"; rfl = LIST1 row_field SEP "|"; ">";
+ ntl = LIST1 name_tag; "]" ->
+ <:ctyp< [ < $list:rfl$ > $list:ntl$ ] >> ] ]
+ ;
+ row_field:
+ [ [ "`"; i = ident -> MLast.RfTag i False []
+ | "`"; i = ident; "of"; ao = OPT "&"; l = LIST1 ctyp SEP "&" ->
+ MLast.RfTag i (o2b ao) l
+ | "`"; i = ident; "&"; l = LIST1 ctyp SEP "&" -> MLast.RfTag i True l
+ | "`"; i = ident; l = LIST1 ctyp SEP "&" -> MLast.RfTag i False l ] ]
+ ;
+ name_tag:
+ [ [ "`"; i = ident -> i ] ]
+ ;
+ expr: LEVEL "expr1"
+ [ [ "fun"; p = labeled_patt; e = fun_def -> <:expr< fun $p$ -> $e$ >> ] ]
+ ;
+ expr: AFTER "apply"
+ [ "label"
+ [ i = LABEL; e = SELF -> <:expr< ~ $i$ : $e$ >>
+ | i = ELABEL -> <:expr< ~ $i$ >>
+ | "?"; i = LABEL; e = SELF -> <:expr< ? $i$ : $e$ >>
+ | "?"; i = ELABEL -> <:expr< ? $i$ >> ] ]
+ ;
+ expr: LEVEL "simple"
+ [ [ "`"; s = ident -> <:expr< ` $s$ >> ] ]
+ ;
+ fun_def:
+ [ [ p = labeled_patt; e = SELF -> <:expr< fun $p$ -> $e$ >> ] ]
+ ;
+ fun_binding:
+ [ [ p = labeled_patt; e = SELF -> <:expr< fun $p$ -> $e$ >> ] ]
+ ;
+ patt: LEVEL "simple"
+ [ [ "`"; s = ident -> <:patt< ` $s$ >> ] ]
+ ;
+ labeled_patt:
+ [ [ i = LABEL; p = patt LEVEL "simple" -> <:patt< ~ $i$ : $p$ >>
+ | i = ELABEL -> <:patt< ~ $i$ >>
+ | "?"; i = LABEL; j = LIDENT -> <:patt< ? $i$ : ($lid:j$) >>
+ | "?"; "("; i = LABEL; j = LIDENT; ")" -> <:patt< ? $i$ : ($lid:j$) >>
+ | "?"; "("; i = LABEL; j = LIDENT; "="; e = expr; ")" ->
+ <:patt< ? $i$ : ( $lid:j$ = $e$ ) >>
+ | "?"; i = ELABEL -> <:patt< ? $i$ : ($lid:i$) >>
+ | "?"; "("; i = ELABEL; "="; e = expr; ")" ->
+ <:patt< ? $i$ : ( $lid:i$ = $e$ ) >> ] ]
+ ;
+ class_type:
+ [ [ i = LABEL; t = ctyp LEVEL "ctyp1"; "->"; ct = SELF ->
+ <:class_type< [ ~ $i$ : $t$ ] -> $ct$ >>
+ | "?"; i = LABEL; t = ctyp LEVEL "ctyp1"; "->"; ct = SELF ->
+ <:class_type< [ ? $i$ : $t$ ] -> $ct$ >> ] ]
+ ;
+ class_fun_binding:
+ [ [ p = labeled_patt; cfb = SELF -> <:class_expr< fun $p$ -> $cfb$ >> ] ]
+ ;
+ ident:
+ [ [ i = LIDENT -> i
+ | i = UIDENT -> i ] ]
+ ;
+END;
+
+type spat_comp =
+ [ SpTrm of Loc.t and MLast.patt and option MLast.expr
+ | SpNtr of Loc.t and MLast.patt and MLast.expr
+ | SpStr of Loc.t and MLast.patt ]
+;
+type sexp_comp =
+ [ SeTrm of Loc.t and MLast.expr | SeNtr of Loc.t and MLast.expr ]
+;
+
+value strm_n = "__strm";
+value peek_fun loc = <:expr< Stream.peek >>;
+value junk_fun loc = <:expr< Stream.junk >>;
+
+(* Parsers. *)
+(* In syntax generated, many cases are optimisations. *)
+
+value rec pattern_eq_expression p e =
+ match (p, e) with
+ [ (<:patt< $lid:a$ >>, <:expr< $lid:b$ >>) -> a = b
+ | (<:patt< $uid:a$ >>, <:expr< $uid:b$ >>) -> a = b
+ | (<:patt< $p1$ $p2$ >>, <:expr< $e1$ $e2$ >>) ->
+ pattern_eq_expression p1 e1 && pattern_eq_expression p2 e2
+ | _ -> False ]
+;
+
+value is_raise e =
+ match e with
+ [ <:expr< raise $_$ >> -> True
+ | _ -> False ]
+;
+
+value is_raise_failure e =
+ match e with
+ [ <:expr< raise Stream.Failure >> -> True
+ | _ -> False ]
+;
+
+value rec handle_failure e =
+ match e with
+ [ <:expr< try $te$ with [ Stream.Failure -> $e$] >> -> handle_failure e
+ | <:expr< match $me$ with [ $list:pel$ ] >> ->
+ handle_failure me &&
+ List.for_all
+ (fun
+ [ (_, None, e) -> handle_failure e
+ | _ -> False ])
+ pel
+ | <:expr< let $list:pel$ in $e$ >> ->
+ List.for_all (fun (p, e) -> handle_failure e) pel && handle_failure e
+ | <:expr< $lid:_$ >> | <:expr< $int:_$ >> | <:expr< $str:_$ >> |
+ <:expr< $chr:_$ >> | <:expr< fun [ $list:_$ ] >> | <:expr< $uid:_$ >> ->
+ True
+ | <:expr< raise $e$ >> ->
+ match e with
+ [ <:expr< Stream.Failure >> -> False
+ | _ -> True ]
+ | <:expr< $f$ $x$ >> ->
+ is_constr_apply f && handle_failure f && handle_failure x
+ | _ -> False ]
+and is_constr_apply =
+ fun
+ [ <:expr< $uid:_$ >> -> True
+ | <:expr< $lid:_$ >> -> False
+ | <:expr< $x$ $_$ >> -> is_constr_apply x
+ | _ -> False ]
+;
+
+value rec subst v e =
+ let loc = MLast.loc_of_expr e in
+ match e with
+ [ <:expr< $lid:x$ >> ->
+ let x = if x = v then strm_n else x in
+ <:expr< $lid:x$ >>
+ | <:expr< $uid:_$ >> -> e
+ | <:expr< $int:_$ >> -> e
+ | <:expr< $chr:_$ >> -> e
+ | <:expr< $str:_$ >> -> e
+ | <:expr< $_$ . $_$ >> -> e
+ | <:expr< let $opt:rf$ $list:pel$ in $e$ >> ->
+ <:expr< let $opt:rf$ $list:List.map (subst_pe v) pel$ in $subst v e$ >>
+ | <:expr< $e1$ $e2$ >> -> <:expr< $subst v e1$ $subst v e2$ >>
+ | <:expr< ( $list:el$ ) >> -> <:expr< ( $list:List.map (subst v) el$ ) >>
+ | _ -> raise Not_found ]
+and subst_pe v (p, e) =
+ match p with
+ [ <:patt< $lid:v'$ >> -> if v = v' then (p, e) else (p, subst v e)
+ | _ -> raise Not_found ]
+;
+
+value stream_pattern_component skont ckont =
+ fun
+ [ SpTrm loc p wo ->
+ <:expr< match $peek_fun loc$ $lid:strm_n$ with
+ [ Some $p$ $when:wo$ ->
+ do { $junk_fun loc$ $lid:strm_n$; $skont$ }
+ | _ -> $ckont$ ] >>
+ | SpNtr loc p e ->
+ let e =
+ match e with
+ [ <:expr< fun [ ($lid:v$ : Stream.t _) -> $e$ ] >> when v = strm_n ->
+ e
+ | _ -> <:expr< $e$ $lid:strm_n$ >> ]
+ in
+ if pattern_eq_expression p skont then
+ if is_raise_failure ckont then e
+ else if handle_failure e then e
+ else <:expr< try $e$ with [ Stream.Failure -> $ckont$ ] >>
+ else if is_raise_failure ckont then <:expr< let $p$ = $e$ in $skont$ >>
+ else if pattern_eq_expression <:patt< Some $p$ >> skont then
+ <:expr< try Some $e$ with [ Stream.Failure -> $ckont$ ] >>
+ else if is_raise ckont then
+ let tst =
+ if handle_failure e then e
+ else <:expr< try $e$ with [ Stream.Failure -> $ckont$ ] >>
+ in
+ <:expr< let $p$ = $tst$ in $skont$ >>
+ else
+ <:expr< match try Some $e$ with [ Stream.Failure -> None ] with
+ [ Some $p$ -> $skont$
+ | _ -> $ckont$ ] >>
+ | SpStr loc p ->
+ try
+ match p with
+ [ <:patt< $lid:v$ >> -> subst v skont
+ | _ -> raise Not_found ]
+ with
+ [ Not_found -> <:expr< let $p$ = $lid:strm_n$ in $skont$ >> ] ]
+;
+
+value rec stream_pattern loc epo e ekont =
+ fun
+ [ [] ->
+ match epo with
+ [ Some ep -> <:expr< let $ep$ = Stream.count $lid:strm_n$ in $e$ >>
+ | _ -> e ]
+ | [(spc, err) :: spcl] ->
+ let skont =
+ let ekont err =
+ let str =
+ match err with
+ [ Some estr -> estr
+ | _ -> <:expr< "" >> ]
+ in
+ <:expr< raise (Stream.Error $str$) >>
+ in
+ stream_pattern loc epo e ekont spcl
+ in
+ let ckont = ekont err in
+ stream_pattern_component skont ckont spc ]
+;
+
+value stream_patterns_term loc ekont tspel =
+ let pel =
+ List.map
+ (fun (p, w, loc, spcl, epo, e) ->
+ let p = <:patt< Some $p$ >> in
+ let e =
+ let ekont err =
+ let str =
+ match err with
+ [ Some estr -> estr
+ | _ -> <:expr< "" >> ]
+ in
+ <:expr< raise (Stream.Error $str$) >>
+ in
+ let skont = stream_pattern loc epo e ekont spcl in
+ <:expr< do { $junk_fun loc$ $lid:strm_n$; $skont$ } >>
+ in
+ (p, w, e))
+ tspel
+ in
+ let pel = pel @ [(<:patt< _ >>, None, ekont ())] in
+ <:expr< match $peek_fun loc$ $lid:strm_n$ with [ $list:pel$ ] >>
+;
+
+value rec group_terms =
+ fun
+ [ [([(SpTrm loc p w, None) :: spcl], epo, e) :: spel] ->
+ let (tspel, spel) = group_terms spel in
+ ([(p, w, loc, spcl, epo, e) :: tspel], spel)
+ | spel -> ([], spel) ]
+;
+
+value rec parser_cases loc =
+ fun
+ [ [] -> <:expr< raise Stream.Failure >>
+ | spel ->
+ match group_terms spel with
+ [ ([], [(spcl, epo, e) :: spel]) ->
+ stream_pattern loc epo e (fun _ -> parser_cases loc spel) spcl
+ | (tspel, spel) ->
+ stream_patterns_term loc (fun _ -> parser_cases loc spel) tspel ] ]
+;
+
+value cparser loc bpo pc =
+ let e = parser_cases loc pc in
+ let e =
+ match bpo with
+ [ Some bp -> <:expr< let $bp$ = Stream.count $lid:strm_n$ in $e$ >>
+ | None -> e ]
+ in
+ let p = <:patt< ($lid:strm_n$ : Stream.t _) >> in
+ <:expr< fun $p$ -> $e$ >>
+;
+
+value cparser_match loc me bpo pc =
+ let pc = parser_cases loc pc in
+ let e =
+ match bpo with
+ [ Some bp -> <:expr< let $bp$ = Stream.count $lid:strm_n$ in $pc$ >>
+ | None -> pc ]
+ in
+ <:expr< let $lid:strm_n$ = $me$ in $e$ >>
+;
+
+(* streams *)
+
+value rec not_computing =
+ fun
+ [ <:expr< $lid:_$ >> | <:expr< $uid:_$ >> | <:expr< $int:_$ >> |
+ <:expr< $flo:_$ >> | <:expr< $chr:_$ >> | <:expr< $str:_$ >> ->
+ True
+ | <:expr< $x$ $y$ >> -> is_cons_apply_not_computing x && not_computing y
+ | _ -> False ]
+and is_cons_apply_not_computing =
+ fun
+ [ <:expr< $uid:_$ >> -> True
+ | <:expr< $lid:_$ >> -> False
+ | <:expr< $x$ $y$ >> -> is_cons_apply_not_computing x && not_computing y
+ | _ -> False ]
+;
+
+value slazy loc e =
+ match e with
+ [ <:expr< $f$ () >> ->
+ match f with
+ [ <:expr< $lid:_$ >> -> f
+ | _ -> <:expr< fun _ -> $e$ >> ]
+ | _ -> <:expr< fun _ -> $e$ >> ]
+;
+
+value rec cstream gloc =
+ fun
+ [ [] ->
+ let loc = gloc in
+ <:expr< Stream.sempty >>
+ | [SeTrm loc e] ->
+ if not_computing e then <:expr< Stream.ising $e$ >>
+ else <:expr< Stream.lsing $slazy loc e$ >>
+ | [SeTrm loc e :: secl] ->
+ if not_computing e then <:expr< Stream.icons $e$ $cstream gloc secl$ >>
+ else <:expr< Stream.lcons $slazy loc e$ $cstream gloc secl$ >>
+ | [SeNtr loc e] ->
+ if not_computing e then e else <:expr< Stream.slazy $slazy loc e$ >>
+ | [SeNtr loc e :: secl] ->
+ if not_computing e then <:expr< Stream.iapp $e$ $cstream gloc secl$ >>
+ else <:expr< Stream.lapp $slazy loc e$ $cstream gloc secl$ >> ]
+;
+
+(* Syntax extensions in Ocaml grammar *)
+
+EXTEND
+ GLOBAL: expr;
+ expr: LEVEL "expr1"
+ [ [ "parser"; po = OPT ipatt; OPT "|"; pcl = LIST1 parser_case SEP "|" ->
+ <:expr< $cparser loc po pcl$ >>
+ | "match"; e = SELF; "with"; "parser"; po = OPT ipatt; OPT "|";
+ pcl = LIST1 parser_case SEP "|" ->
+ <:expr< $cparser_match loc e po pcl$ >> ] ]
+ ;
+ parser_case:
+ [ [ "[<"; sp = stream_patt; ">]"; po = OPT ipatt; "->"; e = expr ->
+ (sp, po, e) ] ]
+ ;
+ stream_patt:
+ [ [ spc = stream_patt_comp -> [(spc, None)]
+ | spc = stream_patt_comp; ";" -> [(spc, None)]
+ | spc = stream_patt_comp; ";"; sp = stream_patt_comp_err_list ->
+ [(spc, None) :: sp]
+ | -> (* empty *) [] ] ]
+ ;
+ stream_patt_comp_err_list:
+ [ [ spc = stream_patt_comp_err -> [spc]
+ | spc = stream_patt_comp_err; ";" -> [spc]
+ | spc = stream_patt_comp_err; ";"; sp = SELF -> [spc :: sp] ] ]
+ ;
+ stream_patt_comp:
+ [ [ "'"; p = patt; eo = OPT [ "when"; e = expr LEVEL "expr1" -> e ] ->
+ SpTrm loc p eo
+ | p = patt; "="; e = expr LEVEL "expr1" -> SpNtr loc p e
+ | p = patt -> SpStr loc p ] ]
+ ;
+ stream_patt_comp_err:
+ [ [ spc = stream_patt_comp;
+ eo = OPT [ "?"; e = expr LEVEL "expr1" -> e ] ->
+ (spc, eo) ] ]
+ ;
+ ipatt:
+ [ [ i = LIDENT -> <:patt< $lid:i$ >> ] ]
+ ;
+ expr: LEVEL "simple"
+ [ [ "[<"; ">]" -> <:expr< $cstream loc []$ >>
+ | "[<"; sel = stream_expr_comp_list; ">]" ->
+ <:expr< $cstream loc sel$ >> ] ]
+ ;
+ stream_expr_comp_list:
+ [ [ se = stream_expr_comp; ";"; sel = SELF -> [se :: sel]
+ | se = stream_expr_comp; ";" -> [se]
+ | se = stream_expr_comp -> [se] ] ]
+ ;
+ stream_expr_comp:
+ [ [ "'"; e = expr LEVEL "expr1" -> SeTrm loc e
+ | e = expr LEVEL "expr1" -> SeNtr loc e ] ]
+ ;
+END;
--- /dev/null
+#########################################################################
+# #
+# Objective Caml #
+# #
+# Camlp4 #
+# #
+# Copyright 2004 Institut National de Recherche en Informatique et #
+# en Automatique. All rights reserved. This file is distributed #
+# under the terms of the Q Public License version 1.0. #
+# #
+#########################################################################
+#
+# Makefile for pa_lefteval
+# M.Mauny
+#
+
+include ../../config/Makefile.cnf
+
+OCAMLTOP=../../..
+CAMLP4=../../camlp4/camlp4$(EXE)
+
+OCAMLC=$(OCAMLTOP)/ocamlc$(EXE)
+OCAMLOPT=$(OCAMLTOP)/ocamlopt$(EXE)
+
+P4INCLUDES= -nolib -I ../../meta -I ../../etc
+OCAMLINCLUDES= -nostdlib -I $(OCAMLTOP)/stdlib -I ../../camlp4 -I ../../lib -I ../../etc
+OCAMLCFLAGS=-warn-error A $(OCAMLINCLUDES)
+
+SCHSRC=pa_scheme.sc
+SRC=pa_scheme.ml pr_scheme.ml pr_schp_main.ml
+OBJS=$(SRC:.ml=.cmo)
+OBJSX=$(OCAMLSRC:.ml=.cmx)
+
+all: $(OBJS) pr_schemep.cmo camlp4sch$(EXE)
+
+opt: all
+
+bootstrap: camlp4sch$(EXE) save
+ ./camlp4sch$(EXE) ../../etc/q_phony.cmo ../../meta/pa_extend.cmo ../../etc/pr_r.cmo ../../etc/pr_extend.cmo ../../etc/pr_rp.cmo -impl pa_scheme.sc \
+ | sed -e 's/^;; \(.*\)$$/(* \1 *)/' -e 's/^; \(.*\)$$/(* \1 *)/' \
+ -e 's/$$Id.*\$$/File generated by pretty print; do not edit!/' > pa_scheme.ml
+ @if cmp -s pa_scheme.ml SAVED/pa_scheme.ml; then \
+ echo 'pa_scheme.ml and SAVED/pa_scheme.ml are identical' ; \
+ else \
+ echo '**** Note: pa_scheme.ml differs from SAVED/pa_scheme.ml'; \
+ fi
+
+save:
+ test -d SAVED || mkdir SAVED
+ mkdir SAVED.$$$$ && mv SAVED pa_scheme.ml SAVED.$$$$ && mv SAVED.$$$$ SAVED
+
+restore:
+ mv SAVED SAVED.$$$$ && mv SAVED.$$$$/* . && rmdir SAVED.$$$$
+
+depend:
+ cp .depend .depend.bak
+ > .depend
+ for file in $(SRC); do \
+ $(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $$file` pr_depend.cmo $$i | \
+ sed -e 's| \.\./\.\./\.\.| $$(OCAMLTOP)|g' >> .depend; \
+ done
+
+clean:
+ rm -f camlp4sch$(EXE) *.cm* *.$(O) *.bak .*.bak
+
+camlp4sch: pa_scheme.cmo
+ rm -f camlp4sch
+ DIR=`pwd` && cd ../../camlp4 && $(MAKE) CAMLP4=$$DIR/camlp4sch CAMLP4M="-I $$DIR pa_scheme.cmo ../meta/pr_dump.cmo"
+
+pr_schemep.cmo: pr_schp_main.cmo
+ $(OCAMLC) ../../etc/parserify.cmo pr_schp_main.cmo -a -o $@
+
+.SUFFIXES: .cmx .cmo .cmi .ml .mli
+
+.mli.cmi:
+ $(OCAMLC) $(OCAMLCFLAGS) -c $<
+
+
+.ml.cmo:
+ $(OCAMLC) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<` -loc loc" -c $<
+
+.ml.cmx:
+ $(OCAMLOPT) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<` -loc loc" -c $<
+
+include .depend
--- /dev/null
+This is an application of or an extension for Camlp4. Although it is
+currently distributed with OCaml/Camlp4, it may or may not be
+actively maintained.
+
+It probably won't be part of future OCaml/Camlp4 distributions but be
+accessible from the Camlp4 hump. If you are interested in developing
+this package further and/or actively maintain it, please let us know
+(caml@inria.fr)
+
+This package is distributed under the same license as the Objective
+Caml Library (that is, LGPL with a special exception allowing both
+static and dynamic link).
+
+-- Michel Mauny
+
--- /dev/null
+(* pa_r.cmo pa_rp.cmo pa_extend.cmo q_MLast.cmo pr_dump.cmo *)
+(* ********************************************************************** *)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 2002 Institut National de Recherche en Informatique et *)
+(* en Automatique. All rights reserved. This file is distributed *)
+(* under the terms of the GNU Library General Public License, with *)
+(* the special exception on linking described in file *)
+(* ../../../LICENSE. *)
+(* *)
+(* ********************************************************************** *)
+(* File generated by pretty print; do not edit! *)
+
+open Pcaml;
+open Stdpp;
+
+type choice 'a 'b =
+ [ Left of 'a
+ | Right of 'b ]
+;
+
+(* Buffer *)
+
+module Buff =
+ struct
+ value buff = ref (String.create 80);
+ value store len x =
+ do {
+ if len >= String.length buff.val then
+ buff.val := buff.val ^ String.create (String.length buff.val)
+ else ();
+ buff.val.[len] := x;
+ succ len
+ }
+ ;
+ value get len = String.sub buff.val 0 len;
+ end
+;
+
+(* Lexer *)
+
+value rec skip_to_eol =
+ parser
+ [ [: `'\n' | '\r' :] -> ()
+ | [: `_; s :] -> skip_to_eol s ]
+;
+
+value no_ident = ['('; ')'; '['; ']'; '{'; '}'; ' '; '\t'; '\n'; '\r'; ';'];
+
+value rec ident len =
+ parser
+ [ [: `'.' :] -> (Buff.get len, True)
+ | [: `x when not (List.mem x no_ident); s :] -> ident (Buff.store len x) s
+ | [: :] -> (Buff.get len, False) ]
+;
+
+value identifier kwt (s, dot) =
+ let con =
+ try do { (Hashtbl.find kwt s : unit); "" } with
+ [ Not_found ->
+ match s.[0] with
+ [ 'A'..'Z' -> if dot then "UIDENTDOT" else "UIDENT"
+ | _ -> if dot then "LIDENTDOT" else "LIDENT" ] ]
+ in
+ (con, s)
+;
+
+value rec string len =
+ parser
+ [ [: `'"' :] -> Buff.get len
+ | [: `'\\'; `c; s :] -> string (Buff.store (Buff.store len '\\') c) s
+ | [: `x; s :] -> string (Buff.store len x) s ]
+;
+
+value rec end_exponent_part_under len =
+ parser
+ [ [: `('0'..'9' as c); s :] -> end_exponent_part_under (Buff.store len c) s
+ | [: :] -> ("FLOAT", Buff.get len) ]
+;
+
+value end_exponent_part len =
+ parser
+ [ [: `('0'..'9' as c); s :] -> end_exponent_part_under (Buff.store len c) s
+ | [: :] -> raise (Stream.Error "ill-formed floating-point constant") ]
+;
+
+value exponent_part len =
+ parser
+ [ [: `('+' | '-' as c); s :] -> end_exponent_part (Buff.store len c) s
+ | [: a = end_exponent_part len :] -> a ]
+;
+
+value rec decimal_part len =
+ parser
+ [ [: `('0'..'9' as c); s :] -> decimal_part (Buff.store len c) s
+ | [: `'e' | 'E'; s :] -> exponent_part (Buff.store len 'E') s
+ | [: :] -> ("FLOAT", Buff.get len) ]
+;
+
+value rec number len =
+ parser
+ [ [: `('0'..'9' as c); s :] -> number (Buff.store len c) s
+ | [: `'.'; s :] -> decimal_part (Buff.store len '.') s
+ | [: `'e' | 'E'; s :] -> exponent_part (Buff.store len 'E') s
+ | [: :] -> ("INT", Buff.get len) ]
+;
+
+value binary = parser [: `('0'..'1' as c) :] -> c;
+
+value octal = parser [: `('0'..'7' as c) :] -> c;
+
+value hexa = parser [: `('0'..'9' | 'a'..'f' | 'A'..'F' as c) :] -> c;
+
+value rec digits_under kind len =
+ parser
+ [ [: d = kind; s :] -> digits_under kind (Buff.store len d) s
+ | [: :] -> Buff.get len ]
+;
+
+value digits kind bp len =
+ parser
+ [ [: d = kind; s :] -> ("INT", digits_under kind (Buff.store len d) s)
+ | [: s :] ep ->
+ raise_with_loc
+ (Reloc.shift_pos bp Reloc.zero_loc, Reloc.shift_pos ep Reloc.zero_loc)
+ (Failure "ill-formed integer constant") ]
+;
+
+value base_number kwt bp len =
+ parser
+ [ [: `'b' | 'B'; s :] -> digits binary bp (Buff.store len 'b') s
+ | [: `'o' | 'O'; s :] -> digits octal bp (Buff.store len 'o') s
+ | [: `'x' | 'X'; s :] -> digits hexa bp (Buff.store len 'x') s
+ | [: id = ident (Buff.store 0 '#') :] -> identifier kwt id ]
+;
+
+value rec operator len =
+ parser
+ [ [: `'.' :] -> Buff.get (Buff.store len '.')
+ | [: :] -> Buff.get len ]
+;
+
+value char_or_quote_id x =
+ parser
+ [ [: `''' :] -> ("CHAR", String.make 1 x)
+ | [: s :] ep ->
+ if List.mem x no_ident then
+ Stdpp.raise_with_loc
+ (Reloc.shift_pos (ep - 2) Reloc.zero_loc,
+ Reloc.shift_pos (ep - 1) Reloc.zero_loc)
+ (Stream.Error "bad quote")
+ else
+ let len = Buff.store (Buff.store 0 ''') x in
+ let (s, dot) = ident len s in
+ (if dot then "LIDENTDOT" else "LIDENT", s) ]
+;
+
+value rec char len =
+ parser
+ [ [: `''' :] -> len
+ | [: `x; s :] -> char (Buff.store len x) s ]
+;
+
+value quote =
+ parser
+ [ [: `'\\'; len = char (Buff.store 0 '\\') :] -> ("CHAR", Buff.get len)
+ | [: `x; s :] -> char_or_quote_id x s ]
+;
+
+(* The system with LIDENTDOT and UIDENTDOT is not great (it would be *)
+(* better to have a token DOT (actually SPACEDOT and DOT)) but it is *)
+(* the only way (that I have found) to have a good behaviour in the *)
+(* toplevel (not expecting tokens after a phrase). Drawbacks: 1/ to be *)
+(* complete, we should have STRINGDOT, RIGHTPARENDOT, and so on 2/ the *)
+(* parser rule with dot is right associative and we have to reverse *)
+(* the resulting tree (using the function leftify). *)
+(* This is a complicated issue: the behaviour of the OCaml toplevel *)
+(* is strange, anyway. For example, even without Camlp4, The OCaml *)
+(* toplevel accepts that: *)
+(* # let x = 32;; foo bar match let ) *)
+
+value rec lexer kwt = parser [: t = lexer0 kwt; _ = no_dot :] -> t
+and no_dot =
+ parser
+ [ [: `'.' :] ep ->
+ Stdpp.raise_with_loc
+ (Reloc.shift_pos (ep - 1) Reloc.zero_loc,
+ Reloc.shift_pos ep Reloc.zero_loc)
+ (Stream.Error "bad dot")
+ | [: :] -> () ]
+and lexer0 kwt =
+ parser bp
+ [ [: `'\t' | '\n' | '\r'; s :] -> lexer0 kwt s
+ | [: `' '; s :] -> after_space kwt s
+ | [: `';'; _ = skip_to_eol; s :] -> lexer kwt s
+ | [: `'(' :] -> (("", "("), (bp, bp + 1))
+ | [: `')'; s :] ep -> (("", rparen s), (bp, ep))
+ | [: `'[' :] -> (("", "["), (bp, bp + 1))
+ | [: `']' :] -> (("", "]"), (bp, bp + 1))
+ | [: `'{' :] -> (("", "{"), (bp, bp + 1))
+ | [: `'}' :] -> (("", "}"), (bp, bp + 1))
+ | [: `'"'; s = string 0 :] ep -> (("STRING", s), (bp, ep))
+ | [: `'''; tok = quote :] ep -> (tok, (bp, ep))
+ | [: `'<'; tok = less kwt :] ep -> (tok, (bp, ep))
+ | [: `'-'; tok = minus kwt :] ep -> (tok, (bp, ep))
+ | [: `'~'; tok = tilde :] ep -> (tok, (bp, ep))
+ | [: `'?'; tok = question :] ep -> (tok, (bp, ep))
+ | [: `'#'; tok = base_number kwt bp (Buff.store 0 '0') :] ep ->
+ (tok, (bp, ep))
+ | [: `('0'..'9' as c); tok = number (Buff.store 0 c) :] ep ->
+ (tok, (bp, ep))
+ | [: `('+' | '*' | '/' as c); id = operator (Buff.store 0 c) :] ep ->
+ (identifier kwt (id, False), (bp, ep))
+ | [: `x; id = ident (Buff.store 0 x) :] ep -> (identifier kwt id, (bp, ep))
+ | [: :] -> (("EOI", ""), (bp, bp + 1)) ]
+and rparen =
+ parser
+ [ [: `'.' :] -> ")."
+ | [: ___ :] -> ")" ]
+and after_space kwt =
+ parser
+ [ [: `'.' :] ep -> (("", "."), (ep - 1, ep))
+ | [: x = lexer0 kwt :] -> x ]
+and tilde =
+ parser
+ [ [: `('a'..'z' as c); (s, dot) = ident (Buff.store 0 c) :] ->
+ ("TILDEIDENT", s)
+ | [: :] -> ("LIDENT", "~") ]
+and question =
+ parser
+ [ [: `('a'..'z' as c); (s, dot) = ident (Buff.store 0 c) :] ->
+ ("QUESTIONIDENT", s)
+ | [: :] -> ("LIDENT", "?") ]
+and minus kwt =
+ parser
+ [ [: `'.' :] -> identifier kwt ("-.", False)
+ | [: `('0'..'9' as c); n = number (Buff.store (Buff.store 0 '-') c) :] ->
+ n
+ | [: id = ident (Buff.store 0 '-') :] -> identifier kwt id ]
+and less kwt =
+ parser
+ [ [: `':'; lab = label 0; `'<' ? "'<' expected"; q = quotation 0 :] ->
+ ("QUOT", lab ^ ":" ^ q)
+ | [: id = ident (Buff.store 0 '<') :] -> identifier kwt id ]
+and label len =
+ parser
+ [ [: `('a'..'z' | 'A'..'Z' | '_' as c); s :] -> label (Buff.store len c) s
+ | [: :] -> Buff.get len ]
+and quotation len =
+ parser
+ [ [: `'>'; s :] -> quotation_greater len s
+ | [: `x; s :] -> quotation (Buff.store len x) s
+ | [: :] -> failwith "quotation not terminated" ]
+and quotation_greater len =
+ parser
+ [ [: `'>' :] -> Buff.get len
+ | [: a = quotation (Buff.store len '>') :] -> a ]
+;
+
+value lexer_using kwt (con, prm) =
+ match con with
+ [ "CHAR" | "EOI" | "INT" | "FLOAT" | "LIDENT" | "LIDENTDOT" |
+ "QUESTIONIDENT" | "QUOT" | "STRING" | "TILDEIDENT" | "UIDENT" |
+ "UIDENTDOT" ->
+ ()
+ | "ANTIQUOT" -> ()
+ | "" ->
+ try Hashtbl.find kwt prm with [ Not_found -> Hashtbl.add kwt prm () ]
+ | _ ->
+ raise
+ (Token.Error
+ ("the constructor \"" ^ con ^ "\" is not recognized by Plexer")) ]
+;
+
+value lexer_text (con, prm) =
+ if con = "" then "'" ^ prm ^ "'"
+ else if prm = "" then con
+ else con ^ " \"" ^ prm ^ "\""
+;
+
+value lexer_gmake () =
+ let kwt = Hashtbl.create 89 in
+ {Token.tok_func =
+ Token.lexer_func_of_parser
+ (fun s ->
+ let (r, (bp, ep)) = lexer kwt s in
+ (r,
+ (Reloc.shift_pos bp Reloc.zero_loc,
+ Reloc.shift_pos ep Reloc.zero_loc)));
+ Token.tok_using = lexer_using kwt; Token.tok_removing = fun [];
+ Token.tok_match = Token.default_match; Token.tok_text = lexer_text;
+ Token.tok_comm = None}
+;
+
+(* Building AST *)
+
+type sexpr =
+ [ Sacc of Loc.t and sexpr and sexpr
+ | Schar of Loc.t and string
+ | Sexpr of Loc.t and list sexpr
+ | Sint of Loc.t and string
+ | Sfloat of Loc.t and string
+ | Slid of Loc.t and string
+ | Slist of Loc.t and list sexpr
+ | Sqid of Loc.t and string
+ | Squot of Loc.t and string and string
+ | Srec of Loc.t and list sexpr
+ | Sstring of Loc.t and string
+ | Stid of Loc.t and string
+ | Suid of Loc.t and string ]
+;
+
+value loc_of_sexpr =
+ fun [
+ Sacc loc _ _ | Schar loc _ | Sexpr loc _ | Sint loc _ | Sfloat loc _ |
+ Slid loc _ | Slist loc _ | Sqid loc _ | Squot loc _ _ | Srec loc _ |
+ Sstring loc _ | Stid loc _ | Suid loc _ ->
+ loc ]
+;
+value error_loc loc err =
+ raise_with_loc loc (Stream.Error (err ^ " expected"))
+;
+value error se err = error_loc (loc_of_sexpr se) err;
+
+value strm_n = "__strm";
+value peek_fun loc = <:expr< Stream.peek >>;
+value junk_fun loc = <:expr< Stream.junk >>;
+
+value assoc_left_parsed_op_list =
+ ["+"; "*"; "+."; "*."; "land"; "lor"; "lxor"]
+;
+value assoc_right_parsed_op_list = ["and"; "or"; "^"; "@"];
+value and_by_couple_op_list = ["="; "<>"; "<"; ">"; "<="; ">="; "=="; "!="];
+
+value op_apply loc e1 e2 =
+ fun
+ [ "and" -> <:expr< $e1$ && $e2$ >>
+ | "or" -> <:expr< $e1$ || $e2$ >>
+ | x -> <:expr< $lid:x$ $e1$ $e2$ >> ]
+;
+
+value string_se =
+ fun
+ [ Sstring loc s -> s
+ | se -> error se "string" ]
+;
+
+value mod_ident_se =
+ fun
+ [ Suid _ s -> [Pcaml.rename_id.val s]
+ | Slid _ s -> [Pcaml.rename_id.val s]
+ | se -> error se "mod_ident" ]
+;
+
+value lident_expr loc s =
+ if String.length s > 1 && s.[0] = '`' then
+ let s = String.sub s 1 (String.length s - 1) in
+ <:expr< ` $s$ >>
+ else <:expr< $lid:(Pcaml.rename_id.val s)$ >>
+;
+
+value rec module_expr_se =
+ fun
+ [ Sexpr loc [Slid _ "functor"; Suid _ s; se1; se2] ->
+ let s = Pcaml.rename_id.val s in
+ let mt = module_type_se se1 in
+ let me = module_expr_se se2 in
+ <:module_expr< functor ($s$ : $mt$) -> $me$ >>
+ | Sexpr loc [Slid _ "struct" :: sl] ->
+ let mel = List.map str_item_se sl in
+ <:module_expr< struct $list:mel$ end >>
+ | Sexpr loc [se1; se2] ->
+ let me1 = module_expr_se se1 in
+ let me2 = module_expr_se se2 in
+ <:module_expr< $me1$ $me2$ >>
+ | Suid loc s -> <:module_expr< $uid:(Pcaml.rename_id.val s)$ >>
+ | se -> error se "module expr" ]
+and module_type_se =
+ fun
+ [ Sexpr loc [Slid _ "functor"; Suid _ s; se1; se2] ->
+ let s = Pcaml.rename_id.val s in
+ let mt1 = module_type_se se1 in
+ let mt2 = module_type_se se2 in
+ <:module_type< functor ($s$ : $mt1$) -> $mt2$ >>
+ | Sexpr loc [Slid _ "sig" :: sel] ->
+ let sil = List.map sig_item_se sel in
+ <:module_type< sig $list:sil$ end >>
+ | Sexpr loc [Slid _ "with"; se; Sexpr _ sel] ->
+ let mt = module_type_se se in
+ let wcl = List.map with_constr_se sel in
+ <:module_type< $mt$ with $list:wcl$ >>
+ | Suid loc s -> <:module_type< $uid:(Pcaml.rename_id.val s)$ >>
+ | se -> error se "module type" ]
+and with_constr_se =
+ fun
+ [ Sexpr loc [Slid _ "type"; se1; se2] ->
+ let tn = mod_ident_se se1 in
+ let te = ctyp_se se2 in
+ MLast.WcTyp loc tn [] te
+ | se -> error se "with constr" ]
+and sig_item_se =
+ fun
+ [ Sexpr loc [Slid _ "type" :: sel] ->
+ let tdl = type_declaration_list_se sel in
+ <:sig_item< type $list:tdl$ >>
+ | Sexpr loc [Slid _ "exception"; Suid _ c :: sel] ->
+ let c = Pcaml.rename_id.val c in
+ let tl = List.map ctyp_se sel in
+ <:sig_item< exception $c$ of $list:tl$ >>
+ | Sexpr loc [Slid _ "value"; Slid _ s; se] ->
+ let s = Pcaml.rename_id.val s in
+ let t = ctyp_se se in
+ <:sig_item< value $s$ : $t$ >>
+ | Sexpr loc [Slid _ "external"; Slid _ i; se :: sel] ->
+ let i = Pcaml.rename_id.val i in
+ let pd = List.map string_se sel in
+ let t = ctyp_se se in
+ <:sig_item< external $i$ : $t$ = $list:pd$ >>
+ | Sexpr loc [Slid _ "module"; Suid _ s; se] ->
+ let s = Pcaml.rename_id.val s in
+ let mb = module_type_se se in
+ <:sig_item< module $s$ : $mb$ >>
+ | Sexpr loc [Slid _ "moduletype"; Suid _ s; se] ->
+ let s = Pcaml.rename_id.val s in
+ let mt = module_type_se se in
+ <:sig_item< module type $s$ = $mt$ >>
+ | se -> error se "sig item" ]
+and str_item_se se =
+ match se with
+ [ Sexpr loc [Slid _ "open"; se] ->
+ let s = mod_ident_se se in
+ <:str_item< open $s$ >>
+ | Sexpr loc [Slid _ "type" :: sel] ->
+ let tdl = type_declaration_list_se sel in
+ <:str_item< type $list:tdl$ >>
+ | Sexpr loc [Slid _ "exception"; Suid _ c :: sel] ->
+ let c = Pcaml.rename_id.val c in
+ let tl = List.map ctyp_se sel in
+ <:str_item< exception $c$ of $list:tl$ >>
+ | Sexpr loc [Slid _ ("define" | "definerec" as r); se :: sel] ->
+ let r = r = "definerec" in
+ let (p, e) = fun_binding_se se (begin_se loc sel) in
+ <:str_item< value $opt:r$ $p$ = $e$ >>
+ | Sexpr loc [Slid _ ("define*" | "definerec*" as r) :: sel] ->
+ let r = r = "definerec*" in
+ let lbs = List.map let_binding_se sel in
+ <:str_item< value $opt:r$ $list:lbs$ >>
+ | Sexpr loc [Slid _ "external"; Slid _ i; se :: sel] ->
+ let i = Pcaml.rename_id.val i in
+ let pd = List.map string_se sel in
+ let t = ctyp_se se in
+ <:str_item< external $i$ : $t$ = $list:pd$ >>
+ | Sexpr loc [Slid _ "module"; Suid _ i; se] ->
+ let i = Pcaml.rename_id.val i in
+ let mb = module_binding_se se in
+ <:str_item< module $i$ = $mb$ >>
+ | Sexpr loc [Slid _ "moduletype"; Suid _ s; se] ->
+ let s = Pcaml.rename_id.val s in
+ let mt = module_type_se se in
+ <:str_item< module type $s$ = $mt$ >>
+ | _ ->
+ let loc = loc_of_sexpr se in
+ let e = expr_se se in
+ <:str_item< $exp:e$ >> ]
+and module_binding_se se = module_expr_se se
+and expr_se =
+ fun
+ [ Sacc loc se1 se2 ->
+ let e1 = expr_se se1 in
+ match se2 with
+ [ Slist loc [se2] ->
+ let e2 = expr_se se2 in
+ <:expr< $e1$ .[ $e2$ ] >>
+ | Sexpr loc [se2] ->
+ let e2 = expr_se se2 in
+ <:expr< $e1$ .( $e2$ ) >>
+ | _ ->
+ let e2 = expr_se se2 in
+ <:expr< $e1$ . $e2$ >> ]
+ | Slid loc s -> lident_expr loc s
+ | Suid loc s -> <:expr< $uid:(Pcaml.rename_id.val s)$ >>
+ | Sint loc s -> <:expr< $int:s$ >>
+ | Sfloat loc s -> <:expr< $flo:s$ >>
+ | Schar loc s -> <:expr< $chr:s$ >>
+ | Sstring loc s -> <:expr< $str:s$ >>
+ | Stid loc s -> <:expr< ~ $(Pcaml.rename_id.val s)$ >>
+ | Sqid loc s -> <:expr< ? $(Pcaml.rename_id.val s)$ >>
+ | Sexpr loc [] -> <:expr< () >>
+ | Sexpr loc [Slid _ s; e1 :: ([_ :: _] as sel)]
+ when List.mem s assoc_left_parsed_op_list ->
+ let rec loop e1 =
+ fun
+ [ [] -> e1
+ | [e2 :: el] -> loop (op_apply loc e1 e2 s) el ]
+ in
+ loop (expr_se e1) (List.map expr_se sel)
+ | Sexpr loc [Slid _ s :: ([_; _ :: _] as sel)]
+ when List.mem s assoc_right_parsed_op_list ->
+ let rec loop =
+ fun
+ [ [] -> assert False
+ | [e1] -> e1
+ | [e1 :: el] ->
+ let e2 = loop el in
+ op_apply loc e1 e2 s ]
+ in
+ loop (List.map expr_se sel)
+ | Sexpr loc [Slid _ s :: ([_; _ :: _] as sel)]
+ when List.mem s and_by_couple_op_list ->
+ let rec loop =
+ fun
+ [ [] | [_] -> assert False
+ | [e1; e2] -> <:expr< $lid:s$ $e1$ $e2$ >>
+ | [e1 :: ([e2; _ :: _] as el)] ->
+ let a1 = op_apply loc e1 e2 s in
+ let a2 = loop el in
+ <:expr< $a1$ && $a2$ >> ]
+ in
+ loop (List.map expr_se sel)
+ | Sexpr loc [Stid _ s; se] ->
+ let e = expr_se se in
+ <:expr< ~ $s$ : $e$ >>
+ | Sexpr loc [Slid _ "-"; se] ->
+ let e = expr_se se in
+ <:expr< - $e$ >>
+ | Sexpr loc [Slid _ "if"; se; se1] ->
+ let e = expr_se se in
+ let e1 = expr_se se1 in
+ <:expr< if $e$ then $e1$ else () >>
+ | Sexpr loc [Slid _ "if"; se; se1; se2] ->
+ let e = expr_se se in
+ let e1 = expr_se se1 in
+ let e2 = expr_se se2 in
+ <:expr< if $e$ then $e1$ else $e2$ >>
+ | Sexpr loc [Slid _ "cond" :: sel] ->
+ let rec loop =
+ fun
+ [ [Sexpr loc [Slid _ "else" :: sel]] -> begin_se loc sel
+ | [Sexpr loc [se1 :: sel1] :: sel] ->
+ let e1 = expr_se se1 in
+ let e2 = begin_se loc sel1 in
+ let e3 = loop sel in
+ <:expr< if $e1$ then $e2$ else $e3$ >>
+ | [] -> <:expr< () >>
+ | [se :: _] -> error se "cond clause" ]
+ in
+ loop sel
+ | Sexpr loc [Slid _ "while"; se :: sel] ->
+ let e = expr_se se in
+ let el = List.map expr_se sel in
+ <:expr< while $e$ do { $list:el$ } >>
+ | Sexpr loc [Slid _ "for"; Slid _ i; se1; se2 :: sel] ->
+ let i = Pcaml.rename_id.val i in
+ let e1 = expr_se se1 in
+ let e2 = expr_se se2 in
+ let el = List.map expr_se sel in
+ <:expr< for $i$ = $e1$ to $e2$ do { $list:el$ } >>
+ | Sexpr loc [Slid loc1 "lambda"] -> <:expr< fun [] >>
+ | Sexpr loc [Slid loc1 "lambda"; sep :: sel] ->
+ let e = begin_se loc1 sel in
+ match ipatt_opt_se sep with
+ [ Left p -> <:expr< fun $p$ -> $e$ >>
+ | Right (se, sel) ->
+ List.fold_right
+ (fun se e ->
+ let p = ipatt_se se in
+ <:expr< fun $p$ -> $e$ >>)
+ [se :: sel] e ]
+ | Sexpr loc [Slid _ "lambda_match" :: sel] ->
+ let pel = List.map (match_case loc) sel in
+ <:expr< fun [ $list:pel$ ] >>
+ | Sexpr loc [Slid _ ("let" | "letrec" as r) :: sel] ->
+ match sel with
+ [ [Sexpr _ sel1 :: sel2] ->
+ let r = r = "letrec" in
+ let lbs = List.map let_binding_se sel1 in
+ let e = begin_se loc sel2 in
+ <:expr< let $opt:r$ $list:lbs$ in $e$ >>
+ | [Slid _ n; Sexpr _ sl :: sel] ->
+ let n = Pcaml.rename_id.val n in
+ let (pl, el) =
+ List.fold_right
+ (fun se (pl, el) ->
+ match se with
+ [ Sexpr _ [se1; se2] ->
+ ([patt_se se1 :: pl], [expr_se se2 :: el])
+ | se -> error se "named let" ])
+ sl ([], [])
+ in
+ let e1 =
+ List.fold_right (fun p e -> <:expr< fun $p$ -> $e$ >>) pl
+ (begin_se loc sel)
+ in
+ let e2 =
+ List.fold_left (fun e1 e2 -> <:expr< $e1$ $e2$ >>)
+ <:expr< $lid:n$ >> el
+ in
+ <:expr< let rec $lid:n$ = $e1$ in $e2$ >>
+ | [se :: _] -> error se "let_binding"
+ | _ -> error_loc loc "let_binding" ]
+ | Sexpr loc [Slid _ "let*" :: sel] ->
+ match sel with
+ [ [Sexpr _ sel1 :: sel2] ->
+ List.fold_right
+ (fun se ek ->
+ let (p, e) = let_binding_se se in
+ <:expr< let $p$ = $e$ in $ek$ >>)
+ sel1 (begin_se loc sel2)
+ | [se :: _] -> error se "let_binding"
+ | _ -> error_loc loc "let_binding" ]
+ | Sexpr loc [Slid _ "match"; se :: sel] ->
+ let e = expr_se se in
+ let pel = List.map (match_case loc) sel in
+ <:expr< match $e$ with [ $list:pel$ ] >>
+ | Sexpr loc [Slid _ "parser" :: sel] ->
+ let e =
+ match sel with
+ [ [(Slid _ _ as se) :: sel] ->
+ let p = patt_se se in
+ let pc = parser_cases_se loc sel in
+ <:expr< let $p$ = Stream.count $lid:strm_n$ in $pc$ >>
+ | _ -> parser_cases_se loc sel ]
+ in
+ <:expr< fun ($lid:strm_n$ : Stream.t _) -> $e$ >>
+ | Sexpr loc [Slid _ "match_with_parser"; se :: sel] ->
+ let me = expr_se se in
+ let (bpo, sel) =
+ match sel with
+ [ [(Slid _ _ as se) :: sel] -> (Some (patt_se se), sel)
+ | _ -> (None, sel) ]
+ in
+ let pc = parser_cases_se loc sel in
+ let e =
+ match bpo with
+ [ Some bp -> <:expr< let $bp$ = Stream.count $lid:strm_n$ in $pc$ >>
+ | None -> pc ]
+ in
+ match me with
+ [ <:expr< $lid:x$ >> when x = strm_n -> e
+ | _ -> <:expr< let ($lid:strm_n$ : Stream.t _) = $me$ in $e$ >> ]
+ | Sexpr loc [Slid _ "try"; se :: sel] ->
+ let e = expr_se se in
+ let pel = List.map (match_case loc) sel in
+ <:expr< try $e$ with [ $list:pel$ ] >>
+ | Sexpr loc [Slid _ "begin" :: sel] ->
+ let el = List.map expr_se sel in
+ <:expr< do { $list:el$ } >>
+ | Sexpr loc [Slid _ ":="; se1; se2] ->
+ let e1 = expr_se se1 in
+ let e2 = expr_se se2 in
+ <:expr< $e1$ := $e2$ >>
+ | Sexpr loc [Slid _ "values" :: sel] ->
+ let el = List.map expr_se sel in
+ <:expr< ( $list:el$ ) >>
+ | Srec loc [Slid _ "with"; se :: sel] ->
+ let e = expr_se se in
+ let lel = List.map (label_expr_se loc) sel in
+ <:expr< { ($e$) with $list:lel$ } >>
+ | Srec loc sel ->
+ let lel = List.map (label_expr_se loc) sel in
+ <:expr< { $list:lel$ } >>
+ | Sexpr loc [Slid _ ":"; se1; se2] ->
+ let e = expr_se se1 in
+ let t = ctyp_se se2 in
+ <:expr< ( $e$ : $t$ ) >>
+ | Sexpr loc [se] ->
+ let e = expr_se se in
+ <:expr< $e$ () >>
+ | Sexpr loc [Slid _ "assert"; Suid _ "False"] -> <:expr< assert False >>
+ | Sexpr loc [Slid _ "assert"; se] ->
+ let e = expr_se se in
+ <:expr< assert $e$ >>
+ | Sexpr loc [Slid _ "lazy"; se] ->
+ let e = expr_se se in
+ <:expr< lazy $e$ >>
+ | Sexpr loc [se :: sel] ->
+ List.fold_left
+ (fun e se ->
+ let e1 = expr_se se in
+ <:expr< $e$ $e1$ >>)
+ (expr_se se) sel
+ | Slist loc sel ->
+ let rec loop =
+ fun
+ [ [] -> <:expr< [] >>
+ | [se1; Slid _ "."; se2] ->
+ let e = expr_se se1 in
+ let el = expr_se se2 in
+ <:expr< [$e$ :: $el$] >>
+ | [se :: sel] ->
+ let e = expr_se se in
+ let el = loop sel in
+ <:expr< [$e$ :: $el$] >> ]
+ in
+ loop sel
+ | Squot loc typ txt -> Pcaml.handle_expr_quotation loc (typ, txt) ]
+and begin_se loc =
+ fun
+ [ [] -> <:expr< () >>
+ | [se] -> expr_se se
+ | sel ->
+ let el = List.map expr_se sel in
+ let loc = (fst (loc_of_sexpr (List.hd sel)), snd loc) in
+ <:expr< do { $list:el$ } >> ]
+and let_binding_se =
+ fun
+ [ Sexpr loc [se :: sel] ->
+ let e = begin_se loc sel in
+ match ipatt_opt_se se with
+ [ Left p -> (p, e)
+ | Right _ -> fun_binding_se se e ]
+ | se -> error se "let_binding" ]
+and fun_binding_se se e =
+ match se with
+ [ Sexpr _ [Slid _ "values" :: _] -> (ipatt_se se, e)
+ | Sexpr _ [Slid loc s :: sel] ->
+ let s = Pcaml.rename_id.val s in
+ let e =
+ List.fold_right
+ (fun se e ->
+ let loc = (fst (loc_of_sexpr se), snd (MLast.loc_of_expr e)) in
+ let p = ipatt_se se in
+ <:expr< fun $p$ -> $e$ >>)
+ sel e
+ in
+ let p = <:patt< $lid:s$ >> in
+ (p, e)
+ | _ -> (ipatt_se se, e) ]
+and match_case loc =
+ fun
+ [ Sexpr loc [Sexpr _ [Slid _ "when"; se; sew] :: sel] ->
+ (patt_se se, Some (expr_se sew), begin_se loc sel)
+ | Sexpr loc [se :: sel] -> (patt_se se, None, begin_se loc sel)
+ | se -> error se "match_case" ]
+and label_expr_se loc =
+ fun
+ [ Sexpr _ [se1; se2] -> (patt_se se1, expr_se se2)
+ | se -> error se "label_expr" ]
+and label_patt_se loc =
+ fun
+ [ Sexpr _ [se1; se2] -> (patt_se se1, patt_se se2)
+ | se -> error se "label_patt" ]
+and parser_cases_se loc =
+ fun
+ [ [] -> <:expr< raise Stream.Failure >>
+ | [Sexpr loc [Sexpr _ spsel :: act] :: sel] ->
+ let ekont _ = parser_cases_se loc sel in
+ let act =
+ match act with
+ [ [se] -> expr_se se
+ | [sep; se] ->
+ let p = patt_se sep in
+ let e = expr_se se in
+ <:expr< let $p$ = Stream.count $lid:strm_n$ in $e$ >>
+ | _ -> error_loc loc "parser_case" ]
+ in
+ stream_pattern_se loc act ekont spsel
+ | [se :: _] -> error se "parser_case" ]
+and stream_pattern_se loc act ekont =
+ fun
+ [ [] -> act
+ | [se :: sel] ->
+ let ckont err = <:expr< raise (Stream.Error $err$) >> in
+ let skont = stream_pattern_se loc act ckont sel in
+ stream_pattern_component skont ekont <:expr< "" >> se ]
+and stream_pattern_component skont ekont err =
+ fun
+ [ Sexpr loc [Slid _ "`"; se :: wol] ->
+ let wo =
+ match wol with
+ [ [se] -> Some (expr_se se)
+ | [] -> None
+ | _ -> error_loc loc "stream_pattern_component" ]
+ in
+ let e = peek_fun loc in
+ let p = patt_se se in
+ let j = junk_fun loc in
+ let k = ekont err in
+ <:expr< match $e$ $lid:strm_n$ with
+ [ Some $p$ $when:wo$ -> do { $j$ $lid:strm_n$ ; $skont$ }
+ | _ -> $k$ ] >>
+ | Sexpr loc [se1; se2] ->
+ let p = patt_se se1 in
+ let e =
+ let e = expr_se se2 in
+ <:expr< try Some ($e$ $lid:strm_n$) with [ Stream.Failure -> None ] >>
+ in
+ let k = ekont err in
+ <:expr< match $e$ with [ Some $p$ -> $skont$ | _ -> $k$ ] >>
+ | Sexpr loc [Slid _ "?"; se1; se2] ->
+ stream_pattern_component skont ekont (expr_se se2) se1
+ | Slid loc s ->
+ let s = Pcaml.rename_id.val s in
+ <:expr< let $lid:s$ = $lid:strm_n$ in $skont$ >>
+ | se -> error se "stream_pattern_component" ]
+and patt_se =
+ fun
+ [ Sacc loc se1 se2 ->
+ let p1 = patt_se se1 in
+ let p2 = patt_se se2 in
+ <:patt< $p1$ . $p2$ >>
+ | Slid loc "_" -> <:patt< _ >>
+ | Slid loc s -> <:patt< $lid:(Pcaml.rename_id.val s)$ >>
+ | Suid loc s -> <:patt< $uid:(Pcaml.rename_id.val s)$ >>
+ | Sint loc s -> <:patt< $int:s$ >>
+ | Sfloat loc s -> <:patt< $flo:s$ >>
+ | Schar loc s -> <:patt< $chr:s$ >>
+ | Sstring loc s -> <:patt< $str:s$ >>
+ | Stid loc _ -> error_loc loc "patt"
+ | Sqid loc _ -> error_loc loc "patt"
+ | Srec loc sel ->
+ let lpl = List.map (label_patt_se loc) sel in
+ <:patt< { $list:lpl$ } >>
+ | Sexpr loc [Slid _ ":"; se1; se2] ->
+ let p = patt_se se1 in
+ let t = ctyp_se se2 in
+ <:patt< ($p$ : $t$) >>
+ | Sexpr loc [Slid _ "or"; se :: sel] ->
+ List.fold_left
+ (fun p se ->
+ let p1 = patt_se se in
+ <:patt< $p$ | $p1$ >>)
+ (patt_se se) sel
+ | Sexpr loc [Slid _ "range"; se1; se2] ->
+ let p1 = patt_se se1 in
+ let p2 = patt_se se2 in
+ <:patt< $p1$ .. $p2$ >>
+ | Sexpr loc [Slid _ "values" :: sel] ->
+ let pl = List.map patt_se sel in
+ <:patt< ( $list:pl$ ) >>
+ | Sexpr loc [Slid _ "as"; se1; se2] ->
+ let p1 = patt_se se1 in
+ let p2 = patt_se se2 in
+ <:patt< ($p1$ as $p2$) >>
+ | Sexpr loc [se :: sel] ->
+ List.fold_left
+ (fun p se ->
+ let p1 = patt_se se in
+ <:patt< $p$ $p1$ >>)
+ (patt_se se) sel
+ | Sexpr loc [] -> <:patt< () >>
+ | Slist loc sel ->
+ let rec loop =
+ fun
+ [ [] -> <:patt< [] >>
+ | [se1; Slid _ "."; se2] ->
+ let p = patt_se se1 in
+ let pl = patt_se se2 in
+ <:patt< [$p$ :: $pl$] >>
+ | [se :: sel] ->
+ let p = patt_se se in
+ let pl = loop sel in
+ <:patt< [$p$ :: $pl$] >> ]
+ in
+ loop sel
+ | Squot loc typ txt -> Pcaml.handle_patt_quotation loc (typ, txt) ]
+and ipatt_se se =
+ match ipatt_opt_se se with
+ [ Left p -> p
+ | Right (se, _) -> error se "ipatt" ]
+and ipatt_opt_se =
+ fun
+ [ Slid loc "_" -> Left <:patt< _ >>
+ | Slid loc s -> Left <:patt< $lid:(Pcaml.rename_id.val s)$ >>
+ | Stid loc s -> Left <:patt< ~ $(Pcaml.rename_id.val s)$ >>
+ | Sqid loc s -> Left <:patt< ? $(Pcaml.rename_id.val s)$ >>
+ | Sexpr loc [Sqid _ s; se] ->
+ let s = Pcaml.rename_id.val s in
+ let e = expr_se se in
+ Left <:patt< ? ( $lid:s$ = $e$ ) >>
+ | Sexpr loc [Slid _ ":"; se1; se2] ->
+ let p = ipatt_se se1 in
+ let t = ctyp_se se2 in
+ Left <:patt< ($p$ : $t$) >>
+ | Sexpr loc [Slid _ "values" :: sel] ->
+ let pl = List.map ipatt_se sel in
+ Left <:patt< ( $list:pl$ ) >>
+ | Sexpr loc [] -> Left <:patt< () >>
+ | Sexpr loc [se :: sel] -> Right (se, sel)
+ | se -> error se "ipatt" ]
+and type_declaration_list_se =
+ fun
+ [ [se1; se2 :: sel] ->
+ let (n1, loc1, tpl) =
+ match se1 with
+ [ Sexpr _ [Slid loc n :: sel] ->
+ (n, loc, List.map type_parameter_se sel)
+ | Slid loc n -> (n, loc, [])
+ | se -> error se "type declaration" ]
+ in
+ [((loc1, Pcaml.rename_id.val n1), tpl, ctyp_se se2, []) ::
+ type_declaration_list_se sel]
+ | [] -> []
+ | [se :: _] -> error se "type_declaration" ]
+and type_parameter_se =
+ fun
+ [ Slid _ s when String.length s >= 2 && s.[0] = ''' ->
+ (String.sub s 1 (String.length s - 1), (False, False))
+ | se -> error se "type_parameter" ]
+and ctyp_se =
+ fun
+ [ Sexpr loc [Slid _ "sum" :: sel] ->
+ let cdl = List.map constructor_declaration_se sel in
+ <:ctyp< [ $list:cdl$ ] >>
+ | Srec loc sel ->
+ let ldl = List.map label_declaration_se sel in
+ <:ctyp< { $list:ldl$ } >>
+ | Sexpr loc [Slid _ "->" :: ([_; _ :: _] as sel)] ->
+ let rec loop =
+ fun
+ [ [] -> assert False
+ | [se] -> ctyp_se se
+ | [se :: sel] ->
+ let t1 = ctyp_se se in
+ let loc = (fst (loc_of_sexpr se), snd loc) in
+ let t2 = loop sel in
+ <:ctyp< $t1$ -> $t2$ >> ]
+ in
+ loop sel
+ | Sexpr loc [Slid _ "*" :: sel] ->
+ let tl = List.map ctyp_se sel in
+ <:ctyp< ($list:tl$) >>
+ | Sexpr loc [se :: sel] ->
+ List.fold_left
+ (fun t se ->
+ let t2 = ctyp_se se in
+ <:ctyp< $t$ $t2$ >>)
+ (ctyp_se se) sel
+ | Sacc loc se1 se2 ->
+ let t1 = ctyp_se se1 in
+ let t2 = ctyp_se se2 in
+ <:ctyp< $t1$ . $t2$ >>
+ | Slid loc "_" -> <:ctyp< _ >>
+ | Slid loc s ->
+ if s.[0] = ''' then
+ let s = String.sub s 1 (String.length s - 1) in
+ <:ctyp< '$s$ >>
+ else <:ctyp< $lid:(Pcaml.rename_id.val s)$ >>
+ | Suid loc s -> <:ctyp< $uid:(Pcaml.rename_id.val s)$ >>
+ | se -> error se "ctyp" ]
+and constructor_declaration_se =
+ fun
+ [ Sexpr loc [Suid _ ci :: sel] ->
+ (loc, Pcaml.rename_id.val ci, List.map ctyp_se sel)
+ | se -> error se "constructor_declaration" ]
+and label_declaration_se =
+ fun
+ [ Sexpr loc [Slid _ lab; Slid _ "mutable"; se] ->
+ (loc, Pcaml.rename_id.val lab, True, ctyp_se se)
+ | Sexpr loc [Slid _ lab; se] ->
+ (loc, Pcaml.rename_id.val lab, False, ctyp_se se)
+ | se -> error se "label_declaration" ]
+;
+
+value directive_se =
+ fun
+ [ Sexpr _ [Slid _ s] -> (s, None)
+ | Sexpr _ [Slid _ s; se] ->
+ let e = expr_se se in
+ (s, Some e)
+ | se -> error se "directive" ]
+;
+
+(* Parser *)
+
+Pcaml.syntax_name.val := "Scheme";
+Pcaml.no_constructors_arity.val := False;
+
+do {
+ Grammar.Unsafe.gram_reinit gram (lexer_gmake ());
+ Grammar.Unsafe.clear_entry interf;
+ Grammar.Unsafe.clear_entry implem;
+ Grammar.Unsafe.clear_entry top_phrase;
+ Grammar.Unsafe.clear_entry use_file;
+ Grammar.Unsafe.clear_entry module_type;
+ Grammar.Unsafe.clear_entry module_expr;
+ Grammar.Unsafe.clear_entry sig_item;
+ Grammar.Unsafe.clear_entry str_item;
+ Grammar.Unsafe.clear_entry expr;
+ Grammar.Unsafe.clear_entry patt;
+ Grammar.Unsafe.clear_entry ctyp;
+ Grammar.Unsafe.clear_entry let_binding;
+ Grammar.Unsafe.clear_entry type_declaration;
+ Grammar.Unsafe.clear_entry class_type;
+ Grammar.Unsafe.clear_entry class_expr;
+ Grammar.Unsafe.clear_entry class_sig_item;
+ Grammar.Unsafe.clear_entry class_str_item
+};
+
+Pcaml.parse_interf.val := Grammar.Entry.parse interf;
+Pcaml.parse_implem.val := Grammar.Entry.parse implem;
+
+value sexpr = Grammar.Entry.create gram "sexpr";
+
+value rec leftify =
+ fun
+ [ Sacc loc1 se1 se2 ->
+ match leftify se2 with
+ [ Sacc loc2 se2 se3 -> Sacc loc1 (Sacc loc2 se1 se2) se3
+ | se2 -> Sacc loc1 se1 se2 ]
+ | x -> x ]
+;
+
+EXTEND
+ GLOBAL: implem interf top_phrase use_file str_item sig_item expr patt sexpr;
+ implem:
+ [ [ "#"; se = sexpr ->
+ let (n, dp) = directive_se se in
+ ([(<:str_item< # $n$ $opt:dp$ >>, loc)], True)
+ | si = str_item; x = SELF ->
+ let (sil, stopped) = x in
+ let loc = MLast.loc_of_str_item si in
+ ([(si, loc) :: sil], stopped)
+ | EOI -> ([], False) ] ]
+ ;
+ interf:
+ [ [ "#"; se = sexpr ->
+ let (n, dp) = directive_se se in
+ ([(<:sig_item< # $n$ $opt:dp$ >>, loc)], True)
+ | si = sig_item; x = SELF ->
+ let (sil, stopped) = x in
+ let loc = MLast.loc_of_sig_item si in
+ ([(si, loc) :: sil], stopped)
+ | EOI -> ([], False) ] ]
+ ;
+ top_phrase:
+ [ [ "#"; se = sexpr ->
+ let (n, dp) = directive_se se in
+ Some <:str_item< # $n$ $opt:dp$ >>
+ | se = sexpr -> Some (str_item_se se)
+ | EOI -> None ] ]
+ ;
+ use_file:
+ [ [ "#"; se = sexpr ->
+ let (n, dp) = directive_se se in
+ ([<:str_item< # $n$ $opt:dp$ >>], True)
+ | si = str_item; x = SELF ->
+ let (sil, stopped) = x in
+ ([si :: sil], stopped)
+ | EOI -> ([], False) ] ]
+ ;
+ str_item:
+ [ [ se = sexpr -> str_item_se se
+ | e = expr -> <:str_item< $exp:e$ >> ] ]
+ ;
+ sig_item:
+ [ [ se = sexpr -> sig_item_se se ] ]
+ ;
+ expr:
+ [ "top"
+ [ se = sexpr -> expr_se se ] ]
+ ;
+ patt:
+ [ [ se = sexpr -> patt_se se ] ]
+ ;
+ sexpr:
+ [ [ se1 = sexpr_dot; se2 = SELF -> leftify (Sacc loc se1 se2) ]
+ | [ "("; sl = LIST0 sexpr; ")" -> Sexpr loc sl
+ | "("; sl = LIST0 sexpr; ")."; se = SELF ->
+ leftify (Sacc loc (Sexpr loc sl) se)
+ | "["; sl = LIST0 sexpr; "]" -> Slist loc sl
+ | "{"; sl = LIST0 sexpr; "}" -> Srec loc sl
+ | a = pa_extend_keyword -> Slid loc a
+ | s = LIDENT -> Slid loc s
+ | s = UIDENT -> Suid loc s
+ | s = TILDEIDENT -> Stid loc s
+ | s = QUESTIONIDENT -> Sqid loc s
+ | s = INT -> Sint loc s
+ | s = FLOAT -> Sfloat loc s
+ | s = CHAR -> Schar loc s
+ | s = STRING -> Sstring loc s
+ | s = QUOT ->
+ let i = String.index s ':' in
+ let typ = String.sub s 0 i in
+ let txt = String.sub s (i + 1) (String.length s - i - 1) in
+ Squot loc typ txt ] ]
+ ;
+ sexpr_dot:
+ [ [ s = LIDENTDOT -> Slid loc s
+ | s = UIDENTDOT -> Suid loc s ] ]
+ ;
+ pa_extend_keyword:
+ [ [ "_" -> "_"
+ | "," -> ","
+ | "=" -> "="
+ | ":" -> ":"
+ | "." -> "."
+ | "/" -> "/" ] ]
+ ;
+END;
--- /dev/null
+; pa_r.cmo pa_rp.cmo pa_extend.cmo q_MLast.cmo pr_dump.cmo
+; **********************************************************************
+;
+; Camlp4
+;
+; Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt
+;
+; Copyright 2002 Institut National de Recherche en Informatique et
+; en Automatique. All rights reserved. This file is distributed
+; under the terms of the GNU Library General Public License, with
+; the special exception on linking described in file
+; ../../../LICENSE.
+;
+; **********************************************************************
+
+(open Pcaml)
+(open Stdpp)
+
+(type (choice 'a 'b) (sum (Left 'a) (Right 'b)))
+
+; Buffer
+
+(module Buff
+ (struct
+ (define buff (ref (String.create 80)))
+ (define (store len x)
+ (if (>= len (String.length buff.val))
+ (:= buff.val (^ buff.val (String.create (String.length buff.val)))))
+ (:= buff.val.[len] x)
+ (succ len))
+ (define (get len) (String.sub buff.val 0 len))))
+
+; Lexer
+
+(definerec skip_to_eol
+ (parser
+ (((` (or '\n' '\r'))) ())
+ (((` _) s) (skip_to_eol s))))
+
+(define no_ident ['(' ')' '[' ']' '{' '}' ' ' '\t' '\n' '\r' ';'])
+
+(definerec (ident len)
+ (parser
+ (((` '.')) (values (Buff.get len) True))
+ (((` x (not (List.mem x no_ident))) s) (ident (Buff.store len x) s))
+ (() (values (Buff.get len) False))))
+
+(define (identifier kwt (values s dot))
+ (let ((con
+ (try (begin (: (Hashtbl.find kwt s) unit) "")
+ (Not_found
+ (match s.[0]
+ ((range 'A' 'Z') (if dot "UIDENTDOT" "UIDENT"))
+ (_ (if dot "LIDENTDOT" "LIDENT")))))))
+ (values con s)))
+
+(definerec (string len)
+ (parser
+ (((` '"')) (Buff.get len))
+ (((` '\\') (` c) s) (string (Buff.store (Buff.store len '\\') c) s))
+ (((` x) s) (string (Buff.store len x) s))))
+
+(definerec (end_exponent_part_under len)
+ (parser
+ (((` (as (range '0' '9') c)) s)
+ (end_exponent_part_under (Buff.store len c) s))
+ (() (values "FLOAT" (Buff.get len)))))
+
+(define (end_exponent_part len)
+ (parser
+ (((` (as (range '0' '9') c)) s)
+ (end_exponent_part_under (Buff.store len c) s))
+ (() (raise (Stream.Error "ill-formed floating-point constant")))))
+
+(define (exponent_part len)
+ (parser
+ (((` (as (or '+' '-') c)) s) (end_exponent_part (Buff.store len c) s))
+ (((a (end_exponent_part len))) a)))
+
+(definerec (decimal_part len)
+ (parser
+ (((` (as (range '0' '9') c)) s) (decimal_part (Buff.store len c) s))
+ (((` (or 'e' 'E')) s) (exponent_part (Buff.store len 'E') s))
+ (() (values "FLOAT" (Buff.get len)))))
+
+(definerec (number len)
+ (parser
+ (((` (as (range '0' '9') c)) s) (number (Buff.store len c) s))
+ (((` '.') s) (decimal_part (Buff.store len '.') s))
+ (((` (or 'e' 'E')) s) (exponent_part (Buff.store len 'E') s))
+ (() (values "INT" (Buff.get len)))))
+
+(define binary
+ (parser
+ (((` (as (range '0' '1') c))) c)))
+
+(define octal
+ (parser
+ (((` (as (range '0' '7') c))) c)))
+
+(define hexa
+ (parser
+ (((` (as (or (range '0' '9') (range 'a' 'f') (range 'A' 'F')) c))) c)))
+
+(definerec (digits_under kind len)
+ (parser
+ (((d kind) s) (digits_under kind (Buff.store len d) s))
+ (() (Buff.get len))))
+
+(define (digits kind bp len)
+ (parser
+ (((d kind) s) (values "INT" (digits_under kind (Buff.store len d) s)))
+ ((s) ep
+ (raise_with_loc (values
+ (Reloc.shift_pos bp Reloc.zero_loc)
+ (Reloc.shift_pos ep Reloc.zero_loc))
+ (Failure "ill-formed integer constant")))))
+
+(define (base_number kwt bp len)
+ (parser
+ (((` (or 'b' 'B')) s) (digits binary bp (Buff.store len 'b') s))
+ (((` (or 'o' 'O')) s) (digits octal bp (Buff.store len 'o') s))
+ (((` (or 'x' 'X')) s) (digits hexa bp (Buff.store len 'x') s))
+ (((id (ident (Buff.store 0 '#')))) (identifier kwt id))))
+
+(definerec (operator len)
+ (parser
+ (((` '.')) (Buff.get (Buff.store len '.')))
+ (() (Buff.get len))))
+
+(define (char_or_quote_id x)
+ (parser
+ (((` ''')) (values "CHAR" (String.make 1 x)))
+ ((s) ep
+ (if (List.mem x no_ident)
+ (Stdpp.raise_with_loc (values
+ (Reloc.shift_pos (- ep 2) Reloc.zero_loc)
+ (Reloc.shift_pos (- ep 1) Reloc.zero_loc))
+ (Stream.Error "bad quote"))
+ (let* ((len (Buff.store (Buff.store 0 ''') x))
+ ((values s dot) (ident len s)))
+ (values (if dot "LIDENTDOT" "LIDENT") s))))))
+
+(definerec (char len)
+ (parser
+ (((` ''')) len)
+ (((` x) s) (char (Buff.store len x) s))))
+
+(define quote
+ (parser
+ (((` '\\') (len (char (Buff.store 0 '\\'))))
+ (values "CHAR" (Buff.get len)))
+ (((` x) s) (char_or_quote_id x s))))
+
+; The system with LIDENTDOT and UIDENTDOT is not great (it would be
+; better to have a token DOT (actually SPACEDOT and DOT)) but it is
+; the only way (that I have found) to have a good behaviour in the
+; toplevel (not expecting tokens after a phrase). Drawbacks: 1/ to be
+; complete, we should have STRINGDOT, RIGHTPARENDOT, and so on 2/ the
+; parser rule with dot is right associative and we have to reverse
+; the resulting tree (using the function leftify).
+; This is a complicated issue: the behaviour of the OCaml toplevel
+; is strange, anyway. For example, even without Camlp4, The OCaml
+; toplevel accepts that:
+; # let x = 32;; foo bar match let )
+
+(definerec*
+ ((lexer kwt)
+ (parser
+ (((t (lexer0 kwt))
+ (_ no_dot)) t)))
+ (no_dot
+ (parser
+ (((` '.')) ep
+ (Stdpp.raise_with_loc (values
+ (Reloc.shift_pos (- ep 1) Reloc.zero_loc)
+ (Reloc.shift_pos ep Reloc.zero_loc))
+ (Stream.Error "bad dot")))
+ (() ())))
+ ((lexer0 kwt)
+ (parser bp
+ (((` (or '\t' '\n' '\r')) s) (lexer0 kwt s))
+ (((` ' ') s) (after_space kwt s))
+ (((` ';') (_ skip_to_eol) s) (lexer kwt s))
+ (((` '(')) (values (values "" "(") (values bp (+ bp 1))))
+ (((` ')') s) ep (values (values "" (rparen s)) (values bp ep)))
+ (((` '[')) (values (values "" "[") (values bp (+ bp 1))))
+ (((` ']')) (values (values "" "]") (values bp (+ bp 1))))
+ (((` '{')) (values (values "" "{") (values bp (+ bp 1))))
+ (((` '}')) (values (values "" "}") (values bp (+ bp 1))))
+ (((` '"') (s (string 0))) ep
+ (values (values "STRING" s) (values bp ep)))
+ (((` ''') (tok quote)) ep (values tok (values bp ep)))
+ (((` '<') (tok (less kwt))) ep (values tok (values bp ep)))
+ (((` '-') (tok (minus kwt))) ep (values tok (values bp ep)))
+ (((` '~') (tok tilde)) ep (values tok (values bp ep)))
+ (((` '?') (tok question)) ep (values tok (values bp ep)))
+ (((` '#') (tok (base_number kwt bp (Buff.store 0 '0')))) ep
+ (values tok (values bp ep)))
+ (((` (as (range '0' '9') c)) (tok (number (Buff.store 0 c)))) ep
+ (values tok (values bp ep)))
+ (((` (as (or '+' '*' '/') c)) (id (operator (Buff.store 0 c)))) ep
+ (values (identifier kwt (values id False)) (values bp ep)))
+ (((` x) (id (ident (Buff.store 0 x)))) ep
+ (values (identifier kwt id) (values bp ep)))
+ (() (values (values "EOI" "") (values bp (+ bp 1))))))
+ (rparen
+ (parser
+ (((` '.')) ").")
+ ((_) ")")))
+ ((after_space kwt)
+ (parser
+ (((` '.')) ep (values (values "" ".") (values (- ep 1) ep)))
+ (((x (lexer0 kwt))) x)))
+ (tilde
+ (parser
+ (((` (as (range 'a' 'z') c)) ((values s dot) (ident (Buff.store 0 c))))
+ (values "TILDEIDENT" s))
+ (() (values "LIDENT" "~"))))
+ (question
+ (parser
+ (((` (as (range 'a' 'z') c)) ((values s dot) (ident (Buff.store 0 c))))
+ (values "QUESTIONIDENT" s))
+ (() (values "LIDENT" "?"))))
+ ((minus kwt)
+ (parser
+ (((` '.')) (identifier kwt (values "-." False)))
+ (((` (as (range '0' '9') c))
+ (n (number (Buff.store (Buff.store 0 '-') c)))) ep n)
+ (((id (ident (Buff.store 0 '-')))) (identifier kwt id))))
+ ((less kwt)
+ (parser
+ (((` ':') (lab (label 0)) (? (` '<') "'<' expected") (q (quotation 0)))
+ (values "QUOT" (^ lab ":" q)))
+ (((id (ident (Buff.store 0 '<')))) (identifier kwt id))))
+ ((label len)
+ (parser
+ (((` (as (or (range 'a' 'z') (range 'A' 'Z') '_') c)) s)
+ (label (Buff.store len c) s))
+ (() (Buff.get len))))
+ ((quotation len)
+ (parser
+ (((` '>') s) (quotation_greater len s))
+ (((` x) s) (quotation (Buff.store len x) s))
+ (() (failwith "quotation not terminated"))))
+ ((quotation_greater len)
+ (parser
+ (((` '>')) (Buff.get len))
+ (((a (quotation (Buff.store len '>')))) a))))
+
+(define (lexer_using kwt (values con prm))
+ (match con
+ ((or "CHAR" "EOI" "INT" "FLOAT" "LIDENT" "LIDENTDOT" "QUESTIONIDENT"
+ "QUOT" "STRING" "TILDEIDENT" "UIDENT" "UIDENTDOT")
+ ())
+ ("ANTIQUOT" ())
+ ("" (try (Hashtbl.find kwt prm) (Not_found (Hashtbl.add kwt prm ()))))
+ (_
+ (raise
+ (Token.Error
+ (^ "the constructor \"" con "\" is not recognized by Plexer"))))))
+
+(define (lexer_text (values con prm))
+ (cond
+ ((= con "") (^ "'"prm "'"))
+ ((= prm "") con)
+ (else (^ con " \"" prm "\""))))
+
+(define (lexer_gmake ())
+ (let ((kwt (Hashtbl.create 89)))
+ {(Token.tok_func
+ (Token.lexer_func_of_parser
+ (lambda (s)
+ (let (((values r (values bp ep)) (lexer kwt s)))
+ (values r (values (Reloc.shift_pos bp Reloc.zero_loc)
+ (Reloc.shift_pos ep Reloc.zero_loc)))))))
+ (Token.tok_using (lexer_using kwt))
+ (Token.tok_removing (lambda))
+ (Token.tok_match Token.default_match)
+ (Token.tok_text lexer_text)
+ (Token.tok_comm None)}))
+
+; Building AST
+
+(type sexpr
+ (sum
+ (Sacc MLast.loc sexpr sexpr)
+ (Schar MLast.loc string)
+ (Sexpr MLast.loc (list sexpr))
+ (Sint MLast.loc string)
+ (Sfloat MLast.loc string)
+ (Slid MLast.loc string)
+ (Slist MLast.loc (list sexpr))
+ (Sqid MLast.loc string)
+ (Squot MLast.loc string string)
+ (Srec MLast.loc (list sexpr))
+ (Sstring MLast.loc string)
+ (Stid MLast.loc string)
+ (Suid MLast.loc string)))
+
+(define loc_of_sexpr
+ (lambda_match
+ ((or (Sacc loc _ _) (Schar loc _) (Sexpr loc _) (Sint loc _)
+ (Sfloat loc _) (Slid loc _) (Slist loc _) (Sqid loc _) (Squot loc _ _)
+ (Srec loc _) (Sstring loc _) (Stid loc _) (Suid loc _))
+ loc)))
+(define (error_loc loc err)
+ (raise_with_loc loc (Stream.Error (^ err " expected"))))
+(define (error se err) (error_loc (loc_of_sexpr se) err))
+
+(define strm_n "strm__")
+(define (peek_fun loc) <:expr< Stream.peek >>)
+(define (junk_fun loc) <:expr< Stream.junk >>)
+
+(define assoc_left_parsed_op_list ["+" "*" "+." "*." "land" "lor" "lxor"])
+(define assoc_right_parsed_op_list ["and" "or" "^" "@"])
+(define and_by_couple_op_list ["=" "<>" "<" ">" "<=" ">=" "==" "!="])
+
+(define (op_apply loc e1 e2)
+ (lambda_match
+ ("and" <:expr< $e1$ && $e2$ >>)
+ ("or" <:expr< $e1$ || $e2$ >>)
+ (x <:expr< $lid:x$ $e1$ $e2$ >>)))
+
+(define string_se
+ (lambda_match
+ ((Sstring loc s) s)
+ (se (error se "string"))))
+
+(define mod_ident_se
+ (lambda_match
+ ((Suid _ s) [(Pcaml.rename_id.val s)])
+ ((Slid _ s) [(Pcaml.rename_id.val s)])
+ (se (error se "mod_ident"))))
+
+(define (lident_expr loc s)
+ (if (&& (> (String.length s) 1) (= s.[0] '`'))
+ (let ((s (String.sub s 1 (- (String.length s) 1))))
+ <:expr< ` $s$ >>)
+ <:expr< $lid:(Pcaml.rename_id.val s)$ >>))
+
+(definerec*
+ (module_expr_se
+ (lambda_match
+ ((Sexpr loc [(Slid _ "functor") (Suid _ s) se1 se2])
+ (let* ((s (Pcaml.rename_id.val s))
+ (mt (module_type_se se1))
+ (me (module_expr_se se2)))
+ <:module_expr< functor ($s$ : $mt$) -> $me$ >>))
+ ((Sexpr loc [(Slid _ "struct") . sl])
+ (let ((mel (List.map str_item_se sl)))
+ <:module_expr< struct $list:mel$ end >>))
+ ((Sexpr loc [se1 se2])
+ (let* ((me1 (module_expr_se se1))
+ (me2 (module_expr_se se2)))
+ <:module_expr< $me1$ $me2$ >>))
+ ((Suid loc s) <:module_expr< $uid:(Pcaml.rename_id.val s)$ >>)
+ (se (error se "module expr"))))
+ (module_type_se
+ (lambda_match
+ ((Sexpr loc [(Slid _ "functor") (Suid _ s) se1 se2])
+ (let* ((s (Pcaml.rename_id.val s))
+ (mt1 (module_type_se se1))
+ (mt2 (module_type_se se2)))
+ <:module_type< functor ($s$ : $mt1$) -> $mt2$ >>))
+ ((Sexpr loc [(Slid _ "sig") . sel])
+ (let ((sil (List.map sig_item_se sel)))
+ <:module_type< sig $list:sil$ end >>))
+ ((Sexpr loc [(Slid _ "with") se (Sexpr _ sel)])
+ (let* ((mt (module_type_se se))
+ (wcl (List.map with_constr_se sel)))
+ <:module_type< $mt$ with $list:wcl$ >>))
+ ((Suid loc s) <:module_type< $uid:(Pcaml.rename_id.val s)$ >>)
+ (se (error se "module type"))))
+ (with_constr_se
+ (lambda_match
+ ((Sexpr loc [(Slid _ "type") se1 se2])
+ (let* ((tn (mod_ident_se se1))
+ (te (ctyp_se se2)))
+ (MLast.WcTyp loc tn [] te)))
+ (se (error se "with constr"))))
+ (sig_item_se
+ (lambda_match
+ ((Sexpr loc [(Slid _ "type") . sel])
+ (let ((tdl (type_declaration_list_se sel)))
+ <:sig_item< type $list:tdl$ >>))
+ ((Sexpr loc [(Slid _ "exception") (Suid _ c) . sel])
+ (let* ((c (Pcaml.rename_id.val c))
+ (tl (List.map ctyp_se sel)))
+ <:sig_item< exception $c$ of $list:tl$ >>))
+ ((Sexpr loc [(Slid _ "value") (Slid _ s) se])
+ (let* ((s (Pcaml.rename_id.val s))
+ (t (ctyp_se se)))
+ <:sig_item< value $s$ : $t$ >>))
+ ((Sexpr loc [(Slid _ "external") (Slid _ i) se . sel])
+ (let* ((i (Pcaml.rename_id.val i))
+ (pd (List.map string_se sel))
+ (t (ctyp_se se)))
+ <:sig_item< external $i$ : $t$ = $list:pd$ >>))
+ ((Sexpr loc [(Slid _ "module") (Suid _ s) se])
+ (let* ((s (Pcaml.rename_id.val s))
+ (mb (module_type_se se)))
+ <:sig_item< module $s$ : $mb$ >>))
+ ((Sexpr loc [(Slid _ "moduletype") (Suid _ s) se])
+ (let* ((s (Pcaml.rename_id.val s))
+ (mt (module_type_se se)))
+ <:sig_item< module type $s$ = $mt$ >>))
+ (se (error se "sig item"))))
+ ((str_item_se se)
+ (match se
+ ((Sexpr loc [(Slid _ "open") se])
+ (let ((s (mod_ident_se se))) <:str_item< open $s$ >>))
+ ((Sexpr loc [(Slid _ "type") . sel])
+ (let ((tdl (type_declaration_list_se sel)))
+ <:str_item< type $list:tdl$ >>))
+ ((Sexpr loc [(Slid _ "exception") (Suid _ c) . sel])
+ (let* ((c (Pcaml.rename_id.val c))
+ (tl (List.map ctyp_se sel)))
+ <:str_item< exception $c$ of $list:tl$ >>))
+ ((Sexpr loc [(Slid _ (as (or "define" "definerec") r)) se . sel])
+ (let* ((r (= r "definerec"))
+ ((values p e) (fun_binding_se se (begin_se loc sel))))
+ <:str_item< value $opt:r$ $p$ = $e$ >>))
+ ((Sexpr loc [(Slid _ (as (or "define*" "definerec*") r)) . sel])
+ (let* ((r (= r "definerec*"))
+ (lbs (List.map let_binding_se sel)))
+ <:str_item< value $opt:r$ $list:lbs$ >>))
+ ((Sexpr loc [(Slid _ "external") (Slid _ i) se . sel])
+ (let* ((i (Pcaml.rename_id.val i))
+ (pd (List.map string_se sel))
+ (t (ctyp_se se)))
+ <:str_item< external $i$ : $t$ = $list:pd$ >>))
+ ((Sexpr loc [(Slid _ "module") (Suid _ i) se])
+ (let* ((i (Pcaml.rename_id.val i))
+ (mb (module_binding_se se)))
+ <:str_item< module $i$ = $mb$ >>))
+ ((Sexpr loc [(Slid _ "moduletype") (Suid _ s) se])
+ (let* ((s (Pcaml.rename_id.val s))
+ (mt (module_type_se se)))
+ <:str_item< module type $s$ = $mt$ >>))
+ (_
+ (let* ((loc (loc_of_sexpr se))
+ (e (expr_se se)))
+ <:str_item< $exp:e$ >>))))
+ ((module_binding_se se) (module_expr_se se))
+ (expr_se
+ (lambda_match
+ ((Sacc loc se1 se2)
+ (let ((e1 (expr_se se1)))
+ (match se2
+ ((Slist loc [se2])
+ (let ((e2 (expr_se se2))) <:expr< $e1$ .[ $e2$ ] >>))
+ ((Sexpr loc [se2])
+ (let ((e2 (expr_se se2))) <:expr< $e1$ .( $e2$ ) >>))
+ (_ (let ((e2 (expr_se se2))) <:expr< $e1$ . $e2$ >>)))))
+ ((Slid loc s) (lident_expr loc s))
+ ((Suid loc s) <:expr< $uid:(Pcaml.rename_id.val s)$ >>)
+ ((Sint loc s) <:expr< $int:s$ >>)
+ ((Sfloat loc s) <:expr< $flo:s$ >>)
+ ((Schar loc s) <:expr< $chr:s$ >>)
+ ((Sstring loc s) <:expr< $str:s$ >>)
+ ((Stid loc s) <:expr< ~ $(Pcaml.rename_id.val s)$ >>)
+ ((Sqid loc s) <:expr< ? $(Pcaml.rename_id.val s)$ >>)
+ ((Sexpr loc []) <:expr< () >>)
+ ((when (Sexpr loc [(Slid _ s) e1 . (as [_ . _] sel)])
+ (List.mem s assoc_left_parsed_op_list))
+ (letrec
+ (((loop e1)
+ (lambda_match
+ ([] e1)
+ ([e2 . el] (loop (op_apply loc e1 e2 s) el)))))
+ (loop (expr_se e1) (List.map expr_se sel))))
+ ((when (Sexpr loc [(Slid _ s) . (as [_ _ . _] sel)])
+ (List.mem s assoc_right_parsed_op_list))
+ (letrec
+ ((loop
+ (lambda_match
+ ([]
+ (assert False))
+ ([e1] e1)
+ ([e1 . el] (let ((e2 (loop el))) (op_apply loc e1 e2 s))))))
+ (loop (List.map expr_se sel))))
+ ((when (Sexpr loc [(Slid _ s) . (as [_ _ . _] sel)])
+ (List.mem s and_by_couple_op_list))
+ (letrec
+ ((loop
+ (lambda_match
+ ((or [] [_]) (assert False))
+ ([e1 e2] <:expr< $lid:s$ $e1$ $e2$ >>)
+ ([e1 . (as [e2 _ . _] el)]
+ (let* ((a1 (op_apply loc e1 e2 s))
+ (a2 (loop el)))
+ <:expr< $a1$ && $a2$ >>)))))
+ (loop (List.map expr_se sel))))
+ ((Sexpr loc [(Stid _ s) se])
+ (let ((e (expr_se se))) <:expr< ~ $s$ : $e$ >>))
+ ((Sexpr loc [(Slid _ "-") se])
+ (let ((e (expr_se se))) <:expr< - $e$ >>))
+ ((Sexpr loc [(Slid _ "if") se se1])
+ (let* ((e (expr_se se))
+ (e1 (expr_se se1)))
+ <:expr< if $e$ then $e1$ else () >>))
+ ((Sexpr loc [(Slid _ "if") se se1 se2])
+ (let* ((e (expr_se se))
+ (e1 (expr_se se1))
+ (e2 (expr_se se2)))
+ <:expr< if $e$ then $e1$ else $e2$ >>))
+ ((Sexpr loc [(Slid _ "cond") . sel])
+ (letrec
+ ((loop
+ (lambda_match
+ ([(Sexpr loc [(Slid _ "else") . sel])] (begin_se loc sel))
+ ([(Sexpr loc [se1 . sel1]) . sel]
+ (let* ((e1 (expr_se se1))
+ (e2 (begin_se loc sel1))
+ (e3 (loop sel)))
+ <:expr< if $e1$ then $e2$ else $e3$ >>))
+ ([] <:expr< () >>)
+ ([se . _] (error se "cond clause")))))
+ (loop sel)))
+ ((Sexpr loc [(Slid _ "while") se . sel])
+ (let* ((e (expr_se se))
+ (el (List.map expr_se sel)))
+ <:expr< while $e$ do { $list:el$ } >>))
+ ((Sexpr loc [(Slid _ "for") (Slid _ i) se1 se2 . sel])
+ (let* ((i (Pcaml.rename_id.val i))
+ (e1 (expr_se se1))
+ (e2 (expr_se se2))
+ (el (List.map expr_se sel)))
+ <:expr< for $i$ = $e1$ to $e2$ do { $list:el$ } >>))
+ ((Sexpr loc [(Slid loc1 "lambda")]) <:expr< fun [] >>)
+ ((Sexpr loc [(Slid loc1 "lambda") sep . sel])
+ (let ((e (begin_se loc1 sel)))
+ (match (ipatt_opt_se sep)
+ ((Left p) <:expr< fun $p$ -> $e$ >>)
+ ((Right (values se sel))
+ (List.fold_right
+ (lambda (se e)
+ (let ((p (ipatt_se se))) <:expr< fun $p$ -> $e$ >>))
+ [se . sel] e)))))
+ ((Sexpr loc [(Slid _ "lambda_match") . sel])
+ (let ((pel (List.map (match_case loc) sel)))
+ <:expr< fun [ $list:pel$ ] >>))
+ ((Sexpr loc [(Slid _ (as (or "let" "letrec") r)) . sel])
+ (match sel
+ ([(Sexpr _ sel1) . sel2]
+ (let* ((r (= r "letrec"))
+ (lbs (List.map let_binding_se sel1))
+ (e (begin_se loc sel2)))
+ <:expr< let $opt:r$ $list:lbs$ in $e$ >>))
+ ([(Slid _ n) (Sexpr _ sl) . sel]
+ (let* ((n (Pcaml.rename_id.val n))
+ ((values pl el)
+ (List.fold_right
+ (lambda (se (values pl el))
+ (match se
+ ((Sexpr _ [se1 se2])
+ (values [(patt_se se1) . pl]
+ [(expr_se se2) . el]))
+ (se (error se "named let"))))
+ sl (values [] [])))
+ (e1
+ (List.fold_right
+ (lambda (p e) <:expr< fun $p$ -> $e$ >>)
+ pl (begin_se loc sel)))
+ (e2
+ (List.fold_left
+ (lambda (e1 e2) <:expr< $e1$ $e2$ >>)
+ <:expr< $lid:n$ >> el)))
+ <:expr< let rec $lid:n$ = $e1$ in $e2$ >>))
+ ([se . _] (error se "let_binding"))
+ (_ (error_loc loc "let_binding"))))
+ ((Sexpr loc [(Slid _ "let*") . sel])
+ (match sel
+ ([(Sexpr _ sel1) . sel2]
+ (List.fold_right
+ (lambda (se ek)
+ (let (((values p e) (let_binding_se se)))
+ <:expr< let $p$ = $e$ in $ek$ >>))
+ sel1 (begin_se loc sel2)))
+ ([se . _] (error se "let_binding"))
+ (_ (error_loc loc "let_binding"))))
+ ((Sexpr loc [(Slid _ "match") se . sel])
+ (let* ((e (expr_se se))
+ (pel (List.map (match_case loc) sel)))
+ <:expr< match $e$ with [ $list:pel$ ] >>))
+ ((Sexpr loc [(Slid _ "parser") . sel])
+ (let ((e
+ (match sel
+ ([(as (Slid _ _) se) . sel]
+ (let* ((p (patt_se se))
+ (pc (parser_cases_se loc sel)))
+ <:expr< let $p$ = Stream.count $lid:strm_n$ in $pc$ >>))
+ (_ (parser_cases_se loc sel)))))
+ <:expr< fun ($lid:strm_n$ : Stream.t _) -> $e$ >>))
+ ((Sexpr loc [(Slid _ "match_with_parser") se . sel])
+ (let* ((me (expr_se se))
+ ((values bpo sel)
+ (match sel
+ ([(as (Slid _ _) se) . sel] (values (Some (patt_se se)) sel))
+ (_ (values None sel))))
+ (pc (parser_cases_se loc sel))
+ (e
+ (match bpo
+ ((Some bp)
+ <:expr< let $bp$ = Stream.count $lid:strm_n$ in $pc$ >>)
+ (None pc))))
+ (match me
+ ((when <:expr< $lid:x$ >> (= x strm_n)) e)
+ (_ <:expr< let ($lid:strm_n$ : Stream.t _) = $me$ in $e$ >>))))
+ ((Sexpr loc [(Slid _ "try") se . sel])
+ (let* ((e (expr_se se))
+ (pel (List.map (match_case loc) sel)))
+ <:expr< try $e$ with [ $list:pel$ ] >>))
+ ((Sexpr loc [(Slid _ "begin") . sel])
+ (let ((el (List.map expr_se sel))) <:expr< do { $list:el$ } >>))
+ ((Sexpr loc [(Slid _ ":=") se1 se2])
+ (let* ((e1 (expr_se se1))
+ (e2 (expr_se se2)))
+ <:expr< $e1$ := $e2$ >>))
+ ((Sexpr loc [(Slid _ "values") . sel])
+ (let ((el (List.map expr_se sel))) <:expr< ( $list:el$ ) >>))
+ ((Srec loc [(Slid _ "with") se . sel])
+ (let* ((e (expr_se se))
+ (lel (List.map (label_expr_se loc) sel)))
+ <:expr< { ($e$) with $list:lel$ } >>))
+ ((Srec loc sel)
+ (let ((lel (List.map (label_expr_se loc) sel)))
+ <:expr< { $list:lel$ } >>))
+ ((Sexpr loc [(Slid _ ":") se1 se2])
+ (let* ((e (expr_se se1)) (t (ctyp_se se2))) <:expr< ( $e$ : $t$ ) >>))
+ ((Sexpr loc [se]) (let ((e (expr_se se))) <:expr< $e$ () >>))
+ ((Sexpr loc [(Slid _ "assert") (Suid _ "False")])
+ <:expr< assert False >>)
+ ((Sexpr loc [(Slid _ "assert") se])
+ (let ((e (expr_se se))) <:expr< assert $e$ >>))
+ ((Sexpr loc [(Slid _ "lazy") se])
+ (let ((e (expr_se se))) <:expr< lazy $e$ >>))
+ ((Sexpr loc [se . sel])
+ (List.fold_left
+ (lambda (e se) (let ((e1 (expr_se se))) <:expr< $e$ $e1$ >>))
+ (expr_se se) sel))
+ ((Slist loc sel)
+ (letrec ((loop
+ (lambda_match
+ ([] <:expr< [] >>)
+ ([se1 (Slid _ ".") se2]
+ (let* ((e (expr_se se1))
+ (el (expr_se se2)))
+ <:expr< [$e$ :: $el$] >>))
+ ([se . sel]
+ (let* ((e (expr_se se))
+ (el (loop sel)))
+ <:expr< [$e$ :: $el$] >>)))))
+ (loop sel)))
+ ((Squot loc typ txt)
+ (Pcaml.handle_expr_quotation loc (values typ txt)))))
+ ((begin_se loc)
+ (lambda_match
+ ([] <:expr< () >>)
+ ([se] (expr_se se))
+ ((sel)
+ (let* ((el (List.map expr_se sel))
+ (loc (values (fst (loc_of_sexpr (List.hd sel))) (snd loc))))
+ <:expr< do { $list:el$ } >>))))
+ (let_binding_se
+ (lambda_match
+ ((Sexpr loc [se . sel])
+ (let ((e (begin_se loc sel)))
+ (match (ipatt_opt_se se)
+ ((Left p) (values p e))
+ ((Right _) (fun_binding_se se e)))))
+ (se (error se "let_binding"))))
+ ((fun_binding_se se e)
+ (match se
+ ((Sexpr _ [(Slid _ "values") . _]) (values (ipatt_se se) e))
+ ((Sexpr _ [(Slid loc s) . sel])
+ (let* ((s (Pcaml.rename_id.val s))
+ (e
+ (List.fold_right
+ (lambda (se e)
+ (let* ((loc
+ (values (fst (loc_of_sexpr se))
+ (snd (MLast.loc_of_expr e))))
+ (p (ipatt_se se)))
+ <:expr< fun $p$ -> $e$ >>))
+ sel e))
+ (p <:patt< $lid:s$ >>))
+ (values p e)))
+ ((_) (values (ipatt_se se) e))))
+ ((match_case loc)
+ (lambda_match
+ ((Sexpr loc [(Sexpr _ [(Slid _ "when") se sew]) . sel])
+ (values (patt_se se) (Some (expr_se sew)) (begin_se loc sel)))
+ ((Sexpr loc [se . sel])
+ (values (patt_se se) None (begin_se loc sel)))
+ (se (error se "match_case"))))
+ ((label_expr_se loc)
+ (lambda_match
+ ((Sexpr _ [se1 se2]) (values (patt_se se1) (expr_se se2)))
+ (se (error se "label_expr"))))
+ ((label_patt_se loc)
+ (lambda_match
+ ((Sexpr _ [se1 se2]) (values (patt_se se1) (patt_se se2)))
+ (se (error se "label_patt"))))
+ ((parser_cases_se loc)
+ (lambda_match
+ ([] <:expr< raise Stream.Failure >>)
+ ([(Sexpr loc [(Sexpr _ spsel) . act]) . sel]
+ (let* ((ekont (lambda _ (parser_cases_se loc sel)))
+ (act (match act
+ ([se] (expr_se se))
+ ([sep se]
+ (let* ((p (patt_se sep))
+ (e (expr_se se)))
+ <:expr< let $p$ = Stream.count $lid:strm_n$ in $e$ >>))
+ (_ (error_loc loc "parser_case")))))
+ (stream_pattern_se loc act ekont spsel)))
+ ([se . _]
+ (error se "parser_case"))))
+ ((stream_pattern_se loc act ekont)
+ (lambda_match
+ ([] act)
+ ([se . sel]
+ (let* ((ckont (lambda err <:expr< raise (Stream.Error $err$) >>))
+ (skont (stream_pattern_se loc act ckont sel)))
+ (stream_pattern_component skont ekont <:expr< "" >> se)))))
+ ((stream_pattern_component skont ekont err)
+ (lambda_match
+ ((Sexpr loc [(Slid _ "`") se . wol])
+ (let* ((wo (match wol
+ ([se] (Some (expr_se se)))
+ ([] None)
+ (_ (error_loc loc "stream_pattern_component"))))
+ (e (peek_fun loc))
+ (p (patt_se se))
+ (j (junk_fun loc))
+ (k (ekont err)))
+ <:expr< match $e$ $lid:strm_n$ with
+ [ Some $p$ $when:wo$ -> do { $j$ $lid:strm_n$ ; $skont$ }
+ | _ -> $k$ ] >>))
+ ((Sexpr loc [se1 se2])
+ (let* ((p (patt_se se1))
+ (e (let ((e (expr_se se2)))
+ <:expr< try Some ($e$ $lid:strm_n$) with [ Stream.Failure -> None ] >>))
+ (k (ekont err)))
+ <:expr< match $e$ with [ Some $p$ -> $skont$ | _ -> $k$ ] >>))
+ ((Sexpr loc [(Slid _ "?") se1 se2])
+ (stream_pattern_component skont ekont (expr_se se2) se1))
+ ((Slid loc s)
+ (let ((s (Pcaml.rename_id.val s)))
+ <:expr< let $lid:s$ = $lid:strm_n$ in $skont$ >>))
+ (se
+ (error se "stream_pattern_component"))))
+ (patt_se
+ (lambda_match
+ ((Sacc loc se1 se2)
+ (let* ((p1 (patt_se se1)) (p2 (patt_se se2))) <:patt< $p1$ . $p2$ >>))
+ ((Slid loc "_") <:patt< _ >>)
+ ((Slid loc s) <:patt< $lid:(Pcaml.rename_id.val s)$ >>)
+ ((Suid loc s) <:patt< $uid:(Pcaml.rename_id.val s)$ >>)
+ ((Sint loc s) <:patt< $int:s$ >>)
+ ((Sfloat loc s) <:patt< $flo:s$ >>)
+ ((Schar loc s) <:patt< $chr:s$ >>)
+ ((Sstring loc s) <:patt< $str:s$ >>)
+ ((Stid loc _) (error_loc loc "patt"))
+ ((Sqid loc _) (error_loc loc "patt"))
+ ((Srec loc sel)
+ (let ((lpl (List.map (label_patt_se loc) sel)))
+ <:patt< { $list:lpl$ } >>))
+ ((Sexpr loc [(Slid _ ":") se1 se2])
+ (let* ((p (patt_se se1)) (t (ctyp_se se2))) <:patt< ($p$ : $t$) >>))
+ ((Sexpr loc [(Slid _ "or") se . sel])
+ (List.fold_left
+ (lambda (p se) (let ((p1 (patt_se se))) <:patt< $p$ | $p1$ >>))
+ (patt_se se) sel))
+ ((Sexpr loc [(Slid _ "range") se1 se2])
+ (let* ((p1 (patt_se se1)) (p2 (patt_se se2))) <:patt< $p1$ .. $p2$ >>))
+ ((Sexpr loc [(Slid _ "values") . sel])
+ (let ((pl (List.map patt_se sel))) <:patt< ( $list:pl$ ) >>))
+ ((Sexpr loc [(Slid _ "as") se1 se2])
+ (let* ((p1 (patt_se se1))
+ (p2 (patt_se se2)))
+ <:patt< ($p1$ as $p2$) >>))
+ ((Sexpr loc [se . sel])
+ (List.fold_left
+ (lambda (p se) (let ((p1 (patt_se se))) <:patt< $p$ $p1$ >>))
+ (patt_se se) sel))
+ ((Sexpr loc []) <:patt< () >>)
+ ((Slist loc sel)
+ (letrec ((loop
+ (lambda_match
+ ([] <:patt< [] >>)
+ ([se1 (Slid _ ".") se2]
+ (let* ((p (patt_se se1))
+ (pl (patt_se se2)))
+ <:patt< [$p$ :: $pl$] >>))
+ ([se . sel]
+ (let* ((p (patt_se se))
+ (pl (loop sel)))
+ <:patt< [$p$ :: $pl$] >>)))))
+ (loop sel)))
+ ((Squot loc typ txt)
+ (Pcaml.handle_patt_quotation loc (values typ txt)))))
+ ((ipatt_se se)
+ (match (ipatt_opt_se se)
+ ((Left p) p)
+ ((Right (values se _)) (error se "ipatt"))))
+ (ipatt_opt_se
+ (lambda_match
+ ((Slid loc "_") (Left <:patt< _ >>))
+ ((Slid loc s) (Left <:patt< $lid:(Pcaml.rename_id.val s)$ >>))
+ ((Stid loc s) (Left <:patt< ~ $(Pcaml.rename_id.val s)$ >>))
+ ((Sqid loc s) (Left <:patt< ? $(Pcaml.rename_id.val s)$ >>))
+ ((Sexpr loc [(Sqid _ s) se])
+ (let* ((s (Pcaml.rename_id.val s))
+ (e (expr_se se)))
+ (Left <:patt< ? ( $lid:s$ = $e$ ) >>)))
+ ((Sexpr loc [(Slid _ ":") se1 se2])
+ (let* ((p (ipatt_se se1)) (t (ctyp_se se2)))
+ (Left <:patt< ($p$ : $t$) >>)))
+ ((Sexpr loc [(Slid _ "values") . sel])
+ (let ((pl (List.map ipatt_se sel))) (Left <:patt< ( $list:pl$ ) >>)))
+ ((Sexpr loc []) (Left <:patt< () >>))
+ ((Sexpr loc [se . sel]) (Right (values se sel)))
+ (se (error se "ipatt"))))
+ (type_declaration_list_se
+ (lambda_match
+ ([se1 se2 . sel]
+ (let (((values n1 loc1 tpl)
+ (match se1
+ ((Sexpr _ [(Slid loc n) . sel])
+ (values n loc (List.map type_parameter_se sel)))
+ ((Slid loc n)
+ (values n loc []))
+ ((se)
+ (error se "type declaration")))))
+ [(values (values loc1 (Pcaml.rename_id.val n1)) tpl (ctyp_se se2) []) .
+ (type_declaration_list_se sel)]))
+ ([] [])
+ ([se . _] (error se "type_declaration"))))
+ (type_parameter_se
+ (lambda_match
+ ((when (Slid _ s) (and (>= (String.length s) 2) (= s.[0] ''')))
+ (values (String.sub s 1 (- (String.length s) 1)) (values False False)))
+ (se
+ (error se "type_parameter"))))
+ (ctyp_se
+ (lambda_match
+ ((Sexpr loc [(Slid _ "sum") . sel])
+ (let ((cdl (List.map constructor_declaration_se sel)))
+ <:ctyp< [ $list:cdl$ ] >>))
+ ((Srec loc sel)
+ (let ((ldl (List.map label_declaration_se sel)))
+ <:ctyp< { $list:ldl$ } >>))
+ ((Sexpr loc [(Slid _ "->") . (as [_ _ . _] sel)])
+ (letrec
+ ((loop
+ (lambda_match
+ ([] (assert False))
+ ([se] (ctyp_se se))
+ ([se . sel]
+ (let* ((t1 (ctyp_se se))
+ (loc (values (fst (loc_of_sexpr se)) (snd loc)))
+ (t2 (loop sel)))
+ <:ctyp< $t1$ -> $t2$ >>)))))
+ (loop sel)))
+ ((Sexpr loc [(Slid _ "*") . sel])
+ (let ((tl (List.map ctyp_se sel))) <:ctyp< ($list:tl$) >>))
+ ((Sexpr loc [se . sel])
+ (List.fold_left
+ (lambda (t se) (let ((t2 (ctyp_se se))) <:ctyp< $t$ $t2$ >>))
+ (ctyp_se se) sel))
+ ((Sacc loc se1 se2)
+ (let* ((t1 (ctyp_se se1)) (t2 (ctyp_se se2))) <:ctyp< $t1$ . $t2$ >>))
+ ((Slid loc "_") <:ctyp< _ >>)
+ ((Slid loc s)
+ (if (= s.[0] ''')
+ (let ((s (String.sub s 1 (- (String.length s) 1))))
+ <:ctyp< '$s$ >>)
+ <:ctyp< $lid:(Pcaml.rename_id.val s)$ >>))
+ ((Suid loc s) <:ctyp< $uid:(Pcaml.rename_id.val s)$ >>)
+ (se (error se "ctyp"))))
+ (constructor_declaration_se
+ (lambda_match
+ ((Sexpr loc [(Suid _ ci) . sel])
+ (values loc (Pcaml.rename_id.val ci) (List.map ctyp_se sel)))
+ (se
+ (error se "constructor_declaration"))))
+ (label_declaration_se
+ (lambda_match
+ ((Sexpr loc [(Slid _ lab) (Slid _ "mutable") se])
+ (values loc (Pcaml.rename_id.val lab) True (ctyp_se se)))
+ ((Sexpr loc [(Slid _ lab) se])
+ (values loc (Pcaml.rename_id.val lab) False (ctyp_se se)))
+ (se
+ (error se "label_declaration")))))
+
+(define directive_se
+ (lambda_match
+ ((Sexpr _ [(Slid _ s)]) (values s None))
+ ((Sexpr _ [(Slid _ s) se]) (let ((e (expr_se se))) (values s (Some e))))
+ (se (error se "directive"))))
+
+; Parser
+
+(:= Pcaml.syntax_name.val "Scheme")
+(:= Pcaml.no_constructors_arity.val False)
+
+(begin
+ (Grammar.Unsafe.gram_reinit gram (lexer_gmake ()))
+ (Grammar.Unsafe.clear_entry interf)
+ (Grammar.Unsafe.clear_entry implem)
+ (Grammar.Unsafe.clear_entry top_phrase)
+ (Grammar.Unsafe.clear_entry use_file)
+ (Grammar.Unsafe.clear_entry module_type)
+ (Grammar.Unsafe.clear_entry module_expr)
+ (Grammar.Unsafe.clear_entry sig_item)
+ (Grammar.Unsafe.clear_entry str_item)
+ (Grammar.Unsafe.clear_entry expr)
+ (Grammar.Unsafe.clear_entry patt)
+ (Grammar.Unsafe.clear_entry ctyp)
+ (Grammar.Unsafe.clear_entry let_binding)
+ (Grammar.Unsafe.clear_entry type_declaration)
+ (Grammar.Unsafe.clear_entry class_type)
+ (Grammar.Unsafe.clear_entry class_expr)
+ (Grammar.Unsafe.clear_entry class_sig_item)
+ (Grammar.Unsafe.clear_entry class_str_item))
+
+(:= Pcaml.parse_interf.val (Grammar.Entry.parse interf))
+(:= Pcaml.parse_implem.val (Grammar.Entry.parse implem))
+
+(define sexpr (Grammar.Entry.create gram "sexpr"))
+
+(definerec leftify
+ (lambda_match
+ ((Sacc loc1 se1 se2)
+ (match (leftify se2)
+ ((Sacc loc2 se2 se3) (Sacc loc1 (Sacc loc2 se1 se2) se3))
+ (se2 (Sacc loc1 se1 se2))))
+ (x x)))
+
+EXTEND
+ GLOBAL : implem interf top_phrase use_file str_item sig_item expr
+ patt sexpr /
+ implem :
+ [ [ "#" / se = sexpr ->
+ (let (((values n dp) (directive_se se)))
+ (values [(values <:str_item< # $n$ $opt:dp$ >> loc)] True))
+ | si = str_item / x = SELF ->
+ (let* (((values sil stopped) x)
+ (loc (MLast.loc_of_str_item si)))
+ (values [(values si loc) . sil] stopped))
+ | EOI -> (values [] False) ] ]
+ /
+ interf :
+ [ [ "#" / se = sexpr ->
+ (let (((values n dp) (directive_se se)))
+ (values [(values <:sig_item< # $n$ $opt:dp$ >> loc)] True))
+ | si = sig_item / x = SELF ->
+ (let* (((values sil stopped) x)
+ (loc (MLast.loc_of_sig_item si)))
+ (values [(values si loc) . sil] stopped))
+ | EOI -> (values [] False) ] ]
+ /
+ top_phrase :
+ [ [ "#" / se = sexpr ->
+ (let (((values n dp) (directive_se se)))
+ (Some <:str_item< # $n$ $opt:dp$ >>))
+ | se = sexpr -> (Some (str_item_se se))
+ | EOI -> None ] ]
+ /
+ use_file :
+ [ [ "#" / se = sexpr ->
+ (let (((values n dp) (directive_se se)))
+ (values [<:str_item< # $n$ $opt:dp$ >>] True))
+ | si = str_item / x = SELF ->
+ (let (((values sil stopped) x)) (values [si . sil] stopped))
+ | EOI -> (values [] False) ] ]
+ /
+ str_item :
+ [ [ se = sexpr -> (str_item_se se)
+ | e = expr -> <:str_item< $exp:e$ >> ] ]
+ /
+ sig_item :
+ [ [ se = sexpr -> (sig_item_se se) ] ]
+ /
+ expr :
+ [ "top"
+ [ se = sexpr -> (expr_se se) ] ]
+ /
+ patt :
+ [ [ se = sexpr -> (patt_se se) ] ]
+ /
+ sexpr :
+ [ [ se1 = sexpr_dot / se2 = sexpr -> (leftify (Sacc loc se1 se2)) ]
+ | [ "(" / sl = LIST0 sexpr / ")" -> (Sexpr loc sl)
+ | "(" / sl = LIST0 sexpr / ")." / se = sexpr ->
+ (leftify (Sacc loc (Sexpr loc sl) se))
+ | "[" / sl = LIST0 sexpr / "]" -> (Slist loc sl)
+ | "{" / sl = LIST0 sexpr / "}" -> (Srec loc sl)
+ | a = pa_extend_keyword -> (Slid loc a)
+ | s = LIDENT -> (Slid loc s)
+ | s = UIDENT -> (Suid loc s)
+ | s = TILDEIDENT -> (Stid loc s)
+ | s = QUESTIONIDENT -> (Sqid loc s)
+ | s = INT -> (Sint loc s)
+ | s = FLOAT -> (Sfloat loc s)
+ | s = CHAR -> (Schar loc s)
+ | s = STRING -> (Sstring loc s)
+ | s = QUOT ->
+ (let* ((i (String.index s ':'))
+ (typ (String.sub s 0 i))
+ (txt (String.sub s (+ i 1) (- (- (String.length s) i) 1))))
+ (Squot loc typ txt)) ] ]
+ /
+ sexpr_dot :
+ [ [ s = LIDENTDOT -> (Slid loc s)
+ | s = UIDENTDOT -> (Suid loc s) ] ]
+ /
+ pa_extend_keyword :
+ [ [ "_" -> "_"
+ | "," -> ","
+ | "=" -> "="
+ | ":" -> ":"
+ | "." -> "."
+ | "/" -> "/" ] ]
+ /
+END
--- /dev/null
+(* pa_r.cmo q_MLast.cmo pa_extfun.cmo pr_dump.cmo *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 2002 Institut National de Recherche en Informatique et *)
+(* en Automatique. All rights reserved. This file is distributed *)
+(* under the terms of the GNU Library General Public License, with *)
+(* the special exception on linking described in file *)
+(* ../../../LICENSE. *)
+(* *)
+(***********************************************************************)
+
+
+open Pcaml;
+open Format;
+
+type printer_t 'a =
+ { pr_fun : mutable string -> next 'a;
+ pr_levels : mutable list (pr_level 'a) }
+and pr_level 'a =
+ { pr_label : string;
+ pr_box : formatter -> (formatter -> unit) -> 'a -> unit;
+ pr_rules : mutable pr_rule 'a }
+and pr_rule 'a =
+ Extfun.t 'a (formatter -> curr 'a -> next 'a -> string -> kont -> unit)
+and curr 'a = formatter -> ('a * string * kont) -> unit
+and next 'a = formatter -> ('a * string * kont) -> unit
+and kont = formatter -> unit;
+
+value not_impl name x ppf k =
+ let desc =
+ if Obj.is_block (Obj.repr x) then
+ "tag = " ^ string_of_int (Obj.tag (Obj.repr x))
+ else "int_val = " ^ string_of_int (Obj.magic x)
+ in
+ fprintf ppf "<pr_scheme: not impl: %s; %s>%t" name desc k
+;
+
+value pr_fun name pr lab =
+ loop False pr.pr_levels where rec loop app =
+ fun
+ [ [] -> fun ppf (x, dg, k) -> failwith ("unable to print " ^ name)
+ | [lev :: levl] ->
+ if app || lev.pr_label = lab then
+ let next = loop True levl in
+ let rec curr ppf (x, dg, k) =
+ Extfun.apply lev.pr_rules x ppf curr next dg k
+ in
+ fun ppf ((x, _, _) as n) -> lev.pr_box ppf (fun ppf -> curr ppf n) x
+ else loop app levl ]
+;
+
+value rec find_pr_level lab =
+ fun
+ [ [] -> failwith ("level " ^ lab ^ " not found")
+ | [lev :: levl] ->
+ if lev.pr_label = lab then lev else find_pr_level lab levl ]
+;
+
+value pr_constr_decl = {pr_fun = fun []; pr_levels = []};
+value constr_decl ppf (x, k) = pr_constr_decl.pr_fun "top" ppf (x, "", k);
+pr_constr_decl.pr_fun := pr_fun "constr_decl" pr_constr_decl;
+
+value pr_ctyp = {pr_fun = fun []; pr_levels = []};
+pr_ctyp.pr_fun := pr_fun "ctyp" pr_ctyp;
+value ctyp ppf (x, k) = pr_ctyp.pr_fun "top" ppf (x, "", k);
+
+value pr_expr = {pr_fun = fun []; pr_levels = []};
+pr_expr.pr_fun := pr_fun "expr" pr_expr;
+value expr ppf (x, k) = pr_expr.pr_fun "top" ppf (x, "", k);
+
+value pr_label_decl = {pr_fun = fun []; pr_levels = []};
+value label_decl ppf (x, k) = pr_label_decl.pr_fun "top" ppf (x, "", k);
+pr_label_decl.pr_fun := pr_fun "label_decl" pr_label_decl;
+
+value pr_let_binding = {pr_fun = fun []; pr_levels = []};
+pr_let_binding.pr_fun := pr_fun "let_binding" pr_let_binding;
+value let_binding ppf (x, k) = pr_let_binding.pr_fun "top" ppf (x, "", k);
+
+value pr_match_assoc = {pr_fun = fun []; pr_levels = []};
+pr_match_assoc.pr_fun := pr_fun "match_assoc" pr_match_assoc;
+value match_assoc ppf (x, k) = pr_match_assoc.pr_fun "top" ppf (x, "", k);
+
+value pr_mod_ident = {pr_fun = fun []; pr_levels = []};
+pr_mod_ident.pr_fun := pr_fun "mod_ident" pr_mod_ident;
+value mod_ident ppf (x, k) = pr_mod_ident.pr_fun "top" ppf (x, "", k);
+
+value pr_module_binding = {pr_fun = fun []; pr_levels = []};
+pr_module_binding.pr_fun := pr_fun "module_binding" pr_module_binding;
+value module_binding ppf (x, k) =
+ pr_module_binding.pr_fun "top" ppf (x, "", k);
+
+value pr_module_expr = {pr_fun = fun []; pr_levels = []};
+pr_module_expr.pr_fun := pr_fun "module_expr" pr_module_expr;
+value module_expr ppf (x, k) = pr_module_expr.pr_fun "top" ppf (x, "", k);
+
+value pr_module_type = {pr_fun = fun []; pr_levels = []};
+pr_module_type.pr_fun := pr_fun "module_type" pr_module_type;
+value module_type ppf (x, k) = pr_module_type.pr_fun "top" ppf (x, "", k);
+
+value pr_patt = {pr_fun = fun []; pr_levels = []};
+pr_patt.pr_fun := pr_fun "patt" pr_patt;
+value patt ppf (x, k) = pr_patt.pr_fun "top" ppf (x, "", k);
+
+value pr_sig_item = {pr_fun = fun []; pr_levels = []};
+pr_sig_item.pr_fun := pr_fun "sig_item" pr_sig_item;
+value sig_item ppf (x, k) = pr_sig_item.pr_fun "top" ppf (x, "", k);
+
+value pr_str_item = {pr_fun = fun []; pr_levels = []};
+pr_str_item.pr_fun := pr_fun "str_item" pr_str_item;
+value str_item ppf (x, k) = pr_str_item.pr_fun "top" ppf (x, "", k);
+
+value pr_type_decl = {pr_fun = fun []; pr_levels = []};
+value type_decl ppf (x, k) = pr_type_decl.pr_fun "top" ppf (x, "", k);
+pr_type_decl.pr_fun := pr_fun "type_decl" pr_type_decl;
+
+value pr_type_params = {pr_fun = fun []; pr_levels = []};
+value type_params ppf (x, k) = pr_type_params.pr_fun "top" ppf (x, "", k);
+pr_type_params.pr_fun := pr_fun "type_params" pr_type_params;
+
+value pr_with_constr = {pr_fun = fun []; pr_levels = []};
+value with_constr ppf (x, k) = pr_with_constr.pr_fun "top" ppf (x, "", k);
+pr_with_constr.pr_fun := pr_fun "with_constr" pr_with_constr;
+
+(* general functions *)
+
+value nok ppf = ();
+value ks s k ppf = fprintf ppf "%s%t" s k;
+
+value rec list f ppf (l, k) =
+ match l with
+ [ [] -> k ppf
+ | [x] -> f ppf (x, k)
+ | [x :: l] -> fprintf ppf "%a@ %a" f (x, nok) (list f) (l, k) ]
+;
+
+value rec listwb b f ppf (l, k) =
+ match l with
+ [ [] -> k ppf
+ | [x] -> f ppf ((b, x), k)
+ | [x :: l] -> fprintf ppf "%a@ %a" f ((b, x), nok) (listwb "" f) (l, k) ]
+;
+
+(* specific functions *)
+
+value rec is_irrefut_patt =
+ fun
+ [ <:patt< $lid:_$ >> -> True
+ | <:patt< () >> -> True
+ | <:patt< _ >> -> True
+ | <:patt< ($x$ as $y$) >> -> is_irrefut_patt x && is_irrefut_patt y
+ | <:patt< { $list:fpl$ } >> ->
+ List.for_all (fun (_, p) -> is_irrefut_patt p) fpl
+ | <:patt< ($p$ : $_$) >> -> is_irrefut_patt p
+ | <:patt< ($list:pl$) >> -> List.for_all is_irrefut_patt pl
+ | <:patt< ? $_$ : ( $p$ ) >> -> is_irrefut_patt p
+ | <:patt< ? $_$ : ($p$ = $_$) >> -> is_irrefut_patt p
+ | <:patt< ~ $_$ >> -> True
+ | <:patt< ~ $_$ : $p$ >> -> is_irrefut_patt p
+ | _ -> False ]
+;
+
+value expr_fun_args ge = Extfun.apply pr_expr_fun_args.val ge;
+
+pr_expr_fun_args.val :=
+ extfun Extfun.empty with
+ [ <:expr< fun [$p$ -> $e$] >> as ge ->
+ if is_irrefut_patt p then
+ let (pl, e) = expr_fun_args e in
+ ([p :: pl], e)
+ else ([], ge)
+ | ge -> ([], ge) ];
+
+value sequence ppf (e, k) =
+ match e with
+ [ <:expr< do { $list:el$ } >> ->
+ fprintf ppf "@[<hv>%a@]" (list expr) (el, k)
+ | _ -> expr ppf (e, k) ]
+;
+
+value string ppf (s, k) = fprintf ppf "\"%s\"%t" s k;
+
+value int_repr s =
+ if String.length s > 2 && s.[0] = '0' then
+ match s.[1] with
+ [ 'b' | 'o' | 'x' | 'B' | 'O' | 'X' ->
+ "#" ^ String.sub s 1 (String.length s - 1)
+ | _ -> s ]
+ else s
+;
+
+value assoc_left_parsed_op_list = ["+"; "*"; "land"; "lor"; "lxor"];
+value assoc_right_parsed_op_list = ["and"; "or"; "^"; "@"];
+value and_by_couple_op_list = ["="; "<>"; "<"; ">"; "<="; ">="; "=="; "!="];
+
+(* extensible pretty print functions *)
+
+pr_constr_decl.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ (loc, c, []) ->
+ fun ppf curr next dg k -> fprintf ppf "(@[<hv>%s%t@]" c (ks ")" k)
+ | (loc, c, tl) ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[<hv>%s@ %a@]" c (list ctyp) (tl, ks ")" k) ]}];
+
+pr_ctyp.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ <:ctyp< [ $list:cdl$ ] >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[<hv>sum@ %a@]" (list constr_decl) (cdl, ks ")" k)
+ | <:ctyp< { $list:cdl$ } >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "{@[<hv>%a@]" (list label_decl) (cdl, ks "}" k)
+ | <:ctyp< ( $list:tl$ ) >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[* @[<hv>%a@]@]" (list ctyp) (tl, ks ")" k)
+ | <:ctyp< $t1$ -> $t2$ >> ->
+ fun ppf curr next dg k ->
+ let tl =
+ loop t2 where rec loop =
+ fun
+ [ <:ctyp< $t1$ -> $t2$ >> -> [t1 :: loop t2]
+ | t -> [t] ]
+ in
+ fprintf ppf "(@[-> @[<hv>%a@]@]" (list ctyp)
+ ([t1 :: tl], ks ")" k)
+ | <:ctyp< $t1$ $t2$ >> ->
+ fun ppf curr next dg k ->
+ let (t, tl) =
+ loop [t2] t1 where rec loop tl =
+ fun
+ [ <:ctyp< $t1$ $t2$ >> -> loop [t2 :: tl] t1
+ | t1 -> (t1, tl) ]
+ in
+ fprintf ppf "(@[%a@ %a@]" ctyp (t, nok) (list ctyp) (tl, ks ")" k)
+ | <:ctyp< $t1$ . $t2$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "%a.%a" ctyp (t1, nok) ctyp (t2, k)
+ | <:ctyp< $lid:s$ >> | <:ctyp< $uid:s$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "%s%t" s k
+ | <:ctyp< ' $s$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "'%s%t" s k
+ | <:ctyp< _ >> ->
+ fun ppf curr next dg k -> fprintf ppf "_%t" k
+ | x ->
+ fun ppf curr next dg k -> not_impl "ctyp" x ppf k ]}];
+
+pr_expr.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ <:expr< fun [] >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(lambda%t" (ks ")" k)
+ | <:expr< fun $lid:s$ -> $e$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(lambda@ %s@;<1 1>%a" s expr (e, ks ")" k)
+ | <:expr< fun [ $list:pwel$ ] >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[<hv>lambda_match@ %a@]" (list match_assoc)
+ (pwel, ks ")" k)
+ | <:expr< match $e$ with [ $list:pwel$ ] >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[<hv>@[<b 2>match@ %a@]@ %a@]" expr (e, nok)
+ (list match_assoc) (pwel, ks ")" k)
+ | <:expr< try $e$ with [ $list:pwel$ ] >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[<hv>@[<b 2>try@ %a@]@ %a@]" expr (e, nok)
+ (list match_assoc) (pwel, ks ")" k)
+ | <:expr< let $p1$ = $e1$ in $e2$ >> ->
+ fun ppf curr next dg k ->
+ let (pel, e) =
+ loop [(p1, e1)] e2 where rec loop pel =
+ fun
+ [ <:expr< let $p1$ = $e1$ in $e2$ >> ->
+ loop [(p1, e1) :: pel] e2
+ | e -> (List.rev pel, e) ]
+ in
+ let b =
+ match pel with
+ [ [_] -> "let"
+ | _ -> "let*" ]
+ in
+ fprintf ppf "(@[@[%s (@[<v>%a@]@]@;<1 2>%a@]" b
+ (listwb "" let_binding) (pel, ks ")" nok)
+ sequence (e, ks ")" k)
+ | <:expr< let $opt:rf$ $list:pel$ in $e$ >> ->
+ fun ppf curr next dg k ->
+ let b = if rf then "letrec" else "let" in
+ fprintf ppf "(@[<hv>%s@ (@[<hv>%a@]@ %a@]" b
+ (listwb "" let_binding) (pel, ks ")" nok) expr (e, ks ")" k)
+ | <:expr< if $e1$ then $e2$ else () >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(if @[%a@;<1 0>%a@]" expr (e1, nok)
+ expr (e2, ks ")" k)
+ | <:expr< if $e1$ then $e2$ else $e3$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(if @[%a@ %a@ %a@]" expr (e1, nok)
+ expr (e2, nok) expr (e3, ks ")" k)
+ | <:expr< do { $list:el$ } >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(begin@;<1 1>@[<hv>%a@]" (list expr) (el, ks ")" k)
+ | <:expr< for $i$ = $e1$ to $e2$ do { $list:el$ } >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[for %s@ %a@ %a %a@]" i expr (e1, nok)
+ expr (e2, nok) (list expr) (el, ks ")" k)
+ | <:expr< ($e$ : $t$) >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(:@ %a@ %a" expr (e, nok) ctyp (t, ks ")" k)
+ | <:expr< ($list:el$) >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(values @[%a@]" (list expr) (el, ks ")" k)
+ | <:expr< { $list:fel$ } >> ->
+ fun ppf curr next dg k ->
+ let record_binding ppf ((p, e), k) =
+ fprintf ppf "(@[%a@ %a@]" patt (p, nok) expr (e, ks ")" k)
+ in
+ fprintf ppf "{@[<hv>%a@]" (list record_binding) (fel, ks "}" k)
+ | <:expr< { ($e$) with $list:fel$ } >> ->
+ fun ppf curr next dg k ->
+ let record_binding ppf ((p, e), k) =
+ fprintf ppf "(@[%a@ %a@]" patt (p, nok) expr (e, ks ")" k)
+ in
+ fprintf ppf "{@[@[with@ %a@]@ @[%a@]@]" expr (e, nok)
+ (list record_binding) (fel, ks "}" k)
+ | <:expr< $e1$ := $e2$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(:=@;<1 1>%a@;<1 1>%a" expr (e1, nok)
+ expr (e2, ks ")" k)
+ | <:expr< [$_$ :: $_$] >> as e ->
+ fun ppf curr next dg k ->
+ let (el, c) =
+ make_list e where rec make_list e =
+ match e with
+ [ <:expr< [$e$ :: $y$] >> ->
+ let (el, c) = make_list y in
+ ([e :: el], c)
+ | <:expr< [] >> -> ([], None)
+ | x -> ([], Some e) ]
+ in
+ match c with
+ [ None ->
+ fprintf ppf "[%a" (list expr) (el, ks "]" k)
+ | Some x ->
+ fprintf ppf "[%a@ %a" (list expr) (el, ks " ." nok)
+ expr (x, ks "]" k) ]
+ | <:expr< lazy ($x$) >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[lazy@ %a@]" expr (x, ks ")" k)
+ | <:expr< $lid:s$ $e1$ $e2$ >>
+ when List.mem s assoc_right_parsed_op_list ->
+ fun ppf curr next dg k ->
+ let el =
+ loop [e1] e2 where rec loop el =
+ fun
+ [ <:expr< $lid:s1$ $e1$ $e2$ >> when s1 = s ->
+ loop [e1 :: el] e2
+ | e -> List.rev [e :: el] ]
+ in
+ fprintf ppf "(@[%s %a@]" s (list expr) (el, ks ")" k)
+ | <:expr< $e1$ $e2$ >> ->
+ fun ppf curr next dg k ->
+ let (f, el) =
+ loop [e2] e1 where rec loop el =
+ fun
+ [ <:expr< $e1$ $e2$ >> -> loop [e2 :: el] e1
+ | e1 -> (e1, el) ]
+ in
+ fprintf ppf "(@[%a@ %a@]" expr (f, nok) (list expr) (el, ks ")" k)
+ | <:expr< ~ $s$ : ($e$) >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(~%s@ %a" s expr (e, ks ")" k)
+ | <:expr< $e1$ .[ $e2$ ] >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "%a.[%a" expr (e1, nok) expr (e2, ks "]" k)
+ | <:expr< $e1$ .( $e2$ ) >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "%a.(%a" expr (e1, nok) expr (e2, ks ")" k)
+ | <:expr< $e1$ . $e2$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "%a.%a" expr (e1, nok) expr (e2, k)
+ | <:expr< $int:s$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "%s%t" (int_repr s) k
+ | <:expr< $lid:s$ >> | <:expr< $uid:s$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "%s%t" s k
+ | <:expr< ` $s$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "`%s%t" s k
+ | <:expr< $str:s$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "\"%s\"%t" s k
+ | <:expr< $chr:s$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "'%s'%t" s k
+ | x ->
+ fun ppf curr next dg k -> not_impl "expr" x ppf k ]}];
+
+pr_label_decl.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ (loc, f, m, t) ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[<hv>%s%t@ %a@]" f
+ (fun ppf -> if m then fprintf ppf "@ mutable" else ())
+ ctyp (t, ks ")" k) ]}];
+
+pr_let_binding.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ (b, (p, e)) ->
+ fun ppf curr next dg k ->
+ let (pl, e) = expr_fun_args e in
+ match pl with
+ [ [] ->
+ fprintf ppf "(@[<b 1>%s%s%a@ %a@]" b
+ (if b = "" then "" else " ") patt (p, nok)
+ sequence (e, ks ")" k)
+ | _ ->
+ fprintf ppf "(@[<b 1>%s%s(%a)@ %a@]" b
+ (if b = "" then "" else " ") (list patt) ([p :: pl], nok)
+ sequence (e, ks ")" k) ] ]}];
+
+pr_match_assoc.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ (p, we, e) ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[%t@ %a@]"
+ (fun ppf ->
+ match we with
+ [ Some e ->
+ fprintf ppf "(when@ %a@ %a" patt (p, nok)
+ expr (e, ks ")" nok)
+ | None -> patt ppf (p, nok) ])
+ sequence (e, ks ")" k) ]}];
+
+pr_mod_ident.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ [s] ->
+ fun ppf curr next dg k ->
+ fprintf ppf "%s%t" s k
+ | [s :: sl] ->
+ fun ppf curr next dg k ->
+ fprintf ppf "%s.%a" s curr (sl, "", k)
+ | x ->
+ fun ppf curr next dg k -> not_impl "mod_ident" x ppf k ]}];
+
+pr_module_binding.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ (b, s, me) ->
+ fun ppf curr next dg k ->
+ fprintf ppf "%s@ %s@ %a" b s module_expr (me, k) ]}];
+
+pr_module_expr.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ <:module_expr< functor ($i$ : $mt$) -> $me$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[@[@[functor@ %s@]@ %a@]@ %a@]"
+ i module_type (mt, nok) module_expr (me, ks ")" k)
+ | <:module_expr< struct $list:sil$ end >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[struct@ @[<hv>%a@]@]" (list str_item)
+ (sil, ks ")" k)
+ | <:module_expr< $me1$ $me2$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[%a@ %a@]" module_expr (me1, nok)
+ module_expr (me2, ks ")" k)
+ | <:module_expr< $uid:s$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "%s%t" s k
+ | x ->
+ fun ppf curr next dg k -> not_impl "module_expr" x ppf k ]}];
+
+pr_module_type.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ <:module_type< functor ($i$ : $mt1$) -> $mt2$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[@[@[functor@ %s@]@ %a@]@ %a@]"
+ i module_type (mt1, nok) module_type (mt2, ks ")" k)
+ | <:module_type< sig $list:sil$ end >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[sig@ @[<hv>%a@]@]" (list sig_item) (sil, ks ")" k)
+ | <:module_type< $mt$ with $list:wcl$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[with@;<1 2>@[%a@ (%a@]@]" module_type (mt, nok)
+ (list with_constr) (wcl, ks "))" k)
+ | <:module_type< $uid:s$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "%s%t" s k
+ | x ->
+ fun ppf curr next dg k -> not_impl "module_type" x ppf k ]}];
+
+pr_patt.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ <:patt< $p1$ | $p2$ >> ->
+ fun ppf curr next dg k ->
+ let (f, pl) =
+ loop [p2] p1 where rec loop pl =
+ fun
+ [ <:patt< $p1$ | $p2$ >> -> loop [p2 :: pl] p1
+ | p1 -> (p1, pl) ]
+ in
+ fprintf ppf "(@[or@ %a@ %a@]" patt (f, nok) (list patt)
+ (pl, ks ")" k)
+ | <:patt< ($p1$ as $p2$) >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[as@ %a@ %a@]" patt (p1, nok) patt (p2, ks ")" k)
+ | <:patt< $p1$ .. $p2$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[range@ %a@ %a@]" patt (p1, nok) patt (p2, ks ")" k)
+ | <:patt< [$_$ :: $_$] >> as p ->
+ fun ppf curr next dg k ->
+ let (pl, c) =
+ make_list p where rec make_list p =
+ match p with
+ [ <:patt< [$p$ :: $y$] >> ->
+ let (pl, c) = make_list y in
+ ([p :: pl], c)
+ | <:patt< [] >> -> ([], None)
+ | x -> ([], Some p) ]
+ in
+ match c with
+ [ None ->
+ fprintf ppf "[%a" (list patt) (pl, ks "]" k)
+ | Some x ->
+ fprintf ppf "[%a@ %a" (list patt) (pl, ks " ." nok)
+ patt (x, ks "]" k) ]
+ | <:patt< $p1$ $p2$ >> ->
+ fun ppf curr next dg k ->
+ let pl =
+ loop [p2] p1 where rec loop pl =
+ fun
+ [ <:patt< $p1$ $p2$ >> -> loop [p2 :: pl] p1
+ | p1 -> [p1 :: pl] ]
+ in
+ fprintf ppf "(@[%a@]" (list patt) (pl, ks ")" k)
+ | <:patt< ($p$ : $t$) >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(:@ %a@ %a" patt (p, nok) ctyp (t, ks ")" k)
+ | <:patt< ($list:pl$) >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(values @[%a@]" (list patt) (pl, ks ")" k)
+ | <:patt< { $list:fpl$ } >> ->
+ fun ppf curr next dg k ->
+ let record_binding ppf ((p1, p2), k) =
+ fprintf ppf "(@[%a@ %a@]" patt (p1, nok) patt (p2, ks ")" k)
+ in
+ fprintf ppf "(@[<hv>{}@ %a@]" (list record_binding) (fpl, ks ")" k)
+ | <:patt< ? $x$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "?%s%t" x k
+ | <:patt< ? ($lid:x$ = $e$) >> ->
+ fun ppf curr next dg k -> fprintf ppf "(?%s@ %a" x expr (e, ks ")" k)
+ | <:patt< $p1$ . $p2$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "%a.%a" patt (p1, nok) patt (p2, k)
+ | <:patt< $lid:s$ >> | <:patt< $uid:s$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "%s%t" s k
+ | <:patt< $str:s$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "\"%s\"%t" s k
+ | <:patt< $chr:s$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "'%s'%t" s k
+ | <:patt< $int:s$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "%s%t" (int_repr s) k
+ | <:patt< $flo:s$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "%s%t" s k
+ | <:patt< _ >> ->
+ fun ppf curr next dg k -> fprintf ppf "_%t" k
+ | x ->
+ fun ppf curr next dg k -> not_impl "patt" x ppf k ]}];
+
+pr_sig_item.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ <:sig_item< type $list:tdl$ >> ->
+ fun ppf curr next dg k ->
+ match tdl with
+ [ [td] -> fprintf ppf "(%a" type_decl (("type", td), ks ")" k)
+ | tdl ->
+ fprintf ppf "(@[<hv>type@ %a@]" (listwb "" type_decl)
+ (tdl, ks ")" k) ]
+ | <:sig_item< exception $c$ of $list:tl$ >> ->
+ fun ppf curr next dg k ->
+ match tl with
+ [ [] -> fprintf ppf "(@[exception@ %s%t@]" c (ks ")" k)
+ | tl ->
+ fprintf ppf "(@[@[exception@ %s@]@ %a@]" c
+ (list ctyp) (tl, ks ")" k) ]
+ | <:sig_item< value $i$ : $t$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[@[value %s@]@ %a@]" i ctyp (t, ks ")" k)
+ | <:sig_item< external $i$ : $t$ = $list:pd$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[@[external@ %s@]@ %a@ %a@]" i ctyp (t, nok)
+ (list string) (pd, ks ")" k)
+ | <:sig_item< module $s$ : $mt$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[@[module@ %s@]@ %a@]" s
+ module_type (mt, ks ")" k)
+ | <:sig_item< module type $s$ = $mt$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[@[moduletype@ %s@]@ %a@]" s
+ module_type (mt, ks ")" k)
+ | <:sig_item< declare $list:s$ end >> ->
+ fun ppf curr next dg k ->
+ if s = [] then fprintf ppf "; ..."
+ else fprintf ppf "%a" (list sig_item) (s, k)
+ | MLast.SgUse _ _ _ ->
+ fun ppf curr next dg k -> ()
+ | x ->
+ fun ppf curr next dg k -> not_impl "sig_item" x ppf k ]}];
+
+pr_str_item.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ <:str_item< open $i$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(open@ %a" mod_ident (i, ks ")" k)
+ | <:str_item< type $list:tdl$ >> ->
+ fun ppf curr next dg k ->
+ match tdl with
+ [ [td] -> fprintf ppf "(%a" type_decl (("type", td), ks ")" k)
+ | tdl ->
+ fprintf ppf "(@[<hv>type@ %a@]" (listwb "" type_decl)
+ (tdl, ks ")" k) ]
+ | <:str_item< exception $c$ of $list:tl$ >> ->
+ fun ppf curr next dg k ->
+ match tl with
+ [ [] -> fprintf ppf "(@[exception@ %s%t@]" c (ks ")" k)
+ | tl ->
+ fprintf ppf "(@[@[exception@ %s@]@ %a@]" c
+ (list ctyp) (tl, ks ")" k) ]
+ | <:str_item< value $opt:rf$ $list:pel$ >> ->
+ fun ppf curr next dg k ->
+ let b = if rf then "definerec" else "define" in
+ match pel with
+ [ [(p, e)] ->
+ fprintf ppf "%a" let_binding ((b, (p, e)), k)
+ | pel ->
+ fprintf ppf "(@[<hv 1>%s*@ %a@]" b (listwb "" let_binding)
+ (pel, ks ")" k) ]
+ | <:str_item< module $s$ = $me$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(%a" module_binding (("module", s, me), ks ")" k)
+ | <:str_item< module type $s$ = $mt$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[@[moduletype@ %s@]@ %a@]" s
+ module_type (mt, ks ")" k)
+ | <:str_item< external $i$ : $t$ = $list:pd$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(@[external@ %s@ %a@ %a@]" i ctyp (t, nok)
+ (list string) (pd, ks ")" k)
+ | <:str_item< $exp:e$ >> ->
+ fun ppf curr next dg k ->
+ fprintf ppf "%a" expr (e, k)
+ | <:str_item< # $s$ $opt:x$ >> ->
+ fun ppf curr next dg k ->
+ match x with
+ [ Some e -> fprintf ppf "; # (%s %a" s expr (e, ks ")" k)
+ | None -> fprintf ppf "; # (%s%t" s (ks ")" k) ]
+ | <:str_item< declare $list:s$ end >> ->
+ fun ppf curr next dg k ->
+ if s = [] then fprintf ppf "; ..."
+ else fprintf ppf "%a" (list str_item) (s, k)
+ | MLast.StUse _ _ _ ->
+ fun ppf curr next dg k -> ()
+ | x ->
+ fun ppf curr next dg k -> not_impl "str_item" x ppf k ]}];
+
+pr_type_decl.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ (b, ((_, tn), tp, te, cl)) ->
+ fun ppf curr next dg k ->
+ fprintf ppf "%t%t@;<1 1>%a"
+ (fun ppf ->
+ if b <> "" then fprintf ppf "%s@ " b
+ else ())
+ (fun ppf ->
+ match tp with
+ [ [] -> fprintf ppf "%s" tn
+ | tp -> fprintf ppf "(%s%a)" tn type_params (tp, nok) ])
+ ctyp (te, k) ]}];
+
+pr_type_params.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ [(s, vari) :: tpl] ->
+ fun ppf curr next dg k ->
+ fprintf ppf "@ '%s%a" s type_params (tpl, k)
+ | [] ->
+ fun ppf curr next dg k -> () ]}];
+
+pr_with_constr.pr_levels :=
+ [{pr_label = "top";
+ pr_box ppf f x = fprintf ppf "@[%t@]" f;
+ pr_rules =
+ extfun Extfun.empty with
+ [ MLast.WcTyp _ m tp te ->
+ fun ppf curr next dg k ->
+ fprintf ppf "(type@ %t@;<1 1>%a"
+ (fun ppf ->
+ match tp with
+ [ [] -> fprintf ppf "%a" mod_ident (m, nok)
+ | tp ->
+ fprintf ppf "(%a@ %a)" mod_ident (m, nok)
+ type_params (tp, nok) ])
+ ctyp (te, ks ")" k)
+ | x ->
+ fun ppf curr next dg k -> not_impl "with_constr" x ppf k ]}];
+
+(* main *)
+
+value output_string_eval ppf s =
+ loop 0 where rec loop i =
+ if i == String.length s then ()
+ else if i == String.length s - 1 then pp_print_char ppf s.[i]
+ else
+ match (s.[i], s.[i + 1]) with
+ [ ('\\', 'n') -> do { pp_print_char ppf '\n'; loop (i + 2) }
+ | (c, _) -> do { pp_print_char ppf c; loop (i + 1) } ]
+;
+
+value sep = Pcaml.inter_phrases;
+
+value input_source ic len =
+ let buff = Buffer.create 20 in
+ try
+ let rec loop i =
+ if i >= len then Buffer.contents buff
+ else do { let c = input_char ic in Buffer.add_char buff c; loop (i + 1) }
+ in
+ loop 0
+ with
+ [ End_of_file ->
+ let s = Buffer.contents buff in
+ if s = "" then
+ match sep.val with
+ [ Some s -> s
+ | None -> "\n" ]
+ else s ]
+;
+
+value copy_source ppf (ic, first, bp, ep) =
+ match sep.val with
+ [ Some str ->
+ if first then ()
+ else if ep == in_channel_length ic then pp_print_string ppf "\n"
+ else output_string_eval ppf str
+ | None ->
+ do {
+ seek_in ic bp;
+ let s = input_source ic (ep - bp) in pp_print_string ppf s
+ } ]
+;
+
+value copy_to_end ppf (ic, first, bp) =
+ let ilen = in_channel_length ic in
+ if bp < ilen then copy_source ppf (ic, first, bp, ilen)
+ else pp_print_string ppf "\n"
+;
+
+value apply_printer printer ast =
+ let ppf = std_formatter in
+ if Pcaml.input_file.val <> "-" && Pcaml.input_file.val <> "" then do {
+ let ic = open_in_bin Pcaml.input_file.val in
+ try
+ let (first, last_pos) =
+ List.fold_left
+ (fun (first, last_pos) (si, (bp, ep)) ->
+ do {
+ fprintf ppf "@[%a@]@?" copy_source (ic, first, last_pos.Lexing.pos_cnum, bp.Lexing.pos_cnum);
+ fprintf ppf "@[%a@]@?" printer (si, nok);
+ (False, ep)
+ })
+ (True, Token.nowhere) ast
+ in
+ fprintf ppf "@[%a@]@?" copy_to_end (ic, first, last_pos.Lexing.pos_cnum)
+ with x ->
+ do { fprintf ppf "@."; close_in ic; raise x };
+ close_in ic;
+ }
+ else failwith "not implemented"
+;
+
+Pcaml.print_interf.val := apply_printer sig_item;
+Pcaml.print_implem.val := apply_printer str_item;
+
+Pcaml.add_option "-l" (Arg.Int (fun x -> set_margin x))
+ "<length> Maximum line length for pretty printing.";
+
+Pcaml.add_option "-sep" (Arg.String (fun x -> sep.val := Some x))
+ "<string> Use this string between phrases instead of reading source.";
--- /dev/null
+(* pa_r.cmo q_MLast.cmo pa_extfun.cmo pr_dump.cmo *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 2002 Institut National de Recherche en Informatique et *)
+(* en Automatique. All rights reserved. This file is distributed *)
+(* under the terms of the GNU Library General Public License, with *)
+(* the special exception on linking described in file *)
+(* ../../../LICENSE. *)
+(* *)
+(***********************************************************************)
+
+
+open Format;
+open Pcaml;
+open Parserify;
+
+value nok = Pr_scheme.nok;
+value ks = Pr_scheme.ks;
+value patt = Pr_scheme.patt;
+value expr = Pr_scheme.expr;
+value find_pr_level = Pr_scheme.find_pr_level;
+value pr_expr = Pr_scheme.pr_expr;
+type printer_t 'a = Pr_scheme.printer_t 'a ==
+ { pr_fun : mutable string -> Pr_scheme.next 'a;
+ pr_levels : mutable list (pr_level 'a) }
+and pr_level 'a = Pr_scheme.pr_level 'a ==
+ { pr_label : string;
+ pr_box : formatter -> (formatter -> unit) -> 'a -> unit;
+ pr_rules : mutable Pr_scheme.pr_rule 'a }
+;
+
+(* extensions for rebuilding syntax of parsers *)
+
+value parser_cases ppf (spel, k) =
+ let rec parser_cases ppf (spel, k) =
+ match spel with
+ [ [] -> fprintf ppf "[: `HVbox [: b; k :] :]"
+ | [(sp, epo, e)] -> parser_case ppf (sp, epo, e, k)
+ | [(sp, epo, e) :: spel] ->
+ fprintf ppf "%a@ %a" parser_case (sp, epo, e, nok)
+ parser_cases (spel, k) ]
+ and parser_case ppf (sp, epo, e, k) =
+ fprintf ppf "(@[@[(%a)%t@]@ %a@]" stream_patt (sp, nok)
+ (fun ppf ->
+ match epo with
+ [ Some p -> fprintf ppf "@ %a" patt (p, nok)
+ | None -> () ])
+ expr (e, ks ")" k)
+ and stream_patt ppf (sp, k) =
+ match sp with
+ [ [] -> k ppf
+ | [(spc, None)] -> fprintf ppf "%a" stream_patt_comp (spc, k)
+ | [(spc, Some e)] ->
+ fprintf ppf "(@[? %a@ %a@]" stream_patt_comp (spc, nok)
+ expr (e, ks ")" k)
+ | [(spc, None) :: spcl] ->
+ fprintf ppf "%a@ %a" stream_patt_comp (spc, nok) stream_patt (spcl, k)
+ | [(spc, Some e) :: spcl] ->
+ fprintf ppf "(@[? %a@ %a@]@ %a" stream_patt_comp (spc, nok)
+ expr (e, ks ")" nok) stream_patt (spcl, k) ]
+ and stream_patt_comp ppf (spc, k) =
+ match spc with
+ [ SPCterm (p, w) ->
+ match w with
+ [ Some e ->
+ fprintf ppf "(` %a@ %a" patt (p, nok) expr (e, ks ")" k)
+ | None -> fprintf ppf "(` %a" patt (p, ks ")" k) ]
+ | SPCnterm p e ->
+ fprintf ppf "(@[%a %a@]" patt (p, nok) expr (e, ks ")" k)
+ | SPCsterm p -> fprintf ppf "%a" patt (p, k) ]
+ in
+ parser_cases ppf (spel, k)
+;
+
+value parser_body ppf (e, k) =
+ let (bp, e) =
+ match e with
+ [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e)
+ | e -> (None, e) ]
+ in
+ match parser_of_expr e with
+ [ [] ->
+ fprintf ppf "(parser%t%t"
+ (fun ppf ->
+ match bp with
+ [ Some p -> fprintf ppf "@ %a" patt (p, nok)
+ | _ -> ()])
+ (ks ")" k)
+ | spel ->
+ fprintf ppf "(@[<v>@[parser%t@]@ @[<v 0>%a@]@]"
+ (fun ppf ->
+ match bp with
+ [ Some p -> fprintf ppf "@ %a" patt (p, nok)
+ | _ -> ()])
+ parser_cases (spel, ks ")" k) ]
+;
+
+value pmatch ppf (e, k) =
+ let (me, e) =
+ match e with
+ [ <:expr< let (__strm : Stream.t _) = $me$ in $e$ >> -> (me, e)
+ | _ -> failwith "Pr_schp_main.pmatch" ]
+ in
+ let (bp, e) =
+ match e with
+ [ <:expr< let $bp$ = Stream.count __strm in $e$ >> -> (Some bp, e)
+ | e -> (None, e) ]
+ in
+ let spel = parser_of_expr e in
+ fprintf ppf "(@[@[match_with_parser@ %a@]%t@ @[<v 0>%a@]@]" expr (me, nok)
+ (fun ppf ->
+ match bp with
+ [ Some p -> fprintf ppf "@ %a" patt (p, nok)
+ | _ -> () ])
+ parser_cases (spel, ks ")" k)
+;
+
+pr_expr_fun_args.val :=
+ extfun pr_expr_fun_args.val with
+ [ <:expr< fun [(__strm : $_$) -> $_$] >> as ge -> ([], ge) ];
+
+let lev = find_pr_level "top" pr_expr.pr_levels in
+lev.pr_rules :=
+ extfun lev.pr_rules with
+ [ <:expr< fun (__strm : $_$) -> $x$ >> ->
+ fun ppf curr next dg k -> fprintf ppf "%a" parser_body (x, k)
+ | <:expr< let (__strm : Stream.t _) = $_$ in $_$ >> as e ->
+ fun ppf curr next dg k -> fprintf ppf "%a" pmatch (e, k) ];
--- /dev/null
+#########################################################################
+# #
+# Objective Caml #
+# #
+# Camlp4 #
+# #
+# Copyright 2004 Institut National de Recherche en Informatique et #
+# en Automatique. All rights reserved. This file is distributed #
+# under the terms of the Q Public License version 1.0. #
+# #
+#########################################################################
+#
+# Makefile for pa_sml
+# M.Mauny
+#
+
+include ../../config/Makefile.cnf
+
+OCAMLTOP=../../..
+
+OCAMLC=$(OCAMLTOP)/ocamlc$(EXE) -nostdlib -I $(OCAMLTOP)/stdlib
+OCAMLOPT=$(OCAMLTOP)/ocamlopt$(EXE) -nostdlib -I $(OCAMLTOP)/stdlib
+
+P4INCLUDES=-I ../../meta -I ../../etc -I ../../lib -I ../../camlp4
+OCAMLINCLUDES=-I ../../meta -I ../../lib -I ../../camlp4
+
+CAMLP4=camlp4$(EXE) -nolib
+OCAMLCFLAGS=-warn-error A $(OCAMLINCLUDES)
+
+SRC=pa_sml.ml
+OBJS=$(SRC:.ml=.cmo)
+OBJSX=$(SRC:.ml=.cmx)
+
+all: $(OBJS) smllib.cmo
+
+opt: $(OBJSX) smllib.cmx
+
+depend:
+ cp .depend .depend.bak
+ > .depend
+ for file in $(SRC); do \
+ $(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $$file` pr_depend.cmo $$i | \
+ sed -e 's| \.\./\.\./\.\.| $$(OCAMLTOP)|g' >> .depend; \
+ done
+
+clean:
+ rm -f *.cm* *.o *.bak .*.bak
+
+
+.SUFFIXES: .cmx .cmo .cmi .ml .mli .sml
+
+.mli.cmi:
+ $(OCAMLC) $(OCAMLCFLAGS) -c $<
+
+
+.sml.cmo:
+ $(OCAMLC) -I ../../../otherlibs/unix -pp "$(CAMLP4) ./pa_sml.cmo ../../meta/pr_dump.cmo -impl" -c -o $*.cmo -impl $<
+
+.sml.cmx:
+ $(OCAMLOPT) -I ../../../otherlibs/unix -pp "$(CAMLP4) ./pa_sml.cmo ../../meta/pr_dump.cmo -impl" -c -o $*.cmx -impl $<
+
+.ml.cmo:
+ $(OCAMLC) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $<
+
+.ml.cmx:
+ $(OCAMLOPT) $(OCAMLCFLAGS) -pp "$(CAMLP4) $(P4INCLUDES) `awk 'NR == 1 { ORS=" "; for (i=2; i < NF; i++) print $$i; } ' $<`" -c $<
+
+include .depend
--- /dev/null
+This is an application of or an extension for Camlp4. Although it is
+currently distributed with OCaml/Camlp4, it may or may not be
+actively maintained.
+
+It probably won't be part of future OCaml/Camlp4 distributions but be
+accessible from the Camlp4 hump. If you are interested in developing
+this package further and/or actively maintain it, please let us know
+(caml@inria.fr)
+
+This package is distributed under the same license as the Objective
+Caml Library (that is, LGPL with a special exception allowing both
+static and dynamic link).
+
+-- Michel Mauny
+
--- /dev/null
+(* pa_r.cmo pa_rp.cmo pa_extend.cmo q_MLast.cmo pr_dump.cmo *)
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 2002 Institut National de Recherche en Informatique et *)
+(* en Automatique. All rights reserved. This file is distributed *)
+(* under the terms of the GNU Library General Public License, with *)
+(* the special exception on linking described in file *)
+(* ../../../LICENSE. *)
+(* *)
+(***********************************************************************)
+
+
+
+open Stdpp;
+open Pcaml;
+
+value ocaml_records = ref False;
+
+Pcaml.no_constructors_arity.val := True;
+
+value lexer = Plexer.gmake ();
+
+do {
+ Grammar.Unsafe.gram_reinit gram lexer;
+ Grammar.Unsafe.clear_entry interf;
+ Grammar.Unsafe.clear_entry implem;
+ Grammar.Unsafe.clear_entry top_phrase;
+ Grammar.Unsafe.clear_entry use_file;
+ Grammar.Unsafe.clear_entry module_type;
+ Grammar.Unsafe.clear_entry module_expr;
+ Grammar.Unsafe.clear_entry sig_item;
+ Grammar.Unsafe.clear_entry str_item;
+ Grammar.Unsafe.clear_entry expr;
+ Grammar.Unsafe.clear_entry patt;
+ Grammar.Unsafe.clear_entry ctyp;
+ Grammar.Unsafe.clear_entry let_binding;
+};
+
+Pcaml.parse_interf.val := Grammar.Entry.parse interf;
+Pcaml.parse_implem.val := Grammar.Entry.parse implem;
+
+value not_impl loc s =
+ raise_with_loc loc (Stream.Error ("not implemented feature [" ^ s ^ "]"))
+;
+
+type altern 'a 'b = [ Left of 'a | Right of 'b ];
+
+value get_seq =
+ fun
+ [ <:expr< do { $list:el$ } >> -> el
+ | e -> [e] ]
+;
+
+value choose_tvar tpl =
+ let rec find_alpha v =
+ let s = String.make 1 v in
+ if List.mem_assoc s tpl then
+ if v = 'z' then None else find_alpha (Char.chr (Char.code v + 1))
+ else Some (String.make 1 v)
+ in
+ let rec make_n n =
+ let v = "a" ^ string_of_int n in
+ if List.mem_assoc v tpl then make_n (succ n) else v
+ in
+ match find_alpha 'a' with
+ [ Some x -> x
+ | None -> make_n 1 ]
+;
+
+value mklistexp loc last =
+ loop True where rec loop top =
+ fun
+ [ [] ->
+ match last with
+ [ Some e -> e
+ | None -> <:expr< [] >> ]
+ | [e1 :: el] ->
+ let loc = if top then loc else (fst (MLast.loc_of_expr e1), snd loc) in
+ <:expr< [$e1$ :: $loop False el$] >> ]
+;
+
+value mklistpat loc last =
+ loop True where rec loop top =
+ fun
+ [ [] ->
+ match last with
+ [ Some p -> p
+ | None -> <:patt< [] >> ]
+ | [p1 :: pl] ->
+ let loc = if top then loc else (fst (MLast.loc_of_patt p1), snd loc) in
+ <:patt< [$p1$ :: $loop False pl$] >> ]
+;
+
+value expr_of_patt p =
+ let loc = MLast.loc_of_patt p in
+ match p with
+ [ <:patt< $lid:x$ >> -> <:expr< $lid:x$ >>
+ | _ -> Stdpp.raise_with_loc loc (Stream.Error "identifier expected") ]
+;
+
+value apply_bind loc e bl =
+ let rec loop e =
+ fun
+ [ [] -> e
+ | [<:str_item< value $p1$ = $e1$ >> :: list] ->
+ loop_let e [(p1, e1)] list
+ | [<:str_item< value rec $p1$ = $e1$ >> :: list] ->
+ loop_letrec e [(p1, e1)] list
+ | [<:str_item< module $s$ = $me$ >> :: list] ->
+ let e = <:expr< let module $s$ = $me$ in $e$ >> in
+ loop e list
+ | [si :: list] ->
+ raise Exit ]
+ and loop_let e pel =
+ fun
+ [ [<:str_item< value $p1$ = $e1$ >> :: list] ->
+ loop_let e [(p1, e1) :: pel] list
+ | list ->
+ let e = <:expr< let $list:pel$ in $e$ >> in
+ loop e list ]
+ and loop_letrec e pel =
+ fun
+ [ [<:str_item< value rec $p1$ = $e1$ >> :: list] ->
+ loop_letrec e [(p1, e1) :: pel] list
+ | list ->
+ let e = <:expr< let rec $list:pel$ in $e$ >> in
+ loop e list ]
+ in
+ loop e (List.rev bl)
+;
+
+value make_local loc sl1 sl2 =
+ try
+ let pl =
+ List.map
+ (fun
+ [ <:str_item< value $opt:_$ $p$ = $_$ >> -> p
+ | _ -> raise Exit ])
+ sl2
+ in
+ let e1 =
+ match List.map expr_of_patt pl with
+ [ [e] -> e
+ | el -> <:expr< ($list:el$) >> ]
+ in
+ let p1 =
+ match pl with
+ [ [p] -> p
+ | pl -> <:patt< ($list:pl$) >> ]
+ in
+ let e = apply_bind loc e1 sl2 in
+ let e = apply_bind loc e sl1 in
+ <:str_item< value $p1$ = $e$ >>
+ with
+ [ Exit ->
+ do {
+ Printf.eprintf "\
+*** Warning: a 'local' statement will be defined global because of bindings
+which cannot be defined as first class values (modules, exceptions, ...)\n";
+ flush stderr;
+ <:str_item< declare $list:sl1 @ sl2$ end >>
+ } ]
+;
+
+value str_declare loc =
+ fun
+ [ [d] -> d
+ | dl -> <:str_item< declare $list:dl$ end >> ]
+;
+
+value sig_declare loc =
+ fun
+ [ [d] -> d
+ | dl -> <:sig_item< declare $list:dl$ end >> ]
+;
+
+value extract_label_types loc tn tal cdol =
+ let (cdl, aux) =
+ List.fold_right
+ (fun (loc, c, tl, aux_opt) (cdl, aux) ->
+ match aux_opt with
+ [ Some anon_record_type ->
+ let new_tn = tn ^ "_" ^ c in
+ let loc = MLast.loc_of_ctyp anon_record_type in
+ let aux_def = ((loc, new_tn), [], anon_record_type, []) in
+ let tl = [<:ctyp< $lid:new_tn$ >>] in
+ ([(loc, c, tl) :: cdl], [aux_def :: aux])
+ | None -> ([(loc, c, tl) :: cdl], aux) ])
+ cdol ([], [])
+ in
+ [((loc, tn), tal, <:ctyp< [ $list:cdl$ ] >>, []) :: aux]
+;
+
+value function_of_clause_list loc xl =
+ let (fname, fname_loc, nbpat, l) =
+ List.fold_left
+ (fun (fname, fname_loc, nbpat, l) ((x1, loc), x2, x3, x4) ->
+ let (fname, fname_loc, nbpat) =
+ if fname = "" then (x1, loc, List.length x2)
+ else if x1 <> fname then
+ raise_with_loc loc
+ (Stream.Error ("'" ^ fname ^ "' expected"))
+ else if List.length x2 <> nbpat then
+ raise_with_loc loc
+ (Stream.Error "bad number of patterns in that clause")
+ else (fname, fname_loc, nbpat)
+ in
+ let x4 =
+ match x3 with
+ [ Some t -> <:expr< ($x4$ : $t$) >>
+ | _ -> x4 ]
+ in
+ let l = [(x2, x4) :: l] in
+ (fname, fname_loc, nbpat, l))
+ ("", loc, 0, []) xl
+ in
+ let l = List.rev l in
+ let e =
+ match l with
+ [ [(pl, e)] ->
+ List.fold_right (fun p e -> <:expr< fun $p$ -> $e$ >>) pl e
+ | _ ->
+ if nbpat = 1 then
+ let pwel =
+ List.map
+ (fun (pl, e) -> (<:patt< $List.hd pl$ >>, None, e)) l
+ in
+ <:expr< fun [ $list:pwel$ ] >>
+ else
+ let sl =
+ loop 0 where rec loop n =
+ if n = nbpat then []
+ else ["a" ^ string_of_int (n + 1) :: loop (n + 1)]
+ in
+ let e =
+ let el = List.map (fun s -> <:expr< $lid:s$ >>) sl in
+ let pwel =
+ List.map
+ (fun (pl, e) -> (<:patt< ($list:pl$) >>, None, e)) l
+ in
+ <:expr< match ($list:el$) with [ $list:pwel$ ] >>
+ in
+ List.fold_right (fun s e -> <:expr< fun $lid:s$ -> $e$ >>) sl e ]
+ in
+ (let loc = fname_loc in <:patt< $lid:fname$ >>, e)
+;
+
+value record_expr loc x1 =
+ if ocaml_records.val then <:expr< { $list:x1$ } >>
+ else
+ let list1 =
+ List.map
+ (fun (l, v) ->
+ let id =
+ match l with
+ [ <:patt< $lid:l$ >> -> l
+ | _ -> "" ]
+ in
+ let loc = MLast.loc_of_expr v in
+ <:class_str_item< value $id$ = $v$ >>)
+ x1
+ in
+ let list2 =
+ List.map
+ (fun (l, v) ->
+ let id =
+ match l with
+ [ <:patt< $lid:l$ >> -> l
+ | _ -> "" ]
+ in
+ let loc = MLast.loc_of_patt l in
+ <:class_str_item< method $id$ = $lid:id$ >>)
+ x1
+ in
+ <:expr<
+ let module M =
+ struct
+ class a = object $list:list1 @ list2$ end;
+ end
+ in
+ new M.a
+ >>
+;
+
+value record_match_assoc loc lpl e =
+ if ocaml_records.val then (<:patt< { $list:lpl$ } >>, e)
+ else
+ let pl = List.map (fun (_, p) -> p) lpl in
+ let e =
+ let el =
+ List.map
+ (fun (l, _) ->
+ let s =
+ match l with
+ [ <:patt< $lid:l$ >> -> l
+ | _ -> "" ]
+ in
+ let loc = MLast.loc_of_patt l in
+ <:expr< v # $lid:s$ >>)
+ lpl
+ in
+ let loc = MLast.loc_of_expr e in
+ <:expr< let v = $e$ in ($list:el$) >>
+ in
+ let p = <:patt< ($list:pl$) >> in
+ (p, e)
+;
+
+value op =
+ Grammar.Entry.of_parser gram "op"
+ (parser [: `("", "op"); `(_, x) :] -> x)
+;
+lexer.Token.tok_using ("", "op");
+
+value special x =
+ if String.length x >= 2 then
+ match x.[0] with
+ [ '+' | '<' | '^' -> True
+ | _ -> False ]
+ else False
+;
+
+value idd =
+ let p =
+ parser
+ [ [: `("LIDENT", x) :] -> x
+ | [: `("UIDENT", x) :] -> x
+ | [: `("", "op"); `(_, x) :] -> x
+ | [: `("", x) when special x :] -> x ]
+ in
+ Grammar.Entry.of_parser Pcaml.gram "ID" p
+;
+
+value uncap s = String.uncapitalize s;
+
+EXTEND
+ GLOBAL: implem interf top_phrase use_file sig_item str_item ctyp patt expr
+ module_type module_expr;
+
+ implem:
+ [ [ x = interdec; EOI -> x ] ]
+ ;
+ interf:
+ [ [ x = LIST1 [ s = sig_item; OPT ";" -> (s, loc) ] -> (x, False) ] ]
+ ;
+ top_phrase:
+ [ [ ph = phrase; ";" -> Some ph
+ | EOI -> None ] ]
+ ;
+ use_file:
+ [ [ l = LIST0 phrase; EOI -> (l, False) ] ]
+ ;
+ phrase:
+ [ [ x = str_item -> x
+ | x = expr -> <:str_item< $exp:x$ >>
+ | "#"; n = LIDENT; dp = dir_param -> MLast.StDir loc n dp ] ]
+ ;
+ dir_param:
+ [ [ -> None
+ | e = expr -> Some e ] ]
+ ;
+ sdecs:
+ [ [ x = sdec; l = sdecs -> [x :: l]
+ | ";"; l = sdecs -> l
+ | -> [] ] ]
+ ;
+
+ fsigb: [ [ -> not_impl loc "fsigb" ] ];
+ fsigconstraint_op: [ [ -> not_impl loc "fsigconstraint_op" ] ];
+ fct_exp: [ [ -> not_impl loc "fct_exp" ] ];
+ exp_pa: [ [ -> not_impl loc "exp_pa" ] ];
+ rvb: [ [ -> not_impl loc "rvb" ] ];
+ tyvarseq: [ [ -> not_impl loc "tyvarseq" ] ];
+
+ tyvar_pc:
+ [ [ "'"; x1 = LIDENT -> [(x1, (False, False))]
+ | "'"; x1 = LIDENT; ","; l = tyvar_pc -> [(x1, (False, False)) :: l] ] ]
+ ;
+ id:
+ [ [ x1 = idd -> x1
+ | "*" -> "*" ] ]
+ ;
+ ident:
+ [ [ x1 = idd -> x1
+ | "*" -> "*"
+ | "=" -> "="
+ | "<" -> "<"
+ | ">" -> ">"
+ | "<=" -> "<="
+ | ">=" -> ">="
+ | "^" -> "^" ] ]
+ ;
+ op_op:
+ [ [ x1 = op -> not_impl loc "op_op 1"
+ | -> () ] ]
+ ;
+ qid:
+ [ [ x1 = idd; "."; x2 = qid -> <:module_expr< $uid:x1$ . $x2$ >>
+ | x1 = idd -> <:module_expr< $uid:x1$ >>
+ | x1 = "*" -> <:module_expr< $uid:x1$ >>
+ | x1 = "=" -> <:module_expr< $uid:x1$ >> ] ]
+ ;
+ eqid:
+ [ [ x1 = UIDENT; "."; x2 = eqid -> <:expr< $uid:x1$ . $x2$ >>
+ | x1 = UIDENT -> <:expr< $uid:x1$ >>
+ | x1 = idd -> <:expr< $lid:x1$ >>
+ | x1 = "*" -> <:expr< $lid:x1$ >>
+ | x1 = "=" -> <:expr< $lid:x1$ >> ] ]
+ ;
+ sqid:
+ [ [ x1 = idd; "."; x2 = sqid -> [x1 :: x2]
+ | x1 = idd -> [x1]
+ | x1 = "*" -> [x1]
+ | x1 = "=" -> [x1] ] ]
+ ;
+ tycon:
+ [ [ LIDENT "real" -> <:ctyp< float >>
+ | x1 = idd; "."; x2 = tycon ->
+ let r = <:ctyp< $uid:x1$ . $x2$ >> in
+ loop r where rec loop =
+ fun
+ [ <:ctyp< $a$ . ($b$ . $c$) >> -> <:ctyp< $a$ . $b$ . $loop c$ >>
+ | x -> x ]
+ | x1 = idd -> <:ctyp< $lid:uncap x1$ >> ] ]
+ ;
+ selector:
+ [ [ x1 = id -> x1
+ | x1 = INT -> not_impl loc "selector 1" ] ]
+ ;
+ tlabel:
+ [ [ x1 = selector; ":"; x2 = ctyp -> (loc, x1, False, x2) ] ]
+ ;
+ tuple_ty:
+ [ [ x1 = ctyp LEVEL "ty'"; "*"; x2 = tuple_ty -> [x1 :: x2]
+ | x1 = ctyp LEVEL "ty'" -> [x1] ] ]
+ ;
+ ctyp:
+ [ RIGHTA
+ [ x1 = ctyp; "->"; x2 = ctyp -> <:ctyp< $x1$ -> $x2$ >> ]
+ | [ x1 = ctyp; "*"; x2 = tuple_ty -> <:ctyp< ($list:[x1 :: x2]$) >> ]
+ | "ty'"
+ [ "'"; x1 = LIDENT -> <:ctyp< '$x1$ >>
+ | "'"; "'"; x1 = LIDENT -> <:ctyp< '$x1$ >>
+ | "{"; x1 = LIST1 tlabel SEP ","; "}" ->
+ if ocaml_records.val then <:ctyp< { $list:x1$ } >>
+ else
+ let list = List.map (fun (_, l, _, t) -> (l, t)) x1 in
+ <:ctyp< < $list:list$ > >>
+ | "{"; "}" -> not_impl loc "ty' 3"
+ | "("; x1 = ctyp; ","; x2 = LIST1 ctyp SEP ","; ")"; x3 = tycon ->
+ List.fold_left (fun t1 t2 -> <:ctyp< $t1$ $t2$ >>) x3 [x1 :: x2]
+ | "("; x1 = ctyp; ")" -> x1
+ | x1 = ctyp; x2 = tycon -> <:ctyp< $x2$ $x1$ >>
+ | x1 = tycon -> x1 ] ]
+ ;
+ rule:
+ [ [ x1 = patt; "=>"; x2 = expr -> (x1, None, x2) ] ]
+ ;
+ elabel:
+ [ [ x1 = selector; "="; x2 = expr -> (<:patt< $lid:x1$ >>, x2) ] ]
+ ;
+ exp_ps:
+ [ [ x1 = expr -> x1
+ | x1 = expr; ";"; x2 = exp_ps ->
+ <:expr< do { $list:[x1 :: get_seq x2]$ } >> ] ]
+ ;
+ expr:
+ [ [ "if"; x1 = expr; "then"; x2 = expr; "else"; x3 = expr ->
+ <:expr< if $x1$ then $x2$ else $x3$ >>
+ | "fn"; x1 = LIST1 rule SEP "|" -> <:expr< fun [$list:x1$] >>
+ | "case"; x1 = expr; "of"; x2 = LIST1 rule SEP "|" ->
+ <:expr< match $x1$ with [$list:x2$] >>
+ | "while"; x1 = expr; "do"; x2 = expr ->
+ <:expr< while $x1$ do { $x2$ } >>
+ | x1 = expr; "handle"; x2 = LIST1 rule SEP "|" ->
+ <:expr< try $x1$ with [$list:x2$] >> ]
+ | RIGHTA
+ [ "raise"; x1 = expr -> <:expr< raise $x1$ >> ]
+ | [ e1 = expr; ":="; e2 = expr -> <:expr< $e1$.val := $e2$ >> ]
+ | LEFTA
+ [ x1 = expr; "orelse"; x2 = expr -> <:expr< $x1$ || $x2$ >> ]
+ | LEFTA
+ [ x1 = expr; "andalso"; x2 = expr -> <:expr< $x1$ && $x2$ >> ]
+ | LEFTA
+ [ x1 = expr; ":"; x2 = ctyp -> <:expr< ($x1$ : $x2$) >> ]
+ | "4" NONA
+ [ x1 = expr; "<"; x2 = expr -> <:expr< $x1$ < $x2$ >>
+ | x1 = expr; ">"; x2 = expr -> <:expr< $x1$ > $x2$ >>
+ | x1 = expr; "<>"; x2 = expr -> <:expr< $x1$ <> $x2$ >>
+ | x1 = expr; "="; x2 = expr -> <:expr< $x1$ = $x2$ >>
+ | x1 = expr; ">="; x2 = expr -> <:expr< $x1$ >= $x2$ >>
+ | x1 = expr; "<="; x2 = expr -> <:expr< $x1$ <= $x2$ >> ]
+ | RIGHTA
+ [ x1 = expr; "^"; x2 = expr -> <:expr< $x1$ ^ $x2$ >>
+ | x1 = expr; "@"; x2 = expr -> <:expr< $x1$ @ $x2$ >>
+ | x1 = expr; "o"; x2 = expr -> <:expr< ooo $x1$ $x2$ >> ]
+ | "5" RIGHTA
+ [ x1 = expr; "::"; x2 = expr -> <:expr< [$x1$ :: $x2$] >> ]
+ | "6" LEFTA
+ [ x1 = expr; "+"; x2 = expr -> <:expr< $x1$ + $x2$ >>
+ | x1 = expr; "-"; x2 = expr -> <:expr< $x1$ - $x2$ >> ]
+ | "7" LEFTA
+ [ x1 = expr; "*"; x2 = expr -> <:expr< $x1$ * $x2$ >>
+ | x1 = expr; "/"; x2 = expr -> <:expr< $x1$ / $x2$ >>
+ | x1 = expr; "div"; x2 = expr -> <:expr< $x1$ / $x2$ >>
+ | x1 = expr; "mod"; x2 = expr -> <:expr< $x1$ mod $x2$ >> ]
+ | LEFTA
+ [ x1 = expr; x2 = expr -> <:expr< $x1$ $x2$ >> ]
+ | [ "#"; x1 = STRING -> <:expr< $chr:x1$ >>
+ | "#"; x1 = selector; x2 = expr ->
+ if ocaml_records.val then <:expr< $x2$ . $lid:x1$ >>
+ else <:expr< $x2$ # $lid:x1$ >>
+ | x1 = expr; "ocaml_record_access"; x2 = expr -> <:expr< $x1$ . $x2$ >> ]
+ | [ "!"; x1 = expr -> <:expr< $x1$ . val >>
+ | "~"; x1 = expr -> <:expr< - $x1$ >> ]
+ | [ x1 = LIDENT ->
+ match x1 with
+ [ "true" | "false" -> <:expr< $uid:String.capitalize x1$ >>
+ | "nil" -> <:expr< [] >>
+ | _ -> <:expr< $lid:x1$ >> ]
+ | x1 = UIDENT -> <:expr< $uid:x1$ >>
+ | x1 = UIDENT; "."; x2 = eqid -> <:expr< $uid:x1$ . $x2$ >>
+ | x1 = INT -> <:expr< $int:x1$ >>
+ | x1 = FLOAT -> <:expr< $flo:x1$ >>
+ | x1 = STRING -> <:expr< $str:x1$ >>
+ | "~"; x1 = INT -> <:expr< $int:"-"^x1$ >>
+ | i = op ->
+ if i = "::" then <:expr< fun (x, y) -> [x :: y] >>
+ else <:expr< fun (x, y) -> $lid:i$ x y >>
+ | "let"; x1 = ldecs; "in"; x2 = exp_ps; "end" ->
+ List.fold_right
+ (fun pel x2 ->
+ let loc =
+ match pel with
+ [ [(p, _) :: _] ->
+ (fst (MLast.loc_of_patt p), snd (MLast.loc_of_expr x2))
+ | _ -> loc ]
+ in
+ match pel with
+ [ [(_, <:expr< fun [$list:_$] >>) :: _] ->
+ <:expr< let rec $list:pel$ in $x2$ >>
+ | _ ->
+ let pel =
+ List.map
+ (fun (p, e) ->
+ match p with
+ [ <:patt< { $list:lpl$ } >> ->
+ record_match_assoc (MLast.loc_of_patt p) lpl e
+ | _ -> (p, e) ])
+ pel
+ in
+ <:expr< let $list:pel$ in $x2$ >> ])
+ x1 x2
+ | "{"; x1 = LIST1 elabel SEP ","; "}" -> record_expr loc x1
+ | "["; "]" -> <:expr< [] >>
+ | "["; x1 = expr; "]" -> <:expr< [$x1$] >>
+ | "["; x1 = expr; ","; x2 = LIST1 SELF SEP ","; "]" ->
+ mklistexp loc None [x1 :: x2]
+ | "("; ")" -> <:expr< () >>
+ | "("; x1 = expr; ","; x2 = LIST1 SELF SEP ","; ")" ->
+ <:expr< ($list:[x1::x2]$) >>
+ | "("; x1 = expr; ";"; x2 = LIST1 SELF SEP ";"; ")" ->
+ <:expr< do { $list:[x1::x2]$ } >>
+ | "("; x1 = expr; ")" -> x1 ] ]
+ ;
+ fixity:
+ [ [ "infix" -> ("infix", None)
+ | "infix"; x1 = INT -> not_impl loc "fixity 2"
+ | "infixr" -> not_impl loc "fixity 3"
+ | "infixr"; x1 = INT -> ("infixr", Some x1)
+ | "nonfix" -> not_impl loc "fixity 5" ] ]
+ ;
+ patt:
+ [ [ x1 = patt; "as"; x2 = patt -> <:patt< ($x1$ as $x2$) >> ]
+ | LEFTA
+ [ x1 = patt; ":"; x2 = ctyp -> <:patt< ($x1$ : $x2$) >> ]
+ | RIGHTA
+ [ x1 = patt; "::"; x2 = patt -> <:patt< [$x1$ :: $x2$] >> ]
+ | [ x1 = patt; x2 = patt ->
+ match x1 with
+ [ <:patt< ref >> -> <:patt< {contents = $x2$} >>
+ | _ -> <:patt< $x1$ $x2$ >> ] ]
+ | "apat"
+ [ x1 = patt; "."; x2 = patt -> <:patt< $x1$ . $x2$ >>
+ | x1 = INT -> <:patt< $int:x1$ >>
+ | x1 = UIDENT -> <:patt< $uid:x1$ >>
+ | x1 = STRING -> <:patt< $str:x1$ >>
+ | "#"; x1 = STRING -> <:patt< $chr:x1$ >>
+ | "~"; x1 = INT -> <:patt< $int:"-"^x1$ >>
+ | LIDENT "nil" -> <:patt< [] >>
+ | LIDENT "false" -> <:patt< False >>
+ | LIDENT "true" -> <:patt< True >>
+ | x1 = id -> <:patt< $lid:x1$ >>
+ | x1 = op -> <:patt< $lid:x1$ >>
+ | "_" -> <:patt< _ >>
+ | "["; "]" -> <:patt< [] >>
+ | "["; x1 = patt; "]" -> <:patt< [$x1$] >>
+ | "["; x1 = patt; ","; x2 = LIST1 SELF SEP ","; "]" ->
+ mklistpat loc None [x1 :: x2]
+ | "{"; x1 = LIST1 plabel SEP ","; "}" -> <:patt< {$list:x1$} >>
+ | "("; ")" -> <:patt< () >>
+ | "("; x1 = patt; ","; x2 = LIST1 SELF SEP ","; ")" ->
+ <:patt< ($list:[x1::x2]$) >>
+ | "("; x1 = patt; ")" -> x1 ] ]
+ ;
+ plabel:
+ [ [ x1 = selector; "="; x2 = patt -> (<:patt< $lid:x1$ >>, x2)
+ | x1 = selector -> (<:patt< $lid:x1$ >>, <:patt< $lid:x1$ >>) ] ]
+ ;
+ vb:
+ [ [ "lazy"; x1 = patt; "="; x2 = expr -> not_impl loc "vb 1"
+ | x1 = patt; "="; x2 = expr -> (x1, x2) ] ]
+ ;
+ constrain:
+ [ [ -> None
+ | ":"; x1 = ctyp -> Some x1 ] ]
+ ;
+ fb:
+ [ [ xl = LIST1 clause SEP "|" -> function_of_clause_list loc xl
+ | "lazy"; x1 = LIST1 clause SEP "|" -> not_impl loc "fb 2" ] ]
+ ;
+ clause:
+ [ [ x1 = patt LEVEL "apat"; x2 = LIST1 (patt LEVEL "apat");
+ x3 = constrain; "="; x4 = expr ->
+ let x1 =
+ match x1 with
+ [ <:patt< $lid:id$ >> -> (id, MLast.loc_of_patt x1)
+ | _ -> not_impl loc "clause 1" ]
+ in
+ (x1, x2, x3, x4) ] ]
+ ;
+ tb:
+ [ [ x1 = tyvars; x2 = idd; "="; x3 = ctyp ->
+ ((loc, uncap x2), x1, x3, [])
+ | x1 = tyvars; x2 = idd; "="; x3 = ctyp; "=="; x4 = dbrhs ->
+ let x4 = List.map (fun (loc, c, tl, _) -> (loc, c, tl)) x4 in
+ ((loc, uncap x2), x1, <:ctyp< $x3$ == [ $list:x4$ ] >>, []) ] ]
+ ;
+ tyvars:
+ [ [ "'"; x1 = LIDENT -> [(x1, (False, False))]
+ | "("; x1 = tyvar_pc; ")" -> x1
+ | -> [] ] ]
+ ;
+ db1:
+ [ [ x1 = tyvars; x2 = ident; "="; x3 = dbrhs ->
+ let x2 = uncap x2 in
+ extract_label_types loc x2 x1 x3
+ | "lazy"; x1 = tyvars; x2 = ident; "="; x3 = dbrhs ->
+ not_impl loc "db 2" ] ]
+ ;
+ db:
+ [ [ x1 = LIST1 db1 SEP "and" ->
+ List.fold_right (fun td tdl -> td @ tdl) x1 [] ] ]
+ ;
+ dbrhs:
+ [ [ x1 = LIST1 constr SEP "|" -> x1
+ | "datatype"; x1 = tycon -> not_impl loc "dbrhs 2" ] ]
+ ;
+ constr:
+ [ [ x1 = op_op; x2 = ident -> (loc, x2, [], None)
+ | x1 = op_op; x2 = ident; "of"; x3 = ctyp ->
+ match x3 with
+ [ <:ctyp< {$list:_$} >> -> (loc, x2, [], Some x3)
+ | _ -> (loc, x2, [x3], None) ] ] ]
+ ;
+ eb:
+ [ [ x1 = op_op; x2 = ident -> (x2, [], [])
+ | x1 = op_op; x2 = ident; "of"; x3 = ctyp -> (x2, [x3], [])
+ | x1 = op_op; x2 = ident; "="; x3 = sqid -> (x2, [], x3) ] ]
+ ;
+ ldec1:
+ [ [ "val"; x1 = LIST1 vb SEP "and" -> x1
+ | "fun"; x1 = LIST1 fb SEP "and" -> x1 ] ]
+ ;
+ ldecs:
+ [ [ -> []
+ | x1 = ldec1; x2 = ldecs -> [x1 :: x2]
+ | ";"; x1 = ldecs -> x1
+ | "local"; x1 = ldecs; "in"; x2 = ldecs; "end"; x3 = ldecs ->
+ not_impl loc "ldecs 4" ] ]
+ ;
+ spec_s:
+ [ [ -> []
+ | x1 = spec; x2 = spec_s -> [x1 :: x2]
+ | ";"; x1 = spec_s -> x1 ] ]
+ ;
+ spec:
+ [ [ "structure"; x1 = LIST1 strspec SEP "and" -> sig_declare loc x1
+ | "functor"; x1 = LIST1 fctspec SEP "and" -> sig_declare loc x1
+ | "datatype"; x1 = db -> <:sig_item< type $list:x1$ >>
+ | "type"; x1 = LIST1 tyspec SEP "and" -> <:sig_item< type $list:x1$ >>
+ | "eqtype"; x1 = LIST1 tyspec SEP "and" -> <:sig_item< type $list:x1$ >>
+ | "val"; x1 = LIST1 valspec SEP "and" -> sig_declare loc x1
+ | "exception"; x1 = LIST1 exnspec SEP "and" -> sig_declare loc x1
+ | "sharing"; x1 = LIST1 sharespec SEP "and" -> <:sig_item< declare end >>
+ | "include"; x1 = module_type -> <:sig_item< include $x1$ >> ] ]
+ ;
+ sig_item:
+ [ [ x = spec -> x ] ]
+ ;
+ strspec:
+ [ [ x1 = ident; ":"; x2 = module_type; x3 = LIST0 sharing_def ->
+ let x2 =
+ List.fold_left
+ (fun mt sdl ->
+ List.fold_right
+ (fun spl mt ->
+ match spl with
+ [ Right ([m1], m2) ->
+ let (m1, m2) =
+ match m2 with
+ [ <:module_expr< $uid:x$ . $_$ >> ->
+ if x = x1 then (m2, m1) else (m1, m2)
+ | _ -> (m1, m2) ]
+ in
+ let m1 =
+ loop m1 where rec loop =
+ fun
+ [ <:module_expr< $uid:x$ >> -> x
+ | <:module_expr< $uid:x$ . $y$ >> -> loop y
+ | _ -> not_impl loc "strspec 2" ]
+ in
+ <:module_type< $mt$ with module $[m1]$ = $m2$ >>
+ | _ -> not_impl loc "strspec 1" ])
+ sdl mt)
+ x2 x3
+ in
+ <:sig_item< module $x1$ : $x2$ >> ] ]
+ ;
+ sharing_def:
+ [ [ "sharing"; x3 = LIST1 sharespec SEP "and" -> x3 ] ]
+ ;
+ fctspec:
+ [ [ x1 = ident; x2 = fsig -> <:sig_item< module $x1$ : $x2$ >> ] ]
+ ;
+ tyspec:
+ [ [ x1 = tyvars; x2 = idd ->
+ ((loc, uncap x2), x1, <:ctyp< '$choose_tvar x1$ >>, [])
+ | x1 = tyvars; x2 = idd; "="; x3 = ctyp ->
+ ((loc, uncap x2), x1, x3, []) ] ]
+ ;
+ valspec:
+ [ [ x1 = op_op; x2 = ident; ":"; x3 = ctyp ->
+ <:sig_item< value $x2$ : $x3$ >> ] ]
+ ;
+ exnspec:
+ [ [ x1 = ident -> <:sig_item< exception $x1$ >>
+ | x1 = ident; "of"; x2 = ctyp ->
+ <:sig_item< exception $x1$ of $x2$ >> ] ]
+ ;
+ sharespec:
+ [ [ "type"; x1 = patheqn -> Left x1
+ | x1 = patheqn -> Right x1 ] ]
+ ;
+ patheqn:
+ [ [ l = patheqn1 -> l ] ]
+ ;
+ patheqn1:
+ [ [ (l, y) = patheqn1; "="; x = qid -> ([y :: l], x)
+ | x = qid -> ([], x) ] ]
+ ;
+ whspec:
+ [ [ "type"; x1 = tyvars; x2 = sqid; "="; x3 = ctyp ->
+ MLast.WcTyp loc x2 x1 x3
+ | x1 = sqid; "="; x2 = qid -> MLast.WcMod loc x1 x2 ] ]
+ ;
+ module_type:
+ [ [ x1 = ident -> <:module_type< $uid:x1$ >>
+ | "sig"; x1 = spec_s; "end" -> <:module_type< sig $list:x1$ end >>
+ | x1 = module_type; "where"; x2 = LIST1 whspec SEP "and" ->
+ <:module_type< $x1$ with $list:x2$ >> ] ]
+ ;
+ sigconstraint_op:
+ [ [ -> None
+ | ":"; x1 = module_type -> Some x1
+ | ":>"; x1 = module_type -> not_impl loc "sigconstraint_op 3" ] ]
+ ;
+ sigb:
+ [ [ x1 = ident; "="; x2 = module_type ->
+ <:str_item< module type $x1$ = $x2$ >> ] ]
+ ;
+ fsig:
+ [ [ ":"; x1 = ident -> not_impl loc "fsig 1"
+ | x1 = fparamList; ":"; x2 = module_type -> not_impl loc "fsig 2" ] ]
+ ;
+ module_expr:
+ [ [ x1 = qid -> x1
+ | "struct"; x1 = strdecs; "end" -> <:module_expr< struct $list:x1$ end >>
+ | x1 = qid; x2 = arg_fct ->
+ match x2 with
+ [ Left [] -> x1
+ | Left x2 -> <:module_expr< $x1$ (struct $list:x2$ end) >>
+ | Right x2 -> <:module_expr< $x1$ $x2$ >> ]
+ | "let"; x1 = strdecs; "in"; x2 = module_expr; "end" ->
+ not_impl loc "str 4"
+ | x1 = module_expr; ":"; x2 = module_type -> not_impl loc "str 5"
+ | x1 = module_expr; x2 = ":>"; x3 = module_type ->
+ not_impl loc "str 6" ] ]
+ ;
+ arg_fct:
+ [ [ "("; x1 = strdecs; ")"; x2 = arg_fct -> not_impl loc "arg_fct 1"
+ | "("; x1 = module_expr; ")"; x2 = arg_fct -> not_impl loc "arg_fct 2"
+ | "("; x1 = module_expr; ")" -> Right x1
+ | "("; x2 = strdecs; ")" -> Left x2 ] ]
+ ;
+ strdecs:
+ [ [ x1 = str_item LEVEL "strdec"; x2 = strdecs -> [x1 :: x2]
+ | ";"; x1 = strdecs -> x1
+ | -> [] ] ]
+ ;
+ str_item:
+ [ [ "signature"; x1 = LIST1 sigb SEP "and" -> str_declare loc x1
+ | "funsig"; x1 = fsigb -> not_impl loc "sdec 3" ]
+ | "strdec"
+ [ "structure"; x1 = LIST1 strb SEP "and" -> str_declare loc x1
+ | "functor"; x1 = LIST1 fctb SEP "and" -> str_declare loc x1
+ | "local"; x1 = sdecs; "in"; x2 = sdecs; "end" ->
+ make_local loc x1 x2 ]
+ | [ "val"; x1 = LIST1 vb SEP "and" -> <:str_item< value $list:x1$ >>
+ | "val"; x1 = tyvarseq; x3 = LIST1 vb SEP "and" ->
+ not_impl loc "ldec 2"
+ | "val"; "rec"; x1 = rvb -> not_impl loc "ldec 3"
+ | "val"; "rec"; x1 = tyvarseq; x2 = rvb -> not_impl loc "ldec 4"
+ | "fun"; x1 = LIST1 fb SEP "and" -> <:str_item< value rec $list:x1$ >>
+ | "fun"; x1 = tyvarseq; x2 = fb -> not_impl loc "ldec 6"
+ | "type"; x1 = LIST1 tb SEP "and" -> <:str_item< type $list:x1$ >>
+ | "datatype"; x1 = db -> <:str_item< type $list:x1$ >>
+ | "datatype"; x1 = db; "withtype"; x2 = tb ->
+ <:str_item< type $list:x1 @ [x2]$ >>
+ | "abstype"; x1 = db; "with"; x2 = ldecs; "end" -> not_impl loc "ldec 10"
+ | "abstype"; x1 = db; "withtype"; x2 = tb; "with"; x3 = ldecs; "end" ->
+ not_impl loc "ldec 11"
+ | "exception"; x1 = LIST1 eb SEP "and" ->
+ let dl =
+ List.map
+ (fun (s, tl, eqn) ->
+ <:str_item< exception $s$ of $list:tl$ = $eqn$ >>)
+ x1
+ in
+ str_declare loc dl
+ | "open"; x1 = LIST1 sqid ->
+ let dl = List.map (fun sl -> <:str_item< open $sl$ >>) x1 in
+ str_declare loc dl
+ | LIDENT "use"; s = STRING ->
+ <:str_item< #use $str:s$ >>
+ | x1 = fixity; list = LIST1 idd ->
+ match x1 with
+ [ ("infixr", Some n) ->
+ do {
+ List.iter
+ (fun s ->
+ EXTEND
+ expr: LEVEL $n$
+ [ [ x1 = expr; $s$; x2 = expr ->
+ <:expr< $lid:s$ ($x1$, $x2$) >> ] ]
+ ;
+ END)
+ list;
+ str_declare loc []
+ }
+ | ("infix", None) ->
+ do {
+ List.iter
+ (fun s ->
+ EXTEND
+ expr: LEVEL "4"
+ [ [ x1 = expr; $s$; x2 = expr ->
+ <:expr< $lid:s$ ($x1$, $x2$) >> ] ]
+ ;
+ clause:
+ [ [ x1 = patt LEVEL "apat"; $s$;
+ x2 = patt LEVEL "apat"; "="; x4 = expr ->
+ ((s, loc), [<:patt< ($x1$, $x2$) >>],
+ None, x4) ] ]
+ ;
+ END)
+ list;
+ str_declare loc []
+ }
+ | _ -> not_impl loc "ldec 14" ]
+ | "overload"; x1 = ident; ":"; x2 = ctyp; "as"; x3 = exp_pa ->
+ not_impl loc "ldec 15"
+ | x = expr -> <:str_item< $exp:x$ >> ] ]
+ ;
+ sdec:
+ [ [ x = str_item -> x ] ]
+ ;
+ strb:
+ [ [ x1 = ident; x2 = sigconstraint_op; "="; x3 = module_expr ->
+ let x3 =
+ match x2 with
+ [ Some x2 -> <:module_expr< ($x3$ : $x2$) >>
+ | None -> x3 ]
+ in
+ <:str_item< module $x1$ = $x3$ >> ] ]
+ ;
+ fparam:
+ [ [ x1 = idd; ":"; x2 = module_type -> [<:sig_item< module $x1$ : $x2$ >>]
+ | x1 = spec_s -> x1 ] ]
+ ;
+ fparamList:
+ [ [ "("; x1 = fparam; ")" -> [x1]
+ | "("; x1 = fparam; ")"; x2 = fparamList -> [x1 :: x2] ] ]
+ ;
+ fctb:
+ [ [ x1 = ident; x2 = fparamList; x3 = sigconstraint_op; "=";
+ x4 = module_expr ->
+ let list = List.flatten x2 in
+ let x4 =
+ if list = [] then x4
+ else
+ match x4 with
+ [ <:module_expr< struct $list:list$ end >> ->
+ let si =
+ let loc = (Token.nowhere, Token.nowhere) in
+ <:str_item< open AAA >> in
+ <:module_expr< struct $list:[si :: list]$ end >>
+ | _ -> not_impl loc "fctb 1" ]
+ in
+ let x4 =
+ match x3 with
+ [ Some x3 -> <:module_expr< ($x4$ : $x3$) >>
+ | None -> x4 ]
+ in
+ let x4 =
+ if list = [] then x4
+ else
+ let mt =
+ let loc =
+ (fst (MLast.loc_of_sig_item (List.hd list)),
+ snd (MLast.loc_of_sig_item (List.hd (List.rev list))))
+ in
+ <:module_type< sig $list:list$ end >>
+ in
+ <:module_expr< functor (AAA : $mt$) -> $x4$ >>
+ in
+ <:str_item< module $x1$ = $x4$ >>
+ | x1 = ident; x2 = fsigconstraint_op; "="; x3 = fct_exp ->
+ not_impl loc "fctb 2" ] ]
+ ;
+ interdec:
+ [ [ x = LIST1 [ s = str_item; OPT ";" -> (s, loc) ] -> (x, False)
+ | x = expr; OPT ";" -> not_impl loc "interdec 2" ] ]
+ ;
+END;
+
+Pcaml.add_option "-records" (Arg.Set ocaml_records)
+ "Convert record into OCaml records, instead of objects";
--- /dev/null
+(***********************************************************************)
+(* *)
+(* Camlp4 *)
+(* *)
+(* Daniel de Rauglaudre, projet Cristal, INRIA Rocquencourt *)
+(* *)
+(* Copyright 2002 Institut National de Recherche en Informatique et *)
+(* Automatique. Distributed only by permission. *)
+(* *)
+(***********************************************************************)
+
+
+
+datatype 'a option = SOME of 'a | NONE
+exception Fail of string
+exception Domain
+exception Subscript
+type 'a vector = 'a array
+
+structure OCaml =
+ struct
+ structure List = List
+ structure String = String
+ end
+
+structure Time =
+ struct
+ datatype time = TIME of { sec : int, usec : int }
+ fun toString _ = failwith "not implemented Time.toString"
+ fun now _ = failwith "not implemented Time.now"
+ end
+
+datatype cpu_timer =
+ CPUT of { gc : Time.time, sys : Time.time, usr : Time.time }
+
+datatype real_timer =
+ RealT of Time.time
+
+structure Char =
+ struct
+ val ord = Char.code
+ end
+
+structure General =
+ struct
+ datatype order = LESS | EQUAL | GREATER
+ end
+type order = General.order == LESS | EQUAL | GREATER
+
+structure OS =
+ struct
+ exception SysErr
+ structure Path =
+ struct
+ fun dir s =
+ let val r = Filename.dirname s in
+ if r = "." then "" else r
+ end
+ val file = Filename.basename
+ fun ext s =
+ let fun loop i =
+ if i < 0 then NONE
+ else if String.get s i = #"." then
+ let val len = String.length s - i - 1 in
+ if len = 0 then NONE else SOME (String.sub s (i + 1) len)
+ end
+ else loop (i - 1)
+ in
+ loop (String.length s - 1)
+ end
+ fun splitDirFile s =
+ {dir = Filename.dirname s,
+ file = Filename.basename s}
+ fun joinDirFile x =
+ let val {dir,file} = x in Filename.concat dir file end
+ end
+ structure FileSys =
+ struct
+ datatype access_mode = A_READ | A_WRITE | A_EXEC
+ val chDir = Sys.chdir
+ fun isDir s =
+ (Unix.stat s) ocaml_record_access Unix.st_kind = Unix.S_DIR
+ handle Unix.Unix_error _ => raise SysErr
+ fun access (s, accs) =
+ let val st = Unix.stat s
+ val prm = st ocaml_record_access Unix.st_perm
+ val prm =
+ if st ocaml_record_access Unix.st_uid = Unix.getuid () then
+ lsr prm 6
+ else if st ocaml_record_access Unix.st_uid = Unix.getgid ()
+ then
+ lsr prm 3
+ else prm
+ val rf =
+ if List.mem A_READ accs then land prm 4 <> 0 else true
+ val wf =
+ if List.mem A_WRITE accs then land prm 2 <> 0 else true
+ val xf =
+ if List.mem A_EXEC accs then land prm 1 <> 0 else true
+ in
+ rf andalso wf andalso xf
+ end
+ handle Unix.Unix_error (_, f, _) =>
+ if f = "stat" then false else raise SysErr
+ end
+ structure Process =
+ struct
+ fun system s = (flush stdout; flush stderr; Sys.command s)
+ fun getEnv s = SOME (Sys.getenv s) handle Not_found => NONE
+ val success = 0
+ end
+ end
+
+exception SysErr = OS.SysErr
+
+structure IO =
+ struct
+ exception Io of {cause:exn, function:string, name:string}
+ end
+
+structure TextIO =
+ struct
+ type instream = in_channel * char option option ref
+ type outstream = out_channel
+ type elem = char
+ type vector = string
+ fun openIn fname =
+ (open_in fname, ref NONE) handle exn =>
+ raise IO.Io {cause = exn, function = "openIn", name = fname}
+ val openOut = open_out
+ fun closeIn (ic, ahc) = (ahc := SOME NONE; close_in ic)
+ val closeOut = close_out
+ val stdIn = (stdin, ref (NONE : char option option))
+ fun endOfStream (ic, _) = pos_in ic = in_channel_length ic
+ fun inputLine (ic, ahc) =
+ case !ahc of
+ NONE =>
+ (input_line ic ^ "\n" handle End_of_file => (ahc := SOME NONE; ""))
+ | SOME NONE => ""
+ | SOME (SOME c) =>
+ (ahc := NONE;
+ if c = #"\n" then "\n"
+ else
+ String.make 1 c ^ input_line ic ^ "\n" handle
+ End_of_file => (ahc := SOME NONE; ""))
+ fun input1 (ic, ahc) =
+ case !ahc of
+ NONE =>
+ (SOME (input_char ic) handle End_of_file => (ahc := SOME NONE; NONE))
+ | SOME NONE => NONE
+ | SOME x => (ahc := NONE; x)
+ fun inputN (ins, n) =
+ let fun loop n =
+ if n <= 0 then ""
+ else
+ case input1 ins of
+ SOME c => String.make 1 c ^ loop (n - 1)
+ | NONE => ""
+ in
+ loop n
+ end
+ fun output (oc, v) = output_string oc v
+ fun inputAll ic = failwith "not implemented TextIO.inputAll"
+ fun lookahead (ic, ahc) =
+ case !ahc of
+ NONE => let val r = SOME (input_char ic) in ahc := SOME r; r end
+ | SOME x => x
+ fun print s = (print_string s; flush stdout)
+ end
+
+structure Timer =
+ struct
+ fun startRealTimer () = failwith "not implemented Timer.startRealTimer"
+ fun startCPUTimer () = failwith "not implemented Timer.startCPUTimer"
+ fun checkRealTimer _ = failwith "not implemented Timer.checkRealTimer"
+ fun checkCPUTimer _ = failwith "not implemented Timer.checkCPUTimer"
+ end
+
+structure Date =
+ struct
+ datatype month =
+ Jan | Feb | Mar | Apr | May | Jun | Jul | Sep | Oct | Nov | Dec
+ datatype wday = Sun | Mon | Tue | Wed | Thu | Fri | Sat
+ datatype date =
+ DATE of
+ {day : int, hour : int, isDst : bool option, minute : int,
+ month : month, offset : int option, second : int, wday : wday,
+ yday : int, year : int}
+ fun fmt _ _ = failwith "not implemented Date.fmt"
+ fun fromTimeLocal _ = failwith "not implemented Date.fromTimeLocal"
+ end
+
+structure Posix =
+ struct
+ structure ProcEnv =
+ struct
+ fun getenv s = SOME (Sys.getenv s) handle Not_found => NONE
+ end
+ end
+
+structure SMLofNJ =
+ struct
+ fun exportML s = failwith ("not implemented exportML " ^ s)
+ end
+
+fun null x = x = []
+fun explode s =
+ let fun loop i =
+ if i = String.length s then []
+ else String.get s i :: loop (i + 1)
+ in
+ loop 0
+ end
+
+val app = List.iter
+fun implode [] = ""
+ | implode (c :: l) = String.make 1 c ^ implode l
+
+fun ooo f g x = f (g x)
+
+structure Array =
+ struct
+ fun array (len, v) = Array.create len v
+ fun sub _ = failwith "not implemented Array.sub"
+ fun update _ = failwith "not implemented Array.update"
+ (* for make the profiler work *)
+ val set = Array.set
+ val get = Array.get
+ end
+
+structure Vector =
+ struct
+ fun tabulate _ = failwith "not implemented Vector.tabulate"
+ fun sub _ = failwith "not implemented Vector.sub"
+ end
+
+structure Bool =
+ struct
+ val toString = string_of_bool
+ end
+
+structure String =
+ struct
+ val size = String.length
+ fun substring (s, beg, len) =
+ String.sub s beg len handle Invalid_argument _ => raise Subscript
+ val concat = String.concat ""
+ fun sub (s, i) = String.get s i
+ val str = String.make 1
+ fun compare (s1, s2) =
+ if s1 < s2 then LESS
+ else if s1 > s2 then GREATER
+ else EQUAL
+ fun isPrefix s1 s2 =
+ let fun loop i1 i2 =
+ if i1 >= String.length s1 then true
+ else if i2 >= String.length s2 then false
+ else if String.get s1 i1 = String.get s2 i2 then loop (i1 + 1) (i2 + 1)
+ else false
+ in
+ loop 0 0
+ end
+ fun tokens p s =
+ let fun loop tok i =
+ if i >= String.length s then
+ if tok = "" then [] else [tok]
+ else if p (String.get s i) then
+ if tok <> "" then tok :: loop "" (i + 1)
+ else loop "" (i + 1)
+ else loop (tok ^ String.make 1 (String.get s i)) (i + 1)
+ in
+ loop "" 0
+ end
+ fun extract _ = failwith "not implemented String.extract"
+ end
+
+structure Substring =
+ struct
+ type substring = string * int * int
+ fun string (s : substring) = String.substring s
+ fun all s : substring = (s, 0, String.size s)
+ fun splitl f ((s, beg, len) : substring) : substring * substring =
+ let fun loop di =
+ if di = len then ((s, beg, len), (s, 0, 0))
+ else if f (String.sub (s, beg + di)) then loop (di + 1)
+ else ((s, beg, di), (s, beg + di, len - di))
+ in
+ loop 0
+ end
+ fun getc (s, i, len) =
+ if len > 0 andalso i < String.size s then
+ SOME (String.sub (s, i), (s, i+1, len-1))
+ else NONE
+ fun slice _ = failwith "not implemented: Substring.slice"
+ fun isEmpty (s, beg, len) = len = 0
+ fun concat sl = String.concat (List.map string sl)
+ end
+type substring = Substring.substring
+
+structure StringCvt =
+ struct
+ datatype radix = BIN | OCT | DEC | HEX
+ type ('a, 'b) reader = 'b -> ('a * 'b) option
+ end
+
+structure ListPair =
+ struct
+ fun zip (a1::l1, a2::l2) = (a1, a2) :: zip (l1, l2)
+ | zip _ = []
+ val unzip = List.split
+ fun all f (x1 :: l1, x2 :: l2) = f (x1, x2) andalso all f (l1, l2)
+ | all _ _ = true
+ fun map f (a1::l1, a2::l2) =
+ let val r = f (a1, a2) in r :: map f (l1, l2) end
+ | map _ _ = []
+ end
+
+structure ListMergeSort =
+ struct
+ fun uniqueSort cmp l =
+ List.sort
+ (fn x => fn y =>
+ case cmp (x, y) of
+ LESS => ~1
+ | EQUAL => 0
+ | GREATER => 1)
+ l
+ end
+
+structure List =
+ struct
+ exception Empty
+ fun hd [] = raise Empty
+ | hd (x :: l) = x
+ fun tl [] = raise Empty
+ | tl (x :: l) = l
+ fun foldr f a l =
+ let fun loop a [] = a
+ | loop a (x :: l) = loop (f (x, a)) l
+ in
+ loop a (List.rev l)
+ end
+ fun foldl f a l = List.fold_left (fn a => fn x => f (x, a)) a l
+ val concat = List.flatten
+ val exists = List.exists
+ val filter = List.filter
+ val length = List.length
+ val map = List.map
+ val rev = List.rev
+ val all = List.for_all
+ fun find f [] = NONE
+ | find f (x :: l) = if f x then SOME x else find f l
+ fun last s =
+ case List.rev s of
+ [] => raise Empty
+ | x :: _ => x
+ fun take _ = failwith "not implemented: List.take"
+ fun partition _ = failwith "not implemented: List.partition"
+ fun mapPartial f [] = []
+ | mapPartial f (x :: l) =
+ case f x of
+ NONE => mapPartial f l
+ | SOME y => y :: mapPartial f l
+ fun op @ l1 l2 = List.rev_append (List.rev l1) l2
+ end
+
+structure Int =
+ struct
+ type int1 = int
+ type int = int1
+ val toString = string_of_int
+ fun fromString s = SOME (int_of_string s) handle Failure _ => NONE
+ fun min (x, y) = if x < y then x else y
+ fun max (x, y) = if x > y then x else y
+ fun scan radix getc src = failwith "not impl: Int.scan"
+ end
+
+val foldr = List.foldr
+val exists = List.exists
+val size = String.size
+val substring = String.substring
+val concat = String.concat
+val length = List.length
+val op @ = List.op @
+val hd = List.hd
+val tl = List.tl
+val map = List.map
+val rev = List.rev
+val use_hook = ref (fn (s : string) => (failwith "no defined directive use" : unit))
+fun use s = !use_hook s
+fun isSome (SOME _) = true
+ | isSome NONE = false
+fun valOf (SOME x) = x
+ | valOf NONE = failwith "valOf"
+val print = TextIO.print
# #
#########################################################################
-# $Id: configure 11064 2011-06-04 08:13:25Z xleroy $
+# $Id: configure 11110 2011-07-04 21:15:01Z doligez $
configure_options="$*"
prefix=/usr/local
fi
fi
+case "$host" in
+ *-*-cygwin*) tk_libs="$tk_libs -lws2_32";;
+esac
+
if test $has_tk = true; then
if sh ./hasgot $tk_libs $tk_x11_libs $tkauxlibs Tk_SetGrid; then
echo "Tcl/Tk libraries found."
--- /dev/null
+*.aux
+*.haux
+*.html
+*.htoc
+*.log
+*.pdf
--- /dev/null
+# Makefile
+
+all: manual.pdf manual.html
+
+%.pdf: %.tex
+ pdflatex $<
+ pdflatex $<
+
+%.html: %.tex manual.hva
+ hevea -fix -O manual.hva $<
+
+.PHONY: clean
+
+clean:
+ rm -f *.pdf *.log *.aux *.ps *.dvi manual.h{tml,aux,toc}
--- /dev/null
+\newcommand{\mathscr}[1]{{\mathcal{#1}}}
\ No newline at end of file
--- /dev/null
+% -*- LaTeX -*-
+%(*** preamble
+\documentclass[9pt]{article}
+\usepackage[utf8]{inputenc}
+\usepackage{palatino}
+\usepackage{mathrsfs}
+\usepackage{xspace}
+\usepackage[T1]{fontenc}
+\usepackage[english]{babel}
+\usepackage[a4paper,lmargin=1cm,rmargin=1cm,tmargin=1cm,bmargin=2cm]{geometry}
+\newcommand{\ocb}{\texttt{ocamlbuild}\xspace}
+\newcommand{\tags}{\texttt{\_tags}\xspace}
+%***)
+%(*** title
+\begin{document}
+\title{The \ocb users manual}
+\author{Berke \textsc{Durak}, Nicolas \textsc{Pouillard}}
+\date{February 2007}
+\maketitle
+%***)
+%(*** abstract
+\begin{abstract}
+\ocb is a tool automating the compilation of most OCaml projects with minimal
+user input. Its use is not restricted to projects having a simple structure --
+the extra effort needed to make it work with the more complex projects is in
+reasonable proportion with their added complexity. In practice, one will use a
+set of small text files, and, if needed, an OCaml compilation module that can
+fine-tune the behaviour and define custom rules.
+\end{abstract}
+%***)
+%(*** Features of ocamlbuild
+\section{Features of \ocb}
+{\em This section is intended to read like a sales brochure or a datasheet.}
+
+\begin{itemize}
+\item Built-in compilation rules for OCaml projects handle all the nasty cases:
+native and byte-code, missing \texttt{.mli} files, preprocessor rules,
+libraries, package (-pack) debugging and profiling flags, C stubs.
+\item Plugin mechanism for writing compilation rules and actions in a real programming language,
+OCaml itself.
+\item Automatic inference of dependencies.
+\item Correct handling of dynamically discovered dependencies.
+\item Object files and other temporary files are created in a specific directory, leaving your main directory uncluttered.
+\item Sanity checks ensure that object files are where they are supposed to be: in the build directory.
+\item Regular projects are built using a single command with no extra files.
+\item Parallel compilation to speed up things on multi-core systems.
+\item Sophisticated display mode to keep your screen free of boring and repetitive compilation message
+while giving you important progress information in a glimpse, and correctly multiplexing the error messages.
+\item Tags and flags provide a concise and convenient mechanism for automatic selection of compilation, preprocessing and
+other options.
+\item Extended shell-like glob patterns, that can be combined using boolean operators,
+allow you to concisely define the tags that apply to a given file.
+\item Mechanisms for defining the mutual visibility of subdirectories.
+\item Cache mechanism avoiding unnecessary compilations where reasonably computable.
+\end{itemize}
+%***)
+%(*** Limitations
+\section{Limitations}
+{\em Not perfect nor complete yet, but already pretty damn useful.}
+
+We were not expecting to write the ultimate compilation tool in a few man-months, however we believe we have
+a tool that solves many compilation problems, especially our own, in a satisfactory way. Hence there are a
+lot of missing features, incomplete options and hideous bugs lurking in \ocb, and we hope that the OCaml community
+will find our first try at \ocb useful and hopefully help it grow into a tool that satisfies most needs of most users
+by providing feedback, bug reports and patches.
+
+The plugin API maybe somewhat lacking in maturity, as it has only been tested
+by a few people. We believe a good API can only evolve under pressure from
+many peers and the courage to rewrite things cleanly when time is ripe by the
+developers. Most of the important functions a user will need are encapsulated
+in the plugin API, which is the \texttt{Ocamlbuild\_plugin} module pack. We
+intend to keep that API backwards compatible. It may happen that intricate
+projects need features not available in that module -- you may then use
+functions or values directly from the core \ocb modules. We ask you to report
+such usage to the authors so that we may make the necessary changes to the API;
+you may also want to isolate calls to the non-API parts of the \ocb library
+from the rest of your plugin to be able to keep the later when incompatible
+changes arise.
+
+The way that \ocb handles the command-line options, the \tags file,
+the target names, names of the tags, and so on, are not expected to change in
+incompatible ways. We intend to keep a project that compiles without a plugin
+compilable without modifications in the future.
+%***)
+%(*** Using ocamlbuild
+\section{Using \ocb}
+{\em Learn how to use \ocb with short, specific, straight-to-the-point examples.}
+
+The amount of time and effort spent on the compilation process of a project
+should be proportionate to that spent on the project itself. It should be easy
+to set up a small project, maybe a little harder for a medium-sized project,
+and it may take some more time, but not too much, for a big project. Ideally
+setting up a big project would be as easy as setting up a small project. However,
+as projects grow, modularization techniques start to be used, and the probability
+of using meta programming or multiple programming languages increases, thus making
+the compilation process more delicate.
+
+\ocb is intended to be very easy to use for projects, large or small, with a simple
+compilation process: typing
+\texttt{ocamlbuild foo.native} should be enough to compile the native version
+of a program whose top module is \texttt{foo.ml} and whose dependencies are in
+the same directory. As your project gets more complex, you will gradually
+start to use command-line options to specify libraries to link with, then
+configuration files, ultimately culminating in a custom OCaml plugin for
+complex projects with arbitrary dependencies and actions.
+
+%(*** Hygiene *)
+\subsection{Hygiene \& where is my code ?}
+Your code is in the \texttt{\_build} directory, but \ocb automatically creates
+a symbolic link to the executables it produces in the current directory.
+\ocb copies the source files and compiles them in a separate directory
+which is \texttt{\_build} by default.
+
+For \ocb, any file that is not in the build directory is a source file.
+It is not unreasonable to think that some users may have bought binary object files
+they keep in their project directory. Usually binary files cluttering the project
+directory are due to previous builds using other systems. \ocb has so-called
+``hygiene'' rules that state that object files (\texttt{.cmo}, \texttt{.cmi},
+or \texttt{.o} files, for instance) must not appear outside of the build
+directory. These rules are enforced at startup; any violations will be reported
+and \ocb will exit. You must then remove these files by hand or run, with caution,
+the script \texttt{sanitize.sh}, which is generated in your source directory.
+This script will contain commands to remove them for you.
+
+To disable these checks, you can use the \texttt{-no-hygiene} flag. If you have
+files that must elude the hygiene squad, just tag them with \texttt{precious}
+or \texttt{not\_hygienic}.
+%***)
+%(*** Hello, world !
+\subsection{Hello, world !}
+Assuming we are in a directory named \texttt{example1} containing one file \texttt{hello.ml}
+whose contents are
+\begin{verbatim}
+let _ =
+ Printf.printf "Hello, %s ! My name is %s\n"
+ (if Array.length Sys.argv > 1 then Sys.argv.(1) else "stranger")
+ Sys.argv.(0)
+;;
+\end{verbatim}
+we can compile and link it into a native executable by invoking \texttt{ocamlbuild hello.native}.
+Here, \texttt{hello} is the basename of the top-level module and \texttt{native} is an extension used
+by \ocb to denote native code executables.
+\begin{verbatim}
+% ls
+hello.ml
+% ocamlbuild hello.native
+Finished, 4 targets (0 cached) in 00:00:00.
+% ls -l
+total 12
+drwxrwx--- 2 linus gallium 4096 2007-01-17 16:24 _build/
+-rw-rw---- 1 linus gallium 43 2007-01-17 16:23 hello.ml
+lrwxrwxrwx 1 linus gallium 19 2007-01-17 16:24 hello.native -> _build/hello.native*
+\end{verbatim}
+What's this funny \texttt{\_build} directory ? Well that's where \ocb does its dirty work
+of compiling. You usually won't have to look very often into this directory. Source files are be copied
+into \texttt{\_build} and this is where the compilers will be run. Various cache files are also stored
+there. Its contents may look like this:
+\begin{verbatim}
+% ls -l _build
+total 208
+-rw-rw---- 1 linus gallium 337 2007-01-17 16:24 _digests
+-rw-rw---- 1 linus gallium 191 2007-01-17 16:24 hello.cmi
+-rw-rw---- 1 linus gallium 262 2007-01-17 16:24 hello.cmo
+-rw-rw---- 1 linus gallium 225 2007-01-17 16:24 hello.cmx
+-rw-rw---- 1 linus gallium 43 2007-01-17 16:23 hello.ml
+-rw-rw---- 1 linus gallium 17 2007-01-17 16:24 hello.ml.depends
+-rwxrwx--- 1 linus gallium 173528 2007-01-17 16:24 hello.native*
+-rw-rw---- 1 linus gallium 936 2007-01-17 16:24 hello.o
+-rw-rw---- 1 linus gallium 22 2007-01-17 16:24 ocamlc.where
+\end{verbatim}
+%***)
+%(*** Executing my code
+\subsection{Executing my code}
+You can execute your code the old-fashioned way (\texttt{./hello.native}).
+You may also type
+\begin{verbatim}
+ocamlbuild hello.native -- Caesar
+\end{verbatim}
+and it will compile and then run \texttt{hello.native} with the arguments following \texttt{-{}-},
+which should display:
+\begin{verbatim}
+% ocamlbuild hello.native -- Caesar
+Finished, 4 targets (0 cached) in 00:00:00.
+Hello, Caesar ! My name is _build/hello.native
+\end{verbatim}
+%***)
+%(*** The log file, verbosity and debugging
+\subsection{The log file, verbosity and debugging}
+By default, if you run \ocb on a terminal, it will use some ANSI escape sequences
+to display a nice, one-line progress indicator. To see what commands \ocb has actually run,
+you can check the contents of the \texttt{\_build/\_log} file. To change the name of the
+log file or to disable logging, use the \texttt{-log <file>} or \texttt{-no-log} options.
+Note that the log file is truncated at each execution of \ocb.
+
+The log file contains all the external commands that \ocb ran or intended to
+run along with the target name and the computed tags. With the
+\texttt{-verbose <level>} option, \ocb will also write more or less useful
+debugging information; a verbosity level of $1$ (which can also be specified
+using the \texttt{-verbose} switch) prints generally useful information; higher
+levels produce much more output.
+%***)
+%(*** Cleaning
+\subsection{Cleaning}
+\ocb may leave a \texttt{\_build} directory and symbolic links to executables in
+that directory (unless when using -no-links). All of these can be removed safely
+by hand, or by invoking \ocb with the \texttt{-clean} flag.
+%***)
+%(*** Where and how to run \ocb
+\subsection{Where and how to run \ocb ?}
+An important point is that \ocb must be invoked from the root of the project,
+even if this project has multiple, nested subdirectories. This is because \ocb
+likes to store the object files in a single \texttt{\_build} directory. You
+can change the name of that directory with the \texttt{-build-dir} option.
+
+\ocb can be either invoked manually from the UNIX or Windows shell, or
+automatically from a build script or a Makefile. Unless run with the
+\texttt{-no-hygiene} option, there is the possibility that \ocb will prompt the
+user for a response. By default, on UNIX systems, if \ocb senses that the
+standard output is a terminal, it will use a nice progress indicator using ANSI
+codes, instrumenting the output of the processes it spawns to have a consistent
+display. Under non-UNIX systems, or if the standard output is not a terminal,
+it will run in classic mode where it will echo the executed commands on its
+standard output. This selection can be overridden with the \texttt{-classic-display} option.
+%***)
+%(*** Dependencies
+\subsection{Dependencies}
+{\em Dependencies are automatically discovered.}
+
+Most of the value of \ocb lies in the fact that it often needs no extra
+information to compile a project besides the name of the top-level module.
+\ocb calls \texttt{ocamldep} to automatically find the dependencies of any
+modules it wants to compile. These dependencies are dynamically incorporated
+in the dependency graph, something \texttt{make} cannot do.
+For instance, let's add a module \texttt{Greet} that implements various ways of
+greeting people.
+\begin{verbatim}
+% cat greet.ml
+type how = Nicely | Badly;;
+
+let greet how who =
+ match how with Nicely -> Printf.printf "Hello, %s !\n" who
+ | Badly -> Printf.printf "Oh, here is that %s again.\n" who
+;;
+% cat hello.ml
+open Greet
+
+let _ =
+ let name =
+ if Array.length Sys.argv > 1 then
+ Sys.argv.(1)
+ else
+ "stranger"
+ in
+ greet
+ (if name = "Caesar" then Nicely else Badly)
+ name;
+ Printf.printf "My name is %s\n" Sys.argv.(0)
+;;
+\end{verbatim}
+Then the module \texttt{Hello} depends on the module \texttt{Greet} and \ocb can
+figure this out for himself -- we still only have to invoke \texttt{\ocb
+hello.native}. Needless to say, this works for any number of modules.
+%***)
+%(*** Native and byte code
+\subsection{Native and byte-code}
+If we want to compile byte-code instead of native, we just a target name of
+\texttt{hello.byte} instead of \texttt{hello.native}, i.e., we type
+\texttt{\ocb hello.byte}.
+%***)
+%(*** Compile flags
+\subsection{Compile flags}
+To pass a flag to the compiler, such as the \texttt{-rectypes} option,
+use the \texttt{-cflag} option as in:
+\begin{verbatim}
+ocamlbuild -cflag -rectypes hello.native
+\end{verbatim}
+You can put multiple \texttt{-cflag} options, they will be passed to the compiler
+in the same order. You can also given them in a comma-separated list with the
+\texttt{-cflags} option (notice the plural):
+\begin{verbatim}
+ocamlbuild -cflags -I,+lablgtk,-rectypes hello.native
+\end{verbatim}
+These flags apply when compiling, that is, when producing \texttt{.cmi},
+\texttt{.cmo},\texttt{.cmx} and \texttt{.o} files from \texttt{.ml} or
+\texttt{.mli} files.
+%***)
+%(*** Link flags
+\subsection{Link flags}
+Link flags apply when the various object files are collected and linked into
+one executable. These will typically be include directories for libraries.
+They are given using the \texttt{-lflag} and \texttt{-lflags} options, which
+work in the same way as the \texttt{-cflag} and \texttt{-cflags} options.
+%***)
+%(*** Linking with external libraries
+\subsection{Linking with external libraries}
+In our third example, we use one Unix system call and functions from the \texttt{num}
+library:
+\begin{verbatim}
+% cat epoch.ml
+let _ =
+ let s = Num.num_of_string (Printf.sprintf "%.0f" (Unix.gettimeofday ())) in
+ let ps = Num.mult_num (Num.num_of_string "1000000000000") s in
+ Printf.printf "%s picoseconds have passed since January 1st, 1970.\n"
+ (Num.string_of_num ps)
+;;
+\end{verbatim}
+This requires linking with the \texttt{unix} and \texttt{num} modules, which is accomplished
+by using the \texttt{-lib unix} and \texttt{-lib num} flags, or, alternatively, \texttt{-libs unix,num}:
+\begin{verbatim}
+% ocamlbuild -libs nums,unix epoch.native --
+Finished, 4 targets (4 cached) in 00:00:00.
+1169051647000000000000 picoseconds have passed since January 1st, 1970.
+\end{verbatim}
+You may need to add options such as \texttt{-cflags -I,/usr/local/lib/ocaml/}
+and \texttt{-lflags -I,/usr/local/lib/ocaml/} if the libraries you wish to
+link with are not in OCaml's default search path.
+%***)
+%(*** The _tags files
+\subsection{The \tags files}
+Finer control over the compiler flags applied to each source file, such as
+preprocessing, debugging, profiling and linking options, can be gained using
+\ocb's tagging mechanism.
+
+Every source file has a set of tags which tells \ocb what kind of file it is
+and what to do with it. A tag is simply a string, usually lowercase, for
+example \texttt{ocaml} or \texttt{native}. The set of tags attached to a file
+is computed by applying the tagging rules to the filename. Tagging rules are
+defined in \tags files in any parent directory of a file, up to the main
+project directory.
+
+Each line in the \tags file is made of a glob pattern (see subsection
+\ref{subsec:glob}) and a list of tags. More than one rule can apply to a file
+and rules are applied in the order in which they appear in a file.
+By preceding a tag with a minus sign, one may remove tags from one or more files.
+
+\subsubsection{Example: the built-in \tags file}
+\begin{verbatim}
+ <**/*.ml> or <**/*.mli> or <**/*.mlpack> or <**/*.ml.depends>: ocaml
+ <**/*.byte>: ocaml, byte, program
+ <**/*.odoc>: ocaml, doc
+ <**/*.native>: ocaml, native, program
+ <**/*.cma>: ocaml, byte, library
+ <**/*.cmxa>: ocaml, native, library
+ <**/*.cmo>: ocaml, byte
+ <**/*.cmi>: ocaml, byte, native
+ <**/*.cmx>: ocaml, native
+\end{verbatim}
+
+A special tag made from the path name of the file relative to the toplevel
+of the project is automatically defined for each file. For a file
+\texttt{foo/bar.ml} this tag will be \texttt{file:foo/bar.ml}.
+
+If you do not have subdirectories, you can put \texttt{*.ml} instead of
+\texttt{**/*.ml}.
+%***)
+%(*** Glob patterns and expressions
+\subsection{Glob patterns and expressions}
+\label{subsec:glob}
+Glob patterns have a syntax similar to those used by UNIX shells to select path
+names (like \texttt{foo\_*.ba?}). They are used in \ocb to define the files
+and directories to which tags apply. Glob expressions are glob patterns
+enclosed in brackets \texttt{<} and \texttt{>} combined using the standard
+boolean operators \texttt{and}, \texttt{or}, \texttt{not}. This allows one to
+describe sets of path names in more concise and more readable ways.
+
+Please note that file and directory names are supposed to be made of the
+following characters: $\texttt{a}$, $\dots$, $\texttt{z}$, $\texttt{A}$,
+$\dots$, $\texttt{Z}$, $\texttt{0}$, $\dots$, $\texttt{9}$, $\texttt{\_}$,
+$\texttt{-}$ and $\texttt{.}$. This is called the pathname alphabet $P$.
+
+\begin{table}[h]
+ \begin{center}
+ \small
+ \begin{tabular}{|p{3cm}|l|p{3cm}|p{3cm}|p{5cm}|}
+ \hline
+ {\em Formal syntax} &
+ {\em Example} & {\em Matches} & {\em Does not match} &
+ {\em Meaning (formal meaning)} \\
+ \hline
+ \hline
+%%
+ {$u$ \vspace*{0.5em} A string of pathname characters} &
+ \texttt{foo.ml} &
+ \texttt{foo.ml} &
+ \texttt{fo.ml}, \texttt{bar/foo.ml} &
+ The exact string $u$
+ ($\{ u \}$, where $u \in P^*$) \\
+ \hline
+%%
+ {\texttt{*} \vspace*{0.5em} The wild-card star}&
+ \texttt{*}&
+ $\varepsilon$, \texttt{foo}, \texttt{bar} &
+ \texttt{foo/bar}, \texttt{/bar} &
+ Any string not containing a slash
+ ($P^*$) \\
+ \hline
+%%
+ {\texttt{?} \vspace*{0.5em} The joker}&
+ \texttt{?}&
+ \texttt{a}, \texttt{b}, \texttt{z} &
+ \texttt{/}, \texttt{bar} &
+ Any one-letter string, excluding the slash \\
+ \hline
+%%
+ {\texttt{**/} \vspace*{0.5em} The prefix inter-directory star}&
+ \texttt{**/foo.ml}&
+ \texttt{foo.ml}, \texttt{bar/foo.ml}, \texttt{bar/baz/foo.ml} &
+ \texttt{foo/bar}, \texttt{/bar} &
+ The empty string, or any string ending with a slash
+ ($\varepsilon \cup P^*\mathtt{/}$) \\
+ \hline
+%%
+ {\texttt{/**} \vspace*{0.5em} The suffix inter-directory star}&
+ \texttt{foo/**}&
+ \texttt{foo}, \texttt{foo/bar} &
+ \texttt{bar/foo} &
+ Any string starting with a slash, or the empty string
+ ($\varepsilon \cup \mathtt{/}P^*$) \\
+ \hline
+%%
+ {\texttt{/**/} \vspace*{0.5em} The infix inter-directory star}&
+ \texttt{bar/**/foo.ml}&
+ \texttt{bar/foo.ml}, \texttt{bar/baz/foo.ml} &
+ \texttt{foo.ml} &
+ Any string starting and ending with a slash
+ ($\varepsilon \cup \mathtt{/}P^*\mathtt{/}$) \\
+ \hline
+%%
+ {$\mathtt{[} r_1 r_2 \cdots r_k \mathtt{]}$
+ where $r_i$ is either $c$ or $c_1-c_2$ $(1 \leq i \leq k)$
+ \vspace*{0.5em} The positive character class}&
+ \texttt{[a-fA-F0-9\_.]}&
+ \texttt{3}, \texttt{F}, \texttt{.} &
+ \texttt{z}, \texttt{bar} &
+ Any one-letter string made of characters from one of the ranges
+ $r_i$ ($1 \leq i \leq n$).
+ ($\mathscr L(r_1) \cup \cdots \cup \mathscr L(r_n)$) \\
+ \hline
+%%
+ {\texttt{[\char`\^}$r_1 r_2 \cdots r_k \mathtt{]}$
+ where $r_i$ is either $c$ or $c_1-c_2$ $(1 \leq i \leq k)$
+ \vspace*{0.5em} The negative character class}&
+ \texttt{[\char`\^a-fA-F0-9\_.]}&
+ \texttt{z}, \texttt{bar} &
+ \texttt{3}, \texttt{F}, \texttt{.} &
+ Any one-letter string NOT made of characters from one of the ranges
+ $r_i$ ($1 \leq i \leq n$).
+ ($\Sigma^* \setminus \left(\mathscr L(r_1) \cup \cdots \cup \mathscr L(r_n)\right)$) \\
+ \hline
+%%
+ {$p_1 p_2$ \vspace*{0.5em} A concatenation of patterns}&
+ \texttt{foo*}&
+ \texttt{foo}, \texttt{foob}, \texttt{foobar} &
+ \texttt{fo}, \texttt{bar} &
+ Any string with a prefix matching $p_1$ and the corresponding suffix
+ matching $p_2$,
+ ($\{ uv \mid u \in \mathscr L(p_1), v \in \mathscr L(p_2) \}$) \\
+ \hline
+%%
+ {$\mathtt{\{} p_1 \mathtt{,} p_2 \mathtt{,} \cdots \mathtt{,} p_k \mathtt{\}}$ \vspace*{0.5em} A union of patterns}&
+ \texttt{toto.\{ml,mli\}}&
+ \texttt{toto.ml}, \texttt{toto.mli} &
+ \texttt{toto.} &
+ Any string matching one of the patterns $p_i$ for $1 \leq i \leq k$.
+ ($\mathscr L(p_1) \cup \cdots \cup \mathscr L(p_k)$) \\
+ \hline
+%%
+ \end{tabular}
+ \end{center}
+ \caption{
+ Syntax and semantics of glob patterns.
+ }
+\end{table}
+\begin{table}
+ \begin{center}
+ \small
+ \begin{tabular}{|p{2cm}|l|p{7cm}|}
+ \hline
+ {\em Formal syntax} &
+ {\em Example} &
+ {\em Meaning (formal meaning)} \\
+ \hline
+ \hline
+ {$\mathtt{<}p\mathtt{>}$} &
+ \texttt{<foo.ml>} &
+ Pathnames matching the pattern $p$ \\
+ \hline
+ {$e_1 \; \mathtt{or} \; e_2$} &
+ \texttt{<*.ml> or <foo/bar.ml>} &
+ Pathnames matching at least one of the expressions $e_1$ and $e_2$ \\
+ \hline
+ {$e_1 \; \mathtt{and} \; e_2$} &
+ \texttt{<*.ml> and <foo\_*>} &
+ Pathnames matching both expressions $e_1$ and $e_2$ \\
+ \hline
+ {$\mathtt{not} \; e$} &
+ \texttt{not <*.mli>} &
+ Pathnames not matching the expression $e$ \\
+ \hline
+ {$\mathtt{true}$} &
+ \texttt{true} &
+ All pathnames \\
+ \hline
+ {$\mathtt{false}$} &
+ \texttt{false} &
+ No pathnames \\
+ \hline
+ \end{tabular}
+ \end{center}
+ \caption{
+ Syntax and semantics of glob expressions.
+ }
+\end{table}
+%***)
+%(*** Subdirectories
+\subsection{Subdirectories}
+If the files of your project are held in one or more subdirectories,
+\ocb must be made aware of that fact using the \texttt{-I} or \texttt{-Is} options
+or by adding an \texttt{include} tag. For instance, assume your project is made
+of three subdirectories, \texttt{foo}, \texttt{bar} and \texttt{baz} containing
+various \texttt{.ml} files, the main file being \texttt{foo/main.ml}. Then you can
+either type:
+\begin{verbatim}
+% ocamlbuild -Is foo,bar,baz foo/main.native
+\end{verbatim}
+or add the following line in the \tags file
+\begin{verbatim}
+<foo> or <bar> or <baz>: include
+\end{verbatim}
+and call
+\begin{verbatim}
+% ocamlbuild foo/main.native
+\end{verbatim}
+
+There are then two cases. If no other modules named \texttt{Bar} or
+\texttt{Baz} exist elsewhere in the project, then you are done. Just use
+\texttt{Foo}, \texttt{Foo.Bar} and \texttt{Foo.Baz} in your code.
+Otherwise, you will need to use the plugin mechanism and define the mutual
+visibility of the subdirectories using the \texttt{Pathname.define\_context}
+function.
+
+\subsubsection{Note on subdirectory traversal}
+\ocb used to traverse by default any subdirectory not explicitly excluded.
+This is no longer the case. Note that you can still have a fine grained
+control using your \tags file and the \texttt{traverse} tag.
+
+There is no longer the \texttt{true: traverse} tag declaration by default. To
+make \ocb recursive use one of these:
+\begin{enumerate}
+\item Give the \texttt{-r} flag to ocamlbuild.
+\item Have a \tags or myocamlbuild.ml file in your top directory.
+\end{enumerate}
+
+%***)
+%(*** Grouping targets
+\subsection{Grouping targets with \texttt{.itarget}}
+You can create a file named \texttt{foo.itarget} containing
+a list of targets, one per line, such as
+\begin{verbatim}
+main.native
+main.byte
+stuff.docdir/index.html
+\end{verbatim}
+Requesting the target \texttt{foo.otarget} will then build every target
+listed in the file \texttt{foo.itarget}. Blank lines and lines starting
+with a sharp (\texttt{\#}) are ignored.
+%***)
+%(*** Packing subdirectories into modules
+\subsection{Packing subdirectories into modules}
+OCaml's \texttt{-pack} option allows you to structure the contents of a
+module in a subdirectory. For instance, assume you have a directory
+\texttt{foo} containing two modules \texttt{bar.ml} and \texttt{baz.ml}.
+You want from these to build a module \texttt{Foo} containing \texttt{Bar}
+and \texttt{Baz} as submodules. In the case where no modules named
+\texttt{Bar} or \texttt{Baz} exist outside of \texttt{Foo}, to do this you
+must write a file \texttt{foo.mlpack}, preferably sitting in the same
+directory as the directory \texttt{Foo} and containing the list of modules
+(one per line) it must contain:
+\begin{verbatim}
+Bar
+Baz
+\end{verbatim}
+Then when you will request for building \texttt{foo.cmo} the package will be
+made from \texttt{bar.cmo} and \texttt{baz.cmo}.
+%***)
+%(*** Making an OCaml library
+\subsection{Making an OCaml library}
+In a similar way than for packaged modules you can make a library by putting
+it's contents in a file (with the mllib extension). For instance, assume you
+have a two modules \texttt{bar.ml} and \texttt{baz.ml}. You want from these to
+build a library \texttt{foo.cmx?a} containing \texttt{Bar} and \texttt{Baz}
+modules. To do this you must write a file \texttt{foo.mllib} containing the
+list of modules (one per line) it must contain:
+\begin{verbatim}
+Bar
+Baz
+\end{verbatim}
+Then when you will request for building \texttt{foo.cma} the library will be
+made from \texttt{bar.cmo} and \texttt{baz.cmo}.
+%***)
+%(*** Making an OCaml toplevel
+\subsection{Making an OCaml toplevel}
+Making a toplevel is almost the same thing than making a packaged module or a
+library. Just write a file with the \texttt{mltop} extension (like
+\texttt{foo.mltop}) and request for building the toplevel using the
+\texttt{top} extension (\texttt{foo.top} in this example).
+%***)
+%(*** Preprocessor options
+\subsection{Preprocessor options and tags}
+You can specify preprocessor options with \texttt{-pp} followed by the
+preprocessor string, for instance \texttt{ocamlbuild -pp "camlp4o.opt -unsafe"}
+would run your sources thru CamlP4 with the \texttt{-unsafe} option.
+Another way is to use the tags file.
+\begin{center}
+ \begin{tabular}{|l|l|l|}
+ \hline
+ \textbf{Tag} & \textbf{Preprocessor command} & \textbf{Remark} \\
+ \hline
+ \hline
+ \texttt{pp(cmd...)} & \texttt{cmd...} & Arbitrary
+ preprocessor command\footnote{The command must not contain newlines or parentheses.} \\
+ \hline
+ \texttt{camlp4o} & \texttt{camlp4o} & Original OCaml syntax \\
+ \hline
+ \texttt{camlp4r} & \texttt{camlp4r} & Revised OCaml syntax \\
+ \hline
+ \texttt{camlp4of} & \texttt{camlp4of} & Original OCaml syntax with extensions \\
+ \hline
+ \texttt{camlp4rf} & \texttt{camlp4rf} & Revised OCaml syntax with extensions \\
+ \hline
+ \end{tabular}
+\end{center}
+
+%%%%% \subsubsection{An example, dealing with some configuration variables}
+%%%%%
+%%%%% It's quite common to have in your sources some files that you want to access
+%%%%% when your program is running. One often uses some variables that are setup by
+%%%%% the end user. Now suppose that there is only two files that use these variables
+%%%%% (mylib.ml and parseopt.ml).
+%%%%%
+%%%%% In the \tags file:
+%%%%% \begin{verbatim}
+%%%%% "mylib.ml" or "parseopt.ml": pp(sed -e "s,LIBDIR,/usr/local/lib/FOO,g")
+%%%%% \end{verbatim}
+%%%%%
+%%%%% In fact that solution is not really acceptable, since the variable is hardcoded
+%%%%% in the \tags file. Trying to workaround this issue by using some shell variable
+%%%%% does not work either since the -pp argument will be escaped in simple quotes.
+%%%%% Note also that using some script shell that will do that sed and use \verb'$LIBDIR'
+%%%%% as a shell variable is not a good idea since \ocb don't know this dependency on that
+%%%%% shell script.
+%%%%%
+%%%%% There is in fact at least two good solutions. The first is to tell that dependency
+%%%%% using the \texttt{dep} function in your plugin. The second is simpler it just consist
+%%%%% on generating some OCaml file at configure time. By naming this configuration file
+%%%%% \texttt{myocamlbuild_config.ml} \ocb will make it also available to your plugin.
+%%%%%
+%%%%% In your \texttt{myocamlbuild_config.mli} interface:
+%%%%% \begin{verbotim}
+%%%%% val prefix : string
+%%%%% val libdir : string
+%%%%% \end{verbotim}
+%%%%%
+%%%%% And in your \texttt{configure} script
+%%%%% \begin{verbatim}
+%%%%% #!/bin/sh
+%%%%%
+%%%%% # Setting defaults values
+%%%%% PREFIX=/usr/local
+%%%%% LIBDIR=$PREFIX/lib/FOO
+%%%%% CONF=myocamlbuild_config.ml
+%%%%%
+%%%%% # ... some shell to parse option and check configuration ...
+%%%%%
+%%%%% # Dumping the configuration as an OCaml file.
+%%%%% rm -f $CONF
+%%%%% echo "let prefix = \"$PREFIX\";;" >> $CONF
+%%%%% echo "let libdir = \"$LIBDIR\";;" >> $CONF
+%%%%% chmod -w $CONF
+%%%%% \end{verbatim}
+
+%***)
+%(*** Debugging and profiling
+\subsection{Debugging byte code and profiling native code}
+The preferred way of compiling code suitable for debugging with \texttt{ocamldebug} or
+profiling native code with \texttt{ocamlprof} is to use the appropriate target
+extensions, \texttt{.d.byte} for debugging or \texttt{.p.native}.
+
+Another way is to add use the \texttt{debug} or \texttt{profile} tags.
+Note that these tags must be applied at the compilation and linking stages.
+Hence you must either use \texttt{-tag debug} or \texttt{-tag profile}
+on the command line, or add a
+\begin{verbatim}
+true: debug
+\end{verbatim}
+line to your \tags file.
+Please note that the byte-code profiler works in a wholly different way
+and is not supported by \ocb.
+%***)
+%(*** Generating documentation using \texttt{ocamldoc}
+\subsection{Generating documentation using \texttt{ocamldoc}}
+Write the names of the modules whose interfaces will be documented in a file
+whose extension is \texttt{.odocl}, for example \texttt{foo.odocl}, then invoke
+\ocb on the target \texttt{foo.docdir/index.html}. This will collect all the
+documentation from the interfaces (which will be build, if necessary) using
+\texttt{ocamldoc} and generate a set of HTML files under the directory
+\texttt{foo.docdir/}, which is actually a link to \texttt{\_build/foo.docdir/}.
+As for packing subdirectories into modules, the module names must be written
+one per line, without extensions and correctly capitalized. Note that
+generating documentation in formats other than HTML or from implementations is
+not supported.
+%***)
+%(*** The display line
+\subsection{The display line}
+Provided \ocb runs in a terminal under a POSIX environment, it will
+display a sophisticated progress-indicator line that graciously interacts
+with the output of subcommands. This line looks like this:
+\begin{verbatim}
+00:00:02 210 (180 ) main.cmx ONbp--il /
+\end{verbatim}
+Here, 00:00:02 is the elapsed time in hour:minute:second format since \ocb has
+been invoked; 210 is the number of external commands, typically calls to the
+compiler or the like, that may or may not have been invoked; 180 is the number
+of external commands that have not been invoked since their result is already
+in the build directory; \texttt{main.cmx} is the name of the last target built;
+\texttt{ONbp--il} is a short string that describes the tags that have been
+encountered and the slash at the end is a frame from a rotating ticker. Hence,
+the display line has the following structure:
+\begin{verbatim}
+HH:MM:SS JOBS (CACHED) PATHNAME TAGS TICKER
+\end{verbatim}
+
+The tag string is made of 8 indicators which each monitor a tag. These tags
+are \texttt{ocaml}, \texttt{native}, \texttt{byte}, \texttt{program},
+\texttt{pp}, \texttt{debug}, \texttt{interf} and \texttt{link}. Initially,
+each indicator displays a dash \texttt{-}. If the current target has the
+monitored tag, then the indicator displays the corresponding character
+(see table \ref{tab:tag-chars}) in uppercase. Otherwise, it displays that
+character in lowercase. This allows you to see the set of tags that have
+been applied to files in your project during the current invocation of \ocb.
+
+Hence the tag string \texttt{ONbp--il} means that the current target
+\texttt{main.cmx} has the tags \texttt{ocaml} and \texttt{native}, and that
+the tags \texttt{ocaml}, \texttt{native}, \texttt{byte}, \texttt{program},
+\texttt{interf} and \texttt{link} have already been seen.
+
+\begin{table}
+ \begin{center}
+ \begin{tabular}{|l|c|}
+ \hline
+ \textbf{Tag} & \textbf{Display character} \\
+ \hline
+ \hline
+ ocaml & O \\
+ \hline
+ native & N \\
+ \hline
+ byte & B \\
+ \hline
+ program & P \\
+ \hline
+ pp & R \\
+ \hline
+ debug & D \\
+ \hline
+ interf & I \\
+ \hline
+ link & L \\
+ \hline
+ \end{tabular}
+ \end{center}
+ \caption{\label{tab:tag-chars} Relation between the characters displayed in
+ the tag string and the tags.}
+\end{table}
+%***)
+%(*** ocamllex, ocamlyacc and menhir
+\subsection{\texttt{ocamllex}, \texttt{ocamlyacc} and \texttt{menhir}}
+\ocb knows how to run the standard lexer and parser generator tools
+\texttt{ocamllex} and \texttt{ocamlyacc} when your files have the
+standard \texttt{.mll} and \texttt{.mly} extensions. If you want to
+use \texttt{menhir} instead of \texttt{ocamlyacc}, you can either
+launch \ocb with the \texttt{-use-menhir} option or add a
+\begin{verbatim}
+true: use_menhir
+\end{verbatim}
+line to your \tags file. Note that there is currently no way
+of using \texttt{menhir} and \texttt{ocamlyacc} in the same execution
+of \ocb.
+%***)
+%(*** Changing the compilers
+\subsection{Changing the compilers or tools}
+As \ocb is part of your OCaml distribution, it knows if it can call the
+native compilers and tools (\texttt{ocamlc.opt}, \texttt{ocamlopt.opt}...)
+or not. However you may want \ocb to use another \texttt{ocaml} compiler
+for different reasons (such as cross-compiling or using a wrapper such as
+\texttt{ocamlfind}). Here is the list of relevant options:
+\begin{itemize}
+ \item \texttt{-ocamlc <command>}
+ \item \texttt{-ocamlopt <command>}
+ \item \texttt{-ocamldep <command>}
+ \item \texttt{-ocamlyacc <command>}
+ \item \texttt{-menhir <command>}
+ \item \texttt{-ocamllex <command>}
+ \item \texttt{-ocamlmktop <command>}
+ \item \texttt{-ocamlrun <command>}
+\end{itemize}
+
+%***)
+\subsection{Writing a \texttt{myocamlbuild.ml} plugin}
+%(*** Interaction with version control systems
+\subsection{Interaction with version control systems}
+Here are tips for configuring your version control system to ignore the files
+and directories generated by \ocb.
+
+The directory \texttt{\_build} and any symbolic links
+pointing into \texttt{\_build} should be ignored.
+To do this, you must add the following ignore patterns to your version
+control system's ignore set:
+\begin{verbatim}
+_build
+*.native
+*.byte
+*.d.native
+*.p.byte
+\end{verbatim}
+
+For CVS, add the above lines to the \texttt{.cvsignore} file.
+For Subversion (SVN), type \texttt{svn propedit svn:ignore .} and add the
+above lines.
+%***)
+%(*** A shell script for driving it all?
+\subsection{A shell script for driving it all?}
+{\em To shell or to make ?}
+Traditionally, makefiles have two major functions. The first one
+is the dependency-ordering, rule-matching logic used for compiling.
+The second one is as a dispatcher for various actions defined using
+phony targets with shell script actions. These actions include cleaning,
+cleaning really well, archiving, uploading and so on. Their characteristic
+is that they rely little or not on the building process -- they either need
+the building to have been completed, or they don't need anything.
+As \texttt{/bin/sh} scripts have been here for three to four decades and are
+not going anywhere, why not replace that functionality of makefiles with a
+shell script ? We have thought of three bad reasons:
+\begin{itemize}
+ \item Typing \texttt{make} to compile is now an automatism,
+ \item We need to share variable definitions between rules and actions,
+ \item Escaping already way too special-character-sensitive shell code with
+ invisible tabs and backslashes is a dangerously fun game.
+\end{itemize}
+We also have bad reasons for not using an OCaml script to drive everything:
+\begin{itemize}
+ \item \texttt{Sys.command} calls the \texttt{/bin/sh} anyway,
+ \item Shell scripts can execute partial commands or commands with badly formed arguments.
+ \item Shell scripts are more concise for expressing... shell scripts.
+\end{itemize}
+Anyway you are of course free to use a makefile or an OCaml script to call ocamlbuild.
+Here is an example shell driver script:
+\begin{verbatim}
+#!/bin/sh
+
+set -e
+
+TARGET=epoch
+FLAGS="-libs unix,nums"
+OCAMLBUILD=ocamlbuild
+
+ocb()
+{
+ $OCAMLBUILD $FLAGS $*
+}
+
+rule() {
+ case $1 in
+ clean) ocb -clean;;
+ native) ocb $TARGET.native;;
+ byte) ocb $TARGET.byte;;
+ all) ocb $TARGET.native $TARGET.byte;;
+ depend) echo "Not needed.";;
+ *) echo "Unknown action $1";;
+ esac;
+}
+
+if [ $# -eq 0 ]; then
+ rule all
+else
+ while [ $# -gt 0 ]; do
+ rule $1;
+ shift
+ done
+fi
+\end{verbatim}
+%***)
+%\subsection{Common errors}
+%***)
+\appendix
+%(*** Motivations
+\section{Motivations}
+{\em This inflammatory appendix describes the frustration that led us to write \ocb.}
+
+Many people have painfully found that the utilities of the \texttt{make}
+family, namely GNU Make, BSD Make, and their derivatives, fail to scale to
+large projects, especially when using multi-stage compilation rules, such as
+custom pre-processors, unless dependencies are hand-defined. But as your
+project gets larger, more modular, and uses more diverse pre-processing tools,
+it becomes increasingly difficult to correctly define dependencies by hand.
+Hence people tend to use language-specific tools that attempt to extract
+dependencies. However another problem then appears: \texttt{make} was designed
+with the idea of a static dependency graph. Dependency extracting tools,
+however, are typically run by a rule in \texttt{make} itself; this means that
+make has to reload the dependency information. This is the origin of the
+\texttt{make clean; make depend; make} mantra. This approach tends to work
+quite well as long as all the files sit in a single directory and there is only
+one stage of pre-processing. If there are two or more stages, then dependency
+extracting tools must be run two or more times - and this means multiple
+invocations of \texttt{make}. Also, if one distributes the modules of a large
+project into multiple subdirectories, it becomes difficult to distribute the
+makefiles themselves, because the language of \texttt{make} was not conceived
+to be modular; the only two mechanisms permitted, inclusion of makefile
+fragments, and invocation of other make instances, must be skillfully
+coordinated with phony target names (\texttt{depend1, depend2...}) to insure
+inclusion of generated dependencies with multi-stage programming; changes in
+the structure of the project must be reflected by hand and the order of
+variable definitions must be well-thought ahead to avoid long afternoons spent
+combinatorially fiddling makefiles until it works but no one understands why.
+
+These problems become especially apparent with OCaml: to ensure type safety and
+to allow a small amount of cross-unit optimization when compiling native code,
+interface and object files include cryptographical digests of interfaces they
+are to be linked with. This means that linking is safer, but that makefile sloppiness
+leads to messages such as:
+\begin{verbatim}
+Files foo.cmo and bar.cmo
+make inconsistent assumptions over interface Bar
+\end{verbatim}
+
+The typical reaction is then to issue the mantra \texttt{make clean; make
+depend; make} and everything compiles just fine... from the beginning. Hence
+on medium projects, the programmer often has to wait for minutes instead of the
+few seconds that would be taken if \texttt{make} could correctly guess the
+small number of files that really had to be recompiled.
+
+It is not surprising that hacking a build tool such as \texttt{make} to include
+a programming language while retaining the original syntax and semantics gives
+an improvised and cumbersome macro language of dubious expressive power. For
+example, using GNU make, suppose you have a list of \texttt{.ml}s that you want
+to convert into a list including both \texttt{.cmo}s and \texttt{.cmi}s, that
+is you want to transform \texttt{a.ml b.ml c.ml} into \texttt{a.cmi a.cmo b.cmi
+b.cmo c.cmi c.cmo} while preserving the dependency order which must be hand
+specified for linking \footnote{By the way, what's the point of having a
+declarative language if \texttt{make} can't sort the dependencies in
+topological order for giving them to \texttt{gcc} or whatever ?}.
+Unfortunately \texttt{\$patsubst \%.ml, \%.cmi \%.cmo, a.ml b.ml c.ml} won't
+work since the \%-sign in the right-hand of a \texttt{patsubst} gets
+substituted only once. You then have to delve into something that is hardly
+lambda calculus: an intricate network of \texttt{foreach}, \texttt{eval},
+\texttt{call} and \texttt{define}s may get you the job done, unless you chicken
+out and opt for an external \texttt{awk}, \texttt{sed} or \texttt{perl} call.
+People who at this point have not lost their temper or sanity usually resort to
+metaprogramming by writing Makefile generators using a mixture of shell and m4.
+One such an attempt gave something that is the nightmare of wannabe package
+maintainers: it's called \texttt{autotools}.
+
+Note that it is also difficult to write \texttt{Makefiles} to build object
+files in a separate directory. It is not impossible since the language of
+\texttt{make} is Turing-complete, a proof of which is left as an exercise.
+Note that building things in a separate directory is not necessarily a young
+enthusiast's way of giving a different look and feel to his projects -- it may
+be a good way of telling the computer that \texttt{foo.mli} is generated by
+\texttt{ocamlyacc} using \texttt{foo.mly} and can thus be removed.
+%***)
+%(*** Default rules
+\section{Summary of default rules}
+The contents of this table give a summary of the most important default rules.
+To get the most accurate and up-to-date information, launch \ocb with the
+\texttt{-documentation} option.
+\begin{center}
+\small
+\begin{tabular}{|l|l|p{5cm}|}
+ \hline
+ \textbf{Tags} & \textbf{Dependencies} & \textbf{Targets} \\
+ \hline
+ \hline
+ & \%.itarget & \%.otarget \\
+ \hline
+ ocaml & \%.mli \%.mli.depends & \%.cmi \\
+ \hline
+ byte, debug, ocaml & \%.mlpack \%.cmi & \%.d.cmo \\
+ \hline
+ byte, ocaml & \%.mlpack & \%.cmo \%.cmi \\
+ \hline
+ byte, ocaml & \%.mli \%.ml \%.ml.depends \%.cmi & \%.d.cmo \\
+ \hline
+ byte, ocaml & \%.mli \%.ml \%.ml.depends \%.cmi & \%.cmo \\
+ \hline
+ native, ocaml, profile & \%.mlpack \%.cmi & \%.p.cmx \%.p.o \\
+ \hline
+ native, ocaml & \%.mlpack \%.cmi & \%.cmx \%.o \\
+ \hline
+ native, ocaml, profile & \%.ml \%.ml.depends \%.cmi & \%.p.cmx \%.p.o \\
+ \hline
+ native, ocaml & \%.ml \%.ml.depends \%.cmi & \%.cmx \%.o \\
+ \hline
+ debug, ocaml & \%.ml \%.ml.depends \%.cmi & \%.d.cmo \\
+ \hline
+ ocaml & \%.ml \%.ml.depends & \%.cmo \%.cmi \\
+ \hline
+ byte, debug, ocaml, program & \%.d.cmo & \%.d.byte \\
+ \hline
+ byte, ocaml, program & \%.cmo & \%.byte \\
+ \hline
+ native, ocaml, profile, program & \%.p.cmx \%.p.o & \%.p.native \\
+ \hline
+ native, ocaml, program & \%.cmx \%.o & \%.native \\
+ \hline
+ byte, debug, library, ocaml & \%.mllib & \%.d.cma \\
+ \hline
+ byte, library, ocaml & \%.mllib & \%.cma \\
+ \hline
+ byte, debug, library, ocaml & \%.d.cmo & \%.d.cma \\
+ \hline
+ byte, library, ocaml & \%.cmo & \%.cma \\
+ \hline
+ & lib\%(libname).clib & lib\%(libname).a dll\%(libname).so \\
+ \hline
+ & \%(path)/lib\%(libname).clib & \%(path)/lib\%(libname).a \%(path)/dll\%(libname).so \\
+ \hline
+ library, native, ocaml, profile & \%.mllib & \%.p.cmxa \%.p.a \\
+ \hline
+ library, native, ocaml & \%.mllib & \%.cmxa \%.a \\
+ \hline
+ library, native, ocaml, profile & \%.p.cmx \%.p.o & \%.p.cmxa \%.p.a \\
+ \hline
+ library, native, ocaml & \%.cmx \%.o & \%.cmxa \%.a \\
+ \hline
+ & \%.ml & \%.ml.depends \\
+ \hline
+ & \%.mli & \%.mli.depends \\
+ \hline
+ ocaml & \%.mll & \%.ml \\
+ \hline
+ doc, ocaml & \%.mli \%.mli.depends & \%.odoc \\
+ \hline
+ & \%.odocl & \%.docdir/index.html \\
+ \hline
+ ocaml & \%.mly & \%.ml \%.mli \\
+ \hline
+ & \%.c & \%.o \\
+ \hline
+ & \%.ml \%.ml.depends & \%.inferred.mli \\
+ \hline
+\end{tabular}
+\end{center}
+%***)
+\end{document}
--- /dev/null
+(*p
+ \usepackage{xspace}
+ \newcommand{\ocb}{\texttt{ocamlbuild}\xspace}
+ \newcommand{\tags}{\texttt{\_tags}\xspace}
+*)
+let main = let module M = struct
+
+open Ocamlbuild_plugin;;
+open Command;;
+
+let pdflatex = ref (A"pdflatex");;
+let ocamlweb = ref (A"ocamlweb");;
+
+(*c dispatch is the main call of an \ocb plugin *)
+dispatch begin function
+
+ (*c Here one can change the default value of options, they can still be updated by a command line option. *)
+ | Before_options ->
+
+ (*c This will put all warnings to \texttt{ocaml\{c,opt\}} by default. *)
+ Options.ocaml_cflags := ["-w";"A"]
+
+ (*c Here one can change the final value of options. *)
+ | After_options ->
+
+ (*c This avoids the creation of symbolic links to the build directory. *)
+ Options.make_links := false
+
+ (*c This hook is called before the hygiene phase.
+ This phase also serve as collecting all the information about the
+ source tree. *)
+ | Before_hygiene ->
+
+ (*c Here you can dynamically tag some files or directories. *)
+ (*c This is done here by checking the [SOME_COND] variable which is
+ impossible in the \tags file. *)
+ if getenv "SOME_COND" ~default:"false" = "true" then
+
+ (*c By setting foo\_dir as not\_hygienic one say that the foo directory
+ can contains non hygienic files (such as \texttt{.cmi}, \texttt{.cmo}\ldots). *)
+ tag_file "foo_dir" ["not_hygienic"]
+
+ (*c One can also do things after the hygiene step. *)
+ | After_hygiene -> ()
+
+ (*c One can setup rules before the standard ones but that's not recommended. *)
+ | Before_rules -> ()
+
+ (*c Here one can add or override new rules *)
+ | After_rules ->
+
+ (*c Rules can be declared by a call of the form
+ [rule name ~prod ~dep action].
+ The first argument is the name of the rule.
+ [~prod:string] specifies the product of the rule.
+ Note that [~prods:string list] also exists.
+ [~dep] and [~deps] are for dependencies *)
+ rule "LaTeX to PDF conversion rule"
+ ~prod:"%.pdf"
+ ~dep:"%.tex"
+ begin fun env _build ->
+
+ (*c The action is a function that receive two arguments:
+ [env] is a conversion function that substitutes `\%' occurrences
+ according to the targets to which the rule applies.
+ [_build] can be called to build new things (dynamic dependencies). *)
+ let tex = env "%.tex" and _pdf = env "%.pdf" in
+
+ (*c Here we say: ``We compile the file tex form \LaTeX\xspace to PDF''.
+ Note that in fact that is a set of tags, thus the order does not
+ matter. But you got the idea. *)
+ let tags = tags_of_pathname tex++"compile"++"LaTeX"++"pdf" in
+
+ (*c Here we produce the command to run.
+ [S] is for giving a sequence of command pieces.
+ [A] is for atoms.
+ [P] is for pathnames.
+ [Px] is a special pathname that should be the main product of the
+ rule (for display purposes).
+ [T] is for tags.
+
+ The other constructors are given in the documentation of the
+ [Command] module in [Signatures.COMMAND]. *)
+ let cmd = Cmd(S[!pdflatex; T tags; P tex; Sh"< /dev/null"]) in
+ (*c Hoping that \LaTeX will converge in two iterations *)
+ Seq[cmd; cmd]
+ end;
+
+ (*c Here we make an extension of any rule that produces a command
+ containing these tags. *)
+ flag ["compile"; "LaTeX"; "pdf"; "safe"] (A"-halt-on-error");
+
+ (*c Here we give an exception: the file ``manual.tex'' is tagged ``safe''.\ocweol
+ With this tag we add the -halt-on-error flag during the \LaTeX
+ compilation. *)
+ tag_file "manual.tex" ["safe"];
+
+ (*c The generic \LaTeX rule could look at the file searching for some
+ \verb'\input{}' command, but \LaTeX is so complex that it will
+ be hard to make this solution complete.
+ Here we manually inject some dependencies at one particular point. *)
+
+ (*c The [dep] function takes tags and pathnames. This will build pathnames
+ if a command contains these tags. Note that every file [some_file_name] is
+ tagged [file:some_file_name]. *)
+ dep ["compile"; "LaTeX"; "pdf"; "file:manual.tex"]
+ ["ocamlweb.sty"; "myocamlbuild.tex"];
+
+ rule "OCaml to LaTeX conversion rule (using ocamlweb)"
+ ~prod:"%.tex"
+ ~dep:"%.ml"
+ begin fun env _build ->
+ let tex = env "%.tex" and ml = env "%.ml" in
+ let tags = tags_of_pathname ml++"ocamlweb"++"LaTeX" in
+ Cmd(S[!ocamlweb; T tags; P ml; A"-o"; Px tex])
+ end;
+end;;
+
+end in ();;
\ No newline at end of file
--- /dev/null
+00:00:00 0 (0) STARTING -------- |
+00:00:00 1 (0) back.ml.depends O------- |
+00:00:00 8 (0) keyword.mli.depends O-b---i- |
+00:00:00 16 (0) mark.cmi O-B---I- /
+00:00:00 20 (0) stringSet.cmi O-B---I- /
+00:00:00 24 (0) time.mli.depends O-b---i- /
+00:00:00 32 (0) stdlib.ml.depends O-b---i- -
+00:00:00 35 (0) stringSet.cmx ONb---i- -
+00:00:00 37 (0) settings.cmx ONb---i- -
+00:00:00 44 (0) lineCount.cmx ONb---i- \
+00:00:00 45 (0) interface.ml.depends Onb---i- \
+00:00:00 45 (0) interface.ml.depends Onb---i- \
+00:00:01 52 (0) stringMap.ml.depends Onb---i- |
+00:00:01 53 (0) printer.cmx ONb---i- |
+00:00:01 53 (0) printer.cmx ONb---i- |
+00:00:01 57 (0) time.cmx ONb---i- /
+00:00:01 64 (0) partialGrammar.cmi OnB---I- /
+00:00:01 67 (0) parameters.ml.depends Onb---i- /
+00:00:01 72 (0) misc.ml.depends Onb---i- -
+00:00:01 74 (0) keyword.ml.depends Onb---i- -
+00:00:01 77 (0) error.cmi OnB---I- -
+00:00:01 82 (0) parameters.cmx ONb---i- \
+00:00:01 84 (0) action.cmx ONb---i- \
+00:00:01 87 (0) parser.mli.depends Onb---i- \
+00:00:02 96 (0) parserAux.cmx ONb---i- |
+00:00:02 103 (0) tarjan.ml.depends Onb---i- |
+00:00:02 106 (0) unionFind.cmx ONb---i- |
+00:00:02 108 (0) lexer.mll Onb---i- /
+00:00:02 108 (0) lexer.mll Onb---i- /
+00:00:02 110 (0) lexer.cmo OnB---i- -
+00:00:02 111 (0) parser.cmx ONb---i- -
+00:00:02 112 (0) partialGrammar.cmx ONb---i- -
+00:00:02 114 (0) lexer.cmx ONb---i- \
+00:00:02 116 (0) codeBits.mli.depends Onb---i- \
+00:00:03 118 (0) preFront.cmx ONb---i- |
+00:00:03 120 (0) tokenType.cmx ONb---i- |
+00:00:03 123 (0) inliner.cmi OnB---I- |
+00:00:03 126 (0) traverse.cmx ONb---i- /
+00:00:03 126 (0) traverse.cmx ONb---i- /
+00:00:03 129 (0) code.cmi OnB---I- /
+00:00:03 131 (0) lr1.mli.depends Onb---i- /
+00:00:03 134 (0) lookahead.mli.depends Onb---i- -
+00:00:03 137 (0) gMap.ml.depends Onb---i- -
+00:00:03 144 (0) lr1.cmi OnB---I- -
+00:00:03 146 (0) item.ml.depends Onb---i- -
+00:00:03 149 (0) patricia.cmi OnB---I- \
+00:00:03 151 (0) patricia.cmx ONb---i- \
+00:00:03 151 (0) patricia.cmx ONb---i- \
+00:00:04 154 (0) front.cmi OnB---I- |
+00:00:04 164 (0) listMonad.ml.depends Onb---i- |
+00:00:04 167 (0) listMonad.cmx ONb---i- |
+00:00:04 170 (0) infer.cmi OnB---I- /
+00:00:04 171 (0) lexmli.mll Onb---i- /
+00:00:04 172 (0) lexmli.ml.depends Onb---i- /
+00:00:04 174 (0) lexdep.mll Onb---i- -
+00:00:04 177 (0) interface.cmx ONb---i- -
+00:00:04 178 (0) IO.ml.depends Onb---i- \
+00:00:04 181 (0) lexmli.cmx ONb---i- \
+00:00:04 183 (0) IO.cmx ONb---i- \
+00:00:05 187 (0) infer.cmx ONb---i- |
+00:00:05 190 (0) dot.cmi OnB---I- |
+00:00:05 193 (0) compressedBitSet.cmi OnB---I- /
+00:00:05 195 (0) dot.cmx ONb---i- /
+00:00:05 197 (0) grammar.cmx ONb---i- /
+00:00:05 197 (0) grammar.cmx ONb---i- /
+00:00:05 197 (0) grammar.cmx ONb---i- -
+00:00:05 200 (0) infiniteArray.cmi OnB---I- -
+00:00:05 201 (0) item.cmx ONb---i- -
+00:00:05 204 (0) breadth.mli.depends Onb---i- \
+00:00:05 208 (0) invariant.ml.depends Onb---i- \
+00:00:06 212 (0) invariant.cmx ONb---i- |
+00:00:06 213 (0) inliner.cmx ONb---i- |
+00:00:06 214 (0) code.cmx ONb---i- /
+00:00:06 216 (0) back.native ONbP--iL -
+Finished, 216 targets (0 cached) in 00:00:06.
+Finished, 216 targets (0 cached) in 00:00:06.
+Finished, 216 targets (0 cached) in 00:00:06.
+Finished, 216 targets (0 cached) in 00:00:06.
+Finished, 216 targets (0 cached) in 00:00:06.
+Finished, 216 targets (0 cached) in 00:00:06.
+Finished, 216 targets (0 cached) in 00:00:06.
+Finished, 216 targets (0 cached) in 00:00:06.
+Finished, 216 targets (0 cached) in 00:00:06.
--- /dev/null
+ _____ _ ____
+|_ _|__ ___| |_|___ \
+ | |/ _ \/ __| __| __) |
+ | | __/\__ \ |_ / __/
+ |_|\___||___/\__|_____|
+
++ CMDOPTS='-- -help'
++ BUILD='../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display '
++ BUILD1='../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -- -help'
++ BUILD2='../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt -- -help'
++ rm -rf _build
++ cp vivi1.ml vivi.ml
++ ../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -- -help
+ocamldep.opt -modules toto.ml > toto.ml.depends
+ocamldep.opt -modules tata.mli > tata.mli.depends
+ocamldep.opt -modules titi.ml > titi.ml.depends
+ocamldep.opt -modules tutu.mli > tutu.mli.depends
+ocamlc.opt -c -o tata.cmi tata.mli
+ocamlc.opt -c -o titi.cmo titi.ml
+ocamlc.opt -c -o tutu.cmi tutu.mli
+ocamlc.opt -c -o toto.cmo toto.ml
+ocamldep.opt -modules tata.ml > tata.ml.depends
+ocamldep.opt -modules tutu.ml > tutu.ml.depends
+ocamldep.opt -modules tyty.mli > tyty.mli.depends
+ocamldep.opt -pp camlp4o -modules vivi.ml > vivi.ml.depends
+ocamlc.opt -c -o tyty.cmi tyty.mli
+ocamlc.opt -c -pp camlp4o -o vivi.cmo vivi.ml
+ocamlc.opt -c -o tata.cmo tata.ml
+ocamlc.opt -c -o tutu.cmo tutu.ml
+ocamlc.opt tata.cmo titi.cmo vivi.cmo tutu.cmo toto.cmo -o toto.byte
+ocamlopt.opt -c -pp camlp4o -o vivi.cmx vivi.ml
+ocamlopt.opt -c -o tata.cmx tata.ml
+ocamlopt.opt -c -o titi.cmx titi.ml
+ocamlopt.opt -c -o tutu.cmx tutu.ml
+ocamlopt.opt -c -o toto.cmx toto.ml
+ocamlopt.opt tata.cmx titi.cmx vivi.cmx tutu.cmx toto.cmx -o toto.native
+Warning: Using -- only run the last target
+toto.native: _build/toto.native: Hello world!!!
+Tutu.tutu => 1
+Tata.tata => "TATA2"
++ ../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt -- -help
+[cache hit] ocamldep.opt -modules toto.ml > toto.ml.depends
+[cache hit] ocamldep.opt -modules tata.mli > tata.mli.depends
+[cache hit] ocamlc.opt -c -o tata.cmi tata.mli
+[cache hit] ocamldep.opt -modules titi.ml > titi.ml.depends
+[cache hit] ocamlc.opt -c -o titi.cmo titi.ml
+[cache hit] ocamldep.opt -modules tutu.mli > tutu.mli.depends
+[cache hit] ocamlc.opt -c -o tutu.cmi tutu.mli
+[cache hit] ocamlc.opt -c -o toto.cmo toto.ml
+[cache hit] ocamldep.opt -modules tata.ml > tata.ml.depends
+[cache hit] ocamlc.opt -c -o tata.cmo tata.ml
+[cache hit] ocamldep.opt -modules tutu.ml > tutu.ml.depends
+[cache hit] ocamldep.opt -modules tyty.mli > tyty.mli.depends
+[cache hit] ocamlc.opt -c -o tyty.cmi tyty.mli
+[cache hit] ocamldep.opt -pp camlp4o -modules vivi.ml > vivi.ml.depends
+[cache hit] ocamlc.opt -c -pp camlp4o -o vivi.cmo vivi.ml
+[cache hit] ocamlc.opt -c -o tutu.cmo tutu.ml
+[cache hit] ocamlc.opt tata.cmo titi.cmo vivi.cmo tutu.cmo toto.cmo -o toto.byte
+[cache hit] ocamlopt.opt -c -o tata.cmx tata.ml
+[cache hit] ocamlopt.opt -c -o titi.cmx titi.ml
+[cache hit] ocamlopt.opt -c -pp camlp4o -o vivi.cmx vivi.ml
+[cache hit] ocamlopt.opt -c -o tutu.cmx tutu.ml
+[cache hit] ocamlopt.opt -c -o toto.cmx toto.ml
+[cache hit] ocamlopt.opt tata.cmx titi.cmx vivi.cmx tutu.cmx toto.cmx -o toto.native
+Warning: Using -- only run the last target
+toto.native: _build/toto.native: Hello world!!!
+Tutu.tutu => 1
+Tata.tata => "TATA2"
++ cp vivi2.ml vivi.ml
++ ../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -- -help
+ocamldep.opt -pp camlp4o -modules vivi.ml > vivi.ml.depends
+ocamlc.opt -c -pp camlp4o -o vivi.cmo vivi.ml
+ocamlc.opt tata.cmo titi.cmo vivi.cmo tutu.cmo toto.cmo -o toto.byte
+ocamlopt.opt -c -pp camlp4o -o vivi.cmx vivi.ml
+ocamlopt.opt tata.cmx titi.cmx vivi.cmx tutu.cmx toto.cmx -o toto.native
+Warning: Using -- only run the last target
+toto.native: _build/toto.native: Hello world!!!
+Tutu.tutu => 1
+Tata.tata => "TATA2"
++ ../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt -- -help
+[cache hit] ocamldep.opt -modules toto.ml > toto.ml.depends
+[cache hit] ocamldep.opt -modules tata.mli > tata.mli.depends
+[cache hit] ocamlc.opt -c -o tata.cmi tata.mli
+[cache hit] ocamldep.opt -modules titi.ml > titi.ml.depends
+[cache hit] ocamlc.opt -c -o titi.cmo titi.ml
+[cache hit] ocamldep.opt -modules tutu.mli > tutu.mli.depends
+[cache hit] ocamlc.opt -c -o tutu.cmi tutu.mli
+[cache hit] ocamlc.opt -c -o toto.cmo toto.ml
+[cache hit] ocamldep.opt -modules tata.ml > tata.ml.depends
+[cache hit] ocamlc.opt -c -o tata.cmo tata.ml
+[cache hit] ocamldep.opt -modules tutu.ml > tutu.ml.depends
+[cache hit] ocamldep.opt -modules tyty.mli > tyty.mli.depends
+[cache hit] ocamlc.opt -c -o tyty.cmi tyty.mli
+[cache hit] ocamldep.opt -pp camlp4o -modules vivi.ml > vivi.ml.depends
+[cache hit] ocamlc.opt -c -pp camlp4o -o vivi.cmo vivi.ml
+[cache hit] ocamlc.opt -c -o tutu.cmo tutu.ml
+[cache hit] ocamlc.opt tata.cmo titi.cmo vivi.cmo tutu.cmo toto.cmo -o toto.byte
+[cache hit] ocamlopt.opt -c -o tata.cmx tata.ml
+[cache hit] ocamlopt.opt -c -o titi.cmx titi.ml
+[cache hit] ocamlopt.opt -c -pp camlp4o -o vivi.cmx vivi.ml
+[cache hit] ocamlopt.opt -c -o tutu.cmx tutu.ml
+[cache hit] ocamlopt.opt -c -o toto.cmx toto.ml
+[cache hit] ocamlopt.opt tata.cmx titi.cmx vivi.cmx tutu.cmx toto.cmx -o toto.native
+Warning: Using -- only run the last target
+toto.native: _build/toto.native: Hello world!!!
+Tutu.tutu => 1
+Tata.tata => "TATA2"
++ cp vivi3.ml vivi.ml
++ ../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -- -help
+ocamldep.opt -pp camlp4o -modules vivi.ml > vivi.ml.depends
+ocamlc.opt -c -pp camlp4o -o vivi.cmo vivi.ml
+ocamlc.opt -c -o tutu.cmo tutu.ml
+ocamlc.opt tata.cmo titi.cmo vivi.cmo tutu.cmo toto.cmo -o toto.byte
+ocamlopt.opt -c -pp camlp4o -o vivi.cmx vivi.ml
+ocamlopt.opt -c -o tutu.cmx tutu.ml
+ocamlopt.opt -c -o toto.cmx toto.ml
+ocamlopt.opt tata.cmx titi.cmx vivi.cmx tutu.cmx toto.cmx -o toto.native
+Warning: Using -- only run the last target
+toto.native: _build/toto.native: Hello world!!!
+Tutu.tutu => 2
+Tata.tata => "TATA2"
++ ../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt -- -help
+[cache hit] ocamldep.opt -modules toto.ml > toto.ml.depends
+[cache hit] ocamldep.opt -modules tata.mli > tata.mli.depends
+[cache hit] ocamlc.opt -c -o tata.cmi tata.mli
+[cache hit] ocamldep.opt -modules titi.ml > titi.ml.depends
+[cache hit] ocamlc.opt -c -o titi.cmo titi.ml
+[cache hit] ocamldep.opt -modules tutu.mli > tutu.mli.depends
+[cache hit] ocamlc.opt -c -o tutu.cmi tutu.mli
+[cache hit] ocamlc.opt -c -o toto.cmo toto.ml
+[cache hit] ocamldep.opt -modules tata.ml > tata.ml.depends
+[cache hit] ocamlc.opt -c -o tata.cmo tata.ml
+[cache hit] ocamldep.opt -modules tutu.ml > tutu.ml.depends
+[cache hit] ocamldep.opt -modules tyty.mli > tyty.mli.depends
+[cache hit] ocamlc.opt -c -o tyty.cmi tyty.mli
+[cache hit] ocamldep.opt -pp camlp4o -modules vivi.ml > vivi.ml.depends
+[cache hit] ocamlc.opt -c -pp camlp4o -o vivi.cmo vivi.ml
+[cache hit] ocamlc.opt -c -o tutu.cmo tutu.ml
+[cache hit] ocamlc.opt tata.cmo titi.cmo vivi.cmo tutu.cmo toto.cmo -o toto.byte
+[cache hit] ocamlopt.opt -c -o tata.cmx tata.ml
+[cache hit] ocamlopt.opt -c -o titi.cmx titi.ml
+[cache hit] ocamlopt.opt -c -pp camlp4o -o vivi.cmx vivi.ml
+[cache hit] ocamlopt.opt -c -o tutu.cmx tutu.ml
+[cache hit] ocamlopt.opt -c -o toto.cmx toto.ml
+[cache hit] ocamlopt.opt tata.cmx titi.cmx vivi.cmx tutu.cmx toto.cmx -o toto.native
+Warning: Using -- only run the last target
+toto.native: _build/toto.native: Hello world!!!
+Tutu.tutu => 2
+Tata.tata => "TATA2"
+ _____ _ _____
+|_ _|__ ___| |_|___ /
+ | |/ _ \/ __| __| |_ \
+ | | __/\__ \ |_ ___) |
+ |_|\___||___/\__|____/
+
++ CMDOTPS=
++ BUILD='../../_build/ocamlbuild.native a.byte a.native proj.docdir/index.html -no-skip -classic-display '
++ BUILD1='../../_build/ocamlbuild.native a.byte a.native proj.docdir/index.html -no-skip -classic-display '
++ BUILD2='../../_build/ocamlbuild.native a.byte a.native proj.docdir/index.html -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt '
++ rm -rf _build
++ ../../_build/ocamlbuild.native a.byte a.native proj.docdir/index.html -no-skip -classic-display
+ocamldep.opt -modules a.mli > a.mli.depends
+ocamlc.opt -c -o a.cmi a.mli
+ocamldep.opt -modules a.ml > a.ml.depends
+ocamldep.opt -modules b.mli > b.mli.depends
+ocamlc.opt -c -o b.cmi b.mli
+ocamlc.opt -c -o a.cmo a.ml
+ocamldep.opt -modules b.ml > b.ml.depends
+ocamldep.opt -modules c.mli > c.mli.depends
+ocamlc.opt -c -o c.cmi c.mli
+ocamlc.opt -c -o b.cmo b.ml
+ocamldep.opt -modules c.ml > c.ml.depends
+ocamldep.opt -modules d.mli > d.mli.depends
+ocamlc.opt -c -o d.cmi d.mli
+ocamlc.opt -c -o c.cmo c.ml
+ocamldep.opt -modules d.ml > d.ml.depends
+ocamldep.opt -modules e.mli > e.mli.depends
+ocamlc.opt -c -o e.cmi e.mli
+ocamlc.opt -c -o d.cmo d.ml
+ocamldep.opt -modules e.ml > e.ml.depends
+ocamldep.opt -modules f.mli > f.mli.depends
+ocamlc.opt -c -o f.cmi f.mli
+ocamlc.opt -c -o e.cmo e.ml
+ocamldep.opt -modules f.ml > f.ml.depends
+ocamlc.opt -c -o f.cmo f.ml
+ocamlc.opt unix.cma f.cmo e.cmo d.cmo c.cmo b.cmo a.cmo -o a.byte
+ocamlopt.opt -c -o f.cmx f.ml
+ocamlopt.opt -c -o e.cmx e.ml
+ocamlopt.opt -c -o d.cmx d.ml
+ocamlopt.opt -c -o c.cmx c.ml
+ocamlopt.opt -c -o b.cmx b.ml
+ocamlopt.opt -c -o a.cmx a.ml
+ocamlopt.opt unix.cmxa f.cmx e.cmx d.cmx c.cmx b.cmx a.cmx -o a.native
+ocamldoc.opt -dump a.odoc a.mli
+ocamldoc.opt -dump b.odoc b.mli
+ocamldoc.opt -dump c.odoc c.mli
+ocamldoc.opt -dump d.odoc d.mli
+ocamldoc.opt -dump e.odoc e.mli
+ocamldoc.opt -dump f.odoc f.mli
+rm -rf proj.docdir
+mkdir -p proj.docdir
+ocamldoc.opt -load a.odoc -load b.odoc -load c.odoc -load d.odoc -load e.odoc -load f.odoc -html -d proj.docdir
++ ../../_build/ocamlbuild.native a.byte a.native proj.docdir/index.html -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt
+[cache hit] ocamldep.opt -modules a.mli > a.mli.depends
+[cache hit] ocamlc.opt -c -o a.cmi a.mli
+[cache hit] ocamldep.opt -modules a.ml > a.ml.depends
+[cache hit] ocamldep.opt -modules b.mli > b.mli.depends
+[cache hit] ocamlc.opt -c -o b.cmi b.mli
+[cache hit] ocamlc.opt -c -o a.cmo a.ml
+[cache hit] ocamldep.opt -modules b.ml > b.ml.depends
+[cache hit] ocamldep.opt -modules c.mli > c.mli.depends
+[cache hit] ocamlc.opt -c -o c.cmi c.mli
+[cache hit] ocamlc.opt -c -o b.cmo b.ml
+[cache hit] ocamldep.opt -modules c.ml > c.ml.depends
+[cache hit] ocamldep.opt -modules d.mli > d.mli.depends
+[cache hit] ocamlc.opt -c -o d.cmi d.mli
+[cache hit] ocamlc.opt -c -o c.cmo c.ml
+[cache hit] ocamldep.opt -modules d.ml > d.ml.depends
+[cache hit] ocamldep.opt -modules e.mli > e.mli.depends
+[cache hit] ocamlc.opt -c -o e.cmi e.mli
+[cache hit] ocamlc.opt -c -o d.cmo d.ml
+[cache hit] ocamldep.opt -modules e.ml > e.ml.depends
+[cache hit] ocamldep.opt -modules f.mli > f.mli.depends
+[cache hit] ocamlc.opt -c -o f.cmi f.mli
+[cache hit] ocamlc.opt -c -o e.cmo e.ml
+[cache hit] ocamldep.opt -modules f.ml > f.ml.depends
+[cache hit] ocamlc.opt -c -o f.cmo f.ml
+[cache hit] ocamlc.opt unix.cma f.cmo e.cmo d.cmo c.cmo b.cmo a.cmo -o a.byte
+[cache hit] ocamlopt.opt -c -o f.cmx f.ml
+[cache hit] ocamlopt.opt -c -o e.cmx e.ml
+[cache hit] ocamlopt.opt -c -o d.cmx d.ml
+[cache hit] ocamlopt.opt -c -o c.cmx c.ml
+[cache hit] ocamlopt.opt -c -o b.cmx b.ml
+[cache hit] ocamlopt.opt -c -o a.cmx a.ml
+[cache hit] ocamlopt.opt unix.cmxa f.cmx e.cmx d.cmx c.cmx b.cmx a.cmx -o a.native
+[cache hit] ocamldoc.opt -dump a.odoc a.mli
+[cache hit] ocamldoc.opt -dump b.odoc b.mli
+[cache hit] ocamldoc.opt -dump c.odoc c.mli
+[cache hit] ocamldoc.opt -dump d.odoc d.mli
+[cache hit] ocamldoc.opt -dump e.odoc e.mli
+[cache hit] ocamldoc.opt -dump f.odoc f.mli
+[cache hit] rm -rf proj.docdir
+[cache hit] mkdir -p proj.docdir
+[cache hit] ocamldoc.opt -load a.odoc -load b.odoc -load c.odoc -load d.odoc -load e.odoc -load f.odoc -html -d proj.docdir
+ _____ _ _ _
+|_ _|__ ___| |_| || |
+ | |/ _ \/ __| __| || |_
+ | | __/\__ \ |_|__ _|
+ |_|\___||___/\__| |_|
+
++ CMDOTPS=
++ BUILD='../../_build/ocamlbuild.native -I a -I b aa.byte aa.native -no-skip -classic-display '
++ BUILD1='../../_build/ocamlbuild.native -I a -I b aa.byte aa.native -no-skip -classic-display '
++ BUILD2='../../_build/ocamlbuild.native -I a -I b aa.byte aa.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt '
++ rm -rf _build
++ ../../_build/ocamlbuild.native -I a -I b aa.byte aa.native -no-skip -classic-display
+ocamldep.opt -modules a/aa.mli > a/aa.mli.depends
+ocamlc.opt -c -I a -I b -o a/aa.cmi a/aa.mli
+ocamldep.opt -modules a/aa.ml > a/aa.ml.depends
+ocamldep.opt -modules b/bb.ml > b/bb.ml.depends
+ocamlc.opt -c -I b -I a -o b/bb.cmo b/bb.ml
+ocamlc.opt -c -I a -I b -o a/aa.cmo a/aa.ml
+ocamlc.opt str.cma b/bb.cmo a/aa.cmo -o a/aa.byte
+ocamlopt.opt -c -I b -I a -o b/bb.cmx b/bb.ml
+ocamlopt.opt -c -I a -I b -o a/aa.cmx a/aa.ml
+ocamlopt.opt str.cmxa b/bb.cmx a/aa.cmx -o a/aa.native
++ ../../_build/ocamlbuild.native -I a -I b aa.byte aa.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt
+[cache hit] ocamldep.opt -modules a/aa.mli > a/aa.mli.depends
+[cache hit] ocamlc.opt -c -I a -I b -o a/aa.cmi a/aa.mli
+[cache hit] ocamldep.opt -modules a/aa.ml > a/aa.ml.depends
+[cache hit] ocamldep.opt -modules b/bb.ml > b/bb.ml.depends
+[cache hit] ocamlc.opt -c -I b -I a -o b/bb.cmo b/bb.ml
+[cache hit] ocamlc.opt -c -I a -I b -o a/aa.cmo a/aa.ml
+[cache hit] ocamlc.opt str.cma b/bb.cmo a/aa.cmo -o a/aa.byte
+[cache hit] ocamlopt.opt -c -I b -I a -o b/bb.cmx b/bb.ml
+[cache hit] ocamlopt.opt -c -I a -I b -o a/aa.cmx a/aa.ml
+[cache hit] ocamlopt.opt str.cmxa b/bb.cmx a/aa.cmx -o a/aa.native
+ _____ _ ____
+|_ _|__ ___| |_| ___|
+ | |/ _ \/ __| __|___ \
+ | | __/\__ \ |_ ___) |
+ |_|\___||___/\__|____/
+
++ CMDOPTS=
++ BUILD='../../_build/ocamlbuild.native d.byte d.native -no-skip -classic-display '
++ BUILD1='../../_build/ocamlbuild.native d.byte d.native -no-skip -classic-display '
++ BUILD2='../../_build/ocamlbuild.native d.byte d.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt '
++ rm -rf _build
++ ../../_build/ocamlbuild.native d.byte d.native -no-skip -classic-display
+ocamldep.opt -modules d.ml > d.ml.depends
+ocamldep.opt -modules a.mli > a.mli.depends
+ocamlc.opt -c -o a.cmi a.mli
+ocamldep.opt -modules a.ml > a.ml.depends
+ocamldep.opt -modules stack.ml > stack.ml.depends
+ocamlc.opt -c -o stack.cmo stack.ml
+ocamldep.opt -modules b.ml > b.ml.depends
+ocamlc.opt -c -o a.cmo a.ml
+ocamlc.opt -c -o b.cmo b.ml
+ocamlc.opt -pack a.cmo b.cmo -o c.cmo
+ocamlc.opt -c -o d.cmo d.ml
+ocamlc.opt stack.cmo c.cmo d.cmo -o d.byte
+ocamlopt.opt -c -o stack.cmx stack.ml
+ocamlopt.opt -c -for-pack C -o a.cmx a.ml
+ocamlopt.opt -c -for-pack C -o b.cmx b.ml
+touch c.mli ; if ocamlopt.opt -pack a.cmx b.cmx -o c.cmx ; then rm -f c.mli ; else rm -f c.mli ; exit 1; fi
+ocamlopt.opt -c -o d.cmx d.ml
+ocamlopt.opt stack.cmx c.cmx d.cmx -o d.native
++ ../../_build/ocamlbuild.native d.byte d.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt
+[cache hit] ocamldep.opt -modules d.ml > d.ml.depends
+[cache hit] ocamldep.opt -modules a.mli > a.mli.depends
+[cache hit] ocamlc.opt -c -o a.cmi a.mli
+[cache hit] ocamldep.opt -modules a.ml > a.ml.depends
+[cache hit] ocamldep.opt -modules stack.ml > stack.ml.depends
+[cache hit] ocamlc.opt -c -o stack.cmo stack.ml
+[cache hit] ocamlc.opt -c -o a.cmo a.ml
+[cache hit] ocamldep.opt -modules b.ml > b.ml.depends
+[cache hit] ocamlc.opt -c -o b.cmo b.ml
+[cache hit] ocamlc.opt -pack a.cmo b.cmo -o c.cmo
+[cache hit] ocamlc.opt -c -o d.cmo d.ml
+[cache hit] ocamlc.opt stack.cmo c.cmo d.cmo -o d.byte
+[cache hit] ocamlopt.opt -c -o stack.cmx stack.ml
+[cache hit] ocamlopt.opt -c -for-pack C -o a.cmx a.ml
+[cache hit] ocamlopt.opt -c -for-pack C -o b.cmx b.ml
+[cache hit] touch c.mli ; if ocamlopt.opt -pack a.cmx b.cmx -o c.cmx ; then rm -f c.mli ; else rm -f c.mli ; exit 1; fi
+[cache hit] ocamlopt.opt -c -o d.cmx d.ml
+[cache hit] ocamlopt.opt stack.cmx c.cmx d.cmx -o d.native
+ _____ _ __
+|_ _|__ ___| |_ / /_
+ | |/ _ \/ __| __| '_ \
+ | | __/\__ \ |_| (_) |
+ |_|\___||___/\__|\___/
+
++ rm -rf _build
++ CMDOPTS=
++ BUILD='../../_build/ocamlbuild.native -no-skip main.byte -classic-display '
++ BUILD1='../../_build/ocamlbuild.native -no-skip main.byte -classic-display '
++ BUILD2='../../_build/ocamlbuild.native -no-skip main.byte -classic-display -verbose 0 -nothing-should-be-rebuilt '
++ cp b.mli.v1 b.mli
++ cp d.mli.v1 d.mli
++ ../../_build/ocamlbuild.native -no-skip main.byte -classic-display
+ocamldep.opt -modules main.mli > main.mli.depends
+ocamlc.opt -c -o main.cmi main.mli
+ocamldep.opt -modules main.ml > main.ml.depends
+ocamldep.opt -modules a.mli > a.mli.depends
+ocamldep.opt -modules d.mli > d.mli.depends
+ocamlc.opt -c -o a.cmi a.mli
+ocamlc.opt -c -o d.cmi d.mli
+ocamlc.opt -c -o main.cmo main.ml
+ocamldep.opt -modules a.ml > a.ml.depends
+ocamldep.opt -modules b.mli > b.mli.depends
+ocamlc.opt -c -o b.cmi b.mli
+ocamldep.opt -modules d.ml > d.ml.depends
+ocamlc.opt -c -o a.cmo a.ml
+ocamlc.opt -c -o d.cmo d.ml
+ocamldep.opt -modules b.ml > b.ml.depends
+ocamlc.opt -c -o b.cmo b.ml
+ocamlc.opt d.cmo b.cmo a.cmo main.cmo -o main.byte
++ ../../_build/ocamlbuild.native -no-skip main.byte -classic-display -verbose 0 -nothing-should-be-rebuilt
+[cache hit] ocamldep.opt -modules main.mli > main.mli.depends
+[cache hit] ocamlc.opt -c -o main.cmi main.mli
+[cache hit] ocamldep.opt -modules main.ml > main.ml.depends
+[cache hit] ocamldep.opt -modules a.mli > a.mli.depends
+[cache hit] ocamlc.opt -c -o a.cmi a.mli
+[cache hit] ocamldep.opt -modules d.mli > d.mli.depends
+[cache hit] ocamlc.opt -c -o d.cmi d.mli
+[cache hit] ocamlc.opt -c -o main.cmo main.ml
+[cache hit] ocamldep.opt -modules a.ml > a.ml.depends
+[cache hit] ocamldep.opt -modules b.mli > b.mli.depends
+[cache hit] ocamlc.opt -c -o b.cmi b.mli
+[cache hit] ocamlc.opt -c -o a.cmo a.ml
+[cache hit] ocamldep.opt -modules d.ml > d.ml.depends
+[cache hit] ocamlc.opt -c -o d.cmo d.ml
+[cache hit] ocamldep.opt -modules b.ml > b.ml.depends
+[cache hit] ocamlc.opt -c -o b.cmo b.ml
+[cache hit] ocamlc.opt d.cmo b.cmo a.cmo main.cmo -o main.byte
++ cp b.mli.v2 b.mli
++ cp d.mli.v2 d.mli
++ ../../_build/ocamlbuild.native -no-skip main.byte -classic-display
+ocamldep.opt -modules d.mli > d.mli.depends
+ocamlc.opt -c -o d.cmi d.mli
+ocamlc.opt -c -o main.cmo main.ml
+ocamldep.opt -modules b.mli > b.mli.depends
++ ocamldep.opt -modules b.mli > b.mli.depends
+File "b.mli", line 1, characters 0-2:
+Syntax error
+Command exited with code 2.
++ cp b.mli.v1 b.mli
++ ../../_build/ocamlbuild.native -no-skip main.byte -classic-display
+ocamldep.opt -modules b.mli > b.mli.depends
+ocamlc.opt -c -o b.cmi b.mli
+ocamlc.opt -c -o d.cmo d.ml
+ocamlc.opt -c -o b.cmo b.ml
+ocamlc.opt d.cmo b.cmo a.cmo main.cmo -o main.byte
++ ../../_build/ocamlbuild.native -no-skip main.byte -classic-display -verbose 0 -nothing-should-be-rebuilt
+[cache hit] ocamldep.opt -modules main.mli > main.mli.depends
+[cache hit] ocamlc.opt -c -o main.cmi main.mli
+[cache hit] ocamldep.opt -modules main.ml > main.ml.depends
+[cache hit] ocamldep.opt -modules a.mli > a.mli.depends
+[cache hit] ocamlc.opt -c -o a.cmi a.mli
+[cache hit] ocamldep.opt -modules d.mli > d.mli.depends
+[cache hit] ocamlc.opt -c -o d.cmi d.mli
+[cache hit] ocamlc.opt -c -o main.cmo main.ml
+[cache hit] ocamldep.opt -modules a.ml > a.ml.depends
+[cache hit] ocamldep.opt -modules b.mli > b.mli.depends
+[cache hit] ocamlc.opt -c -o b.cmi b.mli
+[cache hit] ocamlc.opt -c -o a.cmo a.ml
+[cache hit] ocamldep.opt -modules d.ml > d.ml.depends
+[cache hit] ocamlc.opt -c -o d.cmo d.ml
+[cache hit] ocamldep.opt -modules b.ml > b.ml.depends
+[cache hit] ocamlc.opt -c -o b.cmo b.ml
+[cache hit] ocamlc.opt d.cmo b.cmo a.cmo main.cmo -o main.byte
++ echo PASS
+PASS
+ _____ _ _____
+|_ _|__ ___| ||___ |
+ | |/ _ \/ __| __| / /
+ | | __/\__ \ |_ / /
+ |_|\___||___/\__/_/
+
++ CMDOPTS=
++ BUILD='../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display '
++ BUILD1='../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display '
++ BUILD2='../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt '
++ rm -rf _build
++ cp bb1.ml bb.ml
++ ../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display
+ocamlopt.opt -I /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild unix.cmxa /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild/ocamlbuildlib.cmxa myocamlbuild.ml /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild/ocamlbuild.cmx -o myocamlbuild
+ocamldep.opt -modules bb.mli > bb.mli.depends
+ocamlc.opt -c -o bb.cmi bb.mli
+ocamldep.opt -modules bb.ml > bb.ml.depends
+ocamldep.opt -modules cc.ml > cc.ml.depends
+ocamldep.opt -modules aa.ml > aa.ml.depends
+ocamldep.opt -modules c2.mli > c2.mli.depends
+ocamlc.opt -c -o aa.cmo aa.ml
+ocamlc.opt -c -o c2.cmi c2.mli
+ocamlc.opt -c -o bb.cmo bb.ml
+ocamlc.opt -c -o cc.cmo cc.ml
+ocamlc.opt -a bb.cmo cc.cmo -o bbcc.cma
+ocamldep.opt -modules main.ml > main.ml.depends
+ocamldep.opt -modules c3.ml > c3.ml.depends
+ocamlc.opt -c -o c3.cmo c3.ml
+ocamlc.opt -c -o main.cmo main.ml
+ocamldep.opt -modules cool_plugin.ml > cool_plugin.ml.depends
+ocamlc.opt -c -o cool_plugin.cmo cool_plugin.ml
+ocamldep.opt -modules c2.ml > c2.ml.depends
+ocamlc.opt -c -o c2.cmo c2.ml
+ocamlc.opt aa.cmo c2.cmo bbcc.cma c3.cmo main.cmo cool_plugin.cmo -o main.byte
+ocamlopt.opt -c -o bb.cmx bb.ml
+ocamlopt.opt -c -o aa.cmx aa.ml
+ocamlopt.opt -c -o c2.cmx c2.ml
+ocamlopt.opt -c -o cc.cmx cc.ml
+ocamlopt.opt -a bb.cmx cc.cmx -o bbcc.cmxa
+ocamlopt.opt -c -o c3.cmx c3.ml
+ocamlopt.opt -c -o main.cmx main.ml
+ocamlopt.opt aa.cmx c2.cmx bbcc.cmxa c3.cmx main.cmx -o main.native
++ ../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt
+[cache hit] ocamldep.opt -modules bb.mli > bb.mli.depends
+[cache hit] ocamlc.opt -c -o bb.cmi bb.mli
+[cache hit] ocamldep.opt -modules bb.ml > bb.ml.depends
+[cache hit] ocamlc.opt -c -o bb.cmo bb.ml
+[cache hit] ocamldep.opt -modules cc.ml > cc.ml.depends
+[cache hit] ocamldep.opt -modules aa.ml > aa.ml.depends
+[cache hit] ocamlc.opt -c -o aa.cmo aa.ml
+[cache hit] ocamldep.opt -modules c2.mli > c2.mli.depends
+[cache hit] ocamlc.opt -c -o c2.cmi c2.mli
+[cache hit] ocamlc.opt -c -o cc.cmo cc.ml
+[cache hit] ocamlc.opt -a bb.cmo cc.cmo -o bbcc.cma
+[cache hit] ocamldep.opt -modules main.ml > main.ml.depends
+[cache hit] ocamldep.opt -modules c3.ml > c3.ml.depends
+[cache hit] ocamlc.opt -c -o c3.cmo c3.ml
+[cache hit] ocamlc.opt -c -o main.cmo main.ml
+[cache hit] ocamldep.opt -modules cool_plugin.ml > cool_plugin.ml.depends
+[cache hit] ocamlc.opt -c -o cool_plugin.cmo cool_plugin.ml
+[cache hit] ocamldep.opt -modules c2.ml > c2.ml.depends
+[cache hit] ocamlc.opt -c -o c2.cmo c2.ml
+[cache hit] ocamlc.opt aa.cmo c2.cmo bbcc.cma c3.cmo main.cmo cool_plugin.cmo -o main.byte
+[cache hit] ocamlopt.opt -c -o bb.cmx bb.ml
+[cache hit] ocamlopt.opt -c -o aa.cmx aa.ml
+[cache hit] ocamlopt.opt -c -o c2.cmx c2.ml
+[cache hit] ocamlopt.opt -c -o cc.cmx cc.ml
+[cache hit] ocamlopt.opt -a bb.cmx cc.cmx -o bbcc.cmxa
+[cache hit] ocamlopt.opt -c -o c3.cmx c3.ml
+[cache hit] ocamlopt.opt -c -o main.cmx main.ml
+[cache hit] ocamlopt.opt aa.cmx c2.cmx bbcc.cmxa c3.cmx main.cmx -o main.native
++ cp bb2.ml bb.ml
++ ../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display -verbose 0
+[cache hit] ocamldep.opt -modules bb.mli > bb.mli.depends
+[cache hit] ocamlc.opt -c -o bb.cmi bb.mli
+ocamldep.opt -modules bb.ml > bb.ml.depends
+[cache hit] ocamldep.opt -modules cc.ml > cc.ml.depends
+[cache hit] ocamldep.opt -modules aa.ml > aa.ml.depends
+[cache hit] ocamlc.opt -c -o aa.cmo aa.ml
+[cache hit] ocamldep.opt -modules c2.mli > c2.mli.depends
+[cache hit] ocamlc.opt -c -o c2.cmi c2.mli
+[cache hit] ocamlc.opt -c -o cc.cmo cc.ml
+ocamlc.opt -c -o bb.cmo bb.ml
+ocamlc.opt -a bb.cmo cc.cmo -o bbcc.cma
+[cache hit] ocamldep.opt -modules main.ml > main.ml.depends
+[cache hit] ocamldep.opt -modules c3.ml > c3.ml.depends
+[cache hit] ocamlc.opt -c -o c3.cmo c3.ml
+[cache hit] ocamlc.opt -c -o main.cmo main.ml
+[cache hit] ocamldep.opt -modules cool_plugin.ml > cool_plugin.ml.depends
+[cache hit] ocamlc.opt -c -o cool_plugin.cmo cool_plugin.ml
+[cache hit] ocamldep.opt -modules c2.ml > c2.ml.depends
+[cache hit] ocamlc.opt -c -o c2.cmo c2.ml
+ocamlc.opt aa.cmo c2.cmo bbcc.cma c3.cmo main.cmo cool_plugin.cmo -o main.byte
+[cache hit] ocamlopt.opt -c -o aa.cmx aa.ml
+ocamlopt.opt -c -o bb.cmx bb.ml
+[cache hit] ocamlopt.opt -c -o c2.cmx c2.ml
+ocamlopt.opt -c -o cc.cmx cc.ml
+ocamlopt.opt -a bb.cmx cc.cmx -o bbcc.cmxa
+ocamlopt.opt -c -o c3.cmx c3.ml
+ocamlopt.opt -c -o main.cmx main.ml
+ocamlopt.opt aa.cmx c2.cmx bbcc.cmxa c3.cmx main.cmx -o main.native
++ ../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt
+[cache hit] ocamldep.opt -modules bb.mli > bb.mli.depends
+[cache hit] ocamlc.opt -c -o bb.cmi bb.mli
+[cache hit] ocamldep.opt -modules bb.ml > bb.ml.depends
+[cache hit] ocamlc.opt -c -o bb.cmo bb.ml
+[cache hit] ocamldep.opt -modules cc.ml > cc.ml.depends
+[cache hit] ocamldep.opt -modules aa.ml > aa.ml.depends
+[cache hit] ocamlc.opt -c -o aa.cmo aa.ml
+[cache hit] ocamldep.opt -modules c2.mli > c2.mli.depends
+[cache hit] ocamlc.opt -c -o c2.cmi c2.mli
+[cache hit] ocamlc.opt -c -o cc.cmo cc.ml
+[cache hit] ocamlc.opt -a bb.cmo cc.cmo -o bbcc.cma
+[cache hit] ocamldep.opt -modules main.ml > main.ml.depends
+[cache hit] ocamldep.opt -modules c3.ml > c3.ml.depends
+[cache hit] ocamlc.opt -c -o c3.cmo c3.ml
+[cache hit] ocamlc.opt -c -o main.cmo main.ml
+[cache hit] ocamldep.opt -modules cool_plugin.ml > cool_plugin.ml.depends
+[cache hit] ocamlc.opt -c -o cool_plugin.cmo cool_plugin.ml
+[cache hit] ocamldep.opt -modules c2.ml > c2.ml.depends
+[cache hit] ocamlc.opt -c -o c2.cmo c2.ml
+[cache hit] ocamlc.opt aa.cmo c2.cmo bbcc.cma c3.cmo main.cmo cool_plugin.cmo -o main.byte
+[cache hit] ocamlopt.opt -c -o bb.cmx bb.ml
+[cache hit] ocamlopt.opt -c -o aa.cmx aa.ml
+[cache hit] ocamlopt.opt -c -o c2.cmx c2.ml
+[cache hit] ocamlopt.opt -c -o cc.cmx cc.ml
+[cache hit] ocamlopt.opt -a bb.cmx cc.cmx -o bbcc.cmxa
+[cache hit] ocamlopt.opt -c -o c3.cmx c3.ml
+[cache hit] ocamlopt.opt -c -o main.cmx main.ml
+[cache hit] ocamlopt.opt aa.cmx c2.cmx bbcc.cmxa c3.cmx main.cmx -o main.native
++ cp bb3.ml bb.ml
++ ../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display -verbose 0
+[cache hit] ocamldep.opt -modules bb.mli > bb.mli.depends
+[cache hit] ocamlc.opt -c -o bb.cmi bb.mli
+ocamldep.opt -modules bb.ml > bb.ml.depends
+[cache hit] ocamldep.opt -modules cc.ml > cc.ml.depends
+[cache hit] ocamldep.opt -modules aa.ml > aa.ml.depends
+[cache hit] ocamlc.opt -c -o aa.cmo aa.ml
+[cache hit] ocamldep.opt -modules c2.mli > c2.mli.depends
+[cache hit] ocamlc.opt -c -o c2.cmi c2.mli
+[cache hit] ocamlc.opt -c -o cc.cmo cc.ml
+ocamlc.opt -c -o bb.cmo bb.ml
+ocamlc.opt -a bb.cmo cc.cmo -o bbcc.cma
+[cache hit] ocamldep.opt -modules main.ml > main.ml.depends
+[cache hit] ocamldep.opt -modules c3.ml > c3.ml.depends
+[cache hit] ocamlc.opt -c -o c3.cmo c3.ml
+[cache hit] ocamlc.opt -c -o main.cmo main.ml
+[cache hit] ocamldep.opt -modules cool_plugin.ml > cool_plugin.ml.depends
+[cache hit] ocamlc.opt -c -o cool_plugin.cmo cool_plugin.ml
+[cache hit] ocamldep.opt -modules c2.ml > c2.ml.depends
+[cache hit] ocamlc.opt -c -o c2.cmo c2.ml
+ocamlc.opt aa.cmo c2.cmo bbcc.cma c3.cmo main.cmo cool_plugin.cmo -o main.byte
+[cache hit] ocamlopt.opt -c -o aa.cmx aa.ml
+ocamlopt.opt -c -o bb.cmx bb.ml
+[cache hit] ocamlopt.opt -c -o c2.cmx c2.ml
+[cache hit] ocamlopt.opt -c -o cc.cmx cc.ml
+ocamlopt.opt -a bb.cmx cc.cmx -o bbcc.cmxa
+[cache hit] ocamlopt.opt -c -o c3.cmx c3.ml
+[cache hit] ocamlopt.opt -c -o main.cmx main.ml
+ocamlopt.opt aa.cmx c2.cmx bbcc.cmxa c3.cmx main.cmx -o main.native
++ ../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt
+[cache hit] ocamldep.opt -modules bb.mli > bb.mli.depends
+[cache hit] ocamlc.opt -c -o bb.cmi bb.mli
+[cache hit] ocamldep.opt -modules bb.ml > bb.ml.depends
+[cache hit] ocamlc.opt -c -o bb.cmo bb.ml
+[cache hit] ocamldep.opt -modules cc.ml > cc.ml.depends
+[cache hit] ocamldep.opt -modules aa.ml > aa.ml.depends
+[cache hit] ocamlc.opt -c -o aa.cmo aa.ml
+[cache hit] ocamldep.opt -modules c2.mli > c2.mli.depends
+[cache hit] ocamlc.opt -c -o c2.cmi c2.mli
+[cache hit] ocamlc.opt -c -o cc.cmo cc.ml
+[cache hit] ocamlc.opt -a bb.cmo cc.cmo -o bbcc.cma
+[cache hit] ocamldep.opt -modules main.ml > main.ml.depends
+[cache hit] ocamldep.opt -modules c3.ml > c3.ml.depends
+[cache hit] ocamlc.opt -c -o c3.cmo c3.ml
+[cache hit] ocamlc.opt -c -o main.cmo main.ml
+[cache hit] ocamldep.opt -modules cool_plugin.ml > cool_plugin.ml.depends
+[cache hit] ocamlc.opt -c -o cool_plugin.cmo cool_plugin.ml
+[cache hit] ocamldep.opt -modules c2.ml > c2.ml.depends
+[cache hit] ocamlc.opt -c -o c2.cmo c2.ml
+[cache hit] ocamlc.opt aa.cmo c2.cmo bbcc.cma c3.cmo main.cmo cool_plugin.cmo -o main.byte
+[cache hit] ocamlopt.opt -c -o bb.cmx bb.ml
+[cache hit] ocamlopt.opt -c -o aa.cmx aa.ml
+[cache hit] ocamlopt.opt -c -o c2.cmx c2.ml
+[cache hit] ocamlopt.opt -c -o cc.cmx cc.ml
+[cache hit] ocamlopt.opt -a bb.cmx cc.cmx -o bbcc.cmxa
+[cache hit] ocamlopt.opt -c -o c3.cmx c3.ml
+[cache hit] ocamlopt.opt -c -o main.cmx main.ml
+[cache hit] ocamlopt.opt aa.cmx c2.cmx bbcc.cmxa c3.cmx main.cmx -o main.native
+ _____ _ ___
+|_ _|__ ___| |_( _ )
+ | |/ _ \/ __| __/ _ \
+ | | __/\__ \ || (_) |
+ |_|\___||___/\__\___/
+
++ CMDOPTS=
++ BUILD='../../_build/ocamlbuild.native a.byte a.native a a.opt bin/a bin/a.opt -no-skip -classic-display '
++ BUILD1='../../_build/ocamlbuild.native a.byte a.native a a.opt bin/a bin/a.opt -no-skip -classic-display '
++ BUILD2='../../_build/ocamlbuild.native a.byte a.native a a.opt bin/a bin/a.opt -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt '
++ rm -rf _build
++ ../../_build/ocamlbuild.native a.byte a.native a a.opt bin/a bin/a.opt -no-skip -classic-display
+ocamlopt.opt -I /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild unix.cmxa /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild/ocamlbuildlib.cmxa myocamlbuild.ml /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild/ocamlbuild.cmx -o myocamlbuild
+ocamldep.opt -modules a.ml > a.ml.depends
+ocamldep.opt -modules myconfig.ml > myconfig.ml.depends
+ocamlc.opt -c -o myconfig.cmo myconfig.ml
+ocamlc.opt -c -o a.cmo a.ml
+ocamlc.opt myconfig.cmo a.cmo -o a.byte
+ocamlopt.opt -c -o myconfig.cmx myconfig.ml
+ocamlopt.opt -c -o a.cmx a.ml
+ocamlopt.opt myconfig.cmx a.cmx -o a.native
+cp -p a.byte a
+cp -p a.native a.opt
+cp -p a.byte bin/a.byte
+cp -p bin/a.byte bin/a
+cp -p a.native bin/a.native
+cp -p bin/a.native bin/a.opt
++ ../../_build/ocamlbuild.native a.byte a.native a a.opt bin/a bin/a.opt -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt
+[cache hit] ocamldep.opt -modules a.ml > a.ml.depends
+[cache hit] ocamldep.opt -modules myconfig.ml > myconfig.ml.depends
+[cache hit] ocamlc.opt -c -o myconfig.cmo myconfig.ml
+[cache hit] ocamlc.opt -c -o a.cmo a.ml
+[cache hit] ocamlc.opt myconfig.cmo a.cmo -o a.byte
+[cache hit] ocamlopt.opt -c -o myconfig.cmx myconfig.ml
+[cache hit] ocamlopt.opt -c -o a.cmx a.ml
+[cache hit] ocamlopt.opt myconfig.cmx a.cmx -o a.native
+[cache hit] cp -p a.byte a
+[cache hit] cp -p a.native a.opt
+[cache hit] cp -p a.byte bin/a.byte
+[cache hit] cp -p bin/a.byte bin/a
+[cache hit] cp -p a.native bin/a.native
+[cache hit] cp -p bin/a.native bin/a.opt
+ _____ _ ___
+|_ _|__ ___| |_ / _ \
+ | |/ _ \/ __| __| (_) |
+ | | __/\__ \ |_ \__, |
+ |_|\___||___/\__| /_/
+
+++ dirname ./test9/test.sh
++ cd ./test9/../..
++ ./_build/ocamlbuild.native -quiet -build-dir _buildtest -no-links test/test9/testglob.native
++ ./_buildtest/test/test9/testglob.native
+Globexp for "\"hello\"" OK
+Globexp for "<hello>" OK
+Globexp for "<hel*lo>" OK
+Globexp for "<a> and <b> or <c>" OK
+Globexp for "<a> titi" OK
+Glob.eval "<[a]>" "a" = true OK
+Glob.eval "<[a]>" "b" = false OK
+Glob.eval "<[a]>" "a" = true OK
+Glob.eval "<[a]>" "b" = false OK
+Glob.eval "<[a]>" "a" = true OK
+Glob.eval "<[a]>" "b" = false OK
+Glob.eval "<[a-z]>" "a" = true OK
+Glob.eval "<[a-z]>" "e" = true OK
+Glob.eval "<[a-z]>" "k" = true OK
+Glob.eval "<[a-z]>" "z" = true OK
+Glob.eval "<[a-z]>" "0" = false OK
+Glob.eval "<[a-z]>" "A" = false OK
+Glob.eval "<[a-z]>" "~" = false OK
+Glob.eval "<[a-z]>" "a" = true OK
+Glob.eval "<[a-z]>" "e" = true OK
+Glob.eval "<[a-z]>" "k" = true OK
+Glob.eval "<[a-z]>" "z" = true OK
+Glob.eval "<[a-z]>" "0" = false OK
+Glob.eval "<[a-z]>" "A" = false OK
+Glob.eval "<[a-z]>" "~" = false OK
+Glob.eval "<[a-z]>" "a" = true OK
+Glob.eval "<[a-z]>" "e" = true OK
+Glob.eval "<[a-z]>" "k" = true OK
+Glob.eval "<[a-z]>" "z" = true OK
+Glob.eval "<[a-z]>" "0" = false OK
+Glob.eval "<[a-z]>" "A" = false OK
+Glob.eval "<[a-z]>" "~" = false OK
+Glob.eval "<[a-z][0-9]>" "a0" = true OK
+Glob.eval "<[a-z][0-9]>" "b9" = true OK
+Glob.eval "<[a-z][0-9]>" "a00" = false OK
+Glob.eval "<[a-z][0-9]>" "a0a" = false OK
+Glob.eval "<[a-z][0-9]>" "b0a" = false OK
+Glob.eval "<[a-z][0-9]>" "isduis" = false OK
+Glob.eval "<[a-z][0-9]>" "" = false OK
+Glob.eval "<[a-z][0-9]>" "a0" = true OK
+Glob.eval "<[a-z][0-9]>" "b9" = true OK
+Glob.eval "<[a-z][0-9]>" "a00" = false OK
+Glob.eval "<[a-z][0-9]>" "a0a" = false OK
+Glob.eval "<[a-z][0-9]>" "b0a" = false OK
+Glob.eval "<[a-z][0-9]>" "isduis" = false OK
+Glob.eval "<[a-z][0-9]>" "" = false OK
+Glob.eval "<[a-z][0-9]>" "a0" = true OK
+Glob.eval "<[a-z][0-9]>" "b9" = true OK
+Glob.eval "<[a-z][0-9]>" "a00" = false OK
+Glob.eval "<[a-z][0-9]>" "a0a" = false OK
+Glob.eval "<[a-z][0-9]>" "b0a" = false OK
+Glob.eval "<[a-z][0-9]>" "isduis" = false OK
+Glob.eval "<[a-z][0-9]>" "" = false OK
+Glob.eval "<hello>" "hello" = true OK
+Glob.eval "<hello>" "helli" = false OK
+Glob.eval "<hello>" "hello" = true OK
+Glob.eval "<hello>" "helli" = false OK
+Glob.eval "<hello>" "hello" = true OK
+Glob.eval "<hello>" "helli" = false OK
+Glob.eval "\"hello\"" "hello" = true OK
+Glob.eval "\"hello\"" "heidi" = false OK
+Glob.eval "\"hello\"" "hello" = true OK
+Glob.eval "\"hello\"" "heidi" = false OK
+Glob.eval "\"hello\"" "hello" = true OK
+Glob.eval "\"hello\"" "heidi" = false OK
+Glob.eval "<*>" "" = true OK
+Glob.eval "<*>" "a" = true OK
+Glob.eval "<*>" "ax" = true OK
+Glob.eval "<*>" "" = true OK
+Glob.eval "<*>" "a" = true OK
+Glob.eval "<*>" "ax" = true OK
+Glob.eval "<*>" "" = true OK
+Glob.eval "<*>" "a" = true OK
+Glob.eval "<*>" "ax" = true OK
+Glob.eval "<a*b>" "ab" = true OK
+Glob.eval "<a*b>" "acb" = true OK
+Glob.eval "<a*b>" "axxxxxb" = true OK
+Glob.eval "<a*b>" "ababbababb" = true OK
+Glob.eval "<a*b>" "abx" = false OK
+Glob.eval "<a*b>" "xxxxxab" = false OK
+Glob.eval "<a*b>" "xab" = false OK
+Glob.eval "<a*b>" "ab" = true OK
+Glob.eval "<a*b>" "acb" = true OK
+Glob.eval "<a*b>" "axxxxxb" = true OK
+Glob.eval "<a*b>" "ababbababb" = true OK
+Glob.eval "<a*b>" "abx" = false OK
+Glob.eval "<a*b>" "xxxxxab" = false OK
+Glob.eval "<a*b>" "xab" = false OK
+Glob.eval "<a*b>" "ab" = true OK
+Glob.eval "<a*b>" "acb" = true OK
+Glob.eval "<a*b>" "axxxxxb" = true OK
+Glob.eval "<a*b>" "ababbababb" = true OK
+Glob.eval "<a*b>" "abx" = false OK
+Glob.eval "<a*b>" "xxxxxab" = false OK
+Glob.eval "<a*b>" "xab" = false OK
+Glob.eval "<*.ml>" "hello.ml" = true OK
+Glob.eval "<*.ml>" ".ml" = true OK
+Glob.eval "<*.ml>" "ml" = false OK
+Glob.eval "<*.ml>" "" = false OK
+Glob.eval "<*.ml>" "toto.mli" = false OK
+Glob.eval "<*.ml>" "hello.ml" = true OK
+Glob.eval "<*.ml>" ".ml" = true OK
+Glob.eval "<*.ml>" "ml" = false OK
+Glob.eval "<*.ml>" "" = false OK
+Glob.eval "<*.ml>" "toto.mli" = false OK
+Glob.eval "<*.ml>" "hello.ml" = true OK
+Glob.eval "<*.ml>" ".ml" = true OK
+Glob.eval "<*.ml>" "ml" = false OK
+Glob.eval "<*.ml>" "" = false OK
+Glob.eval "<*.ml>" "toto.mli" = false OK
+Glob.eval "<a>" "a" = true OK
+Glob.eval "<a>" "" = false OK
+Glob.eval "<a>" "aa" = false OK
+Glob.eval "<a>" "ba" = false OK
+Glob.eval "<a>" "ab" = false OK
+Glob.eval "<a>" "abaa" = false OK
+Glob.eval "<a>" "a" = true OK
+Glob.eval "<a>" "" = false OK
+Glob.eval "<a>" "aa" = false OK
+Glob.eval "<a>" "ba" = false OK
+Glob.eval "<a>" "ab" = false OK
+Glob.eval "<a>" "abaa" = false OK
+Glob.eval "<a>" "a" = true OK
+Glob.eval "<a>" "" = false OK
+Glob.eval "<a>" "aa" = false OK
+Glob.eval "<a>" "ba" = false OK
+Glob.eval "<a>" "ab" = false OK
+Glob.eval "<a>" "abaa" = false OK
+Glob.eval "<ab>" "ab" = true OK
+Glob.eval "<ab>" "" = false OK
+Glob.eval "<ab>" "abab" = false OK
+Glob.eval "<ab>" "aba" = false OK
+Glob.eval "<ab>" "abx" = false OK
+Glob.eval "<ab>" "ab" = true OK
+Glob.eval "<ab>" "" = false OK
+Glob.eval "<ab>" "abab" = false OK
+Glob.eval "<ab>" "aba" = false OK
+Glob.eval "<ab>" "abx" = false OK
+Glob.eval "<ab>" "ab" = true OK
+Glob.eval "<ab>" "" = false OK
+Glob.eval "<ab>" "abab" = false OK
+Glob.eval "<ab>" "aba" = false OK
+Glob.eval "<ab>" "abx" = false OK
+Glob.eval "<ab?c>" "abac" = true OK
+Glob.eval "<ab?c>" "abxc" = true OK
+Glob.eval "<ab?c>" "abab" = false OK
+Glob.eval "<ab?c>" "ababab" = false OK
+Glob.eval "<ab?c>" "ababa" = false OK
+Glob.eval "<ab?c>" "abac" = true OK
+Glob.eval "<ab?c>" "abxc" = true OK
+Glob.eval "<ab?c>" "abab" = false OK
+Glob.eval "<ab?c>" "ababab" = false OK
+Glob.eval "<ab?c>" "ababa" = false OK
+Glob.eval "<ab?c>" "abac" = true OK
+Glob.eval "<ab?c>" "abxc" = true OK
+Glob.eval "<ab?c>" "abab" = false OK
+Glob.eval "<ab?c>" "ababab" = false OK
+Glob.eval "<ab?c>" "ababa" = false OK
+Glob.eval "<*ab?cd*>" "123abecd345" = true OK
+Glob.eval "<*ab?cd*>" "abccd" = true OK
+Glob.eval "<*ab?cd*>" "abccd345" = true OK
+Glob.eval "<*ab?cd*>" "ababcababccdab" = true OK
+Glob.eval "<*ab?cd*>" "abcd" = false OK
+Glob.eval "<*ab?cd*>" "aaaaabcdababcd" = false OK
+Glob.eval "<*ab?cd*>" "123abecd345" = true OK
+Glob.eval "<*ab?cd*>" "abccd" = true OK
+Glob.eval "<*ab?cd*>" "abccd345" = true OK
+Glob.eval "<*ab?cd*>" "ababcababccdab" = true OK
+Glob.eval "<*ab?cd*>" "abcd" = false OK
+Glob.eval "<*ab?cd*>" "aaaaabcdababcd" = false OK
+Glob.eval "<*ab?cd*>" "123abecd345" = true OK
+Glob.eval "<*ab?cd*>" "abccd" = true OK
+Glob.eval "<*ab?cd*>" "abccd345" = true OK
+Glob.eval "<*ab?cd*>" "ababcababccdab" = true OK
+Glob.eval "<*ab?cd*>" "abcd" = false OK
+Glob.eval "<*ab?cd*>" "aaaaabcdababcd" = false OK
+Glob.eval "<*this*is*a*test*>" "this is a test" = true OK
+Glob.eval "<*this*is*a*test*>" "You know this is a test really" = true OK
+Glob.eval "<*this*is*a*test*>" "thisisatest" = true OK
+Glob.eval "<*this*is*a*test*>" "thisatest" = false OK
+Glob.eval "<*this*is*a*test*>" "this is a test" = true OK
+Glob.eval "<*this*is*a*test*>" "You know this is a test really" = true OK
+Glob.eval "<*this*is*a*test*>" "thisisatest" = true OK
+Glob.eval "<*this*is*a*test*>" "thisatest" = false OK
+Glob.eval "<*this*is*a*test*>" "this is a test" = true OK
+Glob.eval "<*this*is*a*test*>" "You know this is a test really" = true OK
+Glob.eval "<*this*is*a*test*>" "thisisatest" = true OK
+Glob.eval "<*this*is*a*test*>" "thisatest" = false OK
+Glob.eval "<b*>" "bxx" = true OK
+Glob.eval "<b*>" "bx" = true OK
+Glob.eval "<b*>" "aaab" = false OK
+Glob.eval "<b*>" "" = false OK
+Glob.eval "<b*>" "bxx" = true OK
+Glob.eval "<b*>" "bx" = true OK
+Glob.eval "<b*>" "aaab" = false OK
+Glob.eval "<b*>" "" = false OK
+Glob.eval "<b*>" "bxx" = true OK
+Glob.eval "<b*>" "bx" = true OK
+Glob.eval "<b*>" "aaab" = false OK
+Glob.eval "<b*>" "" = false OK
+Glob.eval "<*>" "" = true OK
+Glob.eval "<*>" "a" = true OK
+Glob.eval "<*>" "aaa" = true OK
+Glob.eval "<*>" "aaaaa" = true OK
+Glob.eval "<*>" "" = true OK
+Glob.eval "<*>" "a" = true OK
+Glob.eval "<*>" "aaa" = true OK
+Glob.eval "<*>" "aaaaa" = true OK
+Glob.eval "<*>" "" = true OK
+Glob.eval "<*>" "a" = true OK
+Glob.eval "<*>" "aaa" = true OK
+Glob.eval "<*>" "aaaaa" = true OK
+Glob.eval "<?>" "a" = true OK
+Glob.eval "<?>" "" = false OK
+Glob.eval "<?>" "aaa" = false OK
+Glob.eval "<?>" "aaaaa" = false OK
+Glob.eval "<?>" "a" = true OK
+Glob.eval "<?>" "" = false OK
+Glob.eval "<?>" "aaa" = false OK
+Glob.eval "<?>" "aaaaa" = false OK
+Glob.eval "<?>" "a" = true OK
+Glob.eval "<?>" "" = false OK
+Glob.eval "<?>" "aaa" = false OK
+Glob.eval "<?>" "aaaaa" = false OK
+Glob.eval "<{a,b}>" "a" = true OK
+Glob.eval "<{a,b}>" "b" = true OK
+Glob.eval "<{a,b}>" "" = false OK
+Glob.eval "<{a,b}>" "aa" = false OK
+Glob.eval "<{a,b}>" "ab" = false OK
+Glob.eval "<{a,b}>" "ba" = false OK
+Glob.eval "<{a,b}>" "bb" = false OK
+Glob.eval "<{a,b}>" "c" = false OK
+Glob.eval "<{a,b}>" "a" = true OK
+Glob.eval "<{a,b}>" "b" = true OK
+Glob.eval "<{a,b}>" "" = false OK
+Glob.eval "<{a,b}>" "aa" = false OK
+Glob.eval "<{a,b}>" "ab" = false OK
+Glob.eval "<{a,b}>" "ba" = false OK
+Glob.eval "<{a,b}>" "bb" = false OK
+Glob.eval "<{a,b}>" "c" = false OK
+Glob.eval "<{a,b}>" "a" = true OK
+Glob.eval "<{a,b}>" "b" = true OK
+Glob.eval "<{a,b}>" "" = false OK
+Glob.eval "<{a,b}>" "aa" = false OK
+Glob.eval "<{a,b}>" "ab" = false OK
+Glob.eval "<{a,b}>" "ba" = false OK
+Glob.eval "<{a,b}>" "bb" = false OK
+Glob.eval "<{a,b}>" "c" = false OK
+Glob.eval "<toto.{ml,mli}>" "toto.ml" = true OK
+Glob.eval "<toto.{ml,mli}>" "toto.mli" = true OK
+Glob.eval "<toto.{ml,mli}>" "toto." = false OK
+Glob.eval "<toto.{ml,mli}>" "toto.mll" = false OK
+Glob.eval "<toto.{ml,mli}>" "toto.ml" = true OK
+Glob.eval "<toto.{ml,mli}>" "toto.mli" = true OK
+Glob.eval "<toto.{ml,mli}>" "toto." = false OK
+Glob.eval "<toto.{ml,mli}>" "toto.mll" = false OK
+Glob.eval "<toto.{ml,mli}>" "toto.ml" = true OK
+Glob.eval "<toto.{ml,mli}>" "toto.mli" = true OK
+Glob.eval "<toto.{ml,mli}>" "toto." = false OK
+Glob.eval "<toto.{ml,mli}>" "toto.mll" = false OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "acf" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "acg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "adf" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "adg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "aef" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "aeg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "bcf" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "bcg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "bdf" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "bdg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "bef" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "beg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "afg" = false OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "af" = false OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "aee" = false OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "acf" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "acg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "adf" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "adg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "aef" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "aeg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "bcf" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "bcg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "bdf" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "bdg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "bef" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "beg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "afg" = false OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "af" = false OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "aee" = false OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "acf" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "acg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "adf" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "adg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "aef" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "aeg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "bcf" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "bcg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "bdf" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "bdg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "bef" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "beg" = true OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "afg" = false OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "af" = false OK
+Glob.eval "<{a,b}{c,[de]}{f,g}>" "aee" = false OK
+Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.ml" = true OK
+Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "b.ml" = true OK
+Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.mli" = true OK
+Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "hello.ml" = false OK
+Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.mli.x" = false OK
+Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.ml" = true OK
+Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "b.ml" = true OK
+Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.mli" = true OK
+Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "hello.ml" = false OK
+Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.mli.x" = false OK
+Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.ml" = true OK
+Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "b.ml" = true OK
+Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.mli" = true OK
+Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "hello.ml" = false OK
+Glob.eval "(<*.ml> or <*.mli>) and not \"hello.ml\"" "a.mli.x" = false OK
+Glob.eval "<*>" "alpha" = true OK
+Glob.eval "<*>" "beta" = true OK
+Glob.eval "<*>" "alpha/beta" = false OK
+Glob.eval "<*>" "gamma/delta" = false OK
+Glob.eval "<*>" "alpha" = true OK
+Glob.eval "<*>" "beta" = true OK
+Glob.eval "<*>" "alpha/beta" = false OK
+Glob.eval "<*>" "gamma/delta" = false OK
+Glob.eval "<*>" "alpha" = true OK
+Glob.eval "<*>" "beta" = true OK
+Glob.eval "<*>" "alpha/beta" = false OK
+Glob.eval "<*>" "gamma/delta" = false OK
+Glob.eval "<alpha/**/beta>" "alpha/beta" = true OK
+Glob.eval "<alpha/**/beta>" "alpha/gamma/beta" = true OK
+Glob.eval "<alpha/**/beta>" "alpha/gamma/delta/beta" = true OK
+Glob.eval "<alpha/**/beta>" "alpha" = false OK
+Glob.eval "<alpha/**/beta>" "beta" = false OK
+Glob.eval "<alpha/**/beta>" "gamma/delta" = false OK
+Glob.eval "<alpha/**/beta>" "alpha/beta" = true OK
+Glob.eval "<alpha/**/beta>" "alpha/gamma/beta" = true OK
+Glob.eval "<alpha/**/beta>" "alpha/gamma/delta/beta" = true OK
+Glob.eval "<alpha/**/beta>" "alpha" = false OK
+Glob.eval "<alpha/**/beta>" "beta" = false OK
+Glob.eval "<alpha/**/beta>" "gamma/delta" = false OK
+Glob.eval "<alpha/**/beta>" "alpha/beta" = true OK
+Glob.eval "<alpha/**/beta>" "alpha/gamma/beta" = true OK
+Glob.eval "<alpha/**/beta>" "alpha/gamma/delta/beta" = true OK
+Glob.eval "<alpha/**/beta>" "alpha" = false OK
+Glob.eval "<alpha/**/beta>" "beta" = false OK
+Glob.eval "<alpha/**/beta>" "gamma/delta" = false OK
+Glob.eval "<**/*.ml>" "toto.ml" = true OK
+Glob.eval "<**/*.ml>" "toto/tata.ml" = true OK
+Glob.eval "<**/*.ml>" "alpha/gamma/delta/beta.ml" = true OK
+Glob.eval "<**/*.ml>" "toto.mli" = false OK
+Glob.eval "<**/*.ml>" "toto.ml" = true OK
+Glob.eval "<**/*.ml>" "toto/tata.ml" = true OK
+Glob.eval "<**/*.ml>" "alpha/gamma/delta/beta.ml" = true OK
+Glob.eval "<**/*.ml>" "toto.mli" = false OK
+Glob.eval "<**/*.ml>" "toto.ml" = true OK
+Glob.eval "<**/*.ml>" "toto/tata.ml" = true OK
+Glob.eval "<**/*.ml>" "alpha/gamma/delta/beta.ml" = true OK
+Glob.eval "<**/*.ml>" "toto.mli" = false OK
+Glob.eval "<toto/**>" "toto/" = true OK
+Glob.eval "<toto/**>" "toto/tata" = true OK
+Glob.eval "<toto/**>" "toto/alpha/gamma/delta/beta.ml" = true OK
+Glob.eval "<toto/**>" "toto" = true OK
+Glob.eval "<toto/**>" "toto2/tata" = false OK
+Glob.eval "<toto/**>" "tata/titi" = false OK
+Glob.eval "<toto/**>" "toto/" = true OK
+Glob.eval "<toto/**>" "toto/tata" = true OK
+Glob.eval "<toto/**>" "toto/alpha/gamma/delta/beta.ml" = true OK
+Glob.eval "<toto/**>" "toto" = true OK
+Glob.eval "<toto/**>" "toto2/tata" = false OK
+Glob.eval "<toto/**>" "tata/titi" = false OK
+Glob.eval "<toto/**>" "toto/" = true OK
+Glob.eval "<toto/**>" "toto/tata" = true OK
+Glob.eval "<toto/**>" "toto/alpha/gamma/delta/beta.ml" = true OK
+Glob.eval "<toto/**>" "toto" = true OK
+Glob.eval "<toto/**>" "toto2/tata" = false OK
+Glob.eval "<toto/**>" "tata/titi" = false OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "src/bar/libfoo.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "otherlibs/unix/libunix.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "otherlibsliblib/unlibix/libunix.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo/libbar.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "src/libfoo/boo/libbar.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "bar" = None OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libbar/foo.a" = None OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo.b.a" = None OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "src/bar/libfoo.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "otherlibs/unix/libunix.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "otherlibsliblib/unlibix/libunix.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo/libbar.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "src/libfoo/boo/libbar.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "bar" = None OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libbar/foo.a" = None OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo.b.a" = None OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "src/bar/libfoo.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "otherlibs/unix/libunix.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "otherlibsliblib/unlibix/libunix.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo/libbar.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "src/libfoo/boo/libbar.a" OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "bar" = None OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libbar/foo.a" = None OK
+Resource.matchit "%(path:<**/>)lib%(libname:<*> and not <*.*>).a" "libfoo.b.a" = None OK
+ _____ _ __ ___ _ _
+|_ _|__ ___| |_ \ \ / (_)_ __| |_ _ _ __ _| |
+ | |/ _ \/ __| __| \ \ / /| | '__| __| | | |/ _` | |
+ | | __/\__ \ |_ \ V / | | | | |_| |_| | (_| | |
+ |_|\___||___/\__| \_/ |_|_| \__|\__,_|\__,_|_|
+
+ _____ _
+|_ _|_ _ _ __ __ _ ___| |_ ___
+ | |/ _` | '__/ _` |/ _ \ __/ __|
+ | | (_| | | | (_| | __/ |_\__ \
+ |_|\__,_|_| \__, |\___|\__|___/
+ |___/
++ CMDOPTS=
++ BUILD='../../_build/ocamlbuild.native bar -no-skip -classic-display '
++ BUILD1='../../_build/ocamlbuild.native bar -no-skip -classic-display '
++ BUILD2='../../_build/ocamlbuild.native bar -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt '
++ rm -rf _build
++ cp foo1 foo
++ ../../_build/ocamlbuild.native bar -no-skip -classic-display
+ocamlopt.opt -I /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild unix.cmxa /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild/ocamlbuildlib.cmxa myocamlbuild.ml /Users/ertai/l/ocaml/ocamlbuild-unstable/ocamlbuild/_install/lib/ocamlbuild/ocamlbuild.cmx -o myocamlbuild
+cp foo bar
++ ../../_build/ocamlbuild.native bar -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt
+[cache hit] cp foo bar
++ cp foo2 foo
++ ../../_build/ocamlbuild.native bar -no-skip -classic-display -verbose 0
+cp foo bar
++ ../../_build/ocamlbuild.native bar -no-skip -classic-display -verbose 0 -nothing-should-be-rebuilt
+[cache hit] cp foo bar
++ rm foo
--- /dev/null
+#!/bin/sh
+set -e
+cd `dirname $0`
+
+myfiglet() {
+ figlet $@ | sed 's/ *$//'
+}
+
+if figlet ""; then
+ BANNER=myfiglet
+else
+ echo "Install figlet to have a better output, press enter to continue with echo"
+ read
+ BANNER=echo
+fi
+
+HERE=`pwd`
+
+$BANNER Test2
+./test2/test.sh $@
+$BANNER Test3
+./test3/test.sh $@
+$BANNER Test4
+./test4/test.sh $@
+$BANNER Test5
+./test5/test.sh $@
+$BANNER Test6
+./test6/test.sh $@
+$BANNER Test7
+./test7/test.sh $@
+$BANNER Test8
+./test8/test.sh $@
+$BANNER Test9
+./test9/test.sh $@
+$BANNER Test Virtual Targets
+./test_virtual/test.sh $@
--- /dev/null
+module MA1 = A1
--- /dev/null
+#load "discard_printf.cmo";;
+#load "debug.cmo";;
+#load "unix.cma";;
+#load "str.cma";;
+#load "my_unix.cmo";;
+#load "bool.cmo";;
+#load "glob_ast.cmo";;
+#load "glob_lexer.cmo";;
+#load "glob.cmo";;
+#load "lexers.cmo";;
+#load "my_std.cmo";;
+#load "tags.cmo";;
--- /dev/null
+#!/bin/sh
+set -e
+set -x
+cd `dirname $0`/../..
+./_build/ocamlbuild.native -quiet -build-dir _buildtest -no-links test/test9/testglob.native
+./_buildtest/test/test9/testglob.native
--- /dev/null
+# a comment
+"a/aa.byte" or "a/aa.native": use_libb
--- /dev/null
+let bar = 3 + List.length Bb.foo
--- /dev/null
+val bar : int
--- /dev/null
+let foo = [2.2]
--- /dev/null
+open Ocamlbuild_plugin;;
+dispatch begin function
+| After_rules -> ocaml_lib "b/libb"
+| _ -> ()
+end
--- /dev/null
+#!/bin/sh
+cd `dirname $0`
+set -e
+set -x
+CMDOTPS="" # -- command args
+BUILD="../../_build/ocamlbuild.native -I a -I b aa.byte aa.native -no-skip -classic-display $@"
+BUILD1="$BUILD $CMDOPTS"
+BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS"
+rm -rf _build
+$BUILD1
+echo looks if libs are there
+ls _build/b/libb.cma _build/b/libb.cmxa _build/b/libb.a
+$BUILD2
--- /dev/null
+"vivi.ml": camlp4o
+
+# , some_useless_tag, \ more_useless_tags
--- /dev/null
+let tata = "TATA2"
--- /dev/null
+(* a comment *)
+val tata : string
--- /dev/null
+#!/bin/sh
+cd `dirname $0`
+set -e
+set -x
+CMDOPTS="-- -help"
+BUILD="../../_build/ocamlbuild.native toto.byte toto.native -no-skip -classic-display $@"
+BUILD1="$BUILD $CMDOPTS"
+BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS"
+rm -rf _build
+cp vivi1.ml vivi.ml
+$BUILD1
+$BUILD2
+cp vivi2.ml vivi.ml
+$BUILD1
+$BUILD2
+cp vivi3.ml vivi.ml
+$BUILD1
+$BUILD2
--- /dev/null
+let titi = []
--- /dev/null
+let i = Tutu.tutu + 10
+let s = Tata.tata ^ ".ml"
+let l = 3 :: Titi.titi
+let () = Format.printf "toto.native: %s: Hello world!!!@." Sys.argv.(0)
+let () = Format.printf "Tutu.tutu => %d@.Tata.tata => %S@." Tutu.tutu Tata.tata
--- /dev/null
+let tutu = (Array.length Vivi.vivi : Tyty.t)
+let tutu' = 2.0 +. float_of_int tutu
--- /dev/null
+(* a comment *)
+val tutu : int
+val tutu' : float
--- /dev/null
+type t = int
--- /dev/null
+let rec p i = [< '1; '2; p (i + 1) >]
+let vivi = [|2|]
--- /dev/null
+let rec p i = [< '1; '2; p (i + 1) >]
+let vivi = [|3|]
--- /dev/null
+let rec p i = [< '1; '2; p (i + 1) >]
+let vivi = [|2.1; 1.1|]
--- /dev/null
+"a.byte" or "a.native": use_unix
--- /dev/null
+module X = B
--- /dev/null
+(* Nothing *)
--- /dev/null
+module X = C
--- /dev/null
+(* nothing *)
--- /dev/null
+module X = D
--- /dev/null
+(* nothing *)
--- /dev/null
+module X = E
--- /dev/null
+(* nothing *)
--- /dev/null
+module X = F
--- /dev/null
+(* nothing *)
--- /dev/null
+(* nothing *)
+let _ = Unix.stat
--- /dev/null
+(* nothing *)
--- /dev/null
+A B C D E F
--- /dev/null
+#!/bin/sh
+cd `dirname $0`
+set -e
+set -x
+CMDOTPS="" # -- command args
+BUILD="../../_build/ocamlbuild.native a.byte a.native proj.docdir/index.html -no-skip -classic-display $@"
+BUILD1="$BUILD $CMDOPTS"
+BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS"
+rm -rf _build
+$BUILD1
+$BUILD2
--- /dev/null
+# a comment
+"a/aa.byte" or "a/aa.native": use_str
--- /dev/null
+let bar = 3 + List.length Bb.foo
--- /dev/null
+val bar : int
--- /dev/null
+let r = Str.regexp "r"
+let foo = [2.2]
--- /dev/null
+#!/bin/sh
+cd `dirname $0`
+set -e
+set -x
+CMDOTPS="" # -- command args
+BUILD="../../_build/ocamlbuild.native -I a -I b aa.byte aa.native -no-skip -classic-display $@"
+BUILD1="$BUILD $CMDOPTS"
+BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS"
+rm -rf _build
+$BUILD1
+$BUILD2
--- /dev/null
+"a.cmx" or "b.cmx": for-pack(C)
--- /dev/null
+let a = 42 + Stack.stack
--- /dev/null
+val a : int
--- /dev/null
+let b = A.a + 1
--- /dev/null
+Format.printf "C.B.b = %d@." C.B.b
--- /dev/null
+let stack = 42
--- /dev/null
+#!/bin/sh
+cd `dirname $0`
+set -e
+set -x
+CMDOPTS="" # -- command args
+BUILD="../../_build/ocamlbuild.native d.byte d.native -no-skip -classic-display $@"
+BUILD1="$BUILD $CMDOPTS"
+BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS"
+rm -rf _build
+$BUILD1
+$BUILD2
--- /dev/null
+let a = B.b
--- /dev/null
+val a : 'a -> 'a
--- /dev/null
+let b = D.d
--- /dev/null
+val b : 'a -> 'a
--- /dev/null
+val b : 'a -> 'a
--- /dev/null
+....
+val b : 'a -> 'a
--- /dev/null
+type t
+let d x = x
--- /dev/null
+val d : 'a -> 'a
--- /dev/null
+type t
+val d : 'a -> 'a
--- /dev/null
+val d : 'a -> 'a
--- /dev/null
+A.a 2. +. D.d 1.
--- /dev/null
+(* nothing *)
--- /dev/null
+#!/bin/sh
+cd `dirname $0`
+set -x
+rm -rf _build
+CMDOPTS="" # -- command args
+BUILD="../../_build/ocamlbuild.native -no-skip main.byte -classic-display $@"
+BUILD1="$BUILD $CMDOPTS"
+BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS"
+cp b.mli.v1 b.mli
+cp d.mli.v1 d.mli
+$BUILD1
+$BUILD2
+cp b.mli.v2 b.mli
+cp d.mli.v2 d.mli
+$BUILD1
+cp b.mli.v1 b.mli
+if $BUILD1; then
+ if $BUILD2; then
+ echo PASS
+ else
+ echo "FAIL (-nothing-should-be-rebuilt)"
+ fi
+else
+ echo FAIL
+fi
+
--- /dev/null
+"main.byte": my_cool_plugin
--- /dev/null
+let aa = "aa"
--- /dev/null
+val bb : int
--- /dev/null
+let bb = 43
--- /dev/null
+let bb = 43
+let f x = x + 1
+let () = incr (ref 0)
--- /dev/null
+let bb = 43
+let f x = x + 1
+let () = incr (ref 1)
--- /dev/null
+let c2 = 12
--- /dev/null
+val c2 : int
--- /dev/null
+let c3 = Bb.bb + 13
--- /dev/null
+let cc = (String.length Aa.aa) + Bb.bb + C2.c2
--- /dev/null
+print_endline "I am a cool plugin"
--- /dev/null
+let main = String.length Aa.aa - Bb.bb - C3.c3 - Cc.cc - 1
--- /dev/null
+open Ocamlbuild_plugin;;
+dispatch begin function
+| After_rules ->
+ use_lib "main" "bbcc";
+ dep ["ocaml"; "link"; "byte"; "my_cool_plugin"] ["cool_plugin.cmo"];
+| _ -> ()
+end
--- /dev/null
+#!/bin/sh
+cd `dirname $0`
+set -e
+set -x
+CMDOPTS="" # -- command args
+BUILD="../../_build/ocamlbuild.native bbcc.cma main.byte bbcc.cmxa main.native -no-skip -classic-display $@"
+BUILD1="$BUILD $CMDARGS"
+BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDARGS"
+rm -rf _build
+cp bb1.ml bb.ml
+$BUILD1
+$BUILD2
+cp bb2.ml bb.ml
+$BUILD1 -verbose 0
+$BUILD2
+cp bb3.ml bb.ml
+$BUILD1 -verbose 0
+$BUILD2
--- /dev/null
+print_endline Myconfig.version;;
--- /dev/null
+open Ocamlbuild_plugin;;
+let version = "0.1";;
+dispatch begin function
+ | After_rules ->
+ rule "myconfig.ml"
+ ~prod:"myconfig.ml"
+ begin fun _ _ ->
+ Echo(["let version = \""; version; "\";;\n"], "myconfig.ml")
+ end;
+
+ copy_rule "copy byte-code executables" "%(path).byte" "%(path:not <**/*.*>)";
+ copy_rule "copy native executables" "%(path).native" "%(path:not <**/*.*>).opt";
+ copy_rule "copy binaries to bin" "%(basename).%(extension)"
+ "bin/%(basename).%(extension:<{byte,native}>)";
+ | _ -> ()
+end
--- /dev/null
+#!/bin/sh
+cd `dirname $0`
+set -e
+set -x
+CMDOPTS="" # -- command args
+BUILD="../../_build/ocamlbuild.native a.byte a.native a a.opt bin/a bin/a.opt -no-skip -classic-display $@"
+BUILD1="$BUILD $CMDOPTS"
+BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS"
+rm -rf _build
+$BUILD1
+$BUILD2
--- /dev/null
+#load "unix.cma";;
+#load "str.cma";;
+#load "discard_printf.cmo";;
+#load "debug.cmo";;
+#load "bool.cmo";;
+#load "glob_ast.cmo";;
+#load "glob_lexer.cmo";;
+#load "my_unix.cmo";;
+#use "glob.ml";;
+#install_printer print_is;;
--- /dev/null
+#!/bin/sh
+set -e
+set -x
+cd `dirname $0`/../..
+./_build/ocamlbuild.native -quiet -build-dir _buildtest -no-links test/test9/testglob.native $@
+./_buildtest/test/test9/testglob.native
--- /dev/null
+(* Testglob *)
+
+open Bool;;
+open Glob;;
+
+let yep f x =
+ try
+ ignore (f x);
+ true
+ with
+ | _ -> false
+;;
+
+let tests1 = [
+ "\"hello\"", true;
+ "<hello>", true;
+ "<hel*lo>", true;
+ "<a> and <b> or <c>", true;
+ "<a> titi", false
+];;
+
+let tests2 = [
+ "<[a]>", ["a"], ["b"];
+ "<[a-z]>", ["a";"e";"k";"z"], ["0";"A";"~"];
+ "<[a-z][0-9]>", ["a0";"b9"], ["a00";"a0a";"b0a";"isduis";""];
+ "<hello>", ["hello"], ["helli"];
+ "\"hello\"", ["hello"], ["heidi"];
+ "<*>", ["";"a";"ax"], [];
+ "<a*b>", ["ab";"acb";"axxxxxb";"ababbababb"], ["abx";"xxxxxab";"xab"];
+ "<*.ml>", ["hello.ml";".ml"], ["ml"; ""; "toto.mli"];
+ "<a>", ["a"], ["";"aa";"ba";"ab";"abaa"];
+ "<ab>", ["ab"], ["";"abab";"aba";"abx"];
+ "<ab?c>", ["abac";"abxc"], ["abab";"ababab";"ababa"];
+ "<*ab?cd*>", ["123abecd345";"abccd";"abccd345";"ababcababccdab"], ["abcd";"aaaaabcdababcd"];
+ "<*this*is*a*test*>", ["this is a test";"You know this is a test really";"thisisatest"], ["thisatest"];
+ "<b*>", ["bxx";"bx"], ["aaab";""];
+ "<*>", ["";"a";"aaa";"aaaaa"], [];
+ "<?>", ["a"],["";"aaa";"aaaaa"];
+ "<{a,b}>", ["a";"b"],["";"aa";"ab";"ba";"bb";"c"];
+ "<toto.{ml,mli}>", ["toto.ml";"toto.mli"],["toto.";"toto.mll"];
+ "<{a,b}{c,[de]}{f,g}>", ["acf";"acg";"adf";"adg";"aef";"aeg";"bcf";"bcg";"bdf";"bdg";"bef";"beg"],
+ ["afg";"af";"aee"];
+ "(<*.ml> or <*.mli>) and not \"hello.ml\"",
+ ["a.ml"; "b.ml"; "a.mli"],
+ ["hello.ml"; "a.mli.x"];
+ "<*>", ["alpha";"beta"], ["alpha/beta";"gamma/delta"];
+ "<alpha/**/beta>", ["alpha/beta";"alpha/gamma/beta";"alpha/gamma/delta/beta"],
+ ["alpha";"beta";"gamma/delta"];
+ "<**/*.ml>", ["toto.ml";"toto/tata.ml";"alpha/gamma/delta/beta.ml"],
+ ["toto.mli"];
+ "<toto/**>", ["toto/";"toto/tata";"toto/alpha/gamma/delta/beta.ml";"toto"],
+ ["toto2/tata"; "tata/titi"]
+];;
+
+let tests3 = [
+ "%(path:<**/>)lib%(libname:<*> and not <*.*>).a",
+ ["libfoo.a","","foo";
+ "src/bar/libfoo.a","src/bar/","foo";
+ "otherlibs/unix/libunix.a","otherlibs/unix/","unix";
+ "otherlibsliblib/unlibix/libunix.a","otherlibsliblib/unlibix/","unix";
+ "libfoo/libbar.a","libfoo/","bar";
+ "src/libfoo/boo/libbar.a","src/libfoo/boo/","bar";
+ ],
+ ["bar"; "libbar/foo.a"; "libfoo.b.a"]
+];;
+
+let _ =
+ let times = 3 in
+ List.iter
+ begin fun (str, ast) ->
+ let ast' = yep Glob.parse str in
+ if ast <> ast' then
+ begin
+ Printf.printf "Globexp parsing failed for %S.\n%!" str;
+ exit 1
+ end
+ else
+ Printf.printf "Globexp for %S OK\n%!" str
+ end
+ tests1;
+ List.iter
+ begin fun (gstr, yes, no) ->
+ let globber = Glob.parse gstr in
+ let check polarity =
+ List.iter
+ begin fun y ->
+ if Glob.eval globber y = polarity then
+ Printf.printf "Glob.eval %S %S = %b OK\n%!" gstr y polarity
+ else
+ begin
+ Printf.printf "Glob.eval %S %S = %b FAIL\n%!" gstr y (not polarity);
+ exit 1
+ end
+ end
+ in
+ for k = 1 to times do
+ check true yes;
+ check false no
+ done
+ end
+ tests2;
+ List.iter begin fun (str, yes, no) ->
+ let resource = Resource.import_pattern str in
+ for k = 1 to times do
+ List.iter begin fun (y, path, libname) ->
+ let resource' = Resource.import y in
+ match Resource.matchit resource resource' with
+ | Some env ->
+ let path' = Resource.subst env "%(path)" in
+ let libname' = Resource.subst env "%(libname)" in
+ if path' = path && libname = libname' then
+ Printf.printf "Resource.matchit %S %S OK\n%!" str y
+ else begin
+ Printf.printf "Resource.matchit %S %S FAIL\n%!" str y;
+ exit 1
+ end
+ | None ->
+ begin
+ Printf.printf "Resource.matchit %S %S = None FAIL\n%!" str y;
+ exit 1
+ end
+ end yes;
+ List.iter begin fun y ->
+ let resource' = Resource.import y in
+ if Resource.matchit resource resource' = None then
+ Printf.printf "Resource.matchit %S %S = None OK\n%!" str y
+ else begin
+ Printf.printf "Resource.matchit %S %S <> None FAIL\n%!" str y;
+ exit 1
+ end
+ end no
+ done
+ end tests3
+;;
--- /dev/null
+open Ocamlbuild_plugin;;
+dispatch begin function
+ | After_rules ->
+ rule "copy foo"
+ ~prod:"bar"
+ ~dep:"foo.otarget"
+ begin fun _env _build ->
+ cp "foo" "bar"
+ end
+ | _ -> ()
+end
--- /dev/null
+#!/bin/sh
+cd `dirname $0`
+set -e
+set -x
+CMDOPTS="" # -- command args
+BUILD="../../_build/ocamlbuild.native bar -no-skip -classic-display $@"
+BUILD1="$BUILD $CMDOPTS"
+BUILD2="$BUILD -verbose 0 -nothing-should-be-rebuilt $CMDOPTS"
+rm -rf _build
+cp foo1 foo
+$BUILD1
+$BUILD2
+cp foo2 foo
+$BUILD1 -verbose 0
+$BUILD2
+rm foo
--- /dev/null
+*.out *.out2
\ No newline at end of file
--- /dev/null
+Index: typing/ctype.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/ctype.ml,v
+retrieving revision 1.201
+diff -u -r1.201 ctype.ml
+--- typing/ctype.ml 5 Apr 2006 02:28:13 -0000 1.201
++++ typing/ctype.ml 17 May 2006 23:48:22 -0000
+@@ -490,6 +490,31 @@
+ unmark_class_signature sign;
+ Some reason
+
++(* Variant for checking principality *)
++
++let rec free_nodes_rec ty =
++ let ty = repr ty in
++ if ty.level >= lowest_level then begin
++ if ty.level <= !current_level then raise Exit;
++ ty.level <- pivot_level - ty.level;
++ begin match ty.desc with
++ Tvar ->
++ raise Exit
++ | Tobject (ty, _) ->
++ free_nodes_rec ty
++ | Tfield (_, _, ty1, ty2) ->
++ free_nodes_rec ty1; free_nodes_rec ty2
++ | Tvariant row ->
++ let row = row_repr row in
++ iter_row free_nodes_rec {row with row_bound = []};
++ if not (static_row row) then free_nodes_rec row.row_more
++ | _ ->
++ iter_type_expr free_nodes_rec ty
++ end;
++ end
++
++let has_free_nodes ty =
++ try free_nodes_rec ty; false with Exit -> true
+
+ (**********************)
+ (* Type duplication *)
+Index: typing/ctype.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/ctype.mli,v
+retrieving revision 1.54
+diff -u -r1.54 ctype.mli
+--- typing/ctype.mli 5 Apr 2006 02:28:13 -0000 1.54
++++ typing/ctype.mli 17 May 2006 23:48:22 -0000
+@@ -228,6 +228,9 @@
+ val closed_class:
+ type_expr list -> class_signature -> closed_class_failure option
+ (* Check whether all type variables are bound *)
++val has_free_nodes: type_expr -> bool
++ (* Check whether there are free type variables, or nodes with
++ level lower or equal to !current_level *)
+
+ val unalias: type_expr -> type_expr
+ val signature_of_class_type: class_type -> class_signature
+Index: typing/typecore.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/typecore.ml,v
+retrieving revision 1.181
+diff -u -r1.181 typecore.ml
+--- typing/typecore.ml 16 Apr 2006 23:28:22 -0000 1.181
++++ typing/typecore.ml 17 May 2006 23:48:22 -0000
+@@ -1183,12 +1183,29 @@
+ let (ty', force) =
+ Typetexp.transl_simple_type_delayed env sty'
+ in
++ if !Clflags.principal then begin_def ();
+ let arg = type_exp env sarg in
++ let has_fv =
++ if !Clflags.principal then begin
++ end_def ();
++ let b = has_free_nodes arg.exp_type in
++ Ctype.unify env arg.exp_type (newvar ());
++ b
++ end else
++ free_variables arg.exp_type <> []
++ in
+ begin match arg.exp_desc, !self_coercion, (repr ty').desc with
+ Texp_ident(_, {val_kind=Val_self _}), (path,r) :: _,
+ Tconstr(path',_,_) when Path.same path path' ->
+ r := sexp.pexp_loc :: !r;
+ force ()
++ | _ when not has_fv ->
++ begin try
++ let force' = subtype env arg.exp_type ty' in
++ force (); force' ()
++ with Subtype (tr1, tr2) ->
++ raise(Error(sexp.pexp_loc, Not_subtype(tr1, tr2)))
++ end
+ | _ ->
+ let ty, b = enlarge_type env ty' in
+ force ();
--- /dev/null
+parsing typing bytecomp driver toplevel
\ No newline at end of file
--- /dev/null
+bytecomp byterun driver parsing stdlib tools toplevel typing utils otherlibs/labltk/browser/searchpos.ml
--- /dev/null
+(* Adapted from: An Expressive Language of Signatures
+ by Norman Ramsey, Kathleen Fisher and Paul Govereau *)
+
+module type VALUE = sig
+ type value (* a Lua value *)
+ type state (* the state of a Lua interpreter *)
+ type usert (* a user-defined value *)
+end
+
+module type CORE0 = sig
+ module V : VALUE
+ val setglobal : V.state -> string -> V.value -> unit
+ (* five more functions common to core and evaluator *)
+end
+
+module type CORE = sig
+ include CORE0
+ val apply : V.value -> V.state -> V.value list -> V.value
+ (* apply function f in state s to list of args *)
+end
+
+module type AST = sig
+ module Value : VALUE
+ type chunk
+ type program
+ val get_value : chunk -> Value.value
+end
+
+module type EVALUATOR = sig
+ module Value : VALUE
+ module Ast : (AST with module Value := Value)
+ type state = Value.state
+ type value = Value.value
+ exception Error of string
+ val compile : Ast.program -> string
+ include CORE0 with module V := Value
+end
+
+module type PARSER = sig
+ type chunk
+ val parse : string -> chunk
+end
+
+module type INTERP = sig
+ include EVALUATOR
+ module Parser : PARSER with type chunk = Ast.chunk
+ val dostring : state -> string -> value list
+ val mk : unit -> state
+end
+
+module type USERTYPE = sig
+ type t
+ val eq : t -> t -> bool
+ val to_string : t -> string
+end
+
+module type TYPEVIEW = sig
+ type combined
+ type t
+ val map : (combined -> t) * (t -> combined)
+end
+
+module type COMBINED_COMMON = sig
+ module T : sig type t end
+ module TV1 : TYPEVIEW with type combined := T.t
+ module TV2 : TYPEVIEW with type combined := T.t
+end
+
+module type COMBINED_TYPE = sig
+ module T : USERTYPE
+ include COMBINED_COMMON with module T := T
+end
+
+module type BARECODE = sig
+ type state
+ val init : state -> unit
+end
+
+module USERCODE(X : TYPEVIEW) = struct
+ module type F =
+ functor (C : CORE with type V.usert = X.combined) ->
+ BARECODE with type state := C.V.state
+end
+
+module Weapon = struct type t end
+
+module type WEAPON_LIB = sig
+ type t = Weapon.t
+ module T : USERTYPE with type t = t
+ module Make :
+ functor (TV : TYPEVIEW with type t = t) -> USERCODE(TV).F
+end
--- /dev/null
+(* cvs update -r fixedtypes parsing typing *)
+
+(* recursive types *)
+class c = object (self) method m = 1 method s = self end
+module type S = sig type t = private #c end;;
+
+module M : S = struct type t = c end
+module type S' = S with type t = c;;
+
+class d = object inherit c method n = 2 end
+module type S2 = S with type t = private #d;;
+module M2 : S = struct type t = d end;;
+module M3 : S = struct type t = private #d end;;
+
+module T1 = struct
+ type ('a,'b) a = [`A of 'a | `B of 'b]
+ type ('a,'b) b = [`Z | ('a,'b) a]
+end
+module type T2 = sig
+ type a and b
+ val evala : a -> int
+ val evalb : b -> int
+end
+module type T3 = sig
+ type a0 = private [> (a0,b0) T1.a]
+ and b0 = private [> (a0,b0) T1.b]
+end
+module type T4 = sig
+ include T3
+ include T2 with type a = a0 and type b = b0
+end
+module F(X:T4) = struct
+ type a = X.a and b = X.b
+ let a = X.evala (`B `Z)
+ let b = X.evalb (`A(`B `Z))
+ let a2b (x : a) : b = `A x
+ let b2a (x : b) : a = `B x
+end
+module M4 = struct
+ type a = [`A of a | `B of b | `ZA]
+ and b = [`A of a | `B of b | `Z]
+ type a0 = a
+ type b0 = b
+ let rec eval0 = function
+ `A a -> evala a
+ | `B b -> evalb b
+ and evala : a -> int = function
+ #T1.a as x -> 1 + eval0 x
+ | `ZA -> 3
+ and evalb : b -> int = function
+ #T1.a as x -> 1 + eval0 x
+ | `Z -> 7
+end
+module M5 = F(M4)
+
+module M6 : sig
+ class ci : int ->
+ object
+ val x : int
+ method x : int
+ method move : int -> unit
+ end
+ type c = private #ci
+ val create : int -> c
+end = struct
+ class ci x = object
+ val mutable x : int = x
+ method x = x
+ method move d = x <- x+d
+ end
+ type c = ci
+ let create = new ci
+end
+let f (x : M6.c) = x#move 3; x#x;;
+
+module M : sig type t = private [> `A of bool] end =
+ struct type t = [`A of int] end
--- /dev/null
+? bytecomp/alpha_eq.ml
+Index: bytecomp/lambda.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/lambda.ml,v
+retrieving revision 1.44
+diff -u -r1.44 lambda.ml
+--- bytecomp/lambda.ml 25 Aug 2005 15:35:16 -0000 1.44
++++ bytecomp/lambda.ml 2 Feb 2006 05:08:56 -0000
+@@ -287,9 +287,10 @@
+ let compare = compare
+ end)
+
+-let free_ids get l =
++let free_ids get used l =
+ let fv = ref IdentSet.empty in
+ let rec free l =
++ let old = !fv in
+ iter free l;
+ fv := List.fold_right IdentSet.add (get l) !fv;
+ match l with
+@@ -307,17 +308,20 @@
+ fv := IdentSet.remove v !fv
+ | Lassign(id, e) ->
+ fv := IdentSet.add id !fv
++ | Lifused(id, e) ->
++ if used && not (IdentSet.mem id old) then fv := IdentSet.remove id !fv
+ | Lvar _ | Lconst _ | Lapply _
+ | Lprim _ | Lswitch _ | Lstaticraise _
+ | Lifthenelse _ | Lsequence _ | Lwhile _
+- | Lsend _ | Levent _ | Lifused _ -> ()
++ | Lsend _ | Levent _ -> ()
+ in free l; !fv
+
+-let free_variables l =
+- free_ids (function Lvar id -> [id] | _ -> []) l
++let free_variables ?(ifused=false) l =
++ free_ids (function Lvar id -> [id] | _ -> []) ifused l
+
+ let free_methods l =
+- free_ids (function Lsend(Self, Lvar meth, obj, _) -> [meth] | _ -> []) l
++ free_ids (function Lsend(Self, Lvar meth, obj, _) -> [meth] | _ -> [])
++ false l
+
+ (* Check if an action has a "when" guard *)
+ let raise_count = ref 0
+Index: bytecomp/lambda.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/lambda.mli,v
+retrieving revision 1.42
+diff -u -r1.42 lambda.mli
+--- bytecomp/lambda.mli 25 Aug 2005 15:35:16 -0000 1.42
++++ bytecomp/lambda.mli 2 Feb 2006 05:08:56 -0000
+@@ -177,7 +177,7 @@
+
+ val iter: (lambda -> unit) -> lambda -> unit
+ module IdentSet: Set.S with type elt = Ident.t
+-val free_variables: lambda -> IdentSet.t
++val free_variables: ?ifused:bool -> lambda -> IdentSet.t
+ val free_methods: lambda -> IdentSet.t
+
+ val transl_path: Path.t -> lambda
+Index: bytecomp/translclass.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/translclass.ml,v
+retrieving revision 1.38
+diff -u -r1.38 translclass.ml
+--- bytecomp/translclass.ml 13 Aug 2005 20:59:37 -0000 1.38
++++ bytecomp/translclass.ml 2 Feb 2006 05:08:56 -0000
+@@ -46,6 +46,10 @@
+
+ let lfield v i = Lprim(Pfield i, [Lvar v])
+
++let ltuple l = Lprim(Pmakeblock(0,Immutable), l)
++
++let lprim name args = Lapply(oo_prim name, args)
++
+ let transl_label l = share (Const_immstring l)
+
+ let rec transl_meth_list lst =
+@@ -68,8 +72,8 @@
+ Lvar offset])])]))
+
+ let transl_val tbl create name =
+- Lapply (oo_prim (if create then "new_variable" else "get_variable"),
+- [Lvar tbl; transl_label name])
++ lprim (if create then "new_variable" else "get_variable")
++ [Lvar tbl; transl_label name]
+
+ let transl_vals tbl create vals rem =
+ List.fold_right
+@@ -82,7 +86,7 @@
+ (fun (nm, id) rem ->
+ try
+ (nm, id,
+- Lapply(oo_prim "get_method", [Lvar tbl; Lvar (Meths.find nm meths)]))
++ lprim "get_method" [Lvar tbl; Lvar (Meths.find nm meths)])
+ :: rem
+ with Not_found -> rem)
+ inh_meths []
+@@ -97,17 +101,15 @@
+ let (inh_init, obj_init, has_init) = init obj' in
+ if obj_init = lambda_unit then
+ (inh_init,
+- Lapply (oo_prim (if has_init then "create_object_and_run_initializers"
+- else"create_object_opt"),
+- [obj; Lvar cl]))
++ lprim (if has_init then "create_object_and_run_initializers"
++ else"create_object_opt")
++ [obj; Lvar cl])
+ else begin
+ (inh_init,
+- Llet(Strict, obj',
+- Lapply (oo_prim "create_object_opt", [obj; Lvar cl]),
++ Llet(Strict, obj', lprim "create_object_opt" [obj; Lvar cl],
+ Lsequence(obj_init,
+ if not has_init then Lvar obj' else
+- Lapply (oo_prim "run_initializers_opt",
+- [obj; Lvar obj'; Lvar cl]))))
++ lprim "run_initializers_opt" [obj; Lvar obj'; Lvar cl])))
+ end
+
+ let rec build_object_init cl_table obj params inh_init obj_init cl =
+@@ -203,14 +205,13 @@
+
+
+ let bind_method tbl lab id cl_init =
+- Llet(StrictOpt, id, Lapply (oo_prim "get_method_label",
+- [Lvar tbl; transl_label lab]),
++ Llet(StrictOpt, id, lprim "get_method_label" [Lvar tbl; transl_label lab],
+ cl_init)
+
+-let bind_methods tbl meths vals cl_init =
+- let methl = Meths.fold (fun lab id tl -> (lab,id) :: tl) meths [] in
++let bind_methods tbl methl vals cl_init =
+ let len = List.length methl and nvals = List.length vals in
+- if len < 2 && nvals = 0 then Meths.fold (bind_method tbl) meths cl_init else
++ if len < 2 && nvals = 0 then
++ List.fold_right (fun (n,i) -> bind_method tbl n i) methl cl_init else
+ if len = 0 && nvals < 2 then transl_vals tbl true vals cl_init else
+ let ids = Ident.create "ids" in
+ let i = ref len in
+@@ -229,21 +230,19 @@
+ vals' cl_init)
+ in
+ Llet(StrictOpt, ids,
+- Lapply (oo_prim getter,
+- [Lvar tbl; transl_meth_list (List.map fst methl)] @ names),
++ lprim getter
++ ([Lvar tbl; transl_meth_list (List.map fst methl)] @ names),
+ List.fold_right
+- (fun (lab,id) lam -> decr i; Llet(StrictOpt, id, lfield ids !i, lam))
++ (fun (lab,id) lam -> decr i; Llet(Alias, id, lfield ids !i, lam))
+ methl cl_init)
+
+ let output_methods tbl methods lam =
+ match methods with
+ [] -> lam
+ | [lab; code] ->
+- lsequence (Lapply(oo_prim "set_method", [Lvar tbl; lab; code])) lam
++ lsequence (lprim "set_method" [Lvar tbl; lab; code]) lam
+ | _ ->
+- lsequence (Lapply(oo_prim "set_methods",
+- [Lvar tbl; Lprim(Pmakeblock(0,Immutable), methods)]))
+- lam
++ lsequence (lprim "set_methods" [Lvar tbl; ltuple methods]) lam
+
+ let rec ignore_cstrs cl =
+ match cl.cl_desc with
+@@ -266,7 +265,8 @@
+ Llet (Strict, obj_init,
+ Lapply(Lprim(Pfield 1, [lpath]), Lvar cla ::
+ if top then [Lprim(Pfield 3, [lpath])] else []),
+- bind_super cla super cl_init))
++ bind_super cla super cl_init),
++ [], [])
+ | _ ->
+ assert false
+ end
+@@ -278,10 +278,11 @@
+ match field with
+ Cf_inher (cl, vals, meths) ->
+ let cl_init = output_methods cla methods cl_init in
+- let inh_init, cl_init =
++ let (inh_init, cl_init, meths', vals') =
+ build_class_init cla false
+ (vals, meths_super cla str.cl_meths meths)
+ inh_init cl_init msubst top cl in
++ let cl_init = bind_methods cla meths' vals' cl_init in
+ (inh_init, cl_init, [], values)
+ | Cf_val (name, id, exp) ->
+ (inh_init, cl_init, methods, (name, id)::values)
+@@ -304,29 +305,37 @@
+ (inh_init, cl_init, methods, vals @ values)
+ | Cf_init exp ->
+ (inh_init,
+- Lsequence(Lapply (oo_prim "add_initializer",
+- Lvar cla :: msubst false (transl_exp exp)),
++ Lsequence(lprim "add_initializer"
++ (Lvar cla :: msubst false (transl_exp exp)),
+ cl_init),
+ methods, values))
+ str.cl_field
+ (inh_init, cl_init, [], [])
+ in
+ let cl_init = output_methods cla methods cl_init in
+- (inh_init, bind_methods cla str.cl_meths values cl_init)
++ (* inh_init, bind_methods cla str.cl_meths values cl_init *)
++ let methods = Meths.fold (fun n i l -> (n,i)::l) str.cl_meths [] in
++ (inh_init, cl_init, methods, values)
+ | Tclass_fun (pat, vals, cl, _) ->
+- let (inh_init, cl_init) =
++ let (inh_init, cl_init, methods, values) =
+ build_class_init cla cstr super inh_init cl_init msubst top cl
+ in
++ let fv = free_variables ~ifused:true cl_init in
++ let vals = List.filter (fun (id,_) -> IdentSet.mem id fv) vals in
+ let vals = List.map (function (id, _) -> (Ident.name id, id)) vals in
+- (inh_init, transl_vals cla true vals cl_init)
++ (* inh_init, transl_vals cla true vals cl_init *)
++ (inh_init, cl_init, methods, vals @ values)
+ | Tclass_apply (cl, exprs) ->
+ build_class_init cla cstr super inh_init cl_init msubst top cl
+ | Tclass_let (rec_flag, defs, vals, cl) ->
+- let (inh_init, cl_init) =
++ let (inh_init, cl_init, methods, values) =
+ build_class_init cla cstr super inh_init cl_init msubst top cl
+ in
++ let fv = free_variables ~ifused:true cl_init in
++ let vals = List.filter (fun (id,_) -> IdentSet.mem id fv) vals in
+ let vals = List.map (function (id, _) -> (Ident.name id, id)) vals in
+- (inh_init, transl_vals cla true vals cl_init)
++ (* inh_init, transl_vals cla true vals cl_init *)
++ (inh_init, cl_init, methods, vals @ values)
+ | Tclass_constraint (cl, vals, meths, concr_meths) ->
+ let virt_meths =
+ List.filter (fun lab -> not (Concr.mem lab concr_meths)) meths in
+@@ -358,23 +367,34 @@
+ cl_init valids in
+ (inh_init,
+ Llet (Strict, inh,
+- Lapply(oo_prim "inherits", narrow_args @
+- [lpath; Lconst(Const_pointer(if top then 1 else 0))]),
++ lprim "inherits"
++ (narrow_args @
++ [lpath; Lconst(Const_pointer(if top then 1 else 0))]),
+ Llet(StrictOpt, obj_init, lfield inh 0,
+ Llet(Alias, inh_vals, lfield inh 1,
+- Llet(Alias, inh_meths, lfield inh 2, cl_init)))))
++ Llet(Alias, inh_meths, lfield inh 2, cl_init)))),
++ [], [])
+ | _ ->
+ let core cl_init =
+ build_class_init cla true super inh_init cl_init msubst top cl
+ in
+ if cstr then core cl_init else
+- let (inh_init, cl_init) =
+- core (Lsequence (Lapply (oo_prim "widen", [Lvar cla]), cl_init))
++ let (inh_init, cl_init, methods, values) =
++ core (Lsequence (lprim "widen" [Lvar cla], cl_init))
+ in
+- (inh_init,
+- Lsequence(Lapply (oo_prim "narrow", narrow_args), cl_init))
++ let cl_init = bind_methods cla methods values cl_init in
++ (inh_init, Lsequence(lprim "narrow" narrow_args, cl_init), [], [])
+ end
+
++let build_class_init cla env inh_init obj_init msubst top cl =
++ let inh_init = List.rev inh_init in
++ let (inh_init, cl_init, methods, values) =
++ build_class_init cla true ([],[]) inh_init obj_init msubst top cl in
++ assert (inh_init = []);
++ if IdentSet.mem env (free_variables ~ifused:true cl_init)
++ then bind_methods cla methods (("", env) :: values) cl_init
++ else Llet(Alias, env, lambda_unit, bind_methods cla methods values cl_init)
++
+ let rec build_class_lets cl =
+ match cl.cl_desc with
+ Tclass_let (rec_flag, defs, vals, cl) ->
+@@ -459,16 +479,16 @@
+ Strict, new_init, lfunction [obj_init] obj_init',
+ Llet(
+ Alias, cla, transl_path path,
+- Lprim(Pmakeblock(0, Immutable),
+- [Lapply(Lvar new_init, [lfield cla 0]);
+- lfunction [table]
+- (Llet(Strict, env_init,
+- Lapply(lfield cla 1, [Lvar table]),
+- lfunction [envs]
+- (Lapply(Lvar new_init,
+- [Lapply(Lvar env_init, [Lvar envs])]))));
+- lfield cla 2;
+- lfield cla 3])))
++ ltuple
++ [Lapply(Lvar new_init, [lfield cla 0]);
++ lfunction [table]
++ (Llet(Strict, env_init,
++ Lapply(lfield cla 1, [Lvar table]),
++ lfunction [envs]
++ (Lapply(Lvar new_init,
++ [Lapply(Lvar env_init, [Lvar envs])]))));
++ lfield cla 2;
++ lfield cla 3]))
+ with Exit ->
+ lambda_unit
+
+@@ -541,7 +561,7 @@
+ open CamlinternalOO
+ let builtin_meths arr self env env2 body =
+ let builtin, args = builtin_meths self env env2 body in
+- if not arr then [Lapply(oo_prim builtin, args)] else
++ if not arr then [lprim builtin args] else
+ let tag = match builtin with
+ "get_const" -> GetConst
+ | "get_var" -> GetVar
+@@ -599,7 +619,8 @@
+
+ (* Prepare for heavy environment handling *)
+ let tables = Ident.create (Ident.name cl_id ^ "_tables") in
+- let (top_env, req) = oo_add_class tables in
++ let table_init = ref None in
++ let (top_env, req) = oo_add_class tables table_init in
+ let top = not req in
+ let cl_env, llets = build_class_lets cl in
+ let new_ids = if top then [] else Env.diff top_env cl_env in
+@@ -633,6 +654,7 @@
+ begin try
+ (* Doesn't seem to improve size for bytecode *)
+ (* if not !Clflags.native_code then raise Not_found; *)
++ if !Clflags.debug then raise Not_found;
+ builtin_meths arr [self] env env2 (lfunction args body')
+ with Not_found ->
+ [lfunction (self :: args)
+@@ -665,15 +687,8 @@
+ build_object_init_0 cla [] cl copy_env subst_env top ids in
+ if not (Translcore.check_recursive_lambda ids obj_init) then
+ raise(Error(cl.cl_loc, Illegal_class_expr));
+- let inh_init' = List.rev inh_init in
+- let (inh_init', cl_init) =
+- build_class_init cla true ([],[]) inh_init' obj_init msubst top cl
+- in
+- assert (inh_init' = []);
+- let table = Ident.create "table"
+- and class_init = Ident.create (Ident.name cl_id ^ "_init")
+- and env_init = Ident.create "env_init"
+- and obj_init = Ident.create "obj_init" in
++ let cl_init = build_class_init cla env2 inh_init obj_init msubst top cl in
++ let obj_init = Ident.create "obj_init" in
+ let pub_meths =
+ List.sort
+ (fun s s' -> compare (Btype.hash_variant s) (Btype.hash_variant s'))
+@@ -685,42 +700,44 @@
+ let name' = List.assoc tag rev_map in
+ if name' <> name then raise(Error(cl.cl_loc, Tags(name, name'))))
+ tags pub_meths;
++ let pos = cl.cl_loc.Location.loc_end in
++ let filepos = [transl_label pos.Lexing.pos_fname;
++ Lconst(Const_base(Const_int pos.Lexing.pos_cnum))] in
+ let ltable table lam =
+- Llet(Strict, table,
+- Lapply (oo_prim "create_table", [transl_meth_list pub_meths]), lam)
++ Llet(Strict, table, lprim "create_table" [transl_meth_list pub_meths], lam)
+ and ldirect obj_init =
+ Llet(Strict, obj_init, cl_init,
+- Lsequence(Lapply (oo_prim "init_class", [Lvar cla]),
++ Lsequence(lprim "init_class_shared" (Lvar cla :: filepos),
+ Lapply(Lvar obj_init, [lambda_unit])))
+ in
+ (* Simplest case: an object defined at toplevel (ids=[]) *)
+ if top && ids = [] then llets (ltable cla (ldirect obj_init)) else
+
++ let table = Ident.create "table"
++ and class_init = Ident.create (Ident.name cl_id ^ "_init")
++ and env_init = Ident.create (Ident.name cl_id ^ "_env_init") in
++ let cl_init_fun = Lfunction(Curried, [cla], cl_init) in
+ let concrete =
+ ids = [] ||
+ Typeclass.virtual_methods (Ctype.signature_of_class_type cl.cl_type) = []
+- and lclass lam =
+- let cl_init = llets (Lfunction(Curried, [cla], cl_init)) in
++ and lclass cl_init lam =
+ Llet(Strict, class_init, cl_init, lam (free_variables cl_init))
+ and lbody fv =
+ if List.for_all (fun id -> not (IdentSet.mem id fv)) ids then
+- Lapply (oo_prim "make_class",[transl_meth_list pub_meths;
+- Lvar class_init])
++ lprim "make_class"
++ (transl_meth_list pub_meths :: Lvar class_init :: filepos)
+ else
+ ltable table (
+ Llet(
+ Strict, env_init, Lapply(Lvar class_init, [Lvar table]),
+- Lsequence(
+- Lapply (oo_prim "init_class", [Lvar table]),
+- Lprim(Pmakeblock(0, Immutable),
+- [Lapply(Lvar env_init, [lambda_unit]);
+- Lvar class_init; Lvar env_init; lambda_unit]))))
++ Lsequence(lprim "init_class_shared" (Lvar table :: filepos),
++ ltuple [Lapply(Lvar env_init, [lambda_unit]);
++ Lvar class_init; Lvar env_init; lambda_unit])))
+ and lbody_virt lenvs =
+- Lprim(Pmakeblock(0, Immutable),
+- [lambda_unit; Lfunction(Curried,[cla], cl_init); lambda_unit; lenvs])
++ ltuple [lambda_unit; cl_init_fun; lambda_unit; lenvs]
+ in
+ (* Still easy: a class defined at toplevel *)
+- if top && concrete then lclass lbody else
++ if top && concrete then lclass (llets cl_init_fun) lbody else
+ if top then llets (lbody_virt lambda_unit) else
+
+ (* Now for the hard stuff: prepare for table cacheing *)
+@@ -733,23 +750,16 @@
+ let lenv =
+ let menv =
+ if !new_ids_meths = [] then lambda_unit else
+- Lprim(Pmakeblock(0, Immutable),
+- List.map (fun id -> Lvar id) !new_ids_meths) in
++ ltuple (List.map (fun id -> Lvar id) !new_ids_meths) in
+ if !new_ids_init = [] then menv else
+- Lprim(Pmakeblock(0, Immutable),
+- menv :: List.map (fun id -> Lvar id) !new_ids_init)
++ ltuple (menv :: List.map (fun id -> Lvar id) !new_ids_init)
+ and linh_envs =
+ List.map (fun (_, p) -> Lprim(Pfield 3, [transl_path p]))
+ (List.rev inh_init)
+ in
+ let make_envs lam =
+ Llet(StrictOpt, envs,
+- (if linh_envs = [] then lenv else
+- Lprim(Pmakeblock(0, Immutable), lenv :: linh_envs)),
+- lam)
+- and def_ids cla lam =
+- Llet(StrictOpt, env2,
+- Lapply (oo_prim "new_variable", [Lvar cla; transl_label ""]),
++ (if linh_envs = [] then lenv else ltuple (lenv :: linh_envs)),
+ lam)
+ in
+ let inh_paths =
+@@ -757,46 +767,53 @@
+ (fun (_,path) -> List.mem (Path.head path) new_ids) inh_init in
+ let inh_keys =
+ List.map (fun (_,p) -> Lprim(Pfield 1, [transl_path p])) inh_paths in
+- let lclass lam =
+- Llet(Strict, class_init,
+- Lfunction(Curried, [cla], def_ids cla cl_init), lam)
++ let lclass_init lam =
++ Llet(Strict, class_init, cl_init_fun, lam)
+ and lcache lam =
+ if inh_keys = [] then Llet(Alias, cached, Lvar tables, lam) else
+- Llet(Strict, cached,
+- Lapply(oo_prim "lookup_tables",
+- [Lvar tables; Lprim(Pmakeblock(0, Immutable), inh_keys)]),
++ Llet(Strict, cached, lprim "lookup_tables" [Lvar tables; ltuple inh_keys],
+ lam)
+ and lset cached i lam =
+ Lprim(Psetfield(i, true), [Lvar cached; lam])
+ in
+- let ldirect () =
+- ltable cla
+- (Llet(Strict, env_init, def_ids cla cl_init,
+- Lsequence(Lapply (oo_prim "init_class", [Lvar cla]),
+- lset cached 0 (Lvar env_init))))
+- and lclass_virt () =
+- lset cached 0 (Lfunction(Curried, [cla], def_ids cla cl_init))
++ let ldirect prim pos =
++ ltable cla (
++ Llet(Strict, env_init, cl_init,
++ Lsequence(lprim prim (Lvar cla :: pos), Lvar env_init)))
++ and lclass_concrete cached =
++ ltuple [Lapply (lfield cached 0, [lenvs]);
++ lfield cached 1; lfield cached 0; lenvs]
+ in
++
+ llets (
+- lcache (
+- Lsequence(
+- Lifthenelse(lfield cached 0, lambda_unit,
+- if ids = [] then ldirect () else
+- if not concrete then lclass_virt () else
+- lclass (
+- Lapply (oo_prim "make_class_store",
+- [transl_meth_list pub_meths;
+- Lvar class_init; Lvar cached]))),
+ make_envs (
+- if ids = [] then Lapply(lfield cached 0, [lenvs]) else
+- Lprim(Pmakeblock(0, Immutable),
+- if concrete then
+- [Lapply(lfield cached 0, [lenvs]);
+- lfield cached 1;
+- lfield cached 0;
+- lenvs]
+- else [lambda_unit; lfield cached 0; lambda_unit; lenvs]
+- )))))
++ if inh_paths = [] && concrete then
++ if ids = [] then begin
++ table_init := Some (ldirect "init_class_shared" filepos);
++ Lapply (Lvar tables, [lenvs])
++ end else begin
++ let init =
++ lclass cl_init_fun (fun _ ->
++ lprim "make_class_env"
++ (transl_meth_list pub_meths :: Lvar class_init :: filepos))
++ in table_init := Some init;
++ lclass_concrete tables
++ end
++ else begin
++ lcache (
++ Lsequence(
++ Lifthenelse(lfield cached 0, lambda_unit,
++ if ids = [] then lset cached 0 (ldirect "init_class" []) else
++ if not concrete then lset cached 0 cl_init_fun else
++ lclass_init (
++ lprim "make_class_store"
++ [transl_meth_list pub_meths; Lvar class_init; Lvar cached])),
++ llets (
++ make_envs (
++ if ids = [] then Lapply(lfield cached 0, [lenvs]) else
++ if concrete then lclass_concrete cached else
++ ltuple [lambda_unit; lfield cached 0; lambda_unit; lenvs]))))
++ end))
+
+ (* Wrapper for class compilation *)
+
+Index: bytecomp/translobj.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/translobj.ml,v
+retrieving revision 1.9
+diff -u -r1.9 translobj.ml
+--- bytecomp/translobj.ml 26 May 2004 11:10:51 -0000 1.9
++++ bytecomp/translobj.ml 2 Feb 2006 05:08:56 -0000
+@@ -88,7 +88,6 @@
+
+ (* Insert labels *)
+
+-let string s = Lconst (Const_base (Const_string s))
+ let int n = Lconst (Const_base (Const_int n))
+
+ let prim_makearray =
+@@ -124,8 +123,8 @@
+ let top_env = ref Env.empty
+ let classes = ref []
+
+-let oo_add_class id =
+- classes := id :: !classes;
++let oo_add_class id init =
++ classes := (id, init) :: !classes;
+ (!top_env, !cache_required)
+
+ let oo_wrap env req f x =
+@@ -141,10 +140,12 @@
+ let lambda = f x in
+ let lambda =
+ List.fold_left
+- (fun lambda id ->
++ (fun lambda (id, init) ->
+ Llet(StrictOpt, id,
+- Lprim(Pmakeblock(0, Mutable),
+- [lambda_unit; lambda_unit; lambda_unit]),
++ (match !init with
++ Some lam -> lam
++ | None -> Lprim(Pmakeblock(0, Mutable),
++ [lambda_unit; lambda_unit; lambda_unit])),
+ lambda))
+ lambda !classes
+ in
+Index: bytecomp/translobj.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/translobj.mli,v
+retrieving revision 1.6
+diff -u -r1.6 translobj.mli
+--- bytecomp/translobj.mli 26 May 2004 11:10:51 -0000 1.6
++++ bytecomp/translobj.mli 2 Feb 2006 05:08:56 -0000
+@@ -25,4 +25,4 @@
+ Ident.t -> int -> ('a -> lambda) -> 'a -> int * lambda
+
+ val oo_wrap: Env.t -> bool -> ('a -> lambda) -> 'a -> lambda
+-val oo_add_class: Ident.t -> Env.t * bool
++val oo_add_class: Ident.t -> Lambda.lambda option ref -> Env.t * bool
+Index: byterun/compare.h
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/byterun/compare.h,v
+retrieving revision 1.2
+diff -u -r1.2 compare.h
+--- byterun/compare.h 31 Dec 2003 14:20:35 -0000 1.2
++++ byterun/compare.h 2 Feb 2006 05:08:56 -0000
+@@ -17,5 +17,6 @@
+ #define CAML_COMPARE_H
+
+ CAMLextern int caml_compare_unordered;
++CAMLextern value caml_compare(value, value);
+
+ #endif /* CAML_COMPARE_H */
+Index: byterun/extern.c
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/byterun/extern.c,v
+retrieving revision 1.59
+diff -u -r1.59 extern.c
+--- byterun/extern.c 4 Jan 2006 16:55:49 -0000 1.59
++++ byterun/extern.c 2 Feb 2006 05:08:56 -0000
+@@ -411,6 +411,22 @@
+ extern_record_location(v);
+ break;
+ }
++ case Object_tag: {
++ value field0;
++ mlsize_t i;
++ i = Wosize_val(Field(v, 0)) - 1;
++ field0 = Field(Field(v, 0),i);
++ if (Wosize_val(field0) > 0) {
++ writecode32(CODE_OBJECT, Wosize_hd (hd));
++ extern_record_location(v);
++ extern_rec(field0);
++ for (i = 1; i < sz - 1; i++) extern_rec(Field(v, i));
++ v = Field(v, i);
++ goto tailcall;
++ }
++ if (!extern_closures)
++ extern_invalid_argument("output_value: dynamic class");
++ } /* may fall through */
+ default: {
+ value field0;
+ mlsize_t i;
+Index: byterun/intern.c
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/byterun/intern.c,v
+retrieving revision 1.60
+diff -u -r1.60 intern.c
+--- byterun/intern.c 22 Sep 2005 14:21:50 -0000 1.60
++++ byterun/intern.c 2 Feb 2006 05:08:56 -0000
+@@ -28,6 +28,8 @@
+ #include "mlvalues.h"
+ #include "misc.h"
+ #include "reverse.h"
++#include "callback.h"
++#include "compare.h"
+
+ static unsigned char * intern_src;
+ /* Reading pointer in block holding input data. */
+@@ -98,6 +100,25 @@
+ #define readblock(dest,len) \
+ (memmove((dest), intern_src, (len)), intern_src += (len))
+
++static value get_method_table (value key)
++{
++ static value *classes = NULL;
++ value current;
++ if (classes == NULL) {
++ classes = caml_named_value("caml_oo_classes");
++ if (classes == NULL) return 0;
++ caml_register_global_root(classes);
++ }
++ for (current = Field(*classes, 0); Is_block(current);
++ current = Field(current, 1))
++ {
++ value head = Field(current, 0);
++ if (caml_compare(key, Field(head, 0)) == Val_int(0))
++ return Field(head, 1);
++ }
++ return 0;
++}
++
+ static void intern_cleanup(void)
+ {
+ if (intern_input_malloced) caml_stat_free(intern_input);
+@@ -315,6 +336,24 @@
+ Custom_ops_val(v) = ops;
+ intern_dest += 1 + size;
+ break;
++ case CODE_OBJECT:
++ size = read32u();
++ v = Val_hp(intern_dest);
++ *dest = v;
++ if (intern_obj_table != NULL) intern_obj_table[obj_counter++] = v;
++ dest = (value *) (intern_dest + 1);
++ *intern_dest = Make_header(size, Object_tag, intern_color);
++ intern_dest += 1 + size;
++ intern_rec(dest);
++ *dest = get_method_table(*dest);
++ if (*dest == 0) {
++ intern_cleanup();
++ caml_failwith("input_value: unknown class");
++ }
++ for(size--, dest++; size > 1; size--, dest++)
++ intern_rec(dest);
++ goto tailcall;
++
+ default:
+ intern_cleanup();
+ caml_failwith("input_value: ill-formed message");
+Index: byterun/intext.h
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/byterun/intext.h,v
+retrieving revision 1.32
+diff -u -r1.32 intext.h
+--- byterun/intext.h 22 Sep 2005 14:21:50 -0000 1.32
++++ byterun/intext.h 2 Feb 2006 05:08:56 -0000
+@@ -56,6 +56,7 @@
+ #define CODE_CODEPOINTER 0x10
+ #define CODE_INFIXPOINTER 0x11
+ #define CODE_CUSTOM 0x12
++#define CODE_OBJECT 0x14
+
+ #if ARCH_FLOAT_ENDIANNESS == 0x76543210
+ #define CODE_DOUBLE_NATIVE CODE_DOUBLE_BIG
+Index: stdlib/camlinternalOO.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/stdlib/camlinternalOO.ml,v
+retrieving revision 1.14
+diff -u -r1.14 camlinternalOO.ml
+--- stdlib/camlinternalOO.ml 25 Oct 2005 18:34:07 -0000 1.14
++++ stdlib/camlinternalOO.ml 2 Feb 2006 05:08:56 -0000
+@@ -305,10 +305,38 @@
+ public_methods;
+ table
+
++(*
++let create_table_variables pub_meths priv_meths vars =
++ let tbl = create_table pub_meths in
++ let pub_meths = to_array pub_meths
++ and priv_meths = to_array priv_meths
++ and vars = to_array vars in
++ let len = 2 + Array.length pub_meths + Array.length priv_meths in
++ let res = Array.create len tbl in
++ let mv = new_methods_variables tbl pub_meths vars in
++ Array.blit mv 0 res 1;
++ res
++*)
++
+ let init_class table =
+ inst_var_count := !inst_var_count + table.size - 1;
+ table.initializers <- List.rev table.initializers;
+- resize table (3 + magic table.methods.(1) * 16 / Sys.word_size)
++ let len = 3 + magic table.methods.(1) * 16 / Sys.word_size in
++ (* keep 1 more for extra info *)
++ let len = if len > Array.length table.methods then len else len+1 in
++ resize table len
++
++let classes = ref []
++let () = Callback.register "caml_oo_classes" classes
++
++let init_class_shared table (file : string) (pos : int) =
++ init_class table;
++ let rec unique_pos pos =
++ if List.mem_assoc (file, pos) !classes then unique_pos (pos + 0x100000)
++ else pos in
++ let pos = unique_pos pos in
++ table.methods.(Array.length table.methods - 1) <- Obj.magic (file, pos);
++ classes := ((file, pos), table.methods) :: !classes
+
+ let inherits cla vals virt_meths concr_meths (_, super, _, env) top =
+ narrow cla vals virt_meths concr_meths;
+@@ -319,12 +347,18 @@
+ Array.map (fun nm -> get_method cla (get_method_label cla nm))
+ (to_array concr_meths))
+
+-let make_class pub_meths class_init =
++let make_class pub_meths class_init file pos =
+ let table = create_table pub_meths in
+ let env_init = class_init table in
+- init_class table;
++ init_class_shared table file pos;
+ (env_init (Obj.repr 0), class_init, env_init, Obj.repr 0)
+
++let make_class_env pub_meths class_init file pos =
++ let table = create_table pub_meths in
++ let env_init = class_init table in
++ init_class_shared table file pos;
++ (env_init, class_init)
++
+ type init_table = { mutable env_init: t; mutable class_init: table -> t }
+
+ let make_class_store pub_meths class_init init_table =
+Index: stdlib/camlinternalOO.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/stdlib/camlinternalOO.mli,v
+retrieving revision 1.9
+diff -u -r1.9 camlinternalOO.mli
+--- stdlib/camlinternalOO.mli 25 Oct 2005 18:34:07 -0000 1.9
++++ stdlib/camlinternalOO.mli 2 Feb 2006 05:08:56 -0000
+@@ -43,14 +43,20 @@
+ val add_initializer : table -> (obj -> unit) -> unit
+ val dummy_table : table
+ val create_table : string array -> table
++(* val create_table_variables :
++ string array -> string array -> string array -> table *)
+ val init_class : table -> unit
++val init_class_shared : table -> string -> int -> unit
+ val inherits :
+ table -> string array -> string array -> string array ->
+ (t * (table -> obj -> Obj.t) * t * obj) -> bool ->
+ (Obj.t * int array * closure array)
+ val make_class :
+- string array -> (table -> Obj.t -> t) ->
++ string array -> (table -> Obj.t -> t) -> string -> int ->
+ (t * (table -> Obj.t -> t) * (Obj.t -> t) * Obj.t)
++val make_class_env :
++ string array -> (table -> Obj.t -> t) -> string -> int ->
++ (Obj.t -> t) * (table -> Obj.t -> t)
+ type init_table
+ val make_class_store :
+ string array -> (table -> t) -> init_table -> unit
--- /dev/null
+Index: parsing/lexer.mll
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/parsing/lexer.mll,v
+retrieving revision 1.73
+diff -u -r1.73 lexer.mll
+--- parsing/lexer.mll 11 Apr 2005 16:44:26 -0000 1.73
++++ parsing/lexer.mll 2 Feb 2006 06:28:32 -0000
+@@ -63,6 +63,8 @@
+ "match", MATCH;
+ "method", METHOD;
+ "module", MODULE;
++ "multifun", MULTIFUN;
++ "multimatch", MULTIMATCH;
+ "mutable", MUTABLE;
+ "new", NEW;
+ "object", OBJECT;
+Index: parsing/parser.mly
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/parsing/parser.mly,v
+retrieving revision 1.123
+diff -u -r1.123 parser.mly
+--- parsing/parser.mly 23 Mar 2005 03:08:37 -0000 1.123
++++ parsing/parser.mly 2 Feb 2006 06:28:32 -0000
+@@ -257,6 +257,8 @@
+ %token MINUSDOT
+ %token MINUSGREATER
+ %token MODULE
++%token MULTIFUN
++%token MULTIMATCH
+ %token MUTABLE
+ %token <nativeint> NATIVEINT
+ %token NEW
+@@ -325,7 +327,7 @@
+ %nonassoc SEMI /* below EQUAL ({lbl=...; lbl=...}) */
+ %nonassoc LET /* above SEMI ( ...; let ... in ...) */
+ %nonassoc below_WITH
+-%nonassoc FUNCTION WITH /* below BAR (match ... with ...) */
++%nonassoc FUNCTION WITH MULTIFUN /* below BAR (match ... with ...) */
+ %nonassoc AND /* above WITH (module rec A: SIG with ... and ...) */
+ %nonassoc THEN /* below ELSE (if ... then ...) */
+ %nonassoc ELSE /* (if ... then ... else ...) */
+@@ -804,8 +806,12 @@
+ { mkexp(Pexp_function("", None, List.rev $3)) }
+ | FUN labeled_simple_pattern fun_def
+ { let (l,o,p) = $2 in mkexp(Pexp_function(l, o, [p, $3])) }
++ | MULTIFUN opt_bar match_cases
++ { mkexp(Pexp_multifun(List.rev $3)) }
+ | MATCH seq_expr WITH opt_bar match_cases
+- { mkexp(Pexp_match($2, List.rev $5)) }
++ { mkexp(Pexp_match($2, List.rev $5, false)) }
++ | MULTIMATCH seq_expr WITH opt_bar match_cases
++ { mkexp(Pexp_match($2, List.rev $5, true)) }
+ | TRY seq_expr WITH opt_bar match_cases
+ { mkexp(Pexp_try($2, List.rev $5)) }
+ | TRY seq_expr WITH error
+@@ -1318,10 +1324,10 @@
+ | simple_core_type2 { Rinherit $1 }
+ ;
+ tag_field:
+- name_tag OF opt_ampersand amper_type_list
+- { Rtag ($1, $3, List.rev $4) }
+- | name_tag
+- { Rtag ($1, true, []) }
++ name_tag OF opt_ampersand amper_type_list amper_type_pair_list
++ { Rtag ($1, $3, List.rev $4, $5) }
++ | name_tag amper_type_pair_list
++ { Rtag ($1, true, [], $2) }
+ ;
+ opt_ampersand:
+ AMPERSAND { true }
+@@ -1331,6 +1337,11 @@
+ core_type { [$1] }
+ | amper_type_list AMPERSAND core_type { $3 :: $1 }
+ ;
++amper_type_pair_list:
++ AMPERSAND core_type EQUAL core_type amper_type_pair_list
++ { ($2, $4) :: $5 }
++ | /* empty */
++ { [] }
+ opt_present:
+ LBRACKETGREATER name_tag_list RBRACKET { List.rev $2 }
+ | /* empty */ { [] }
+Index: parsing/parsetree.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/parsing/parsetree.mli,v
+retrieving revision 1.42
+diff -u -r1.42 parsetree.mli
+--- parsing/parsetree.mli 23 Mar 2005 03:08:37 -0000 1.42
++++ parsing/parsetree.mli 2 Feb 2006 06:28:32 -0000
+@@ -43,7 +43,7 @@
+ | Pfield_var
+
+ and row_field =
+- Rtag of label * bool * core_type list
++ Rtag of label * bool * core_type list * (core_type * core_type) list
+ | Rinherit of core_type
+
+ (* XXX Type expressions for the class language *)
+@@ -86,7 +86,7 @@
+ | Pexp_let of rec_flag * (pattern * expression) list * expression
+ | Pexp_function of label * expression option * (pattern * expression) list
+ | Pexp_apply of expression * (label * expression) list
+- | Pexp_match of expression * (pattern * expression) list
++ | Pexp_match of expression * (pattern * expression) list * bool
+ | Pexp_try of expression * (pattern * expression) list
+ | Pexp_tuple of expression list
+ | Pexp_construct of Longident.t * expression option * bool
+@@ -111,6 +111,7 @@
+ | Pexp_lazy of expression
+ | Pexp_poly of expression * core_type option
+ | Pexp_object of class_structure
++ | Pexp_multifun of (pattern * expression) list
+
+ (* Value descriptions *)
+
+Index: parsing/printast.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/parsing/printast.ml,v
+retrieving revision 1.29
+diff -u -r1.29 printast.ml
+--- parsing/printast.ml 4 Jan 2006 16:55:50 -0000 1.29
++++ parsing/printast.ml 2 Feb 2006 06:28:32 -0000
+@@ -205,10 +205,14 @@
+ line i ppf "Pexp_apply\n";
+ expression i ppf e;
+ list i label_x_expression ppf l;
+- | Pexp_match (e, l) ->
++ | Pexp_match (e, l, b) ->
+ line i ppf "Pexp_match\n";
+ expression i ppf e;
+ list i pattern_x_expression_case ppf l;
++ bool i ppf b
++ | Pexp_multifun l ->
++ line i ppf "Pexp_multifun\n";
++ list i pattern_x_expression_case ppf l;
+ | Pexp_try (e, l) ->
+ line i ppf "Pexp_try\n";
+ expression i ppf e;
+@@ -653,7 +657,7 @@
+
+ and label_x_bool_x_core_type_list i ppf x =
+ match x with
+- Rtag (l, b, ctl) ->
++ Rtag (l, b, ctl, cstr) ->
+ line i ppf "Rtag \"%s\" %s\n" l (string_of_bool b);
+ list (i+1) core_type ppf ctl
+ | Rinherit (ct) ->
+Index: typing/btype.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/btype.ml,v
+retrieving revision 1.38
+diff -u -r1.38 btype.ml
+--- typing/btype.ml 4 Jan 2006 16:55:50 -0000 1.38
++++ typing/btype.ml 2 Feb 2006 06:28:32 -0000
+@@ -66,16 +66,16 @@
+ Clink r when !r <> Cunknown -> commu_repr !r
+ | c -> c
+
+-let rec row_field_repr_aux tl = function
+- Reither(_, tl', _, {contents = Some fi}) ->
+- row_field_repr_aux (tl@tl') fi
+- | Reither(c, tl', m, r) ->
+- Reither(c, tl@tl', m, r)
++let rec row_field_repr_aux tl tl2 = function
++ Reither(_, tl', _, tl2', {contents = Some fi}) ->
++ row_field_repr_aux (tl@tl') (tl2@tl2') fi
++ | Reither(c, tl', m, tl2', r) ->
++ Reither(c, tl@tl', m, tl2@tl2', r)
+ | Rpresent (Some _) when tl <> [] ->
+ Rpresent (Some (List.hd tl))
+ | fi -> fi
+
+-let row_field_repr fi = row_field_repr_aux [] fi
++let row_field_repr fi = row_field_repr_aux [] [] fi
+
+ let rec rev_concat l ll =
+ match ll with
+@@ -170,7 +170,8 @@
+ (fun (_, fi) ->
+ match row_field_repr fi with
+ | Rpresent(Some ty) -> f ty
+- | Reither(_, tl, _, _) -> List.iter f tl
++ | Reither(_, tl, _, tl2, _) ->
++ List.iter f tl; List.iter (fun (t1,t2) -> f t1; f t2) tl2
+ | _ -> ())
+ row.row_fields;
+ match (repr row.row_more).desc with
+@@ -208,15 +209,17 @@
+ (fun (l, fi) -> l,
+ match row_field_repr fi with
+ | Rpresent(Some ty) -> Rpresent(Some(f ty))
+- | Reither(c, tl, m, e) ->
++ | Reither(c, tl, m, tpl, e) ->
+ let e = if keep then e else ref None in
+ let m = if row.row_fixed then fixed else m in
+ let tl = List.map f tl in
++ let tl1 = List.map (fun (t1,_) -> repr (f t1)) tpl
++ and tl2 = List.map (fun (_,t2) -> repr (f t2)) tpl in
+ bound := List.filter
+ (function {desc=Tconstr(_,[],_)} -> false | _ -> true)
+- (List.map repr tl)
++ (List.map repr tl @ tl1 @ tl2)
+ @ !bound;
+- Reither(c, tl, m, e)
++ Reither(c, tl, m, List.combine tl1 tl2, e)
+ | _ -> fi)
+ row.row_fields in
+ let name =
+Index: typing/ctype.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/ctype.ml,v
+retrieving revision 1.200
+diff -u -r1.200 ctype.ml
+--- typing/ctype.ml 6 Jan 2006 02:16:24 -0000 1.200
++++ typing/ctype.ml 2 Feb 2006 06:28:32 -0000
+@@ -340,7 +340,7 @@
+ let fi = filter_row_fields erase fi in
+ match row_field_repr f with
+ Rabsent -> fi
+- | Reither(_,_,false,e) when erase -> set_row_field e Rabsent; fi
++ | Reither(_,_,false,_,e) when erase -> set_row_field e Rabsent; fi
+ | _ -> p :: fi
+
+ (**************************************)
+@@ -1286,6 +1286,10 @@
+
+ module TypeMap = Map.Make (TypeOps)
+
++
++(* A list of univars which may appear free in a type, but only if generic *)
++let allowed_univars = ref TypeSet.empty
++
+ (* Test the occurence of free univars in a type *)
+ (* that's way too expansive. Must do some kind of cacheing *)
+ let occur_univar env ty =
+@@ -1307,7 +1311,12 @@
+ then
+ match ty.desc with
+ Tunivar ->
+- if not (TypeSet.mem ty bound) then raise (Unify [ty, newgenvar()])
++ if TypeSet.mem ty bound then () else
++ if TypeSet.mem ty !allowed_univars &&
++ (ty.level = generic_level ||
++ ty.level = pivot_level - generic_level)
++ then ()
++ else raise (Unify [ty, newgenvar()])
+ | Tpoly (ty, tyl) ->
+ let bound = List.fold_right TypeSet.add (List.map repr tyl) bound in
+ occur_rec bound ty
+@@ -1393,6 +1402,7 @@
+ with exn -> univar_pairs := old_univars; raise exn
+
+ let univar_pairs = ref []
++let delayed_conditionals = ref []
+
+
+ (*****************)
+@@ -1691,9 +1701,11 @@
+ with Not_found -> (h,l)::hl)
+ (List.map (fun (l,_) -> (hash_variant l, l)) row1.row_fields)
+ (List.map fst r2));
++ let fixed1 = row1.row_fixed || rm1.desc <> Tvar
++ and fixed2 = row2.row_fixed || rm2.desc <> Tvar in
+ let more =
+- if row1.row_fixed then rm1 else
+- if row2.row_fixed then rm2 else
++ if fixed1 then rm1 else
++ if fixed2 then rm2 else
+ newgenvar ()
+ in update_level env (min rm1.level rm2.level) more;
+ let fixed = row1.row_fixed || row2.row_fixed
+@@ -1726,18 +1738,18 @@
+ let bound = row1.row_bound @ row2.row_bound in
+ let row0 = {row_fields = []; row_more = more; row_bound = bound;
+ row_closed = closed; row_fixed = fixed; row_name = name} in
+- let set_more row rest =
++ let set_more row row_fixed rest =
+ let rest =
+ if closed then
+ filter_row_fields row.row_closed rest
+ else rest in
+- if rest <> [] && (row.row_closed || row.row_fixed)
+- || closed && row.row_fixed && not row.row_closed then begin
++ if rest <> [] && (row.row_closed || row_fixed)
++ || closed && row_fixed && not row.row_closed then begin
+ let t1 = mkvariant [] true and t2 = mkvariant rest false in
+ raise (Unify [if row == row1 then (t1,t2) else (t2,t1)])
+ end;
+ let rm = row_more row in
+- if row.row_fixed then
++ if row_fixed then
+ if row0.row_more == rm then () else
+ if rm.desc = Tvar then link_type rm row0.row_more else
+ unify env rm row0.row_more
+@@ -1748,11 +1760,11 @@
+ in
+ let md1 = rm1.desc and md2 = rm2.desc in
+ begin try
+- set_more row1 r2;
+- set_more row2 r1;
++ set_more row1 fixed1 r2;
++ set_more row2 fixed2 r1;
+ List.iter
+ (fun (l,f1,f2) ->
+- try unify_row_field env row1.row_fixed row2.row_fixed l f1 f2
++ try unify_row_field env fixed1 fixed2 row1 row2 l f1 f2
+ with Unify trace ->
+ raise (Unify ((mkvariant [l,f1] true,
+ mkvariant [l,f2] true) :: trace)))
+@@ -1761,13 +1773,13 @@
+ log_type rm1; rm1.desc <- md1; log_type rm2; rm2.desc <- md2; raise exn
+ end
+
+-and unify_row_field env fixed1 fixed2 l f1 f2 =
++and unify_row_field env fixed1 fixed2 row1 row2 l f1 f2 =
+ let f1 = row_field_repr f1 and f2 = row_field_repr f2 in
+ if f1 == f2 then () else
+ match f1, f2 with
+ Rpresent(Some t1), Rpresent(Some t2) -> unify env t1 t2
+ | Rpresent None, Rpresent None -> ()
+- | Reither(c1, tl1, m1, e1), Reither(c2, tl2, m2, e2) ->
++ | Reither(c1, tl1, m1, tp1, e1), Reither(c2, tl2, m2, tp2, e2) ->
+ if e1 == e2 then () else
+ let redo =
+ (m1 || m2) &&
+@@ -1777,32 +1789,70 @@
+ List.iter (unify env t1) tl;
+ !e1 <> None || !e2 <> None
+ end in
+- if redo then unify_row_field env fixed1 fixed2 l f1 f2 else
++ let redo =
++ redo || begin
++ if tp1 = [] && fixed1 then unify_pairs env tp2;
++ if tp2 = [] && fixed2 then unify_pairs env tp1;
++ !e1 <> None || !e2 <> None
++ end
++ in
++ if redo then unify_row_field env fixed1 fixed2 row1 row2 l f1 f2 else
+ let tl1 = List.map repr tl1 and tl2 = List.map repr tl2 in
+ let rec remq tl = function [] -> []
+ | ty :: tl' ->
+ if List.memq ty tl then remq tl tl' else ty :: remq tl tl'
+ in
+ let tl2' = remq tl2 tl1 and tl1' = remq tl1 tl2 in
++ let repr_pairs = List.map (fun (t1,t2) -> repr t1, repr t2) in
++ let tp1 = repr_pairs tp1 and tp2 = repr_pairs tp2 in
++ let rec rempq tp = function [] -> []
++ | (t1,t2 as p) :: tp' ->
++ if List.exists (fun (t1',t2') -> t1==t1' && t2==t2') (tp@tp') then
++ rempq tp tp'
++ else p :: rempq tp tp'
++ in
++ let tp1' =
++ if fixed2 then begin
++ delayed_conditionals :=
++ (!univar_pairs, tp1, l, row2) :: !delayed_conditionals;
++ []
++ end else rempq tp2 tp1
++ and tp2' =
++ if fixed1 then begin
++ delayed_conditionals :=
++ (!univar_pairs, tp2, l, row1) :: !delayed_conditionals;
++ []
++ end else rempq tp1 tp2
++ in
+ let e = ref None in
+- let f1' = Reither(c1 || c2, tl1', m1 || m2, e)
+- and f2' = Reither(c1 || c2, tl2', m1 || m2, e) in
+- set_row_field e1 f1'; set_row_field e2 f2';
+- | Reither(_, _, false, e1), Rabsent -> set_row_field e1 f2
+- | Rabsent, Reither(_, _, false, e2) -> set_row_field e2 f1
++ let f1' = Reither(c1 || c2, tl1', m1 || m2, tp2', e)
++ and f2' = Reither(c1 || c2, tl2', m1 || m2, tp1', e) in
++ set_row_field e1 f1'; set_row_field e2 f2'
++ | Reither(_, _, false, _, e1), Rabsent -> set_row_field e1 f2
++ | Rabsent, Reither(_, _, false, _, e2) -> set_row_field e2 f1
+ | Rabsent, Rabsent -> ()
+- | Reither(false, tl, _, e1), Rpresent(Some t2) when not fixed1 ->
++ | Reither(false, tl, _, tp, e1), Rpresent(Some t2) when not fixed1 ->
+ set_row_field e1 f2;
+- (try List.iter (fun t1 -> unify env t1 t2) tl
++ begin try
++ List.iter (fun t1 -> unify env t1 t2) tl;
++ List.iter (fun (t1,t2) -> unify env t1 t2) tp
++ with exn -> e1 := None; raise exn
++ end
++ | Rpresent(Some t1), Reither(false, tl, _, tp, e2) when not fixed2 ->
++ set_row_field e2 f1;
++ begin try
++ List.iter (unify env t1) tl;
++ List.iter (fun (t1,t2) -> unify env t1 t2) tp
++ with exn -> e2 := None; raise exn
++ end
++ | Reither(true, [], _, tpl, e1), Rpresent None when not fixed1 ->
++ set_row_field e1 f2;
++ (try List.iter (fun (t1,t2) -> unify env t1 t2) tpl
+ with exn -> e1 := None; raise exn)
+- | Rpresent(Some t1), Reither(false, tl, _, e2) when not fixed2 ->
++ | Rpresent None, Reither(true, [], _, tpl, e2) when not fixed2 ->
+ set_row_field e2 f1;
+- (try List.iter (unify env t1) tl
++ (try List.iter (fun (t1,t2) -> unify env t1 t2) tpl
+ with exn -> e2 := None; raise exn)
+- | Reither(true, [], _, e1), Rpresent None when not fixed1 ->
+- set_row_field e1 f2
+- | Rpresent None, Reither(true, [], _, e2) when not fixed2 ->
+- set_row_field e2 f1
+ | _ -> raise (Unify [])
+
+
+@@ -1920,6 +1970,166 @@
+ (* Matching between type schemes *)
+ (***********************************)
+
++(* Forward declaration (order should be reversed...) *)
++let equal' = ref (fun _ -> failwith "Ctype.equal'")
++
++let make_generics_univars tyl =
++ let polyvars = ref TypeSet.empty in
++ let rec make_rec ty =
++ let ty = repr ty in
++ if ty.level = generic_level then begin
++ if ty.desc = Tvar then begin
++ log_type ty;
++ ty.desc <- Tunivar;
++ polyvars := TypeSet.add ty !polyvars
++ end
++ else if ty.desc = Tunivar then set_level ty (generic_level - 1);
++ ty.level <- pivot_level - generic_level;
++ iter_type_expr make_rec ty
++ end
++ in
++ List.iter make_rec tyl;
++ List.iter unmark_type tyl;
++ !polyvars
++
++(* New version of moregeneral, using unification *)
++
++let copy_cond (p,tpl,l,row) =
++ let row =
++ match repr (copy (newgenty (Tvariant row))) with
++ {desc=Tvariant row} -> row
++ | _ -> assert false
++ and pairs =
++ List.map (fun (t1,t2) -> copy t1, copy t2) tpl in
++ (p, pairs, l, row)
++
++let get_row_field l row =
++ try row_field_repr (List.assoc l (row_repr row).row_fields)
++ with Not_found -> Rabsent
++
++let rec check_conditional_list env cdtls pattvars tpls =
++ match cdtls with
++ [] ->
++ let finished =
++ List.for_all (fun (_,t1,t2) -> !equal' env false [t1] [t2]) tpls in
++ if not finished then begin
++ let polyvars = make_generics_univars pattvars in
++ delayed_conditionals := [];
++ allowed_univars := polyvars;
++ List.iter (fun (pairs, ty1, ty2) -> unify_pairs env ty1 ty2 pairs)
++ tpls;
++ check_conditionals env polyvars !delayed_conditionals
++ end
++ | (pairs, tpl1, l, row2 as cond) :: cdtls ->
++ let cont = check_conditional_list env cdtls pattvars in
++ let tpl1 =
++ List.filter (fun (t1,t2) -> not (!equal' env false [t1] [t2])) tpl1 in
++ let included =
++ List.for_all
++ (fun (t1,t2) ->
++ List.exists
++ (fun (_,t1',t2') -> !equal' env false [t1;t2] [t1';t2'])
++ tpls)
++ tpl1 in
++ if included then cont tpls else
++ match get_row_field l row2 with
++ Rpresent _ ->
++ cont (List.map (fun (t1,t2) -> (pairs,t1,t2)) tpl1 @ tpls)
++ | Rabsent -> cont tpls
++ | Reither (c, tl2, _, _, _) ->
++ cont tpls;
++ if c && tl2 <> [] then () (* cannot succeed *) else
++ let (pairs, tpl1, l, row2) = copy_cond cond
++ and tpls = List.map (fun (p,t1,t2) -> p, copy t1, copy t2) tpls
++ and pattvars = List.map copy pattvars
++ and cdtls = List.map copy_cond cdtls in
++ cleanup_types ();
++ let tl2, tpl2, e2 =
++ match get_row_field l row2 with
++ Reither (c, tl2, _, tpl2, e2) -> tl2, tpl2, e2
++ | _ -> assert false
++ in
++ let snap = Btype.snapshot () in
++ let ok =
++ try
++ begin match tl2 with
++ [] ->
++ set_row_field e2 (Rpresent None)
++ | t::tl ->
++ set_row_field e2 (Rpresent (Some t));
++ List.iter (unify env t) tl
++ end;
++ List.iter (fun (t1,t2) -> unify_pairs env t1 t2 pairs) tpl2;
++ true
++ with exn ->
++ Btype.backtrack snap;
++ false
++ in
++ (* This is not [cont] : types have been copied *)
++ if ok then
++ check_conditional_list env cdtls pattvars
++ (List.map (fun (t1,t2) -> (pairs,t1,t2)) tpl1 @ tpls)
++
++and check_conditionals env polyvars cdtls =
++ let cdtls = List.map copy_cond cdtls in
++ let pattvars = ref [] in
++ TypeSet.iter
++ (fun ty ->
++ let ty = repr ty in
++ match ty.desc with
++ Tsubst ty ->
++ let ty = repr ty in
++ begin match ty.desc with
++ Tunivar ->
++ log_type ty;
++ ty.desc <- Tvar;
++ pattvars := ty :: !pattvars
++ | Ttuple [tv;_] ->
++ if tv.desc = Tunivar then
++ (log_type tv; tv.desc <- Tvar; pattvars := ty :: !pattvars)
++ else if tv.desc <> Tvar then assert false
++ | Tvar -> ()
++ | _ -> assert false
++ end
++ | _ -> ())
++ polyvars;
++ cleanup_types ();
++ check_conditional_list env cdtls !pattvars []
++
++
++(* Must empty univar_pairs first *)
++let unify_poly env polyvars subj patt =
++ let old_level = !current_level in
++ current_level := generic_level;
++ delayed_conditionals := [];
++ allowed_univars := polyvars;
++ try
++ unify env subj patt;
++ check_conditionals env polyvars !delayed_conditionals;
++ current_level := old_level;
++ allowed_univars := TypeSet.empty;
++ delayed_conditionals := []
++ with exn ->
++ current_level := old_level;
++ allowed_univars := TypeSet.empty;
++ delayed_conditionals := [];
++ raise exn
++
++let moregeneral env _ subj patt =
++ let old_level = !current_level in
++ current_level := generic_level;
++ let subj = instance subj
++ and patt = instance patt in
++ let polyvars = make_generics_univars [patt] in
++ current_level := old_level;
++ let snap = Btype.snapshot () in
++ try
++ unify_poly env polyvars subj patt;
++ true
++ with Unify _ ->
++ Btype.backtrack snap;
++ false
++
+ (*
+ Update the level of [ty]. First check that the levels of generic
+ variables from the subject are not lowered.
+@@ -2072,35 +2282,101 @@
+ Rpresent(Some t1), Rpresent(Some t2) ->
+ moregen inst_nongen type_pairs env t1 t2
+ | Rpresent None, Rpresent None -> ()
+- | Reither(false, tl1, _, e1), Rpresent(Some t2) when not univ ->
++ | Reither(false, tl1, _, [], e1), Rpresent(Some t2) when not univ ->
+ set_row_field e1 f2;
+ List.iter (fun t1 -> moregen inst_nongen type_pairs env t1 t2) tl1
+- | Reither(c1, tl1, _, e1), Reither(c2, tl2, m2, e2) ->
++ | Reither(c1, tl1, _, tpl1, e1), Reither(c2, tl2, m2, tpl2, e2) ->
+ if e1 != e2 then begin
+ if c1 && not c2 then raise(Unify []);
+- set_row_field e1 (Reither (c2, [], m2, e2));
+- if List.length tl1 = List.length tl2 then
+- List.iter2 (moregen inst_nongen type_pairs env) tl1 tl2
+- else match tl2 with
+- t2 :: _ ->
++ let tpl' = if tpl1 = [] then tpl2 else [] in
++ set_row_field e1 (Reither (c2, [], m2, tpl', e2));
++ begin match tl2 with
++ [t2] ->
+ List.iter (fun t1 -> moregen inst_nongen type_pairs env t1 t2)
+ tl1
+- | [] ->
+- if tl1 <> [] then raise (Unify [])
++ | _ ->
++ if List.length tl1 <> List.length tl2 then raise (Unify []);
++ List.iter2 (moregen inst_nongen type_pairs env) tl1 tl2
++ end;
++ if tpl1 <> [] then
++ delayed_conditionals :=
++ (!univar_pairs, tpl1, l, row2) :: !delayed_conditionals
+ end
+- | Reither(true, [], _, e1), Rpresent None when not univ ->
++ | Reither(true, [], _, [], e1), Rpresent None when not univ ->
+ set_row_field e1 f2
+- | Reither(_, _, _, e1), Rabsent when not univ ->
++ | Reither(_, _, _, [], e1), Rabsent when not univ ->
+ set_row_field e1 f2
+ | Rabsent, Rabsent -> ()
+ | _ -> raise (Unify []))
+ pairs
+
++let check_conditional env (pairs, tpl1, l, row2) tpls cont =
++ let tpl1 =
++ List.filter (fun (t1,t2) -> not (!equal' env false [t1] [t2])) tpl1 in
++ let included =
++ List.for_all
++ (fun (t1,t2) ->
++ List.exists (fun (t1',t2') -> !equal' env false [t1;t2] [t1';t2'])
++ tpls)
++ tpl1 in
++ if tpl1 = [] || included then cont tpls else
++ match get_row_field l row2 with
++ Rpresent _ -> cont (tpl1 @ tpls)
++ | Rabsent -> cont tpls
++ | Reither (c, tl2, _, tpl2, e2) ->
++ if not c || tl2 = [] then begin
++ let snap = Btype.snapshot () in
++ let ok =
++ try
++ begin match tl2 with
++ [] ->
++ set_row_field e2 (Rpresent None)
++ | t::tl ->
++ set_row_field e2 (Rpresent (Some t));
++ List.iter (unify env t) tl
++ end;
++ List.iter (fun (t1,t2) -> unify_pairs env t1 t2 pairs) tpl2;
++ true
++ with Unify _ -> false
++ in
++ if ok then cont (tpl1 @ tpls);
++ Btype.backtrack snap
++ end;
++ cont tpls
++
++let rec check_conditionals inst_nongen env cdtls tpls =
++ match cdtls with
++ [] ->
++ let tpls =
++ List.filter (fun (t1,t2) -> not (!equal' env false [t1] [t2])) tpls in
++ if tpls = [] then () else begin
++ delayed_conditionals := [];
++ let tl1, tl2 = List.split tpls in
++ let type_pairs = TypePairs.create 13 in
++ List.iter2 (moregen false type_pairs env) tl2 tl1;
++ check_conditionals inst_nongen env !delayed_conditionals []
++ end
++ | cdtl :: cdtls ->
++ check_conditional env cdtl tpls
++ (check_conditionals inst_nongen env cdtls)
++
++
+ (* Must empty univar_pairs first *)
+ let moregen inst_nongen type_pairs env patt subj =
+ univar_pairs := [];
+- moregen inst_nongen type_pairs env patt subj
++ delayed_conditionals := [];
++ try
++ moregen inst_nongen type_pairs env patt subj;
++ check_conditionals inst_nongen env !delayed_conditionals [];
++ univar_pairs := [];
++ delayed_conditionals := []
++ with exn ->
++ univar_pairs := [];
++ delayed_conditionals := [];
++ raise exn
++
+
++(* old implementation
+ (*
+ Non-generic variable can be instanciated only if [inst_nongen] is
+ true. So, [inst_nongen] should be set to false if the subject might
+@@ -2128,6 +2404,7 @@
+ in
+ current_level := old_level;
+ res
++*)
+
+
+ (* Alternative approach: "rigidify" a type scheme,
+@@ -2296,30 +2573,36 @@
+ {desc=Tvariant row2} -> eqtype_row rename type_pairs subst env row1 row2
+ | _ -> raise Cannot_expand
+ with Cannot_expand ->
++ let eqtype_rec = eqtype rename type_pairs subst env in
+ let row1 = row_repr row1 and row2 = row_repr row2 in
+ let r1, r2, pairs = merge_row_fields row1.row_fields row2.row_fields in
+ if row1.row_closed <> row2.row_closed
+ || not row1.row_closed && (r1 <> [] || r2 <> [])
+ || filter_row_fields false (r1 @ r2) <> []
+ then raise (Unify []);
+- if not (static_row row1) then
+- eqtype rename type_pairs subst env row1.row_more row2.row_more;
++ if not (static_row row1) then eqtype_rec row1.row_more row2.row_more;
+ List.iter
+ (fun (_,f1,f2) ->
+ match row_field_repr f1, row_field_repr f2 with
+ Rpresent(Some t1), Rpresent(Some t2) ->
+- eqtype rename type_pairs subst env t1 t2
+- | Reither(true, [], _, _), Reither(true, [], _, _) ->
+- ()
+- | Reither(false, t1::tl1, _, _), Reither(false, t2::tl2, _, _) ->
+- eqtype rename type_pairs subst env t1 t2;
++ eqtype_rec t1 t2
++ | Reither(true, [], _, tp1, _), Reither(true, [], _, tp2, _) ->
++ List.iter2
++ (fun (t1,t1') (t2,t2') -> eqtype_rec t1 t2; eqtype_rec t1' t2')
++ tp1 tp2
++ | Reither(false, t1::tl1, _, tpl1, _),
++ Reither(false, t2::tl2, _, tpl2, _) ->
++ eqtype_rec t1 t2;
++ List.iter2
++ (fun (t1,t1') (t2,t2') -> eqtype_rec t1 t2; eqtype_rec t1' t2')
++ tpl1 tpl2;
+ if List.length tl1 = List.length tl2 then
+ (* if same length allow different types (meaning?) *)
+- List.iter2 (eqtype rename type_pairs subst env) tl1 tl2
++ List.iter2 eqtype_rec tl1 tl2
+ else begin
+ (* otherwise everything must be equal *)
+- List.iter (eqtype rename type_pairs subst env t1) tl2;
+- List.iter (fun t1 -> eqtype rename type_pairs subst env t1 t2) tl1
++ List.iter (eqtype_rec t1) tl2;
++ List.iter (fun t1 -> eqtype_rec t1 t2) tl1
+ end
+ | Rpresent None, Rpresent None -> ()
+ | Rabsent, Rabsent -> ()
+@@ -2334,6 +2617,8 @@
+ with
+ Unify _ -> false
+
++let () = equal' := equal
++
+ (* Must empty univar_pairs first *)
+ let eqtype rename type_pairs subst env t1 t2 =
+ univar_pairs := [];
+@@ -2770,14 +3055,14 @@
+ (fun (l,f as orig) -> match row_field_repr f with
+ Rpresent None ->
+ if posi then
+- (l, Reither(true, [], false, ref None)), Unchanged
++ (l, Reither(true, [], false, [], ref None)), Unchanged
+ else
+ orig, Unchanged
+ | Rpresent(Some t) ->
+ let (t', c) = build_subtype env visited loops posi level' t in
+ if posi && level > 0 then begin
+ bound := t' :: !bound;
+- (l, Reither(false, [t'], false, ref None)), c
++ (l, Reither(false, [t'], false, [], ref None)), c
+ end else
+ (l, Rpresent(Some t')), c
+ | _ -> assert false)
+@@ -2960,11 +3245,11 @@
+ List.fold_left
+ (fun cstrs (_,f1,f2) ->
+ match row_field_repr f1, row_field_repr f2 with
+- (Rpresent None|Reither(true,_,_,_)), Rpresent None ->
++ (Rpresent None|Reither(true,_,_,[],_)), Rpresent None ->
+ cstrs
+ | Rpresent(Some t1), Rpresent(Some t2) ->
+ subtype_rec env ((t1, t2)::trace) t1 t2 cstrs
+- | Reither(false, t1::_, _, _), Rpresent(Some t2) ->
++ | Reither(false, t1::_, _, [], _), Rpresent(Some t2) ->
+ subtype_rec env ((t1, t2)::trace) t1 t2 cstrs
+ | Rabsent, _ -> cstrs
+ | _ -> raise Exit)
+@@ -2977,11 +3262,11 @@
+ (fun cstrs (_,f1,f2) ->
+ match row_field_repr f1, row_field_repr f2 with
+ Rpresent None, Rpresent None
+- | Reither(true,[],_,_), Reither(true,[],_,_)
++ | Reither(true,[],_,[],_), Reither(true,[],_,[],_)
+ | Rabsent, Rabsent ->
+ cstrs
+ | Rpresent(Some t1), Rpresent(Some t2)
+- | Reither(false,[t1],_,_), Reither(false,[t2],_,_) ->
++ | Reither(false,[t1],_,[],_), Reither(false,[t2],_,[],_) ->
+ subtype_rec env ((t1, t2)::trace) t1 t2 cstrs
+ | _ -> raise Exit)
+ cstrs pairs
+@@ -3079,16 +3364,26 @@
+ let fields = List.map
+ (fun (l,f) ->
+ let f = row_field_repr f in l,
+- match f with Reither(b, ty::(_::_ as tyl), m, e) ->
+- let tyl' =
+- List.fold_left
+- (fun tyl ty ->
+- if List.exists (fun ty' -> equal env false [ty] [ty']) tyl
+- then tyl else ty::tyl)
+- [ty] tyl
++ match f with Reither(b, tyl, m, tp, e) ->
++ let rem_dbl eq l =
++ List.rev
++ (List.fold_left
++ (fun xs x -> if List.exists (eq x) xs then xs else x::xs)
++ [] l)
++ in
++ let tyl' = rem_dbl (fun t1 t2 -> equal env false [t1] [t2]) tyl
++ and tp' =
++ List.filter
++ (fun (ty1,ty2) -> not (equal env false [ty1] [ty2])) tp
++ in
++ let tp' =
++ rem_dbl
++ (fun (t1,t2) (t1',t2') -> equal env false [t1;t2] [t1';t2'])
++ tp'
+ in
+- if List.length tyl' <= List.length tyl then
+- let f = Reither(b, List.rev tyl', m, ref None) in
++ if List.length tyl' < List.length tyl
++ || List.length tp' < List.length tp then
++ let f = Reither(b, tyl', m, tp', ref None) in
+ set_row_field e f;
+ f
+ else f
+@@ -3344,9 +3639,9 @@
+ List.iter
+ (fun (l,fi) ->
+ match row_field_repr fi with
+- Reither (c, t1::(_::_ as tl), m, e) ->
++ Reither (c, t1::(_::_ as tl), m, tp, e) ->
+ List.iter (unify env t1) tl;
+- set_row_field e (Reither (c, [t1], m, ref None))
++ set_row_field e (Reither (c, [t1], m, tp, ref None))
+ | _ ->
+ ())
+ row.row_fields;
+Index: typing/includecore.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/includecore.ml,v
+retrieving revision 1.32
+diff -u -r1.32 includecore.ml
+--- typing/includecore.ml 8 Aug 2005 05:40:52 -0000 1.32
++++ typing/includecore.ml 2 Feb 2006 06:28:32 -0000
+@@ -71,10 +71,10 @@
+ (fun (_, f1, f2) ->
+ match Btype.row_field_repr f1, Btype.row_field_repr f2 with
+ Rpresent(Some t1),
+- (Rpresent(Some t2) | Reither(false, [t2], _, _)) ->
++ (Rpresent(Some t2) | Reither(false,[t2],_,[],_)) ->
+ to_equal := (t1,t2) :: !to_equal; true
+- | Rpresent None, (Rpresent None | Reither(true, [], _, _)) -> true
+- | Reither(c1,tl1,_,_), Reither(c2,tl2,_,_)
++ | Rpresent None, (Rpresent None | Reither(true,[],_,[],_)) -> true
++ | Reither(c1,tl1,_,[],_), Reither(c2,tl2,_,[],_)
+ when List.length tl1 = List.length tl2 && c1 = c2 ->
+ to_equal := List.combine tl1 tl2 @ !to_equal; true
+ | Rabsent, (Reither _ | Rabsent) -> true
+Index: typing/oprint.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/oprint.ml,v
+retrieving revision 1.22
+diff -u -r1.22 oprint.ml
+--- typing/oprint.ml 23 Mar 2005 03:08:37 -0000 1.22
++++ typing/oprint.ml 2 Feb 2006 06:28:33 -0000
+@@ -223,14 +223,18 @@
+ print_fields rest ppf []
+ | (s, t) :: l ->
+ fprintf ppf "%s : %a;@ %a" s print_out_type t (print_fields rest) l
+-and print_row_field ppf (l, opt_amp, tyl) =
++and print_row_field ppf (l, opt_amp, tyl, tpl) =
+ let pr_of ppf =
+ if opt_amp then fprintf ppf " of@ &@ "
+ else if tyl <> [] then fprintf ppf " of@ "
+- else fprintf ppf ""
+- in
+- fprintf ppf "@[<hv 2>`%s%t%a@]" l pr_of (print_typlist print_out_type " &")
+- tyl
++ and pr_tp ppf (t1,t2) =
++ fprintf ppf "@[<hv 2>%a =@ %a@]"
++ print_out_type t1
++ print_out_type t2
++ in
++ fprintf ppf "@[<hv 2>`%s%t%a%a@]" l pr_of
++ (print_typlist print_out_type " &") tyl
++ (print_list_init pr_tp (fun ppf -> fprintf ppf " &@ ")) tpl
+ and print_typlist print_elem sep ppf =
+ function
+ [] -> ()
+Index: typing/outcometree.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/outcometree.mli,v
+retrieving revision 1.14
+diff -u -r1.14 outcometree.mli
+--- typing/outcometree.mli 23 Mar 2005 03:08:37 -0000 1.14
++++ typing/outcometree.mli 2 Feb 2006 06:28:33 -0000
+@@ -61,7 +61,8 @@
+ bool * out_variant * bool * (string list) option
+ | Otyp_poly of string list * out_type
+ and out_variant =
+- | Ovar_fields of (string * bool * out_type list) list
++ | Ovar_fields of
++ (string * bool * out_type list * (out_type * out_type) list ) list
+ | Ovar_name of out_ident * out_type list
+
+ type out_class_type =
+Index: typing/parmatch.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/parmatch.ml,v
+retrieving revision 1.70
+diff -u -r1.70 parmatch.ml
+--- typing/parmatch.ml 24 Mar 2005 17:20:54 -0000 1.70
++++ typing/parmatch.ml 2 Feb 2006 06:28:33 -0000
+@@ -568,11 +568,11 @@
+ List.fold_left
+ (fun nm (tag,f) ->
+ match Btype.row_field_repr f with
+- | Reither(_, _, false, e) ->
++ | Reither(_, _, false, _, e) ->
+ (* m=false means that this tag is not explicitly matched *)
+ Btype.set_row_field e Rabsent;
+ None
+- | Rabsent | Reither (_, _, true, _) | Rpresent _ -> nm)
++ | Rabsent | Reither (_, _, true, _, _) | Rpresent _ -> nm)
+ row.row_name row.row_fields in
+ if not row.row_closed || nm != row.row_name then begin
+ (* this unification cannot fail *)
+@@ -605,8 +605,8 @@
+ List.for_all
+ (fun (tag,f) ->
+ match Btype.row_field_repr f with
+- Rabsent | Reither(_, _, false, _) -> true
+- | Reither (_, _, true, _)
++ Rabsent | Reither(_, _, false, _, _) -> true
++ | Reither (_, _, true, _, _)
+ (* m=true, do not discard matched tags, rather warn *)
+ | Rpresent _ -> List.mem tag fields)
+ row.row_fields
+@@ -739,7 +739,7 @@
+ match Btype.row_field_repr f with
+ Rabsent (* | Reither _ *) -> others
+ (* This one is called after erasing pattern info *)
+- | Reither (c, _, _, _) -> make_other_pat tag c :: others
++ | Reither (c, _, _, _, _) -> make_other_pat tag c :: others
+ | Rpresent arg -> make_other_pat tag (arg = None) :: others)
+ [] row.row_fields
+ with
+Index: typing/printtyp.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/printtyp.ml,v
+retrieving revision 1.140
+diff -u -r1.140 printtyp.ml
+--- typing/printtyp.ml 4 Jan 2006 16:55:50 -0000 1.140
++++ typing/printtyp.ml 2 Feb 2006 06:28:33 -0000
+@@ -157,9 +157,12 @@
+ and raw_field ppf = function
+ Rpresent None -> fprintf ppf "Rpresent None"
+ | Rpresent (Some t) -> fprintf ppf "@[<1>Rpresent(Some@,%a)@]" raw_type t
+- | Reither (c,tl,m,e) ->
+- fprintf ppf "@[<hov1>Reither(%b,@,%a,@,%b,@,@[<1>ref%t@])@]" c
+- raw_type_list tl m
++ | Reither (c,tl,m,tpl,e) ->
++ fprintf ppf "@[<hov1>Reither(%b,@,%a,@,%b,@,%a,@,@[<1>ref%t@])@]"
++ c raw_type_list tl m
++ (raw_list
++ (fun ppf (t1,t2) ->
++ fprintf ppf "@[%a,@,%a@]" raw_type t1 raw_type t2)) tpl
+ (fun ppf ->
+ match !e with None -> fprintf ppf " None"
+ | Some f -> fprintf ppf "@,@[<1>(%a)@]" raw_field f)
+@@ -219,8 +222,9 @@
+ List.for_all
+ (fun (_, f) ->
+ match row_field_repr f with
+- | Reither(c, l, _, _) ->
+- row.row_closed && if c then l = [] else List.length l = 1
++ | Reither(c, l, _, pl, _) ->
++ row.row_closed && pl = [] &&
++ if c then l = [] else List.length l = 1
+ | _ -> true)
+ row.row_fields
+
+@@ -392,13 +396,16 @@
+
+ and tree_of_row_field sch (l, f) =
+ match row_field_repr f with
+- | Rpresent None | Reither(true, [], _, _) -> (l, false, [])
+- | Rpresent(Some ty) -> (l, false, [tree_of_typexp sch ty])
+- | Reither(c, tyl, _, _) ->
+- if c (* contradiction: un constructeur constant qui a un argument *)
+- then (l, true, tree_of_typlist sch tyl)
+- else (l, false, tree_of_typlist sch tyl)
+- | Rabsent -> (l, false, [] (* une erreur, en fait *))
++ | Rpresent None | Reither(true, [], _, [], _) -> (l, false, [], [])
++ | Rpresent(Some ty) -> (l, false, [tree_of_typexp sch ty], [])
++ | Reither(c, tyl, _, tpl, _) ->
++ let ttpl =
++ List.map
++ (fun (t1,t2) -> tree_of_typexp sch t1, tree_of_typexp sch t2)
++ tpl
++ in
++ (l, c && tpl = [], tree_of_typlist sch tyl, ttpl)
++ | Rabsent -> (l, false, [], [] (* une erreur, en fait *))
+
+ and tree_of_typlist sch tyl =
+ List.map (tree_of_typexp sch) tyl
+Index: typing/typeclass.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/typeclass.ml,v
+retrieving revision 1.85
+diff -u -r1.85 typeclass.ml
+--- typing/typeclass.ml 22 Jul 2005 06:42:36 -0000 1.85
++++ typing/typeclass.ml 2 Feb 2006 06:28:33 -0000
+@@ -727,7 +727,7 @@
+ {pexp_loc = loc; pexp_desc =
+ Pexp_match({pexp_loc = loc; pexp_desc =
+ Pexp_ident(Longident.Lident"*opt*")},
+- scases)} in
++ scases, false)} in
+ let sfun =
+ {pcl_loc = scl.pcl_loc; pcl_desc =
+ Pcl_fun(l, None, {ppat_loc = loc; ppat_desc = Ppat_var"*opt*"},
+Index: typing/typecore.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/typecore.ml,v
+retrieving revision 1.178
+diff -u -r1.178 typecore.ml
+--- typing/typecore.ml 6 Jan 2006 02:25:37 -0000 1.178
++++ typing/typecore.ml 2 Feb 2006 06:28:33 -0000
+@@ -156,15 +156,21 @@
+ let field = row_field tag row in
+ begin match field with
+ | Rabsent -> assert false
+- | Reither (true, [], _, e) when not row.row_closed ->
+- set_row_field e (Rpresent None)
+- | Reither (false, ty::tl, _, e) when not row.row_closed ->
++ | Reither (true, [], _, tpl, e) when not row.row_closed ->
++ set_row_field e (Rpresent None);
++ List.iter
++ (fun (t1,t2) -> unify_pat pat.pat_env {pat with pat_type=t1} t2)
++ tpl
++ | Reither (false, ty::tl, _, tpl, e) when not row.row_closed ->
+ set_row_field e (Rpresent (Some ty));
++ List.iter
++ (fun (t1,t2) -> unify_pat pat.pat_env {pat with pat_type=t1} t2)
++ tpl;
+ begin match opat with None -> assert false
+ | Some pat -> List.iter (unify_pat pat.pat_env pat) (ty::tl)
+ end
+- | Reither (c, l, true, e) when not row.row_fixed ->
+- set_row_field e (Reither (c, [], false, ref None))
++ | Reither (c, l, true, tpl, e) when not row.row_fixed ->
++ set_row_field e (Reither (c, [], false, [], ref None))
+ | _ -> ()
+ end;
+ (* Force check of well-formedness *)
+@@ -307,13 +313,13 @@
+ match row_field_repr f with
+ Rpresent None ->
+ (l,None) :: pats,
+- (l, Reither(true,[], true, ref None)) :: fields
++ (l, Reither(true,[], true, [], ref None)) :: fields
+ | Rpresent (Some ty) ->
+ bound := ty :: !bound;
+ (l, Some {pat_desc=Tpat_any; pat_loc=Location.none; pat_env=env;
+ pat_type=ty})
+ :: pats,
+- (l, Reither(false, [ty], true, ref None)) :: fields
++ (l, Reither(false, [ty], true, [], ref None)) :: fields
+ | _ -> pats, fields)
+ ([],[]) fields in
+ let row =
+@@ -337,6 +343,18 @@
+ pat pats in
+ rp { r with pat_loc = loc }
+
++let rec flatten_or_pat pat =
++ match pat.pat_desc with
++ Tpat_or (p1, p2, _) ->
++ flatten_or_pat p1 @ flatten_or_pat p2
++ | _ ->
++ [pat]
++
++let all_variants pat =
++ List.for_all
++ (function {pat_desc=Tpat_variant _} -> true | _ -> false)
++ (flatten_or_pat pat)
++
+ let rec find_record_qual = function
+ | [] -> None
+ | (Longident.Ldot (modname, _), _) :: _ -> Some modname
+@@ -423,7 +441,7 @@
+ let arg = may_map (type_pat env) sarg in
+ let arg_type = match arg with None -> [] | Some arg -> [arg.pat_type] in
+ let row = { row_fields =
+- [l, Reither(arg = None, arg_type, true, ref None)];
++ [l, Reither(arg = None, arg_type, true, [], ref None)];
+ row_bound = arg_type;
+ row_closed = false;
+ row_more = newvar ();
+@@ -788,7 +806,7 @@
+ newty (Tarrow(p, type_option (newvar ()), type_approx env e, Cok))
+ | Pexp_function (p,_,(_,e)::_) ->
+ newty (Tarrow(p, newvar (), type_approx env e, Cok))
+- | Pexp_match (_, (_,e)::_) -> type_approx env e
++ | Pexp_match (_, (_,e)::_, false) -> type_approx env e
+ | Pexp_try (e, _) -> type_approx env e
+ | Pexp_tuple l -> newty (Ttuple(List.map (type_approx env) l))
+ | Pexp_ifthenelse (_,e,_) -> type_approx env e
+@@ -939,17 +957,26 @@
+ exp_loc = sexp.pexp_loc;
+ exp_type = ty_res;
+ exp_env = env }
+- | Pexp_match(sarg, caselist) ->
++ | Pexp_match(sarg, caselist, multi) ->
+ let arg = type_exp env sarg in
+ let ty_res = newvar() in
+ let cases, partial =
+- type_cases env arg.exp_type ty_res (Some sexp.pexp_loc) caselist
++ type_cases env arg.exp_type ty_res (Some sexp.pexp_loc) caselist ~multi
+ in
+ re {
+ exp_desc = Texp_match(arg, cases, partial);
+ exp_loc = sexp.pexp_loc;
+ exp_type = ty_res;
+ exp_env = env }
++ | Pexp_multifun caselist ->
++ let ty_arg = newvar() and ty_res = newvar() in
++ let cases, partial =
++ type_cases env ty_arg ty_res (Some sexp.pexp_loc) caselist ~multi:true
++ in
++ { exp_desc = Texp_function (cases, partial);
++ exp_loc = sexp.pexp_loc;
++ exp_type = newty (Tarrow ("", ty_arg, ty_res, Cok));
++ exp_env = env }
+ | Pexp_try(sbody, caselist) ->
+ let body = type_exp env sbody in
+ let cases, _ =
+@@ -1758,7 +1785,7 @@
+ {pexp_loc = loc; pexp_desc =
+ Pexp_match({pexp_loc = loc; pexp_desc =
+ Pexp_ident(Longident.Lident"*opt*")},
+- scases)} in
++ scases, false)} in
+ let sfun =
+ {pexp_loc = sexp.pexp_loc; pexp_desc =
+ Pexp_function(l, None,[{ppat_loc = loc; ppat_desc = Ppat_var"*opt*"},
+@@ -1864,7 +1891,8 @@
+
+ (* Typing of match cases *)
+
+-and type_cases ?in_function env ty_arg ty_res partial_loc caselist =
++and type_cases ?in_function ?(multi=false)
++ env ty_arg ty_res partial_loc caselist =
+ let ty_arg' = newvar () in
+ let pattern_force = ref [] in
+ let pat_env_list =
+@@ -1898,10 +1926,64 @@
+ let cases =
+ List.map2
+ (fun (pat, ext_env) (spat, sexp) ->
+- let exp = type_expect ?in_function ext_env sexp ty_res in
+- (pat, exp))
+- pat_env_list caselist
+- in
++ let add_variant_case lab row ty_res ty_res' =
++ let fi = List.assoc lab (row_repr row).row_fields in
++ begin match row_field_repr fi with
++ Reither (c, _, m, _, e) ->
++ let row' =
++ { row_fields =
++ [lab, Reither(c,[],false,[ty_res,ty_res'], ref None)];
++ row_more = newvar (); row_bound = [ty_res; ty_res'];
++ row_closed = false; row_fixed = false; row_name = None }
++ in
++ unify_pat ext_env {pat with pat_type= newty (Tvariant row)}
++ (newty (Tvariant row'))
++ | _ ->
++ unify_exp ext_env
++ { exp_desc = Texp_tuple []; exp_type = ty_res;
++ exp_env = ext_env; exp_loc = sexp.pexp_loc }
++ ty_res'
++ end
++ in
++ pat,
++ match pat.pat_desc with
++ _ when multi && all_variants pat ->
++ let ty_res' = newvar () in
++ List.iter
++ (function {pat_desc=Tpat_variant(lab,_,row)} ->
++ add_variant_case lab row ty_res ty_res'
++ | _ -> assert false)
++ (flatten_or_pat pat);
++ type_expect ?in_function ext_env sexp ty_res'
++ | Tpat_alias (p, id) when multi && all_variants p ->
++ let vd = Env.find_value (Path.Pident id) ext_env in
++ let row' =
++ match repr vd.val_type with
++ {desc=Tvariant row'} -> row'
++ | _ -> assert false
++ in
++ begin_def ();
++ let tv = newvar () in
++ let env = Env.add_value id {vd with val_type=tv} ext_env in
++ let exp = type_exp env sexp in
++ end_def ();
++ generalize exp.exp_type;
++ generalize tv;
++ List.iter
++ (function {pat_desc=Tpat_variant(lab,_,row)}, [tv'; ty'] ->
++ let fi' = List.assoc lab (row_repr row').row_fields in
++ let row' =
++ {row' with row_fields=[lab,fi']; row_more=newvar()} in
++ unify_pat ext_env {pat with pat_type=tv'}
++ (newty (Tvariant row'));
++ add_variant_case lab row ty_res ty'
++ | _ -> assert false)
++ (List.map (fun p -> p, instance_list [tv; exp.exp_type])
++ (flatten_or_pat p));
++ {exp with exp_type = instance exp.exp_type}
++ | _ ->
++ type_expect ?in_function ext_env sexp ty_res)
++ pat_env_list caselist in
+ let partial =
+ match partial_loc with None -> Partial
+ | Some loc -> Parmatch.check_partial loc cases
+Index: typing/typedecl.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/typedecl.ml,v
+retrieving revision 1.75
+diff -u -r1.75 typedecl.ml
+--- typing/typedecl.ml 16 Aug 2005 00:48:56 -0000 1.75
++++ typing/typedecl.ml 2 Feb 2006 06:28:33 -0000
+@@ -432,8 +432,10 @@
+ match Btype.row_field_repr f with
+ Rpresent (Some ty) ->
+ compute_same ty
+- | Reither (_, tyl, _, _) ->
+- List.iter compute_same tyl
++ | Reither (_, tyl, _, tpl, _) ->
++ List.iter compute_same tyl;
++ List.iter (compute_variance_rec true true true)
++ (List.map fst tpl @ List.map snd tpl)
+ | _ -> ())
+ row.row_fields;
+ compute_same row.row_more
+@@ -856,8 +858,8 @@
+ explain row.row_fields
+ (fun (l,f) -> match Btype.row_field_repr f with
+ Rpresent (Some t) -> t
+- | Reither (_,[t],_,_) -> t
+- | Reither (_,tl,_,_) -> Btype.newgenty (Ttuple tl)
++ | Reither (_,[t],_,_,_) -> t
++ | Reither (_,tl,_,_,_) -> Btype.newgenty (Ttuple tl)
+ | _ -> Btype.newgenty (Ttuple[]))
+ "case" (fun (lab,_) -> "`" ^ lab ^ " of ")
+ | _ -> trivial ty'
+Index: typing/types.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/types.ml,v
+retrieving revision 1.25
+diff -u -r1.25 types.ml
+--- typing/types.ml 9 Dec 2004 12:40:53 -0000 1.25
++++ typing/types.ml 2 Feb 2006 06:28:33 -0000
+@@ -48,7 +48,9 @@
+
+ and row_field =
+ Rpresent of type_expr option
+- | Reither of bool * type_expr list * bool * row_field option ref
++ | Reither of
++ bool * type_expr list * bool *
++ (type_expr * type_expr) list * row_field option ref
+ | Rabsent
+
+ and abbrev_memo =
+Index: typing/types.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/types.mli,v
+retrieving revision 1.25
+diff -u -r1.25 types.mli
+--- typing/types.mli 9 Dec 2004 12:40:53 -0000 1.25
++++ typing/types.mli 2 Feb 2006 06:28:33 -0000
+@@ -47,7 +47,9 @@
+
+ and row_field =
+ Rpresent of type_expr option
+- | Reither of bool * type_expr list * bool * row_field option ref
++ | Reither of
++ bool * type_expr list * bool *
++ (type_expr * type_expr) list * row_field option ref
+ (* 1st true denotes a constant constructor *)
+ (* 2nd true denotes a tag in a pattern matching, and
+ is erased later *)
+Index: typing/typetexp.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/typetexp.ml,v
+retrieving revision 1.54
+diff -u -r1.54 typetexp.ml
+--- typing/typetexp.ml 22 Jul 2005 06:42:36 -0000 1.54
++++ typing/typetexp.ml 2 Feb 2006 06:28:33 -0000
+@@ -207,9 +207,9 @@
+ match Btype.row_field_repr f with
+ | Rpresent (Some ty) ->
+ bound := ty :: !bound;
+- Reither(false, [ty], false, ref None)
++ Reither(false, [ty], false, [], ref None)
+ | Rpresent None ->
+- Reither (true, [], false, ref None)
++ Reither (true, [], false, [], ref None)
+ | _ -> f)
+ row.row_fields
+ in
+@@ -273,13 +273,16 @@
+ (l, f) :: fields
+ in
+ let rec add_field fields = function
+- Rtag (l, c, stl) ->
++ Rtag (l, c, stl, stpl) ->
+ name := None;
+ let f = match present with
+ Some present when not (List.mem l present) ->
+- let tl = List.map (transl_type env policy) stl in
+- bound := tl @ !bound;
+- Reither(c, tl, false, ref None)
++ let transl_list = List.map (transl_type env policy) in
++ let tl = transl_list stl in
++ let stpl1, stpl2 = List.split stpl in
++ let tpl1 = transl_list stpl1 and tpl2 = transl_list stpl2 in
++ bound := tl @ tpl1 @ tpl2 @ !bound;
++ Reither(c, tl, false, List.combine tpl1 tpl2, ref None)
+ | _ ->
+ if List.length stl > 1 || c && stl <> [] then
+ raise(Error(styp.ptyp_loc, Present_has_conjunction l));
+@@ -311,9 +314,9 @@
+ begin match f with
+ Rpresent(Some ty) ->
+ bound := ty :: !bound;
+- Reither(false, [ty], false, ref None)
++ Reither(false, [ty], false, [], ref None)
+ | Rpresent None ->
+- Reither(true, [], false, ref None)
++ Reither(true, [], false, [], ref None)
+ | _ ->
+ assert false
+ end
+@@ -406,7 +409,8 @@
+ {row with row_fixed=true;
+ row_fields = List.map
+ (fun (s,f as p) -> match Btype.row_field_repr f with
+- Reither (c, tl, m, r) -> s, Reither (c, tl, true, r)
++ Reither (c, tl, m, tpl, r) ->
++ s, Reither (c, tl, true, tpl, r)
+ | _ -> p)
+ row.row_fields};
+ Btype.iter_row make_fixed_univars row
+Index: typing/unused_var.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/unused_var.ml,v
+retrieving revision 1.5
+diff -u -r1.5 unused_var.ml
+--- typing/unused_var.ml 4 Jan 2006 16:55:50 -0000 1.5
++++ typing/unused_var.ml 2 Feb 2006 06:28:33 -0000
+@@ -122,9 +122,11 @@
+ | Pexp_apply (e, lel) ->
+ expression ppf tbl e;
+ List.iter (fun (_, e) -> expression ppf tbl e) lel;
+- | Pexp_match (e, pel) ->
++ | Pexp_match (e, pel, _) ->
+ expression ppf tbl e;
+ match_pel ppf tbl pel;
++ | Pexp_multifun pel ->
++ match_pel ppf tbl pel;
+ | Pexp_try (e, pel) ->
+ expression ppf tbl e;
+ match_pel ppf tbl pel;
+Index: bytecomp/matching.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/matching.ml,v
+retrieving revision 1.67
+diff -u -r1.67 matching.ml
+--- bytecomp/matching.ml 7 Sep 2005 16:07:48 -0000 1.67
++++ bytecomp/matching.ml 2 Feb 2006 06:28:33 -0000
+@@ -1991,7 +1991,7 @@
+ List.iter
+ (fun (_, f) ->
+ match Btype.row_field_repr f with
+- Rabsent | Reither(true, _::_, _, _) -> ()
++ Rabsent | Reither(true, _::_, _, _, _) -> ()
+ | _ -> incr num_constr)
+ row.row_fields
+ else
+Index: toplevel/genprintval.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/toplevel/genprintval.ml,v
+retrieving revision 1.38
+diff -u -r1.38 genprintval.ml
+--- toplevel/genprintval.ml 13 Jun 2005 04:55:53 -0000 1.38
++++ toplevel/genprintval.ml 2 Feb 2006 06:28:33 -0000
+@@ -293,7 +293,7 @@
+ | (l, f) :: fields ->
+ if Btype.hash_variant l = tag then
+ match Btype.row_field_repr f with
+- | Rpresent(Some ty) | Reither(_,[ty],_,_) ->
++ | Rpresent(Some ty) | Reither(_,[ty],_,_,_) ->
+ let args =
+ tree_of_val (depth - 1) (O.field obj 1) ty in
+ Oval_variant (l, Some args)
--- /dev/null
+(* Simple example *)
+let f x =
+ (multimatch x with `A -> 1 | `B -> true),
+ (multimatch x with `A -> 1. | `B -> "1");;
+
+(* OK *)
+module M : sig
+ val f :
+ [< `A & 'a = int & 'b = float | `B & 'b =string & 'a = bool] -> 'a * 'b
+end = struct let f = f end;;
+
+(* Bad *)
+module M : sig
+ val f :
+ [< `A & 'a = int & 'b = float | `B & 'b =string & 'a = int] -> 'a * 'b
+end = struct let f = f end;;
+
+(* Should be good! *)
+module M : sig
+ val f :
+ [< `A & 'a = int * float | `B & 'a = bool * string] -> 'a
+end = struct let f = f end;;
+
+let f = multifun `A|`B as x -> f x;;
+
+(* Two-level example *)
+let f = multifun
+ `A -> (multifun `C -> 1 | `D -> 1.)
+ | `B -> (multifun `C -> true | `D -> "1");;
+
+(* OK *)
+module M : sig
+ val f :
+ [< `A & 'b = [< `C & 'a = int | `D & 'a = float & 'c = bool] -> 'a
+ | `B & 'b = [< `C & 'c = bool | `D & 'c = string] -> 'c] -> 'b
+end = struct let f = f end;;
+
+(* Bad *)
+module M : sig
+ val f :
+ [< `A & 'b = [< `C & 'a = int | `D & 'a = bool] -> 'a
+ | `B & 'b = [< `C & 'c = bool | `D & 'c = string] -> 'c] -> 'b
+end = struct let f = f end;;
+
+module M : sig
+ val f :
+ [< `A & 'b = [< `C & 'a = int | `D] -> 'a
+ | `B & 'b = [< `C & 'c = bool | `D & 'c = string] -> 'c] -> 'b
+end = struct let f = f end;;
+
+
+(* Examples with hidden sharing *)
+let r = ref []
+let f = multifun `A -> 1 | `B -> true
+let g x = r := [f x];;
+
+(* Bad! *)
+module M : sig
+ val g : [< `A & 'a = int | `B & 'a = bool] -> unit
+end = struct let g = g end;;
+
+let r = ref []
+let f = multifun `A -> r | `B -> ref [];;
+(* Now OK *)
+module M : sig
+ val f : [< `A & 'b = int list ref | `B & 'b = 'c list ref] -> 'b
+end = struct let f = f end;;
+(* Still OK *)
+let l : int list ref = r;;
+module M : sig
+ val f : [< `A & 'b = int list ref | `B & 'b = 'c list ref] -> 'b
+end = struct let f = f end;;
+
+
+(* Examples that would need unification *)
+let f = multifun `A -> (1, []) | `B -> (true, [])
+let g x = fst (f x);;
+(* Didn't work, now Ok *)
+module M : sig
+ val g : [< `A & 'a * 'b = int * bool | `B & 'a * 'b = bool * int] -> 'a
+end = struct let g = g end;;
+let g = multifun (`A|`B) as x -> g x;;
+
+(* Other examples *)
+
+let f x =
+ let a = multimatch x with `A -> 1 | `B -> "1" in
+ (multifun `A -> print_int | `B -> print_string) x a
+;;
+
+let f = multifun (`A|`B) as x -> f x;;
+
+type unit_op = [`Set of int | `Move of int]
+type int_op = [`Get]
+
+let op r =
+ multifun
+ `Get -> !r
+ | `Set x -> r := x
+ | `Move dx -> r := !r + dx
+;;
+
+let rec trace r = function
+ [] -> []
+ | op1 :: ops ->
+ multimatch op1 with
+ #int_op as op1 ->
+ let x = op r op1 in
+ x :: trace r ops
+ | #unit_op as op1 ->
+ op r op1;
+ trace r ops
+;;
+
+class point x = object
+ val mutable x : int = x
+ method get = x
+ method set y = x <- y
+ method move dx = x <- x + dx
+end;;
+
+let poly sort coeffs x =
+ let add, mul, zero =
+ multimatch sort with
+ `Int -> (+), ( * ), 0
+ | `Float -> (+.), ( *. ), 0.
+ in
+ let rec compute = function
+ [] -> zero
+ | c :: cs -> add c (mul x (compute cs))
+ in
+ compute coeffs
+;;
+
+module M : sig
+ val poly : [< `Int & 'a = int | `Float & 'a = float] -> 'a list -> 'a -> 'a
+end = struct let poly = poly end;;
+
+type ('a,'b) num_sort =
+ 'b constraint 'b = [< `Int & 'a = int | `Float & 'a = float]
+module M : sig
+ val poly : ('a,_) num_sort -> 'a list -> 'a -> 'a
+end = struct let poly = poly end;;
+
+
+(* type dispatch *)
+
+type num = [ `Int | `Float ]
+let print0 = multifun
+ `Int -> print_int
+ | `Float -> print_float
+;;
+let print1 = multifun
+ #num as x -> print0 x
+ | `List t -> List.iter (print0 t)
+ | `Pair(t1,t2) -> (fun (x,y) -> print0 t1 x; print0 t2 y)
+;;
+print1 (`Pair(`Int,`Float)) (1,1.0);;
--- /dev/null
+%!PS-Adobe-2.0
+%%Creator: dvipsk 5.78 p1.4 Copyright 1996-98 ASCII Corp.(www-ptex@ascii.co.jp)
+%%dvipsk 5.78 Copyright 1998 Radical Eye Software (www.radicaleye.com)
+%%Title: newlabels.dvi
+%%Pages: 2 0
+%%PageOrder: Ascend
+%%BoundingBox: 0 0 596 842
+%%EndComments
+%%BeginProcSet: PStoPS 1 15
+userdict begin
+[/showpage/erasepage/copypage]{dup where{pop dup load
+ type/operatortype eq{1 array cvx dup 0 3 index cvx put
+ bind def}{pop}ifelse}{pop}ifelse}forall
+[/letter/legal/executivepage/a4/a4small/b5/com10envelope
+ /monarchenvelope/c5envelope/dlenvelope/lettersmall/note
+ /folio/quarto/a5]{dup where{dup wcheck{exch{}put}
+ {pop{}def}ifelse}{pop}ifelse}forall
+/setpagedevice {pop}bind 1 index where{dup wcheck{3 1 roll put}
+ {pop def}ifelse}{def}ifelse
+/PStoPSmatrix matrix currentmatrix def
+/PStoPSxform matrix def/PStoPSclip{clippath}def
+/defaultmatrix{PStoPSmatrix exch PStoPSxform exch concatmatrix}bind def
+/initmatrix{matrix defaultmatrix setmatrix}bind def
+/initclip[{matrix currentmatrix PStoPSmatrix setmatrix
+ [{currentpoint}stopped{$error/newerror false put{newpath}}
+ {/newpath cvx 3 1 roll/moveto cvx 4 array astore cvx}ifelse]
+ {[/newpath cvx{/moveto cvx}{/lineto cvx}
+ {/curveto cvx}{/closepath cvx}pathforall]cvx exch pop}
+ stopped{$error/errorname get/invalidaccess eq{cleartomark
+ $error/newerror false put cvx exec}{stop}ifelse}if}bind aload pop
+ /initclip dup load dup type dup/operatortype eq{pop exch pop}
+ {dup/arraytype eq exch/packedarraytype eq or
+ {dup xcheck{exch pop aload pop}{pop cvx}ifelse}
+ {pop cvx}ifelse}ifelse
+ {newpath PStoPSclip clip newpath exec setmatrix} bind aload pop]cvx def
+/initgraphics{initmatrix newpath initclip 1 setlinewidth
+ 0 setlinecap 0 setlinejoin []0 setdash 0 setgray
+ 10 setmiterlimit}bind def
+end
+%%EndProcSet
+%DVIPSCommandLine: dvips -f newlabels
+%DVIPSParameters: dpi=300
+%DVIPSSource: TeX output 1999.10.26:1616
+%%BeginProcSet: tex.pro
+%!
+/TeXDict 300 dict def TeXDict begin /N{def}def /B{bind def}N /S{exch}N
+/X{S N}B /TR{translate}N /isls false N /vsize 11 72 mul N /hsize 8.5 72
+mul N /landplus90{false}def /@rigin{isls{[0 landplus90{1 -1}{-1 1}
+ifelse 0 0 0]concat}if 72 Resolution div 72 VResolution div neg scale
+isls{landplus90{VResolution 72 div vsize mul 0 exch}{Resolution -72 div
+hsize mul 0}ifelse TR}if Resolution VResolution vsize -72 div 1 add mul
+TR[matrix currentmatrix{dup dup round sub abs 0.00001 lt{round}if}
+forall round exch round exch]setmatrix}N /@landscape{/isls true N}B
+/@manualfeed{statusdict /manualfeed true put}B /@copies{/#copies X}B
+/FMat[1 0 0 -1 0 0]N /FBB[0 0 0 0]N /nn 0 N /IE 0 N /ctr 0 N /df-tail{
+/nn 8 dict N nn begin /FontType 3 N /FontMatrix fntrx N /FontBBox FBB N
+string /base X array /BitMaps X /BuildChar{CharBuilder}N /Encoding IE N
+end dup{/foo setfont}2 array copy cvx N load 0 nn put /ctr 0 N[}B /df{
+/sf 1 N /fntrx FMat N df-tail}B /dfs{div /sf X /fntrx[sf 0 0 sf neg 0 0]
+N df-tail}B /E{pop nn dup definefont setfont}B /ch-width{ch-data dup
+length 5 sub get}B /ch-height{ch-data dup length 4 sub get}B /ch-xoff{
+128 ch-data dup length 3 sub get sub}B /ch-yoff{ch-data dup length 2 sub
+get 127 sub}B /ch-dx{ch-data dup length 1 sub get}B /ch-image{ch-data
+dup type /stringtype ne{ctr get /ctr ctr 1 add N}if}B /id 0 N /rw 0 N
+/rc 0 N /gp 0 N /cp 0 N /G 0 N /sf 0 N /CharBuilder{save 3 1 roll S dup
+/base get 2 index get S /BitMaps get S get /ch-data X pop /ctr 0 N ch-dx
+0 ch-xoff ch-yoff ch-height sub ch-xoff ch-width add ch-yoff
+setcachedevice ch-width ch-height true[1 0 0 -1 -.1 ch-xoff sub ch-yoff
+.1 sub]{ch-image}imagemask restore}B /D{/cc X dup type /stringtype ne{]}
+if nn /base get cc ctr put nn /BitMaps get S ctr S sf 1 ne{dup dup
+length 1 sub dup 2 index S get sf div put}if put /ctr ctr 1 add N}B /I{
+cc 1 add D}B /bop{userdict /bop-hook known{bop-hook}if /SI save N @rigin
+0 0 moveto /V matrix currentmatrix dup 1 get dup mul exch 0 get dup mul
+add .99 lt{/QV}{/RV}ifelse load def pop pop}N /eop{SI restore userdict
+/eop-hook known{eop-hook}if showpage}N /@start{userdict /start-hook
+known{start-hook}if pop /VResolution X /Resolution X 1000 div /DVImag X
+/IE 256 array N 2 string 0 1 255{IE S dup 360 add 36 4 index cvrs cvn
+put}for pop 65781.76 div /vsize X 65781.76 div /hsize X}N /p{show}N
+/RMat[1 0 0 -1 0 0]N /BDot 260 string N /rulex 0 N /ruley 0 N /v{/ruley
+X /rulex X V}B /V{}B /RV statusdict begin /product where{pop false[
+(Display)(NeXT)(LaserWriter 16/600)]{dup length product length le{dup
+length product exch 0 exch getinterval eq{pop true exit}if}{pop}ifelse}
+forall}{false}ifelse end{{gsave TR -.1 .1 TR 1 1 scale rulex ruley false
+RMat{BDot}imagemask grestore}}{{gsave TR -.1 .1 TR rulex ruley scale 1 1
+false RMat{BDot}imagemask grestore}}ifelse B /QV{gsave newpath transform
+round exch round exch itransform moveto rulex 0 rlineto 0 ruley neg
+rlineto rulex neg 0 rlineto fill grestore}B /a{moveto}B /delta 0 N /tail
+{dup /delta X 0 rmoveto}B /M{S p delta add tail}B /b{S p tail}B /c{-4 M}
+B /d{-3 M}B /e{-2 M}B /f{-1 M}B /g{0 M}B /h{1 M}B /i{2 M}B /j{3 M}B /k{
+4 M}B /w{0 rmoveto}B /l{p -4 w}B /m{p -3 w}B /n{p -2 w}B /o{p -1 w}B /q{
+p 1 w}B /r{p 2 w}B /s{p 3 w}B /t{p 4 w}B /x{0 S rmoveto}B /y{3 2 roll p
+a}B /bos{/SS save N}B /eos{SS restore}B end
+
+%%EndProcSet
+TeXDict begin 39158280 55380996 1000 300 300 (newlabels.dvi)
+@start
+%DVIPSBitmapFont: Fa cmr6 6 2
+/Fa 2 51 df<187898181818181818181818181818FF08107D8F0F> 49
+D<1F00618040C08060C0600060006000C00180030006000C00102020207FC0FFC00B107F
+8F0F> I E
+%EndDVIPSBitmapFont
+%DVIPSBitmapFont: Fb cmmi8 8 4
+/Fb 4 111 df<FFC0FF1C00181C00101C00101C00103800203800203800203800207000
+40700040700040700040E00080E00080E00080E00080E00100E00200E004006008003830
+000FC00018177E9618> 85 D<0300038003000000000000000000000000001C00240046
+0046008C000C0018001800180031003100320032001C0009177F960C> 105
+D<383C1E0044C6630047028100460301008E0703000C0603000C0603000C060300180C06
+00180C0620180C0C20180C0C40301804C0301807001B0E7F8D1F> 109
+D<383C0044C6004702004602008E06000C06000C06000C0600180C00180C401818401818
+80300980300E00120E7F8D15> I E
+%EndDVIPSBitmapFont
+%DVIPSBitmapFont: Fc cmbx8 8 4
+/Fc 4 111 df<01800780FF80FF80078007800780078007800780078007800780078007
+800780078007800780FFF8FFF80D157D9414> 49 D<387C7C7C3800000000FCFC3C3C3C
+3C3C3C3C3C3C3C3CFFFF08187F970B> 105 D<FC7E0FC0FD8730E03E07C0F03E07C0F03C
+0780F03C0780F03C0780F03C0780F03C0780F03C0780F03C0780F03C0780F03C0780F0FF
+1FE3FCFF1FE3FC1E0F7E8E23> 109 D<FC7C00FD8E003E0F003E0F003C0F003C0F003C0F
+003C0F003C0F003C0F003C0F003C0F003C0F00FF3FC0FF3FC0120F7E8E17> I
+E
+%EndDVIPSBitmapFont
+%DVIPSBitmapFont: Fd cmsy8 8 3
+/Fd 3 93 df<FFFFF0FFFFF014027D881B> 0 D<020002000200C218F2783AE00F800F80
+3AE0F278C2180200020002000D0E7E8E12> 3 D<03F8001FFF003C07806000C0C00060C0
+0060C00060C00060C00060C00060C00060C00060C00060C00060C00060C00060C00060C0
+006040002013137E9218> 92 D E
+%EndDVIPSBitmapFont
+%DVIPSBitmapFont: Fe cmtt12 12 43
+/Fe 43 125 df<01818003C3C003C3C003C3C003C3C003C3C003C3C07FFFF0FFFFF8FFFF
+F87FFFF00787800787800787800F8F800F0F000F0F000F0F000F0F007FFFF0FFFFF8FFFF
+F87FFFF01E1E001E1E001E1E001E1E001E1E001E1E000C0C00151E7E9D1A> 35
+D<00E00003F00007F8000738000E1C000E1C000E1C000E1C000E38000E39FC0E71FC07F1
+FC07E1C007C1C00781C00783800F83801FC3803DC70078E70070EE00E07E00E07E00E03C
+08E03C1CE07E1C70FF1C7FE7F83FC3F80F00E0161E7F9D1A> 38
+D<0038007800F001E003C007800F000E001C001C0038003800700070007000E000E000E0
+00E000E000E000E000E000E000E000700070007000380038001C001C000E000F00078003
+C001E000F8007800380D2878A21A> 40 D<6000F00078003C001E000F000780038001C0
+01C000E000E0007000700070003800380038003800380038003800380038003800700070
+007000E000E001C001C0038007800F001E003C007800F00060000D287CA21A> I<7FFFC0
+FFFFE0FFFFE07FFFC013047D901A> 45 D<00C001C001C003C007C00FC07FC0FDC071C0
+01C001C001C001C001C001C001C001C001C001C001C001C001C001C001C001C001C001C0
+7FFF7FFF7FFF101E7B9D1A> 49 D<03F8000FFE001FFF803C07C07801E07000E0E00070
+F00070F000706000700000700000700000E00000E00001C00003C0000780000F00001E00
+003C0000780000F00003E00007C0000F00001E00703C00707FFFF0FFFFF07FFFF0141E7D
+9D1A> I<03FC000FFF003FFFC03C03E07800E07800707800700000700000700000E00001
+E00007C003FF8003FF0003FFC00003E00000E0000070000078000038000038600038F000
+38F00078E000707000E07E03E03FFFC00FFF0001FC00151E7E9D1A> I<01FC0007FF001F
+FFC01F07C03C01E07800F07000707000707000707800F03800E01E03C00FFF8003FE0007
+FF001F8FC03C01E07800F0700070E00038E00038E00038E00038F000787000707800F03E
+03E01FFFC007FF0001FC00151E7E9D1A> 56 D<01F00007FC001FFE003E0F0038078070
+03807001C0E001C0E001C0E001E0E000E0E000E0E001E07001E07803E03C0FE01FFFE00F
+FCE003F0E00001C00001C00001C0000380600380F00700F00F00F03E007FFC003FF0000F
+C000131E7D9D1A> I<3078FCFC78300000000000000000003078FCFC7830061576941A>
+I<183C7E7E3C18000000000000000000183C7E7E3E1E0E0E1C3CF8F060071C77941A> I<
+0000C00003E00007E0000FC0003F80007E0000FC0003F80007E0000FC0003F80007E0000
+FC0000FC00007E00003F80000FC00007E00003F80000FC00007E00003F80000FC00007E0
+0003E00000C0131A7D9B1A> I<7FFFF0FFFFF8FFFFF87FFFF00000000000000000000000
+007FFFF0FFFFF8FFFFF87FFFF0150C7E941A> I<600000F80000FC00007E00003F80000F
+C00007E00003F80000FC00007E00003F80000FC00007E00007E0000FC0003F80007E0000
+FC0003F80007E0000FC0003F80007E0000FC0000F80000600000131A7D9B1A> I<007C38
+01FF3807FFF80F83F81E00F81C0078380078380038700038700038700000E00000E00000
+E00000E00000E00000E00000E00000E000007000007000387000383800383800381C0070
+1E00F00F83E007FFC001FF80007C00151E7E9D1A> 67 D<FE03FEFF03FEFF03FE1D8070
+1D80701DC0701CC0701CC0701CE0701CE0701C60701C70701C70701C30701C38701C3870
+1C18701C1C701C1C701C0C701C0E701C0E701C06701C06701C07701C03701C0370FF81F0
+FF81F0FF80F0171E7F9D1A> 78 D<03F8E00FFEE01FFFE03C07E07801E0F001E0E000E0
+E000E0E000E0E000007000007800003F80001FF80007FF00007FC00007E00000F0000070
+000038000038600038E00038E00038E00070F000F0FE01E0FFFFC0EFFF80E1FE00151E7E
+9D1A> 83 D<7FFFFEFFFFFEFFFFFEE0380EE0380EE0380EE0380E003800003800003800
+003800003800003800003800003800003800003800003800003800003800003800003800
+00380000380000380000380000380003FF8003FF8003FF80171E7F9D1A> I<FFFCFFFCFF
+FCE000E000E000E000E000E000E000E000E000E000E000E000E000E000E000E000E000E0
+00E000E000E000E000E000E000E000E000E000E000E000E000E000E000E000FFFCFFFCFF
+FC0E2776A21A> 91 D<FFFCFFFCFFFC001C001C001C001C001C001C001C001C001C001C
+001C001C001C001C001C001C001C001C001C001C001C001C001C001C001C001C001C001C
+001C001C001C001C001CFFFCFFFCFFFC0E277FA21A> 93 D<1FF0003FFC007FFE00780F
+00300700000380000380007F8007FF801FFF803F8380780380700380E00380E00380E003
+80700780780F803FFFFC1FFDFC07F0FC16157D941A> 97 D<7E0000FE00007E00000E00
+000E00000E00000E00000E00000E00000E3E000EFF800FFFE00FC1F00F80700F00380E00
+380E001C0E001C0E001C0E001C0E001C0E001C0E001C0F00380F00780F80F00FC1E00FFF
+C00EFF80063E00161E7F9D1A> I<00FF8003FFC00FFFE01F01E03C00C078000070000070
+0000E00000E00000E00000E00000E000007000007000007800703C00701F01F00FFFE003
+FFC000FE0014157D941A> I<000FC0001FC0000FC00001C00001C00001C00001C00001C0
+0001C001F1C007FDC00FFFC01E0FC03C07C07803C07001C0E001C0E001C0E001C0E001C0
+E001C0E001C0E001C07003C07003C03807C03E0FC01FFFF807FDFC01F1F8161E7E9D1A>
+I<01F80007FF000FFF801E07C03C01C07800E07000E0E00070E00070FFFFF0FFFFF0FFFF
+F0E000007000007000007800703C00701F01F00FFFE003FF8000FE0014157D941A> I<00
+07E0001FF0003FF800787800F03000E00000E00000E00000E0007FFFF0FFFFF0FFFFF000
+E00000E00000E00000E00000E00000E00000E00000E00000E00000E00000E00000E00000
+E00000E00000E0003FFF807FFFC03FFF80151E7F9D1A> I<7E0000FE00007E00000E0000
+0E00000E00000E00000E00000E00000E3E000EFF800FFFC00FC1C00F80E00F00E00E00E0
+0E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E07FC3FC
+FFE7FE7FC3FC171E7F9D1A> 104 D<00C00001E00001E00000C000000000000000000000
+0000000000000000007FE0007FE0007FE00000E00000E00000E00000E00000E00000E000
+00E00000E00000E00000E00000E00000E00000E00000E00000E0007FFF80FFFFC07FFF80
+121F7C9E1A> I<7FE000FFE0007FE00000E00000E00000E00000E00000E00000E00000E0
+0000E00000E00000E00000E00000E00000E00000E00000E00000E00000E00000E00000E0
+0000E00000E00000E00000E00000E0007FFFC0FFFFE07FFFC0131E7D9D1A> 108
+D<7CE0E000FFFBF8007FFFF8001F1F1C001E1E1C001E1E1C001C1C1C001C1C1C001C1C1C
+001C1C1C001C1C1C001C1C1C001C1C1C001C1C1C001C1C1C001C1C1C001C1C1C001C1C1C
+007F1F1F00FFBFBF807F1F1F00191580941A> I<7E3E00FEFF807FFFC00FC1C00F80E00F
+00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E
+00E07FC3FCFFE7FE7FC3FC17157F941A> I<01F00007FC001FFF003E0F803C07807803C0
+7001C0E000E0E000E0E000E0E000E0E000E0E000E0F001E07001C07803C03C07803E0F80
+1FFF0007FC0001F00013157D941A> I<7E3E00FEFF807FFFE00FC1F00F80700F00380E00
+380E001C0E001C0E001C0E001C0E001C0E001C0E001C0F00380F00780F80F00FC1E00FFF
+C00EFF800E3E000E00000E00000E00000E00000E00000E00000E00000E00007FC000FFE0
+007FC00016207F941A> I<7F81F8FF8FFC7F9FFE03FE1E03F80C03E00003E00003C00003
+80000380000380000380000380000380000380000380000380000380007FFF00FFFF007F
+FF0017157F941A> 114 D<07FB801FFF807FFF80780780E00380E00380E003807800007F
+C0001FFC0007FE00003F800007806001C0E001C0E001C0F003C0FC0780FFFF00EFFE00E3
+F80012157C941A> I<0180000380000380000380000380000380000380007FFFE0FFFFE0
+FFFFE0038000038000038000038000038000038000038000038000038000038000038070
+03807003807003807001C1E001FFE000FF80003F00141C7F9B1A> I<7E07E0FE0FE07E07
+E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00E00
+E00E00E00E01E00F03E007FFFC03FFFE00FCFC17157F941A> I<7F83FCFFC7FE7F83FC0E
+00E00E00E00E00E00701C00701C00701C003838003838003838001C70001C70001C70000
+EE0000EE0000EE00007C00007C0000380017157F941A> I<FF83FEFF83FEFF83FE380038
+3800381C00701C00701C00701C38701C7C701C7C700C6C600EEEE00EEEE00EEEE00EEEE0
+0EC6E006C6C007C7C00783C00783C017157F941A> I<7FC7F87FCFFC7FC7F80703C00383
+8003C70001EF0000FE00007C00007800003800007C0000EE0001EE0001C7000383800783
+C00F01C07FC7FCFFC7FE7FC7FC17157F941A> I<7F83FCFFC7FE7F83FC0E00E00E00E007
+00E00701C00701C00381C003838003C38001C38001C70000E70000E70000E60000660000
+6E00003C00003C00003C0000380000380000380000700000700030F00078E00071E0007F
+C0003F80001E000017207F941A> I<60F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0
+F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F0F060042775A21A> 124 D
+E
+%EndDVIPSBitmapFont
+%DVIPSBitmapFont: Ff cmr8 8 3
+/Ff 3 51 df<003000003000003000003000003000003000003000003000003000003000
+003000FFFFFCFFFFFC003000003000003000003000003000003000003000003000003000
+00300000300016187E931B> 43 D<06000E00FE000E000E000E000E000E000E000E000E
+000E000E000E000E000E000E000E000E000E00FFE00B157D9412> 49
+D<0F8030E040708030C038E0384038003800700070006000C00180030006000C08080810
+183FF07FF0FFF00D157E9412> I E
+%EndDVIPSBitmapFont
+%DVIPSBitmapFont: Fg cmmi12 12 13
+/Fg 13 121 df<0FFFF81FFFFC3FFFF870200040200080200080600000600000600000C0
+0000C00000C00000C00001C0000180000180000380000380000380000700000300001615
+7E9415> 28 D<0000100000002000000020000000200000002000000040000000400000
+004000000040000000800000008000000080000000800000010000000FE00000711C0001
+C10600030203000E0203801C020180180201C0380401C0700401C0700401C0700401C0E0
+080380E0080380E00807006008070070100E0030101C00301038001C10E0000623800001
+FE0000002000000020000000400000004000000040000000400000008000000080000000
+800000008000001A2D7EA21D> 30 D<70F8F8F87005057C840E> 58
+D<70F8FCFC7404040404080810102040060F7C840E> I<00008000018000018000030000
+0300000300000600000600000600000C00000C00000C0000180000180000180000300000
+300000300000600000600000600000C00000C00000C00001800001800001800001800003
+00000300000300000600000600000600000C00000C00000C000018000018000018000030
+0000300000300000600000600000600000C00000C00000C0000011317DA418> 61
+D<00FFFC00000F8000000F0000000F0000001E0000001E0000001E0000001E0000003C00
+00003C0000003C0000003C00000078000000780000007800000078000000F0000000F000
+0000F0000000F0000001E0000001E0000001E0002001E0002003C0004003C0004003C000
+8003C0008007800180078001000780030007800F000F803E00FFFFFE001B227DA121> 76
+D<1FFFFFFE1E01E00E1801E0063001E0062003C0062003C0064003C0044003C004400780
+04800780048007800400078000000F0000000F0000000F0000000F0000001E0000001E00
+00001E0000001E0000003C0000003C0000003C0000003C00000078000000780000007800
+000078000000F0000000F0000000F0000000F0000001F000007FFFC0001F227EA11D> 84
+D<3FFE01FF8003C0003C0003C000300003C0001000078000200007800020000780002000
+07800020000F000040000F000040000F000040000F000040001E000080001E000080001E
+000080001E000080003C000100003C000100003C000100003C0001000078000200007800
+020000780002000078000200007000040000F000040000F0000800007000080000700010
+00007000200000380040000038008000001C01000000060600000001F800000021237DA1
+21> I<007E000381000700800E00801C0080380080780100700600FFF800F00000F00000
+E00000E00000E00000E00000E00080E000807003003004001838000FC00011157D9417>
+101 D<01E00FC001C001C001C0038003800380038007000700070007000E000E000E000E
+001C001C001C001C0038003800380038007000700070007080E100E100E100620062003C
+000B237EA20F> 108 D<03C0F004631C04740E08780E08700708700708700F00E00F00E0
+0F00E00F00E00F01C01E01C01E01C01E01C03C03803803803803C07003C0E0072180071E
+000700000700000E00000E00000E00000E00001C00001C00001C0000FF8000181F819418
+> 112 D<3C0F004630C04741C08783C08783C08701808700000E00000E00000E00000E00
+001C00001C00001C00001C000038000038000038000038000070000030000012157E9416
+> 114 D<01E0F006310C081A1C101A3C201C3C201C18201C000038000038000038000038
+0000700000700000700000700860E010F0E010F0E020E170404230803C1F0016157E941C
+> 120 D E
+%EndDVIPSBitmapFont
+%DVIPSBitmapFont: Fh cmti12 12 22
+/Fh 22 122 df<FFF0FFF0FFE00C037C8B11> 45 D<70F8F8F0E005057A840F> I<00F8
+C00185C00705C00E03800E03801C03803C0380380700780700780700780700F00E00F00E
+00F00E00F00E10F01C20701C20703C20305C40308C400F078014157B9419> 97
+D<03C01F8003800380038007000700070007000E000E000E000E001C001CF81D0C1E0E3C
+0638073807380F700F700F700F700FE01EE01EE01EE03CE038E038607060E031C01F0010
+237BA216> I<007E0001C1000301800703800E07801C07803C0000380000780000780000
+780000F00000F00000F00000F00000F00100700100700200300C001830000FC00011157B
+9416> I<00003C0003F80000380000380000380000700000700000700000700000E00000
+E00000E00000E00001C000F9C00185C00705C00E03800E03801C03803C03803807007807
+00780700780700F00E00F00E00F00E00F00E10F01C20701C20703C20305C40308C400F07
+8016237BA219> I<00F803840E021C023C0238027804F018FFE0F000F000E000E000E000
+E000E002E0026004701830600F800F157A9416> I<00003E0000470000CF00018F000186
+000380000380000380000700000700000700000700000700000E0000FFF0000E00000E00
+000E00001C00001C00001C00001C00001C00003800003800003800003800003800007000
+00700000700000700000700000E00000E00000E00000E00000C00001C00001C000718000
+F18000F300006200003C0000182D82A20F> I<001F180030B800E0B801C07001C0700380
+700780700700E00F00E00F00E00F00E01E01C01E01C01E01C01E01C01E03800E03800E07
+80060B8006170001E700000700000700000E00000E00000E00701C00F01800F0300060E0
+003F8000151F7E9416> I<00C001E001C001C0000000000000000000000000000000001E
+002300430043008700870087000E000E001C001C001C0038003800384070807080708071
+0032001C000B217BA00F> 105 D<00F00007E00000E00000E00000E00001C00001C00001
+C00001C0000380000380000380000380000700000701E00702100704700E08F00E10F00E
+20600E40001D80001E00001FC0001C7000383800383800381C00381C2070384070384070
+3840701880E01880600F0014237DA216> 107 D<01E00FC001C001C001C0038003800380
+038007000700070007000E000E000E000E001C001C001C001C0038003800380038007000
+700070007100E200E200E200E200640038000B237CA20C> I<1C0F80F8002610C10C0047
+6066060087807807008780780700870070070087007007000E00E00E000E00E00E000E00
+E00E000E00E00E001C01C01C001C01C01C001C01C01C001C01C038203803803840380380
+70403803807080380380308070070031003003001E0023157B9428> I<380F804C30C04E
+40608E80708F00708E00708E00701C00E01C00E01C00E01C00E03801C03801C03801C038
+0384700388700308700708700310E003106001E016157B941B> I<007E0001C300038180
+0701C00E01C01C01E03C01E03801E07801E07801E07801E0F003C0F003C0F00380F00780
+700700700E00700C0030180018700007C00013157B9419> I<01C1F002621804741C0878
+0C08700E08700E08701E00E01E00E01E00E01E00E01E01C03C01C03C01C03C01C0780380
+7003807003C0E003C1C0072380071E000700000700000E00000E00000E00000E00001C00
+001C00001C0000FFC000171F7F9419> I<1C1F002620804741C08783C08703C087018087
+00000E00000E00000E00000E00001C00001C00001C00001C000038000038000038000038
+000070000030000012157B9415> 114 D<00FC000183000200800401800C03800C03000C
+00000F00000FF00007FC0003FE00003E00000F00000700700700F00600F00600E0040040
+08002030001FC00011157D9414> I<00C001C001C001C001C003800380038003800700FF
+F8070007000E000E000E000E001C001C001C001C00380038003800381070207020704070
+8031001E000D1F7C9E10> I<1E0060E02300E0F04380E1F04381C0F08381C0708701C030
+8701C030070380200E0380200E0380200E0380201C0700401C0700401C0700401C070080
+1C0700801C0701001C0F01000C0B02000613840003E0F8001C157B9420> 119
+D<03C1E0046210083470103CF02038F020386020380000700000700000700000700000E0
+0000E00000E00000E02061C040F1C040F1C080E2C100446200383C0014157D9416> I<1E
+00302300704380704380E08380E08700E08700E00701C00E01C00E01C00E01C01C03801C
+03801C03801C03801C07001C07001C07001C0F000C3E0003CE00000E00000E00001C0060
+1C00F03800F03000E0600080C0004380003E0000141F7B9418> I
+E
+%EndDVIPSBitmapFont
+%DVIPSBitmapFont: Fi cmbx12 12 20
+/Fi 20 122 df<FFFFFF8000FFFFFFF00007F003FC0007F0007E0007F0003F0007F0001F
+8007F0000FC007F00007E007F00007E007F00007F007F00003F007F00003F007F00003F0
+07F00003F807F00003F807F00003F807F00003F807F00003F807F00003F807F00003F807
+F00003F807F00003F807F00003F007F00003F007F00003F007F00007E007F00007E007F0
+000FC007F0001F8007F0003F0007F0007E0007F003FC00FFFFFFF000FFFFFF800025227E
+A12B> 68 D<01FE0207FF861F01FE3C007E7C001E78000E78000EF80006F80006FC0006
+FC0000FF0000FFE0007FFF007FFFC03FFFF01FFFF80FFFFC03FFFE003FFE0003FE00007F
+00003F00003FC0001FC0001FC0001FE0001EE0001EF0003CFC003CFF00F8C7FFE080FF80
+18227DA11F> 83 D<7FFFFFFF807FFFFFFF807E03F80F807803F807807003F803806003
+F80180E003F801C0E003F801C0C003F800C0C003F800C0C003F800C0C003F800C00003F8
+00000003F800000003F800000003F800000003F800000003F800000003F800000003F800
+000003F800000003F800000003F800000003F800000003F800000003F800000003F80000
+0003F800000003F800000003F800000003F800000003F8000001FFFFF00001FFFFF00022
+227EA127> I<0FFC003FFF807E07C07E03E07E01E07E01F03C01F00001F00001F0003FF0
+03FDF01FC1F03F01F07E01F0FC01F0FC01F0FC01F0FC01F07E02F07E0CF81FF87F07E03F
+18167E951B> 97 D<FF000000FF0000001F0000001F0000001F0000001F0000001F0000
+001F0000001F0000001F0000001F0000001F0000001F0000001F0FE0001F3FF8001FE07C
+001F803E001F001F001F000F801F000F801F000FC01F000FC01F000FC01F000FC01F000F
+C01F000FC01F000FC01F000FC01F000F801F001F801F801F001FC03E001EE07C001C3FF8
+00180FC0001A237EA21F> I<00FF8007FFE00F83F01F03F03E03F07E03F07C01E07C0000
+FC0000FC0000FC0000FC0000FC0000FC00007C00007E00007E00003E00181F00300FC060
+07FFC000FF0015167E9519> I<00FE0007FF800F87C01E01E03E01F07C00F07C00F8FC00
+F8FC00F8FFFFF8FFFFF8FC0000FC0000FC00007C00007C00007E00003E00181F00300FC0
+7003FFC000FF0015167E951A> 101 D<001FC0007FE000F1F001E3F003E3F007C3F007C1
+E007C00007C00007C00007C00007C00007C000FFFE00FFFE0007C00007C00007C00007C0
+0007C00007C00007C00007C00007C00007C00007C00007C00007C00007C00007C00007C0
+0007C00007C0003FFC003FFC00142380A211> I<01FE0F0007FFBF800F87C7801F03E780
+1E01E0003E01F0003E01F0003E01F0003E01F0003E01F0001E01E0001F03E0000F87C000
+0FFF800009FE000018000000180000001C0000001FFFE0000FFFF80007FFFE001FFFFF00
+3C003F0078000F80F0000780F0000780F0000780F000078078000F003C001E001F007C00
+0FFFF80001FFC00019217F951C> I<1C003E007F007F007F003E001C0000000000000000
+00000000000000FF00FF001F001F001F001F001F001F001F001F001F001F001F001F001F
+001F001F001F001F001F00FFE0FFE00B247EA310> 105 D<FF00FF001F001F001F001F00
+1F001F001F001F001F001F001F001F001F001F001F001F001F001F001F001F001F001F00
+1F001F001F001F001F001F001F001F001F00FFE0FFE00B237EA210> 108
+D<FF07F007F000FF1FFC1FFC001F303E303E001F403E403E001F801F801F001F801F801F
+001F001F001F001F001F001F001F001F001F001F001F001F001F001F001F001F001F001F
+001F001F001F001F001F001F001F001F001F001F001F001F001F001F001F001F001F001F
+001F001F001F001F001F001F00FFE0FFE0FFE0FFE0FFE0FFE02B167E9530> I<FF07E000
+FF1FF8001F307C001F403C001F803E001F803E001F003E001F003E001F003E001F003E00
+1F003E001F003E001F003E001F003E001F003E001F003E001F003E001F003E001F003E00
+1F003E00FFE1FFC0FFE1FFC01A167E951F> I<00FE0007FFC00F83E01E00F03E00F87C00
+7C7C007C7C007CFC007EFC007EFC007EFC007EFC007EFC007EFC007E7C007C7C007C3E00
+F81F01F00F83E007FFC000FE0017167E951C> I<FF0FE000FF3FF8001FE07C001F803E00
+1F001F001F001F801F001F801F000FC01F000FC01F000FC01F000FC01F000FC01F000FC0
+1F000FC01F000FC01F001F801F001F801F803F001FC03E001FE0FC001F3FF8001F0FC000
+1F0000001F0000001F0000001F0000001F0000001F0000001F0000001F000000FFE00000
+FFE000001A207E951F> I<0FF3003FFF00781F00600700E00300E00300F00300FC00007F
+E0007FF8003FFE000FFF0001FF00000F80C00780C00380E00380E00380F00700FC0E00EF
+FC00C7F00011167E9516> 115 D<01800001800001800001800003800003800007800007
+80000F80003F8000FFFF00FFFF000F80000F80000F80000F80000F80000F80000F80000F
+80000F80000F80000F80000F81800F81800F81800F81800F81800F830007C30003FE0000
+F80011207F9F16> I<FF01FE00FF01FE001F003E001F003E001F003E001F003E001F003E
+001F003E001F003E001F003E001F003E001F003E001F003E001F003E001F003E001F003E
+001F003E001F007E001F00FE000F81BE0007FF3FC001FC3FC01A167E951F> I<FFE07FC0
+FFE07FC00F801C0007C0380003E0700003F0600001F8C00000F98000007F8000003F0000
+001F0000001F8000003FC0000037C0000063E00000C1F00001C0F8000380FC0007007E00
+0E003E00FF80FFE0FF80FFE01B167F951E> 120 D<FFE01FE0FFE01FE01F8007000F8006
+000FC00E0007C00C0007E00C0003E0180003E0180001F0300001F0300000F8600000F860
+00007CC000007CC000007FC000003F8000003F8000001F0000001F0000000E0000000E00
+00000C0000000C00000018000078180000FC380000FC300000FC60000069C000007F8000
+001F0000001B207F951E> I E
+%EndDVIPSBitmapFont
+%DVIPSBitmapFont: Fj cmsy10 12 15
+/Fj 15 107 df<FFFFFFFCFFFFFFFC1E027C8C27> 0 D<03F0000FFC001FFE003FFF007F
+FF807FFF80FFFFC0FFFFC0FFFFC0FFFFC0FFFFC0FFFFC0FFFFC0FFFFC07FFF807FFF803F
+FF001FFE000FFC0003F00012147D9519> 15 D<000FFFFC007FFFFC01F0000003800000
+060000000C0000001800000030000000300000006000000060000000C0000000C0000000
+C0000000C0000000C0000000C0000000C0000000C0000000600000006000000030000000
+30000000180000000C000000060000000380000001E00000007FFFFC001FFFFC1E1E7C9A
+27> 26 D<00000001800000000001800000000001800000000001800000000000C00000
+000000C000000000006000000000003000000000003000000000001C00000000000E0000
+0000000700FFFFFFFFFFE0FFFFFFFFFFE0000000000700000000000E00000000001C0000
+000000300000000000300000000000600000000000C00000000000C00000000001800000
+00000180000000000180000000000180002B1A7D9832> 33 D<001FFF007FFF01E00003
+80000600000C0000180000300000300000600000600000600000C00000C00000FFFFFFFF
+FFFFC00000C000006000006000006000003000003000001800000C000006000003800001
+E000007FFF001FFF181E7C9A21> 50 D<00000300000300000600000600000C00000C00
+00180000180000300000300000600000600000C00000C00000C000018000018000030000
+0300000600000600000C00000C0000180000180000300000300000600000600000C00000
+C0000180000180000300000300000300000600000600000C00000C000018000018000030
+0000300000600000600000C00000400000183079A300> 54 D<C0C0C0C0C0C0C0C0E0E0
+C0C0C0C0C0C0C0C003127D9400> I<00008000018001F980070F000C0300180380180780
+3006C03006C0700CE0600C60600C60600C60E01870E01870E01870E03070E03070E03070
+E06070E06070E06070E06070E0C070E0C070E0C070E18070E180706180606300607300E0
+7300E03300C03600C01E01801E01800C03000F0E000DF800180000180000180000142A7E
+A519> 59 D<000100000003000000030000000300000003000000030000000300000003
+000000030000000300000003000000030000000300000003000000030000000300000003
+000000030000000300000003000000030000000300000003000000030000000300000003
+000000030000000300000003000000030000FFFFFFFEFFFFFFFE1F207C9F27> 63
+D<40000040C00000C0C00000C0C00000C0C00000C0C00000C0C00000C0C00000C0C00000
+C0C00000C0C00000C0C00000C0C00000C0C00000C0C00000C0C00000C0C00000C0C00000
+C0C00000C0C00000C0C00000C0C00000C0C00000C0600001806000018030000300180006
+000E001C000780780001FFE000007F80001A1F7D9D21> 91 D<007F800001FFE0000780
+78000E001C0018000600300003006000018060000180C00000C0C00000C0C00000C0C000
+00C0C00000C0C00000C0C00000C0C00000C0C00000C0C00000C0C00000C0C00000C0C000
+00C0C00000C0C00000C0C00000C0C00000C0C00000C0C00000C0C00000C0C00000C0C000
+00C0400000401A1F7D9D21> I<000C0000000C0000001E0000001E0000001E0000003300
+0000330000006180000061800000C0C00000C0C00000C0C0000180600001806000030030
+00030030000300300006001800060018000C000C000C000C000C000C0018000600180006
+003000030030000300600001806000018060000180C00000C0C00000401A1F7D9D21> 94
+D<0003C0001E0000380000700000E00000E00000E00000E00000E00000E00000E00000E0
+0000E00000E00000E00000E00000E00000E00000E00000E00000E00001C0000380000F00
+00F800000F000003800001C00000E00000E00000E00000E00000E00000E00000E00000E0
+0000E00000E00000E00000E00000E00000E00000E00000E00000E000007000003800001E
+000003C012317DA419> 102 D<F800000F000003800001C00000E00000E00000E00000E0
+0000E00000E00000E00000E00000E00000E00000E00000E00000E00000E00000E00000E0
+0000E000007000003800001E000003C0001E0000380000700000E00000E00000E00000E0
+0000E00000E00000E00000E00000E00000E00000E00000E00000E00000E00000E00000E0
+0000E00001C0000380000F0000F8000012317DA419> I<C0C0C0C0C0C0C0C0C0C0C0C0C0
+C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0
+02317AA40E> 106 D E
+%EndDVIPSBitmapFont
+%DVIPSBitmapFont: Fk cmr12 12 65
+/Fk 65 125 df<001FC1F00070371800C03E3C01807C3C0380783C070038000700380007
+003800070038000700380007003800070038000700380007003800FFFFFFC00700380007
+003800070038000700380007003800070038000700380007003800070038000700380007
+0038000700380007003800070038000700380007003800070038000700380007003C007F
+E1FFC01E2380A21C> 11 D<001FC0000070200000C01000018038000380780007007800
+0700300007000000070000000700000007000000070000000700000007000000FFFFF800
+070078000700380007003800070038000700380007003800070038000700380007003800
+070038000700380007003800070038000700380007003800070038000700380007003800
+070038007FE1FF80192380A21B> I<001FD8000070380000C07800018078000380780007
+0038000700380007003800070038000700380007003800070038000700380007003800FF
+FFF800070038000700380007003800070038000700380007003800070038000700380007
+003800070038000700380007003800070038000700380007003800070038000700380007
+003800070038007FF3FF80192380A21B> I<000FC07F00007031C08000E00B004001801E
+00E003803E01E007003C01E007001C00C007001C000007001C000007001C000007001C00
+0007001C000007001C000007001C0000FFFFFFFFE007001C01E007001C00E007001C00E0
+07001C00E007001C00E007001C00E007001C00E007001C00E007001C00E007001C00E007
+001C00E007001C00E007001C00E007001C00E007001C00E007001C00E007001C00E00700
+1C00E007001C00E07FF1FFCFFE272380A229> I<70F8FCFC740404040408081010204006
+0F7CA20E> 39 D<00200040008001000300060004000C000C0018001800300030003000
+7000600060006000E000E000E000E000E000E000E000E000E000E000E000E000E000E000
+6000600060007000300030003000180018000C000C000400060003000100008000400020
+0B327CA413> I<800040002000100018000C000400060006000300030001800180018001
+C000C000C000C000E000E000E000E000E000E000E000E000E000E000E000E000E000E000
+C000C000C001C0018001800180030003000600060004000C00180010002000400080000B
+327DA413> I<70F8FCFC7404040404080810102040060F7C840E> 44
+D<FFF8FFF80D02808B10> I<70F8F8F87005057C840E> I<01F000071C000C0600180300
+3803803803807001C07001C07001C07001C0F001E0F001E0F001E0F001E0F001E0F001E0
+F001E0F001E0F001E0F001E0F001E0F001E0F001E0F001E07001C07001C07001C07803C0
+3803803803801C07000C0600071C0001F00013227EA018> 48 D<008003800F80F38003
+800380038003800380038003800380038003800380038003800380038003800380038003
+800380038003800380038003800380038007C0FFFE0F217CA018> I<03F0000C1C001007
+002007804003C04003C08003E0F003E0F801E0F801E0F801E02003E00003E00003C00003
+C0000780000700000E00001C0000180000300000600000C0000180000100000200200400
+200800201800603000403FFFC07FFFC0FFFFC013217EA018> I<03F8000C1E00100F0020
+07804007C07807C07803C07807C03807C0000780000780000700000F00000C0000380003
+F000001C00000F000007800007800003C00003C00003E02003E07003E0F803E0F803E0F0
+03C04003C0400780200780100F000C1C0003F00013227EA018> I<000300000300000700
+000700000F00001700001700002700006700004700008700018700010700020700060700
+040700080700080700100700200700200700400700C00700FFFFF8000700000700000700
+000700000700000700000700000F80007FF015217FA018> I<70F8F8F870000000000000
+000000000070F8F8F87005157C940E> 58 D<FFFFFFFEFFFFFFFE000000000000000000
+0000000000000000000000000000000000000000000000FFFFFFFEFFFFFFFE1F0C7D9126
+> 61 D<07E01838201C400E800FF00FF00FF00F000F000E001C00380030006000C000C0
+00800080018001000100010001000100010000000000000000000000038007C007C007C0
+038010237DA217> 63 D<0001800000018000000180000003C0000003C0000003C00000
+05E0000005E0000009F0000008F0000008F00000107800001078000010780000203C0000
+203C0000203C0000401E0000401E0000C01F0000800F0000800F0001FFFF800100078001
+000780020003C0020003C0020003C0040001E0040001E0040001E0080000F01C0000F03E
+0001F8FF800FFF20237EA225> 65 D<FFFFF8000F800E0007800780078003C0078003E0
+078001E0078001F0078001F0078001F0078001F0078001F0078001E0078003E0078007C0
+07800F8007803E0007FFFE0007800780078003C0078001E0078001F0078000F0078000F8
+078000F8078000F8078000F8078000F8078000F8078001F0078001F0078003E0078007C0
+0F800F00FFFFFC001D227EA123> I<0007E0100038183000E0063001C00170038000F007
+0000F00E0000701E0000701C0000303C0000303C0000307C0000107800001078000010F8
+000000F8000000F8000000F8000000F8000000F8000000F8000000F80000007800000078
+0000107C0000103C0000103C0000101C0000201E0000200E000040070000400380008001
+C0010000E0020000381C000007E0001C247DA223> I<FFFFF0000F801E00078007000780
+0380078001C0078000E0078000F007800078078000780780007C0780003C0780003C0780
+003C0780003E0780003E0780003E0780003E0780003E0780003E0780003E0780003E0780
+003E0780003C0780003C0780007C0780007807800078078000F0078000E0078001E00780
+03C0078007000F801E00FFFFF0001F227EA125> I<FFFFFFC00F8007C0078001C0078000
+C00780004007800040078000600780002007800020078000200780202007802000078020
+0007802000078060000780E00007FFE0000780E000078060000780200007802000078020
+000780200007800000078000000780000007800000078000000780000007800000078000
+00078000000FC00000FFFE00001B227EA120> 70 D<0007F008003C0C1800E0021801C0
+01B8038000F8070000780F0000381E0000381E0000183C0000183C0000187C0000087800
+000878000008F8000000F8000000F8000000F8000000F8000000F8000000F8000000F800
+1FFF780000F8780000787C0000783C0000783C0000781E0000781E0000780F0000780700
+0078038000B801C000B800E00318003C0C080007F00020247DA226> I<FFFC3FFF0FC003
+F0078001E0078001E0078001E0078001E0078001E0078001E0078001E0078001E0078001
+E0078001E0078001E0078001E0078001E0078001E007FFFFE0078001E0078001E0078001
+E0078001E0078001E0078001E0078001E0078001E0078001E0078001E0078001E0078001
+E0078001E0078001E0078001E00FC003F0FFFC3FFF20227EA125> I<FFFC0FC007800780
+078007800780078007800780078007800780078007800780078007800780078007800780
+07800780078007800780078007800780078007800FC0FFFC0E227EA112> I<FFFC00FF80
+0FC0007C0007800030000780002000078000400007800080000780010000078002000007
+80040000078008000007801000000780200000078040000007808000000781C000000783
+E000000785E000000788F000000790F0000007A078000007C03C000007803C000007801E
+000007800F000007800F00000780078000078007C000078003C000078001E000078001E0
+00078000F000078000F8000FC000FC00FFFC07FF8021227EA126> 75
+D<FFFC001F80000F00000F00000F00000F00000F00000F00000F00000F00000F00000F00
+000F00000F00000F00000F00000F00000F00000F00000F00000F00000F00000F00010F00
+010F00010F00010F00030F00030F00020F00060F00060F001E1F007EFFFFFE18227DA11E
+> I<FF8007FF07C000F807C0007005E0002004F0002004F0002004780020047C0020043C
+0020041E0020041F0020040F002004078020040780200403C0200401E0200401E0200400
+F0200400F8200400782004003C2004003E2004001E2004000F2004000F20040007A00400
+03E0040003E0040001E0040001E0040000E00E0000601F000060FFE0002020227EA125>
+78 D<000FE00000783C0000E00E0003C00780078003C00F0001E00E0000E01E0000F03C
+0000783C0000787C00007C7C00007C7800003C7800003CF800003EF800003EF800003EF8
+00003EF800003EF800003EF800003EF800003EF800003E7800003C7C00007C7C00007C3C
+0000783E0000F81E0000F00F0001E00F0001E0078003C003C0078000E00E0000783C0000
+0FE0001F247DA226> I<FFFFF0000F803C0007800F0007800780078007C0078003C00780
+03E0078003E0078003E0078003E0078003E0078003E0078003C0078007C0078007800780
+0F0007803C0007FFF0000780000007800000078000000780000007800000078000000780
+0000078000000780000007800000078000000780000007800000078000000FC00000FFFC
+00001B227EA121> I<FFFFE000000F803C000007800E00000780078000078007C0000780
+03C000078003E000078003E000078003E000078003E000078003E000078003C000078007
+C000078007800007800E000007803C000007FFE000000780700000078038000007801C00
+0007801E000007800E000007800F000007800F000007800F000007800F000007800F8000
+07800F800007800F800007800F808007800FC080078007C0800FC003C100FFFC01E20000
+00007C0021237EA124> 82 D<03F0200C0C601802603001E07000E0600060E00060E000
+60E00020E00020E00020F00000F000007800007F00003FF0001FFE000FFF0003FF80003F
+C00007E00001E00000F00000F0000070800070800070800070800070C00060C00060E000
+C0F000C0C80180C6070081FC0014247DA21B> I<7FFFFFF8780780786007801840078008
+4007800840078008C007800C800780048007800480078004800780040007800000078000
+000780000007800000078000000780000007800000078000000780000007800000078000
+000780000007800000078000000780000007800000078000000780000007800000078000
+00078000000FC00001FFFE001E227EA123> I<FFF0007FC01F80001F000F00000C000F80
+000C000780000800078000080003C000100003C000100003C000100001E000200001E000
+200001F000600000F000400000F000400000780080000078008000007C008000003C0100
+00003C010000001E020000001E020000001E020000000F040000000F040000000F8C0000
+000788000000078800000003D000000003D000000003F000000001E000000001E0000000
+00C000000000C000000000C0000022237FA125> 86 D<FFF03FFC03FE1F8007E000F80F
+0003C000700F0003C000200F0001E00020078001E00040078001E00040078003F0004003
+C002F0008003C002F0008003C002F0008003E00478018001E00478010001E00478010001
+E0083C010000F0083C020000F0083C020000F0101E02000078101E04000078101E040000
+78200F0400003C200F0800003C200F0800003C600F8800001E40079000001E4007900000
+1E4007D000001F8003F000000F8003E000000F8003E000000F0001E00000070001C00000
+070001C00000060000C0000002000080002F237FA132> I<FEFEC0C0C0C0C0C0C0C0C0C0
+C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0C0FE
+FE07317BA40E> 91 D<FEFE060606060606060606060606060606060606060606060606
+060606060606060606060606060606060606060606FEFE07317FA40E> 93
+D<1FE000303800780C00780E0030070000070000070000070000FF0007C7001E07003C07
+00780700700700F00708F00708F00708F00F087817083C23900FC1E015157E9418> 97
+D<0E0000FE00001E00000E00000E00000E00000E00000E00000E00000E00000E00000E00
+000E00000E00000E1F000E61C00E80600F00300E00380E003C0E001C0E001E0E001E0E00
+1E0E001E0E001E0E001E0E001E0E001C0E003C0E00380F00700C80600C41C0083F001723
+7FA21B> I<01FE000703000C07801C0780380300780000700000F00000F00000F00000F0
+0000F00000F00000F000007000007800403800401C00800C010007060001F80012157E94
+16> I<0000E0000FE00001E00000E00000E00000E00000E00000E00000E00000E00000E0
+0000E00000E00000E001F8E00704E00C02E01C01E03800E07800E07000E0F000E0F000E0
+F000E0F000E0F000E0F000E0F000E07000E07800E03800E01801E00C02E0070CF001F0FE
+17237EA21B> I<01FC000707000C03801C01C03801C07801E07000E0F000E0FFFFE0F000
+00F00000F00000F00000F000007000007800203800201C00400E008007030000FC001315
+7F9416> I<003E0000E30001C78003878003078007000007000007000007000007000007
+0000070000070000070000FFF80007000007000007000007000007000007000007000007
+00000700000700000700000700000700000700000700000700000700000700000780007F
+F000112380A20F> I<00007003F1980E1E181C0E18380700380700780780780780780780
+7807803807003807001C0E001E1C0033F0002000002000003000003800003FFE001FFFC0
+0FFFE03000F0600030C00018C00018C00018C000186000306000303800E00E038003FE00
+15217F9518> I<0E0000FE00001E00000E00000E00000E00000E00000E00000E00000E00
+000E00000E00000E00000E00000E1F800E60C00E80E00F00700F00700E00700E00700E00
+700E00700E00700E00700E00700E00700E00700E00700E00700E00700E00700E00700E00
+70FFE7FF18237FA21B> I<1C003E003E003E001C00000000000000000000000000000000
+000E007E001E000E000E000E000E000E000E000E000E000E000E000E000E000E000E000E
+000E000E00FFC00A227FA10E> I<00E001F001F001F000E0000000000000000000000000
+00000000007007F000F00070007000700070007000700070007000700070007000700070
+00700070007000700070007000700070007000706070F0E0F0C061803F000C2C83A10F>
+I<0E0000FE00001E00000E00000E00000E00000E00000E00000E00000E00000E00000E00
+000E00000E00000E03FC0E01F00E01C00E01800E02000E04000E08000E10000E38000EF8
+000F1C000E1E000E0E000E07000E07800E03C00E01C00E01E00E00F00E00F8FFE3FE1723
+7FA21A> I<0E00FE001E000E000E000E000E000E000E000E000E000E000E000E000E000E
+000E000E000E000E000E000E000E000E000E000E000E000E000E000E000E000E000E000E
+00FFE00B237FA20E> I<0E1FC07F00FE60E183801E807201C00F003C00E00F003C00E00E
+003800E00E003800E00E003800E00E003800E00E003800E00E003800E00E003800E00E00
+3800E00E003800E00E003800E00E003800E00E003800E00E003800E00E003800E00E0038
+00E0FFE3FF8FFE27157F942A> I<0E1F80FE60C01E80E00F00700F00700E00700E00700E
+00700E00700E00700E00700E00700E00700E00700E00700E00700E00700E00700E00700E
+0070FFE7FF18157F941B> I<01FC000707000C01801800C03800E0700070700070F00078
+F00078F00078F00078F00078F00078F000787000707800F03800E01C01C00E0380070700
+01FC0015157F9418> I<0E1F00FE61C00E80600F00700E00380E003C0E003C0E001E0E00
+1E0E001E0E001E0E001E0E001E0E001E0E003C0E003C0E00380F00700E80E00E41C00E3F
+000E00000E00000E00000E00000E00000E00000E00000E00000E0000FFE000171F7F941B
+> I<01F8200704600E02601C01603801E07800E07800E0F000E0F000E0F000E0F000E0F0
+00E0F000E0F000E07800E07800E03801E01C01E00C02E0070CE001F0E00000E00000E000
+00E00000E00000E00000E00000E00000E00000E0000FFE171F7E941A> I<0E3CFE461E8F
+0F0F0F060F000E000E000E000E000E000E000E000E000E000E000E000E000E000F00FFF0
+10157F9413> I<0F8830786018C018C008C008E008F0007F003FE00FF001F8003C801C80
+0C800CC00CC008E018D0308FC00E157E9413> I<02000200020002000600060006000E00
+1E003E00FFFC0E000E000E000E000E000E000E000E000E000E000E000E040E040E040E04
+0E040E040708030801F00E1F7F9E13> I<0E0070FE07F01E00F00E00700E00700E00700E
+00700E00700E00700E00700E00700E00700E00700E00700E00700E00700E00F00E00F006
+017003827800FC7F18157F941B> I<FF80FE1E00781E00300E00200E0020070040070040
+0780C003808003808001C10001C10000E20000E20000E200007400007400003800003800
+00380000100017157F941A> I<FF8FF87F3E01E03C1C01C0181C01E0180E01E0100E0260
+100E027010070270200704302007043820038438400388184003881C4001C81C8001D00C
+8001D00E8000F00F0000E0070000E00700006006000040020020157F9423> I<FF83FE1F
+00F00E00C007008007810003830001C20000E400007800007800003800003C00004E0000
+8F000187000103800201C00401E00C00E03E01F0FF03FE17157F941A> I<FF80FE1E0078
+1E00300E00200E00200700400700400780C003808003808001C10001C10000E20000E200
+00E200007400007400003800003800003800001000001000002000002000002000004000
+F04000F08000F180004300003C0000171F7F941A> I<3FFFC0380380300780200700600E
+00401C00403C0040380000700000E00001E00001C0000380400700400F00400E00C01C00
+80380080780180700780FFFF8012157F9416> I<FFFFFFFFFFFF3001808C31> 124
+D E
+%EndDVIPSBitmapFont
+%DVIPSBitmapFont: Fl cmbx12 14.4 19
+/Fl 19 118 df<00007FE0030007FFFC07001FFFFF0F007FF00F9F00FF0001FF01FC0000
+FF03F800007F07F000003F0FE000001F1FC000001F1FC000000F3F8000000F3F80000007
+7F800000077F800000077F00000000FF00000000FF00000000FF00000000FF00000000FF
+00000000FF00000000FF00000000FF00000000FF000000007F000000007F800000007F80
+0000073F800000073F800000071FC00000071FC000000E0FE000000E07F000001C03F800
+003C01FC00007800FF0001F0007FF007C0001FFFFF800007FFFE0000007FF00028297CA8
+31> 67 D<FFFFFC0000FFFFFC0000FFFFFC000003FC00000003FC00000003FC00000003
+FC00000003FC00000003FC00000003FC00000003FC00000003FC00000003FC00000003FC
+00000003FC00000003FC00000003FC00000003FC00000003FC00000003FC00000003FC00
+000003FC00000003FC00000003FC00000003FC0001C003FC0001C003FC0001C003FC0001
+C003FC0003C003FC00038003FC00038003FC00078003FC00078003FC000F8003FC000F80
+03FC001F8003FC007F8003FC01FF00FFFFFFFF00FFFFFFFF00FFFFFFFF0022297EA828>
+76 D<0000FFC00000000FFFFC0000003F807F000000FE001FC00001F80007E00003F000
+03F00007E00001F8000FE00001FC001FC00000FE001FC00000FE003F8000007F003F8000
+007F007F8000007F807F0000003F807F0000003F807F0000003F80FF0000003FC0FF0000
+003FC0FF0000003FC0FF0000003FC0FF0000003FC0FF0000003FC0FF0000003FC0FF0000
+003FC0FF0000003FC0FF0000003FC07F0000003F807F8000007F807F8000007F803F8000
+007F003F8000007F001FC00000FE001FC00000FE000FE00001FC0007F00003F80003F800
+07F00001FC000FE00000FE001FC000003FC0FF0000000FFFFC00000000FFC000002A297C
+A833> 79 D<FFFFF0007FFFFFFFF0007FFFFFFFF0007FFF03FE000001C001FE00000380
+01FE0000038001FF0000078000FF0000070000FF80000F00007F80000E00007FC0000E00
+003FC0001C00003FC0001C00003FE0003C00001FE0003800001FF0007800000FF0007000
+000FF80070000007F800E0000007F800E0000003FC01C0000003FC01C0000003FE03C000
+0001FE0380000001FF0780000000FF0700000000FF87000000007F8E000000007F8E0000
+00007FDE000000003FDC000000003FFC000000001FF8000000001FF8000000000FF00000
+00000FF0000000000FF00000000007E00000000007E00000000003C00000000003C00000
+30297FA833> 86 D<03FF80000FFFF0001F01FC003F80FE003F807F003F803F003F803F
+801F003F8000003F8000003F8000003F8000003F80003FFF8001FC3F800FE03F801F803F
+803F003F807E003F80FC003F80FC003F80FC003F80FC003F80FC005F807E00DF803F839F
+FC1FFE0FFC03FC03FC1E1B7E9A21> 97 D<FFE00000FFE00000FFE000000FE000000FE0
+00000FE000000FE000000FE000000FE000000FE000000FE000000FE000000FE000000FE0
+00000FE000000FE1FE000FEFFF800FFE07E00FF803F00FF001F80FE000FC0FE000FC0FE0
+007E0FE0007E0FE0007F0FE0007F0FE0007F0FE0007F0FE0007F0FE0007F0FE0007F0FE0
+007F0FE0007E0FE0007E0FE0007E0FE000FC0FE000FC0FF001F80FF803F00F9C0FE00F0F
+FF800E01FC00202A7EA925> I<00007FF000007FF000007FF0000007F0000007F0000007
+F0000007F0000007F0000007F0000007F0000007F0000007F0000007F0000007F0000007
+F0003F87F001FFF7F007F03FF00FC00FF01F8007F03F0007F03F0007F07E0007F07E0007
+F07E0007F0FE0007F0FE0007F0FE0007F0FE0007F0FE0007F0FE0007F0FE0007F0FE0007
+F07E0007F07E0007F03F0007F03F0007F01F800FF00FC01FF007E07FFF01FFE7FF007F87
+FF202A7EA925> 100 D<003FC00001FFF00003E07C000F803E001F801F001F001F003F00
+0F807E000F807E000FC07E000FC0FE0007C0FE0007C0FFFFFFC0FFFFFFC0FE000000FE00
+0000FE0000007E0000007E0000007F0000003F0001C01F0001C00F80038007C0070003F0
+1E0000FFFC00003FE0001A1B7E9A1F> I<0007F8003FFC007E3E01FC7F03F87F03F07F07
+F07F07F03E07F00007F00007F00007F00007F00007F00007F000FFFFC0FFFFC0FFFFC007
+F00007F00007F00007F00007F00007F00007F00007F00007F00007F00007F00007F00007
+F00007F00007F00007F00007F00007F00007F00007F00007F0007FFF807FFF807FFF8018
+2A7EA915> I<FFE00000FFE00000FFE000000FE000000FE000000FE000000FE000000FE0
+00000FE000000FE000000FE000000FE000000FE000000FE000000FE000000FE07E000FE1
+FF800FE30FC00FE40FE00FE807E00FF807F00FF007F00FF007F00FE007F00FE007F00FE0
+07F00FE007F00FE007F00FE007F00FE007F00FE007F00FE007F00FE007F00FE007F00FE0
+07F00FE007F00FE007F00FE007F00FE007F0FFFE3FFFFFFE3FFFFFFE3FFF202A7DA925>
+104 D<07000F801FC03FE03FE03FE01FC00F8007000000000000000000000000000000FF
+E0FFE0FFE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00F
+E00FE00FE00FE00FE00FE0FFFEFFFEFFFE0F2B7EAA12> I<FFE0FFE0FFE00FE00FE00FE0
+0FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE0
+0FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE00FE0FFFEFFFEFFFE
+0F2A7EA912> 108 D<FFC07E00FFC1FF80FFC30FC00FC40FE00FC807E00FD807F00FD007
+F00FD007F00FE007F00FE007F00FE007F00FE007F00FE007F00FE007F00FE007F00FE007
+F00FE007F00FE007F00FE007F00FE007F00FE007F00FE007F00FE007F00FE007F0FFFE3F
+FFFFFE3FFFFFFE3FFF201B7D9A25> 110 D<003FE00001FFFC0003F07E000FC01F801F80
+0FC03F0007E03F0007E07E0003F07E0003F07E0003F0FE0003F8FE0003F8FE0003F8FE00
+03F8FE0003F8FE0003F8FE0003F8FE0003F87E0003F07E0003F03F0007E03F0007E01F80
+0FC00FC01F8007F07F0001FFFC00003FE0001D1B7E9A22> I<FFE1FE00FFEFFF80FFFE0F
+E00FF803F00FF001F80FE001FC0FE000FC0FE000FE0FE000FE0FE0007F0FE0007F0FE000
+7F0FE0007F0FE0007F0FE0007F0FE0007F0FE0007F0FE0007E0FE000FE0FE000FE0FE000
+FC0FE001FC0FF001F80FF807F00FFC0FE00FEFFF800FE1FC000FE000000FE000000FE000
+000FE000000FE000000FE000000FE000000FE000000FE00000FFFE0000FFFE0000FFFE00
+0020277E9A25> I<FFC1F0FFC7FCFFC63E0FCC7F0FD87F0FD07F0FD07F0FF03E0FE0000F
+E0000FE0000FE0000FE0000FE0000FE0000FE0000FE0000FE0000FE0000FE0000FE0000F
+E0000FE0000FE000FFFF00FFFF00FFFF00181B7F9A1B> 114 D<03FE300FFFF03E03F078
+00F07000F0F00070F00070F80070FE0000FFE0007FFF007FFFC03FFFE01FFFF007FFF800
+FFF80007FC0000FCE0007CE0003CF0003CF00038F80038FC0070FF01E0E7FFC0C1FF0016
+1B7E9A1B> I<00E00000E00000E00000E00001E00001E00001E00003E00003E00007E000
+0FE0001FFFE0FFFFE0FFFFE00FE0000FE0000FE0000FE0000FE0000FE0000FE0000FE000
+0FE0000FE0000FE0000FE0000FE0000FE0700FE0700FE0700FE0700FE0700FE0700FE070
+07F0E003F0C001FF80007F0014267FA51A> I<FFE07FF0FFE07FF0FFE07FF00FE007F00F
+E007F00FE007F00FE007F00FE007F00FE007F00FE007F00FE007F00FE007F00FE007F00F
+E007F00FE007F00FE007F00FE007F00FE007F00FE007F00FE007F00FE007F00FE00FF00F
+E00FF007E017F003F067FF01FFC7FF007F87FF201B7D9A25> I E
+%EndDVIPSBitmapFont
+%DVIPSBitmapFont: Fm cmr12 14.4 20
+/Fm 20 118 df<78FCFCFEFE7A02020202040404080810204007127B8510> 44
+D<00200000E00001E0000FE000FFE000F1E00001E00001E00001E00001E00001E00001E0
+0001E00001E00001E00001E00001E00001E00001E00001E00001E00001E00001E00001E0
+0001E00001E00001E00001E00001E00001E00001E00001E00001E00001E00001E00001E0
+0001E00003F000FFFFC0FFFFC012287BA71D> 49 D<01FC0007FF000C0FC01803E02001
+F06001F04000F84000F8F800FCFC00FCFC007CFC007CFC007C7800FC0000FC0000F80000
+F80001F00001F00003E00003C0000780000700000E00001C0000380000300000600000C0
+000180000300040200040400080800081000082000183FFFF87FFFF0FFFFF0FFFFF01628
+7DA71D> I<000FC0003FF000F01801C01803803C07007C0F007C0E00381E00003C00003C
+00003C0000780000780000780000F83F00F8C1C0F900E0FA0070FA0038FC003CFC001EFC
+001EF8001EF8001FF8001FF8001FF8001F78001F78001F78001F78001F3C001E3C001E1C
+003C1E003C0E007807007003C1E001FFC0007E0018297EA71D> 54
+D<007E0001FF800781C00F00E01E00703C00383C003878003C78003CF8001EF8001EF800
+1EF8001EF8001FF8001FF8001FF8001F78001F78003F78003F3C003F1C005F0E005F0700
+9F03831F00FC1F00001E00001E00001E00003E00003C00003C0000381C00783E00703E00
+E03C01C01803801C0F000FFE0003F80018297EA71D> 57 D<0000FF00100007FFE03000
+1FC07830003E000C7000F80006F001F00003F003E00001F007C00000F00F800000700F80
+0000701F000000303F000000303E000000303E000000107E000000107E000000107C0000
+0000FC00000000FC00000000FC00000000FC00000000FC00000000FC00000000FC000000
+00FC00000000FC0000FFFF7C0000FFFF7E000003F07E000001F03E000001F03E000001F0
+3F000001F01F000001F00F800001F00F800001F007C00001F003E00001F001F00002F000
+F80002F0003E000C70001FC038300007FFE0100000FF8000282B7DA92E> 71
+D<01FFFE01FFFE0007E00003E00003E00003E00003E00003E00003E00003E00003E00003
+E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003
+E00003E00003E00003E00003E00003E00003E00003E03003E07803E0FC03E0FC03E0FC03
+C0F807C0400780200F00300E000C3C0003F000172A7DA81E> 74
+D<0001FF0000000F01E000003C0078000078003C0000E0000E0001E0000F0003C0000780
+07800003C00F800003E01F000001F01F000001F03E000000F83E000000F87E000000FC7E
+000000FC7C0000007C7C0000007CFC0000007EFC0000007EFC0000007EFC0000007EFC00
+00007EFC0000007EFC0000007EFC0000007EFC0000007E7C0000007C7E000000FC7E0000
+00FC7E000000FC3E000000F83F000001F81F000001F01F000001F00F800003E007800003
+C007C00007C003E0000F8000F0001E000078003C00003C007800000F01E0000001FF0000
+272B7DA92E> 79 D<03FC00000C070000100380003C01C0003E01E0003E00F0001C00F0
+000800F0000000F0000000F0000000F000007FF00003E0F0000F80F0001E00F0003C00F0
+007C00F0007800F040F800F040F800F040F800F040F801F0407C01F0403C0278801E0C7F
+8007F01E001A1A7E991D> 97 D<0F000000FF000000FF0000001F0000000F0000000F00
+00000F0000000F0000000F0000000F0000000F0000000F0000000F0000000F0000000F00
+00000F0000000F07E0000F1838000F600E000F8007000F8007800F0003C00F0003C00F00
+01E00F0001E00F0001F00F0001F00F0001F00F0001F00F0001F00F0001F00F0001F00F00
+01E00F0001E00F0003E00F0003C00F0003800F8007800E800F000E401C000C303800080F
+C0001C2A7EA921> I<007F0001C0E00700100E00781E00F83C00F83C00707C0020780000
+F80000F80000F80000F80000F80000F80000F80000F800007800007C00003C00083C0008
+1E00100E002007006001C180007E00151A7E991A> I<00FC000387800701C00E01E01C00
+E03C00F03C00F0780078780078F80078F80078FFFFF8F80000F80000F80000F80000F800
+007800007800003C00083C00081E00100E002007004001C180007E00151A7E991A> 101
+D<00000F0001FC3080070743800E03C3801E03C1003C01E0003C01E0007C01F0007C01F0
+007C01F0007C01F0007C01F0003C01E0003C01E0001E03C0000E0380001707000011FC00
+0030000000300000003000000030000000180000001FFF80000FFFF00007FFF80018007C
+0030001E0070000E0060000700E0000700E0000700E0000700E000070070000E0070000E
+0038001C001C0038000781E00000FF000019287E9A1D> 103 D<1E003F003F003F003F00
+1E000000000000000000000000000000000000000F00FF00FF001F000F000F000F000F00
+0F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F00FFF0FFF0
+0C297EA811> 105 D<007E0003C3C00700E00E00701C00383C003C3C003C78001E78001E
+F8001FF8001FF8001FF8001FF8001FF8001FF8001FF8001F78001E78001E3C003C3C003C
+1C00380E00700700E003C3C0007E00181A7E991D> 111 D<003F010001E0830003804300
+0F0027001E0017001E001F003C000F007C000F007C000F0078000F00F8000F00F8000F00
+F8000F00F8000F00F8000F00F8000F00F8000F007C000F007C000F003C000F003E001F00
+1E001F000F002F0007804F0001C18F00007E0F0000000F0000000F0000000F0000000F00
+00000F0000000F0000000F0000000F0000000F0000000F000000FFF00000FFF01C267E99
+1F> 113 D<0F0F80FF11C0FF23E01F43E00F83E00F81C00F80000F00000F00000F00000F
+00000F00000F00000F00000F00000F00000F00000F00000F00000F00000F00000F00000F
+00000F8000FFFC00FFFC00131A7E9917> I<07F0801C0D80300380600180E00180E00080
+E00080F00080F800007E00007FE0003FFC001FFE0007FF00003F800007808003C08003C0
+8001C0C001C0C001C0E00180E00380F00300CC0E0083F800121A7E9917> I<0080000080
+000080000080000180000180000180000380000380000780000F80001FFF80FFFF800780
+000780000780000780000780000780000780000780000780000780000780000780000780
+0007804007804007804007804007804007804007804003C08001C08000E100003E001225
+7FA417> I<0F000F00FF00FF00FF00FF001F001F000F000F000F000F000F000F000F000F
+000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F000F
+000F000F000F000F000F000F000F001F000F001F0007002F0003804F8001C08FF0007F0F
+F01C1A7E9921> I E
+%EndDVIPSBitmapFont
+%DVIPSBitmapFont: Fn cmr17 20.74 18
+/Fn 18 119 df<000001FF00008000001FFFE0018000007F007801800001F8000E038000
+03E000070780000FC000018780001F000000CF80003E0000006F80007C0000003F8000F8
+0000003F8001F00000001F8003F00000000F8007E00000000F8007C000000007800FC000
+000007800FC000000007801F8000000003801F8000000003803F8000000003803F000000
+0001803F0000000001807F0000000001807F0000000001807E0000000000007E00000000
+0000FE000000000000FE000000000000FE000000000000FE000000000000FE0000000000
+00FE000000000000FE000000000000FE000000000000FE000000000000FE000000000000
+FE0000000000007E0000000000007E0000000000007F0000000000007F0000000001803F
+0000000001803F0000000001803F8000000001801F8000000001801F8000000003000FC0
+00000003000FC0000000030007E0000000060007E0000000060003F0000000060001F000
+00000C0000F80000001800007C0000001800003E0000003000001F0000006000000FC000
+01C0000003E0000380000001F8000E000000007F007C000000001FFFF00000000001FF00
+0000313D7CBB39> 67 D<FFFFFC000000FFFFFC00000003FE0000000001F80000000001
+F80000000001F80000000001F80000000001F80000000001F80000000001F80000000001
+F80000000001F80000000001F80000000001F80000000001F80000000001F80000000001
+F80000000001F80000000001F80000000001F80000000001F80000000001F80000000001
+F80000000001F80000000001F80000000001F80000000001F80000000001F80000000001
+F80000000001F80000000001F80000000001F80000000001F80000000001F80000000001
+F80000000001F80000000001F80000000001F80000006001F80000006001F80000006001
+F80000006001F80000006001F8000000E001F8000000C001F8000000C001F8000000C001
+F8000000C001F8000001C001F8000001C001F8000001C001F8000003C001F8000007C001
+F8000007C001F800000FC001F800003F8001F80000FF8003FC0007FF80FFFFFFFFFF80FF
+FFFFFFFF802B3B7CBA32> 76 D<000003FF00000000001E01E000000000F0003C000000
+03C0000F000000078000078000000F000003C000003E000001F000007C000000F80000F8
+0000007C0001F00000003E0001F00000003E0003E00000001F0007E00000001F8007C000
+00000F800FC00000000FC00F8000000007C01F8000000007E01F8000000007E03F000000
+0003F03F0000000003F03F0000000003F07F0000000003F87E0000000001F87E00000000
+01F87E0000000001F8FE0000000001FCFE0000000001FCFE0000000001FCFE0000000001
+FCFE0000000001FCFE0000000001FCFE0000000001FCFE0000000001FCFE0000000001FC
+FE0000000001FCFE0000000001FC7E0000000001F87F0000000003F87F0000000003F87F
+0000000003F87F0000000003F83F0000000003F03F8000000007F01F8000000007E01F80
+00000007E01FC00000000FE00FC00000000FC007C00000000F8007E00000001F8003E000
+00001F0001F00000003E0001F80000007E0000F80000007C00007C000000F800003E0000
+01F000000F000003C000000780000780000003E0001F00000000F8007C000000001E01E0
+0000000003FF000000363D7CBB3E> 79 D<003F80000001C0F0000003003C000004001E
+00000C000F000018000780001C0007C0003E0003C0003F0003E0003F0003E0003F0003E0
+001E0003E000000003E000000003E000000003E00000003FE000000FF3E000007E03E000
+01F803E00003E003E0000FC003E0001F8003E0003F0003E0003E0003E0007E0003E0007E
+0003E060FC0003E060FC0003E060FC0003E060FC0007E060FC0007E0607C000BE0607E00
+0BE0603E0011F0C01F0060F0C007C1807F8000FE003E0023257CA427> 97
+D<03E0000000FFE0000000FFE000000007E000000003E000000003E000000003E0000000
+03E000000003E000000003E000000003E000000003E000000003E000000003E000000003
+E000000003E000000003E000000003E000000003E000000003E000000003E000000003E0
+00000003E000000003E03FC00003E0E0780003E3001C0003E6000F0003E800078003F800
+03C003F00001E003E00001F003E00000F003E00000F803E00000F803E00000FC03E00000
+7C03E000007C03E000007E03E000007E03E000007E03E000007E03E000007E03E000007E
+03E000007E03E000007E03E000007E03E000007C03E000007C03E00000FC03E00000F803
+E00000F803E00001F003E00001E003F00003E003D80003C003C80007800384000E000383
+001C000381C0F00003003F8000273C7EBB2C> I<0007F800003C0E0000F0018001E000C0
+03C00060078000300F0000701F0000F81F0001F83E0001F83E0001F87E0000F07C000000
+7C000000FC000000FC000000FC000000FC000000FC000000FC000000FC000000FC000000
+FC0000007C0000007C0000007E0000003E0000003E00000C1F00000C1F0000180F800018
+0780003003C0006001E000C000F00180003C0E000007F8001E257DA423> I<0007F80000
+3C1E0000F0078001C003C003C001E0078000F00F0000F81F0000781E00007C3E00007C3E
+00007C7E00003E7C00003E7C00003EFC00003EFC00003EFFFFFFFEFC000000FC000000FC
+000000FC000000FC000000FC0000007C0000007C0000007E0000003E0000003E0000061F
+0000060F00000C0F80000C0780001803C0003000E00060007000C0001E07000003FC001F
+257EA423> 101 D<0000FC0000078300000E0380001C07C0003C0FC000780FC000F80FC0
+00F8078000F0000001F0000001F0000001F0000001F0000001F0000001F0000001F00000
+01F0000001F0000001F0000001F0000001F0000001F0000001F00000FFFFFC00FFFFFC00
+01F0000001F0000001F0000001F0000001F0000001F0000001F0000001F0000001F00000
+01F0000001F0000001F0000001F0000001F0000001F0000001F0000001F0000001F00000
+01F0000001F0000001F0000001F0000001F0000001F0000001F0000001F0000001F00000
+01F0000001F0000001F0000001F0000001F0000003F800007FFFE0007FFFE0001A3C7FBB
+18> I<07000F801FC01FC01FC00F80070000000000000000000000000000000000000000
+0000000000000007C0FFC0FFC00FC007C007C007C007C007C007C007C007C007C007C007
+C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007
+C007C00FE0FFFEFFFE0F397DB815> 105 D<0003800007C0000FE0000FE0000FE00007C0
+000380000000000000000000000000000000000000000000000000000000000000000000
+0000000000000007E000FFE000FFE0000FE00003E00003E00003E00003E00003E00003E0
+0003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E0
+0003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E0
+0003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E00003E0
+7803C0FC07C0FC0780FC0780FC0F00780E00381C000FE000134A82B818> I<07C0FFC0FF
+C00FC007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007
+C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007
+C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007C007
+C00FE0FFFEFFFE0F3C7DBB15> 108 D<03E01FE0003FC000FFE0607C00C0F800FFE0801E
+01003C0007E3000F06001E0003E4000F88001F0003E4000F88001F0003E8000790000F00
+03E80007D0000F8003F00007E0000F8003F00007E0000F8003E00007C0000F8003E00007
+C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F80
+03E00007C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F8003E00007
+C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F80
+03E00007C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F8003E00007
+C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F8003E00007C0000F80
+07F0000FE0001FC0FFFF81FFFF03FFFEFFFF81FFFF03FFFE3F257EA443> I<03E01FE000
+FFE0607C00FFE0801E0007E3000F0003E4000F8003E4000F8003E800078003E80007C003
+F00007C003F00007C003E00007C003E00007C003E00007C003E00007C003E00007C003E0
+0007C003E00007C003E00007C003E00007C003E00007C003E00007C003E00007C003E000
+07C003E00007C003E00007C003E00007C003E00007C003E00007C003E00007C003E00007
+C003E00007C003E00007C003E00007C003E00007C007F0000FE0FFFF81FFFFFFFF81FFFF
+28257EA42C> I<0007FC0000001C070000007001C00001E000F00003C00078000780003C
+000F00001E001F00001F001E00000F003E00000F803E00000F807C000007C07C000007C0
+7C000007C0FC000007E0FC000007E0FC000007E0FC000007E0FC000007E0FC000007E0FC
+000007E0FC000007E0FC000007E07C000007C07C000007C07E00000FC03E00000F803E00
+000F801E00000F001F00001F000F00001E000780003C0003C000780001E000F000007001
+C000001C0700000007FC000023257EA427> I<03E03E00FFE0C300FFE1078007E20FC003
+E40FC003E80FC003E8078003E8030003F0000003F0000003F0000003E0000003E0000003
+E0000003E0000003E0000003E0000003E0000003E0000003E0000003E0000003E0000003
+E0000003E0000003E0000003E0000003E0000003E0000003E0000003E0000003E0000003
+E0000003E0000003E0000007F00000FFFFC000FFFFC0001A257EA41E> 114
+D<00FF02000700C6000C002E0010001E0030001E0060000E0060000E00E0000600E00006
+00E0000600F0000600F8000600FC0000007F0000003FF000003FFF80000FFFE00007FFF0
+0001FFFC00003FFE000001FE0000003F00C0001F00C0000F80C0000780E0000380E00003
+80E0000380E0000380F0000300F0000300F8000700F8000600E4000C00E2001800C18070
+00807F800019257DA41F> I<003000000030000000300000003000000030000000300000
+0070000000700000007000000070000000F0000000F0000001F0000001F0000003F00000
+07F000001FFFFE00FFFFFE0001F0000001F0000001F0000001F0000001F0000001F00000
+01F0000001F0000001F0000001F0000001F0000001F0000001F0000001F0000001F00000
+01F0000001F0000001F0000001F0000001F0018001F0018001F0018001F0018001F00180
+01F0018001F0018001F0018001F0018000F0010000F8030000F8030000780200003C0400
+000E08000003F00019357FB41E> I<FFFE000FFFFFFE000FFF07F00007F803E00003E003
+E00001C001F00001C001F000018001F800018000F800030000F8000300007C000600007C
+000600007E000600003E000C00003E000C00003F001C00001F001800001F001800000F80
+3000000F803000000FC070000007C060000007C060000003E0C0000003E0C0000003F1C0
+000001F180000001F180000000FB00000000FB00000000FF000000007E000000007E0000
+00003C000000003C000000003C0000000018000028257FA42A> 118
+D E
+%EndDVIPSBitmapFont
+end
+%%EndProlog
+%%BeginSetup
+%%Feature: *Resolution 300dpi
+TeXDict begin
+%%PaperSize: a4
+
+userdict/PStoPSxform PStoPSmatrix matrix currentmatrix
+ matrix invertmatrix matrix concatmatrix
+ matrix invertmatrix put
+%%EndSetup
+%%Page: (0,1) 1
+userdict/PStoPSsaved save put
+PStoPSmatrix setmatrix
+595.000000 0.271378 translate
+90 rotate
+0.706651 dup scale
+userdict/PStoPSmatrix matrix currentmatrix put
+userdict/PStoPSclip{0 0 moveto
+ 595.000000 0 rlineto 0 842.000000 rlineto -595.000000 0 rlineto
+ closepath}put initclip
+/showpage{}def/copypage{}def/erasepage{}def
+PStoPSxform concat
+1 0 bop Fn 281 370 a(Cleaner) p 570 370 a(seman) n(tics) p
+927 370 a(for) p 1047 370 a(Ob) t(jectiv) n(e) p 1404
+370 a(Lab) r(el) p Fm 717 518 a(Jacques) p 934 518 a(Garrigue) 719
+634 y(Octob) r(er) p 945 634 a(26,) p 1040 634 a(1999) p
+Fl 11 836 a(Credits) p Fk 11 929 a(This) p 122 929 a(prop) q(osal) p
+319 929 a(con) o(tains) p 510 929 a(ideas) p 632 929
+a(from) p 747 929 a(Damien) p 928 929 a(Doligez) p 1101
+929 a(and) p 1196 929 a(Pierre) p 1340 929 a(W) l(eis.) p
+Fl 11 1073 a(Lab) r(els) p 221 1073 a(and) p 351 1073
+a(optionals) p Fk 11 1165 a(Lab) q(els) p 165 1165 a(and) p
+259 1165 a(optional) p 449 1165 a(argumen) o(ts) p 687
+1165 a(had) p 781 1165 a(t) o(w) o(o) p 873 1165 a(problems) p
+1082 1165 a(in) p 1139 1165 a(Ob) s(jectiv) o(e) p 1360
+1165 a(Lab) q(el.) p Fj 83 1280 a(\017) p Fk 133 1280
+a(They) p 259 1280 a(w) o(ere) p 372 1280 a(not) p 459
+1280 a(fully) p 570 1280 a(coheren) o(t) p 767 1280 a(with) p
+878 1280 a(the) p 963 1280 a(original) p 1139 1280 a(call-b) o(y-v) m
+(alue) p 1423 1280 a(seman) o(tics) p 1644 1280 a(of) p
+1700 1280 a(the) p 1784 1280 a(lan-) 133 1340 y(guage.) p
+303 1340 a(In) p 368 1340 a(some) p 495 1340 a(\(subtle\)) p
+681 1340 a(cases,) p 823 1340 a(a) p 868 1340 a(side-e\013ect) p
+1099 1340 a(migh) o(t) p 1243 1340 a(get) p 1329 1340
+a(dela) o(y) o(ed) p 1508 1340 a(more) p 1635 1340 a(than) p
+1753 1340 a(in) p 1814 1340 a(an) 133 1400 y(un) o(t) o(yp) q(ed) p
+322 1400 a(seman) o(tics.) p Fj 83 1502 a(\017) p Fk
+133 1502 a(F) l(or) p 220 1502 a(optional) p 410 1502
+a(argumen) o(ts,) p 660 1502 a(no) p 728 1502 a(un) o(t) o(yp) q(ed) p
+918 1502 a(seman) o(tics) p 1139 1502 a(existed.) 84
+1616 y(This) p 195 1616 a(new) p 295 1616 a(prop) q(osal) p
+492 1616 a(corrects) p 674 1616 a(these) p 799 1616 a(t) o(w) o(o) p
+891 1616 a(\015a) o(ws.) p Fi 11 1746 a(Syn) n(tax) p
+Fk 11 1838 a(W) l(e) p 95 1838 a(k) o(eep) p 206 1838
+a(Ob) s(jectiv) o(e) p 426 1838 a(Lab) q(el's) p 594
+1838 a(syn) o(tax,) p 764 1838 a(except) p 917 1838 a(for) p
+991 1838 a(default) p 1155 1838 a(v) m(alues) p 1301
+1838 a(in) p 1357 1838 a(optional) p 1547 1838 a(argumen) o(ts.) p
+Fh 329 1944 a(typ) n(expr) p Fk 528 1944 a(::=) p Fg
+634 1944 a(:) p 656 1944 a(:) p 678 1944 a(:) p Fj 579
+2004 a(j) p Fh 634 2004 a(typ) n(expr) p Fj 806 2004
+a(!) p Fh 870 2004 a(typ) n(expr) p Fj 579 2064 a(j) p
+Fk 634 2064 a([?]) p Fi(lab) r(el) p Fk 801 2064 a(:) p
+Fh(typ) n(expr) p Fj 987 2064 a(!) p Fh 1050 2064 a(typ) n(expr) 391
+2124 y(expr) p Fk 528 2124 a(::=) p Fg 634 2124 a(:) p
+656 2124 a(:) p 678 2124 a(:) p Fj 579 2185 a(j) p Fh
+634 2185 a(expr) p 746 2185 a(lab) n(ele) n(d-expr) p
+Ff 991 2163 a(+) p Fj 579 2245 a(j) p Fe 634 2245 a(fun) p
+Fj 728 2245 a(f) p Fh(lab) n(ele) n(d-simple-p) n(attern) p
+Fj 1209 2245 a(g) p Ff 1234 2227 a(+) p Fk 1280 2245
+a([) p Fe(when) p Fh 1412 2245 a(expr) p Fk 1507 2245
+a(]) p Fj 1535 2245 a(!) p Fh 1599 2245 a(expr) p Fj
+579 2305 a(j) p Fe 634 2305 a(function) p Fh 856 2305
+a(lab) n(ele) n(d-p) n(attern) p Fk 1177 2305 a([) p
+Fe(when) p Fh 1309 2305 a(expr) p Fk 1404 2305 a(]) p
+Fj 1432 2305 a(!) p Fh 1496 2305 a(expr) p Fj 785 2365
+a(f) p Fe(|) p Fh 851 2365 a(lab) n(ele) n(d-p) n(attern) p
+Fk 1172 2365 a([) p Fe(when) p Fg 1305 2365 a(expr) p
+Fk 1403 2365 a(]) p Fj 1430 2365 a(!) p Fh 1494 2365
+a(expr) p Fj 1589 2365 a(g) p Fd 1614 2347 a(\003) p
+Fh 242 2425 a(lab) n(ele) n(d-expr) p Fk 528 2425 a(::=) p
+634 2425 a([?]) p Fh(expr) p Fj 579 2486 a(j) p Fk 634
+2486 a([?]) p Fi(lab) r(el) p Fk 801 2486 a(:) p Fh(expr) 182
+2546 y(lab) n(ele) n(d-p) n(attern) p Fk 528 2546 a(::=) p
+Fh 634 2546 a(p) n(attern) p Fj 579 2606 a(j) p Fi 634
+2606 a(lab) r(el) p Fk 751 2606 a(:) p Fh(p) n(attern) p
+Fj 579 2666 a(j) p Fk 634 2666 a(?[) p Fe(\() p Fh(expr) p
+Fe(\)) p Fk(]) p Fi(lab) r(el) p Fk 943 2666 a(:) p Fh
+956 2666 a(p) n(attern) p Fk 926 2937 a(1) p eop
+PStoPSsaved restore
+userdict/PStoPSsaved save put
+PStoPSmatrix setmatrix
+595.000000 421.271378 translate
+90 rotate
+0.706651 dup scale
+userdict/PStoPSmatrix matrix currentmatrix put
+userdict/PStoPSclip{0 0 moveto
+ 595.000000 0 rlineto 0 842.000000 rlineto -595.000000 0 rlineto
+ closepath}put initclip
+PStoPSxform concat
+2 1 bop Fi 11 168 a(Dynamic) p 247 168 a(seman) n(tics) p
+Fj 11 261 a(;) p Fk 52 261 a(is) p 101 261 a(a) p 141
+261 a(notation) p 337 261 a(for) p 411 261 a(the) p 495
+261 a(empt) o(y) p 644 261 a(lab) q(el.) 86 366 y(\() p
+Fe(fun) p Fi 198 366 a(l) p Fc 214 373 a(i) p Fk 227
+366 a(:) p Fg(x) p Fj 282 366 a(!) p Fg 346 366 a(e) p
+Fk(\)) p Fi 404 366 a(l) p Fc 420 373 a(1) p Fk 442 366
+a(:) p Fg 455 366 a(e) p Ff 478 373 a(1) p Fg 506 366
+a(:) p 528 366 a(:) p 550 366 a(:) p Fi 571 366 a(l) p
+Fc 587 373 a(n) p Fk 612 366 a(:) p Fg 625 366 a(e) p
+Fb 648 373 a(n) p Fj 515 427 a(!) p Fk 579 427 a(\() p
+Fg(e) p Fk([) p Fg(e) p Fb 658 434 a(i) p Fg 671 427
+a(=x) p Fk(]) p Fi 752 427 a(l) p Fc 768 434 a(1) p Fk
+790 427 a(:) p Fg(e) p Ff 827 434 a(1) p Fg 855 427 a(:) p
+877 427 a(:) p 899 427 a(:) p Fi 920 427 a(l) p Fc 936
+434 a(i) p Fd(\000) p Fc(1) p Fk 997 427 a(:) p Fg 1010
+427 a(e) p Fb 1033 434 a(i) p Fd(\000) p Ff(1) p Fi 1108
+427 a(l) p Fc 1124 434 a(i) p Ff(+) p Fc(1) p Fk 1185
+427 a(:) p Fg(e) p Fb 1222 434 a(i) p Ff(+1) p Fg 1289
+427 a(:) p 1311 427 a(:) p 1333 427 a(:) p Fi 1354 427
+a(l) p Fc 1370 434 a(n) p Fk 1395 427 a(:) p Fg 1408
+427 a(e) p Fb 1431 434 a(n) p Fk 86 487 a(\() p Fe(fun) p
+Fk 198 487 a(?) p Fi(l) p Fc 237 494 a(i) p Fk 250 487
+a(:) p Fg(x) p Fj 305 487 a(!) p Fg 369 487 a(e) p Fk(\)) p
+Fi 427 487 a(l) p Fc 443 494 a(1) p Fk 465 487 a(:) p
+Fg 478 487 a(e) p Ff 501 494 a(1) p Fg 529 487 a(:) p
+551 487 a(:) p 573 487 a(:) p Fi 594 487 a(l) p Fc 610
+494 a(n) p Fk 635 487 a(:) p Fg 648 487 a(e) p Fb 671
+494 a(n) p Fj 515 547 a(!) p Fg 579 547 a(e) p Fk([) p
+Fe(Some) p Fk 717 547 a(\() p Fg(e) p Fb 759 554 a(i) p
+Fk 773 547 a(\)) p Fg(=x) p Fk(]) p Fi 874 547 a(l) p
+Fc 890 554 a(1) p Fk 912 547 a(:) p Fg 925 547 a(e) p
+Ff 948 554 a(1) p Fg 976 547 a(:) p 998 547 a(:) p 1020
+547 a(:) p Fi 1042 547 a(l) p Fc 1058 554 a(i) p Fd(\000) p
+Fc(1) p Fk 1118 547 a(:) p Fg(e) p Fb 1155 554 a(i) p
+Fd(\000) p Ff(1) p Fi 1230 547 a(l) p Fc 1246 554 a(i) p
+Ff(+) p Fc(1) p Fk 1307 547 a(:) p Fg 1320 547 a(e) p
+Fb 1343 554 a(i) p Ff(+1) p Fg 1410 547 a(:) p 1432 547
+a(:) p 1454 547 a(:) p Fi 1476 547 a(l) p Fc 1492 554
+a(n) p Fk 1516 547 a(:) p Fg(e) p Fb 1553 554 a(n) p
+Fk 86 607 a(\() p Fe(fun) p Fk 198 607 a(?) p Fi(l) p
+Fk(:) p Fg 250 607 a(x) p Fj 292 607 a(!) p Fg 356 607
+a(e) p Fk(\)) p Fi 413 607 a(l) p Fc 429 614 a(1) p Fk
+451 607 a(:) p Fg(e) p Ff 488 614 a(1) p Fg 516 607 a(:) p
+538 607 a(:) p 560 607 a(:) p Fi 581 607 a(l) p Fc 597
+614 a(n) p Fk 621 607 a(:) p Fg(e) p Fb 658 614 a(n) p
+Fk 1154 607 a(when) p Fi 1281 607 a(l) p Fc 1297 614
+a(i) p Fk 1324 607 a(=) p Fj 1376 607 a(;) p Fk 1417
+607 a(and) p Fg 1512 607 a(l) p Fj 1541 607 a(62) p 1588
+607 a(f) p Fi(l) p Fc 1629 614 a(1) p Fg 1660 607 a(:) p
+1682 607 a(:) p 1704 607 a(:) p Fi 1725 607 a(l) p Fc
+1741 614 a(n) p Fj 1765 607 a(g) 515 667 y(!) p Fg 579
+667 a(e) p Fk([) p Fe(None) p Fg 717 667 a(=x) p Fk(]) p
+Fi 799 667 a(l) p Fc 815 674 a(1) p Fk 837 667 a(:) p
+Fg(e) p Ff 874 674 a(1) p Fg 901 667 a(:) p 923 667 a(:) p
+945 667 a(:) p Fi 967 667 a(l) p Fc 983 674 a(n) p Fk
+1007 667 a(:) p Fg(e) p Fb 1044 674 a(n) p Fk 86 728
+a(\(\() p Fe(fun) p Fi 217 728 a(l) p Fk(:) p Fg 246
+728 a(x) p Fj 288 728 a(!) p Fg 352 728 a(e) p Fk(\)) p
+Fi 409 728 a(l) p Fc 425 735 a(1) p Fk 447 728 a(:) p
+Fg(e) p Ff 484 735 a(1) p Fg 511 728 a(:) p 533 728 a(:) p
+555 728 a(:) p Fi 577 728 a(l) p Fc 593 735 a(m) p Fk
+629 728 a(:) p Fg 642 728 a(e) p Fb 665 735 a(m) p Fk
+698 728 a(\)) p Fi 733 728 a(l) p Fc 749 735 a(m) p Ff(+) p
+Fc(1) p Fk 833 728 a(:) p Fg 846 728 a(e) p Fb 869 735
+a(m) p Ff(+1) p Fg 955 728 a(:) p 977 728 a(:) p 999
+728 a(:) p Fi 1021 728 a(l) p Fc 1037 735 a(n) p Fk 1061
+728 a(:) p Fg(e) p Fb 1098 735 a(n) p Fk 1373 728 a(when) p
+Fi 1501 728 a(l) p Fj 1530 728 a(62) p 1577 728 a(f) p
+Fi(l) p Fc 1618 735 a(1) p Fg 1648 728 a(:) p 1670 728
+a(:) p 1692 728 a(:) p Fi 1714 728 a(l) p Fc 1730 735
+a(m) p Fj 1765 728 a(g) 515 788 y(!) p Fk 579 788 a(\() p
+Fe(fun) p Fi 691 788 a(l) p Fk(:) p Fg 720 788 a(x) p
+Fj 761 788 a(!) p Fg 825 788 a(e) p Fk(\)) p Fi 883 788
+a(l) p Fc 899 795 a(1) p Fk 921 788 a(:) p Fg 934 788
+a(e) p Ff 957 795 a(1) p Fg 985 788 a(:) p 1007 788 a(:) p
+1029 788 a(:) p Fi 1051 788 a(l) p Fc 1067 795 a(n) p
+Fk 1091 788 a(:) p Fg 1104 788 a(e) p Fb 1127 795 a(n) p
+Fk 86 848 a(\(\() p Fe(fun) p Fk 217 848 a(?) p Fi(l) p
+Fk(:) p Fg 269 848 a(x) p Fj 311 848 a(!) p Fg 375 848
+a(e) p Fk(\)) p Fi 432 848 a(l) p Fc 448 855 a(1) p Fk
+470 848 a(:) p Fg(e) p Ff 507 855 a(1) p Fg 535 848 a(:) p
+557 848 a(:) p 579 848 a(:) p Fi 600 848 a(l) p Fc 616
+855 a(m) p Fk 652 848 a(:) p Fg 665 848 a(e) p Fb 688
+855 a(m) p Fk 721 848 a(\)) p Fi 756 848 a(l) p Fc 772
+855 a(m) p Ff(+) p Fc(1) p Fk 856 848 a(:) p Fg 869 848
+a(e) p Fb 892 855 a(m) p Ff(+1) p Fg 978 848 a(:) p 1000
+848 a(:) p 1022 848 a(:) p Fi 1044 848 a(l) p Fc 1060
+855 a(n) p Fk 1084 848 a(:) p Fg(e) p Fb 1121 855 a(n) p
+Fk 1261 848 a(when) p Fj 1388 848 a(f) p Fi(l) p Fg(;) p
+Fj 1451 848 a(;g) p 1530 848 a(6) m(\\) p 1577 848 a(f) p
+Fi(l) p Fc 1618 855 a(1) p Fg 1648 848 a(:) p 1670 848
+a(:) p 1692 848 a(:) p Fi 1714 848 a(l) p Fc 1730 855
+a(m) p Fj 1765 848 a(g) 515 908 y(!) p Fk 579 908 a(\() p
+Fe(fun) p Fk 691 908 a(?) p Fi(l) p Fk(:) p Fg 743 908
+a(x) p Fj 785 908 a(!) p Fg 848 908 a(e) p Fk(\)) p Fi
+906 908 a(l) p Fc 922 915 a(1) p Fk 944 908 a(:) p Fg(e) p
+Ff 981 915 a(1) p Fg 1008 908 a(:) p 1030 908 a(:) p
+1052 908 a(:) p Fi 1074 908 a(l) p Fc 1090 915 a(n) p
+Fk 1114 908 a(:) p Fg 1127 908 a(e) p Fb 1150 915 a(n) p
+Fi 11 1035 a(T) n(yping) p Fk 11 1127 a(Seman) o(tics) p
+240 1127 a(are) p 321 1127 a(k) o(ept) p 430 1127 a(throughout) p
+685 1127 a(compilation) p 950 1127 a(b) o(y) p 1018 1127
+a(disallo) o(wing) p 1269 1127 a(lab) q(el) p 1387 1127
+a(comm) o(utation) p 1684 1127 a(for) p 1759 1127 a(func-) 11
+1187 y(tion) p 116 1187 a(t) o(yp) q(es.) p 278 1187
+a(Ho) o(w) o(ev) o(er,) p 494 1187 a(the) p 583 1187
+a(original) p 764 1187 a(comfort) p 949 1187 a(of) p
+1009 1187 a(out-of-order) p 1283 1187 a(application) p
+1540 1187 a(is) p 1594 1187 a(reco) o(v) o(ered) p 1814
+1187 a(b) o(y) 11 1247 y(allo) o(wing) p 207 1247 a(argumen) o(t) p
+431 1247 a(reordering) p 670 1247 a(in) p 732 1247 a(application,) p
+1005 1247 a(when) p 1138 1247 a(the) p 1227 1247 a(function's) p
+1457 1247 a(t) o(yp) q(e) p 1572 1247 a(is) p Fh 1626
+1247 a(wel) r(l) p 1731 1247 a(known) p Fk 11 1308 a(\() p
+Fh(c.f.) p Fk 118 1308 a(p) q(olymorphic) p 400 1308
+a(metho) q(ds\).) p Fl 11 1452 a(V) p 56 1452 a(arian) n(ts) p
+Fk 11 1544 a(V) l(arian) o(t) p 187 1544 a(t) o(yping,) p
+355 1544 a(as) p 417 1544 a(it) p 468 1544 a(is) p 519
+1544 a(presen) o(ted) p 739 1544 a(in) p 798 1544 a(the) p
+884 1544 a(user's) p 1022 1544 a(man) o(ual,) p 1210
+1544 a(is) p 1261 1544 a(not) p 1350 1544 a(principal:) p
+1576 1544 a(in) p 1635 1544 a(some) p 1760 1544 a(cases) 11
+1605 y(t) o(ypabilit) o(y) p 239 1605 a(of) p 301 1605
+a(an) p 375 1605 a(expression) p 616 1605 a(ma) o(y) p
+728 1605 a(dep) q(end) p 904 1605 a(on) p 978 1605 a(the) p
+1069 1605 a(order) p 1202 1605 a(in) p 1265 1605 a(whic) o(h) p
+1411 1605 a(the) p 1502 1605 a(t) o(yping) p 1660 1605
+a(algorithm) 11 1665 y(pro) q(ceeds.) p Fe 133 1779 a(#) p
+184 1779 a(let) p 286 1779 a(f1) p 363 1779 a(\(x) p
+440 1779 a(:) p 491 1779 a([<) p 568 1779 a(a) p 620
+1779 a(b\(int\)]\)) p 850 1779 a(=) p 902 1779 a(\(\)) 184
+1839 y(let) p 286 1839 a(f2) p 363 1839 a(\(x) p 440
+1839 a(:) p 491 1839 a([<) p 568 1839 a(a]\)) p 671 1839
+a(=) p 722 1839 a(\(\)) 184 1899 y(let) p 286 1899 a(f3) p
+363 1899 a(\(x) p 440 1899 a(:) p 491 1899 a([<) p 568
+1899 a(a) p 620 1899 a(b\(bool\)]\)) p 876 1899 a(=) p
+927 1899 a(\(\);;) 133 1960 y(val) p 235 1960 a(f1) p
+312 1960 a(:) p 363 1960 a([<) p 440 1960 a(a) p 491
+1960 a(b\(int\)]) p 696 1960 a(->) p 773 1960 a(unit) p
+902 1960 a(=) p 953 1960 a(<fun>) 133 2020 y(val) p 235
+2020 a(f2) p 312 2020 a(:) p 363 2020 a([<) p 440 2020
+a(a]) p 517 2020 a(->) p 594 2020 a(unit) p 722 2020
+a(=) p 773 2020 a(<fun>) 133 2080 y(val) p 235 2080 a(f3) p
+312 2080 a(:) p 363 2080 a([<) p 440 2080 a(a) p 491
+2080 a(b\(bool\)]) p 722 2080 a(->) p 799 2080 a(unit) p
+927 2080 a(=) p 978 2080 a(<fun>) 133 2140 y(#) p 184
+2140 a(fun) p 286 2140 a(x) p 338 2140 a(->) p 414 2140
+a(f1) p 491 2140 a(x;) p 568 2140 a(f2) p 645 2140 a(x;) p
+722 2140 a(f3) p 799 2140 a(x;;) 133 2200 y(-) p 184
+2200 a(:) p 235 2200 a([<) p 312 2200 a(a]) p 389 2200
+a(->) p 466 2200 a(unit) p 594 2200 a(=) p 645 2200 a(<fun>) 133
+2260 y(#) p 184 2260 a(fun) p 286 2260 a(x) p 338 2260
+a(->) p 414 2260 a(f1) p 491 2260 a(x;) p 568 2260 a(f3) p
+645 2260 a(x;;) 133 2321 y(Character) o(s) p 414 2321
+a(18-19:) 133 2381 y(This) p 261 2381 a(expressio) o(n) p
+543 2381 a(has) p 645 2381 a(type) p 773 2381 a([<) p
+850 2381 a(a) p 902 2381 a(b\(int\)]) p 1107 2381 a(but) p
+1209 2381 a(is) p 1286 2381 a(here) p 1414 2381 a(used) p
+1542 2381 a(with) p 1670 2381 a(type) 184 2441 y([<) p
+261 2441 a(a) p 312 2441 a(b\(bool\)]) p Fk 84 2555 a(Here) p
+204 2555 a(the) p 292 2555 a(constrain) o(t) p 526 2555
+a(in) o(tro) q(duced) p 775 2555 a(b) o(y) p Fe 848 2555
+a(f2) p Fk 920 2555 a(hides) p 1049 2555 a(the) p 1138
+2555 a(constructor) p Fe 1401 2555 a(b) p Fk(,) p 1462
+2555 a(and) p 1562 2555 a(a) o(v) o(oids) p 1714 2555
+a(a) p 1760 2555 a(clash) 11 2615 y(b) q(et) o(w) o(een) p
+Fe 199 2615 a(int) p Fk 292 2615 a(and) p Fe 387 2615
+a(bool) p Fk(.) 84 2676 y(An) p 163 2676 a(easy) p 270
+2676 a(w) o(a) o(y) p 369 2676 a(to) p 428 2676 a(solv) o(e) p
+547 2676 a(this) p 642 2676 a(w) o(ould) p 784 2676 a(b) q(e) p
+850 2676 a(to) p 909 2676 a(restrict) p 1077 2676 a(hiding) p
+1226 2676 a(absen) o(t) p 1379 2676 a(lab) q(els) p 1515
+2676 a(to) p 1575 2676 a(generic) p 1739 2676 a(t) o(yp) q(es.) 11
+2736 y(This) p 124 2736 a(w) o(a) o(y) p 224 2736 a(the) p
+310 2736 a(second) p 469 2736 a(case) p 574 2736 a(w) o(ould) p
+718 2736 a(still) p 814 2736 a(fail,) p 913 2736 a(since) p
+Fe 1034 2736 a(x) p Fk 1077 2736 a(has) p 1166 2736 a(a) p
+1208 2736 a(monorphic) p 1451 2736 a(t) o(yp) q(e.) p
+1584 2736 a(This) p 1697 2736 a(solution) 11 2796 y(w) o(ould) p
+153 2796 a(b) q(e) p 219 2796 a(correct) p 382 2796 a(and) p
+477 2796 a(principal.) 926 2937 y(2) p eop
+PStoPSsaved restore
+%%Page: (2,3) 2
+userdict/PStoPSsaved save put
+PStoPSmatrix setmatrix
+595.000000 0.271378 translate
+90 rotate
+0.706651 dup scale
+userdict/PStoPSmatrix matrix currentmatrix put
+userdict/PStoPSclip{0 0 moveto
+ 595.000000 0 rlineto 0 842.000000 rlineto -595.000000 0 rlineto
+ closepath}put initclip
+/showpage{}def/copypage{}def/erasepage{}def
+PStoPSxform concat
+3 2 bop Fk 84 168 a(Ho) o(w) o(ev) o(er,) p 293 168 a(one) p
+382 168 a(can) p 472 168 a(easily) p 606 168 a(see) p
+684 168 a(that) p 789 168 a(this) p 884 168 a(solution) p
+1068 168 a(is) p 1117 168 a(coun) o(ter-in) o(tuitiv) o(e.) p
+1504 168 a(F) l(or) p 1591 168 a(the) p 1675 168 a(user,) p
+Fe 1791 168 a(b) p Fk 1833 168 a(is) 11 229 y(already) p
+183 229 a(an) p 250 229 a(imp) q(ossible) p 488 229 a(constructor,) p
+759 229 a(and) p 854 229 a(ha) o(ving) p 1011 229 a(a) p
+1052 229 a(clash) p 1174 229 a(on) p 1242 229 a(it) p
+1291 229 a(is) p 1340 229 a(hard) p 1453 229 a(to) p
+1513 229 a(understand.) 84 289 y(Another) p 277 289 a(solution) p
+463 289 a(is) p 514 289 a(to) p 575 289 a(go) p 642 289
+a(the) p 728 289 a(opp) q(osite) p 924 289 a(w) o(a) o(y) l(.) p
+1044 289 a(T) l(o) p 1117 289 a(accept) p 1271 289 a(more) p
+1395 289 a(programs.) p 1634 289 a(This) p 1747 289 a(is) p
+1798 289 a(the) 11 349 y(w) o(a) o(y) p 109 349 a(w) o(e) p
+181 349 a(explore) p 351 349 a(here,) p 470 349 a(with) p
+581 349 a(an) p 649 349 a(unc) o(hanged) p 891 349 a(syn) o(tax.) p
+Fi 11 479 a(T) n(yping) p Fk 11 571 a(The) p 114 571
+a(idea) p 220 571 a(is) p 273 571 a(to) p 336 571 a(dela) o(y) p
+466 571 a(uni\014cation) p 711 571 a(on) p 782 571 a(constructor) p
+1043 571 a(un) o(til) p 1161 571 a(they) p 1274 571 a(are) p
+1359 571 a(explicitely) p 1595 571 a(kno) o(wn) p 1753
+571 a(to) p 1816 571 a(b) q(e) 11 631 y(presen) o(t.) p
+199 631 a(W) l(e) p 280 631 a(k) o(eep) p 390 631 a(the) p
+472 631 a(\() p Fg(T) t(;) p 546 631 a(U;) p 601 631
+a(L) p Fk(\)) p 666 631 a(represen) o(tation) p 983 631
+a(of) p 1036 631 a(v) m(arian) o(t) p 1200 631 a(t) o(yp) q(es,) p
+1341 631 a(but) p Fg 1428 631 a(T) p Fk 1478 631 a(is) p
+1525 631 a(no) p 1591 631 a(longer) p 1735 631 a(a) p
+1774 631 a(map) 11 692 y(from) p 126 692 a(constructors) p
+403 692 a(to) p 462 692 a(t) o(yp) q(es,) p 605 692 a(but) p
+694 692 a(from) p 809 692 a(constructors) p 1086 692
+a(to) p 1146 692 a(sets) p 1241 692 a(of) p 1297 692
+a(t) o(yp) q(es.) 84 752 y(When) p 230 752 a(w) o(e) p
+307 752 a(unify) p 436 752 a(t) o(w) o(o) p 532 752 a(v) m(arian) o(t) p
+702 752 a(t) o(yp) q(es,) p 850 752 a(the) p 938 752
+a(\014rst) p 1043 752 a(step) p 1150 752 a(is) p 1204
+752 a(just) p 1305 752 a(to) p 1369 752 a(tak) o(e) p
+1479 752 a(the) p 1567 752 a(union) p 1707 752 a(of) p
+1767 752 a(b) q(oth) 11 812 y(t) o(yping) p 162 812 a(en) o(vironmen) o
+(ts,) p 476 812 a(dropping) p 682 812 a(unnecessary) p
+952 812 a(t) o(yp) q(es.) 204 932 y(\() p Fg(T) p Ff
+252 939 a(1) p Fg 272 932 a(;) p 294 932 a(U) p Ff 327
+939 a(1) p Fg 346 932 a(;) p 368 932 a(L) p Ff 401 939
+a(1) p Fk 421 932 a(\)) p Fj 451 932 a(^) p Fk 495 932
+a(\() p Fg(T) p Ff 543 939 a(2) p Fg 563 932 a(;) p 585
+932 a(U) p Ff 618 939 a(2) p Fg 637 932 a(;) p 659 932
+a(L) p Ff 692 939 a(2) p Fk 712 932 a(\)) p 745 932 a(=) p
+797 932 a(\(\() p Fg(T) p Ff 864 939 a(1) p Fj 883 932
+a(j) p Fb 897 939 a(U) p Fa 921 944 a(1) p Fd 938 939
+a(\\) p Fb(U) p Fa 986 944 a(2) p Fk 1005 932 a(\)) p
+Fj 1035 932 a([) p Fk 1079 932 a(\() p Fg(T) p Ff 1127
+939 a(2) p Fj 1146 932 a(j) p Fb 1160 939 a(U) p Fa 1184
+944 a(1) p Fd 1201 939 a(\\) p Fb(U) p Fa 1249 944 a(2) p
+Fk 1268 932 a(\)) p Fg(;) p 1309 932 a(U) p Ff 1342 939
+a(1) p Fj 1373 932 a(\\) p Fg 1417 932 a(U) p Ff 1450
+939 a(2) p Fg 1470 932 a(;) p 1492 932 a(L) p Ff 1525
+939 a(1) p Fj 1556 932 a([) p Fg 1600 932 a(L) p Ff 1633
+939 a(2) p Fk 1653 932 a(\)) 84 1042 y(Here) p 203 1042
+a(the) p 291 1042 a(union) p 431 1042 a(of) p 490 1042
+a(t) o(w) o(o) p 587 1042 a(t) o(yping) p 742 1042 a(en) o(vironmen) o
+(ts) p 1046 1042 a(is) p 1099 1042 a(the) p 1187 1042
+a(p) q(oin) o(t) o(wise) p 1407 1042 a(union) p 1547
+1042 a(of) p 1606 1042 a(their) p 1727 1042 a(sets) p
+1826 1042 a(of) 11 1102 y(t) o(yp) q(es) p 140 1102 a(for) p
+214 1102 a(eac) o(h) p 324 1102 a(constructor.) 84 1162
+y(This) p 195 1162 a(\014rst) p 296 1162 a(step) p 399
+1162 a(nev) o(er) p 529 1162 a(fails.) 84 1222 y(In) p
+145 1222 a(a) p 186 1222 a(second) p 343 1222 a(step,) p
+460 1222 a(structural) p 685 1222 a(constrain) o(ts) p
+934 1222 a(are) p 1015 1222 a(enforced) p 1209 1222 a(on) p
+1277 1222 a(the) p 1361 1222 a(resulting) p 1562 1222
+a(t) o(yp) q(e) p 1672 1222 a(\() p Fg(T) t(;) p 1746
+1222 a(U;) p 1801 1222 a(L) p Fk(\).) 11 1282 y(First,) p
+Fg 144 1282 a(L) p Fk 195 1282 a(should) p 351 1282 a(b) q(e) p
+418 1282 a(included) p 614 1282 a(in) p Fg 672 1282 a(U) p
+Fk 710 1282 a(.) p 749 1282 a(Then,) p 892 1282 a(for) p
+967 1282 a(all) p 1036 1282 a(constructors) p 1314 1282
+a(app) q(earing) p 1542 1282 a(in) p Fg 1600 1282 a(L) p
+Fk(,) p 1664 1282 a(the) p 1749 1282 a(set) p 1826 1282
+a(of) 11 1343 y(t) o(yp) q(es) p 136 1343 a(asso) q(ciated) p
+365 1343 a(with) p 472 1343 a(eac) o(h) p 578 1343 a(constructor) p
+833 1343 a(is) p 878 1343 a(collapsed) p 1084 1343 a(b) o(y) p
+1148 1343 a(uni\014cation.) p 1407 1343 a(This) p 1515
+1343 a(can) p 1600 1343 a(b) q(e) p 1663 1343 a(expressed) 11
+1403 y(b) o(y) p 78 1403 a(rewriting) p 287 1403 a(rules,) p
+417 1403 a(where) p Fg 558 1403 a(e) p Fk 597 1403 a(is) p
+646 1403 a(a) p 687 1403 a(m) o(ulti-equation) p 1015
+1403 a(and) p Fg 1109 1403 a(\036) p Fk 1155 1403 a(a) p
+1195 1403 a(set) p 1271 1403 a(of) p 1327 1403 a(m) o(ultiequations) 249
+1509 y(if) p Fg 294 1509 a(L) p Fj 341 1509 a(6\032) p
+Fg 393 1509 a(U) p Fk 448 1509 a(then) p 559 1509 a(\() p
+Fg(T) t(;) p 633 1509 a(U;) p 688 1509 a(L) p Fk(\)) p
+753 1509 a(=) p Fg 805 1509 a(e) p Fj 839 1509 a(^) p
+Fg 883 1509 a(\036) p Fj 926 1509 a(\000) p 956 1509
+a(!) p 1020 1509 a(?) p Fk 249 1629 a(if) p Fg 294 1629
+a(l) p Fj 323 1629 a(2) p Fg 370 1629 a(L) p Fk 420 1629
+a(and) p Fg 515 1629 a(T) p Fk 551 1629 a(\() p Fg(l) p
+Fk 586 1629 a(\)) p 617 1629 a(=) p Fj 669 1629 a(f) p
+Fg(\034) p Ff 715 1636 a(1) p Fg 735 1629 a(;) p 757
+1629 a(:) p 779 1629 a(:) p 801 1629 a(:) p 822 1629
+a(;) p 844 1629 a(\034) p Fb 865 1636 a(n) p Fj 889 1629
+a(g) p Fk 930 1629 a(then) 298 1689 y(\() p Fg(T) t(;) p
+372 1689 a(U;) p 427 1689 a(L) p Fk(\)) p 492 1689 a(=) p
+Fg 544 1689 a(e) p Fj 577 1689 a(^) p Fg 622 1689 a(\036) p
+Fj 664 1689 a(\000) p 695 1689 a(!) p Fk 759 1689 a(\() p
+Fg(T) p Fj 814 1689 a(f) p Fg(l) p Fj 867 1689 a(7!) p
+Fg 931 1689 a(\034) p Ff 952 1696 a(1) p Fj 972 1689
+a(g) p Fg(;) p 1019 1689 a(U;) p 1074 1689 a(L) p Fk(\)) p
+1139 1689 a(=) p Fg 1191 1689 a(e) p Fj 1225 1689 a(^) p
+Fg 1269 1689 a(\034) p Ff 1290 1696 a(1) p Fk 1324 1689
+a(=) p Fg 1376 1689 a(:) p 1398 1689 a(:) p 1420 1689
+a(:) p Fk 1447 1689 a(=) p Fg 1498 1689 a(\034) p Fb
+1519 1696 a(n) p Fj 1554 1689 a(^) p Fg 1598 1689 a(\036) p
+Fk 84 1796 a(Optionally) p 331 1796 a(one) p 425 1796
+a(can) p 519 1796 a(add) p 619 1796 a(rules) p 740 1796
+a(that) p 850 1796 a(remo) o(v) o(e) p 1022 1796 a(a) p
+1067 1796 a(constructor) p Fg 1329 1796 a(l) p Fk 1366
+1796 a(from) p Fg 1486 1796 a(U) p Fk 1545 1796 a(if) p
+1594 1796 a(the) p 1683 1796 a(equation) 11 1856 y(obtained) p
+211 1856 a(from) p Fg 326 1856 a(T) p Fk 362 1856 a(\() p
+Fg(l) p Fk 397 1856 a(\)) p 431 1856 a(has) p 518 1856
+a(no) p 586 1856 a(solution.) p 790 1856 a(Suc) o(h) p
+908 1856 a(rules) p 1024 1856 a(w) o(ould) p 1167 1856
+a(b) q(e) p 1233 1856 a(sound) p 1374 1856 a(and) p 1469
+1856 a(complete.) p Fi 11 1986 a(Syn) n(tax) p 198 1986
+a(of) p 262 1986 a(t) n(yp) r(es) p Fk 11 2078 a(Thanks) p
+188 2078 a(to) p 250 2078 a(the) p 336 2078 a(go) q(o) q(d) p
+458 2078 a(prop) q(erties) p 689 2078 a(of) p 747 2078
+a(these) p 874 2078 a(constrain) o(ts,) p 1139 2078 a(the) p
+1226 2078 a(surface) p 1392 2078 a(syn) o(tax) p 1551
+2078 a(of) p 1608 2078 a(t) o(yp) q(es) p 1740 2078 a(w) o(ould) 11
+2138 y(only) p 118 2138 a(ha) o(v) o(e) p 230 2138 a(to) p
+290 2138 a(b) q(e) p 356 2138 a(sligh) o(tly) p 527 2138
+a(extended.) p Fh 590 2244 a(tag-typ) n(e) p Fk 798 2244
+a(::=) p Fh 904 2244 a(ident) p Fj 849 2304 a(j) p Fh
+904 2304 a(ident) p Fe 1031 2304 a(\() p Fh(typ) n(expr-list) p
+Fe(\)) p Fh 523 2365 a(typ) n(expr-list) p Fk 798 2365
+a(::=) p Fh 904 2365 a(typ) n(expr) p Fj 849 2425 a(j) p
+Fh 904 2425 a(typ) n(expr) p Fe 1078 2425 a(&) p Fh 1120
+2425 a(typ) n(expr-list) p Fk 84 2531 a(Notice) p 234
+2531 a(that) p 336 2531 a(a) p 373 2531 a(0-ary) p 496
+2531 a(constructor) p 751 2531 a(and) p 842 2531 a(an) p
+907 2531 a(1-ary) p 1030 2531 a(construtor) p 1262 2531
+a(are) p 1340 2531 a(con) o(tradictory) l(,) p 1648 2531
+a(and) p 1740 2531 a(w) o(ould) 11 2592 y(result) p 146
+2592 a(in) p 203 2592 a(the) p 287 2592 a(absence) p
+466 2592 a(of) p 522 2592 a(this) p 617 2592 a(constructor.) 926
+2937 y(3) p eop
+PStoPSsaved restore
+userdict/PStoPSsaved save put
+PStoPSmatrix setmatrix
+595.000000 421.271378 translate
+90 rotate
+0.706651 dup scale
+userdict/PStoPSmatrix matrix currentmatrix put
+userdict/PStoPSclip{0 0 moveto
+ 595.000000 0 rlineto 0 842.000000 rlineto -595.000000 0 rlineto
+ closepath}put initclip
+PStoPSxform concat
+4 3 bop Fi 11 168 a(Discussion) p Fk 11 261 a(Suc) o(h) p
+133 261 a(a) p 179 261 a(c) o(hange) p 345 261 a(has) p
+436 261 a(the) p 525 261 a(ma) s(jor) p 672 261 a(adv) m(an) o(tage) p
+907 261 a(of) p 967 261 a(b) q(oth) p 1087 261 a(reco) o(v) o(ering) p
+1324 261 a(principalit) o(y) p 1589 261 a(and) p 1688
+261 a(a) o(v) o(oiding) 11 321 y(unin) o(tuitiv) o(e) p
+266 321 a(error) p 392 321 a(messages.) p 640 321 a(Constrain) o(ts) p
+909 321 a(created) p 1087 321 a(in) p 1152 321 a(suc) o(h) p
+1269 321 a(a) p 1317 321 a(w) o(a) o(y) p 1423 321 a(are) p
+1512 321 a(v) o(ery) p 1626 321 a(ligh) o(t:) p 1772
+321 a(they) 11 381 y(alw) o(a) o(ys) p 165 381 a(app) q(ear) p
+325 381 a(inside) p 463 381 a(a) p 502 381 a(v) m(arian) o(t) p
+666 381 a(t) o(yp) q(e,) p 788 381 a(and) p 882 381 a(if) p
+926 381 a(the) p 1008 381 a(v) m(arian) o(t) p 1172 381
+a(t) o(yp) q(e) p 1281 381 a(do) q(es) p 1390 381 a(not) p
+1475 381 a(app) q(ear) p 1635 381 a(in) p 1691 381 a(the) p
+1774 381 a(\014nal) 11 441 y(t) o(yp) q(e) p 120 441
+a(sc) o(heme,) p 301 441 a(then) p 412 441 a(the) p 496
+441 a(constrain) o(t) p 725 441 a(can) p 815 441 a(b) q(e) p
+881 441 a(discarded) p 1098 441 a(safely) l(.) 84 501
+y(On) p 165 501 a(the) p 249 501 a(other) p 376 501 a(hand,) p
+512 501 a(there) p 637 501 a(are) p 718 501 a(t) o(w) o(o) p
+810 501 a(dra) o(wbac) o(ks.) p Fj 83 616 a(\017) p Fk
+133 616 a(Some) p 259 616 a(errors) p 393 616 a(will) p
+482 616 a(b) q(e) p 544 616 a(dela) o(y) o(ed) p 715
+616 a(longer) p 858 616 a(than) p 968 616 a(no) o(w,) p
+1080 616 a(un) o(til) p 1191 616 a(a) p 1228 616 a(construtor) p
+1460 616 a(is) p 1505 616 a(actually) p 1687 616 a(included) 133
+676 y(in) p Fg 189 676 a(L) p Fk(.) p 258 676 a(It) p
+311 676 a(is) p 360 676 a(not) p 446 676 a(clear) p 563
+676 a(ho) o(w) p 665 676 a(damageable) p 930 676 a(it) p
+979 676 a(is.) p Fj 83 777 a(\017) p Fk 133 777 a(While) p
+272 777 a(t) o(yp) q(e) p 378 777 a(inference) p 579
+777 a(is) p 625 777 a(simple) p 774 777 a(and) p 865
+777 a(costless) p 1036 777 a(for) p 1108 777 a(this) p
+1200 777 a(extension,) p 1426 777 a(simpli\014cation) p
+1724 777 a(of) p 1776 777 a(con-) 133 838 y(strain) o(ts) p
+310 838 a(|marking) p 551 838 a(constructors) p 830 838
+a(with) p 943 838 a(unsolv) m(able) p 1182 838 a(constrain) o(ts) p
+1432 838 a(as) p 1494 838 a(absen) o(t,) p 1663 838 a(and) p
+1760 838 a(elim-) 133 898 y(inating) p 300 898 a(redundan) o(t) p
+536 898 a(t) o(yp) q(es) p 667 898 a(in) p 726 898 a(constrain) o(ts|) p
+1025 898 a(is) p 1076 898 a(a) p 1119 898 a(bit) p 1197
+898 a(more) p 1320 898 a(exp) q(ensiv) o(e.) p 1565 898
+a(Also,) p 1691 898 a(allo) o(wing) 133 958 y(suc) o(h) p
+244 958 a(constrained) p 506 958 a(t) o(yp) q(es) p 637
+958 a(inside) p 777 958 a(signatures) p 1010 958 a(w) o(ould) p
+1154 958 a(mean) p 1286 958 a(ha) o(ving) p 1444 958
+a(to) p 1506 958 a(solv) o(e) p 1627 958 a(a) p 1669
+958 a(matc) o(hing) 133 1018 y(problem,) p 333 1018 a(whic) o(h) p
+469 1018 a(is) p 514 1018 a(exp) q(onen) o(tial) p 772
+1018 a(in) p 825 1018 a(the) p 906 1018 a(n) o(um) o(b) q(er) p
+1080 1018 a(of) p 1132 1018 a(connected) p 1356 1018
+a(constrain) o(ts) p 1600 1018 a(inside) p 1735 1018
+a(a) p 1772 1018 a(t) o(yp) q(e) 133 1078 y(sc) o(heme.) 84
+1193 y(Reasonably) p 340 1193 a(e\016cien) o(t) p 516
+1193 a(algorithms) p 754 1193 a(exist) p 866 1193 a(to) p
+922 1193 a(solv) o(e) p 1038 1193 a(these) p 1159 1193
+a(problems,) p 1379 1193 a(so) p 1435 1193 a(the) p 1515
+1193 a(di\016cult) o(y) p 1715 1193 a(is) p 1760 1193
+a(more) 11 1253 y(in) p 67 1253 a(the) p 151 1253 a(increased) p
+363 1253 a(complexit) o(y) p 611 1253 a(of) p 667 1253
+a(the) p 751 1253 a(t) o(yp) q(e-c) o(hec) o(k) o(er) p
+1031 1253 a(than) p 1145 1253 a(in) p 1202 1253 a(run-time) p
+1402 1253 a(cost.) p Fl 11 1397 a(Other) p 205 1397 a(features) p
+Fk 11 1490 a(Ob) s(jectiv) o(e) p 238 1490 a(Lab) q(el) p
+380 1490 a(con) o(tains) p 579 1490 a(t) o(w) o(o) p
+678 1490 a(other) p 812 1490 a(features:) p 1029 1490
+a(p) q(olymorphic) p 1318 1490 a(metho) q(ds) p 1521
+1490 a(and) p 1623 1490 a(t) o(yp) q(e-driv) o(en) 11
+1550 y(access) p 153 1550 a(of) p 208 1550 a(records.) p
+394 1550 a(Both) p 514 1550 a(of) p 568 1550 a(them) p
+692 1550 a(use) p 775 1550 a(the) p 857 1550 a(same) p
+978 1550 a(metho) q(d) p 1154 1550 a(of) p 1209 1550
+a(enforcing) p 1417 1550 a(principalit) o(y) p 1676 1550
+a(of) p 1730 1550 a(t) o(yping) 11 1610 y(through) p
+191 1610 a(tracing) p 351 1610 a(user) p 450 1610 a(pro) o(vided) p
+647 1610 a(t) o(yp) q(e) p 752 1610 a(information.) p
+1034 1610 a(With) p 1155 1610 a(this) p 1246 1610 a(tracing,) p
+1422 1610 a(their) p 1534 1610 a(implem) o(en) n(tation) 11
+1670 y(is) p 60 1670 a(v) o(ery) p 167 1670 a(easy) l(,) p
+283 1670 a(but) p 373 1670 a(without) p 554 1670 a(it) p
+603 1670 a(they) p 713 1670 a(lo) q(ose) p 834 1670 a(principalit) o(y)
+l(.) 84 1730 y(While) p 229 1730 a(these) p 357 1730
+a(features) p 543 1730 a(pro) o(vide) p 720 1730 a(some) p
+845 1730 a(comfort) p 1029 1730 a(in) p 1089 1730 a(writing) p
+1260 1730 a(user) p 1366 1730 a(programs,) p 1598 1730
+a(they) p 1711 1730 a(are) p 1795 1730 a(not) 11 1791
+y(strictly) p 182 1791 a(necessary) p 403 1791 a(for) p
+482 1791 a(the) p 571 1791 a(v) m(arious) p 742 1791
+a(libraries) p 934 1791 a(coming) p 1107 1791 a(with) p
+1223 1791 a(O'Labl) p 1391 1791 a(\(LablTk,) p 1602 1791
+a(LablGL) p 1787 1791 a(and) 11 1851 y(LablGTK\).) 926
+2937 y(4) p eop
+PStoPSsaved restore
+%%Trailer
+end
+userdict /end-hook known{end-hook}if
+%%EOF
--- /dev/null
+? objvariants-3.09.1.diffs
+? objvariants.diffs
+Index: btype.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/btype.ml,v
+retrieving revision 1.37.4.1
+diff -u -r1.37.4.1 btype.ml
+--- btype.ml 5 Dec 2005 13:18:42 -0000 1.37.4.1
++++ btype.ml 16 Jan 2006 02:23:14 -0000
+@@ -177,7 +177,8 @@
+ Tvariant row -> iter_row f row
+ | Tvar | Tunivar | Tsubst _ | Tconstr _ ->
+ Misc.may (fun (_,l) -> List.iter f l) row.row_name;
+- List.iter f row.row_bound
++ List.iter f row.row_bound;
++ List.iter (fun (s,k,t) -> f t) row.row_object
+ | _ -> assert false
+
+ let iter_type_expr f ty =
+@@ -224,7 +225,9 @@
+ | Some (path, tl) -> Some (path, List.map f tl) in
+ { row_fields = fields; row_more = more;
+ row_bound = !bound; row_fixed = row.row_fixed && fixed;
+- row_closed = row.row_closed; row_name = name; }
++ row_closed = row.row_closed; row_name = name;
++ row_object = List.map (fun (s,k,t) -> (s,k,f t)) row.row_object;
++ }
+
+ let rec copy_kind = function
+ Fvar{contents = Some k} -> copy_kind k
+Index: ctype.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/ctype.ml,v
+retrieving revision 1.197.2.6
+diff -u -r1.197.2.6 ctype.ml
+--- ctype.ml 15 Dec 2005 02:28:38 -0000 1.197.2.6
++++ ctype.ml 16 Jan 2006 02:23:15 -0000
+@@ -1421,7 +1421,7 @@
+ newgenty
+ (Tvariant
+ {row_fields = fields; row_closed = closed; row_more = newvar();
+- row_bound = []; row_fixed = false; row_name = None })
++ row_bound = []; row_fixed = false; row_name = None; row_object=[]})
+
+ (**** Unification ****)
+
+@@ -1724,8 +1724,11 @@
+ else None
+ in
+ let bound = row1.row_bound @ row2.row_bound in
++ let opairs, _, miss2 = associate_fields row1.row_object row2.row_object in
++ let row_object = row1.row_object @ miss2 in
+ let row0 = {row_fields = []; row_more = more; row_bound = bound;
+- row_closed = closed; row_fixed = fixed; row_name = name} in
++ row_closed = closed; row_fixed = fixed; row_name = name;
++ row_object = row_object } in
+ let set_more row rest =
+ let rest =
+ if closed then
+@@ -1758,6 +1761,18 @@
+ raise (Unify ((mkvariant [l,f1] true,
+ mkvariant [l,f2] true) :: trace)))
+ pairs;
++ List.iter (fun (s,_,ty1,_,ty2) -> unify env ty1 ty2) opairs;
++ if row_object <> [] then begin
++ List.iter
++ (fun (l,f) ->
++ match row_field_repr f with
++ Rpresent (Some ty) ->
++ let fi = build_fields generic_level row_object (newgenvar()) in
++ unify env (newgenty (Tobject (fi, ref None))) ty
++ | Rpresent None -> raise (Unify [])
++ | _ -> ())
++ (row_repr row1).row_fields
++ end;
+ with exn ->
+ log_type rm1; rm1.desc <- md1; log_type rm2; rm2.desc <- md2; raise exn
+ end
+@@ -2789,7 +2804,8 @@
+ let row =
+ { row_fields = List.map fst fields; row_more = newvar();
+ row_bound = !bound; row_closed = posi; row_fixed = false;
+- row_name = if c > Unchanged then None else row.row_name }
++ row_name = if c > Unchanged then None else row.row_name;
++ row_object = [] }
+ in
+ (newty (Tvariant row), Changed)
+ | Tobject (t1, _) ->
+Index: oprint.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/oprint.ml,v
+retrieving revision 1.22
+diff -u -r1.22 oprint.ml
+--- oprint.ml 23 Mar 2005 03:08:37 -0000 1.22
++++ oprint.ml 16 Jan 2006 02:23:15 -0000
+@@ -185,7 +185,7 @@
+ fprintf ppf "@[<2>< %a >@]" (print_fields rest) fields
+ | Otyp_stuff s -> fprintf ppf "%s" s
+ | Otyp_var (ng, s) -> fprintf ppf "'%s%s" (if ng then "_" else "") s
+- | Otyp_variant (non_gen, row_fields, closed, tags) ->
++ | Otyp_variant (non_gen, row_fields, closed, tags, obj) ->
+ let print_present ppf =
+ function
+ None | Some [] -> ()
+@@ -198,12 +198,17 @@
+ ppf fields
+ | Ovar_name (id, tyl) ->
+ fprintf ppf "@[%a%a@]" print_typargs tyl print_ident id
++ and print_object ppf obj =
++ if obj <> [] then
++ fprintf ppf "@ as @[<2>< %a >@]" (print_fields (Some false)) obj
+ in
+- fprintf ppf "%s[%s@[<hv>@[<hv>%a@]%a ]@]" (if non_gen then "_" else "")
++ fprintf ppf "%s[%s@[<hv>@[<hv>%a@]%a%a ]@]"
++ (if non_gen then "_" else "")
+ (if closed then if tags = None then " " else "< "
+ else if tags = None then "> " else "? ")
+ print_fields row_fields
+ print_present tags
++ print_object obj
+ | Otyp_alias _ | Otyp_poly _ | Otyp_arrow _ | Otyp_tuple _ as ty ->
+ fprintf ppf "@[<1>(%a)@]" print_out_type ty
+ | Otyp_abstract | Otyp_sum _ | Otyp_record _ | Otyp_manifest (_, _) -> ()
+Index: outcometree.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/outcometree.mli,v
+retrieving revision 1.14
+diff -u -r1.14 outcometree.mli
+--- outcometree.mli 23 Mar 2005 03:08:37 -0000 1.14
++++ outcometree.mli 16 Jan 2006 02:23:15 -0000
+@@ -59,6 +59,7 @@
+ | Otyp_var of bool * string
+ | Otyp_variant of
+ bool * out_variant * bool * (string list) option
++ * (string * out_type) list
+ | Otyp_poly of string list * out_type
+ and out_variant =
+ | Ovar_fields of (string * bool * out_type list) list
+Index: printtyp.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/printtyp.ml,v
+retrieving revision 1.139.2.2
+diff -u -r1.139.2.2 printtyp.ml
+--- printtyp.ml 7 Dec 2005 23:37:27 -0000 1.139.2.2
++++ printtyp.ml 16 Jan 2006 02:23:15 -0000
+@@ -244,7 +244,10 @@
+ visited_objects := px :: !visited_objects;
+ match row.row_name with
+ | Some(p, tyl) when namable_row row ->
+- List.iter (mark_loops_rec visited) tyl
++ List.iter (mark_loops_rec visited) tyl;
++ if not (static_row row) then
++ List.iter (fun (s,k,t) -> mark_loops_rec visited t)
++ row.row_object
+ | _ ->
+ iter_row (mark_loops_rec visited) {row with row_bound = []}
+ end
+@@ -343,25 +346,27 @@
+ | _ -> false)
+ fields in
+ let all_present = List.length present = List.length fields in
++ let static = row.row_closed && all_present in
++ let obj =
++ if static then [] else
++ List.map (fun (s,k,t) -> (s, tree_of_typexp sch t)) row.row_object
++ in
++ let tags = if all_present then None else Some (List.map fst present) in
+ begin match row.row_name with
+ | Some(p, tyl) when namable_row row ->
+ let id = tree_of_path p in
+ let args = tree_of_typlist sch tyl in
+- if row.row_closed && all_present then
++ if static then
+ Otyp_constr (id, args)
+ else
+ let non_gen = is_non_gen sch px in
+- let tags =
+- if all_present then None else Some (List.map fst present) in
+ Otyp_variant (non_gen, Ovar_name(tree_of_path p, args),
+- row.row_closed, tags)
++ row.row_closed, tags, obj)
+ | _ ->
+- let non_gen =
+- not (row.row_closed && all_present) && is_non_gen sch px in
++ let non_gen = not static && is_non_gen sch px in
+ let fields = List.map (tree_of_row_field sch) fields in
+- let tags =
+- if all_present then None else Some (List.map fst present) in
+- Otyp_variant (non_gen, Ovar_fields fields, row.row_closed, tags)
++ Otyp_variant (non_gen, Ovar_fields fields, row.row_closed,
++ tags, obj)
+ end
+ | Tobject (fi, nm) ->
+ tree_of_typobject sch fi nm
+Index: typecore.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/typecore.ml,v
+retrieving revision 1.176.2.2
+diff -u -r1.176.2.2 typecore.ml
+--- typecore.ml 11 Dec 2005 09:56:33 -0000 1.176.2.2
++++ typecore.ml 16 Jan 2006 02:23:15 -0000
+@@ -170,7 +170,8 @@
+ (* Force check of well-formedness *)
+ unify_pat pat.pat_env pat
+ (newty(Tvariant{row_fields=[]; row_more=newvar(); row_closed=false;
+- row_bound=[]; row_fixed=false; row_name=None}));
++ row_bound=[]; row_fixed=false; row_name=None;
++ row_object=[]}));
+ | _ -> ()
+
+ let rec iter_pattern f p =
+@@ -251,7 +252,7 @@
+ let ty = may_map (build_as_type env) p' in
+ newty (Tvariant{row_fields=[l, Rpresent ty]; row_more=newvar();
+ row_bound=[]; row_name=None;
+- row_fixed=false; row_closed=false})
++ row_fixed=false; row_closed=false; row_object=[]})
+ | Tpat_record lpl ->
+ let lbl = fst(List.hd lpl) in
+ if lbl.lbl_private = Private then p.pat_type else
+@@ -318,7 +319,8 @@
+ ([],[]) fields in
+ let row =
+ { row_fields = List.rev fields; row_more = newvar(); row_bound = !bound;
+- row_closed = false; row_fixed = false; row_name = Some (path, tyl) }
++ row_closed = false; row_fixed = false; row_name = Some (path, tyl);
++ row_object = [] }
+ in
+ let ty = newty (Tvariant row) in
+ let gloc = {loc with Location.loc_ghost=true} in
+@@ -428,7 +430,8 @@
+ row_closed = false;
+ row_more = newvar ();
+ row_fixed = false;
+- row_name = None } in
++ row_name = None;
++ row_object = [] } in
+ rp {
+ pat_desc = Tpat_variant(l, arg, row);
+ pat_loc = sp.ppat_loc;
+@@ -976,7 +979,8 @@
+ row_bound = [];
+ row_closed = false;
+ row_fixed = false;
+- row_name = None});
++ row_name = None;
++ row_object = []});
+ exp_env = env }
+ | Pexp_record(lid_sexp_list, opt_sexp) ->
+ let ty = newvar() in
+@@ -1261,8 +1265,30 @@
+ assert false
+ end
+ | _ ->
+- (Texp_send(obj, Tmeth_name met),
+- filter_method env met Public obj.exp_type)
++ let obj, met_ty =
++ match expand_head env obj.exp_type with
++ {desc = Tvariant _} ->
++ let exp_ty = newvar () in
++ let met_ty = filter_method env met Public exp_ty in
++ let row =
++ {row_fields=[]; row_more=newvar();
++ row_bound=[]; row_closed=false;
++ row_fixed=false; row_name=None;
++ row_object=[met, Fpresent, met_ty]} in
++ unify_exp env obj (newty (Tvariant row));
++ let prim = Primitive.parse_declaration 1 ["%field1"] in
++ let ty = newty(Tarrow("", obj.exp_type, exp_ty, Cok)) in
++ let vd = {val_type = ty; val_kind = Val_prim prim} in
++ let esnd =
++ {exp_desc=Texp_ident(Path.Pident(Ident.create"snd"), vd);
++ exp_loc = Location.none; exp_type = ty; exp_env = env}
++ in
++ ({obj with exp_type = exp_ty;
++ exp_desc = Texp_apply(esnd,[Some obj, Required])},
++ met_ty)
++ | _ -> (obj, filter_method env met Public obj.exp_type)
++ in
++ (Texp_send(obj, Tmeth_name met), met_ty)
+ in
+ if !Clflags.principal then begin
+ end_def ();
+Index: types.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/types.ml,v
+retrieving revision 1.25
+diff -u -r1.25 types.ml
+--- types.ml 9 Dec 2004 12:40:53 -0000 1.25
++++ types.ml 16 Jan 2006 02:23:15 -0000
+@@ -44,7 +44,9 @@
+ row_bound: type_expr list;
+ row_closed: bool;
+ row_fixed: bool;
+- row_name: (Path.t * type_expr list) option }
++ row_name: (Path.t * type_expr list) option;
++ row_object: (string * field_kind * type_expr) list;
++ }
+
+ and row_field =
+ Rpresent of type_expr option
+Index: types.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/types.mli,v
+retrieving revision 1.25
+diff -u -r1.25 types.mli
+--- types.mli 9 Dec 2004 12:40:53 -0000 1.25
++++ types.mli 16 Jan 2006 02:23:15 -0000
+@@ -43,7 +43,9 @@
+ row_bound: type_expr list;
+ row_closed: bool;
+ row_fixed: bool;
+- row_name: (Path.t * type_expr list) option }
++ row_name: (Path.t * type_expr list) option;
++ row_object: (string * field_kind * type_expr) list;
++ }
+
+ and row_field =
+ Rpresent of type_expr option
+Index: typetexp.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/typetexp.ml,v
+retrieving revision 1.54
+diff -u -r1.54 typetexp.ml
+--- typetexp.ml 22 Jul 2005 06:42:36 -0000 1.54
++++ typetexp.ml 16 Jan 2006 02:23:15 -0000
+@@ -215,7 +215,8 @@
+ in
+ let row = { row_closed = true; row_fields = fields;
+ row_bound = !bound; row_name = Some (path, args);
+- row_fixed = false; row_more = newvar () } in
++ row_fixed = false; row_more = newvar ();
++ row_object = [] } in
+ let static = Btype.static_row row in
+ let row =
+ if static then row else
+@@ -262,7 +263,7 @@
+ let mkfield l f =
+ newty (Tvariant {row_fields=[l,f]; row_more=newvar();
+ row_bound=[]; row_closed=true;
+- row_fixed=false; row_name=None}) in
++ row_fixed=false; row_name=None; row_object=[]}) in
+ let add_typed_field loc l f fields =
+ try
+ let f' = List.assoc l fields in
+@@ -345,7 +346,7 @@
+ let row =
+ { row_fields = List.rev fields; row_more = newvar ();
+ row_bound = !bound; row_closed = closed;
+- row_fixed = false; row_name = !name } in
++ row_fixed = false; row_name = !name; row_object = [] } in
+ let static = Btype.static_row row in
+ let row =
+ if static then row else
--- /dev/null
+(* use with [cvs update -r objvariants typing] *)
+
+let f (x : [> ]) = x#m 3;;
+let o = object method m x = x+2 end;;
+f (`A o);;
+let l = [`A o; `B(object method m x = x -2 method y = 3 end)];;
+List.map f l;;
+let g = function `A x -> x#m 3 | `B x -> x#y;;
+List.map g l;;
+fun x -> ignore (x=f); List.map x l;;
+fun (x : [< `A of _ | `B of _] -> int) -> ignore (x=f); List.map x l;;
+
+
+class cvar name =
+ object
+ method name = name
+ method print ppf = Format.pp_print_string ppf name
+ end
+
+type var = [`Var of cvar]
+
+class cint n =
+ object
+ method n = n
+ method print ppf = Format.pp_print_int ppf n
+ end
+
+class ['a] cadd (e1 : 'a) (e2 : 'a) =
+ object
+ constraint 'a = [> ]
+ method e1 = e1
+ method e2 = e2
+ method print ppf = Format.fprintf ppf "(%t, %t)" e1#print e2#print
+ end
+
+type 'a expr = [var | `Int of cint | `Add of 'a cadd]
+
+type expr1 = expr1 expr
+
+let print = Format.printf "%t@."
+
+let e1 : expr1 = `Add (new cadd (`Var (new cvar "x")) (`Int (new cint 2)))
--- /dev/null
+(* $Id: printers.ml 5492 2003-04-03 02:16:20Z garrigue $ *)
+
+open Types
+
+let ignore_abbrevs ppf ab =
+ let s = match ab with
+ Mnil -> "Mnil"
+ | Mlink _ -> "Mlink _"
+ | Mcons _ -> "Mcons _"
+ in
+ Format.pp_print_string ppf s
--- /dev/null
+module type Printable = sig
+ type t
+ val print : Format.formatter -> t -> unit
+end
+module type Comparable = sig
+ type t
+ val compare : t -> t -> int
+end
+module type PrintableComparable = sig
+ include Printable
+ include Comparable with type t = t
+end
+module type PrintableComparable = sig
+ type t
+ include Printable with type t := t
+ include Comparable with type t := t
+end
+module type PrintableComparable = sig
+ include Printable
+ include Comparable with type t := t
+end
+module type ComparableInt = Comparable with type t := int
+
+module type S = sig type t val f : t -> t end
+module type S' = S with type t := int
+
+module type S = sig type 'a t val map : ('a -> 'b) -> 'a t -> 'b t end
+module type S1 = S with type 'a t := 'a list
+module type S2 = sig
+ type 'a dict = (string * 'a) list
+ include S with type 'a t := 'a dict
+end
+
+
+module type S =
+ sig module T : sig type exp type arg end val f : T.exp -> T.arg end
+module M = struct type exp = string type arg = int end
+module type S' = S with module T := M
--- /dev/null
+(* $Id: tests.ml 2745 2000-01-07 16:47:25Z doligez $ *)
+
+let f1 = function `a x -> x=1 | `b -> true
+let f2 = function `a x -> x | `b -> true
+let f3 = function `b -> true
+let f x = f1 x && f2 x
+
+let sub s ?:pos{=0} ?:len{=String.length s - pos} () =
+ String.sub s pos len
+
+let cCAMLtoTKpack_options w = function
+ `After v1 -> "-after"
+ | `Anchor v1 -> "-anchor"
+ | `Before v1 -> "-before"
+ | `Expand v1 -> "-expand"
+ | `Fill v1 -> "-fill"
+ | `In v1 -> "-in"
+ | `Ipadx v1 -> "-ipadx"
+ | `Ipady v1 -> "-ipady"
+ | `Padx v1 -> "-padx"
+ | `Pady v1 -> "-pady"
+ | `Side v1 -> "-side"
--- /dev/null
+Index: utils/warnings.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/utils/warnings.ml,v
+retrieving revision 1.23
+diff -u -r1.23 warnings.ml
+--- utils/warnings.ml 15 Sep 2005 03:09:26 -0000 1.23
++++ utils/warnings.ml 5 Apr 2006 02:25:59 -0000
+@@ -26,7 +26,7 @@
+ | Statement_type (* S *)
+ | Unused_match (* U *)
+ | Unused_pat
+- | Hide_instance_variable of string (* V *)
++ | Instance_variable_override of string (* V *)
+ | Illegal_backslash (* X *)
+ | Implicit_public_methods of string list
+ | Unerasable_optional_argument
+@@ -54,7 +54,7 @@
+ | Statement_type -> 's'
+ | Unused_match
+ | Unused_pat -> 'u'
+- | Hide_instance_variable _ -> 'v'
++ | Instance_variable_override _ -> 'v'
+ | Illegal_backslash
+ | Implicit_public_methods _
+ | Unerasable_optional_argument
+@@ -126,9 +126,9 @@
+ String.concat " "
+ ("the following methods are overridden \
+ by the inherited class:\n " :: slist)
+- | Hide_instance_variable lab ->
+- "this definition of an instance variable " ^ lab ^
+- " hides a previously\ndefined instance variable of the same name."
++ | Instance_variable_override lab ->
++ "the instance variable " ^ lab ^ " is overridden.\n" ^
++ "The behaviour changed in ocaml 3.10 (previous behaviour was hiding.)"
+ | Partial_application ->
+ "this function application is partial,\n\
+ maybe some arguments are missing."
+Index: utils/warnings.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/utils/warnings.mli,v
+retrieving revision 1.16
+diff -u -r1.16 warnings.mli
+--- utils/warnings.mli 15 Sep 2005 03:09:26 -0000 1.16
++++ utils/warnings.mli 5 Apr 2006 02:25:59 -0000
+@@ -26,7 +26,7 @@
+ | Statement_type (* S *)
+ | Unused_match (* U *)
+ | Unused_pat
+- | Hide_instance_variable of string (* V *)
++ | Instance_variable_override of string (* V *)
+ | Illegal_backslash (* X *)
+ | Implicit_public_methods of string list
+ | Unerasable_optional_argument
+Index: parsing/parser.mly
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/parsing/parser.mly,v
+retrieving revision 1.123
+diff -u -r1.123 parser.mly
+--- parsing/parser.mly 23 Mar 2005 03:08:37 -0000 1.123
++++ parsing/parser.mly 5 Apr 2006 02:25:59 -0000
+@@ -623,6 +623,8 @@
+ { [] }
+ | class_fields INHERIT class_expr parent_binder
+ { Pcf_inher ($3, $4) :: $1 }
++ | class_fields VAL virtual_value
++ { Pcf_valvirt $3 :: $1 }
+ | class_fields VAL value
+ { Pcf_val $3 :: $1 }
+ | class_fields virtual_method
+@@ -638,14 +640,20 @@
+ AS LIDENT
+ { Some $2 }
+ | /* empty */
+- {None}
++ { None }
++;
++virtual_value:
++ MUTABLE VIRTUAL label COLON core_type
++ { $3, Mutable, $5, symbol_rloc () }
++ | VIRTUAL mutable_flag label COLON core_type
++ { $3, $2, $5, symbol_rloc () }
+ ;
+ value:
+- mutable_flag label EQUAL seq_expr
+- { $2, $1, $4, symbol_rloc () }
+- | mutable_flag label type_constraint EQUAL seq_expr
+- { $2, $1, (let (t, t') = $3 in ghexp(Pexp_constraint($5, t, t'))),
+- symbol_rloc () }
++ mutable_flag label EQUAL seq_expr
++ { $2, $1, $4, symbol_rloc () }
++ | mutable_flag label type_constraint EQUAL seq_expr
++ { $2, $1, (let (t, t') = $3 in ghexp(Pexp_constraint($5, t, t'))),
++ symbol_rloc () }
+ ;
+ virtual_method:
+ METHOD PRIVATE VIRTUAL label COLON poly_type
+@@ -711,8 +719,12 @@
+ | class_sig_fields CONSTRAINT constrain { Pctf_cstr $3 :: $1 }
+ ;
+ value_type:
+- mutable_flag label COLON core_type
+- { $2, $1, Some $4, symbol_rloc () }
++ VIRTUAL mutable_flag label COLON core_type
++ { $3, $2, Virtual, $5, symbol_rloc () }
++ | MUTABLE virtual_flag label COLON core_type
++ { $3, Mutable, $2, $5, symbol_rloc () }
++ | label COLON core_type
++ { $1, Immutable, Concrete, $3, symbol_rloc () }
+ ;
+ method_type:
+ METHOD private_flag label COLON poly_type
+Index: parsing/parsetree.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/parsing/parsetree.mli,v
+retrieving revision 1.42
+diff -u -r1.42 parsetree.mli
+--- parsing/parsetree.mli 23 Mar 2005 03:08:37 -0000 1.42
++++ parsing/parsetree.mli 5 Apr 2006 02:25:59 -0000
+@@ -152,7 +152,7 @@
+
+ and class_type_field =
+ Pctf_inher of class_type
+- | Pctf_val of (string * mutable_flag * core_type option * Location.t)
++ | Pctf_val of (string * mutable_flag * virtual_flag * core_type * Location.t)
+ | Pctf_virt of (string * private_flag * core_type * Location.t)
+ | Pctf_meth of (string * private_flag * core_type * Location.t)
+ | Pctf_cstr of (core_type * core_type * Location.t)
+@@ -179,6 +179,7 @@
+
+ and class_field =
+ Pcf_inher of class_expr * string option
++ | Pcf_valvirt of (string * mutable_flag * core_type * Location.t)
+ | Pcf_val of (string * mutable_flag * expression * Location.t)
+ | Pcf_virt of (string * private_flag * core_type * Location.t)
+ | Pcf_meth of (string * private_flag * expression * Location.t)
+Index: parsing/printast.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/parsing/printast.ml,v
+retrieving revision 1.29
+diff -u -r1.29 printast.ml
+--- parsing/printast.ml 4 Jan 2006 16:55:50 -0000 1.29
++++ parsing/printast.ml 5 Apr 2006 02:25:59 -0000
+@@ -353,10 +353,11 @@
+ | Pctf_inher (ct) ->
+ line i ppf "Pctf_inher\n";
+ class_type i ppf ct;
+- | Pctf_val (s, mf, cto, loc) ->
++ | Pctf_val (s, mf, vf, ct, loc) ->
+ line i ppf
+- "Pctf_val \"%s\" %a %a\n" s fmt_mutable_flag mf fmt_location loc;
+- option i core_type ppf cto;
++ "Pctf_val \"%s\" %a %a %a\n" s
++ fmt_mutable_flag mf fmt_virtual_flag vf fmt_location loc;
++ core_type (i+1) ppf ct;
+ | Pctf_virt (s, pf, ct, loc) ->
+ line i ppf
+ "Pctf_virt \"%s\" %a %a\n" s fmt_private_flag pf fmt_location loc;
+@@ -428,6 +429,10 @@
+ line i ppf "Pcf_inher\n";
+ class_expr (i+1) ppf ce;
+ option (i+1) string ppf so;
++ | Pcf_valvirt (s, mf, ct, loc) ->
++ line i ppf
++ "Pcf_valvirt \"%s\" %a %a\n" s fmt_mutable_flag mf fmt_location loc;
++ core_type (i+1) ppf ct;
+ | Pcf_val (s, mf, e, loc) ->
+ line i ppf
+ "Pcf_val \"%s\" %a %a\n" s fmt_mutable_flag mf fmt_location loc;
+Index: typing/btype.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/btype.ml,v
+retrieving revision 1.38
+diff -u -r1.38 btype.ml
+--- typing/btype.ml 4 Jan 2006 16:55:50 -0000 1.38
++++ typing/btype.ml 5 Apr 2006 02:25:59 -0000
+@@ -330,7 +330,7 @@
+
+ let unmark_class_signature sign =
+ unmark_type sign.cty_self;
+- Vars.iter (fun l (m, t) -> unmark_type t) sign.cty_vars
++ Vars.iter (fun l (m, v, t) -> unmark_type t) sign.cty_vars
+
+ let rec unmark_class_type =
+ function
+Index: typing/ctype.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/ctype.ml,v
+retrieving revision 1.200
+diff -u -r1.200 ctype.ml
+--- typing/ctype.ml 6 Jan 2006 02:16:24 -0000 1.200
++++ typing/ctype.ml 5 Apr 2006 02:25:59 -0000
+@@ -857,7 +857,7 @@
+ Tcty_signature
+ {cty_self = copy sign.cty_self;
+ cty_vars =
+- Vars.map (function (mut, ty) -> (mut, copy ty)) sign.cty_vars;
++ Vars.map (function (m, v, ty) -> (m, v, copy ty)) sign.cty_vars;
+ cty_concr = sign.cty_concr;
+ cty_inher =
+ List.map (fun (p,tl) -> (p, List.map copy tl)) sign.cty_inher}
+@@ -2354,10 +2354,11 @@
+ | CM_Val_type_mismatch of string * (type_expr * type_expr) list
+ | CM_Meth_type_mismatch of string * (type_expr * type_expr) list
+ | CM_Non_mutable_value of string
++ | CM_Non_concrete_value of string
+ | CM_Missing_value of string
+ | CM_Missing_method of string
+ | CM_Hide_public of string
+- | CM_Hide_virtual of string
++ | CM_Hide_virtual of string * string
+ | CM_Public_method of string
+ | CM_Private_method of string
+ | CM_Virtual_method of string
+@@ -2390,8 +2391,8 @@
+ end)
+ pairs;
+ Vars.iter
+- (fun lab (mut, ty) ->
+- let (mut', ty') = Vars.find lab sign1.cty_vars in
++ (fun lab (mut, v, ty) ->
++ let (mut', v', ty') = Vars.find lab sign1.cty_vars in
+ try moregen true type_pairs env ty' ty with Unify trace ->
+ raise (Failure [CM_Val_type_mismatch
+ (lab, expand_trace env trace)]))
+@@ -2437,7 +2438,7 @@
+ end
+ in
+ if Concr.mem lab sign1.cty_concr then err
+- else CM_Hide_virtual lab::err)
++ else CM_Hide_virtual ("method", lab) :: err)
+ miss1 []
+ in
+ let missing_method = List.map (fun (m, _, _) -> m) miss2 in
+@@ -2455,11 +2456,13 @@
+ in
+ let error =
+ Vars.fold
+- (fun lab (mut, ty) err ->
++ (fun lab (mut, vr, ty) err ->
+ try
+- let (mut', ty') = Vars.find lab sign1.cty_vars in
++ let (mut', vr', ty') = Vars.find lab sign1.cty_vars in
+ if mut = Mutable && mut' <> Mutable then
+ CM_Non_mutable_value lab::err
++ else if vr = Concrete && vr' <> Concrete then
++ CM_Non_concrete_value lab::err
+ else
+ err
+ with Not_found ->
+@@ -2467,6 +2470,14 @@
+ sign2.cty_vars error
+ in
+ let error =
++ Vars.fold
++ (fun lab (_,vr,_) err ->
++ if vr = Virtual && not (Vars.mem lab sign2.cty_vars) then
++ CM_Hide_virtual ("instance variable", lab) :: err
++ else err)
++ sign1.cty_vars error
++ in
++ let error =
+ List.fold_right
+ (fun e l ->
+ if List.mem e missing_method then l else CM_Virtual_method e::l)
+@@ -2516,8 +2527,8 @@
+ end)
+ pairs;
+ Vars.iter
+- (fun lab (mut, ty) ->
+- let (mut', ty') = Vars.find lab sign1.cty_vars in
++ (fun lab (_, _, ty) ->
++ let (_, _, ty') = Vars.find lab sign1.cty_vars in
+ try eqtype true type_pairs subst env ty ty' with Unify trace ->
+ raise (Failure [CM_Val_type_mismatch
+ (lab, expand_trace env trace)]))
+@@ -2554,7 +2565,7 @@
+ end
+ in
+ if Concr.mem lab sign1.cty_concr then err
+- else CM_Hide_virtual lab::err)
++ else CM_Hide_virtual ("method", lab) :: err)
+ miss1 []
+ in
+ let missing_method = List.map (fun (m, _, _) -> m) miss2 in
+@@ -2578,11 +2589,13 @@
+ in
+ let error =
+ Vars.fold
+- (fun lab (mut, ty) err ->
++ (fun lab (mut, vr, ty) err ->
+ try
+- let (mut', ty') = Vars.find lab sign1.cty_vars in
++ let (mut', vr', ty') = Vars.find lab sign1.cty_vars in
+ if mut = Mutable && mut' <> Mutable then
+ CM_Non_mutable_value lab::err
++ else if vr = Concrete && vr' <> Concrete then
++ CM_Non_concrete_value lab::err
+ else
+ err
+ with Not_found ->
+@@ -2590,6 +2603,14 @@
+ sign2.cty_vars error
+ in
+ let error =
++ Vars.fold
++ (fun lab (_,vr,_) err ->
++ if vr = Virtual && not (Vars.mem lab sign2.cty_vars) then
++ CM_Hide_virtual ("instance variable", lab) :: err
++ else err)
++ sign1.cty_vars error
++ in
++ let error =
+ List.fold_right
+ (fun e l ->
+ if List.mem e missing_method then l else CM_Virtual_method e::l)
+@@ -3279,7 +3300,7 @@
+ let nondep_class_signature env id sign =
+ { cty_self = nondep_type_rec env id sign.cty_self;
+ cty_vars =
+- Vars.map (function (m, t) -> (m, nondep_type_rec env id t))
++ Vars.map (function (m, v, t) -> (m, v, nondep_type_rec env id t))
+ sign.cty_vars;
+ cty_concr = sign.cty_concr;
+ cty_inher =
+Index: typing/ctype.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/ctype.mli,v
+retrieving revision 1.53
+diff -u -r1.53 ctype.mli
+--- typing/ctype.mli 9 Dec 2004 12:40:53 -0000 1.53
++++ typing/ctype.mli 5 Apr 2006 02:25:59 -0000
+@@ -170,10 +170,11 @@
+ | CM_Val_type_mismatch of string * (type_expr * type_expr) list
+ | CM_Meth_type_mismatch of string * (type_expr * type_expr) list
+ | CM_Non_mutable_value of string
++ | CM_Non_concrete_value of string
+ | CM_Missing_value of string
+ | CM_Missing_method of string
+ | CM_Hide_public of string
+- | CM_Hide_virtual of string
++ | CM_Hide_virtual of string * string
+ | CM_Public_method of string
+ | CM_Private_method of string
+ | CM_Virtual_method of string
+Index: typing/includeclass.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/includeclass.ml,v
+retrieving revision 1.7
+diff -u -r1.7 includeclass.ml
+--- typing/includeclass.ml 6 Mar 2000 22:11:57 -0000 1.7
++++ typing/includeclass.ml 5 Apr 2006 02:25:59 -0000
+@@ -78,14 +78,17 @@
+ | CM_Non_mutable_value lab ->
+ fprintf ppf
+ "@[The non-mutable instance variable %s cannot become mutable@]" lab
++ | CM_Non_concrete_value lab ->
++ fprintf ppf
++ "@[The virtual instance variable %s cannot become concrete@]" lab
+ | CM_Missing_value lab ->
+ fprintf ppf "@[The first class type has no instance variable %s@]" lab
+ | CM_Missing_method lab ->
+ fprintf ppf "@[The first class type has no method %s@]" lab
+ | CM_Hide_public lab ->
+ fprintf ppf "@[The public method %s cannot be hidden@]" lab
+- | CM_Hide_virtual lab ->
+- fprintf ppf "@[The virtual method %s cannot be hidden@]" lab
++ | CM_Hide_virtual (k, lab) ->
++ fprintf ppf "@[The virtual %s %s cannot be hidden@]" k lab
+ | CM_Public_method lab ->
+ fprintf ppf "@[The public method %s cannot become private" lab
+ | CM_Virtual_method lab ->
+Index: typing/oprint.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/oprint.ml,v
+retrieving revision 1.22
+diff -u -r1.22 oprint.ml
+--- typing/oprint.ml 23 Mar 2005 03:08:37 -0000 1.22
++++ typing/oprint.ml 5 Apr 2006 02:25:59 -0000
+@@ -291,8 +291,10 @@
+ fprintf ppf "@[<2>method %s%s%s :@ %a@]"
+ (if priv then "private " else "") (if virt then "virtual " else "")
+ name !out_type ty
+- | Ocsg_value (name, mut, ty) ->
+- fprintf ppf "@[<2>val %s%s :@ %a@]" (if mut then "mutable " else "")
++ | Ocsg_value (name, mut, vr, ty) ->
++ fprintf ppf "@[<2>val %s%s%s :@ %a@]"
++ (if mut then "mutable " else "")
++ (if vr then "virtual " else "")
+ name !out_type ty
+
+ let out_class_type = ref print_out_class_type
+Index: typing/outcometree.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/outcometree.mli,v
+retrieving revision 1.14
+diff -u -r1.14 outcometree.mli
+--- typing/outcometree.mli 23 Mar 2005 03:08:37 -0000 1.14
++++ typing/outcometree.mli 5 Apr 2006 02:25:59 -0000
+@@ -71,7 +71,7 @@
+ and out_class_sig_item =
+ | Ocsg_constraint of out_type * out_type
+ | Ocsg_method of string * bool * bool * out_type
+- | Ocsg_value of string * bool * out_type
++ | Ocsg_value of string * bool * bool * out_type
+
+ type out_module_type =
+ | Omty_abstract
+Index: typing/printtyp.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/printtyp.ml,v
+retrieving revision 1.140
+diff -u -r1.140 printtyp.ml
+--- typing/printtyp.ml 4 Jan 2006 16:55:50 -0000 1.140
++++ typing/printtyp.ml 5 Apr 2006 02:26:00 -0000
+@@ -650,7 +650,7 @@
+ Ctype.flatten_fields (Ctype.object_fields sign.cty_self)
+ in
+ List.iter (fun met -> mark_loops (method_type met)) fields;
+- Vars.iter (fun _ (_, ty) -> mark_loops ty) sign.cty_vars
++ Vars.iter (fun _ (_, _, ty) -> mark_loops ty) sign.cty_vars
+ | Tcty_fun (_, ty, cty) ->
+ mark_loops ty;
+ prepare_class_type params cty
+@@ -682,13 +682,15 @@
+ csil (tree_of_constraints params)
+ in
+ let all_vars =
+- Vars.fold (fun l (m, t) all -> (l, m, t) :: all) sign.cty_vars [] in
++ Vars.fold (fun l (m, v, t) all -> (l, m, v, t) :: all) sign.cty_vars []
++ in
+ (* Consequence of PR#3607: order of Map.fold has changed! *)
+ let all_vars = List.rev all_vars in
+ let csil =
+ List.fold_left
+- (fun csil (l, m, t) ->
+- Ocsg_value (l, m = Mutable, tree_of_typexp sch t) :: csil)
++ (fun csil (l, m, v, t) ->
++ Ocsg_value (l, m = Mutable, v = Virtual, tree_of_typexp sch t)
++ :: csil)
+ csil all_vars
+ in
+ let csil =
+@@ -763,7 +765,9 @@
+ List.exists
+ (fun (lab, _, ty) ->
+ not (lab = dummy_method || Concr.mem lab sign.cty_concr))
+- fields in
++ fields
++ || Vars.fold (fun _ (_,vr,_) b -> vr = Virtual || b) sign.cty_vars false
++ in
+
+ Osig_class_type
+ (virt, Ident.name id,
+Index: typing/subst.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/subst.ml,v
+retrieving revision 1.49
+diff -u -r1.49 subst.ml
+--- typing/subst.ml 4 Jan 2006 16:55:50 -0000 1.49
++++ typing/subst.ml 5 Apr 2006 02:26:00 -0000
+@@ -178,7 +178,8 @@
+
+ let class_signature s sign =
+ { cty_self = typexp s sign.cty_self;
+- cty_vars = Vars.map (function (m, t) -> (m, typexp s t)) sign.cty_vars;
++ cty_vars =
++ Vars.map (function (m, v, t) -> (m, v, typexp s t)) sign.cty_vars;
+ cty_concr = sign.cty_concr;
+ cty_inher =
+ List.map (fun (p, tl) -> (type_path s p, List.map (typexp s) tl))
+Index: typing/typeclass.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/typeclass.ml,v
+retrieving revision 1.85
+diff -u -r1.85 typeclass.ml
+--- typing/typeclass.ml 22 Jul 2005 06:42:36 -0000 1.85
++++ typing/typeclass.ml 5 Apr 2006 02:26:00 -0000
+@@ -24,7 +24,7 @@
+
+ type error =
+ Unconsistent_constraint of (type_expr * type_expr) list
+- | Method_type_mismatch of string * (type_expr * type_expr) list
++ | Field_type_mismatch of string * string * (type_expr * type_expr) list
+ | Structure_expected of class_type
+ | Cannot_apply of class_type
+ | Apply_wrong_label of label
+@@ -36,7 +36,7 @@
+ | Unbound_class_type_2 of Longident.t
+ | Abbrev_type_clash of type_expr * type_expr * type_expr
+ | Constructor_type_mismatch of string * (type_expr * type_expr) list
+- | Virtual_class of bool * string list
++ | Virtual_class of bool * string list * string list
+ | Parameter_arity_mismatch of Longident.t * int * int
+ | Parameter_mismatch of (type_expr * type_expr) list
+ | Bad_parameters of Ident.t * type_expr * type_expr
+@@ -49,6 +49,7 @@
+ | Non_collapsable_conjunction of
+ Ident.t * Types.class_declaration * (type_expr * type_expr) list
+ | Final_self_clash of (type_expr * type_expr) list
++ | Mutability_mismatch of string * mutable_flag
+
+ exception Error of Location.t * error
+
+@@ -90,7 +91,7 @@
+ generalize_class_type cty
+ | Tcty_signature {cty_self = sty; cty_vars = vars; cty_inher = inher} ->
+ Ctype.generalize sty;
+- Vars.iter (fun _ (_, ty) -> Ctype.generalize ty) vars;
++ Vars.iter (fun _ (_, _, ty) -> Ctype.generalize ty) vars;
+ List.iter (fun (_,tl) -> List.iter Ctype.generalize tl) inher
+ | Tcty_fun (_, ty, cty) ->
+ Ctype.generalize ty;
+@@ -152,7 +153,7 @@
+ | Tcty_signature sign ->
+ Ctype.closed_schema sign.cty_self
+ &&
+- Vars.fold (fun _ (_, ty) cc -> Ctype.closed_schema ty && cc)
++ Vars.fold (fun _ (_, _, ty) cc -> Ctype.closed_schema ty && cc)
+ sign.cty_vars
+ true
+ | Tcty_fun (_, ty, cty) ->
+@@ -172,7 +173,7 @@
+ limited_generalize rv cty
+ | Tcty_signature sign ->
+ Ctype.limited_generalize rv sign.cty_self;
+- Vars.iter (fun _ (_, ty) -> Ctype.limited_generalize rv ty)
++ Vars.iter (fun _ (_, _, ty) -> Ctype.limited_generalize rv ty)
+ sign.cty_vars;
+ List.iter (fun (_, tl) -> List.iter (Ctype.limited_generalize rv) tl)
+ sign.cty_inher
+@@ -201,11 +202,25 @@
+ Env.add_value id {val_type = ty; val_kind = Val_unbound} par_env)
+
+ (* Enter an instance variable in the environment *)
+-let enter_val cl_num vars lab mut ty val_env met_env par_env =
+- let (id, val_env, met_env, par_env) as result =
+- enter_met_env lab (Val_ivar (mut, cl_num)) ty val_env met_env par_env
++let enter_val cl_num vars inh lab mut virt ty val_env met_env par_env loc =
++ let (id, virt) =
++ try
++ let (id, mut', virt', ty') = Vars.find lab !vars in
++ if mut' <> mut then raise (Error(loc, Mutability_mismatch(lab, mut)));
++ Ctype.unify val_env (Ctype.instance ty) (Ctype.instance ty');
++ (if not inh then Some id else None),
++ (if virt' = Concrete then virt' else virt)
++ with
++ Ctype.Unify tr ->
++ raise (Error(loc, Field_type_mismatch("instance variable", lab, tr)))
++ | Not_found -> None, virt
++ in
++ let (id, _, _, _) as result =
++ match id with Some id -> (id, val_env, met_env, par_env)
++ | None ->
++ enter_met_env lab (Val_ivar (mut, cl_num)) ty val_env met_env par_env
+ in
+- vars := Vars.add lab (id, mut, ty) !vars;
++ vars := Vars.add lab (id, mut, virt, ty) !vars;
+ result
+
+ let inheritance self_type env concr_meths warn_meths loc parent =
+@@ -218,7 +233,7 @@
+ with Ctype.Unify trace ->
+ match trace with
+ _::_::_::({desc = Tfield(n, _, _, _)}, _)::rem ->
+- raise(Error(loc, Method_type_mismatch (n, rem)))
++ raise(Error(loc, Field_type_mismatch ("method", n, rem)))
+ | _ ->
+ assert false
+ end;
+@@ -243,7 +258,7 @@
+ in
+ let ty = transl_simple_type val_env false sty in
+ try Ctype.unify val_env ty ty' with Ctype.Unify trace ->
+- raise(Error(loc, Method_type_mismatch (lab, trace)))
++ raise(Error(loc, Field_type_mismatch ("method", lab, trace)))
+
+ let delayed_meth_specs = ref []
+
+@@ -253,7 +268,7 @@
+ in
+ let unif ty =
+ try Ctype.unify val_env ty ty' with Ctype.Unify trace ->
+- raise(Error(loc, Method_type_mismatch (lab, trace)))
++ raise(Error(loc, Field_type_mismatch ("method", lab, trace)))
+ in
+ match sty.ptyp_desc, priv with
+ Ptyp_poly ([],sty), Public ->
+@@ -279,6 +294,15 @@
+
+ (*******************************)
+
++let add_val env loc lab (mut, virt, ty) val_sig =
++ let virt =
++ try
++ let (mut', virt', ty') = Vars.find lab val_sig in
++ if virt' = Concrete then virt' else virt
++ with Not_found -> virt
++ in
++ Vars.add lab (mut, virt, ty) val_sig
++
+ let rec class_type_field env self_type meths (val_sig, concr_meths, inher) =
+ function
+ Pctf_inher sparent ->
+@@ -293,25 +317,12 @@
+ parent
+ in
+ let val_sig =
+- Vars.fold
+- (fun lab (mut, ty) val_sig -> Vars.add lab (mut, ty) val_sig)
+- cl_sig.cty_vars val_sig
+- in
++ Vars.fold (add_val env sparent.pcty_loc) cl_sig.cty_vars val_sig in
+ (val_sig, concr_meths, inher)
+
+- | Pctf_val (lab, mut, sty_opt, loc) ->
+- let (mut, ty) =
+- match sty_opt with
+- None ->
+- let (mut', ty) =
+- try Vars.find lab val_sig with Not_found ->
+- raise(Error(loc, Unbound_val lab))
+- in
+- (if mut = Mutable then mut' else Immutable), ty
+- | Some sty ->
+- mut, transl_simple_type env false sty
+- in
+- (Vars.add lab (mut, ty) val_sig, concr_meths, inher)
++ | Pctf_val (lab, mut, virt, sty, loc) ->
++ let ty = transl_simple_type env false sty in
++ (add_val env loc lab (mut, virt, ty) val_sig, concr_meths, inher)
+
+ | Pctf_virt (lab, priv, sty, loc) ->
+ declare_method env meths self_type lab priv sty loc;
+@@ -397,7 +408,7 @@
+
+ let rec class_field cl_num self_type meths vars
+ (val_env, met_env, par_env, fields, concr_meths, warn_meths,
+- inh_vals, inher) =
++ warn_vals, inher) =
+ function
+ Pcf_inher (sparent, super) ->
+ let parent = class_expr cl_num val_env par_env sparent in
+@@ -411,18 +422,23 @@
+ parent.cl_type
+ in
+ (* Variables *)
+- let (val_env, met_env, par_env, inh_vars, inh_vals) =
++ let (val_env, met_env, par_env, inh_vars, warn_vals) =
+ Vars.fold
+- (fun lab (mut, ty) (val_env, met_env, par_env, inh_vars, inh_vals) ->
++ (fun lab info (val_env, met_env, par_env, inh_vars, warn_vals) ->
++ let mut, vr, ty = info in
+ let (id, val_env, met_env, par_env) =
+- enter_val cl_num vars lab mut ty val_env met_env par_env
++ enter_val cl_num vars true lab mut vr ty val_env met_env par_env
++ sparent.pcl_loc
+ in
+- if StringSet.mem lab inh_vals then
+- Location.prerr_warning sparent.pcl_loc
+- (Warnings.Hide_instance_variable lab);
+- (val_env, met_env, par_env, (lab, id) :: inh_vars,
+- StringSet.add lab inh_vals))
+- cl_sig.cty_vars (val_env, met_env, par_env, [], inh_vals)
++ let warn_vals =
++ if vr = Virtual then warn_vals else
++ if StringSet.mem lab warn_vals then
++ (Location.prerr_warning sparent.pcl_loc
++ (Warnings.Instance_variable_override lab); warn_vals)
++ else StringSet.add lab warn_vals
++ in
++ (val_env, met_env, par_env, (lab, id) :: inh_vars, warn_vals))
++ cl_sig.cty_vars (val_env, met_env, par_env, [], warn_vals)
+ in
+ (* Inherited concrete methods *)
+ let inh_meths =
+@@ -443,11 +459,26 @@
+ in
+ (val_env, met_env, par_env,
+ lazy(Cf_inher (parent, inh_vars, inh_meths))::fields,
+- concr_meths, warn_meths, inh_vals, inher)
++ concr_meths, warn_meths, warn_vals, inher)
++
++ | Pcf_valvirt (lab, mut, styp, loc) ->
++ if !Clflags.principal then Ctype.begin_def ();
++ let ty = Typetexp.transl_simple_type val_env false styp in
++ if !Clflags.principal then begin
++ Ctype.end_def ();
++ Ctype.generalize_structure ty
++ end;
++ let (id, val_env, met_env', par_env) =
++ enter_val cl_num vars false lab mut Virtual ty
++ val_env met_env par_env loc
++ in
++ (val_env, met_env', par_env,
++ lazy(Cf_val (lab, id, None, met_env' == met_env)) :: fields,
++ concr_meths, warn_meths, StringSet.remove lab warn_vals, inher)
+
+ | Pcf_val (lab, mut, sexp, loc) ->
+- if StringSet.mem lab inh_vals then
+- Location.prerr_warning loc (Warnings.Hide_instance_variable lab);
++ if StringSet.mem lab warn_vals then
++ Location.prerr_warning loc (Warnings.Instance_variable_override lab);
+ if !Clflags.principal then Ctype.begin_def ();
+ let exp =
+ try type_exp val_env sexp with Ctype.Unify [(ty, _)] ->
+@@ -457,17 +488,19 @@
+ Ctype.end_def ();
+ Ctype.generalize_structure exp.exp_type
+ end;
+- let (id, val_env, met_env, par_env) =
+- enter_val cl_num vars lab mut exp.exp_type val_env met_env par_env
+- in
+- (val_env, met_env, par_env, lazy(Cf_val (lab, id, exp)) :: fields,
+- concr_meths, warn_meths, inh_vals, inher)
++ let (id, val_env, met_env', par_env) =
++ enter_val cl_num vars false lab mut Concrete exp.exp_type
++ val_env met_env par_env loc
++ in
++ (val_env, met_env', par_env,
++ lazy(Cf_val (lab, id, Some exp, met_env' == met_env)) :: fields,
++ concr_meths, warn_meths, StringSet.add lab warn_vals, inher)
+
+ | Pcf_virt (lab, priv, sty, loc) ->
+ virtual_method val_env meths self_type lab priv sty loc;
+ let warn_meths = Concr.remove lab warn_meths in
+ (val_env, met_env, par_env, fields, concr_meths, warn_meths,
+- inh_vals, inher)
++ warn_vals, inher)
+
+ | Pcf_meth (lab, priv, expr, loc) ->
+ let (_, ty) =
+@@ -493,7 +526,7 @@
+ end
+ | _ -> assert false
+ with Ctype.Unify trace ->
+- raise(Error(loc, Method_type_mismatch (lab, trace)))
++ raise(Error(loc, Field_type_mismatch ("method", lab, trace)))
+ end;
+ let meth_expr = make_method cl_num expr in
+ (* backup variables for Pexp_override *)
+@@ -510,12 +543,12 @@
+ Cf_meth (lab, texp)
+ end in
+ (val_env, met_env, par_env, field::fields,
+- Concr.add lab concr_meths, Concr.add lab warn_meths, inh_vals, inher)
++ Concr.add lab concr_meths, Concr.add lab warn_meths, warn_vals, inher)
+
+ | Pcf_cstr (sty, sty', loc) ->
+ type_constraint val_env sty sty' loc;
+ (val_env, met_env, par_env, fields, concr_meths, warn_meths,
+- inh_vals, inher)
++ warn_vals, inher)
+
+ | Pcf_let (rec_flag, sdefs, loc) ->
+ let (defs, val_env) =
+@@ -545,7 +578,7 @@
+ ([], met_env, par_env)
+ in
+ (val_env, met_env, par_env, lazy(Cf_let(rec_flag, defs, vals))::fields,
+- concr_meths, warn_meths, inh_vals, inher)
++ concr_meths, warn_meths, warn_vals, inher)
+
+ | Pcf_init expr ->
+ let expr = make_method cl_num expr in
+@@ -562,7 +595,7 @@
+ Cf_init texp
+ end in
+ (val_env, met_env, par_env, field::fields,
+- concr_meths, warn_meths, inh_vals, inher)
++ concr_meths, warn_meths, warn_vals, inher)
+
+ and class_structure cl_num final val_env met_env loc (spat, str) =
+ (* Environment for substructures *)
+@@ -616,7 +649,7 @@
+ Ctype.unify val_env self_type (Ctype.newvar ());
+ let sign =
+ {cty_self = public_self;
+- cty_vars = Vars.map (function (id, mut, ty) -> (mut, ty)) !vars;
++ cty_vars = Vars.map (fun (id, mut, vr, ty) -> (mut, vr, ty)) !vars;
+ cty_concr = concr_meths;
+ cty_inher = inher} in
+ let methods = get_methods self_type in
+@@ -628,7 +661,11 @@
+ be modified after this point *)
+ Ctype.close_object self_type;
+ let mets = virtual_methods {sign with cty_self = self_type} in
+- if mets <> [] then raise(Error(loc, Virtual_class(true, mets)));
++ let vals =
++ Vars.fold
++ (fun name (mut, vr, ty) l -> if vr = Virtual then name :: l else l)
++ sign.cty_vars [] in
++ if mets <> [] then raise(Error(loc, Virtual_class(true, mets, vals)));
+ let self_methods =
+ List.fold_right
+ (fun (lab,kind,ty) rem ->
+@@ -1135,9 +1172,14 @@
+ in
+
+ if cl.pci_virt = Concrete then begin
+- match virtual_methods (Ctype.signature_of_class_type typ) with
+- [] -> ()
+- | mets -> raise(Error(cl.pci_loc, Virtual_class(define_class, mets)))
++ let sign = Ctype.signature_of_class_type typ in
++ let mets = virtual_methods sign in
++ let vals =
++ Vars.fold
++ (fun name (mut, vr, ty) l -> if vr = Virtual then name :: l else l)
++ sign.cty_vars [] in
++ if mets <> [] || vals <> [] then
++ raise(Error(cl.pci_loc, Virtual_class(true, mets, vals)));
+ end;
+
+ (* Misc. *)
+@@ -1400,10 +1442,10 @@
+ Printtyp.report_unification_error ppf trace
+ (fun ppf -> fprintf ppf "Type")
+ (fun ppf -> fprintf ppf "is not compatible with type")
+- | Method_type_mismatch (m, trace) ->
++ | Field_type_mismatch (k, m, trace) ->
+ Printtyp.report_unification_error ppf trace
+ (function ppf ->
+- fprintf ppf "The method %s@ has type" m)
++ fprintf ppf "The %s %s@ has type" k m)
+ (function ppf ->
+ fprintf ppf "but is expected to have type")
+ | Structure_expected clty ->
+@@ -1451,15 +1493,20 @@
+ fprintf ppf "The expression \"new %s\" has type" c)
+ (function ppf ->
+ fprintf ppf "but is used with type")
+- | Virtual_class (cl, mets) ->
++ | Virtual_class (cl, mets, vals) ->
+ let print_mets ppf mets =
+ List.iter (function met -> fprintf ppf "@ %s" met) mets in
+ let cl_mark = if cl then "" else " type" in
++ let missings =
++ match mets, vals with
++ [], _ -> "variables"
++ | _, [] -> "methods"
++ | _ -> "methods and variables"
++ in
+ fprintf ppf
+- "@[This class%s should be virtual@ \
+- @[<2>The following methods are undefined :%a@]
+- @]"
+- cl_mark print_mets mets
++ "@[This class%s should be virtual.@ \
++ @[<2>The following %s are undefined :%a@]@]"
++ cl_mark missings print_mets (mets @ vals)
+ | Parameter_arity_mismatch(lid, expected, provided) ->
+ fprintf ppf
+ "@[The class constructor %a@ expects %i type argument(s),@ \
+@@ -1532,3 +1579,10 @@
+ fprintf ppf "This object is expected to have type")
+ (function ppf ->
+ fprintf ppf "but has actually type")
++ | Mutability_mismatch (lab, mut) ->
++ let mut1, mut2 =
++ if mut = Immutable then "mutable", "immutable"
++ else "immutable", "mutable" in
++ fprintf ppf
++ "@[The instance variable is %s,@ it cannot be redefined as %s@]"
++ mut1 mut2
+Index: typing/typeclass.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/typeclass.mli,v
+retrieving revision 1.18
+diff -u -r1.18 typeclass.mli
+--- typing/typeclass.mli 1 Dec 2003 00:32:11 -0000 1.18
++++ typing/typeclass.mli 5 Apr 2006 02:26:00 -0000
+@@ -49,7 +49,7 @@
+
+ type error =
+ Unconsistent_constraint of (type_expr * type_expr) list
+- | Method_type_mismatch of string * (type_expr * type_expr) list
++ | Field_type_mismatch of string * string * (type_expr * type_expr) list
+ | Structure_expected of class_type
+ | Cannot_apply of class_type
+ | Apply_wrong_label of label
+@@ -61,7 +61,7 @@
+ | Unbound_class_type_2 of Longident.t
+ | Abbrev_type_clash of type_expr * type_expr * type_expr
+ | Constructor_type_mismatch of string * (type_expr * type_expr) list
+- | Virtual_class of bool * string list
++ | Virtual_class of bool * string list * string list
+ | Parameter_arity_mismatch of Longident.t * int * int
+ | Parameter_mismatch of (type_expr * type_expr) list
+ | Bad_parameters of Ident.t * type_expr * type_expr
+@@ -74,6 +74,7 @@
+ | Non_collapsable_conjunction of
+ Ident.t * Types.class_declaration * (type_expr * type_expr) list
+ | Final_self_clash of (type_expr * type_expr) list
++ | Mutability_mismatch of string * mutable_flag
+
+ exception Error of Location.t * error
+
+Index: typing/typecore.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/typecore.ml,v
+retrieving revision 1.178
+diff -u -r1.178 typecore.ml
+--- typing/typecore.ml 6 Jan 2006 02:25:37 -0000 1.178
++++ typing/typecore.ml 5 Apr 2006 02:26:00 -0000
+@@ -611,11 +611,11 @@
+ List.for_all
+ (function
+ Cf_meth _ -> true
+- | Cf_val (_,_,e) -> incr count; is_nonexpansive e
++ | Cf_val (_,_,e,_) -> incr count; is_nonexpansive_opt e
+ | Cf_init e -> is_nonexpansive e
+ | Cf_inher _ | Cf_let _ -> false)
+ fields &&
+- Vars.fold (fun _ (mut,_) b -> decr count; b && mut = Immutable)
++ Vars.fold (fun _ (mut,_,_) b -> decr count; b && mut = Immutable)
+ vars true &&
+ !count = 0
+ | _ -> false
+@@ -1356,7 +1356,7 @@
+ (path_self, _) ->
+ let type_override (lab, snewval) =
+ begin try
+- let (id, _, ty) = Vars.find lab !vars in
++ let (id, _, _, ty) = Vars.find lab !vars in
+ (Path.Pident id, type_expect env snewval (instance ty))
+ with
+ Not_found ->
+Index: typing/typecore.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/typecore.mli,v
+retrieving revision 1.37
+diff -u -r1.37 typecore.mli
+--- typing/typecore.mli 4 Mar 2005 14:51:31 -0000 1.37
++++ typing/typecore.mli 5 Apr 2006 02:26:00 -0000
+@@ -38,7 +38,8 @@
+ string -> type_expr -> Env.t -> Env.t -> Env.t -> Parsetree.pattern ->
+ Typedtree.pattern *
+ (Ident.t * type_expr) Meths.t ref *
+- (Ident.t * Asttypes.mutable_flag * type_expr) Vars.t ref *
++ (Ident.t * Asttypes.mutable_flag * Asttypes.virtual_flag * type_expr)
++ Vars.t ref *
+ Env.t * Env.t * Env.t
+ val type_expect:
+ ?in_function:(Location.t * type_expr) ->
+Index: typing/typedtree.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/typedtree.ml,v
+retrieving revision 1.36
+diff -u -r1.36 typedtree.ml
+--- typing/typedtree.ml 25 Nov 2003 09:20:43 -0000 1.36
++++ typing/typedtree.ml 5 Apr 2006 02:26:00 -0000
+@@ -106,7 +106,7 @@
+
+ and class_field =
+ Cf_inher of class_expr * (string * Ident.t) list * (string * Ident.t) list
+- | Cf_val of string * Ident.t * expression
++ | Cf_val of string * Ident.t * expression option * bool
+ | Cf_meth of string * expression
+ | Cf_let of rec_flag * (pattern * expression) list *
+ (Ident.t * expression) list
+@@ -140,7 +140,8 @@
+ | Tstr_recmodule of (Ident.t * module_expr) list
+ | Tstr_modtype of Ident.t * module_type
+ | Tstr_open of Path.t
+- | Tstr_class of (Ident.t * int * string list * class_expr) list
++ | Tstr_class of
++ (Ident.t * int * string list * class_expr * virtual_flag) list
+ | Tstr_cltype of (Ident.t * cltype_declaration) list
+ | Tstr_include of module_expr * Ident.t list
+
+Index: typing/typedtree.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/typedtree.mli,v
+retrieving revision 1.34
+diff -u -r1.34 typedtree.mli
+--- typing/typedtree.mli 25 Nov 2003 09:20:43 -0000 1.34
++++ typing/typedtree.mli 5 Apr 2006 02:26:00 -0000
+@@ -107,7 +107,8 @@
+ and class_field =
+ Cf_inher of class_expr * (string * Ident.t) list * (string * Ident.t) list
+ (* Inherited instance variables and concrete methods *)
+- | Cf_val of string * Ident.t * expression
++ | Cf_val of string * Ident.t * expression option * bool
++ (* None = virtual, true = override *)
+ | Cf_meth of string * expression
+ | Cf_let of rec_flag * (pattern * expression) list *
+ (Ident.t * expression) list
+@@ -141,7 +142,8 @@
+ | Tstr_recmodule of (Ident.t * module_expr) list
+ | Tstr_modtype of Ident.t * module_type
+ | Tstr_open of Path.t
+- | Tstr_class of (Ident.t * int * string list * class_expr) list
++ | Tstr_class of
++ (Ident.t * int * string list * class_expr * virtual_flag) list
+ | Tstr_cltype of (Ident.t * cltype_declaration) list
+ | Tstr_include of module_expr * Ident.t list
+
+Index: typing/typemod.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/typemod.ml,v
+retrieving revision 1.73
+diff -u -r1.73 typemod.ml
+--- typing/typemod.ml 8 Aug 2005 09:41:51 -0000 1.73
++++ typing/typemod.ml 5 Apr 2006 02:26:00 -0000
+@@ -17,6 +17,7 @@
+ open Misc
+ open Longident
+ open Path
++open Asttypes
+ open Parsetree
+ open Types
+ open Typedtree
+@@ -667,8 +668,9 @@
+ let (classes, new_env) = Typeclass.class_declarations env cl in
+ let (str_rem, sig_rem, final_env) = type_struct new_env srem in
+ (Tstr_class
+- (List.map (fun (i, _,_,_,_,_,_,_, s, m, c) ->
+- (i, s, m, c)) classes) ::
++ (List.map (fun (i, d, _,_,_,_,_,_, s, m, c) ->
++ let vf = if d.cty_new = None then Virtual else Concrete in
++ (i, s, m, c, vf)) classes) ::
+ Tstr_cltype
+ (List.map (fun (_,_, i, d, _,_,_,_,_,_,_) -> (i, d)) classes) ::
+ Tstr_type
+Index: typing/types.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/types.ml,v
+retrieving revision 1.25
+diff -u -r1.25 types.ml
+--- typing/types.ml 9 Dec 2004 12:40:53 -0000 1.25
++++ typing/types.ml 5 Apr 2006 02:26:00 -0000
+@@ -90,7 +90,8 @@
+ | Val_prim of Primitive.description (* Primitive *)
+ | Val_ivar of mutable_flag * string (* Instance variable (mutable ?) *)
+ | Val_self of (Ident.t * type_expr) Meths.t ref *
+- (Ident.t * Asttypes.mutable_flag * type_expr) Vars.t ref *
++ (Ident.t * Asttypes.mutable_flag *
++ Asttypes.virtual_flag * type_expr) Vars.t ref *
+ string * type_expr
+ (* Self *)
+ | Val_anc of (string * Ident.t) list * string
+@@ -156,7 +157,8 @@
+
+ and class_signature =
+ { cty_self: type_expr;
+- cty_vars: (Asttypes.mutable_flag * type_expr) Vars.t;
++ cty_vars:
++ (Asttypes.mutable_flag * Asttypes.virtual_flag * type_expr) Vars.t;
+ cty_concr: Concr.t;
+ cty_inher: (Path.t * type_expr list) list }
+
+Index: typing/types.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/types.mli,v
+retrieving revision 1.25
+diff -u -r1.25 types.mli
+--- typing/types.mli 9 Dec 2004 12:40:53 -0000 1.25
++++ typing/types.mli 5 Apr 2006 02:26:00 -0000
+@@ -91,7 +91,8 @@
+ | Val_prim of Primitive.description (* Primitive *)
+ | Val_ivar of mutable_flag * string (* Instance variable (mutable ?) *)
+ | Val_self of (Ident.t * type_expr) Meths.t ref *
+- (Ident.t * Asttypes.mutable_flag * type_expr) Vars.t ref *
++ (Ident.t * Asttypes.mutable_flag *
++ Asttypes.virtual_flag * type_expr) Vars.t ref *
+ string * type_expr
+ (* Self *)
+ | Val_anc of (string * Ident.t) list * string
+@@ -158,7 +159,8 @@
+
+ and class_signature =
+ { cty_self: type_expr;
+- cty_vars: (Asttypes.mutable_flag * type_expr) Vars.t;
++ cty_vars:
++ (Asttypes.mutable_flag * Asttypes.virtual_flag * type_expr) Vars.t;
+ cty_concr: Concr.t;
+ cty_inher: (Path.t * type_expr list) list }
+
+Index: typing/unused_var.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/typing/unused_var.ml,v
+retrieving revision 1.5
+diff -u -r1.5 unused_var.ml
+--- typing/unused_var.ml 4 Jan 2006 16:55:50 -0000 1.5
++++ typing/unused_var.ml 5 Apr 2006 02:26:00 -0000
+@@ -245,7 +245,7 @@
+ match cf with
+ | Pcf_inher (ce, _) -> class_expr ppf tbl ce;
+ | Pcf_val (_, _, e, _) -> expression ppf tbl e;
+- | Pcf_virt _ -> ()
++ | Pcf_virt _ | Pcf_valvirt _ -> ()
+ | Pcf_meth (_, _, e, _) -> expression ppf tbl e;
+ | Pcf_cstr _ -> ()
+ | Pcf_let (recflag, pel, _) -> let_pel ppf tbl recflag pel None;
+Index: bytecomp/translclass.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/translclass.ml,v
+retrieving revision 1.38
+diff -u -r1.38 translclass.ml
+--- bytecomp/translclass.ml 13 Aug 2005 20:59:37 -0000 1.38
++++ bytecomp/translclass.ml 5 Apr 2006 02:26:00 -0000
+@@ -133,10 +133,10 @@
+ (fun _ -> lambda_unit) cl
+ in
+ (inh_init, lsequence obj_init' obj_init, true)
+- | Cf_val (_, id, exp) ->
++ | Cf_val (_, id, Some exp, _) ->
+ (inh_init, lsequence (set_inst_var obj id exp) obj_init,
+ has_init)
+- | Cf_meth _ ->
++ | Cf_meth _ | Cf_val _ ->
+ (inh_init, obj_init, has_init)
+ | Cf_init _ ->
+ (inh_init, obj_init, true)
+@@ -213,27 +213,17 @@
+ if len < 2 && nvals = 0 then Meths.fold (bind_method tbl) meths cl_init else
+ if len = 0 && nvals < 2 then transl_vals tbl true vals cl_init else
+ let ids = Ident.create "ids" in
+- let i = ref len in
+- let getter, names, cl_init =
+- match vals with [] -> "get_method_labels", [], cl_init
+- | (_,id0)::vals' ->
+- incr i;
+- let i = ref (List.length vals) in
+- "new_methods_variables",
+- [transl_meth_list (List.map fst vals)],
+- Llet(Strict, id0, lfield ids 0,
+- List.fold_right
+- (fun (name,id) rem ->
+- decr i;
+- Llet(Alias, id, Lprim(Poffsetint !i, [Lvar id0]), rem))
+- vals' cl_init)
++ let i = ref (len + nvals) in
++ let getter, names =
++ if nvals = 0 then "get_method_labels", [] else
++ "new_methods_variables", [transl_meth_list (List.map fst vals)]
+ in
+ Llet(StrictOpt, ids,
+ Lapply (oo_prim getter,
+ [Lvar tbl; transl_meth_list (List.map fst methl)] @ names),
+ List.fold_right
+ (fun (lab,id) lam -> decr i; Llet(StrictOpt, id, lfield ids !i, lam))
+- methl cl_init)
++ (methl @ vals) cl_init)
+
+ let output_methods tbl methods lam =
+ match methods with
+@@ -283,8 +273,9 @@
+ (vals, meths_super cla str.cl_meths meths)
+ inh_init cl_init msubst top cl in
+ (inh_init, cl_init, [], values)
+- | Cf_val (name, id, exp) ->
+- (inh_init, cl_init, methods, (name, id)::values)
++ | Cf_val (name, id, exp, over) ->
++ let values = if over then values else (name, id) :: values in
++ (inh_init, cl_init, methods, values)
+ | Cf_meth (name, exp) ->
+ let met_code = msubst true (transl_exp exp) in
+ let met_code =
+@@ -342,27 +333,24 @@
+ assert (Path.same path path');
+ let lpath = transl_path path in
+ let inh = Ident.create "inh"
+- and inh_vals = Ident.create "vals"
+- and inh_meths = Ident.create "meths"
++ and ofs = List.length vals + 1
+ and valids, methids = super in
+ let cl_init =
+ List.fold_left
+ (fun init (nm, id, _) ->
+- Llet(StrictOpt, id, lfield inh_meths (index nm concr_meths),
++ Llet(StrictOpt, id, lfield inh (index nm concr_meths + ofs),
+ init))
+ cl_init methids in
+ let cl_init =
+ List.fold_left
+ (fun init (nm, id) ->
+- Llet(StrictOpt, id, lfield inh_vals (index nm vals), init))
++ Llet(StrictOpt, id, lfield inh (index nm vals + 1), init))
+ cl_init valids in
+ (inh_init,
+ Llet (Strict, inh,
+ Lapply(oo_prim "inherits", narrow_args @
+ [lpath; Lconst(Const_pointer(if top then 1 else 0))]),
+- Llet(StrictOpt, obj_init, lfield inh 0,
+- Llet(Alias, inh_vals, lfield inh 1,
+- Llet(Alias, inh_meths, lfield inh 2, cl_init)))))
++ Llet(StrictOpt, obj_init, lfield inh 0, cl_init)))
+ | _ ->
+ let core cl_init =
+ build_class_init cla true super inh_init cl_init msubst top cl
+@@ -397,12 +385,16 @@
+ XXX Il devrait etre peu couteux d'ecrire des classes :
+ class c x y = d e f
+ *)
+-let rec transl_class_rebind obj_init cl =
++let rec transl_class_rebind obj_init cl vf =
+ match cl.cl_desc with
+ Tclass_ident path ->
++ if vf = Concrete then begin
++ try if (Env.find_class path cl.cl_env).cty_new = None then raise Exit
++ with Not_found -> raise Exit
++ end;
+ (path, obj_init)
+ | Tclass_fun (pat, _, cl, partial) ->
+- let path, obj_init = transl_class_rebind obj_init cl in
++ let path, obj_init = transl_class_rebind obj_init cl vf in
+ let build params rem =
+ let param = name_pattern "param" [pat, ()] in
+ Lfunction (Curried, param::params,
+@@ -414,14 +406,14 @@
+ Lfunction (Curried, params, rem) -> build params rem
+ | rem -> build [] rem)
+ | Tclass_apply (cl, oexprs) ->
+- let path, obj_init = transl_class_rebind obj_init cl in
++ let path, obj_init = transl_class_rebind obj_init cl vf in
+ (path, transl_apply obj_init oexprs)
+ | Tclass_let (rec_flag, defs, vals, cl) ->
+- let path, obj_init = transl_class_rebind obj_init cl in
++ let path, obj_init = transl_class_rebind obj_init cl vf in
+ (path, Translcore.transl_let rec_flag defs obj_init)
+ | Tclass_structure _ -> raise Exit
+ | Tclass_constraint (cl', _, _, _) ->
+- let path, obj_init = transl_class_rebind obj_init cl' in
++ let path, obj_init = transl_class_rebind obj_init cl' vf in
+ let rec check_constraint = function
+ Tcty_constr(path', _, _) when Path.same path path' -> ()
+ | Tcty_fun (_, _, cty) -> check_constraint cty
+@@ -430,21 +422,21 @@
+ check_constraint cl.cl_type;
+ (path, obj_init)
+
+-let rec transl_class_rebind_0 self obj_init cl =
++let rec transl_class_rebind_0 self obj_init cl vf =
+ match cl.cl_desc with
+ Tclass_let (rec_flag, defs, vals, cl) ->
+- let path, obj_init = transl_class_rebind_0 self obj_init cl in
++ let path, obj_init = transl_class_rebind_0 self obj_init cl vf in
+ (path, Translcore.transl_let rec_flag defs obj_init)
+ | _ ->
+- let path, obj_init = transl_class_rebind obj_init cl in
++ let path, obj_init = transl_class_rebind obj_init cl vf in
+ (path, lfunction [self] obj_init)
+
+-let transl_class_rebind ids cl =
++let transl_class_rebind ids cl vf =
+ try
+ let obj_init = Ident.create "obj_init"
+ and self = Ident.create "self" in
+ let obj_init0 = lapply (Lvar obj_init) [Lvar self] in
+- let path, obj_init' = transl_class_rebind_0 self obj_init0 cl in
++ let path, obj_init' = transl_class_rebind_0 self obj_init0 cl vf in
+ if not (Translcore.check_recursive_lambda ids obj_init') then
+ raise(Error(cl.cl_loc, Illegal_class_expr));
+ let id = (obj_init' = lfunction [self] obj_init0) in
+@@ -592,9 +584,9 @@
+ *)
+
+
+-let transl_class ids cl_id arity pub_meths cl =
++let transl_class ids cl_id arity pub_meths cl vflag =
+ (* First check if it is not only a rebind *)
+- let rebind = transl_class_rebind ids cl in
++ let rebind = transl_class_rebind ids cl vflag in
+ if rebind <> lambda_unit then rebind else
+
+ (* Prepare for heavy environment handling *)
+@@ -696,9 +688,7 @@
+ (* Simplest case: an object defined at toplevel (ids=[]) *)
+ if top && ids = [] then llets (ltable cla (ldirect obj_init)) else
+
+- let concrete =
+- ids = [] ||
+- Typeclass.virtual_methods (Ctype.signature_of_class_type cl.cl_type) = []
++ let concrete = (vflag = Concrete)
+ and lclass lam =
+ let cl_init = llets (Lfunction(Curried, [cla], cl_init)) in
+ Llet(Strict, class_init, cl_init, lam (free_variables cl_init))
+@@ -800,11 +790,11 @@
+
+ (* Wrapper for class compilation *)
+
+-let transl_class ids cl_id arity pub_meths cl =
+- oo_wrap cl.cl_env false (transl_class ids cl_id arity pub_meths) cl
++let transl_class ids cl_id arity pub_meths cl vf =
++ oo_wrap cl.cl_env false (transl_class ids cl_id arity pub_meths cl) vf
+
+ let () =
+- transl_object := (fun id meths cl -> transl_class [] id 0 meths cl)
++ transl_object := (fun id meths cl -> transl_class [] id 0 meths cl Concrete)
+
+ (* Error report *)
+
+Index: bytecomp/translclass.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/translclass.mli,v
+retrieving revision 1.11
+diff -u -r1.11 translclass.mli
+--- bytecomp/translclass.mli 12 Aug 2004 12:55:11 -0000 1.11
++++ bytecomp/translclass.mli 5 Apr 2006 02:26:00 -0000
+@@ -16,7 +16,8 @@
+ open Lambda
+
+ val transl_class :
+- Ident.t list -> Ident.t -> int -> string list -> class_expr -> lambda;;
++ Ident.t list -> Ident.t ->
++ int -> string list -> class_expr -> Asttypes.virtual_flag -> lambda;;
+
+ type error = Illegal_class_expr | Tags of string * string
+
+Index: bytecomp/translmod.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/bytecomp/translmod.ml,v
+retrieving revision 1.51
+diff -u -r1.51 translmod.ml
+--- bytecomp/translmod.ml 12 Aug 2004 12:55:11 -0000 1.51
++++ bytecomp/translmod.ml 5 Apr 2006 02:26:00 -0000
+@@ -317,10 +317,10 @@
+ | Tstr_open path :: rem ->
+ transl_structure fields cc rootpath rem
+ | Tstr_class cl_list :: rem ->
+- let ids = List.map (fun (i, _, _, _) -> i) cl_list in
++ let ids = List.map (fun (i, _, _, _, _) -> i) cl_list in
+ Lletrec(List.map
+- (fun (id, arity, meths, cl) ->
+- (id, transl_class ids id arity meths cl))
++ (fun (id, arity, meths, cl, vf) ->
++ (id, transl_class ids id arity meths cl vf))
+ cl_list,
+ transl_structure (List.rev ids @ fields) cc rootpath rem)
+ | Tstr_cltype cl_list :: rem ->
+@@ -414,11 +414,11 @@
+ | Tstr_open path :: rem ->
+ transl_store subst rem
+ | Tstr_class cl_list :: rem ->
+- let ids = List.map (fun (i, _, _, _) -> i) cl_list in
++ let ids = List.map (fun (i, _, _, _, _) -> i) cl_list in
+ let lam =
+ Lletrec(List.map
+- (fun (id, arity, meths, cl) ->
+- (id, transl_class ids id arity meths cl))
++ (fun (id, arity, meths, cl, vf) ->
++ (id, transl_class ids id arity meths cl vf))
+ cl_list,
+ store_idents ids) in
+ Lsequence(subst_lambda subst lam,
+@@ -485,7 +485,7 @@
+ | Tstr_modtype(id, decl) :: rem -> defined_idents rem
+ | Tstr_open path :: rem -> defined_idents rem
+ | Tstr_class cl_list :: rem ->
+- List.map (fun (i, _, _, _) -> i) cl_list @ defined_idents rem
++ List.map (fun (i, _, _, _, _) -> i) cl_list @ defined_idents rem
+ | Tstr_cltype cl_list :: rem -> defined_idents rem
+ | Tstr_include(modl, ids) :: rem -> ids @ defined_idents rem
+
+@@ -603,14 +603,14 @@
+ | Tstr_class cl_list ->
+ (* we need to use unique names for the classes because there might
+ be a value named identically *)
+- let ids = List.map (fun (i, _, _, _) -> i) cl_list in
++ let ids = List.map (fun (i, _, _, _, _) -> i) cl_list in
+ List.iter set_toplevel_unique_name ids;
+ Lletrec(List.map
+- (fun (id, arity, meths, cl) ->
+- (id, transl_class ids id arity meths cl))
++ (fun (id, arity, meths, cl, vf) ->
++ (id, transl_class ids id arity meths cl vf))
+ cl_list,
+ make_sequence
+- (fun (id, _, _, _) -> toploop_setvalue_id id)
++ (fun (id, _, _, _, _) -> toploop_setvalue_id id)
+ cl_list)
+ | Tstr_cltype cl_list ->
+ lambda_unit
+Index: driver/main_args.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/driver/main_args.ml,v
+retrieving revision 1.48
+diff -u -r1.48 main_args.ml
+--- driver/main_args.ml 4 Jan 2006 16:55:49 -0000 1.48
++++ driver/main_args.ml 5 Apr 2006 02:26:00 -0000
+@@ -136,11 +136,11 @@
+ \032 E/e enable/disable fragile match\n\
+ \032 F/f enable/disable partially applied function\n\
+ \032 L/l enable/disable labels omitted in application\n\
+- \032 M/m enable/disable overridden method\n\
++ \032 M/m enable/disable overridden methods\n\
+ \032 P/p enable/disable partial match\n\
+ \032 S/s enable/disable non-unit statement\n\
+ \032 U/u enable/disable unused match case\n\
+- \032 V/v enable/disable hidden instance variable\n\
++ \032 V/v enable/disable overridden instance variables\n\
+ \032 Y/y enable/disable suspicious unused variables\n\
+ \032 Z/z enable/disable all other unused variables\n\
+ \032 X/x enable/disable all other warnings\n\
+Index: driver/optmain.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/driver/optmain.ml,v
+retrieving revision 1.87
+diff -u -r1.87 optmain.ml
+--- driver/optmain.ml 4 Jan 2006 16:55:49 -0000 1.87
++++ driver/optmain.ml 5 Apr 2006 02:26:00 -0000
+@@ -173,7 +173,7 @@
+ \032 P/p enable/disable partial match\n\
+ \032 S/s enable/disable non-unit statement\n\
+ \032 U/u enable/disable unused match case\n\
+- \032 V/v enable/disable hidden instance variables\n\
++ \032 V/v enable/disable overridden instance variables\n\
+ \032 Y/y enable/disable suspicious unused variables\n\
+ \032 Z/z enable/disable all other unused variables\n\
+ \032 X/x enable/disable all other warnings\n\
+Index: stdlib/camlinternalOO.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/stdlib/camlinternalOO.ml,v
+retrieving revision 1.14
+diff -u -r1.14 camlinternalOO.ml
+--- stdlib/camlinternalOO.ml 25 Oct 2005 18:34:07 -0000 1.14
++++ stdlib/camlinternalOO.ml 5 Apr 2006 02:26:00 -0000
+@@ -206,7 +206,11 @@
+ (table.methods_by_name, table.methods_by_label, table.hidden_meths,
+ table.vars, virt_meth_labs, vars)
+ :: table.previous_states;
+- table.vars <- Vars.empty;
++ table.vars <-
++ Vars.fold
++ (fun lab info tvars ->
++ if List.mem lab vars then Vars.add lab info tvars else tvars)
++ table.vars Vars.empty;
+ let by_name = ref Meths.empty in
+ let by_label = ref Labs.empty in
+ List.iter2
+@@ -255,9 +259,11 @@
+ index
+
+ let new_variable table name =
+- let index = new_slot table in
+- table.vars <- Vars.add name index table.vars;
+- index
++ try Vars.find name table.vars
++ with Not_found ->
++ let index = new_slot table in
++ table.vars <- Vars.add name index table.vars;
++ index
+
+ let to_array arr =
+ if arr = Obj.magic 0 then [||] else arr
+@@ -265,16 +271,17 @@
+ let new_methods_variables table meths vals =
+ let meths = to_array meths in
+ let nmeths = Array.length meths and nvals = Array.length vals in
+- let index = new_variable table vals.(0) in
+- let res = Array.create (nmeths + 1) index in
+- for i = 1 to nvals - 1 do ignore (new_variable table vals.(i)) done;
++ let res = Array.create (nmeths + nvals) 0 in
+ for i = 0 to nmeths - 1 do
+- res.(i+1) <- get_method_label table meths.(i)
++ res.(i) <- get_method_label table meths.(i)
++ done;
++ for i = 0 to nvals - 1 do
++ res.(i+nmeths) <- new_variable table vals.(i)
+ done;
+ res
+
+ let get_variable table name =
+- Vars.find name table.vars
++ try Vars.find name table.vars with Not_found -> assert false
+
+ let get_variables table names =
+ Array.map (get_variable table) names
+@@ -315,9 +322,12 @@
+ let init =
+ if top then super cla env else Obj.repr (super cla) in
+ widen cla;
+- (init, Array.map (get_variable cla) (to_array vals),
+- Array.map (fun nm -> get_method cla (get_method_label cla nm))
+- (to_array concr_meths))
++ Array.concat
++ [[| repr init |];
++ magic (Array.map (get_variable cla) (to_array vals) : int array);
++ Array.map
++ (fun nm -> repr (get_method cla (get_method_label cla nm) : closure))
++ (to_array concr_meths) ]
+
+ let make_class pub_meths class_init =
+ let table = create_table pub_meths in
+Index: stdlib/camlinternalOO.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/stdlib/camlinternalOO.mli,v
+retrieving revision 1.9
+diff -u -r1.9 camlinternalOO.mli
+--- stdlib/camlinternalOO.mli 25 Oct 2005 18:34:07 -0000 1.9
++++ stdlib/camlinternalOO.mli 5 Apr 2006 02:26:00 -0000
+@@ -46,8 +46,7 @@
+ val init_class : table -> unit
+ val inherits :
+ table -> string array -> string array -> string array ->
+- (t * (table -> obj -> Obj.t) * t * obj) -> bool ->
+- (Obj.t * int array * closure array)
++ (t * (table -> obj -> Obj.t) * t * obj) -> bool -> Obj.t array
+ val make_class :
+ string array -> (table -> Obj.t -> t) ->
+ (t * (table -> Obj.t -> t) * (Obj.t -> t) * Obj.t)
+@@ -79,6 +78,7 @@
+
+ (** {6 Builtins to reduce code size} *)
+
++(*
+ val get_const : t -> closure
+ val get_var : int -> closure
+ val get_env : int -> int -> closure
+@@ -103,6 +103,7 @@
+ val send_var : tag -> int -> int -> closure
+ val send_env : tag -> int -> int -> int -> closure
+ val send_meth : tag -> label -> int -> closure
++*)
+
+ type impl =
+ GetConst
+Index: stdlib/sys.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/stdlib/sys.ml,v
+retrieving revision 1.142
+diff -u -r1.142 sys.ml
+--- stdlib/sys.ml 22 Mar 2006 12:39:39 -0000 1.142
++++ stdlib/sys.ml 5 Apr 2006 02:26:00 -0000
+@@ -78,4 +78,4 @@
+
+ (* OCaml version string, must be in the format described in sys.mli. *)
+
+-let ocaml_version = "3.10+dev4 (2006-03-22)";;
++let ocaml_version = "3.10+dev5 (2006-04-05)";;
+Index: tools/depend.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/tools/depend.ml,v
+retrieving revision 1.9
+diff -u -r1.9 depend.ml
+--- tools/depend.ml 23 Mar 2005 03:08:37 -0000 1.9
++++ tools/depend.ml 5 Apr 2006 02:26:00 -0000
+@@ -87,7 +87,7 @@
+
+ and add_class_type_field bv = function
+ Pctf_inher cty -> add_class_type bv cty
+- | Pctf_val(_, _, oty, _) -> add_opt add_type bv oty
++ | Pctf_val(_, _, _, ty, _) -> add_type bv ty
+ | Pctf_virt(_, _, ty, _) -> add_type bv ty
+ | Pctf_meth(_, _, ty, _) -> add_type bv ty
+ | Pctf_cstr(ty1, ty2, _) -> add_type bv ty1; add_type bv ty2
+@@ -280,6 +280,7 @@
+ and add_class_field bv = function
+ Pcf_inher(ce, _) -> add_class_expr bv ce
+ | Pcf_val(_, _, e, _) -> add_expr bv e
++ | Pcf_valvirt(_, _, ty, _)
+ | Pcf_virt(_, _, ty, _) -> add_type bv ty
+ | Pcf_meth(_, _, e, _) -> add_expr bv e
+ | Pcf_cstr(ty1, ty2, _) -> add_type bv ty1; add_type bv ty2
+Index: tools/ocamlprof.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/tools/ocamlprof.ml,v
+retrieving revision 1.38
+diff -u -r1.38 ocamlprof.ml
+--- tools/ocamlprof.ml 24 Mar 2005 17:20:54 -0000 1.38
++++ tools/ocamlprof.ml 5 Apr 2006 02:26:00 -0000
+@@ -328,7 +328,7 @@
+ rewrite_patexp_list iflag spat_sexp_list
+ | Pcf_init sexp ->
+ rewrite_exp iflag sexp
+- | Pcf_virt _ | Pcf_cstr _ -> ()
++ | Pcf_valvirt _ | Pcf_virt _ | Pcf_cstr _ -> ()
+
+ and rewrite_class_expr iflag cexpr =
+ match cexpr.pcl_desc with
+Index: otherlibs/labltk/browser/searchpos.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/otherlibs/labltk/browser/searchpos.ml,v
+retrieving revision 1.48
+diff -u -r1.48 searchpos.ml
+--- otherlibs/labltk/browser/searchpos.ml 23 Mar 2005 03:08:37 -0000 1.48
++++ otherlibs/labltk/browser/searchpos.ml 5 Apr 2006 02:26:01 -0000
+@@ -141,9 +141,8 @@
+ List.iter cfl ~f:
+ begin function
+ Pctf_inher cty -> search_pos_class_type cty ~pos ~env
+- | Pctf_val (_, _, Some ty, loc) ->
++ | Pctf_val (_, _, _, ty, loc) ->
+ if in_loc loc ~pos then search_pos_type ty ~pos ~env
+- | Pctf_val _ -> ()
+ | Pctf_virt (_, _, ty, loc) ->
+ if in_loc loc ~pos then search_pos_type ty ~pos ~env
+ | Pctf_meth (_, _, ty, loc) ->
+@@ -675,7 +674,7 @@
+ | Tstr_modtype _ -> ()
+ | Tstr_open _ -> ()
+ | Tstr_class l ->
+- List.iter l ~f:(fun (id, _, _, cl) -> search_pos_class_expr cl ~pos)
++ List.iter l ~f:(fun (id, _, _, cl, _) -> search_pos_class_expr cl ~pos)
+ | Tstr_cltype _ -> ()
+ | Tstr_include (m, _) -> search_pos_module_expr m ~pos
+ end
+@@ -685,7 +684,8 @@
+ begin function
+ Cf_inher (cl, _, _) ->
+ search_pos_class_expr cl ~pos
+- | Cf_val (_, _, exp) -> search_pos_expr exp ~pos
++ | Cf_val (_, _, Some exp, _) -> search_pos_expr exp ~pos
++ | Cf_val _ -> ()
+ | Cf_meth (_, exp) -> search_pos_expr exp ~pos
+ | Cf_let (_, pel, iel) ->
+ List.iter pel ~f:
+Index: ocamldoc/Makefile
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/ocamldoc/Makefile,v
+retrieving revision 1.61
+diff -u -r1.61 Makefile
+--- ocamldoc/Makefile 4 Jan 2006 16:55:49 -0000 1.61
++++ ocamldoc/Makefile 5 Apr 2006 02:26:01 -0000
+@@ -31,7 +31,7 @@
+ MKDIR=mkdir -p
+ CP=cp -f
+ OCAMLDOC=ocamldoc
+-OCAMLDOC_RUN=sh ./runocamldoc $(SUPPORTS_SHARED_LIBRARIES)
++OCAMLDOC_RUN=./ocamldoc.opt #sh ./runocamldoc $(SUPPORTS_SHARED_LIBRARIES)
+ OCAMLDOC_OPT=$(OCAMLDOC).opt
+ OCAMLDOC_LIBCMA=odoc_info.cma
+ OCAMLDOC_LIBCMI=odoc_info.cmi
+@@ -188,12 +188,12 @@
+ ../otherlibs/num/num.mli
+
+ all: exe lib
+- $(MAKE) manpages
+
+ exe: $(OCAMLDOC)
+ lib: $(OCAMLDOC_LIBCMA) $(OCAMLDOC_LIBCMI) $(ODOC_TEST)
+
+ opt.opt: exeopt libopt
++ $(MAKE) manpages
+ exeopt: $(OCAMLDOC_OPT)
+ libopt: $(OCAMLDOC_LIBCMXA) $(OCAMLDOC_LIBCMI)
+ debug:
+Index: ocamldoc/odoc_ast.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/ocamldoc/odoc_ast.ml,v
+retrieving revision 1.27
+diff -u -r1.27 odoc_ast.ml
+--- ocamldoc/odoc_ast.ml 4 Jan 2006 16:55:49 -0000 1.27
++++ ocamldoc/odoc_ast.ml 5 Apr 2006 02:26:01 -0000
+@@ -88,7 +88,7 @@
+ ident_type_decl_list
+ | Typedtree.Tstr_class info_list ->
+ List.iter
+- (fun ((id,_,_,_) as ci) ->
++ (fun ((id,_,_,_,_) as ci) ->
+ Hashtbl.add table (C (Name.from_ident id))
+ (Typedtree.Tstr_class [ci]))
+ info_list
+@@ -146,7 +146,7 @@
+
+ let search_class_exp table name =
+ match Hashtbl.find table (C name) with
+- | (Typedtree.Tstr_class [(_,_,_,ce)]) ->
++ | (Typedtree.Tstr_class [(_,_,_,ce,_)]) ->
+ (
+ try
+ let type_decl = search_type_declaration table name in
+@@ -184,7 +184,7 @@
+ let rec iter = function
+ | [] ->
+ raise Not_found
+- | Typedtree.Cf_val (_, ident, exp) :: q
++ | Typedtree.Cf_val (_, ident, Some exp, _) :: q
+ when Name.from_ident ident = name ->
+ exp.Typedtree.exp_type
+ | _ :: q ->
+@@ -523,7 +523,8 @@
+ p_clexp.Parsetree.pcl_loc.Location.loc_end.Lexing.pos_cnum
+ q
+
+- | (Parsetree.Pcf_val (label, mutable_flag, expression, loc)) :: q ->
++ | (Parsetree.Pcf_val (label, mutable_flag, _, loc) |
++ Parsetree.Pcf_valvirt (label, mutable_flag, _, loc)) :: q ->
+ let complete_name = Name.concat current_class_name label in
+ let (info_opt, ele_comments) = get_comments_in_class last_pos loc.Location.loc_start.Lexing.pos_cnum in
+ let type_exp =
+Index: ocamldoc/odoc_sig.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/ocamldoc/odoc_sig.ml,v
+retrieving revision 1.37
+diff -u -r1.37 odoc_sig.ml
+--- ocamldoc/odoc_sig.ml 4 Jan 2006 16:55:50 -0000 1.37
++++ ocamldoc/odoc_sig.ml 5 Apr 2006 02:26:01 -0000
+@@ -107,7 +107,7 @@
+ | _ -> assert false
+
+ let search_attribute_type name class_sig =
+- let (_, type_expr) = Types.Vars.find name class_sig.Types.cty_vars in
++ let (_, _, type_expr) = Types.Vars.find name class_sig.Types.cty_vars in
+ type_expr
+
+ let search_method_type name class_sig =
+@@ -269,7 +269,7 @@
+ [] -> pos_limit
+ | ele2 :: _ ->
+ match ele2 with
+- Parsetree.Pctf_val (_, _, _, loc)
++ Parsetree.Pctf_val (_, _, _, _, loc)
+ | Parsetree.Pctf_virt (_, _, _, loc)
+ | Parsetree.Pctf_meth (_, _, _, loc)
+ | Parsetree.Pctf_cstr (_, _, loc) -> loc.Location.loc_start.Lexing.pos_cnum
+@@ -330,7 +330,7 @@
+ in
+ ([], ele_comments)
+
+- | Parsetree.Pctf_val (name, mutable_flag, _, loc) :: q ->
++ | Parsetree.Pctf_val (name, mutable_flag, _, _, loc) :: q ->
+ (* of (string * mutable_flag * core_type option * Location.t)*)
+ let (comment_opt, eles_comments) = get_comments_in_class last_pos loc.Location.loc_start.Lexing.pos_cnum in
+ let complete_name = Name.concat current_class_name name in
+Index: camlp4/camlp4/ast2pt.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/camlp4/camlp4/ast2pt.ml,v
+retrieving revision 1.36
+diff -u -r1.36 ast2pt.ml
+--- camlp4/camlp4/ast2pt.ml 29 Jun 2005 04:11:26 -0000 1.36
++++ camlp4/camlp4/ast2pt.ml 5 Apr 2006 02:26:01 -0000
+@@ -244,6 +244,7 @@
+ ;
+ value mkmutable m = if m then Mutable else Immutable;
+ value mkprivate m = if m then Private else Public;
++value mkvirtual m = if m then Virtual else Concrete;
+ value mktrecord (loc, n, m, t) =
+ (n, mkmutable m, ctyp (mkpolytype t), mkloc loc);
+ value mkvariant (loc, c, tl) = (c, List.map ctyp tl, mkloc loc);
+@@ -862,8 +863,8 @@
+ | CgInh loc ct -> [Pctf_inher (class_type ct) :: l]
+ | CgMth loc s pf t ->
+ [Pctf_meth (s, mkprivate pf, ctyp (mkpolytype t), mkloc loc) :: l]
+- | CgVal loc s b t ->
+- [Pctf_val (s, mkmutable b, Some (ctyp t), mkloc loc) :: l]
++ | CgVal loc s b v t ->
++ [Pctf_val (s, mkmutable b, mkvirtual v, ctyp t, mkloc loc) :: l]
+ | CgVir loc s b t ->
+ [Pctf_virt (s, mkprivate b, ctyp (mkpolytype t), mkloc loc) :: l] ]
+ and class_expr =
+@@ -907,7 +908,9 @@
+ [Pcf_meth (s, mkprivate b, e, mkloc loc) :: l]
+ | CrVal loc s b e -> [Pcf_val (s, mkmutable b, expr e, mkloc loc) :: l]
+ | CrVir loc s b t ->
+- [Pcf_virt (s, mkprivate b, ctyp (mkpolytype t), mkloc loc) :: l] ]
++ [Pcf_virt (s, mkprivate b, ctyp (mkpolytype t), mkloc loc) :: l]
++ | CrVvr loc s b t ->
++ [Pcf_valvirt (s, mkmutable b, ctyp t, mkloc loc) :: l] ]
+ ;
+
+ value interf ast = List.fold_right sig_item ast [];
+Index: camlp4/camlp4/mLast.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/camlp4/camlp4/mLast.mli,v
+retrieving revision 1.18
+diff -u -r1.18 mLast.mli
+--- camlp4/camlp4/mLast.mli 29 Jun 2005 04:11:26 -0000 1.18
++++ camlp4/camlp4/mLast.mli 5 Apr 2006 02:26:01 -0000
+@@ -180,7 +180,7 @@
+ | CgDcl of loc and list class_sig_item
+ | CgInh of loc and class_type
+ | CgMth of loc and string and bool and ctyp
+- | CgVal of loc and string and bool and ctyp
++ | CgVal of loc and string and bool and bool and ctyp
+ | CgVir of loc and string and bool and ctyp ]
+ and class_expr =
+ [ CeApp of loc and class_expr and expr
+@@ -196,7 +196,8 @@
+ | CrIni of loc and expr
+ | CrMth of loc and string and bool and expr and option ctyp
+ | CrVal of loc and string and bool and expr
+- | CrVir of loc and string and bool and ctyp ]
++ | CrVir of loc and string and bool and ctyp
++ | CrVvr of loc and string and bool and ctyp ]
+ ;
+
+ external loc_of_ctyp : ctyp -> loc = "%field0";
+Index: camlp4/camlp4/reloc.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/camlp4/camlp4/reloc.ml,v
+retrieving revision 1.18
+diff -u -r1.18 reloc.ml
+--- camlp4/camlp4/reloc.ml 29 Jun 2005 04:11:26 -0000 1.18
++++ camlp4/camlp4/reloc.ml 5 Apr 2006 02:26:01 -0000
+@@ -350,7 +350,7 @@
+ | CgDcl loc x1 -> let nloc = floc loc in CgDcl nloc (List.map (class_sig_item floc sh) x1)
+ | CgInh loc x1 -> let nloc = floc loc in CgInh nloc (class_type floc sh x1)
+ | CgMth loc x1 x2 x3 -> let nloc = floc loc in CgMth nloc x1 x2 (ctyp floc sh x3)
+- | CgVal loc x1 x2 x3 -> let nloc = floc loc in CgVal nloc x1 x2 (ctyp floc sh x3)
++ | CgVal loc x1 x2 x3 x4 -> let nloc = floc loc in CgVal nloc x1 x2 x3 (ctyp floc sh x4)
+ | CgVir loc x1 x2 x3 -> let nloc = floc loc in CgVir nloc x1 x2 (ctyp floc sh x3) ]
+ and class_expr floc sh =
+ self where rec self =
+@@ -377,5 +377,6 @@
+ | CrMth loc x1 x2 x3 x4 ->
+ let nloc = floc loc in CrMth nloc x1 x2 (expr floc sh x3) (option_map (ctyp floc sh) x4)
+ | CrVal loc x1 x2 x3 -> let nloc = floc loc in CrVal nloc x1 x2 (expr floc sh x3)
+- | CrVir loc x1 x2 x3 -> let nloc = floc loc in CrVir nloc x1 x2 (ctyp floc sh x3) ]
++ | CrVir loc x1 x2 x3 -> let nloc = floc loc in CrVir nloc x1 x2 (ctyp floc sh x3)
++ | CrVvr loc x1 x2 x3 -> let nloc = floc loc in CrVvr nloc x1 x2 (ctyp floc sh x3) ]
+ ;
+Index: camlp4/etc/pa_o.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/camlp4/etc/pa_o.ml,v
+retrieving revision 1.66
+diff -u -r1.66 pa_o.ml
+--- camlp4/etc/pa_o.ml 29 Jun 2005 04:11:26 -0000 1.66
++++ camlp4/etc/pa_o.ml 5 Apr 2006 02:26:01 -0000
+@@ -1037,8 +1037,14 @@
+ class_str_item:
+ [ [ "inherit"; ce = class_expr; pb = OPT [ "as"; i = LIDENT -> i ] ->
+ <:class_str_item< inherit $ce$ $opt:pb$ >>
+- | "val"; mf = OPT "mutable"; lab = label; e = cvalue_binding ->
+- <:class_str_item< value $opt:o2b mf$ $lab$ = $e$ >>
++ | "val"; "mutable"; lab = label; e = cvalue_binding ->
++ <:class_str_item< value mutable $lab$ = $e$ >>
++ | "val"; lab = label; e = cvalue_binding ->
++ <:class_str_item< value $lab$ = $e$ >>
++ | "val"; "mutable"; "virtual"; lab = label; ":"; t = ctyp ->
++ <:class_str_item< value virtual mutable $lab$ : $t$ >>
++ | "val"; "virtual"; mf = OPT "mutable"; lab = label; ":"; t = ctyp ->
++ <:class_str_item< value virtual $opt:o2b mf$ $lab$ : $t$ >>
+ | "method"; "private"; "virtual"; l = label; ":"; t = poly_type ->
+ <:class_str_item< method virtual private $l$ : $t$ >>
+ | "method"; "virtual"; "private"; l = label; ":"; t = poly_type ->
+@@ -1087,8 +1093,9 @@
+ ;
+ class_sig_item:
+ [ [ "inherit"; cs = class_signature -> <:class_sig_item< inherit $cs$ >>
+- | "val"; mf = OPT "mutable"; l = label; ":"; t = ctyp ->
+- <:class_sig_item< value $opt:o2b mf$ $l$ : $t$ >>
++ | "val"; mf = OPT "mutable"; vf = OPT "virtual";
++ l = label; ":"; t = ctyp ->
++ <:class_sig_item< value $opt:o2b mf$ $opt:o2b vf$ $l$ : $t$ >>
+ | "method"; "private"; "virtual"; l = label; ":"; t = poly_type ->
+ <:class_sig_item< method virtual private $l$ : $t$ >>
+ | "method"; "virtual"; "private"; l = label; ":"; t = poly_type ->
+Index: camlp4/etc/pr_o.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/camlp4/etc/pr_o.ml,v
+retrieving revision 1.51
+diff -u -r1.51 pr_o.ml
+--- camlp4/etc/pr_o.ml 5 Jan 2006 10:44:29 -0000 1.51
++++ camlp4/etc/pr_o.ml 5 Apr 2006 02:26:01 -0000
+@@ -1768,10 +1768,11 @@
+ [: `S LR "method"; private_flag pf; `label lab;
+ `S LR ":" :];
+ `ctyp t "" k :]
+- | MLast.CgVal _ lab mf t ->
++ | MLast.CgVal _ lab mf vf t ->
+ fun curr next dg k ->
+ [: `HVbox
+- [: `S LR "val"; mutable_flag mf; `label lab; `S LR ":" :];
++ [: `S LR "val"; mutable_flag mf; virtual_flag vf;
++ `label lab; `S LR ":" :];
+ `ctyp t "" k :]
+ | MLast.CgVir _ lab pf t ->
+ fun curr next dg k ->
+Index: camlp4/meta/pa_r.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/camlp4/meta/pa_r.ml,v
+retrieving revision 1.64
+diff -u -r1.64 pa_r.ml
+--- camlp4/meta/pa_r.ml 29 Jun 2005 04:11:26 -0000 1.64
++++ camlp4/meta/pa_r.ml 5 Apr 2006 02:26:01 -0000
+@@ -658,7 +658,9 @@
+ | "inherit"; ce = class_expr; pb = OPT as_lident ->
+ <:class_str_item< inherit $ce$ $opt:pb$ >>
+ | "value"; mf = OPT "mutable"; lab = label; e = cvalue_binding ->
+- <:class_str_item< value $opt:o2b mf$ $lab$ = $e$ >>
++ <:class_str_item< value $opt:o2b mf$ $lab$ = $e$ >>
++ | "value"; "virtual"; mf = OPT "mutable"; l = label; ":"; t = ctyp ->
++ <:class_str_item< value virtual $opt:o2b mf$ $l$ : $t$ >>
+ | "method"; "virtual"; pf = OPT "private"; l = label; ":"; t = ctyp ->
+ <:class_str_item< method virtual $opt:o2b pf$ $l$ : $t$ >>
+ | "method"; pf = OPT "private"; l = label; topt = OPT polyt;
+@@ -701,8 +703,9 @@
+ [ [ "declare"; st = LIST0 [ s = class_sig_item; ";" -> s ]; "end" ->
+ <:class_sig_item< declare $list:st$ end >>
+ | "inherit"; cs = class_type -> <:class_sig_item< inherit $cs$ >>
+- | "value"; mf = OPT "mutable"; l = label; ":"; t = ctyp ->
+- <:class_sig_item< value $opt:o2b mf$ $l$ : $t$ >>
++ | "value"; mf = OPT "mutable"; vf = OPT "virtual";
++ l = label; ":"; t = ctyp ->
++ <:class_sig_item< value $opt:o2b mf$ $opt:o2b vf$ $l$ : $t$ >>
+ | "method"; "virtual"; pf = OPT "private"; l = label; ":"; t = ctyp ->
+ <:class_sig_item< method virtual $opt:o2b pf$ $l$ : $t$ >>
+ | "method"; pf = OPT "private"; l = label; ":"; t = ctyp ->
+Index: camlp4/meta/q_MLast.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/camlp4/meta/q_MLast.ml,v
+retrieving revision 1.60
+diff -u -r1.60 q_MLast.ml
+--- camlp4/meta/q_MLast.ml 29 Jun 2005 04:11:26 -0000 1.60
++++ camlp4/meta/q_MLast.ml 5 Apr 2006 02:26:01 -0000
+@@ -947,6 +947,8 @@
+ Qast.Node "CrDcl" [Qast.Loc; st]
+ | "inherit"; ce = class_expr; pb = SOPT as_lident ->
+ Qast.Node "CrInh" [Qast.Loc; ce; pb]
++ | "value"; "virtual"; mf = SOPT "mutable"; l = label; ":"; t = ctyp ->
++ Qast.Node "CrVvr" [Qast.Loc; l; o2b mf; t]
+ | "value"; mf = SOPT "mutable"; lab = label; e = cvalue_binding ->
+ Qast.Node "CrVal" [Qast.Loc; lab; o2b mf; e]
+ | "method"; "virtual"; pf = SOPT "private"; l = label; ":"; t = ctyp ->
+@@ -992,8 +994,9 @@
+ [ [ "declare"; st = SLIST0 [ s = class_sig_item; ";" -> s ]; "end" ->
+ Qast.Node "CgDcl" [Qast.Loc; st]
+ | "inherit"; cs = class_type -> Qast.Node "CgInh" [Qast.Loc; cs]
+- | "value"; mf = SOPT "mutable"; l = label; ":"; t = ctyp ->
+- Qast.Node "CgVal" [Qast.Loc; l; o2b mf; t]
++ | "value"; mf = SOPT "mutable"; vf = SOPT "virtual";
++ l = label; ":"; t = ctyp ->
++ Qast.Node "CgVal" [Qast.Loc; l; o2b mf; o2b vf; t]
+ | "method"; "virtual"; pf = SOPT "private"; l = label; ":"; t = ctyp ->
+ Qast.Node "CgVir" [Qast.Loc; l; o2b pf; t]
+ | "method"; pf = SOPT "private"; l = label; ":"; t = ctyp ->
+Index: camlp4/ocaml_src/camlp4/ast2pt.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/camlp4/ocaml_src/camlp4/ast2pt.ml,v
+retrieving revision 1.36
+diff -u -r1.36 ast2pt.ml
+--- camlp4/ocaml_src/camlp4/ast2pt.ml 29 Jun 2005 04:11:26 -0000 1.36
++++ camlp4/ocaml_src/camlp4/ast2pt.ml 5 Apr 2006 02:26:01 -0000
+@@ -227,6 +227,7 @@
+ ;;
+ let mkmutable m = if m then Mutable else Immutable;;
+ let mkprivate m = if m then Private else Public;;
++let mkvirtual m = if m then Virtual else Concrete;;
+ let mktrecord (loc, n, m, t) =
+ n, mkmutable m, ctyp (mkpolytype t), mkloc loc
+ ;;
+@@ -878,8 +879,8 @@
+ | CgInh (loc, ct) -> Pctf_inher (class_type ct) :: l
+ | CgMth (loc, s, pf, t) ->
+ Pctf_meth (s, mkprivate pf, ctyp (mkpolytype t), mkloc loc) :: l
+- | CgVal (loc, s, b, t) ->
+- Pctf_val (s, mkmutable b, Some (ctyp t), mkloc loc) :: l
++ | CgVal (loc, s, b, v, t) ->
++ Pctf_val (s, mkmutable b, mkvirtual v, ctyp t, mkloc loc) :: l
+ | CgVir (loc, s, b, t) ->
+ Pctf_virt (s, mkprivate b, ctyp (mkpolytype t), mkloc loc) :: l
+ and class_expr =
+@@ -923,6 +924,8 @@
+ | CrVal (loc, s, b, e) -> Pcf_val (s, mkmutable b, expr e, mkloc loc) :: l
+ | CrVir (loc, s, b, t) ->
+ Pcf_virt (s, mkprivate b, ctyp (mkpolytype t), mkloc loc) :: l
++ | CrVvr (loc, s, b, t) ->
++ Pcf_valvirt (s, mkmutable b, ctyp t, mkloc loc) :: l
+ ;;
+
+ let interf ast = List.fold_right sig_item ast [];;
+Index: camlp4/ocaml_src/camlp4/mLast.mli
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/camlp4/ocaml_src/camlp4/mLast.mli,v
+retrieving revision 1.20
+diff -u -r1.20 mLast.mli
+--- camlp4/ocaml_src/camlp4/mLast.mli 29 Jun 2005 04:11:26 -0000 1.20
++++ camlp4/ocaml_src/camlp4/mLast.mli 5 Apr 2006 02:26:01 -0000
+@@ -180,7 +180,7 @@
+ | CgDcl of loc * class_sig_item list
+ | CgInh of loc * class_type
+ | CgMth of loc * string * bool * ctyp
+- | CgVal of loc * string * bool * ctyp
++ | CgVal of loc * string * bool * bool * ctyp
+ | CgVir of loc * string * bool * ctyp
+ and class_expr =
+ CeApp of loc * class_expr * expr
+@@ -197,6 +197,7 @@
+ | CrMth of loc * string * bool * expr * ctyp option
+ | CrVal of loc * string * bool * expr
+ | CrVir of loc * string * bool * ctyp
++ | CrVvr of loc * string * bool * ctyp
+ ;;
+
+ external loc_of_ctyp : ctyp -> loc = "%field0";;
+Index: camlp4/ocaml_src/camlp4/reloc.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/camlp4/ocaml_src/camlp4/reloc.ml,v
+retrieving revision 1.20
+diff -u -r1.20 reloc.ml
+--- camlp4/ocaml_src/camlp4/reloc.ml 29 Jun 2005 04:11:26 -0000 1.20
++++ camlp4/ocaml_src/camlp4/reloc.ml 5 Apr 2006 02:26:01 -0000
+@@ -430,8 +430,8 @@
+ let nloc = floc loc in CgInh (nloc, class_type floc sh x1)
+ | CgMth (loc, x1, x2, x3) ->
+ let nloc = floc loc in CgMth (nloc, x1, x2, ctyp floc sh x3)
+- | CgVal (loc, x1, x2, x3) ->
+- let nloc = floc loc in CgVal (nloc, x1, x2, ctyp floc sh x3)
++ | CgVal (loc, x1, x2, x3, x4) ->
++ let nloc = floc loc in CgVal (nloc, x1, x2, x3, ctyp floc sh x4)
+ | CgVir (loc, x1, x2, x3) ->
+ let nloc = floc loc in CgVir (nloc, x1, x2, ctyp floc sh x3)
+ in
+@@ -478,6 +478,8 @@
+ let nloc = floc loc in CrVal (nloc, x1, x2, expr floc sh x3)
+ | CrVir (loc, x1, x2, x3) ->
+ let nloc = floc loc in CrVir (nloc, x1, x2, ctyp floc sh x3)
++ | CrVvr (loc, x1, x2, x3) ->
++ let nloc = floc loc in CrVvr (nloc, x1, x2, ctyp floc sh x3)
+ in
+ self
+ ;;
+Index: camlp4/ocaml_src/meta/pa_r.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/camlp4/ocaml_src/meta/pa_r.ml,v
+retrieving revision 1.59
+diff -u -r1.59 pa_r.ml
+--- camlp4/ocaml_src/meta/pa_r.ml 29 Jun 2005 04:11:26 -0000 1.59
++++ camlp4/ocaml_src/meta/pa_r.ml 5 Apr 2006 02:26:01 -0000
+@@ -2161,6 +2161,15 @@
+ (fun (t : 'ctyp) _ (l : 'label) (pf : string option) _ _
+ (_loc : Lexing.position * Lexing.position) ->
+ (MLast.CrVir (_loc, l, o2b pf, t) : 'class_str_item));
++ [Gramext.Stoken ("", "value"); Gramext.Stoken ("", "virtual");
++ Gramext.Sopt (Gramext.Stoken ("", "mutable"));
++ Gramext.Snterm (Grammar.Entry.obj (label : 'label Grammar.Entry.e));
++ Gramext.Stoken ("", ":");
++ Gramext.Snterm (Grammar.Entry.obj (ctyp : 'ctyp Grammar.Entry.e))],
++ Gramext.action
++ (fun (t : 'ctyp) _ (l : 'label) (mf : string option) _ _
++ (_loc : Lexing.position * Lexing.position) ->
++ (MLast.CrVvr (_loc, l, o2b mf, t) : 'class_str_item));
+ [Gramext.Stoken ("", "value");
+ Gramext.Sopt (Gramext.Stoken ("", "mutable"));
+ Gramext.Snterm (Grammar.Entry.obj (label : 'label Grammar.Entry.e));
+@@ -2338,13 +2347,15 @@
+ (MLast.CgVir (_loc, l, o2b pf, t) : 'class_sig_item));
+ [Gramext.Stoken ("", "value");
+ Gramext.Sopt (Gramext.Stoken ("", "mutable"));
++ Gramext.Sopt (Gramext.Stoken ("", "virtual"));
+ Gramext.Snterm (Grammar.Entry.obj (label : 'label Grammar.Entry.e));
+ Gramext.Stoken ("", ":");
+ Gramext.Snterm (Grammar.Entry.obj (ctyp : 'ctyp Grammar.Entry.e))],
+ Gramext.action
+- (fun (t : 'ctyp) _ (l : 'label) (mf : string option) _
++ (fun (t : 'ctyp) _ (l : 'label) (vf : string option)
++ (mf : string option) _
+ (_loc : Lexing.position * Lexing.position) ->
+- (MLast.CgVal (_loc, l, o2b mf, t) : 'class_sig_item));
++ (MLast.CgVal (_loc, l, o2b mf, o2b vf, t) : 'class_sig_item));
+ [Gramext.Stoken ("", "inherit");
+ Gramext.Snterm
+ (Grammar.Entry.obj (class_type : 'class_type Grammar.Entry.e))],
+Index: camlp4/ocaml_src/meta/q_MLast.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/camlp4/ocaml_src/meta/q_MLast.ml,v
+retrieving revision 1.65
+diff -u -r1.65 q_MLast.ml
+--- camlp4/ocaml_src/meta/q_MLast.ml 12 Jan 2006 08:54:21 -0000 1.65
++++ camlp4/ocaml_src/meta/q_MLast.ml 5 Apr 2006 02:26:01 -0000
+@@ -3152,9 +3152,9 @@
+ Gramext.action
+ (fun (x : string)
+ (_loc : Lexing.position * Lexing.position) ->
+- (Qast.Str x : 'e__17))])],
++ (Qast.Str x : 'e__18))])],
+ Gramext.action
+- (fun (a : 'e__17 option)
++ (fun (a : 'e__18 option)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.Option a : 'a_opt));
+ [Gramext.Snterm
+@@ -3191,9 +3191,9 @@
+ Gramext.action
+ (fun (x : string)
+ (_loc : Lexing.position * Lexing.position) ->
+- (Qast.Str x : 'e__16))])],
++ (Qast.Str x : 'e__17))])],
+ Gramext.action
+- (fun (a : 'e__16 option)
++ (fun (a : 'e__17 option)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.Option a : 'a_opt));
+ [Gramext.Snterm
+@@ -3216,9 +3216,9 @@
+ Gramext.action
+ (fun (x : string)
+ (_loc : Lexing.position * Lexing.position) ->
+- (Qast.Str x : 'e__15))])],
++ (Qast.Str x : 'e__16))])],
+ Gramext.action
+- (fun (a : 'e__15 option)
++ (fun (a : 'e__16 option)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.Option a : 'a_opt));
+ [Gramext.Snterm
+@@ -3235,6 +3235,31 @@
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.Node ("CrVal", [Qast.Loc; lab; o2b mf; e]) :
+ 'class_str_item));
++ [Gramext.Stoken ("", "value"); Gramext.Stoken ("", "virtual");
++ Gramext.srules
++ [[Gramext.Sopt
++ (Gramext.srules
++ [[Gramext.Stoken ("", "mutable")],
++ Gramext.action
++ (fun (x : string)
++ (_loc : Lexing.position * Lexing.position) ->
++ (Qast.Str x : 'e__15))])],
++ Gramext.action
++ (fun (a : 'e__15 option)
++ (_loc : Lexing.position * Lexing.position) ->
++ (Qast.Option a : 'a_opt));
++ [Gramext.Snterm
++ (Grammar.Entry.obj (a_opt : 'a_opt Grammar.Entry.e))],
++ Gramext.action
++ (fun (a : 'a_opt) (_loc : Lexing.position * Lexing.position) ->
++ (a : 'a_opt))];
++ Gramext.Snterm (Grammar.Entry.obj (label : 'label Grammar.Entry.e));
++ Gramext.Stoken ("", ":");
++ Gramext.Snterm (Grammar.Entry.obj (ctyp : 'ctyp Grammar.Entry.e))],
++ Gramext.action
++ (fun (t : 'ctyp) _ (l : 'label) (mf : 'a_opt) _ _
++ (_loc : Lexing.position * Lexing.position) ->
++ (Qast.Node ("CrVvr", [Qast.Loc; l; o2b mf; t]) : 'class_str_item));
+ [Gramext.Stoken ("", "inherit");
+ Gramext.Snterm
+ (Grammar.Entry.obj (class_expr : 'class_expr Grammar.Entry.e));
+@@ -3366,9 +3391,9 @@
+ Gramext.action
+ (fun _ (csf : 'class_sig_item)
+ (_loc : Lexing.position * Lexing.position) ->
+- (csf : 'e__18))])],
++ (csf : 'e__19))])],
+ Gramext.action
+- (fun (a : 'e__18 list)
++ (fun (a : 'e__19 list)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.List a : 'a_list));
+ [Gramext.Snterm
+@@ -3446,9 +3471,9 @@
+ Gramext.action
+ (fun (x : string)
+ (_loc : Lexing.position * Lexing.position) ->
+- (Qast.Str x : 'e__22))])],
++ (Qast.Str x : 'e__24))])],
+ Gramext.action
+- (fun (a : 'e__22 option)
++ (fun (a : 'e__24 option)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.Option a : 'a_opt));
+ [Gramext.Snterm
+@@ -3471,9 +3496,9 @@
+ Gramext.action
+ (fun (x : string)
+ (_loc : Lexing.position * Lexing.position) ->
+- (Qast.Str x : 'e__21))])],
++ (Qast.Str x : 'e__23))])],
+ Gramext.action
+- (fun (a : 'e__21 option)
++ (fun (a : 'e__23 option)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.Option a : 'a_opt));
+ [Gramext.Snterm
+@@ -3496,9 +3521,26 @@
+ Gramext.action
+ (fun (x : string)
+ (_loc : Lexing.position * Lexing.position) ->
+- (Qast.Str x : 'e__20))])],
++ (Qast.Str x : 'e__21))])],
+ Gramext.action
+- (fun (a : 'e__20 option)
++ (fun (a : 'e__21 option)
++ (_loc : Lexing.position * Lexing.position) ->
++ (Qast.Option a : 'a_opt));
++ [Gramext.Snterm
++ (Grammar.Entry.obj (a_opt : 'a_opt Grammar.Entry.e))],
++ Gramext.action
++ (fun (a : 'a_opt) (_loc : Lexing.position * Lexing.position) ->
++ (a : 'a_opt))];
++ Gramext.srules
++ [[Gramext.Sopt
++ (Gramext.srules
++ [[Gramext.Stoken ("", "virtual")],
++ Gramext.action
++ (fun (x : string)
++ (_loc : Lexing.position * Lexing.position) ->
++ (Qast.Str x : 'e__22))])],
++ Gramext.action
++ (fun (a : 'e__22 option)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.Option a : 'a_opt));
+ [Gramext.Snterm
+@@ -3510,9 +3552,10 @@
+ Gramext.Stoken ("", ":");
+ Gramext.Snterm (Grammar.Entry.obj (ctyp : 'ctyp Grammar.Entry.e))],
+ Gramext.action
+- (fun (t : 'ctyp) _ (l : 'label) (mf : 'a_opt) _
++ (fun (t : 'ctyp) _ (l : 'label) (vf : 'a_opt) (mf : 'a_opt) _
+ (_loc : Lexing.position * Lexing.position) ->
+- (Qast.Node ("CgVal", [Qast.Loc; l; o2b mf; t]) : 'class_sig_item));
++ (Qast.Node ("CgVal", [Qast.Loc; l; o2b mf; o2b vf; t]) :
++ 'class_sig_item));
+ [Gramext.Stoken ("", "inherit");
+ Gramext.Snterm
+ (Grammar.Entry.obj (class_type : 'class_type Grammar.Entry.e))],
+@@ -3531,9 +3574,9 @@
+ Gramext.action
+ (fun _ (s : 'class_sig_item)
+ (_loc : Lexing.position * Lexing.position) ->
+- (s : 'e__19))])],
++ (s : 'e__20))])],
+ Gramext.action
+- (fun (a : 'e__19 list)
++ (fun (a : 'e__20 list)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.List a : 'a_list));
+ [Gramext.Snterm
+@@ -3556,9 +3599,9 @@
+ Gramext.action
+ (fun (x : string)
+ (_loc : Lexing.position * Lexing.position) ->
+- (Qast.Str x : 'e__23))])],
++ (Qast.Str x : 'e__25))])],
+ Gramext.action
+- (fun (a : 'e__23 option)
++ (fun (a : 'e__25 option)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.Option a : 'a_opt));
+ [Gramext.Snterm
+@@ -3593,9 +3636,9 @@
+ Gramext.action
+ (fun (x : string)
+ (_loc : Lexing.position * Lexing.position) ->
+- (Qast.Str x : 'e__24))])],
++ (Qast.Str x : 'e__26))])],
+ Gramext.action
+- (fun (a : 'e__24 option)
++ (fun (a : 'e__26 option)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.Option a : 'a_opt));
+ [Gramext.Snterm
+@@ -3713,9 +3756,9 @@
+ Gramext.action
+ (fun (x : string)
+ (_loc : Lexing.position * Lexing.position) ->
+- (Qast.Str x : 'e__25))])],
++ (Qast.Str x : 'e__27))])],
+ Gramext.action
+- (fun (a : 'e__25 option)
++ (fun (a : 'e__27 option)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.Option a : 'a_opt));
+ [Gramext.Snterm
+@@ -3922,9 +3965,9 @@
+ Gramext.action
+ (fun (x : string)
+ (_loc : Lexing.position * Lexing.position) ->
+- (Qast.Str x : 'e__26))])],
++ (Qast.Str x : 'e__28))])],
+ Gramext.action
+- (fun (a : 'e__26 option)
++ (fun (a : 'e__28 option)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.Option a : 'a_opt));
+ [Gramext.Snterm
+@@ -4390,9 +4433,9 @@
+ Gramext.action
+ (fun _ (e : 'expr)
+ (_loc : Lexing.position * Lexing.position) ->
+- (e : 'e__29))])],
++ (e : 'e__31))])],
+ Gramext.action
+- (fun (a : 'e__29 list)
++ (fun (a : 'e__31 list)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.List a : 'a_list));
+ [Gramext.Snterm
+@@ -4425,9 +4468,9 @@
+ Gramext.action
+ (fun _ (e : 'expr)
+ (_loc : Lexing.position * Lexing.position) ->
+- (e : 'e__28))])],
++ (e : 'e__30))])],
+ Gramext.action
+- (fun (a : 'e__28 list)
++ (fun (a : 'e__30 list)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.List a : 'a_list));
+ [Gramext.Snterm
+@@ -4454,9 +4497,9 @@
+ Gramext.action
+ (fun _ (e : 'expr)
+ (_loc : Lexing.position * Lexing.position) ->
+- (e : 'e__27))])],
++ (e : 'e__29))])],
+ Gramext.action
+- (fun (a : 'e__27 list)
++ (fun (a : 'e__29 list)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.List a : 'a_list));
+ [Gramext.Snterm
+@@ -4547,9 +4590,9 @@
+ Gramext.action
+ (fun _ (cf : 'class_str_item)
+ (_loc : Lexing.position * Lexing.position) ->
+- (cf : 'e__30))])],
++ (cf : 'e__32))])],
+ Gramext.action
+- (fun (a : 'e__30 list)
++ (fun (a : 'e__32 list)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.List a : 'a_list));
+ [Gramext.Snterm
+@@ -4592,9 +4635,9 @@
+ Gramext.action
+ (fun _ (csf : 'class_sig_item)
+ (_loc : Lexing.position * Lexing.position) ->
+- (csf : 'e__32))])],
++ (csf : 'e__34))])],
+ Gramext.action
+- (fun (a : 'e__32 list)
++ (fun (a : 'e__34 list)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.List a : 'a_list));
+ [Gramext.Snterm
+@@ -4623,9 +4666,9 @@
+ Gramext.action
+ (fun _ (csf : 'class_sig_item)
+ (_loc : Lexing.position * Lexing.position) ->
+- (csf : 'e__31))])],
++ (csf : 'e__33))])],
+ Gramext.action
+- (fun (a : 'e__31 list)
++ (fun (a : 'e__33 list)
+ (_loc : Lexing.position * Lexing.position) ->
+ (Qast.List a : 'a_list));
+ [Gramext.Snterm
+Index: camlp4/top/rprint.ml
+===================================================================
+RCS file: /net/yquem/devel/caml/repository/csl/camlp4/top/rprint.ml,v
+retrieving revision 1.18
+diff -u -r1.18 rprint.ml
+--- camlp4/top/rprint.ml 29 Jun 2005 04:11:26 -0000 1.18
++++ camlp4/top/rprint.ml 5 Apr 2006 02:26:01 -0000
+@@ -288,8 +288,9 @@
+ fprintf ppf "@[<2>method %s%s%s :@ %a;@]"
+ (if priv then "private " else "") (if virt then "virtual " else "")
+ name Toploop.print_out_type.val ty
+- | Ocsg_value name mut ty ->
+- fprintf ppf "@[<2>value %s%s :@ %a;@]" (if mut then "mutable " else "")
++ | Ocsg_value name mut virt ty ->
++ fprintf ppf "@[<2>value %s%s%s :@ %a;@]"
++ (if mut then "mutable " else "") (if virt then "virtual " else "")
+ name Toploop.print_out_type.val ty ]
+ ;
+
--- /dev/null
+(* cvs update -r varunion parsing typing bytecomp toplevel *)
+
+type t = private [> ];;
+type u = private [> ] ~ [t];;
+type v = [t | u];;
+let f x = (x : t :> v);;
+
+(* bad *)
+module Mix(X: sig type t = private [> ] end)
+ (Y: sig type t = private [> ] end) =
+ struct type t = [X.t | Y.t] end;;
+
+(* bad *)
+module Mix(X: sig type t = private [> `A of int ] end)
+ (Y: sig type t = private [> `A of bool] ~ [X.t] end) =
+ struct type t = [X.t | Y.t] end;;
+
+(* ok *)
+module Mix(X: sig type t = private [> `A of int ] end)
+ (Y: sig type t = private [> `A of int] ~ [X.t] end) =
+ struct type t = [X.t | Y.t] end;;
+
+(* bad *)
+module Mix(X: sig type t = private [> `A of int ] end)
+ (Y: sig type t = private [> `B of bool] ~ [X.t] end) =
+ struct type t = [X.t | Y.t] end;;
+
+type 'a t = private [> `L of 'a] ~ [`L];;
+
+(* ok *)
+module Mix(X: sig type t = private [> `A of int ] ~ [`B] end)
+ (Y: sig type t = private [> `B of bool] ~ [X.t] end) =
+ struct type t = [X.t | Y.t] let is_t = function #t -> true | _ -> false end;;
+
+module Mix(X: sig type t = private [> `A of int ] ~ [`B] end)
+ (Y: sig type t = private [> `B of bool] ~ [X.t] end) =
+ struct
+ type t = [X.t | Y.t]
+ let which = function #X.t -> `X | #Y.t -> `Y
+ end;;
+
+module Mix(I: sig type t = private [> ] ~ [`A;`B] end)
+ (X: sig type t = private [> I.t | `A of int ] ~ [`B] end)
+ (Y: sig type t = private [> I.t | `B of bool] ~ [X.t] end) =
+ struct
+ type t = [X.t | Y.t]
+ let which = function #X.t -> `X | #Y.t -> `Y
+ end;;
+
+(* ok *)
+module M =
+ Mix(struct type t = [`C of char] end)
+ (struct type t = [`A of int | `C of char] end)
+ (struct type t = [`B of bool | `C of char] end);;
+
+(* bad *)
+module M =
+ Mix(struct type t = [`B of bool] end)
+ (struct type t = [`A of int | `B of bool] end)
+ (struct type t = [`B of bool | `C of char] end);;
+
+(* ok *)
+module M1 = struct type t = [`A of int | `C of char] end
+module M2 = struct type t = [`B of bool | `C of char] end
+module I = struct type t = [`C of char] end
+module M = Mix(I)(M1)(M2) ;;
+
+let c = (`C 'c' : M.t) ;;
+
+module M(X : sig type t = private [> `A] end) =
+ struct let f (#X.t as x) = x end;;
+
+(* code generation *)
+type t = private [> `A ] ~ [`B];;
+match `B with #t -> 1 | `B -> 2;;
+
+module M : sig type t = private [> `A of int | `B] ~ [`C] end =
+ struct type t = [`A of int | `B | `D of bool] end;;
+let f = function (`C | #M.t) -> 1+1 ;;
+let f = function (`A _ | `B #M.t) -> 1+1 ;;
+
+(* expression *)
+module Mix(X:sig type t = private [> ] val show: t -> string end)
+ (Y:sig type t = private [> ] ~ [X.t] val show: t -> string end) =
+ struct
+ type t = [X.t | Y.t]
+ let show : t -> string = function
+ #X.t as x -> X.show x
+ | #Y.t as y -> Y.show y
+ end;;
+
+module EStr = struct
+ type t = [`Str of string]
+ let show (`Str s) = s
+end
+module EInt = struct
+ type t = [`Int of int]
+ let show (`Int i) = string_of_int i
+end
+module M = Mix(EStr)(EInt);;
+
+module type T = sig type t = private [> ] val show: t -> string end
+module Mix(X:T)(Y:T with type t = private [> ] ~ [X.t]) :
+ T with type t = [X.t | Y.t] =
+ struct
+ type t = [X.t | Y.t]
+ let show = function
+ #X.t as x -> X.show x
+ | #Y.t as y -> Y.show y
+ end;;
+module M = Mix(EStr)(EInt);;
+
+(* deep *)
+module M : sig type t = private [> `A] end = struct type t = [`A] end
+module M' : sig type t = private [> ] end = struct type t = [M.t | `A] end;;
+
+(* bad *)
+type t = private [> ]
+type u = private [> `A of int] ~ [t] ;;
+
+(* ok *)
+type t = private [> `A of int]
+type u = private [> `A of int] ~ [t] ;;
+
+module F(X: sig
+ type t = private [> ] ~ [`A;`B;`C;`D]
+ type u = private [> `A|`B|`C] ~ [t; `D]
+end) : sig type v = private [< X.t | X.u | `D] end = struct
+ open X
+ let f = function #u -> 1 | #t -> 2 | `D -> 3
+ let g = function #u|#t|`D -> 2
+ type v = [t|u|`D]
+end
+
+(* ok *)
+module M = struct type t = private [> `A] end;;
+module M' : sig type t = private [> ] ~ [`A] end = M;;
+
+(* ok *)
+module type T = sig type t = private [> ] ~ [`A] end;;
+module type T' = T with type t = private [> `A];;
+
+(* ok *)
+type t = private [> ] ~ [`A]
+let f = function `A x -> x | #t -> 0
+type t' = private [< `A of int | t];;
+
+(* should be ok *)
+module F(X:sig end) :
+ sig type t = private [> ] type u = private [> ] ~ [t] end =
+ struct type t = [ `A] type u = [`B] end
+module M = F(String)
+let f = function #M.t -> 1 | #M.u -> 2
+let f = function #M.t -> 1 | _ -> 2
+type t = [M.t | M.u]
+let f = function #t -> 1 | _ -> 2;;
+module G(X : sig type t = private [> ] type u = private [> ] ~ [t] end) =
+ struct let f = function #X.t -> 1 | _ -> 2 end;;
+module M1 = G(struct module N = F(String) type t = N.t type u = N.u end) ;;
+module M1 = G(struct type t = M.t type u = M.u end) ;;
+(* bad *)
+let f = function #F(String).t -> 1 | _ -> 2;;
+type t = [F(String).t | M.u]
+let f = function #t -> 1 | _ -> 2;;
+module N : sig type t = private [> ] end =
+ struct type t = [F(String).t | M.u] end;;
+
+(* compatibility improvement *)
+type a = [`A of int | `B]
+type b = [`A of bool | `B]
+type c = private [> ] ~ [a;b]
+let f = function #c -> 1 | `A x -> truncate x
+type d = private [> ] ~ [a]
+let g = function #d -> 1 | `A x -> truncate x;;
+
+
+(* Expression Problem: functorial form *)
+
+type num = [ `Num of int ]
+
+module type Exp = sig
+ type t = private [> num]
+ val eval : t -> t
+ val show : t -> string
+end
+
+module Num(X : Exp) = struct
+ type t = num
+ let eval (`Num _ as x) : X.t = x
+ let show (`Num n) = string_of_int n
+end
+
+type 'a add = [ `Add of 'a * 'a ]
+
+module Add(X : Exp with type t = private [> num | 'a add] as 'a) = struct
+ type t = X.t add
+ let show (`Add(e1, e2) : t) = "("^ X.show e1 ^"+"^ X.show e2 ^")"
+ let eval (`Add(e1, e2) : t) =
+ let e1 = X.eval e1 and e2 = X.eval e2 in
+ match e1, e2 with
+ `Num n1, `Num n2 -> `Num (n1+n2)
+ | `Num 0, e | e, `Num 0 -> e
+ | e12 -> `Add e12
+end
+
+type 'a mul = [`Mul of 'a * 'a]
+
+module Mul(X : Exp with type t = private [> num | 'a mul] as 'a) = struct
+ type t = X.t mul
+ let show (`Mul(e1, e2) : t) = "("^ X.show e1 ^"*"^ X.show e2 ^")"
+ let eval (`Mul(e1, e2) : t) =
+ let e1 = X.eval e1 and e2 = X.eval e2 in
+ match e1, e2 with
+ `Num n1, `Num n2 -> `Num (n1*n2)
+ | `Num 0, e | e, `Num 0 -> `Num 0
+ | `Num 1, e | e, `Num 1 -> e
+ | e12 -> `Mul e12
+end
+
+module Ext(X : sig type t = private [> ] end)(Y : sig type t end) = struct
+ module type S =
+ sig
+ type t = private [> ] ~ [ X.t ]
+ val eval : t -> Y.t
+ val show : t -> string
+ end
+end
+
+module Dummy = struct type t = [`Dummy] end
+
+module Mix(E : Exp)(E1 : Ext(Dummy)(E).S)(E2 : Ext(E1)(E).S) =
+ struct
+ type t = [E1.t | E2.t]
+ let eval = function
+ #E1.t as x -> E1.eval x
+ | #E2.t as x -> E2.eval x
+ let show = function
+ #E1.t as x -> E1.show x
+ | #E2.t as x -> E2.show x
+ end
+
+module rec EAdd : (Exp with type t = [num | EAdd.t add]) =
+ Mix(EAdd)(Num(EAdd))(Add(EAdd))
+
+(* A bit heavy: one must pass E to everybody *)
+module rec E : Exp with type t = [num | E.t add | E.t mul] =
+ Mix(E)(Mix(E)(Num(E))(Add(E)))(Mul(E))
+
+let e = E.eval (`Add(`Mul(`Num 2,`Num 3),`Num 1))
+
+(* Alternatives *)
+(* Direct approach, no need of Mix *)
+module rec E : (Exp with type t = [num | E.t add | E.t mul]) =
+ struct
+ module E1 = Num(E)
+ module E2 = Add(E)
+ module E3 = Mul(E)
+ type t = E.t
+ let show = function
+ | #num as x -> E1.show x
+ | #add as x -> E2.show x
+ | #mul as x -> E3.show x
+ let eval = function
+ | #num as x -> E1.eval x
+ | #add as x -> E2.eval x
+ | #mul as x -> E3.eval x
+ end
+
+(* Do functor applications in Mix *)
+module type T = sig type t = private [> ] end
+module type Tnum = sig type t = private [> num] end
+
+module Ext(E : Tnum) = struct
+ module type S = functor (Y : Exp with type t = E.t) ->
+ sig
+ type t = private [> num]
+ val eval : t -> Y.t
+ val show : t -> string
+ end
+end
+
+module Ext'(E : Tnum)(X : T) = struct
+ module type S = functor (Y : Exp with type t = E.t) ->
+ sig
+ type t = private [> ] ~ [ X.t ]
+ val eval : t -> Y.t
+ val show : t -> string
+ end
+end
+
+module Mix(E : Exp)(F1 : Ext(E).S)(F2 : Ext'(E)(F1(E)).S) =
+ struct
+ module E1 = F1(E)
+ module E2 = F2(E)
+ type t = [E1.t | E2.t]
+ let eval = function
+ #E1.t as x -> E1.eval x
+ | #E2.t as x -> E2.eval x
+ let show = function
+ #E1.t as x -> E1.show x
+ | #E2.t as x -> E2.show x
+ end
+
+module Join(E : Exp)(F1 : Ext(E).S)(F2 : Ext'(E)(F1(E)).S)
+ (E' : Exp with type t = E.t) =
+ Mix(E)(F1)(F2)
+
+module rec EAdd : (Exp with type t = [num | EAdd.t add]) =
+ Mix(EAdd)(Num)(Add)
+
+module rec EMul : (Exp with type t = [num | EMul.t mul]) =
+ Mix(EMul)(Num)(Mul)
+
+module rec E : (Exp with type t = [num | E.t add | E.t mul]) =
+ Mix(E)(Join(E)(Num)(Add))(Mul)
+
+(* Linear extension by the end: not so nice *)
+module LExt(X : T) = struct
+ module type S =
+ sig
+ type t
+ val eval : t -> X.t
+ val show : t -> string
+ end
+end
+module LNum(E: Exp)(X : LExt(E).S with type t = private [> ] ~ [num]) =
+ struct
+ type t = [num | X.t]
+ let show = function
+ `Num n -> string_of_int n
+ | #X.t as x -> X.show x
+ let eval = function
+ #num as x -> x
+ | #X.t as x -> X.eval x
+ end
+module LAdd(E : Exp with type t = private [> num | 'a add] as 'a)
+ (X : LExt(E).S with type t = private [> ] ~ [add]) =
+ struct
+ type t = [E.t add | X.t]
+ let show = function
+ `Add(e1,e2) -> "("^ E.show e1 ^"+"^ E.show e2 ^")"
+ | #X.t as x -> X.show x
+ let eval = function
+ `Add(e1,e2) ->
+ let e1 = E.eval e1 and e2 = E.eval e2 in
+ begin match e1, e2 with
+ `Num n1, `Num n2 -> `Num (n1+n2)
+ | `Num 0, e | e, `Num 0 -> e
+ | e12 -> `Add e12
+ end
+ | #X.t as x -> X.eval x
+ end
+module LEnd = struct
+ type t = [`Dummy]
+ let show `Dummy = ""
+ let eval `Dummy = `Dummy
+end
+module rec L : Exp with type t = [num | L.t add | `Dummy] =
+ LAdd(L)(LNum(L)(LEnd))
+
+(* Back to first form, but add map *)
+
+module Num(X : Exp) = struct
+ type t = num
+ let map f x = x
+ let eval1 (`Num _ as x) : X.t = x
+ let show (`Num n) = string_of_int n
+end
+
+module Add(X : Exp with type t = private [> num | 'a add] as 'a) = struct
+ type t = X.t add
+ let show (`Add(e1, e2) : t) = "("^ X.show e1 ^"+"^ X.show e2 ^")"
+ let map f (`Add(e1, e2) : t) = `Add(f e1, f e2)
+ let eval1 (`Add(e1, e2) as e : t) =
+ match e1, e2 with
+ `Num n1, `Num n2 -> `Num (n1+n2)
+ | `Num 0, e | e, `Num 0 -> e
+ | _ -> e
+end
+
+module Mul(X : Exp with type t = private [> num | 'a mul] as 'a) = struct
+ type t = X.t mul
+ let show (`Mul(e1, e2) : t) = "("^ X.show e1 ^"*"^ X.show e2 ^")"
+ let map f (`Mul(e1, e2) : t) = `Mul(f e1, f e2)
+ let eval1 (`Mul(e1, e2) as e : t) =
+ match e1, e2 with
+ `Num n1, `Num n2 -> `Num (n1*n2)
+ | `Num 0, e | e, `Num 0 -> `Num 0
+ | `Num 1, e | e, `Num 1 -> e
+ | _ -> e
+end
+
+module Ext(X : sig type t = private [> ] end)(Y : sig type t end) = struct
+ module type S =
+ sig
+ type t = private [> ] ~ [ X.t ]
+ val map : (Y.t -> Y.t) -> t -> t
+ val eval1 : t -> Y.t
+ val show : t -> string
+ end
+end
+
+module Mix(E : Exp)(E1 : Ext(Dummy)(E).S)(E2 : Ext(E1)(E).S) =
+ struct
+ type t = [E1.t | E2.t]
+ let map f = function
+ #E1.t as x -> (E1.map f x : E1.t :> t)
+ | #E2.t as x -> (E2.map f x : E2.t :> t)
+ let eval1 = function
+ #E1.t as x -> E1.eval1 x
+ | #E2.t as x -> E2.eval1 x
+ let show = function
+ #E1.t as x -> E1.show x
+ | #E2.t as x -> E2.show x
+ end
+
+module type ET = sig
+ type t
+ val map : (t -> t) -> t -> t
+ val eval1 : t -> t
+ val show : t -> string
+end
+
+module Fin(E : ET) = struct
+ include E
+ let rec eval e = eval1 (map eval e)
+end
+
+module rec EAdd : (Exp with type t = [num | EAdd.t add]) =
+ Fin(Mix(EAdd)(Num(EAdd))(Add(EAdd)))
+
+module rec E : Exp with type t = [num | E.t add | E.t mul] =
+ Fin(Mix(E)(Mix(E)(Num(E))(Add(E)))(Mul(E)))
+
+let e = E.eval (`Add(`Mul(`Num 2,`Num 3),`Num 1))
(* *)
(***********************************************************************)
-(* $Id: unused_var.ml 10250 2010-04-08 03:58:41Z garrigue $ *)
+(* $Id: unused_var.ml 11110 2011-07-04 21:15:01Z doligez $ *)
open Parsetree
| Pstr_open _ -> ()
| Pstr_class cdl -> List.iter (class_declaration ppf tbl) cdl;
| Pstr_class_type _ -> ()
- | Pstr_include _ -> ()
+ | Pstr_include me -> module_expr ppf tbl me;
and expression ppf tbl e =
match e.pexp_desc with
projects / ocaml.git / commitdiff