diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/byterun/sys.c seminalOcaml/byterun/sys.c
*** ocaml-3.08.4/byterun/sys.c	2004-05-18 01:50:22.000000000 -0700
--- seminalOcaml/byterun/sys.c	2009-01-19 09:36:42.121334405 -0800
***************
*** 245,250 ****
--- 245,260 ----
  
  CAMLprim value caml_sys_time(value unit)
  {
+   /* ADDED BSL 12/05/2005 to support higher resolution clocks */
+ #ifdef HAS_GETTIMEOFDAY
+   struct timeval tp;
+   if (gettimeofday(&tp, NULL) == -1) {
+     return caml_copy_double((double)clock() / CLOCKS_PER_SEC);
+   }
+   return caml_copy_double((double) tp.tv_sec + (double) tp.tv_usec / 1e6);
+ #endif
+   /* END ADDED BSL */
+ 
  #ifdef HAS_TIMES
  #ifndef CLK_TCK
  #ifdef HZ
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/camlp4/config/Makefile seminalOcaml/camlp4/config/Makefile
*** ocaml-3.08.4/camlp4/config/Makefile	1969-12-31 16:00:00.000000000 -0800
--- seminalOcaml/camlp4/config/Makefile	2009-01-19 09:36:58.121036308 -0800
***************
*** 0 ****
--- 1,60 ----
+ # $Id: Makefile.tpl,v 1.1.1.1 2005/12/09 03:02:40 blerner Exp $
+ 
+ # Change the value of PROFILING to prof for systematically building
+ # and installing profiled versions of Camlp4 libraries. Then, execute
+ # `make opt.opt', then `make install' in the OCaml toplevel directory
+ # (or in the camlp4 subdirectory).
+ 
+ # Default value is noprof
+ 
+ #PROFILING=prof
+ PROFILING=noprof
+ 
+ ###########################################################################
+ 
+ CAMLP4_COMM=OTOP=$(OTOP) OPT=$(OPT) EXE=$(EXE) ../tools/camlp4_comm.sh
+ OCAMLC=@OTOP=$(OTOP) OPT=$(OPT) EXE=$(EXE) ../tools/ocamlc.sh
+ OCAMLOPT=@OTOP=$(OTOP) OPT=$(OPT) EXE=$(EXE) ../tools/ocamlopt.sh
+ OCAMLCFLAGS=
+ MKDIR=mkdir -p
+ 
+ TEST_DIRECTORY=test `basename "$<"` = "$<" || { echo "You are not in the right directory"; exit 1; }
+ 
+ .SUFFIXES: .cmx .cmo .cmi .ml .mli .p.cmx
+ 
+ .mli.cmi:
+ 	@$(TEST_DIRECTORY)
+ 	@$(CAMLP4_COMM) $< -o $*.ppi
+ 	$(OCAMLC) $(OCAMLCFLAGS) -c -intf $*.ppi
+ 	rm -f $*.ppi	
+ 
+ .ml.cmo:
+ 	@$(TEST_DIRECTORY)
+ 	@$(CAMLP4_COMM) $< -o $*.ppo
+ 	$(OCAMLC) $(OCAMLCFLAGS) -c -impl $*.ppo
+ 	rm -f $*.ppo
+ 
+ .ml.cmx:
+ 	@$(TEST_DIRECTORY)
+ 	@$(CAMLP4_COMM) $< -o $*.ppo
+ 	$(OCAMLOPT) $(OCAMLCFLAGS) -c -impl $*.ppo
+ 	rm -f $*.ppo
+ 
+ .ml.p.cmx:
+ 	@$(TEST_DIRECTORY)
+ 	@$(CAMLP4_COMM) $< -o $*.ppo
+ 	$(OCAMLOPT) $(OCAMLCFLAGS) -c -p -o $*.p.cmx -impl $*.ppo
+ 	rm -f $*.ppo
+ 
+ EXE=
+ O=o
+ A=a
+ OPT=
+ OTOP=../..
+ RANLIB=ranlib
+ RANLIBCMD=ranlib
+ OLIBDIR=$(OTOP)/boot
+ PREFIX=/projects/swlab8/blerner/projects/seminal/seminalOcaml
+ BINDIR=/projects/swlab8/blerner/projects/seminal/seminalOcaml/bin
+ LIBDIR=/projects/swlab8/blerner/projects/seminal/seminalOcaml/lib/ocaml
+ MANDIR=/projects/swlab8/blerner/projects/seminal/seminalOcaml/man
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/camlp4/config/Makefile.cnf seminalOcaml/camlp4/config/Makefile.cnf
*** ocaml-3.08.4/camlp4/config/Makefile.cnf	1969-12-31 16:00:00.000000000 -0800
--- seminalOcaml/camlp4/config/Makefile.cnf	2009-01-19 09:36:58.081037182 -0800
***************
*** 0 ****
--- 1,12 ----
+ EXE=
+ O=o
+ A=a
+ OPT=
+ OTOP=../..
+ RANLIB=ranlib
+ RANLIBCMD=ranlib
+ OLIBDIR=$(OTOP)/boot
+ PREFIX=/projects/swlab8/blerner/projects/seminal/seminalOcaml
+ BINDIR=/projects/swlab8/blerner/projects/seminal/seminalOcaml/bin
+ LIBDIR=/projects/swlab8/blerner/projects/seminal/seminalOcaml/lib/ocaml
+ MANDIR=/projects/swlab8/blerner/projects/seminal/seminalOcaml/man
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/config/Makefile seminalOcaml/config/Makefile
*** ocaml-3.08.4/config/Makefile	1969-12-31 16:00:00.000000000 -0800
--- seminalOcaml/config/Makefile	2009-01-19 09:37:42.980206989 -0800
***************
*** 0 ****
--- 1,50 ----
+ # generated by ./configure --prefix /projects/swlab8/blerner/projects/seminal/seminalOcaml
+ PREFIX=/projects/swlab8/blerner/projects/seminal/seminalOcaml
+ BINDIR=$(PREFIX)/bin
+ LIBDIR=$(PREFIX)/lib/ocaml
+ STUBLIBDIR=$(LIBDIR)/stublibs
+ MANDIR=$(PREFIX)/man
+ MANEXT=1
+ RANLIB=ranlib
+ RANLIBCMD=ranlib
+ SHARPBANGSCRIPTS=true
+ BNG_ARCH=ia32
+ BNG_ASM_LEVEL=2
+ PTHREAD_LINK=-lpthread
+ X11_INCLUDES=
+ X11_LINK=-lX11
+ DBM_INCLUDES=-I/usr/include/gdbm
+ DBM_LINK=-lgdbm
+ TK_DEFS= $(X11_INCLUDES)
+ TK_LINK= -ltk8.4 -ltcl8.4  -ldl $(X11_LINK)
+ BYTECC=gcc
+ BYTECCCOMPOPTS=-fno-defer-pop -Wall -D_FILE_OFFSET_BITS=64 -D_REENTRANT
+ BYTECCLINKOPTS= -Wl,-E
+ BYTECCLIBS= -lm  -ldl -lcurses -lpthread
+ BYTECCRPATH=-Wl,-rpath,
+ EXE=
+ SUPPORTS_SHARED_LIBRARIES=true
+ SHAREDCCCOMPOPTS=-fPIC
+ MKSHAREDLIB=gcc -shared -o
+ MKSHAREDLIBRPATH=-Wl,-rpath,
+ ARCH=i386
+ MODEL=default
+ SYSTEM=linux_elf
+ NATIVECC=gcc
+ NATIVECCCOMPOPTS=-Wall -D_FILE_OFFSET_BITS=64 -D_REENTRANT
+ NATIVECCPROFOPTS=-Wall -D_FILE_OFFSET_BITS=64 -D_REENTRANT
+ NATIVECCLINKOPTS=
+ NATIVECCRPATH=-Wl,-rpath,
+ NATIVECCLIBS= -lm  -ldl
+ ASFLAGS=
+ ASPP=gcc
+ ASPPFLAGS=-c -DSYS_$(SYSTEM)
+ ASPPPROFFLAGS=-DPROFILING
+ PROFILING=prof
+ BINUTILS_OBJCOPY=/usr/bin/objcopy
+ BINUTILS_INSTALL_OBJCOPY=:
+ BINUTILS_NM=/usr/bin/nm
+ DYNLINKOPTS= -ldl
+ OTHERLIBRARIES=unix str num dynlink bigarray systhreads threads graph dbm labltk
+ DEBUGGER=ocamldebugger
+ CC_PROFILE=-pg
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/config/Makefile.msvc seminalOcaml/config/Makefile.msvc
*** ocaml-3.08.4/config/Makefile.msvc	2005-02-02 07:39:40.000000000 -0800
--- seminalOcaml/config/Makefile.msvc	2009-01-19 09:37:42.720212263 -0800
***************
*** 11,23 ****
  #                                                                       #
  #########################################################################
  
! # $Id: Makefile.msvc,v 1.12.4.2 2005/02/02 15:39:40 xleroy Exp $
  
  # Configuration for Windows, Visual C++ compiler
  
  ######### General configuration
  
! PREFIX=C:/ocamlms
  
  ### Where to install the binaries.
  BINDIR=$(PREFIX)/bin
--- 11,23 ----
  #                                                                       #
  #########################################################################
  
! # $Id: Makefile.msvc,v 1.2 2006/02/06 18:38:40 blerner Exp $
  
  # Configuration for Windows, Visual C++ compiler
  
  ######### General configuration
  
! PREFIX=C:/docume~1/blerner/desktop/ocamlms
  
  ### Where to install the binaries.
  BINDIR=$(PREFIX)/bin
***************
*** 45,51 ****
  ########## Configuration for the bytecode compiler
  
  ### Which C compiler to use for the bytecode interpreter.
! BYTECC=cl /nologo
  
  ### Additional compile-time options for $(BYTECC).  (For static linking.)
  BYTECCCOMPOPTS=/Ox /MT
--- 45,52 ----
  ########## Configuration for the bytecode compiler
  
  ### Which C compiler to use for the bytecode interpreter.
! VCDIR=/cygdrive/c/Program\ Files/Microsoft\ Visual\ Studio\ .NET\ 2003/Vc7/bin
! BYTECC=$(VCDIR)/cl /nologo
  
  ### Additional compile-time options for $(BYTECC).  (For static linking.)
  BYTECCCOMPOPTS=/Ox /MT
***************
*** 61,73 ****
  NATIVECCLIBS=advapi32.lib
  
  ### How to invoke the C preprocessor
! CPP=cl /nologo /EP
  
  ### How to build a DLL
! MKDLL=link /nologo /dll /out:$(1) /implib:$(2) $(3)
  
  ### How to build a static library
! MKLIB=link /lib /nologo /debugtype:CV /out:$(1) $(2)
  
  ### Canonicalize the name of a system library
  SYSLIB=$(1).lib
--- 62,74 ----
  NATIVECCLIBS=advapi32.lib
  
  ### How to invoke the C preprocessor
! CPP=$(VCDIR)/cl /nologo /EP
  
  ### How to build a DLL
! MKDLL=$(VCDIR)/link /nologo /dll /out:$(1) /implib:$(2) $(3)
  
  ### How to build a static library
! MKLIB=$(VCDIR)/link /lib /nologo /debug /out:$(1) $(2)
  
  ### Canonicalize the name of a system library
  SYSLIB=$(1).lib
***************
*** 96,102 ****
  NATIVECCLINKOPTS=/MT
  
  ### Build partially-linked object file
! PARTIALLD=lib /nologo /debugtype:cv
  PACKLD=ld -r --oformat pe-i386
  
  ### nm and objcopy are missing
--- 97,103 ----
  NATIVECCLINKOPTS=/MT
  
  ### Build partially-linked object file
! PARTIALLD=lib /nologo /debug
  PACKLD=ld -r --oformat pe-i386
  
  ### nm and objcopy are missing
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/config/m.h seminalOcaml/config/m.h
*** ocaml-3.08.4/config/m.h	1969-12-31 16:00:00.000000000 -0800
--- seminalOcaml/config/m.h	2009-01-19 09:37:42.820210266 -0800
***************
*** 0 ****
--- 1,11 ----
+ #undef ARCH_SIXTYFOUR
+ #define SIZEOF_INT 4
+ #define SIZEOF_LONG 4
+ #define SIZEOF_SHORT 2
+ #define ARCH_INT64_TYPE long long
+ #define ARCH_UINT64_TYPE unsigned long long
+ #define ARCH_INT64_PRINTF_FORMAT "ll"
+ #undef ARCH_BIG_ENDIAN
+ #undef ARCH_ALIGN_DOUBLE
+ #undef ARCH_ALIGN_INT64
+ #undef NONSTANDARD_DIV_MOD
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/config/s.h seminalOcaml/config/s.h
*** ocaml-3.08.4/config/s.h	1969-12-31 16:00:00.000000000 -0800
--- seminalOcaml/config/s.h	2009-01-19 09:37:42.888208829 -0800
***************
*** 0 ****
--- 1,45 ----
+ #define OCAML_OS_TYPE "Unix"
+ #define OCAML_STDLIB_DIR "/projects/swlab8/blerner/projects/seminal/seminalOcaml/lib/ocaml"
+ #define POSIX_SIGNALS
+ #define HAS_TIMES
+ #define HAS_TERMCAP
+ #define HAS_SOCKETS
+ #define HAS_SOCKLEN_T
+ #define HAS_INET_ATON
+ #define HAS_IPV6
+ #define HAS_UNISTD
+ #define HAS_OFF_T
+ #define HAS_DIRENT
+ #define HAS_REWINDDIR
+ #define HAS_LOCKF
+ #define HAS_MKFIFO
+ #define HAS_GETCWD
+ #define HAS_GETWD
+ #define HAS_GETPRIORITY
+ #define HAS_UTIME
+ #define HAS_UTIMES
+ #define HAS_DUP2
+ #define HAS_FCHMOD
+ #define HAS_TRUNCATE
+ #define HAS_SYS_SELECT_H
+ #define HAS_SELECT
+ #define HAS_SYMLINK
+ #define HAS_WAITPID
+ #define HAS_WAIT4
+ #define HAS_GETGROUPS
+ #define HAS_TERMIOS
+ #define HAS_ASYNC_IO
+ #define HAS_SETITIMER
+ #define HAS_GETHOSTNAME
+ #define HAS_UNAME
+ #define HAS_GETTIMEOFDAY
+ #define HAS_MKTIME
+ #define HAS_SETSID
+ #define HAS_PUTENV
+ #define HAS_LOCALE
+ #define SUPPORT_DYNAMIC_LINKING
+ #define HAS_MMAP
+ #define HAS_GETHOSTBYNAME_R 6
+ #define HAS_GETHOSTBYADDR_R 8
+ #define HAS_STACK_OVERFLOW_DETECTION
+ #define HAS_SIGWAIT
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/.depend seminalOcaml/.depend
*** ocaml-3.08.4/.depend	2005-02-22 06:33:34.000000000 -0800
--- seminalOcaml/.depend	2009-01-19 09:42:21.592965358 -0800
***************
*** 23,28 ****
--- 23,29 ----
  parsing/parsetree.cmi: parsing/longident.cmi parsing/location.cmi \
      parsing/asttypes.cmi 
  parsing/printast.cmi: parsing/parsetree.cmi 
+ parsing/printcode.cmi: parsing/parsetree.cmi 
  parsing/syntaxerr.cmi: parsing/location.cmi 
  parsing/lexer.cmo: utils/warnings.cmi parsing/parser.cmi utils/misc.cmi \
      parsing/location.cmi parsing/lexer.cmi 
***************
*** 50,55 ****
--- 51,60 ----
      parsing/location.cmi parsing/asttypes.cmi parsing/printast.cmi 
  parsing/printast.cmx: parsing/parsetree.cmi parsing/longident.cmx \
      parsing/location.cmx parsing/asttypes.cmi parsing/printast.cmi 
+ parsing/printcode.cmo: parsing/parsetree.cmi parsing/longident.cmi \
+     parsing/location.cmi parsing/asttypes.cmi parsing/printcode.cmi 
+ parsing/printcode.cmx: parsing/parsetree.cmi parsing/longident.cmx \
+     parsing/location.cmx parsing/asttypes.cmi parsing/printcode.cmi 
  parsing/syntaxerr.cmo: parsing/location.cmi parsing/syntaxerr.cmi 
  parsing/syntaxerr.cmx: parsing/location.cmx parsing/syntaxerr.cmi 
  typing/btype.cmi: typing/types.cmi typing/path.cmi parsing/asttypes.cmi 
***************
*** 430,437 ****
  asmcomp/clambda.cmi: bytecomp/lambda.cmi typing/ident.cmi \
      parsing/asttypes.cmi 
  asmcomp/closure.cmi: bytecomp/lambda.cmi asmcomp/clambda.cmi 
- asmcomp/cmm.cmi: typing/ident.cmi 
  asmcomp/cmmgen.cmi: asmcomp/cmm.cmi asmcomp/clambda.cmi 
  asmcomp/codegen.cmi: asmcomp/cmm.cmi 
  asmcomp/comballoc.cmi: asmcomp/mach.cmi 
  asmcomp/compilenv.cmi: typing/ident.cmi asmcomp/clambda.cmi 
--- 435,442 ----
  asmcomp/clambda.cmi: bytecomp/lambda.cmi typing/ident.cmi \
      parsing/asttypes.cmi 
  asmcomp/closure.cmi: bytecomp/lambda.cmi asmcomp/clambda.cmi 
  asmcomp/cmmgen.cmi: asmcomp/cmm.cmi asmcomp/clambda.cmi 
+ asmcomp/cmm.cmi: typing/ident.cmi 
  asmcomp/codegen.cmi: asmcomp/cmm.cmi 
  asmcomp/comballoc.cmi: asmcomp/mach.cmi 
  asmcomp/compilenv.cmi: typing/ident.cmi asmcomp/clambda.cmi 
***************
*** 445,452 ****
  asmcomp/printmach.cmi: asmcomp/reg.cmi asmcomp/mach.cmi 
  asmcomp/proc.cmi: asmcomp/reg.cmi asmcomp/mach.cmi 
  asmcomp/reg.cmi: asmcomp/cmm.cmi 
- asmcomp/reload.cmi: asmcomp/mach.cmi 
  asmcomp/reloadgen.cmi: asmcomp/reg.cmi asmcomp/mach.cmi 
  asmcomp/schedgen.cmi: asmcomp/mach.cmi asmcomp/linearize.cmi 
  asmcomp/scheduling.cmi: asmcomp/linearize.cmi 
  asmcomp/selectgen.cmi: utils/tbl.cmi asmcomp/reg.cmi asmcomp/mach.cmi \
--- 450,457 ----
  asmcomp/printmach.cmi: asmcomp/reg.cmi asmcomp/mach.cmi 
  asmcomp/proc.cmi: asmcomp/reg.cmi asmcomp/mach.cmi 
  asmcomp/reg.cmi: asmcomp/cmm.cmi 
  asmcomp/reloadgen.cmi: asmcomp/reg.cmi asmcomp/mach.cmi 
+ asmcomp/reload.cmi: asmcomp/mach.cmi 
  asmcomp/schedgen.cmi: asmcomp/mach.cmi asmcomp/linearize.cmi 
  asmcomp/scheduling.cmi: asmcomp/linearize.cmi 
  asmcomp/selectgen.cmi: utils/tbl.cmi asmcomp/reg.cmi asmcomp/mach.cmi \
***************
*** 510,517 ****
      utils/misc.cmx bytecomp/lambda.cmx typing/ident.cmx asmcomp/compilenv.cmx \
      utils/clflags.cmx asmcomp/clambda.cmx parsing/asttypes.cmi \
      asmcomp/closure.cmi 
- asmcomp/cmm.cmo: typing/ident.cmi asmcomp/arch.cmo asmcomp/cmm.cmi 
- asmcomp/cmm.cmx: typing/ident.cmx asmcomp/arch.cmx asmcomp/cmm.cmi 
  asmcomp/cmmgen.cmo: typing/types.cmi bytecomp/switch.cmi asmcomp/proc.cmi \
      typing/primitive.cmi utils/misc.cmi bytecomp/lambda.cmi typing/ident.cmi \
      utils/config.cmi asmcomp/compilenv.cmi asmcomp/cmm.cmi utils/clflags.cmo \
--- 515,520 ----
***************
*** 522,527 ****
--- 525,532 ----
      utils/config.cmx asmcomp/compilenv.cmx asmcomp/cmm.cmx utils/clflags.cmx \
      asmcomp/clambda.cmx parsing/asttypes.cmi asmcomp/arch.cmx \
      asmcomp/cmmgen.cmi 
+ asmcomp/cmm.cmo: typing/ident.cmi asmcomp/arch.cmo asmcomp/cmm.cmi 
+ asmcomp/cmm.cmx: typing/ident.cmx asmcomp/arch.cmx asmcomp/cmm.cmi 
  asmcomp/codegen.cmo: asmcomp/split.cmi asmcomp/spill.cmi asmcomp/reload.cmi \
      asmcomp/reg.cmi asmcomp/printmach.cmi asmcomp/printlinear.cmi \
      asmcomp/printcmm.cmi asmcomp/liveness.cmi asmcomp/linearize.cmi \
***************
*** 542,557 ****
      utils/config.cmi asmcomp/clambda.cmi asmcomp/compilenv.cmi 
  asmcomp/compilenv.cmx: utils/misc.cmx typing/ident.cmx typing/env.cmx \
      utils/config.cmx asmcomp/clambda.cmx asmcomp/compilenv.cmi 
  asmcomp/emit.cmo: asmcomp/reg.cmi asmcomp/proc.cmi utils/misc.cmi \
      asmcomp/mach.cmi parsing/location.cmi asmcomp/linearize.cmi \
      asmcomp/emitaux.cmi utils/config.cmi asmcomp/compilenv.cmi \
!     asmcomp/cmm.cmi asmcomp/arch.cmo asmcomp/emit.cmi 
  asmcomp/emit.cmx: asmcomp/reg.cmx asmcomp/proc.cmx utils/misc.cmx \
      asmcomp/mach.cmx parsing/location.cmx asmcomp/linearize.cmx \
      asmcomp/emitaux.cmx utils/config.cmx asmcomp/compilenv.cmx \
!     asmcomp/cmm.cmx asmcomp/arch.cmx asmcomp/emit.cmi 
! asmcomp/emitaux.cmo: asmcomp/emitaux.cmi 
! asmcomp/emitaux.cmx: asmcomp/emitaux.cmi 
  asmcomp/interf.cmo: asmcomp/reg.cmi asmcomp/proc.cmi utils/misc.cmi \
      asmcomp/mach.cmi asmcomp/interf.cmi 
  asmcomp/interf.cmx: asmcomp/reg.cmx asmcomp/proc.cmx utils/misc.cmx \
--- 547,562 ----
      utils/config.cmi asmcomp/clambda.cmi asmcomp/compilenv.cmi 
  asmcomp/compilenv.cmx: utils/misc.cmx typing/ident.cmx typing/env.cmx \
      utils/config.cmx asmcomp/clambda.cmx asmcomp/compilenv.cmi 
+ asmcomp/emitaux.cmo: asmcomp/emitaux.cmi 
+ asmcomp/emitaux.cmx: asmcomp/emitaux.cmi 
  asmcomp/emit.cmo: asmcomp/reg.cmi asmcomp/proc.cmi utils/misc.cmi \
      asmcomp/mach.cmi parsing/location.cmi asmcomp/linearize.cmi \
      asmcomp/emitaux.cmi utils/config.cmi asmcomp/compilenv.cmi \
!     asmcomp/cmm.cmi utils/clflags.cmo asmcomp/arch.cmo asmcomp/emit.cmi 
  asmcomp/emit.cmx: asmcomp/reg.cmx asmcomp/proc.cmx utils/misc.cmx \
      asmcomp/mach.cmx parsing/location.cmx asmcomp/linearize.cmx \
      asmcomp/emitaux.cmx utils/config.cmx asmcomp/compilenv.cmx \
!     asmcomp/cmm.cmx utils/clflags.cmx asmcomp/arch.cmx asmcomp/emit.cmi 
  asmcomp/interf.cmo: asmcomp/reg.cmi asmcomp/proc.cmi utils/misc.cmi \
      asmcomp/mach.cmi asmcomp/interf.cmi 
  asmcomp/interf.cmx: asmcomp/reg.cmx asmcomp/proc.cmx utils/misc.cmx \
***************
*** 586,617 ****
      asmcomp/arch.cmx asmcomp/proc.cmi 
  asmcomp/reg.cmo: asmcomp/cmm.cmi asmcomp/reg.cmi 
  asmcomp/reg.cmx: asmcomp/cmm.cmx asmcomp/reg.cmi 
- asmcomp/reload.cmo: asmcomp/reloadgen.cmi asmcomp/reload.cmi 
- asmcomp/reload.cmx: asmcomp/reloadgen.cmx asmcomp/reload.cmi 
  asmcomp/reloadgen.cmo: asmcomp/reg.cmi utils/misc.cmi asmcomp/mach.cmi \
      asmcomp/reloadgen.cmi 
  asmcomp/reloadgen.cmx: asmcomp/reg.cmx utils/misc.cmx asmcomp/mach.cmx \
      asmcomp/reloadgen.cmi 
  asmcomp/schedgen.cmo: asmcomp/reg.cmi utils/misc.cmi asmcomp/mach.cmi \
      asmcomp/linearize.cmi asmcomp/cmm.cmi asmcomp/arch.cmo \
      asmcomp/schedgen.cmi 
  asmcomp/schedgen.cmx: asmcomp/reg.cmx utils/misc.cmx asmcomp/mach.cmx \
      asmcomp/linearize.cmx asmcomp/cmm.cmx asmcomp/arch.cmx \
      asmcomp/schedgen.cmi 
! asmcomp/scheduling.cmo: asmcomp/schedgen.cmi asmcomp/mach.cmi \
!     asmcomp/arch.cmo asmcomp/scheduling.cmi 
! asmcomp/scheduling.cmx: asmcomp/schedgen.cmx asmcomp/mach.cmx \
!     asmcomp/arch.cmx asmcomp/scheduling.cmi 
  asmcomp/selectgen.cmo: utils/tbl.cmi asmcomp/reg.cmi asmcomp/proc.cmi \
      utils/misc.cmi asmcomp/mach.cmi typing/ident.cmi asmcomp/cmm.cmi \
      asmcomp/arch.cmo asmcomp/selectgen.cmi 
  asmcomp/selectgen.cmx: utils/tbl.cmx asmcomp/reg.cmx asmcomp/proc.cmx \
      utils/misc.cmx asmcomp/mach.cmx typing/ident.cmx asmcomp/cmm.cmx \
      asmcomp/arch.cmx asmcomp/selectgen.cmi 
! asmcomp/selection.cmo: asmcomp/selectgen.cmi asmcomp/reg.cmi utils/misc.cmi \
!     asmcomp/mach.cmi asmcomp/cmm.cmi asmcomp/arch.cmo asmcomp/selection.cmi 
! asmcomp/selection.cmx: asmcomp/selectgen.cmx asmcomp/reg.cmx utils/misc.cmx \
!     asmcomp/mach.cmx asmcomp/cmm.cmx asmcomp/arch.cmx asmcomp/selection.cmi 
  asmcomp/spill.cmo: asmcomp/reg.cmi asmcomp/proc.cmi utils/misc.cmi \
      asmcomp/mach.cmi asmcomp/spill.cmi 
  asmcomp/spill.cmx: asmcomp/reg.cmx asmcomp/proc.cmx utils/misc.cmx \
--- 591,624 ----
      asmcomp/arch.cmx asmcomp/proc.cmi 
  asmcomp/reg.cmo: asmcomp/cmm.cmi asmcomp/reg.cmi 
  asmcomp/reg.cmx: asmcomp/cmm.cmx asmcomp/reg.cmi 
  asmcomp/reloadgen.cmo: asmcomp/reg.cmi utils/misc.cmi asmcomp/mach.cmi \
      asmcomp/reloadgen.cmi 
  asmcomp/reloadgen.cmx: asmcomp/reg.cmx utils/misc.cmx asmcomp/mach.cmx \
      asmcomp/reloadgen.cmi 
+ asmcomp/reload.cmo: asmcomp/reloadgen.cmi asmcomp/reg.cmi asmcomp/mach.cmi \
+     asmcomp/cmm.cmi asmcomp/arch.cmo asmcomp/reload.cmi 
+ asmcomp/reload.cmx: asmcomp/reloadgen.cmx asmcomp/reg.cmx asmcomp/mach.cmx \
+     asmcomp/cmm.cmx asmcomp/arch.cmx asmcomp/reload.cmi 
  asmcomp/schedgen.cmo: asmcomp/reg.cmi utils/misc.cmi asmcomp/mach.cmi \
      asmcomp/linearize.cmi asmcomp/cmm.cmi asmcomp/arch.cmo \
      asmcomp/schedgen.cmi 
  asmcomp/schedgen.cmx: asmcomp/reg.cmx utils/misc.cmx asmcomp/mach.cmx \
      asmcomp/linearize.cmx asmcomp/cmm.cmx asmcomp/arch.cmx \
      asmcomp/schedgen.cmi 
! asmcomp/scheduling.cmo: asmcomp/schedgen.cmi asmcomp/scheduling.cmi 
! asmcomp/scheduling.cmx: asmcomp/schedgen.cmx asmcomp/scheduling.cmi 
  asmcomp/selectgen.cmo: utils/tbl.cmi asmcomp/reg.cmi asmcomp/proc.cmi \
      utils/misc.cmi asmcomp/mach.cmi typing/ident.cmi asmcomp/cmm.cmi \
      asmcomp/arch.cmo asmcomp/selectgen.cmi 
  asmcomp/selectgen.cmx: utils/tbl.cmx asmcomp/reg.cmx asmcomp/proc.cmx \
      utils/misc.cmx asmcomp/mach.cmx typing/ident.cmx asmcomp/cmm.cmx \
      asmcomp/arch.cmx asmcomp/selectgen.cmi 
! asmcomp/selection.cmo: asmcomp/selectgen.cmi asmcomp/reg.cmi asmcomp/proc.cmi \
!     utils/misc.cmi asmcomp/mach.cmi asmcomp/cmm.cmi asmcomp/arch.cmo \
!     asmcomp/selection.cmi 
! asmcomp/selection.cmx: asmcomp/selectgen.cmx asmcomp/reg.cmx asmcomp/proc.cmx \
!     utils/misc.cmx asmcomp/mach.cmx asmcomp/cmm.cmx asmcomp/arch.cmx \
!     asmcomp/selection.cmi 
  asmcomp/spill.cmo: asmcomp/reg.cmi asmcomp/proc.cmi utils/misc.cmi \
      asmcomp/mach.cmi asmcomp/spill.cmi 
  asmcomp/spill.cmx: asmcomp/reg.cmx asmcomp/proc.cmx utils/misc.cmx \
***************
*** 622,653 ****
      asmcomp/split.cmi 
  driver/compile.cmi: typing/env.cmi 
  driver/optcompile.cmi: typing/env.cmi 
  driver/compile.cmo: utils/warnings.cmi typing/typemod.cmi \
      typing/typedtree.cmi bytecomp/translmod.cmi bytecomp/simplif.cmi \
!     typing/printtyp.cmi bytecomp/printlambda.cmi bytecomp/printinstr.cmi \
!     parsing/printast.cmi driver/pparse.cmi parsing/parse.cmi utils/misc.cmi \
!     typing/ident.cmi typing/env.cmi bytecomp/emitcode.cmi utils/config.cmi \
!     utils/clflags.cmo utils/ccomp.cmi bytecomp/bytegen.cmi driver/compile.cmi 
  driver/compile.cmx: utils/warnings.cmx typing/typemod.cmx \
      typing/typedtree.cmx bytecomp/translmod.cmx bytecomp/simplif.cmx \
!     typing/printtyp.cmx bytecomp/printlambda.cmx bytecomp/printinstr.cmx \
!     parsing/printast.cmx driver/pparse.cmx parsing/parse.cmx utils/misc.cmx \
!     typing/ident.cmx typing/env.cmx bytecomp/emitcode.cmx utils/config.cmx \
!     utils/clflags.cmx utils/ccomp.cmx bytecomp/bytegen.cmx driver/compile.cmi 
  driver/errors.cmo: utils/warnings.cmi typing/typetexp.cmi typing/typemod.cmi \
      typing/typedecl.cmi typing/typecore.cmi typing/typeclass.cmi \
      bytecomp/translmod.cmi bytecomp/translcore.cmi bytecomp/translclass.cmi \
!     parsing/syntaxerr.cmi bytecomp/symtable.cmi driver/pparse.cmi \
!     parsing/location.cmi parsing/lexer.cmi typing/includemod.cmi \
!     typing/env.cmi typing/ctype.cmi bytecomp/bytepackager.cmi \
!     bytecomp/bytelink.cmi bytecomp/bytelibrarian.cmi driver/errors.cmi 
  driver/errors.cmx: utils/warnings.cmx typing/typetexp.cmx typing/typemod.cmx \
      typing/typedecl.cmx typing/typecore.cmx typing/typeclass.cmx \
      bytecomp/translmod.cmx bytecomp/translcore.cmx bytecomp/translclass.cmx \
!     parsing/syntaxerr.cmx bytecomp/symtable.cmx driver/pparse.cmx \
!     parsing/location.cmx parsing/lexer.cmx typing/includemod.cmx \
!     typing/env.cmx typing/ctype.cmx bytecomp/bytepackager.cmx \
!     bytecomp/bytelink.cmx bytecomp/bytelibrarian.cmx driver/errors.cmi 
  driver/main.cmo: utils/warnings.cmi utils/misc.cmi driver/main_args.cmi \
      driver/errors.cmi utils/config.cmi driver/compile.cmi utils/clflags.cmo \
      bytecomp/bytepackager.cmi bytecomp/bytelink.cmi \
--- 629,668 ----
      asmcomp/split.cmi 
  driver/compile.cmi: typing/env.cmi 
  driver/optcompile.cmi: typing/env.cmi 
+ driver/seminal.cmi: typing/typedtree.cmi parsing/parsetree.cmi utils/misc.cmi \
+     parsing/location.cmi utils/config.cmi 
  driver/compile.cmo: utils/warnings.cmi typing/typemod.cmi \
      typing/typedtree.cmi bytecomp/translmod.cmi bytecomp/simplif.cmi \
!     driver/seminal.cmi typing/printtyp.cmi bytecomp/printlambda.cmi \
!     bytecomp/printinstr.cmi parsing/printast.cmi driver/pparse.cmi \
!     parsing/parse.cmi utils/misc.cmi typing/ident.cmi driver/errors.cmi \
!     typing/env.cmi bytecomp/emitcode.cmi utils/config.cmi utils/clflags.cmo \
!     utils/ccomp.cmi bytecomp/bytegen.cmi driver/compile.cmi 
  driver/compile.cmx: utils/warnings.cmx typing/typemod.cmx \
      typing/typedtree.cmx bytecomp/translmod.cmx bytecomp/simplif.cmx \
!     driver/seminal.cmx typing/printtyp.cmx bytecomp/printlambda.cmx \
!     bytecomp/printinstr.cmx parsing/printast.cmx driver/pparse.cmx \
!     parsing/parse.cmx utils/misc.cmx typing/ident.cmx driver/errors.cmx \
!     typing/env.cmx bytecomp/emitcode.cmx utils/config.cmx utils/clflags.cmx \
!     utils/ccomp.cmx bytecomp/bytegen.cmx driver/compile.cmi 
  driver/errors.cmo: utils/warnings.cmi typing/typetexp.cmi typing/typemod.cmi \
      typing/typedecl.cmi typing/typecore.cmi typing/typeclass.cmi \
      bytecomp/translmod.cmi bytecomp/translcore.cmi bytecomp/translclass.cmi \
!     parsing/syntaxerr.cmi bytecomp/symtable.cmi driver/seminal.cmi \
!     driver/pparse.cmi parsing/location.cmi parsing/lexer.cmi \
!     typing/includemod.cmi typing/env.cmi typing/ctype.cmi \
!     bytecomp/bytepackager.cmi bytecomp/bytelink.cmi \
!     bytecomp/bytelibrarian.cmi driver/errors.cmi 
  driver/errors.cmx: utils/warnings.cmx typing/typetexp.cmx typing/typemod.cmx \
      typing/typedecl.cmx typing/typecore.cmx typing/typeclass.cmx \
      bytecomp/translmod.cmx bytecomp/translcore.cmx bytecomp/translclass.cmx \
!     parsing/syntaxerr.cmx bytecomp/symtable.cmx driver/seminal.cmx \
!     driver/pparse.cmx parsing/location.cmx parsing/lexer.cmx \
!     typing/includemod.cmx typing/env.cmx typing/ctype.cmx \
!     bytecomp/bytepackager.cmx bytecomp/bytelink.cmx \
!     bytecomp/bytelibrarian.cmx driver/errors.cmi 
! driver/main_args.cmo: driver/main_args.cmi 
! driver/main_args.cmx: driver/main_args.cmi 
  driver/main.cmo: utils/warnings.cmi utils/misc.cmi driver/main_args.cmi \
      driver/errors.cmi utils/config.cmi driver/compile.cmi utils/clflags.cmo \
      bytecomp/bytepackager.cmi bytecomp/bytelink.cmi \
***************
*** 656,663 ****
      driver/errors.cmx utils/config.cmx driver/compile.cmx utils/clflags.cmx \
      bytecomp/bytepackager.cmx bytecomp/bytelink.cmx \
      bytecomp/bytelibrarian.cmx driver/main.cmi 
- driver/main_args.cmo: driver/main_args.cmi 
- driver/main_args.cmx: driver/main_args.cmi 
  driver/optcompile.cmo: utils/warnings.cmi typing/typemod.cmi \
      typing/typedtree.cmi bytecomp/translmod.cmi bytecomp/simplif.cmi \
      typing/printtyp.cmi bytecomp/printlambda.cmi parsing/printast.cmi \
--- 671,676 ----
***************
*** 700,705 ****
--- 713,728 ----
      utils/ccomp.cmi driver/pparse.cmi 
  driver/pparse.cmx: utils/misc.cmx parsing/location.cmx utils/clflags.cmx \
      utils/ccomp.cmx driver/pparse.cmi 
+ driver/seminal.cmo: typing/typetexp.cmi typing/typemod.cmi \
+     typing/typedecl.cmi typing/typecore.cmi typing/typeclass.cmi \
+     parsing/printcode.cmi parsing/parsetree.cmi utils/misc.cmi \
+     parsing/longident.cmi parsing/location.cmi typing/includemod.cmi \
+     utils/config.cmi parsing/asttypes.cmi driver/seminal.cmi 
+ driver/seminal.cmx: typing/typetexp.cmx typing/typemod.cmx \
+     typing/typedecl.cmx typing/typecore.cmx typing/typeclass.cmx \
+     parsing/printcode.cmx parsing/parsetree.cmi utils/misc.cmx \
+     parsing/longident.cmx parsing/location.cmx typing/includemod.cmx \
+     utils/config.cmx parsing/asttypes.cmi driver/seminal.cmi 
  toplevel/genprintval.cmi: typing/types.cmi typing/path.cmi \
      typing/outcometree.cmi typing/env.cmi 
  toplevel/topdirs.cmi: parsing/longident.cmi 
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/driver/compile.ml seminalOcaml/driver/compile.ml
*** ocaml-3.08.4/driver/compile.ml	2004-06-13 05:46:41.000000000 -0700
--- seminalOcaml/driver/compile.ml	2009-01-19 09:37:59.283902623 -0800
***************
*** 18,23 ****
--- 18,24 ----
  open Config
  open Format
  open Typedtree
+ open Seminal
  
  (* Initialize the search path.
     The current directory is always searched first,
***************
*** 59,64 ****
--- 60,66 ----
      let ast =
        Pparse.file ppf inputfile Parse.interface ast_intf_magic_number in
      if !Clflags.dump_parsetree then fprintf ppf "%a@." Printast.interface ast;
+     if !Clflags.dump_printcode then fprintf ppf "%a@." Printcode.interface ast;
      let sg = Typemod.transl_signature (initial_env()) ast in
      if !Clflags.print_types then
        fprintf std_formatter "%a@." Printtyp.signature
***************
*** 77,105 ****
    if !flag then fprintf ppf "%a@." printer arg;
    arg
  
! let (++) x f = f x
  
! let implementation ppf sourcefile outputprefix =
    init_path();
    let modulename =
      String.capitalize(Filename.basename(chop_extension_if_any sourcefile)) in
    let inputfile = Pparse.preprocess sourcefile in
    let env = initial_env() in
!   if !Clflags.print_types then begin
      try ignore(
        Pparse.file ppf inputfile Parse.implementation ast_impl_magic_number
        ++ print_if ppf Clflags.dump_parsetree Printast.implementation
        ++ Typemod.type_implementation sourcefile outputprefix modulename env)
      with x ->
        Pparse.remove_preprocessed_if_ast inputfile;
        raise x
!   end else begin    
      let objfile = outputprefix ^ ".cmo" in
      let oc = open_out_bin objfile in
      try
!       Pparse.file ppf inputfile Parse.implementation ast_impl_magic_number
!       ++ print_if ppf Clflags.dump_parsetree Printast.implementation
!       ++ Typemod.type_implementation sourcefile outputprefix modulename env
        ++ Translmod.transl_implementation modulename
        ++ print_if ppf Clflags.dump_rawlambda Printlambda.lambda
        ++ Simplif.simplify_lambda
--- 79,207 ----
    if !flag then fprintf ppf "%a@." printer arg;
    arg
  
! let printSeminalErrors_if shouldPrint (ret, ex) = 
!   if shouldPrint then (match ex with
!     Seminal.FixedErrors(exs) -> 
!       if exs <> [] then Errors.report_error Format.err_formatter ex
!   | _ -> ());
!   ret
! 
! 
! (*
! let createFeedback inputfile =
!   let init_rand () =
!     let initDone = ref false in
!     if !initDone then () else (Random.self_init(); initDone := true) in
! 
!   let copyFile ifile ofile =
!     let ic = open_in ifile in
!     let oc = open_out ofile in
!     
!     let sanitize charStream =
!       try
!         let curDepth = ref 0 in
!         let junk n = for i = 1 to n do Stream.junk charStream done in
!         while true do
!           let nextChar = Stream.next charStream in
!           begin 
!             match (nextChar :: (Stream.npeek 5 charStream)) with
!               ['('; '*'; '\r'; '\n'; '*'; ')'] -> if (!curDepth = 0) then (output_string oc "(*\r\n*)") else (output_string oc "##\r\n##"); junk 5
!             | ['('; '*'; '\n'; '\r'; '*'; ')'] -> if (!curDepth = 0) then (output_string oc "(*\n\r*)") else (output_string oc "##\n\r##"); junk 5
!             | _ -> match (nextChar :: (Stream.npeek 4 charStream)) with
!                 ['('; '*'; '\n'; '*'; ')'] -> if (!curDepth = 0) then (output_string oc "(*\n*)") else (output_string oc "##\n##"); junk 4
!               | ['('; '*'; '\r'; '*'; ')'] -> if (!curDepth = 0) then (output_string oc "(*\r*)") else (output_string oc "##\r##"); junk 4
!               | ['('; '*'; '\t'; '*'; ')'] -> if (!curDepth = 0) then (output_string oc "(*\t*)") else (output_string oc "#####"); junk 4
!               | ['('; '*'; ' '; '*'; ')'] -> if (!curDepth = 0) then (output_string oc "(* *)") else (output_string oc "#####"); junk 4
!               | _ -> match (nextChar :: (Stream.npeek 3 charStream)) with
!                   ['('; '*'; '\n'; '\r'] -> (if (!curDepth = 0) then (output_string oc "(*\n\r") else (output_string oc "##\n\r")); junk 3; incr curDepth
!                 | ['('; '*'; '\r'; '\n'] -> (if (!curDepth = 0) then (output_string oc "(*\r\n") else (output_string oc "##\r\n")); junk 3; incr curDepth
!                 | ['\n'; '\r'; '*'; ')'] -> (if (!curDepth = 1) then (output_string oc "\n\r*)") else (output_string oc "\n\r##")); junk 3; decr curDepth
!                 | ['\r'; '\n'; '*'; ')'] -> (if (!curDepth = 1) then (output_string oc "\r\n*)") else (output_string oc "\r\n##")); junk 3; decr curDepth
!                 | _ -> match (nextChar :: (Stream.npeek 2 charStream)) with
!                   | ['('; '*'; '\r'] -> (if (!curDepth = 0) then (output_string oc "(*\r") else (output_string oc "##\r")); junk 2; incr curDepth
!                   | ['('; '*'; '\n'] -> (if (!curDepth = 0) then (output_string oc "(*\n") else (output_string oc "##\n")); junk 2; incr curDepth
!                   | ['('; '*'; '\t'] -> (if (!curDepth = 0) then (output_string oc "(*\t") else (output_string oc "###")); junk 2; incr curDepth
!                   | ['('; '*'; ' '] -> (if (!curDepth = 0) then (output_string oc "(* ") else (output_string oc "###")); junk 2; incr curDepth
!                   | ['\r'; '*'; ')'] -> (if (!curDepth = 1) then (output_string oc "\r*)") else (output_string oc "\r##")); junk 2; decr curDepth
!                   | ['\n'; '*'; ')'] -> (if (!curDepth = 1) then (output_string oc "\n*)") else (output_string oc "\n##")); junk 2; decr curDepth
!                   | ['\t'; '*'; ')'] -> (if (!curDepth = 1) then (output_string oc "\t*)") else (output_string oc "###")); junk 2; decr curDepth
!                   | [' '; '*'; ')'] -> (if (!curDepth = 1) then (output_string oc " *)") else (output_string oc "###")); junk 2; decr curDepth
!                   | _ -> match nextChar with
!                       '\n'
!                     | '\r' -> output_char oc nextChar
!                     | _ -> if (!curDepth = 0) then output_char oc nextChar else output_char oc '#'
!           end
!         done
!       with Stream.Failure -> () in
!     
!     sanitize (Stream.of_channel ic);
!     close_in ic; close_out oc in
! 
!   init_rand();
!   let os = Sys.os_type in
!   let safeGetEnv envStr =
!     try
!       (Sys.getenv envStr)
!     with Not_found -> envStr ^ "NOTFOUND" in
!   let semDir = safeGetEnv "SEMINAL_DIR" in
!   let uname = if (os = "Win32") then (safeGetEnv "USERNAME") else (safeGetEnv "USER") in
!   let hashUname = Digest.to_hex(Digest.string (uname ^ string_of_int(Random.bits()))) in
!   let destFile = Filename.concat semDir (hashUname ^ ".seminal.ml") in
!   if (semDir = "SEMINAL_DIRNOTFOUND") 
!   then (print_string "Not generating Seminal feedback file\n") 
!   else (try
!     copyFile inputfile destFile
!   with Not_found -> print_string ("Could not generate backup file on " ^ os ^ "\n"))
! *)
! 
! 
  
! 
! let rec implementation ppf sourcefile outputprefix =
    init_path();
    let modulename =
      String.capitalize(Filename.basename(chop_extension_if_any sourcefile)) in
    let inputfile = Pparse.preprocess sourcefile in
    let env = initial_env() in
!   let (++) x f = f x in
!   if !Clflags.print_types then begin (* this branch just dumps types out *)
      try ignore(
        Pparse.file ppf inputfile Parse.implementation ast_impl_magic_number
        ++ print_if ppf Clflags.dump_parsetree Printast.implementation
+       ++ print_if ppf Clflags.dump_printcode Printcode.implementation
        ++ Typemod.type_implementation sourcefile outputprefix modulename env)
      with x ->
        Pparse.remove_preprocessed_if_ast inputfile;
        raise x
!   end else begin    (* this actually compiles the code *)
      let objfile = outputprefix ^ ".cmo" in
      let oc = open_out_bin objfile in
      try
!       let frontEnd =
!         if !Clflags.use_seminal then
!           (hookSeminal 
!              (function file -> 
!                (Pparse.file ppf file Parse.implementation ast_impl_magic_number)
!                  ++ print_if ppf Clflags.dump_parsetree Printast.implementation
!                  ++ print_if ppf Clflags.dump_printcode Printcode.implementation)
!              (function ast ->
!                let initenv = initial_env() in
!                Typemod.type_implementation sourcefile outputprefix modulename initenv ast)
!              inputfile 
!              outputprefix
!              initial_env
!              interface
!              implementation)
!             ++ printSeminalErrors_if false
!         else
!           (try 
!             Pparse.file ppf inputfile Parse.implementation ast_impl_magic_number
!               ++ print_if ppf Clflags.dump_parsetree Printast.implementation
!               ++ print_if ppf Clflags.dump_printcode Printcode.implementation
!               ++ Typemod.type_implementation sourcefile outputprefix modulename env
!           with x -> ((* createFeedback inputfile; *) raise x))
!       in
!       frontEnd
        ++ Translmod.transl_implementation modulename
        ++ print_if ppf Clflags.dump_rawlambda Printlambda.lambda
        ++ Simplif.simplify_lambda
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/driver/errors.ml seminalOcaml/driver/errors.ml
*** ocaml-3.08.4/driver/errors.ml	2003-06-19 08:53:49.000000000 -0700
--- seminalOcaml/driver/errors.ml	2009-01-19 09:37:55.431982015 -0800
***************
*** 20,27 ****
  
  (* Report an error *)
  
! let report_error ppf exn =
!   let report ppf = function
    | Lexer.Error(err, loc) ->
        Location.print ppf loc;
        Lexer.report_error ppf err
--- 20,27 ----
  
  (* Report an error *)
  
! let rec report_error ppf exn =
!   let rec report ppf = function
    | Lexer.Error(err, loc) ->
        Location.print ppf loc;
        Lexer.report_error ppf err
***************
*** 64,69 ****
--- 64,73 ----
        fprintf ppf "I/O error: %s" msg
    | Warnings.Errors (n) ->
        fprintf ppf "@.Error: %d error-enabled warnings occurred." n
+   | Seminal.TooManyErrors ->
+       fprintf ppf "\nToo many errors caught; aborting" 
+   | Seminal.FixedErrors (exs) ->
+       ()
    | x -> fprintf ppf "@]"; raise x in
  
    fprintf ppf "@[%a@]@." report exn
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/driver/main_args.ml seminalOcaml/driver/main_args.ml
*** ocaml-3.08.4/driver/main_args.ml	2003-07-17 01:38:27.000000000 -0700
--- seminalOcaml/driver/main_args.ml	2009-01-19 09:37:59.435899616 -0800
***************
*** 56,61 ****
--- 56,64 ----
  
       val _nopervasives : unit -> unit
       val _dparsetree : unit -> unit
+      val _dprintcode : unit -> unit
+      val _use_seminal : unit -> unit
+      val _no_triage : unit -> unit
       val _drawlambda : unit -> unit
       val _dlambda : unit -> unit
       val _dinstr : unit -> unit
***************
*** 109,114 ****
--- 112,119 ----
      "-principal", Arg.Unit F._principal,
             " Check principality of type inference";
      "-rectypes", Arg.Unit F._rectypes, " Allow arbitrary recursive types";
+     "-seminal", Arg.Unit F._use_seminal, " Automatic search for fixes to errors in code";
+     "-no-triage", Arg.Unit F._no_triage, " Skip triage fixes when using Seminal search";
      "-thread", Arg.Unit F._thread, " Generate code that supports the system threads library";
      "-unsafe", Arg.Unit F._unsafe,
             " No bounds checking on array and string access";
***************
*** 145,150 ****
--- 150,156 ----
             " Print location of standard library and exit";
      "-nopervasives", Arg.Unit F._nopervasives, " (undocumented)";
      "-dparsetree", Arg.Unit F._dparsetree, " (undocumented)";
+     "-dprintcode", Arg.Unit F._dprintcode, " (undocumented)";
      "-drawlambda", Arg.Unit F._drawlambda, " (undocumented)";
      "-dlambda", Arg.Unit F._dlambda, " (undocumented)";
      "-dinstr", Arg.Unit F._dinstr, " (undocumented)";
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/driver/main_args.mli seminalOcaml/driver/main_args.mli
*** ocaml-3.08.4/driver/main_args.mli	2003-07-17 01:38:27.000000000 -0700
--- seminalOcaml/driver/main_args.mli	2009-01-19 09:37:59.327901864 -0800
***************
*** 56,61 ****
--- 56,64 ----
  
        val _nopervasives : unit -> unit
        val _dparsetree : unit -> unit
+       val _dprintcode : unit -> unit
+       val _use_seminal : unit -> unit
+       val _no_triage : unit -> unit
        val _drawlambda : unit -> unit
        val _dlambda : unit -> unit
        val _dinstr : unit -> unit
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/driver/main.ml seminalOcaml/driver/main.ml
*** ocaml-3.08.4/driver/main.ml	2004-06-13 05:46:41.000000000 -0700
--- seminalOcaml/driver/main.ml	2009-01-19 09:37:59.935889236 -0800
***************
*** 125,130 ****
--- 125,133 ----
    let _verbose = set verbose
    let _nopervasives = set nopervasives
    let _dparsetree = set dump_parsetree
+   let _dprintcode = set dump_printcode
+   let _use_seminal = set use_seminal
+   let _no_triage = set no_triage
    let _drawlambda = set dump_rawlambda
    let _dlambda = set dump_lambda
    let _dinstr = set dump_instr
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/driver/optcompile.ml seminalOcaml/driver/optcompile.ml
*** ocaml-3.08.4/driver/optcompile.ml	2004-06-13 05:46:41.000000000 -0700
--- seminalOcaml/driver/optcompile.ml	2009-01-19 09:37:56.391962219 -0800
***************
*** 56,61 ****
--- 56,62 ----
      let ast =
        Pparse.file ppf inputfile Parse.interface ast_intf_magic_number in
      if !Clflags.dump_parsetree then fprintf ppf "%a@." Printast.interface ast;
+     if !Clflags.dump_printcode then fprintf ppf "%a@." Printcode.interface ast;
      let sg = Typemod.transl_signature (initial_env()) ast in
      if !Clflags.print_types then
        fprintf std_formatter "%a@." Printtyp.signature
***************
*** 88,97 ****
--- 89,100 ----
      if !Clflags.print_types then ignore(
        Pparse.file ppf inputfile Parse.implementation ast_impl_magic_number
        ++ print_if ppf Clflags.dump_parsetree Printast.implementation
+       ++ print_if ppf Clflags.dump_printcode Printcode.implementation
        ++ Typemod.type_implementation sourcefile outputprefix modulename env)
      else begin
        Pparse.file ppf inputfile Parse.implementation ast_impl_magic_number
        ++ print_if ppf Clflags.dump_parsetree Printast.implementation
+       ++ print_if ppf Clflags.dump_printcode Printcode.implementation
        ++ Typemod.type_implementation sourcefile outputprefix modulename env
        ++ Translmod.transl_store_implementation modulename
        +++ print_if ppf Clflags.dump_rawlambda Printlambda.lambda
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/driver/optmain.ml seminalOcaml/driver/optmain.ml
*** ocaml-3.08.4/driver/optmain.ml	2004-06-13 05:46:41.000000000 -0700
--- seminalOcaml/driver/optmain.ml	2009-01-19 09:37:56.459960835 -0800
***************
*** 176,181 ****
--- 176,182 ----
  
         "-nopervasives", Arg.Set nopervasives, " (undocumented)";
         "-dparsetree", Arg.Set dump_parsetree, " (undocumented)";
+        "-dprintcode", Arg.Set dump_printcode, " (undocumented)";
         "-drawlambda", Arg.Set dump_rawlambda, " (undocumented)";
         "-dlambda", Arg.Set dump_lambda, " (undocumented)";
         "-dcmm", Arg.Set dump_cmm, " (undocumented)";
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/driver/seminal.ml seminalOcaml/driver/seminal.ml
*** ocaml-3.08.4/driver/seminal.ml	1969-12-31 16:00:00.000000000 -0800
--- seminalOcaml/driver/seminal.ml	2009-01-19 09:37:56.583958258 -0800
***************
*** 0 ****
--- 1,5006 ----
+ open Misc
+ open Config
+ open Format
+ open Parsetree
+ open Location
+ open Lexing
+ open Warnings
+ 
+    
+ (* XXXXXXXXXXXXXXXX Temporary functions until main work complete XXXXXXXXXXX *)
+ let time_delta t2 t1 =
+   let df = t2 -. t1 in
+   let di = int_of_float df in
+   let s = di mod 60 in
+   let m = (di / 60) mod 60 in
+   let h = (di / 3600) in
+   let frac = int_of_float (10000000. *. fst (modf df)) in
+   Printf.sprintf "%02d:%02d:%02d.%07d" h m s frac
+ 
+ let timeFns = ref [];;
+ let timeFn fn incrfun =
+   let sTime = Sys.time() in 
+   let (eTime, ans) =
+     try 
+       let ans = fn () in
+       let eTime = Sys.time() in 
+       timeFns := (sTime, eTime) :: !timeFns;
+       incrfun (eTime -. sTime);
+       (eTime, ans)
+     with x -> 
+       let eTime = Sys.time() in 
+       timeFns := (sTime, eTime) :: !timeFns;
+       incrfun (eTime -. sTime);
+       raise x
+   in (ans, eTime -. sTime, (time_delta eTime sTime))
+ 
+ let mock_report_error exn =
+   let ppf = str_formatter in 
+   let rec report ppf = function 
+     | Typecore.Error(loc, err) ->
+         Location.print ppf loc; Typecore.report_error ppf err
+     | Typetexp.Error(loc, err) ->
+         Location.print ppf loc; Typetexp.report_error ppf err
+     | Typedecl.Error(loc, err) ->
+         Location.print ppf loc; Typedecl.report_error ppf err
+     | Typeclass.Error(loc, err) ->
+         Location.print ppf loc; Typeclass.report_error ppf err
+     | Includemod.Error err ->
+         Includemod.report_error ppf err
+     | Typemod.Error(loc, err) ->
+         Location.print ppf loc; Typemod.report_error ppf err
+     | x -> fprintf ppf "@]" in
+   
+   fprintf ppf "@[%a@]@." report exn
+ 
+ 
+ 
+ let rec fmt_longident_aux f x =
+   match x with
+   | Longident.Lident (s) -> fprintf f "%s" s;
+   | Longident.Ldot (y, s) -> fprintf f "%a.%s" fmt_longident_aux y s;
+   | Longident.Lapply (y, z) ->
+       fprintf f "%a(%a)" fmt_longident_aux y fmt_longident_aux z;
+ ;;
+ 
+ let fmt_longident f x = fprintf f "%a" fmt_longident_aux x;;
+ 
+ let longidentToStr id = fmt_longident str_formatter id; flush_str_formatter ()
+ let rec strToLongident str =
+   let splitAtParens str =
+     try 
+       if str = "" then (false, "", "") else
+       let strlen = String.length str in
+       if (str.[strlen-1] <> ')') then
+         (false, str, "")
+       else 
+         let parenCount = ref 1 in
+         let lastParenIdx = ref 0 in
+         for i = strlen-2 downto 0 do
+           if (str.[i] = '(') then decr parenCount
+           else if (str.[i] = ')') then incr parenCount;
+           if (!parenCount = 0 && !lastParenIdx < i) then lastParenIdx := i
+         done;
+         let leftsub = try String.sub str 0 !lastParenIdx with _ -> "" in
+         let rightsub = try String.sub str (!lastParenIdx + 1) (strlen - !lastParenIdx - 2) with _ -> "" in
+         (true, leftsub, rightsub)
+     with Invalid_argument _ ->(false, str, "") in
+   let splitAtPeriod str =
+     try
+       if str = "" then (false, "", "") else
+       let strlen = String.length str in
+       let lastPeriodIdx = try String.rindex str '.' with Not_found -> strlen in
+       if (lastPeriodIdx < strlen) then 
+         let leftsub = try String.sub str 0 lastPeriodIdx with _ -> "" in
+         let rightsub = try String.sub str (lastPeriodIdx + 1) (strlen - lastPeriodIdx - 1) with _ -> "" in
+         (true, leftsub, rightsub)
+       else
+         (false, str, "") 
+     with Invalid_argument _ -> (false, str, "") in
+   let (resParen, lparen, rparen) = splitAtParens str in
+   if resParen then
+     Longident.Lapply (strToLongident lparen, strToLongident rparen)
+   else
+     let (resPeriod, lperiod, rperiod) = splitAtPeriod str in
+     if resPeriod then
+       Longident.Ldot (strToLongident lperiod, rperiod)
+     else 
+       Longident.Lident str
+ 
+ 
+ 
+ (*XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ 
+ 
+ 
+ exception TooManyErrors
+ exception FixedErrors of exn list
+ 
+ let locNone = ref { loc_start = {Lexing.dummy_pos with pos_cnum = -3} ; 
+                     loc_end =   {Lexing.dummy_pos with pos_cnum = -2} ; 
+                     loc_ghost = true }
+ 
+ let locBefore loc1 loc2 = (* loc1 before loc2 *)
+   (loc1.loc_end.pos_cnum <= loc2.loc_end.pos_cnum)
+ 
+ let locAfter loc1 loc2 = (* loc1 after loc2 *)
+   (loc1.loc_start.pos_cnum >= loc2.loc_start.pos_cnum)
+ 
+ let locOverlap loc1 loc2 =
+   (loc1.loc_start.pos_cnum <= loc2.loc_end.pos_cnum ||
+    loc2.loc_start.pos_cnum <= loc1.loc_end.pos_cnum)
+ 
+ let locInside loc1 loc2 = (* loc1 inside loc2 *)
+   (loc1.loc_start.pos_cnum >= loc2.loc_start.pos_cnum &&
+    loc1.loc_end.pos_cnum <= loc2.loc_end.pos_cnum)
+ 
+ let locLen loc = loc.loc_end.pos_cnum - loc.loc_start.pos_cnum
+ 
+ let locJoin loc1 loc2 = (* smallest location containing both loc1 and loc2 *)
+   if loc1 = !locNone then loc2 else
+   if loc2 = !locNone then loc1 else
+   let lS = if (locBefore loc1 loc2) then loc1.loc_start else loc2.loc_start in
+   let lE = if (locAfter loc1 loc2) then loc1.loc_end else loc2.loc_end in
+   let lG = loc1.loc_ghost && loc2.loc_ghost in
+   {loc_start = lS; loc_end = lE; loc_ghost = lG}
+ 
+ let locSub loc1 loc2 = 
+   if (locAfter loc2 loc1) then
+     if (loc2.loc_start.pos_cnum < loc1.loc_end.pos_cnum) then
+       {loc1 with loc_end = loc2.loc_start}
+     else loc1
+   else loc1
+ 
+ let sourceFromLoc loc =
+   if (loc.loc_start.pos_fname = "") then 
+     (print_string "Something is really really wrong!!\n"; ">>Error: no filename given!<<")
+   else
+   let ic = open_in loc.loc_start.pos_fname in
+   let n = (loc.loc_end.pos_cnum - loc.loc_start.pos_cnum) in 
+   if (n <= 0) then "" else
+   let src = String.create n in 
+   seek_in ic (loc.loc_start.pos_cnum); 
+   Pervasives.really_input ic src 0 n;
+   close_in ic;
+   src
+ 
+ (* Constructs generic instances of each syntactic category. *)
+ let alphaStr = []
+ let alphaSig = []
+ let alphaExp exnName loc =
+   let expRaise = { pexp_desc = Pexp_ident (Longident.parse "Pervasives.raise"); pexp_loc = loc } in
+   let expExn = { pexp_desc = Pexp_construct (Longident.parse ("SEMINAL_" ^ exnName), None, false); pexp_loc = loc } 
+   in { pexp_desc = Pexp_apply (expRaise, [ ("", expExn) ] ); pexp_loc = loc }
+ let alphaPat loc = { ppat_desc = Ppat_any; ppat_loc = loc }
+ let alphaTyp =   
+   let tyCount = ref 0 in
+   let alphaTy loc = 
+     tyCount := !tyCount + 1; 
+     { ptyp_desc = Ptyp_var ("SEMINAL_" ^ (string_of_int !tyCount)); ptyp_loc = loc }
+   in alphaTy
+ let alphaStritem exnName loc = { pstr_desc = Pstr_eval(alphaExp exnName loc); pstr_loc = loc }
+ let alphaMod loc = { pmod_desc = Pmod_structure(alphaStr); pmod_loc = loc }
+ let alphaModty loc = { pmty_desc = Pmty_signature(alphaSig); pmty_loc = loc }
+ let alphaTydec loc = { ptype_params = []; ptype_cstrs = []; ptype_kind = Ptype_abstract; ptype_manifest = None; ptype_variance = []; ptype_loc = loc }
+ let alphaClsig loc = (alphaTyp loc, [])
+ let alphaClinfo a loc = { pci_virt = Asttypes.Virtual; pci_params = ([], Location.none); pci_name = "SEMINAL_BOGUS"; pci_expr = a; pci_variance = []; pci_loc = loc }
+ let alphaClty loc = { pcty_desc = Pcty_signature(alphaClsig loc); pcty_loc = loc }
+ let alphaCldec loc = (alphaClinfo alphaClty loc)
+ let alphaCltydec loc = (alphaClinfo alphaClty loc)
+ 
+ 
+ 
+ 
+ 
+ 
+ (* constructs a nullary exception declaration of the given name *)
+ let globalPrologue = ref []
+ let declareException exnName : Parsetree.structure =
+   let newexn = 
+   { pstr_desc = Pstr_exception (("SEMINAL_" ^ exnName), []);
+     pstr_loc = !locNone } in
+   if (not (List.exists (fun s -> s = newexn) !globalPrologue)) then
+     globalPrologue := newexn :: !globalPrologue;
+   []
+ 
+ (* inline function composition *)
+ let (<<==) f g = function x -> f(g(x))
+ 
+ (* splits list before nth element -- tail-recursive *)
+ let splitAt n lst = 
+   let rec splitAcc frontAccRev n lst =
+     match (lst, n) with
+       ([], _) -> (List.rev frontAccRev, [])
+     | (back, i) when (i <= 0) -> (List.rev frontAccRev, back)
+     | (hd :: tl, i) -> splitAcc (hd :: frontAccRev) (i-1) tl
+   in splitAcc [] n lst
+ 
+ (* swaps a single item of a list for a new value -- tail-recursive *)
+ let replaceNthWith lst n item = 
+   let rec replaceNthAcc accRev lst n item =
+     match (lst, n) with 
+       ([], _) -> List.rev accRev
+     | (hd :: tl, 0) -> List.rev_append accRev (item :: tl)
+     | (hd :: tl, i) -> replaceNthAcc (hd :: accRev) tl (i-1) item
+   in replaceNthAcc [] lst n item
+ 
+ (* removes the nth item -- tail-recursive *)
+ let removeNth n lst =
+   match splitAt n lst with
+     (front, []) -> front
+   | (front, nth :: back) -> List.rev_append (List.rev front) back
+ 
+ (* inserts an item at position n -- tail-recursive *)
+ let insertNth lst n item =
+   let (front, back) = splitAt n lst in List.rev_append (List.rev front) (item :: back)
+ 
+ (* returns the list [0..n-1] -- tail-recursive *)
+ let tabulate n = 
+   let rec tabAcc acc n i =
+     if (i > n) then acc else tabAcc ((n-i) :: acc) n (i+1)
+   in tabAcc [] n 1
+ 
+ (* fold_left, carrying a counter argument -- tail-recursive *)
+ let fold_left_n f accu l =
+   let rec aux n accu l =
+   match l with
+     [] -> accu
+   | a::l -> aux (n+1) (f n accu a) l in
+   aux 0 accu l
+ 
+ (* applies (f : int -> 'a -> 'b) to each element of l -- tail-recursive 
+  * n is the zero-based position of the element a in the list l *)
+ let map_at f l =
+   let rec aux accu n l =
+     match l with
+       [] -> List.rev accu
+     | a::l -> let r = f n a in aux (r::accu) (n+1) l in
+   aux [] 0 l
+ 
+ (* applies (f : int -> 'a option -> 'b) to each gap between elements of l
+  * including before the first element, and after the last element 
+  * n is the zero-based index before element a in list l -- tail-recursive *)
+ let map_between f l =
+   let rec aux accu n l =
+     match l with
+       [] -> List.rev ((f n None) :: accu)
+     | a::l -> let r = f n (Some a) in aux (r::accu) (n+1) l in
+   aux [] 0 l
+ 
+ (* map, with a count instead of the argument -- tail-recursive *)
+ let map_c f l =
+   map_at (fun n x -> f n) l
+ 
+ 
+ (* List.flatten (mapper f l) -- tail-recursive *)
+ let mapper_and_flatten mapper f l =
+   let flatten_and_rev l =
+     let rec aux2 innerlist acc =
+       match innerlist with
+         [] -> acc
+       | hd::tl -> aux2 tl (hd::acc) in
+     let rec aux1 outerlist acc =
+       match outerlist with
+         [] -> acc
+       | hd::tl -> aux1 tl (aux2 hd acc) in
+     aux1 l [] in
+   List.rev (flatten_and_rev (mapper f l))
+ 
+ (* List.flatten (List.map f l) -- tail-recursive *)
+ let map_and_flatten f l = mapper_and_flatten List.map f l
+ 
+ (* List.flatten (map_n f l) -- tail-recursive *)
+ let map_at_and_flatten f l = mapper_and_flatten map_at f l
+ 
+ (* List.flatten (map_between f l) -- tail-recursive *)
+ let map_between_and_flatten f l = mapper_and_flatten map_between f l
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ (* XXXXXXXXXXXXXXXXXXXXXX  Modifications Data Type  XXXXXXXXXXXXXXXXXX *)
+ exception DynamicTypeError
+ type astThing =
+     Exp of expression
+   | StrItem of structure_item
+   | Str of structure
+   | Pat of pattern
+   | Typ of core_type
+   | Mod of module_expr
+   | Modty of module_type
+   | Tydec of type_declaration
+   | Cldec of class_declaration 
+   | Cldesc of class_description
+   | Cltydec of class_type_declaration
+   | Clfield of class_field
+   | Clexp of class_expr
+   | Sigitem of signature_item
+   | Clty of class_type
+   | Cltyfield of class_type_field
+ and astContext = astThing -> astThing
+ and descent = astThing * astContext         (* hole to explore, context to typecheck it in *)
+ and followups = unit -> (astMod list)
+ and fallbacks = unit -> (astMod list)
+ and elision = astThing * (astThing -> astThing) * (astThing -> astThing) * astContext * (astThing -> astContext)
+             (* hole  * adapt hole to parent * knockout hole in parent * ideal context * put hole back in some parent *)
+ and singlerepl = {trep_prologue : Parsetree.structure; (* Any additional code needed to construct _ values *)
+                   trep_revision : (unit -> astThing);  (* what to replace the current astNode with *)
+                   trep_replaced : astThing;            (* what was replaced *)
+                   trep_validate : (unit -> bool);      (* whether this modification is valid or not *)
+                   trep_desc     : string;              (* diagnostic message *)
+                   trep_tag      : int;                 (* tag for comparing same modifications *)
+                   trep_loc      : Location.t;          (* error location *)
+                   trep_type     : typedTreeType}       (* TypedAst type, if any *)
+ and triagerepl = {ttri_prologue : Parsetree.structure;    (* Any additonal code to construct the repair *)
+                   ttri_idealctx : (astThing -> astThing); (* idealized context from triaging all expressions -- triage change == ttri_idealctx(ttri_replaced.trep_revision()) *)
+                   ttri_triaged  : astThing list;          (* all the expressions which were triaged *)
+                   ttri_adapted  : astThing list;          (* all the expressions which were adapted *)
+                   ttri_original : astThing;               (* original parent node of all triaged parts *)
+                   ttri_desc     : string;                 (* diagnostic message *)
+                   ttri_tag      : int;                    (* tag for comparing same modifications *)
+                   ttri_locs     : Location.t list;        (* locations of all triaged expressions *)
+                   ttri_replaced : singlerepl}             (* after triage, what change was needed? *)
+ and astMod =
+   | Attempt of astMod list * followups * fallbacks
+   | TriggerSingle of descent
+   | TriggerMulti of descent
+   | TriggerTriage of descent
+   | SingleRecur of descent
+   | SingleReplace of singlerepl
+   | TriageElide of (astThing * astThing list * elision list) list
+ and replacement = 
+   | SingleRepl of singlerepl
+   | TriageRepl of triagerepl
+ and typedTreeType = 
+     SimpleType of Types.type_expr 
+   | ClassType of Types.class_type
+   | ModType of Types.module_type
+   | NoType
+ and searchResults = (replacement * (astContext * astContext * astContext)) list                       (* outerCtx, searchCtx, displayCtx *)
+ 
+ let spf = ref (fun a -> ())
+ let sp () = !spf
+ let toExp       a : expression             = match a with Exp x -> x | _ -> sp () a; raise DynamicTypeError
+ let toStrItem   a : structure_item         = match a with StrItem x -> x | _ -> sp () a; raise DynamicTypeError
+ let toStr       a : structure              = match a with Str x -> x | _ -> sp () a; raise DynamicTypeError
+ let toPat       a : pattern                = match a with Pat x -> x | _ -> sp () a; raise DynamicTypeError
+ let toTyp       a : core_type              = match a with Typ x -> x | _ -> sp () a; raise DynamicTypeError
+ let toMod       a : module_expr            = match a with Mod x -> x | _ -> sp () a; raise DynamicTypeError
+ let toModty     a : module_type            = match a with Modty x -> x | _ -> sp () a; raise DynamicTypeError
+ let toTydec     a : type_declaration       = match a with Tydec x -> x | _ -> sp () a; raise DynamicTypeError
+ let toCldec     a : class_declaration      = match a with Cldec x -> x | _ -> sp () a; raise DynamicTypeError
+ let toCldesc    a : class_description      = match a with Cldesc x -> x | _ -> sp () a; raise DynamicTypeError
+ let toCltydec   a : class_type_declaration = match a with Cltydec x -> x | _ -> sp () a; raise DynamicTypeError
+ let toClfield   a : class_field            = match a with Clfield x -> x | _ -> sp () a; raise DynamicTypeError
+ let toClexp     a : class_expr             = match a with Clexp x -> x | _ -> sp () a; raise DynamicTypeError
+ let toSigitem   a : signature_item         = match a with Sigitem x -> x | _ -> sp () a; raise DynamicTypeError
+ let toClty      a : class_type             = match a with Clty x -> x | _ -> sp () a; raise DynamicTypeError
+ let toCltyfield a : class_type_field       = match a with Cltyfield x -> x | _ -> sp () a; raise DynamicTypeError
+ 
+ 
+ let noFollowups (_ : unit) = []      (* for use in the new types of modifications *)
+ let noFallbacks (_ : unit) = []      (* for use in the new types of modifications *)
+ let alwaysValid _ = true             (* for use in the new types of modifications *)
+ let neverValid _  = false            (* for use in the new types of modifications *)
+ 
+ let validations = ref []
+ let registerValidate astThing fn = validations := (astThing, fn) :: !validations
+ 
+ let numClosures = ref 0
+ 
+ let followup a f                   = Attempt(a, f, noFallbacks)
+ 
+ let recurStritemStr (s, ctx)       = incr numClosures; SingleRecur(StrItem s, (fun x -> Str (ctx (toStrItem x))))
+ let replaceStr a p s v d t l       = incr numClosures; SingleReplace({trep_prologue = p; trep_revision = (fun () -> Str (s ())); trep_replaced = a; trep_validate = v; trep_desc = d; trep_tag = t; trep_loc = l; trep_type = NoType})
+ 
+ let recurExpStritem (e, ctx)       = incr numClosures; SingleRecur((Exp e, (fun x -> StrItem (ctx (toExp x)))))
+ let recurPatStritem (p, ctx)       = incr numClosures; SingleRecur((Pat p, (fun x -> StrItem (ctx (toPat x)))))
+ let recurTypStritem (t, ctx)       = incr numClosures; SingleRecur((Typ t, (fun x -> StrItem (ctx (toTyp x)))))
+ let recurTypdecStritem (t, ctx)    = incr numClosures; SingleRecur((Tydec t, (fun x -> StrItem (ctx (toTydec x)))))
+ let recurModStritem (m, ctx)       = incr numClosures; SingleRecur((Mod m, (fun x -> StrItem (ctx (toMod x)))))
+ let recurModtyStritem (m, ctx)     = incr numClosures; SingleRecur((Modty m, (fun x -> StrItem (ctx (toModty x)))))
+ let recurCldecStritem (c, ctx)     = incr numClosures; SingleRecur((Cldec c, (fun x -> StrItem (ctx (toCldec x)))))
+ let recurCltydecStritem (c, ctx)   = incr numClosures; SingleRecur((Cltydec c, (fun x -> StrItem (ctx (toCltydec x)))))
+ let replaceStritem a p s v d t l   = incr numClosures; SingleReplace({trep_prologue = p; trep_revision = (fun () -> StrItem (s ())); trep_replaced = a; trep_validate = v; trep_desc = d; trep_tag = t; trep_loc = l; trep_type = NoType})
+ 
+ let recurExpExp (e, ctx)           = incr numClosures; SingleRecur((Exp e, (fun x -> Exp (ctx (toExp x)))))
+ let recurPatExp (p, ctx)           = incr numClosures; SingleRecur((Pat p, (fun x -> Exp (ctx (toPat x)))))
+ let recurModExp (m, ctx)           = incr numClosures; SingleRecur((Mod m, (fun x -> Exp (ctx (toMod x)))))
+ let recurTypExp (t, ctx)           = incr numClosures; SingleRecur((Typ t, (fun x -> Exp (ctx (toTyp x)))))
+ let replaceExp a p e v d t l       = incr numClosures; SingleReplace({trep_prologue = p; trep_revision = (fun () -> Exp (e ())); trep_replaced = a; trep_validate = v; trep_desc = d; trep_tag = t; trep_loc = l; trep_type = NoType})
+ 
+ let recurTypTypdec (t, ctx)        = incr numClosures; SingleRecur((Typ t, (fun x -> Tydec (ctx (toTyp x)))))
+ let replaceTypdec a p t v d t' l   = incr numClosures; SingleReplace({trep_prologue = p; trep_revision = (fun () -> Tydec (t ())); trep_replaced = a; trep_validate = v; trep_desc = d; trep_tag = t'; trep_loc = l; trep_type = NoType})
+ 
+ let recurTypTyp (t, ctx)           = incr numClosures; SingleRecur((Typ t, (fun x -> Typ (ctx (toTyp x)))))
+ let replaceTyp a p t v d t' l      = incr numClosures; SingleReplace({trep_prologue = p; trep_revision = (fun () -> Typ (t ())); trep_replaced = a; trep_validate = v; trep_desc = d; trep_tag = t'; trep_loc = l; trep_type = NoType})
+ 
+ let recurStrMod (s, ctx)           = incr numClosures; SingleRecur((Str s, (fun x -> Mod (ctx (toStr x)))))
+ let recurModMod (m, ctx)           = incr numClosures; SingleRecur((Mod m, (fun x -> Mod (ctx (toMod x)))))
+ let recurModtyMod (m, ctx)         = incr numClosures; SingleRecur((Modty m, (fun x -> Mod (ctx (toModty x)))))
+ let replaceMod a p m v d t l       = incr numClosures; SingleReplace({trep_prologue = p; trep_revision = (fun () -> Mod (m ())); trep_replaced = a; trep_validate = v; trep_desc = d; trep_tag = t; trep_loc = l; trep_type = NoType})
+ 
+ let recurPatPat (p, ctx)           = incr numClosures; SingleRecur((Pat p, (fun x -> Pat (ctx (toPat x)))))
+ let recurTypPat (t, ctx)           = incr numClosures; SingleRecur((Typ t, (fun x -> Pat (ctx (toTyp x)))))
+ let replacePat a p' p v d t l      = incr numClosures; SingleReplace({trep_prologue = p'; trep_revision = (fun () -> Pat (p ())); trep_replaced = a; trep_validate = v; trep_desc = d; trep_tag = t; trep_loc = l; trep_type = NoType})
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ 
+ 
+ 
+ 
+ 
+ let rec astRevisionName a =
+   let nameOf a =
+     match a with
+       Exp _ -> "Exp"
+     | StrItem _ -> "Stritem"
+     | Str _ -> "Str"
+     | Pat _ -> "Pat"
+     | Typ _ -> "Typ"
+     | Mod _ -> "Mod"
+     | Modty _ -> "Modty"
+     | Tydec _ -> "Tydec"
+     | Cldec _ -> "Cldec"
+     | Cldesc _ -> "Cldesc"
+     | Cltydec _ -> "Cltydec"
+     | Clfield _ -> "Clfield"
+     | Clexp _ -> "Clexp"
+     | Sigitem _ -> "Sigitem" 
+     | Clty _ -> "Clty" 
+     | Cltyfield _ -> "Cltyfield" in
+   match a with
+   | TriggerSingle (hole, ctx) -> "triggersingle" ^ (nameOf hole) ^ (nameOf (ctx hole))
+   | TriggerMulti (hole, ctx) -> "triggermulti" ^ (nameOf hole) ^ (nameOf (ctx hole))
+   | TriggerTriage (hole, ctx) -> "triggertriage" ^ (nameOf hole) ^ (nameOf (ctx hole))
+   | Attempt (a, _, _) -> "attempt(" ^ (List.fold_left (fun accu a -> accu ^ "," ^ (astRevisionName a)) "" a) ^ ")"
+   | SingleRecur (hole, ctx) -> "singlerecur" ^ (nameOf hole) ^ (nameOf (ctx hole))
+   | SingleReplace rep -> "singlereplace" ^ (nameOf (rep.trep_revision ()))
+   | TriageElide phases -> "triageelide(" ^ (string_of_int (List.length phases)) ^ "phases)"
+ 
+ 
+ module TagMap = Map.Make(struct type t = string let compare = compare end)
+ let modTags = ref TagMap.empty
+ let nextTag = ref 0
+ let t tag = try (TagMap.find tag !modTags) with Not_found -> (incr nextTag; modTags := TagMap.add tag !nextTag !modTags; !nextTag)
+ 
+    
+ let shouldTryFix phraseLoc locOpt =
+   match locOpt with
+     None -> true
+   | Some loc -> (* locInside loc phraseLoc *) true
+         
+ 
+ 
+ 
+ 
+ 
+ 
+ (* XXXXXXXXXXXXXXX Print modification in context of AST XXXXXXXXXXXXXXXXXXX *)
+ type contextList = astContext array
+ let makeContext len = Array.make len (fun x -> x)
+ let narrowContext oldCtx innerCtx =
+   Array.init (Array.length oldCtx)
+     (fun idx -> if idx = 0 then innerCtx else oldCtx.(idx-1) <<== innerCtx)
+ let widestContext ctx = ctx.(Array.length ctx - 1)
+ 
+ 
+ let print_exp = Printcode.expression std_formatter
+ let print_stritem = Printcode.stritem std_formatter
+ let print_str = Printcode.implementation std_formatter
+ let print_pat = Printcode.pattern std_formatter
+ let print_typ = Printcode.coretype std_formatter
+ let print_mod = Printcode.modexp std_formatter
+ let print_modty = Printcode.modtyp std_formatter
+ let print_tydec = Printcode.tydec std_formatter
+ let print_cldec = Printcode.cldec std_formatter
+ let print_cldesc = Printcode.cldesc std_formatter
+ let print_cltydec = Printcode.cltydec std_formatter
+ let print_clfield = Printcode.classfld std_formatter
+ let print_clexp = Printcode.clexp std_formatter
+ let print_sigitem = Printcode.sigitem std_formatter
+ let print_clty = Printcode.clty std_formatter
+ let print_cltf = Printcode.cltf std_formatter
+ 
+ let smartPrintTo stream astThing =
+   (match astThing with
+     Exp exp -> Printcode.expression stream exp
+   | StrItem strItem -> Printcode.stritem stream strItem
+   | Str str -> Printcode.implementation stream str
+   | Pat pat -> Printcode.pattern stream pat
+   | Typ typ -> Printcode.coretype stream typ
+   | Mod md -> Printcode.modexp stream md
+   | Modty mty -> Printcode.modtyp stream mty
+   | Tydec tyd -> Printcode.tydec stream tyd
+   | Cldec cld -> Printcode.cldec stream cld
+   | Cldesc cld -> Printcode.cldesc stream cld
+   | Cltydec ctd -> Printcode.cltydec stream ctd
+   | Clfield clf -> Printcode.classfld stream clf
+   | Clexp cle -> Printcode.clexp stream cle
+   | Sigitem sit -> Printcode.sigitem stream sit
+   | Clty clt -> Printcode.clty stream clt
+   | Cltyfield cltf -> Printcode.cltf stream cltf)
+ let smartPrint astThing =
+   (smartPrintTo std_formatter astThing;
+    print_string "\n===============\n")
+ let smartPrintTypeTo stream astType =
+   match astType with
+     SimpleType t -> Printtyp.type_expr stream t
+   | ClassType t -> Printtyp.class_type stream t
+   | ModType t -> Printtyp.modtype stream t
+   | NoType -> fprintf stream "No type\n"
+ let smartPrintType = smartPrintTypeTo std_formatter;;
+ spf := (fun x -> print_string "Type error!! "; smartPrint x);;
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ (* XXXXXXXXXXXXXXXXXXXXXX Convert AST to uniform AST XXXXXXXXXXXXXXXXXXXXXX *)
+ module ASTMap = Map.Make(struct type t = astThing let compare = compare end)
+ type 'a uniformAST = { past_data : 'a;
+                        past_node : astThing;
+                        past_idxs : int ASTMap.t;
+                        past_kids : 'a uniformAST list
+                      }
+ let rec convertUniform (f : astThing -> 'a) (ast : astThing) : 'a uniformAST =
+   let emptyUniformAST = { past_data = f (Str []); past_node = Str []; past_idxs = ASTMap.empty; past_kids = []} in
+   let indexList lst = 
+     fold_left_n (fun idx accu item -> ASTMap.add item idx accu) (ASTMap.empty) lst in
+   let buildUniformAST childList = 
+     { past_data = f ast;
+       past_node = ast;
+       past_idxs = indexList childList;
+       past_kids = List.map (convertUniform f) childList } in
+   match ast with 
+     Str str -> 
+       begin
+         let strList = List.map (fun x -> StrItem x) str in
+         buildUniformAST strList
+       end
+   | StrItem stritem ->
+       begin
+         let flatPElist peList = List.flatten 
+             (List.fold_right (fun (p,e) accu -> [Pat p; Exp e] :: accu) peList []) in
+         match stritem.pstr_desc with
+           Pstr_eval e -> buildUniformAST [ Exp e ]
+         | Pstr_value(rec_flag, peList) -> buildUniformAST (flatPElist peList)
+         | Pstr_primitive(prim, value_desc) -> buildUniformAST [ Typ value_desc.pval_type ]
+         | Pstr_type tytydecList -> 
+             let tydecList = List.map (fun (tyname, tydec) -> Tydec tydec) tytydecList in
+             buildUniformAST tydecList
+         | Pstr_exception (exn, exDec) -> 
+             let exndec = List.map (fun x -> Typ x) exDec in
+             buildUniformAST exndec
+         | Pstr_exn_rebind (str, id) -> buildUniformAST []
+         | Pstr_module (str, modexp) -> buildUniformAST [ Mod modexp ]
+         | Pstr_recmodule strModtyModexpList -> 
+             let flatmtymexpList = List.flatten
+                 (List.fold_right (fun (s, mty, md) accu -> [Modty mty; Mod md] :: accu) strModtyModexpList []) in
+             buildUniformAST flatmtymexpList
+         | Pstr_modtype (str, mty) -> buildUniformAST [ Modty mty ]
+         | Pstr_open id -> buildUniformAST []
+         | Pstr_class cldecList -> 
+             let cldecs = List.map (fun x -> Cldec x) cldecList in
+             buildUniformAST cldecs
+         | Pstr_class_type cltydecList -> 
+             let cltydecs = List.map (fun x -> Cltydec x) cltydecList in
+             buildUniformAST cltydecs
+         | Pstr_include md -> buildUniformAST [ Mod md ]
+       end
+   | Tydec tyd ->
+       begin
+         let cstrs = List.flatten
+             (List.fold_right (fun (t1, t2, l) accu -> [Typ t1; Typ t2] :: accu) tyd.ptype_cstrs []) in
+         let tykinds = 
+           match tyd.ptype_kind with
+             Ptype_abstract -> []
+           | Ptype_variant (strtyList, _) -> List.flatten
+                 (List.fold_right (fun (_, tyList) accu -> (List.map (fun ty -> Typ ty) tyList) :: accu) strtyList [])
+           | Ptype_record (strmuttyList, _) -> List.fold_right (fun (_, _, ty) accu -> (Typ ty) :: accu) strmuttyList [] in
+         let manifest = match tyd.ptype_manifest with None -> [] | Some t -> [Typ t] in
+         buildUniformAST (cstrs @ tykinds @ manifest)
+       end
+   | Pat pat ->
+       begin
+         match pat.ppat_desc with
+           Ppat_any -> buildUniformAST []
+         | Ppat_var str -> buildUniformAST []
+         | Ppat_alias (pat, str) -> buildUniformAST [ Pat pat ]
+         | Ppat_constant c -> buildUniformAST []
+         | Ppat_tuple pList -> 
+             let patList = (List.map (fun x -> Pat x) pList) in
+             buildUniformAST patList
+         | Ppat_construct (id, pOpt, b) ->
+             let p = match pOpt with None -> [] | Some pat -> [ Pat pat ] in
+             buildUniformAST p
+         | Ppat_variant (lab, pOpt) ->
+             let p = match pOpt with None -> [] | Some pat -> [ Pat pat ] in
+             buildUniformAST p
+         | Ppat_record idpatList ->
+             let patList = (List.map (fun (id, p) -> Pat p) idpatList) in
+             buildUniformAST patList
+         | Ppat_array pList -> 
+             let patList = (List.map (fun x -> Pat x) pList) in
+             buildUniformAST patList
+         | Ppat_or (p1, p2) -> buildUniformAST [ Pat p1; Pat p2 ]
+         | Ppat_constraint (p, ty) -> buildUniformAST [ Pat p; Typ ty ]
+         | Ppat_type id -> buildUniformAST []
+       end
+   | Exp exp ->
+       begin
+         let flatPElist peList = List.flatten 
+             (List.fold_right (fun (p,e) accu -> [Pat p; Exp e] :: accu) peList []) in
+         match exp.pexp_desc with
+           Pexp_ident id -> buildUniformAST []
+         | Pexp_constant c -> buildUniformAST []
+         | Pexp_let (recf, peList, e) -> 
+             let pes = flatPElist peList in
+             buildUniformAST ( pes @ [ Exp e ] )
+         | Pexp_function (lab, eOpt, peList) ->
+             let pes = flatPElist peList in
+             let e = match eOpt with None -> [] | Some e -> [ Exp e ] in
+             buildUniformAST (e @ pes)
+         | Pexp_apply (e, leList) -> 
+             let flatLElist leList = List.fold_right (fun (_,e) accu -> ( Exp e ) :: accu) leList [] in
+             buildUniformAST (( Exp e ) :: (flatLElist leList))
+         | Pexp_match (e, peList) -> buildUniformAST ((Exp e) :: (flatPElist peList))
+         | Pexp_try (e, peList) -> buildUniformAST ((Exp e) :: (flatPElist peList))
+         | Pexp_tuple eList -> 
+             let es = List.map (fun x -> Exp x) eList in
+             buildUniformAST es
+         | Pexp_construct (id, eOpt, b) -> 
+             let e = match eOpt with None -> [] | Some e -> [ Exp e ] in
+             buildUniformAST e
+         | Pexp_variant (lab, eOpt) -> 
+             let e = match eOpt with None -> [] | Some e -> [ Exp e ] in
+             buildUniformAST e
+         | Pexp_record (ideList, eOpt) ->
+             let e = match eOpt with None -> [] | Some e -> [ Exp e ] in
+             let es = List.fold_right (fun (_, e) accu -> (Exp e) :: accu) ideList e in
+             buildUniformAST es
+         | Pexp_field (e, id) ->  buildUniformAST [ Exp e ]
+         | Pexp_setfield (e1, id, e2) -> buildUniformAST [ Exp e1; Exp e2 ]
+         | Pexp_array eList -> 
+             let es = List.map (fun x -> Exp x) eList in
+             buildUniformAST es
+         | Pexp_ifthenelse (e1,e2,e3Opt) -> 
+             let e3 = match e3Opt with None -> [] | Some e3 -> [ Exp e3 ] in
+             buildUniformAST (Exp e1 :: Exp e2 :: e3)
+         | Pexp_sequence (e1, e2) -> buildUniformAST [ Exp e1; Exp e2 ]
+         | Pexp_while (e1, e2) -> buildUniformAST [ Exp e1; Exp e2 ]
+         | Pexp_for (s, e1, e2, d, e3) -> buildUniformAST [ Exp e1; Exp e2; Exp e3 ]
+         | Pexp_constraint (e, ty1Opt, ty2Opt) -> 
+             let t1 = match ty1Opt with None -> [] | Some ty1 -> [ Typ ty1 ] in
+             let t2 = match ty2Opt with None -> [] | Some ty2 -> [ Typ ty2 ] in
+             buildUniformAST ((Exp e) :: (t1 @ t2))
+         | Pexp_when (e1, e2) -> buildUniformAST [ Exp e1; Exp e2 ]
+         | Pexp_send (e, s) -> buildUniformAST [ Exp e ]
+         | Pexp_new id -> buildUniformAST []
+         | Pexp_setinstvar (s, e) -> buildUniformAST [ Exp e ]
+         | Pexp_override seList -> 
+             let flatSElist seList = List.fold_right (fun (_,e) accu -> ( Exp e ) :: accu) seList [] in
+             buildUniformAST (flatSElist seList)
+         | Pexp_letmodule (s, md, e) -> buildUniformAST [ Mod md ; Exp e ]
+         | Pexp_assert e -> buildUniformAST [ Exp e ]
+         | Pexp_assertfalse -> buildUniformAST []
+         | Pexp_lazy e -> buildUniformAST [ Exp e ]
+         | Pexp_poly (e, tyOpt) -> 
+             let ty = match tyOpt with None -> [] | Some ty -> [ Typ ty ] in
+             buildUniformAST ((Exp e) :: ty)
+         | Pexp_object (p, cfList) -> 
+             let clfs = List.map (fun x -> Clfield x) cfList in
+             buildUniformAST ((Pat p) :: clfs)
+       end
+   | Mod mdl ->
+       begin
+         match mdl.pmod_desc with
+           Pmod_ident id -> buildUniformAST []
+         | Pmod_structure str -> buildUniformAST [ Str str ]
+         | Pmod_functor (s, mty, md') -> buildUniformAST [ Modty mty ; Mod md' ]
+         | Pmod_apply (m1, m2) -> buildUniformAST [ Mod m1 ; Mod m2 ]
+         | Pmod_constraint (m, mty) -> buildUniformAST [ Mod m ; Modty mty ]
+       end
+   | Modty mty ->
+       begin
+         match mty.pmty_desc with
+           Pmty_ident id -> buildUniformAST []
+         | Pmty_signature sgn -> 
+             let sits = List.map (fun x -> Sigitem x) sgn in
+             buildUniformAST sits
+         | Pmty_functor (s, mty1, mty2) -> buildUniformAST [ Modty mty1 ; Modty mty2 ]
+         | Pmty_with (mt1, idwithList) ->
+             let withList = List.fold_right 
+                 (fun (id, wconstraint) accu -> match wconstraint with Pwith_type tyd -> (Tydec tyd) :: accu | _ -> accu) idwithList [] in
+             buildUniformAST ((Modty mt1)::withList)
+       end
+   | Sigitem sit ->
+       begin
+         match sit.psig_desc with
+           Psig_value (s, valu) -> buildUniformAST [ Typ valu.pval_type ]
+         | Psig_type styList ->
+             let tys = List.map (fun (s, ty) -> Tydec ty) styList in
+             buildUniformAST tys
+         | Psig_exception (s, exn) -> 
+             let tys = List.map (fun x -> Typ x) exn in
+             buildUniformAST tys
+         | Psig_module (s, mty) -> buildUniformAST [ Modty mty ]
+         | Psig_recmodule smtyList ->
+             let mtys = List.map (fun (s, mty) -> Modty mty) smtyList in
+             buildUniformAST mtys
+         | Psig_modtype (s, mtydec) ->
+             let mtydecs = match mtydec with Pmodtype_manifest mty -> [ Modty mty ] | _ -> [] in
+             buildUniformAST mtydecs
+         | Psig_open id -> buildUniformAST []
+         | Psig_include mty -> buildUniformAST [ Modty mty ]
+         | Psig_class cldecList ->
+             let cldecs = List.map (fun x -> Cldesc x) cldecList in
+             buildUniformAST cldecs
+         | Psig_class_type cltydecList ->
+             let cltydecs = List.map (fun x -> Cltydec x) cltydecList in
+             buildUniformAST cltydecs
+       end
+   | Typ typ ->
+       begin
+         match typ.ptyp_desc with
+           Ptyp_any -> buildUniformAST []
+         | Ptyp_var s -> buildUniformAST []
+         | Ptyp_arrow (l, ty1, ty2) -> buildUniformAST [ Typ ty1 ; Typ ty2 ]
+         | Ptyp_tuple tyList ->
+             let tys = List.map (fun x -> Typ x) tyList in
+             buildUniformAST tys
+         | Ptyp_constr (id, tyList) ->
+             let tys = List.map (fun x -> Typ x) tyList in
+             buildUniformAST tys
+         | Ptyp_object cftyList -> 
+             let tys = (List.fold_right 
+                          (fun cfty accu ->
+                            match cfty.pfield_desc with
+                              Pfield (s, ty) -> (Typ ty)::accu
+                            | Pfield_var -> accu) cftyList []) in
+             buildUniformAST tys
+         | Ptyp_class (id, tyList, labList) ->
+             let tys = List.map (fun x -> Typ x) tyList in
+             buildUniformAST tys
+         | Ptyp_alias (ty, s) -> buildUniformAST [ Typ ty ]
+         | Ptyp_variant (rfList, b, lablistOpt) -> 
+             let tys = List.flatten
+                 (List.fold_right 
+                    (fun rf accu ->
+                      match rf with
+                        Rtag (l, b, tyList) -> (List.map (fun x -> Typ x) tyList) :: accu
+                      | Rinherit ty -> [ Typ ty ] :: accu) rfList []) in
+             buildUniformAST tys
+         | Ptyp_poly (sList, ty) -> buildUniformAST [ Typ ty ]
+       end 
+   | Cldec cli ->
+       begin
+         buildUniformAST [ Clexp cli.pci_expr ]
+       end
+   | Cldesc cli ->
+       begin
+         buildUniformAST [ Clty cli.pci_expr ]
+       end 
+   | Cltydec cli ->
+       begin
+         buildUniformAST [ Clty cli.pci_expr ]
+       end
+   | Clfield clf ->
+       begin
+         match clf with
+           Pcf_inher (cle, s) -> buildUniformAST [ Clexp cle ]
+         | Pcf_val (s, mut, e, loc) -> buildUniformAST [ Exp e ]
+         | Pcf_virt (s, priv, ty, loc) -> buildUniformAST [ Typ ty ]
+         | Pcf_meth (s, priv, e, loc) -> buildUniformAST [ Exp e ]
+         | Pcf_cstr (ty1, ty2, loc) -> buildUniformAST [ Typ ty1; Typ ty2 ]
+         | Pcf_let (r, peList, loc) ->
+             let flatPElist peList = List.flatten 
+                 (List.fold_right (fun (p,e) accu -> [Pat p; Exp e]::accu) peList []) in
+             buildUniformAST (flatPElist peList)
+         | Pcf_init e -> buildUniformAST [ Exp e ]
+       end
+   | Clexp cle ->
+       begin
+         match cle.pcl_desc with 
+           Pcl_constr (id, tyList) -> 
+             let tys = List.map (fun x -> Typ x) tyList in
+             buildUniformAST tys
+         | Pcl_structure (pat, clfieldList) ->
+             let clfs = List.map (fun x -> Clfield x) clfieldList in
+             buildUniformAST ((Pat pat)::clfs)
+         | Pcl_fun (lab, eOpt, pat, clexp) ->
+             let e = match eOpt with None -> [] | Some e -> [ Exp e ] in
+             buildUniformAST (e @ [ Pat pat ; Clexp clexp ])
+         | Pcl_apply (clexp, labeList) ->
+             let es = List.map (fun (_, e) -> Exp e) labeList in
+             buildUniformAST ((Clexp clexp)::es)
+         | Pcl_let (recflag, peList, clexp) ->
+             let pes = List.flatten 
+                 (List.fold_right (fun (pat, exp) accu -> [ Pat pat ; Exp exp ] :: accu) peList []) in
+             buildUniformAST (pes @ [ Clexp clexp ] )
+         | Pcl_constraint (clexp, clty) ->
+             buildUniformAST [ Clexp clexp ; Clty clty ]
+       end
+   | Clty clty ->
+       begin
+         match clty.pcty_desc with
+           Pcty_constr (id, tyList) ->
+             let tys = List.map (fun x -> Typ x) tyList in
+             buildUniformAST tys
+         | Pcty_signature (ty, cltyfieldList) ->
+             let cltfs = List.map (fun x -> Cltyfield x) cltyfieldList in
+             buildUniformAST ((Typ ty)::cltfs)
+         | Pcty_fun (l, ty, clty) -> buildUniformAST [ Typ ty ; Clty clty ]
+       end
+   | Cltyfield cltf ->
+       begin
+         match cltf with
+           Pctf_inher clty -> buildUniformAST [ Clty clty ]
+         | Pctf_val (s, mut, tyOpt, loc) -> 
+             let ty = match tyOpt with None -> [] | Some ty -> [ Typ ty ] in
+             buildUniformAST ty
+         | Pctf_virt (s, privflag, ty, loc) -> buildUniformAST [ Typ ty ]
+         | Pctf_meth (s, privflag, ty, loc) -> buildUniformAST [ Typ ty ]
+         | Pctf_cstr (ty1, ty2, loc) -> buildUniformAST [ Typ ty1 ; Typ ty2 ]
+       end
+ 
+ let equalNode x y = 
+   match (x.past_node, y.past_node) with 
+     (Str _, Str _) -> true
+   | (StrItem stritem1, StrItem stritem2) -> 
+       begin
+         match (stritem1.pstr_desc, stritem2.pstr_desc) with
+           (Pstr_eval _, Pstr_eval _) -> true
+         | (Pstr_value(rec_flag1, _), Pstr_value(rec_flag2, _)) -> rec_flag1 = rec_flag2
+         | (Pstr_primitive(prim1, _), Pstr_primitive(prim2, _)) -> prim1 = prim2
+         | (Pstr_type _, Pstr_type _) -> true
+         | (Pstr_exception (exn1, _), Pstr_exception(exn2, _)) -> exn1 = exn2
+         | (Pstr_exn_rebind (str1, id1), Pstr_exn_rebind(str2, id2)) -> str1 = str2 && id1 = id2
+         | (Pstr_module (str1, _), Pstr_module(str2, _)) -> str1 = str2
+         | (Pstr_recmodule _, Pstr_recmodule _) -> true
+         | (Pstr_modtype (str1, _), Pstr_modtype (str2, _)) -> str1 = str2
+         | (Pstr_open id1, Pstr_open id2) -> id1 = id2
+         | (Pstr_class _, Pstr_class _) -> true
+         | (Pstr_class_type _, Pstr_class_type _) -> true
+         | (Pstr_include _, Pstr_include _) -> true
+         | _ -> false
+       end
+   | (Tydec _, Tydec _) -> true
+   | (Pat pat1, Pat pat2) ->
+       begin
+         match (pat1.ppat_desc, pat2.ppat_desc) with
+           (Ppat_any, Ppat_any) -> true
+         | (Ppat_var str1, Ppat_var str2) -> str1 = str2
+         | (Ppat_alias (_, str1), Ppat_alias (_, str2)) -> str1 = str2
+         | (Ppat_constant c1, Ppat_constant c2) -> c1 = c2
+         | (Ppat_tuple _, Ppat_tuple _) -> true
+         | (Ppat_construct (id1, _, b1), Ppat_construct (id2, _, b2)) -> id1 = id2 && b1 = b2
+         | (Ppat_variant (lab1, _), Ppat_variant (lab2, _)) -> lab1 = lab2
+         | (Ppat_record _, Ppat_record _) -> true
+         | (Ppat_array _, Ppat_array _) -> true
+         | (Ppat_or _, Ppat_or _) -> true
+         | (Ppat_constraint _, Ppat_constraint _) -> true
+         | (Ppat_type id1, Ppat_type id2) -> id1 = id2
+         | _ -> false
+       end
+   | (Exp exp1, Exp exp2) ->
+       begin
+         match (exp1.pexp_desc, exp2.pexp_desc) with
+           (Pexp_ident id1, Pexp_ident id2) -> id1 = id2
+         | (Pexp_constant c1, Pexp_constant c2) -> c1 = c2
+         | (Pexp_let (recf1, _, _), Pexp_let (recf2, _, _)) -> recf1 = recf2
+         | (Pexp_function (lab1, _, _), Pexp_function (lab2, _, _)) -> lab1 = lab2
+         | (Pexp_apply _, Pexp_apply _) -> true
+         | (Pexp_match _, Pexp_match _) -> true
+         | (Pexp_try _, Pexp_try _) -> true
+         | (Pexp_tuple _, Pexp_tuple _) -> true
+         | (Pexp_construct (id1, _, b1), Pexp_construct (id2, _, b2)) -> id1 = id2 && b1 = b2
+         | (Pexp_variant (lab1, _), Pexp_variant (lab2, _)) -> lab1 = lab2
+         | (Pexp_record _, Pexp_record _) -> true
+         | (Pexp_field (_, id1), Pexp_field (_, id2)) -> id1 = id2
+         | (Pexp_setfield (_, id1, _), Pexp_setfield (_, id2, _)) -> id1 = id2
+         | (Pexp_array _, Pexp_array _) -> true
+         | (Pexp_ifthenelse _, Pexp_ifthenelse _) -> true
+         | (Pexp_sequence _, Pexp_sequence _) -> true
+         | (Pexp_while _, Pexp_while _) -> true
+         | (Pexp_for (s1, _, _, d1, _), Pexp_for (s2, _, _, d2, _)) -> s1 = s2 && d1 = d2
+         | (Pexp_constraint _, Pexp_constraint _) -> true
+         | (Pexp_when _, Pexp_when _) -> true
+         | (Pexp_send (_, s1), Pexp_send (_, s2)) -> s1 = s2
+         | (Pexp_new id1, Pexp_new id2) -> id1 = id2
+         | (Pexp_setinstvar (s1, _), Pexp_setinstvar (s2, _)) -> s1 = s2
+         | (Pexp_override _, Pexp_override _) -> true
+         | (Pexp_letmodule (s1, _, _), Pexp_letmodule (s2, _, _)) -> s1 = s2
+         | (Pexp_assert _, Pexp_assert _) -> true
+         | (Pexp_assertfalse, Pexp_assertfalse) -> true
+         | (Pexp_lazy _, Pexp_lazy _) -> true
+         | (Pexp_poly _, Pexp_poly _) -> true
+         | (Pexp_object _, Pexp_object _) -> true
+         | _ -> false
+       end
+   | (Mod mdl1, Mod mdl2) ->
+       begin
+         match (mdl1.pmod_desc, mdl2.pmod_desc) with
+           (Pmod_ident id1, Pmod_ident id2) -> id1 = id2
+         | (Pmod_structure _, Pmod_structure _) -> true
+         | (Pmod_functor (s1, _, _), Pmod_functor (s2, _, _)) -> s1 = s2
+         | (Pmod_apply _, Pmod_apply _) -> true
+         | (Pmod_constraint _, Pmod_constraint _) -> true
+         | _ -> false
+       end
+   | (Typ typ1, Typ typ2) ->
+       begin
+         match (typ1.ptyp_desc, typ2.ptyp_desc) with
+           (Ptyp_any, Ptyp_any) -> true
+         | (Ptyp_var s1, Ptyp_var s2) -> s1 = s2
+         | (Ptyp_arrow (l1, _, _), Ptyp_arrow (l2, _, _)) -> l1 = l2
+         | (Ptyp_tuple _, Ptyp_tuple _) -> true
+         | (Ptyp_constr (id1, _), Ptyp_constr (id2, _)) -> id1 = id2
+         | (Ptyp_object _, Ptyp_object _) -> true
+         | (Ptyp_class (id1, _, _), Ptyp_class (id2, _, _)) -> id1 = id2
+         | (Ptyp_alias (_, s1), Ptyp_alias (_, s2)) -> s1 = s2
+         | (Ptyp_variant (_, b1, _), Ptyp_variant (_, b2, _)) -> b1 = b2
+         | (Ptyp_poly _, Ptyp_poly _) -> true
+         | _ -> false
+       end 
+   | _ -> false
+ (*  | Modty mty ->
+       begin
+         match mty.pmty_desc with
+           Pmty_ident id -> buildUniformAST []
+         | Pmty_signature sgn -> 
+             let sits = List.map (fun x -> Sigitem x) sgn in
+             buildUniformAST sits
+         | Pmty_functor (s, mty1, mty2) -> buildUniformAST [ Modty mty1 ; Modty mty2 ]
+         | Pmty_with (mt1, idwithList) ->
+             let withList = List.fold_right 
+                 (fun (id, wconstraint) accu -> match wconstraint with Pwith_type tyd -> (Tydec tyd) :: accu | _ -> accu) idwithList [] in
+             buildUniformAST ((Modty mt1)::withList)
+       end
+   | Sigitem sit ->
+       begin
+         match sit.psig_desc with
+           Psig_value (s, valu) -> buildUniformAST [ Typ valu.pval_type ]
+         | Psig_type styList ->
+             let tys = List.map (fun (s, ty) -> Tydec ty) styList in
+             buildUniformAST tys
+         | Psig_exception (s, exn) -> 
+             let tys = List.map (fun x -> Typ x) exn in
+             buildUniformAST tys
+         | Psig_module (s, mty) -> buildUniformAST [ Modty mty ]
+         | Psig_recmodule smtyList ->
+             let mtys = List.map (fun (s, mty) -> Modty mty) smtyList in
+             buildUniformAST mtys
+         | Psig_modtype (s, mtydec) ->
+             let mtydecs = match mtydec with Pmodtype_manifest mty -> [ Modty mty ] | _ -> [] in
+             buildUniformAST mtydecs
+         | Psig_open id -> buildUniformAST []
+         | Psig_include mty -> buildUniformAST [ Modty mty ]
+         | Psig_class cldecList ->
+             let cldecs = List.map (fun x -> Cldesc x) cldecList in
+             buildUniformAST cldecs
+         | Psig_class_type cltydecList ->
+             let cltydecs = List.map (fun x -> Cltydec x) cltydecList in
+             buildUniformAST cltydecs
+       end
+   | Cldec cli ->
+       begin
+         buildUniformAST [ Clexp cli.pci_expr ]
+       end
+   | Cldesc cli ->
+       begin
+         buildUniformAST [ Clty cli.pci_expr ]
+       end 
+   | Cltydec cli ->
+       begin
+         buildUniformAST [ Clty cli.pci_expr ]
+       end
+   | Clfield clf ->
+       begin
+         match clf with
+           Pcf_inher (cle, s) -> buildUniformAST [ Clexp cle ]
+         | Pcf_val (s, mut, e, loc) -> buildUniformAST [ Exp e ]
+         | Pcf_virt (s, priv, ty, loc) -> buildUniformAST [ Typ ty ]
+         | Pcf_meth (s, priv, e, loc) -> buildUniformAST [ Exp e ]
+         | Pcf_cstr (ty1, ty2, loc) -> buildUniformAST [ Typ ty1; Typ ty2 ]
+         | Pcf_let (r, peList, loc) ->
+             let flatPElist peList = List.flatten 
+                 (List.fold_right (fun (p,e) accu -> [Pat p; Exp e]::accu) peList []) in
+             buildUniformAST (flatPElist peList)
+         | Pcf_init e -> buildUniformAST [ Exp e ]
+       end
+   | Clexp cle ->
+       begin
+         match cle.pcl_desc with 
+           Pcl_constr (id, tyList) -> 
+             let tys = List.map (fun x -> Typ x) tyList in
+             buildUniformAST tys
+         | Pcl_structure (pat, clfieldList) ->
+             let clfs = List.map (fun x -> Clfield x) clfieldList in
+             buildUniformAST ((Pat pat)::clfs)
+         | Pcl_fun (lab, eOpt, pat, clexp) ->
+             let e = match eOpt with None -> [] | Some e -> [ Exp e ] in
+             buildUniformAST (e @ [ Pat pat ; Clexp clexp ])
+         | Pcl_apply (clexp, labeList) ->
+             let es = List.map (fun (_, e) -> Exp e) labeList in
+             buildUniformAST ((Clexp clexp)::es)
+         | Pcl_let (recflag, peList, clexp) ->
+             let pes = List.flatten 
+                 (List.fold_right (fun (pat, exp) accu -> [ Pat pat ; Exp exp ] :: accu) peList []) in
+             buildUniformAST (pes @ [ Clexp clexp ] )
+         | Pcl_constraint (clexp, clty) ->
+             buildUniformAST [ Clexp clexp ; Clty clty ]
+       end
+   | Clty clty ->
+       begin
+         match clty.pcty_desc with
+           Pcty_constr (id, tyList) ->
+             let tys = List.map (fun x -> Typ x) tyList in
+             buildUniformAST tys
+         | Pcty_signature (ty, cltyfieldList) ->
+             let cltfs = List.map (fun x -> Cltyfield x) cltyfieldList in
+             buildUniformAST ((Typ ty)::cltfs)
+         | Pcty_fun (l, ty, clty) -> buildUniformAST [ Typ ty ; Clty clty ]
+       end
+   | Cltyfield cltf ->
+       begin
+         match cltf with
+           Pctf_inher clty -> buildUniformAST [ Clty clty ]
+         | Pctf_val (s, mut, tyOpt, loc) -> 
+             let ty = match tyOpt with None -> [] | Some ty -> [ Typ ty ] in
+             buildUniformAST ty
+         | Pctf_virt (s, privflag, ty, loc) -> buildUniformAST [ Typ ty ]
+         | Pctf_meth (s, privflag, ty, loc) -> buildUniformAST [ Typ ty ]
+         | Pctf_cstr (ty1, ty2, loc) -> buildUniformAST [ Typ ty1 ; Typ ty2 ]
+       end
+ *)
+ let itemLocation ast =
+   match ast with 
+     Str str -> 
+       begin
+         match str with
+           [] -> Location.none
+         | hd::tl -> List.fold_left (fun loc stritem -> locJoin loc stritem.pstr_loc) hd.pstr_loc tl
+       end
+   | StrItem stritem -> stritem.pstr_loc
+   | Tydec tyd -> tyd.ptype_loc
+   | Pat pat -> pat.ppat_loc
+   | Exp exp -> exp.pexp_loc
+   | Mod mdl -> mdl.pmod_loc
+   | Modty mty -> mty.pmty_loc
+   | Typ typ -> typ.ptyp_loc
+   | Cldec cli -> cli.pci_loc
+   | Cldesc cli -> cli.pci_loc
+   | Cltydec cli -> cli.pci_loc
+   | Clfield clf -> Location.none
+   | Clexp cle -> cle.pcl_loc
+   | Sigitem sit -> sit.psig_loc
+   | Clty clt -> clt.pcty_loc
+   | Cltyfield cltf -> (match cltf with
+       Pctf_inher t -> t.pcty_loc
+     | Pctf_val (_, _, _, loc)
+     | Pctf_virt (_, _, _, loc)
+     | Pctf_meth (_, _, _, loc)
+     | Pctf_cstr (_, _, loc) -> loc)
+ let nameOf a =
+   match a with 
+     Str str -> "Str"
+   | StrItem stritem ->
+       begin "StrItem:" ^ 
+         match stritem.pstr_desc with
+           Pstr_eval e -> "Pstr_eval"
+         | Pstr_value(rec_flag, peList) -> "Pstr_value"
+         | Pstr_primitive(prim, value_desc) -> "Pstr_primitive"
+         | Pstr_type tytydecList -> "Pstr_type"
+         | Pstr_exception (exn, exDec) -> "Pstr_exception"
+         | Pstr_exn_rebind (str, id) -> "Pstr_exn_rebind"
+         | Pstr_module (str, modexp) -> "Pstr_module"
+         | Pstr_recmodule strModtyModexpList -> "Pstr_recmodule"
+         | Pstr_modtype (str, mty) -> "Pstr_modtype"
+         | Pstr_open id -> "Pstr_open"
+         | Pstr_class cldecList -> "Pstr_class"
+         | Pstr_class_type cltydecList -> "Pstr_class_type"
+         | Pstr_include md -> "Pstr_include"
+       end
+   | Tydec tyd ->
+       begin "Tydec:" ^ 
+         match tyd.ptype_kind with
+           Ptype_abstract -> "Ptype_abstract"
+         | Ptype_variant (strtyList, _) -> "Ptype_variant"
+         | Ptype_record (strmuttyList, _) -> "Ptype_record"
+       end
+   | Pat pat ->
+       begin "Pat:" ^
+         match pat.ppat_desc with
+           Ppat_any -> "Ppat_any"
+         | Ppat_var str -> "Ppat_var"
+         | Ppat_alias (pat, str) -> "Ppat_alias"
+         | Ppat_constant c -> "Ppat_constant"
+         | Ppat_tuple pList -> "Ppat_tuple"
+         | Ppat_construct (id, pOpt, b) -> "Ppat_construct"
+         | Ppat_variant (lab, pOpt) -> "Ppat_variant"
+         | Ppat_record idpatList -> "Ppat_record"
+         | Ppat_array pList -> "Ppat_array"
+         | Ppat_or (p1, p2) -> "Ppat_or"
+         | Ppat_constraint (p, ty) -> "Ppat_constraint"
+         | Ppat_type id -> "Ppat_type"
+       end
+   | Exp exp ->
+       begin "Exp:" ^
+         match exp.pexp_desc with
+           Pexp_ident id -> "Pexp_ident"
+         | Pexp_constant c -> "Pexp_constant"
+         | Pexp_let (recf, peList, e) -> "Pexp_let"
+         | Pexp_function (lab, eOpt, peList) -> "Pexp_function"
+         | Pexp_apply (e, leList) -> "Pexp_apply"
+         | Pexp_match (e, peList) -> "Pexp_match"
+         | Pexp_try (e, peList) -> "Pexp_try"
+         | Pexp_tuple eList -> "Pexp_tuple"
+         | Pexp_construct (id, eOpt, b) -> "Pexp_construct"
+         | Pexp_variant (lab, eOpt) -> "Pexp_variant"
+         | Pexp_record (ideList, eOpt) -> "Pexp_record"
+         | Pexp_field (e, id) ->  "Pexp_field"
+         | Pexp_setfield (e1, id, e2) -> "Pexp_setfield"
+         | Pexp_array eList -> "Pexp_array"
+         | Pexp_ifthenelse (e1,e2,e3Opt) -> "Pexp_ifthenelse"
+         | Pexp_sequence (e1, e2) -> "Pexp_sequence"
+         | Pexp_while (e1, e2) -> "Pexp_while"
+         | Pexp_for (s, e1, e2, d, e3) -> "Pexp_for"
+         | Pexp_constraint (e, ty1Opt, ty2Opt) -> "Pexp_constraint"
+         | Pexp_when (e1, e2) -> "Pexp_when"
+         | Pexp_send (e, s) -> "Pexp_send"
+         | Pexp_new id -> "Pexp_new"
+         | Pexp_setinstvar (s, e) -> "Pexp_setinstvar"
+         | Pexp_override seList -> "Pexp_override"
+         | Pexp_letmodule (s, md, e) -> "Pexp_letmodule"
+         | Pexp_assert e -> "Pexp_assert"
+         | Pexp_assertfalse -> "Pexp_assertfalse"
+         | Pexp_lazy e -> "Pexp_lazy"
+         | Pexp_poly (e, tyOpt) -> "Pexp_poly"
+         | Pexp_object (p, cfList) -> "Pexp_object"
+       end
+   | Mod mdl ->
+       begin "Mod:" ^
+         match mdl.pmod_desc with
+           Pmod_ident id -> "Pmod_ident"
+         | Pmod_structure str -> "Pmod_structure"
+         | Pmod_functor (s, mty, md') -> "Pmod_functor"
+         | Pmod_apply (m1, m2) -> "Pmod_apply"
+         | Pmod_constraint (m, mty) -> "Pmod_constraint"
+       end
+   | Modty mty ->
+       begin "Modty:" ^
+         match mty.pmty_desc with
+           Pmty_ident id -> "Pmty_ident"
+         | Pmty_signature sgn -> "Pmty_signature"
+         | Pmty_functor (s, mty1, mty2) -> "Pmty_functor"
+         | Pmty_with (mt1, idwithList) -> "Pmty_with"
+       end
+   | Sigitem sit ->
+       begin "Sigitem:" ^
+         match sit.psig_desc with
+           Psig_value (s, valu) -> "Psig_value"
+         | Psig_type styList -> "Psig_type"
+         | Psig_exception (s, exn) -> "Psig_exception"
+         | Psig_module (s, mty) -> "Psig_module"
+         | Psig_recmodule smtyList -> "Psig_recmodule"
+         | Psig_modtype (s, mtydec) -> "Psig_modtype"
+         | Psig_open id -> "Psig_open"
+         | Psig_include mty -> "Psig_include"
+         | Psig_class cldecList -> "Psig_class"
+         | Psig_class_type cltydecList -> "Psig_class_type"
+       end
+   | Typ typ ->
+       begin "Typ:" ^
+         match typ.ptyp_desc with
+           Ptyp_any -> "Ptyp_any"
+         | Ptyp_var s -> "Ptyp_var"
+         | Ptyp_arrow (l, ty1, ty2) -> "Ptyp_arrow"
+         | Ptyp_tuple tyList -> "Ptyp_tuple"
+         | Ptyp_constr (id, tyList) -> "Ptyp_constr"
+         | Ptyp_object cftyList -> "Ptyp_object"
+         | Ptyp_class (id, tyList, labList) -> "Ptyp_class"
+         | Ptyp_alias (ty, s) -> "Ptyp_alias"
+         | Ptyp_variant (rfList, b, lablistOpt) -> "Ptyp_variant"
+         | Ptyp_poly (sList, ty) -> "Ptyp_poly"
+       end 
+   | Cldec cli -> "Cldec"
+   | Cldesc cli -> "Cldesc"
+   | Cltydec cli -> "Cltydec"
+   | Clfield clf ->
+       begin "Clfield:" ^
+         match clf with
+           Pcf_inher (cle, s) -> "Pcf_inher"
+         | Pcf_val (s, mut, e, loc) -> "Pcf_val"
+         | Pcf_virt (s, priv, ty, loc) -> "Pcf_virt"
+         | Pcf_meth (s, priv, e, loc) -> "Pcf_meth"
+         | Pcf_cstr (ty1, ty2, loc) -> "Pcf_cstr"
+         | Pcf_let (r, peList, loc) -> "Pcf_let"
+         | Pcf_init e -> "Pcf_init"
+       end
+   | Clexp cle ->
+       begin "Clexp:" ^
+         match cle.pcl_desc with 
+           Pcl_constr (id, tyList) -> "Pcl_constr"
+         | Pcl_structure (pat, clfieldList) -> "Pcl_structure"
+         | Pcl_fun (lab, eOpt, pat, clexp) -> "Pcl_fun"
+         | Pcl_apply (clexp, labeList) -> "Pcl_apply"
+         | Pcl_let (recflag, peList, clexp) -> "Pcl_let"
+         | Pcl_constraint (clexp, clty) -> "Pcl_constraint"
+       end
+   | Clty clty ->
+       begin "Clty:" ^
+         match clty.pcty_desc with
+           Pcty_constr (id, tyList) -> "Pcty_constr"
+         | Pcty_signature (ty, cltyfieldList) -> "Pcty_signature"
+         | Pcty_fun (l, ty, clty) -> "Pcty_fun"
+       end
+   | Cltyfield cltf ->
+       begin "Cltyfield:" ^
+         match cltf with
+           Pctf_inher clty -> "Pctf_inher"
+         | Pctf_val (s, mut, tyOpt, loc) -> "Pctf_val"
+         | Pctf_virt (s, privflag, ty, loc) -> "Pctf_virt"
+         | Pctf_meth (s, privflag, ty, loc) -> "Pctf_meth"
+         | Pctf_cstr (ty1, ty2, loc) -> "Pctf_cstr"
+       end
+ let printUniformAST (f : 'a -> string -> astThing -> unit) (x : 'a uniformAST) =
+   let rec printAST indent x =
+     f x.past_data indent x.past_node;
+     List.iter (printAST (indent ^ "  ")) x.past_kids in
+   printAST "" x
+ let printNamedLocatedAST ast =
+   let printItem (name, loc) indent node =
+     print_string (indent ^ name ^ " "); Location.print std_formatter loc;
+ (*    try
+       print_string (indent ^ (sourceFromLoc loc) ^ "\n")
+     with _ -> *) (print_string indent; smartPrintTo std_formatter node; print_string "\n") in
+   printUniformAST printItem ast
+ let makeNamedLocatedAST ast : (string * Location.t) uniformAST =
+   convertUniform (fun a -> (nameOf a, itemLocation a)) ast
+ let rec mapUniformAST (f : 'a -> 'b) (ast : 'a uniformAST) : 'b uniformAST =
+   let newKids = List.map (mapUniformAST f) ast.past_kids in
+   {ast with past_kids = newKids; past_data = (f ast.past_data)}
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ (* XXXXXXXXXXXXXXXXXXXXX Find node type in typed AST XXXXXXXXXXXXXXXXXXXXXX *)
+ (* typeAST: (Parsetree.structure -> Typedtree.structure * Typedtree.module_coercion) *)
+ exception FoundType of typedTreeType
+ let findType typedAst targetLoc =
+   let foundType typ = raise (FoundType typ) in
+   let rec findInStructure str : unit = List.iter findInStritem str
+   and findInStritem stritem : unit =
+     match stritem with
+       Typedtree.Tstr_eval e -> findInExp e
+     | Typedtree.Tstr_value (_, peList) -> List.iter (fun (p,e) -> findInPat p; findInExp e) peList
+     | Typedtree.Tstr_primitive (id, valdesc) -> ()
+     | Typedtree.Tstr_type idTydecs -> () (* no location info *)
+     | Typedtree.Tstr_exception (id, eDec) -> () (* no location info *)
+     | Typedtree.Tstr_exn_rebind _ -> ()
+     | Typedtree.Tstr_module (id, modexp) -> findInMod modexp
+     | Typedtree.Tstr_recmodule idmodList -> List.iter (fun (id,md) -> findInStritem (Typedtree.Tstr_module (id,md))) idmodList
+     | Typedtree.Tstr_modtype (id, modty) -> () (* no location info *)
+     | Typedtree.Tstr_open _ -> ()
+     | Typedtree.Tstr_class idisclexpList -> List.iter (fun (id, i, sList, clexp) -> 
+         findInClexp clexp) idisclexpList
+     | Typedtree.Tstr_cltype _ -> () (* no location info *)
+     | Typedtree.Tstr_include (modexp, ids) -> findInMod modexp
+   and findInPat p : unit = 
+     if (targetLoc = p.Typedtree.pat_loc) then foundType (SimpleType p.Typedtree.pat_type) 
+     else if (locInside targetLoc p.Typedtree.pat_loc) then
+       begin
+         (match p.Typedtree.pat_desc with
+           Typedtree.Tpat_any -> ()
+         | Typedtree.Tpat_var _ -> ()
+         | Typedtree.Tpat_alias (p, _) -> findInPat p
+         | Typedtree.Tpat_constant _ -> ()
+         | Typedtree.Tpat_tuple pList -> List.iter findInPat pList
+         | Typedtree.Tpat_construct (constrDesc, pList) -> List.iter findInPat pList
+         | Typedtree.Tpat_variant (l, pOpt, rDesc) -> (match pOpt with None -> () | Some p' -> findInPat p')
+         | Typedtree.Tpat_record lpList -> List.iter (fun (l, p') -> findInPat p') lpList
+         | Typedtree.Tpat_array pList -> List.iter findInPat pList
+         | Typedtree.Tpat_or (p1, p2, _) -> findInPat p1; findInPat p2
+         );
+         foundType (SimpleType p.Typedtree.pat_type) (* was inside, but not any smaller... *)
+       end
+   and findInExp e : unit = 
+     if (targetLoc = e.Typedtree.exp_loc) then foundType (SimpleType e.Typedtree.exp_type)
+     else if (locInside targetLoc e.Typedtree.exp_loc) then 
+       begin
+         (match e.Typedtree.exp_desc with
+           Typedtree.Texp_ident _ -> ()
+         | Typedtree.Texp_constant _ -> ()
+         | Typedtree.Texp_let (_, peList, e) -> List.iter (fun (p,e) -> findInPat p; findInExp e) peList; findInExp e
+         | Typedtree.Texp_function (peList, _) -> List.iter (fun (p,e) -> findInPat p; findInExp e) peList
+         | Typedtree.Texp_apply (e, eooList) -> 
+             findInExp e; 
+             List.iter (fun (eOpt, _) -> match eOpt with None -> () | Some e' -> findInExp e') eooList
+         | Typedtree.Texp_match (e, peList, _)
+         | Typedtree.Texp_try (e, peList) -> findInExp e; List.iter (fun (p,e) -> findInPat p; findInExp e) peList
+         | Typedtree.Texp_tuple eList -> List.iter findInExp eList
+         | Typedtree.Texp_construct (constrDesc, eList) -> List.iter findInExp eList
+         | Typedtree.Texp_variant (_, eOpt) -> (match eOpt with None -> () | Some e' -> findInExp e')
+         | Typedtree.Texp_record (leList, eOpt) ->
+             List.iter (fun (_, e) -> findInExp e) leList;
+             (match eOpt with None -> () | Some e' -> findInExp e')
+         | Typedtree.Texp_field (e, _) -> findInExp e
+         | Typedtree.Texp_setfield (e1, _, e2) -> findInExp e1; findInExp e2
+         | Typedtree.Texp_array eList -> List.iter findInExp eList
+         | Typedtree.Texp_ifthenelse (e1, e2, e3Opt) -> findInExp e1; findInExp e2; (match e3Opt with None -> () | Some e' -> findInExp e')
+         | Typedtree.Texp_sequence (e1, e2) -> findInExp e1; findInExp e2
+         | Typedtree.Texp_while (e1, e2) -> findInExp e1; findInExp e2
+         | Typedtree.Texp_for (_, e1, e2, _, e3) -> findInExp e1; findInExp e2; findInExp e3
+         | Typedtree.Texp_when (e1, e2) -> findInExp e1; findInExp e2
+         | Typedtree.Texp_send (e, _) -> findInExp e
+         | Typedtree.Texp_new _ -> ()
+         | Typedtree.Texp_instvar _ -> ()
+         | Typedtree.Texp_setinstvar (_, _, e) -> findInExp e
+         | Typedtree.Texp_override (_, heList) -> List.iter (fun (path, e) -> findInExp e) heList
+         | Typedtree.Texp_letmodule (_, m, e) -> findInMod m; findInExp e
+         | Typedtree.Texp_assert e -> findInExp e
+         | Typedtree.Texp_assertfalse -> ()
+         | Typedtree.Texp_lazy e -> findInExp e
+         | Typedtree.Texp_object (clstr, clsig, _) -> findInClstr clstr
+         );
+         foundType (SimpleType e.Typedtree.exp_type) (* was inside, but not any smaller... *)
+       end
+   and findInMod m : unit = 
+     if (targetLoc = m.Typedtree.mod_loc) then foundType (ModType m.Typedtree.mod_type)
+     else if (locInside targetLoc m.Typedtree.mod_loc) then 
+       begin
+         (match m.Typedtree.mod_desc with
+           Typedtree.Tmod_ident _ -> ()
+         | Typedtree.Tmod_structure str -> findInStructure str
+         | Typedtree.Tmod_functor (id, mty, mexp) -> findInMod mexp
+         | Typedtree.Tmod_apply (m1, m2, mcoerce) -> findInMod m1; findInMod m2
+         | Typedtree.Tmod_constraint (mexp, mty, mcoerce) -> findInMod mexp
+         );
+         foundType (ModType m.Typedtree.mod_type) (* was inside, but not any smaller... *)
+       end
+   and findInClexp cl : unit = 
+     if (targetLoc = cl.Typedtree.cl_loc) then foundType (ClassType cl.Typedtree.cl_type)
+     else if (locInside targetLoc cl.Typedtree.cl_loc) then
+       begin
+         (match cl.Typedtree.cl_desc with
+           Typedtree.Tclass_ident _ -> ()
+         | Typedtree.Tclass_structure cls -> findInClstr cls
+         | Typedtree.Tclass_fun (p, ideList, clexp, _) -> findInPat p; List.iter (fun (id, e) -> findInExp e) ideList; findInClexp clexp
+         | Typedtree.Tclass_apply (clexp, eooList) -> 
+             findInClexp clexp; List.iter (fun (eOpt, _) -> match eOpt with None -> () | Some e -> findInExp e) eooList
+         | Typedtree.Tclass_let (rFlag, peList, ieList, clexp) ->
+             List.iter (fun (p,e) -> findInPat p; findInExp e) peList;
+             List.iter (fun (id, e) -> findInExp e) ieList;
+             findInClexp clexp
+         | Typedtree.Tclass_constraint (clexp, _, _, _) -> findInClexp clexp
+         );
+         foundType (ClassType cl.Typedtree.cl_type) (* was inside, but not any smaller... *)
+       end
+   and findInClstr cls =
+     List.iter (fun clf ->
+       match clf with
+         Typedtree.Cf_inher (clexp, _, _) -> findInClexp clexp
+       | Typedtree.Cf_val (_, _, e) -> findInExp e
+       | Typedtree.Cf_meth (_, e) -> findInExp e
+       | Typedtree.Cf_let (_, peList, ieList) ->
+           List.iter (fun (p,e) -> findInPat p; findInExp e) peList;
+           List.iter (fun (i,e) -> findInExp e) ieList
+       | Typedtree.Cf_init e -> findInExp e
+               ) cls.Typedtree.cl_field
+   in try
+     findInStructure typedAst;
+     NoType
+   with FoundType typ -> typ
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ (* XXXXXXXXXXXXXXXXXXXX Collect Strings and Longidents XXXXXXXXXXXXXXXXXXXX *)
+ module StrLIdMap = Map.Make(struct type t = string let compare = compare end)
+ let safeLookup setref strlid = 
+   try StrLIdMap.find (strlid) !setref with Not_found -> []
+ let safeUpdate setref strlid loc isDef = (* Normalize everything to a string *)
+   setref := StrLIdMap.add strlid ((loc, isDef)::(safeLookup setref strlid)) !setref
+ 
+ let astStrLIds = ref StrLIdMap.empty
+ let collectStrIDs ast =
+   let rec addStr str loc isDef = safeUpdate astStrLIds (str) loc isDef
+   and addId lid loc isDef = safeUpdate astStrLIds (longidentToStr lid) loc isDef
+ 
+   and findInStr str =
+     List.iter (fun stritem -> findInStritem stritem) str
+   and findInStritem stritem =
+     let loc = stritem.pstr_loc in
+     match stritem.pstr_desc with
+       Pstr_eval e -> findInExp e
+     | Pstr_value(rec_flag, peList) -> List.iter (fun (p,e) -> findInPat p; findInExp e) peList
+     | Pstr_primitive(prim, value_desc) -> addStr prim loc true; findInValue value_desc loc
+     | Pstr_type tytydecList -> List.iter (fun (typ, tydec) -> addStr typ loc true; findInTydec tydec) tytydecList
+     | Pstr_exception (exn, exDec) -> addStr exn loc true; List.iter findInTyp exDec
+     | Pstr_exn_rebind (str, id) -> addStr str loc true; addId id loc false
+     | Pstr_module (str, modexp) -> addStr str loc true; findInMod modexp
+     | Pstr_recmodule strModtyModexpList ->
+         List.iter (fun (str, mty, md) -> 
+           addStr str loc true; findInModty mty; findInMod md) strModtyModexpList
+     | Pstr_modtype (str, mty) -> addStr str loc true; findInModty mty
+     | Pstr_open id -> addId id loc true
+     | Pstr_class cldecList -> List.iter findInCldec cldecList
+     | Pstr_class_type cltydecList -> List.iter findInCltydec cltydecList
+     | Pstr_include md -> findInMod md
+   and findInTydec tydec =
+     let loc = tydec.ptype_loc in
+     List.iter (fun str -> addStr str loc true) tydec.ptype_params;
+     List.iter (fun (t1, t2, loc) -> findInTyp t1; findInTyp t2) tydec.ptype_cstrs;
+     findInTykind tydec.ptype_kind loc;
+     (match tydec.ptype_manifest with
+       None -> () | Some t -> findInTyp t)
+   and findInTykind tkn loc =
+     match tkn with
+       Ptype_abstract -> ()
+     | Ptype_variant (strtyListList, priv_flag) ->
+         List.iter (fun (str, tylist) -> addStr str loc true; List.iter findInTyp tylist) strtyListList
+     | Ptype_record (strmuttyList, priv_flat) ->
+         List.iter (fun (str, mut, ty) -> addStr str loc true; findInTyp ty) strmuttyList
+   and findInValue valu loc =
+     findInTyp valu.pval_type; List.iter (fun str -> addStr str loc true) valu.pval_prim
+   and findInPat pat =
+     let loc = pat.ppat_loc in
+     match pat.ppat_desc with
+       Ppat_any -> ()
+     | Ppat_var str -> addStr str loc true
+     | Ppat_alias (pat, str) -> findInPat pat; addStr str loc false
+     | Ppat_constant c -> ()
+     | Ppat_tuple pList -> List.iter findInPat pList
+     | Ppat_construct (id, pOpt, b) ->
+         addId id loc false; (match pOpt with None -> () | Some p -> findInPat p)
+     | Ppat_variant (lab, pOpt) ->
+         addStr lab loc false; (match pOpt with None -> () | Some p -> findInPat p)
+     | Ppat_record idpatList ->
+         List.iter (fun (id, pat) -> addId id loc false; findInPat pat) idpatList
+     | Ppat_array pList -> List.iter findInPat pList
+     | Ppat_or (p1, p2) -> findInPat p1; findInPat p2
+     | Ppat_constraint (p, ty) -> findInPat p; findInTyp ty
+     | Ppat_type id -> addId id loc false
+   and findInExp exp =
+     let loc = exp.pexp_loc in
+     let findInPEList peList = 
+       List.iter (fun (p, e) -> findInPat p; findInExp e) peList in
+     match exp.pexp_desc with
+       Pexp_ident id -> addId id loc false
+     | Pexp_constant c -> ()
+     | Pexp_let (recf, peList, e) -> findInPEList peList; findInExp e
+     | Pexp_function (lab, eOpt, peList) ->
+         addStr lab loc false; findInPEList peList;
+         (match eOpt with None -> () | Some e -> findInExp e)
+     | Pexp_apply (e, leList) -> findInExp e;
+         List.iter (fun (l, e) -> addStr l loc false; findInExp e) leList
+     | Pexp_match (e, peList) -> findInExp e; findInPEList peList
+     | Pexp_try (e, peList) -> findInExp e; findInPEList peList
+     | Pexp_tuple eList -> List.iter findInExp eList
+     | Pexp_construct (id, eOpt, b) -> addId id loc false; (match eOpt with None -> () | Some e -> findInExp e)
+     | Pexp_variant (lab, eOpt) -> addStr lab loc false; (match eOpt with None -> () | Some e -> findInExp e)
+     | Pexp_record (ideList, eOpt) ->
+         List.iter (fun (id, e) -> addId id loc false; findInExp e) ideList;
+         (match eOpt with None -> () | Some e -> findInExp e)
+     | Pexp_field (e, id) -> findInExp e; addId id loc false
+     | Pexp_setfield (e1, id, e2) -> findInExp e1; addId id loc false; findInExp e2
+     | Pexp_array eList -> List.iter findInExp eList
+     | Pexp_ifthenelse (e1,e2,e3Opt) -> findInExp e1; findInExp e2;
+         (match e3Opt with None -> () | Some e -> findInExp e)
+     | Pexp_sequence (e1, e2) -> findInExp e1; findInExp e2
+     | Pexp_while (e1, e2) -> findInExp e1; findInExp e2
+     | Pexp_for (s, e1, e2, d, e3) -> addStr s loc true; findInExp e1; findInExp e2; findInExp e3
+     | Pexp_constraint (e, ty1Opt, ty2Opt) -> findInExp e;
+         (match ty1Opt with None -> () | Some t -> findInTyp t);
+         (match ty2Opt with None -> () | Some t -> findInTyp t)
+     | Pexp_when (e1, e2) -> findInExp e1; findInExp e2
+     | Pexp_send (e, s) -> findInExp e; addStr s loc false
+     | Pexp_new id -> addId id loc false
+     | Pexp_setinstvar (s, e) -> addStr s loc false; findInExp e
+     | Pexp_override seList -> List.iter (fun (s, e) -> addStr s loc false; findInExp e) seList
+     | Pexp_letmodule (s, md, e) -> addStr s loc true; findInMod md; findInExp e
+     | Pexp_assert e -> findInExp e;
+     | Pexp_assertfalse -> ()
+     | Pexp_lazy e -> findInExp e
+     | Pexp_poly (e, tyOpt) -> findInExp e;
+         (match tyOpt with None -> () | Some t -> findInTyp t)
+     | Pexp_object (p, cfList) -> findInPat p; List.iter (fun clfield -> findInClfield clfield loc) cfList
+   and findInMod md =
+     let loc = md.pmod_loc in
+     match md.pmod_desc with
+       Pmod_ident id -> addId id loc false
+     | Pmod_structure str -> findInStr str
+     | Pmod_functor (s, mty, md) -> addStr s loc true; findInModty mty; findInMod md
+     | Pmod_apply (md1, md2) -> findInMod md1; findInMod md2
+     | Pmod_constraint (md, mty) -> findInMod md; findInModty mty
+   and findInModty mty =
+     let loc = mty.pmty_loc in
+     match mty.pmty_desc with
+       Pmty_ident id -> addId id loc false
+     | Pmty_signature sigList -> List.iter findInSigitem sigList
+     | Pmty_functor (s, mty1, mty2) -> addStr s loc true; findInModty mty1; findInModty mty2
+     | Pmty_with (mty, idconstrList) -> findInModty mty; 
+         List.iter (fun (id, constr) -> addId id loc true;
+           match constr with
+             Pwith_type tydec -> findInTydec tydec
+           | Pwith_module id -> addId id loc false) idconstrList
+   and findInSigitem sigitem =
+     let loc = sigitem.psig_loc in
+     match sigitem.psig_desc with
+       Psig_value (s, valu) -> addStr s loc true; findInValue valu loc
+     | Psig_type styList -> List.iter (fun (s, ty) -> addStr s loc true; findInTydec ty) styList
+     | Psig_exception (s, tyList) -> addStr s loc true; List.iter findInTyp tyList
+     | Psig_module (s, mty) -> addStr s loc true; findInModty mty
+     | Psig_recmodule smtyList -> List.iter (fun (s, mty) -> addStr s loc true; findInModty mty) smtyList
+     | Psig_modtype (s, mtydec) -> addStr s loc true;
+         (match mtydec with Pmodtype_abstract -> () | Pmodtype_manifest mty -> findInModty mty)
+     | Psig_open id -> addId id loc false
+     | Psig_include mty -> findInModty mty
+     | Psig_class cldecList -> List.iter findInCldesc cldecList
+     | Psig_class_type cltydecList -> List.iter findInCltydec cltydecList
+   and findInTyp ty =
+     let loc = ty.ptyp_loc in
+     match ty.ptyp_desc with
+       Ptyp_any -> ()
+     | Ptyp_var s -> addStr s loc false
+     | Ptyp_arrow (l, t1, t2) -> addStr l loc false; findInTyp t1; findInTyp t2
+     | Ptyp_tuple tList -> List.iter findInTyp tList
+     | Ptyp_constr (id, tList) -> addId id loc false; List.iter findInTyp tList
+     | Ptyp_object cftList -> List.iter findInCfty cftList
+     | Ptyp_class (id, tList, lList) -> addId id loc true; List.iter (fun str -> addStr str loc false) lList; List.iter findInTyp tList
+     | Ptyp_alias (ty, s) -> findInTyp ty; addStr s loc false
+     | Ptyp_variant (rList, b, lListOpt) -> List.iter (fun rf -> findInRfield rf loc) rList;
+         (match lListOpt with None -> () | Some lList -> List.iter (fun str -> addStr str loc false) lList)
+     | Ptyp_poly (sList, ty) -> findInTyp ty; List.iter (fun str -> addStr str loc false) sList
+   and findInRfield rf loc =
+     match rf with
+       Rtag (l, b, tList) -> addStr l loc true; List.iter findInTyp tList
+     | Rinherit ty -> findInTyp ty
+   and findInCfty cft =
+     let loc = cft.pfield_loc in
+     match cft.pfield_desc with
+       Pfield (s, ty) -> addStr s loc false; findInTyp ty
+     | Pfield_var -> ()
+   and findInCldec cli = 
+     let loc = cli.pci_loc in
+     List.iter (fun str -> addStr str loc true) (fst cli.pci_params);
+     addStr cli.pci_name loc true;
+     findInClexp cli.pci_expr
+   and findInCldesc cli =
+     let loc = cli.pci_loc in
+     List.iter (fun str -> addStr str loc true) (fst cli.pci_params);
+     addStr cli.pci_name loc true;
+     findInClty cli.pci_expr
+   and findInCltydec cli = findInCldesc cli
+   and findInClfield clfield loc =
+     match clfield with
+       Pcf_inher (clexp, sOpt) -> findInClexp clexp;
+         (match sOpt with None -> () | Some s -> addStr s loc true)
+     | Pcf_val (s, mut, e, loc) -> addStr s loc true; findInExp e
+     | Pcf_virt (s, priv, ty, loc) -> addStr s loc true; findInTyp ty
+     | Pcf_meth (s, priv, e, loc) -> addStr s loc true; findInExp e
+     | Pcf_cstr (t1, t2, loc) -> findInTyp t1; findInTyp t2
+     | Pcf_let (r, peList, loc) -> List.iter (fun (p, e) -> findInPat p; findInExp e) peList
+     | Pcf_init e -> findInExp e
+   and findInClexp cle =
+     let loc = cle.pcl_loc in
+     match cle.pcl_desc with
+       Pcl_constr (id, tyList) -> addId id loc true; List.iter findInTyp tyList
+     | Pcl_structure (p, cfList) -> findInPat p; List.iter (fun clfield -> findInClfield clfield loc) cfList
+     | Pcl_fun (l, eOpt, p, cle) -> addStr l loc true; findInPat p; findInClexp cle;
+         (match eOpt with None -> () | Some e -> findInExp e)
+     | Pcl_apply (cle, leList) -> findInClexp cle; List.iter (fun (l, e) -> addStr l loc false; findInExp e) leList
+     | Pcl_let (r, peList, cle) -> findInClexp cle; List.iter (fun (p, e) -> findInPat p; findInExp e) peList
+     | Pcl_constraint (cle, clt) -> findInClexp cle; findInClty clt
+   and findInClty clt =
+     let loc = clt.pcty_loc in
+     match clt.pcty_desc with
+       Pcty_constr (id, tyList) -> addId id loc true; List.iter findInTyp tyList
+     | Pcty_signature (ty, ctfList) -> findInTyp ty; List.iter (fun ctf -> findInCltyfield ctf loc) ctfList
+     | Pcty_fun (l, t, clty) -> addStr l loc false; findInTyp t; findInClty clty
+   and findInCltyfield ctf loc = 
+     match ctf with
+       Pctf_inher cty -> findInClty cty
+     | Pctf_val (s, mut, tOpt, loc') -> addStr s loc false; (match tOpt with None -> () | Some t -> findInTyp t)
+     | Pctf_virt (s, priv, ty, loc') -> addStr s loc false; findInTyp ty
+     | Pctf_meth (s, priv, ty, loc') -> addStr s loc false; findInTyp ty
+     | Pctf_cstr (t1, t2, loc') -> findInTyp t1; findInTyp t2
+   in 
+   astStrLIds := StrLIdMap.empty;
+   findInStr ast
+ 
+ let strLIdsOf ast =
+   let temp = !astStrLIds in
+   collectStrIDs ast;
+   let result = !astStrLIds in
+   astStrLIds := temp;
+   result
+ 
+ 
+ let nearestDefStrLId strlid loc = (* nearest definition of strlid from given loc *)
+   try
+     (* locations are in reversed pre-order, which means that the first location 
+      * in the list is the last location in the source file *)
+     Some (List.find (fun (defloc, isdef) -> isdef && locAfter loc defloc) 
+             (safeLookup astStrLIds strlid))
+   with Not_found -> None
+ let reachingDefStrLId loc = (* all other definitions which reach this location *)
+   StrLIdMap.fold (fun strlid loclist acc -> 
+     let reachingdefs = (List.filter (fun (defloc, isdef) -> isdef && locAfter loc defloc) loclist) in
+     if reachingdefs != [] then StrLIdMap.add strlid reachingdefs acc else acc
+               ) !astStrLIds StrLIdMap.empty
+ 
+ let printStrLIdMap map = 
+   StrLIdMap.iter (fun strlid deflocs ->
+     print_string ("Str: \'" ^ strlid ^ "\' => [\n");
+     List.iter (fun (loc, isdef) -> print_string (if isdef then "Def: " else "     "); 
+       Location.print std_formatter loc) deflocs;
+     print_string "]\n") map
+ 
+ 
+ let tryStrs loc f = 
+   (* (let temp = reachingDefStrLId loc in
+   print_string "Printing reaching defs for "; Location.print std_formatter loc;
+   printStrLIdMap temp); *)
+   StrLIdMap.fold (fun s _ acc -> (f s)::acc) !astStrLIds []
+ 
+ 
+ 
+ (* Based on Longest Common Subsequence algorithm from CLRS, sec15.4 *)
+ let stringEditDistance s1 s2 =
+   let len1 = String.length s1 in
+   let len2 = String.length s2 in
+   let idDist = Array.make_matrix (len1+1) (len2+1) 0 in
+   for i = 0 to len1 do
+     idDist.(i).(0) <- i
+   done;
+   for j = 0 to len2 do
+     idDist.(0).(j) <- j
+   done;
+   for j = 1 to len2 do
+     for i = 1 to len1 do
+       idDist.(i).(j) <- 1+ (min idDist.(i-1).(j) idDist.(i).(j-1));
+       if (s1.[i-1] = s2.[j-1]) then
+         idDist.(i).(j) <- (min idDist.(i).(j) idDist.(i-1).(j-1));
+     done
+   done;
+   idDist.(len1).(len2)
+ 
+ 
+ 
+ module CachedIDIDsMap = Map.Make(struct type t = string let compare = compare end)
+ let strIDsCache = ref CachedIDIDsMap.empty
+ module StrIDStrs = Set.Make(struct type t = string let compare = compare end)
+ let allStrIDs = ref StrIDStrs.empty
+ let tryIDs id loc f = 
+   (* (let temp = reachingDefStrLId loc in
+   print_string "Printing reaching defs for "; Location.print std_formatter loc;
+   printStrLIdMap temp); *)
+   let asLId strlid = strToLongident strlid in
+   let asStr strlid = strlid in
+   let refstr = longidentToStr id in
+   let compareStrIDsTo refstr str1 str2 = 
+     let strdist = compare (stringEditDistance refstr str1) (stringEditDistance refstr str2) in
+     if strdist = 0 then compare str1 str2 else strdist in
+   if !allStrIDs = StrIDStrs.empty then 
+     allStrIDs := StrLIdMap.fold (fun s _ acc -> StrIDStrs.add (asStr s) acc) !astStrLIds StrIDStrs.empty;
+   if (CachedIDIDsMap.mem refstr !strIDsCache) then
+     List.rev_map f (CachedIDIDsMap.find refstr !strIDsCache)
+   else begin
+     let res = List.map (fun s -> (s, stringEditDistance refstr s)) (StrIDStrs.elements !allStrIDs) in
+     let res = fst (List.split (List.sort (fun (s1,d1) (s2,d2) -> compare d1 d2) res)) in
+     let rec first n lst acc = 
+       if n = 0 then acc else 
+       match lst with
+         [] -> acc
+       | hd::tl -> first (n-1) tl ((strToLongident hd)::acc ) in
+     let res = first 10 res [] in
+     strIDsCache := CachedIDIDsMap.add refstr res (!strIDsCache);
+     List.rev_map f res
+   end
+ 
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ 
+ (* XXXXXXXXXXXXXXXXXXX Collect top-level type constructors XXXXXXXXXXXXXXXX *)
+ let astTypeIds = ref StrLIdMap.empty
+ let collectTypeIDs ast =
+   let rec addStr str loc isShadow = safeUpdate astTypeIds (str) loc isShadow
+   and findInStr str =
+     List.iter (fun stritem -> findInStritem stritem) str
+   and findInStritem stritem =
+     match stritem.pstr_desc with
+       Pstr_type tytydecList -> List.iter (fun (typ, tydec) -> findInTydec tydec) tytydecList
+     | _ -> ()
+   and findInTydec tydec =
+     let loc = tydec.ptype_loc in
+     findInTykind tydec.ptype_kind loc;
+   and findInTykind tkn loc =
+     match tkn with
+       Ptype_abstract -> ()
+     | Ptype_variant (strtyListList, priv_flag) ->
+         List.iter (fun (str, tylist) -> 
+           let prevBindings = safeLookup astTypeIds str in
+           match prevBindings with
+             [] -> addStr str loc false
+           | (loc', shadowed)::tl -> addStr str loc' true) strtyListList
+     | Ptype_record (strmuttyList, priv_flat) -> ()
+   in 
+   astTypeIds := StrLIdMap.empty;
+   findInStr ast
+ 
+ let findShadowedIDs ast =
+   let unAst = match ast with
+     Str a -> a
+   | Exp a -> [{pstr_desc = Pstr_eval a; pstr_loc = !locNone}]
+   | StrItem a -> [a]
+   | Pat a -> [{pstr_desc = Pstr_value (Asttypes.Default, [a, alphaExp "NOT_A_MATCH" !locNone]); pstr_loc = !locNone}]
+   | Typ a -> [{pstr_desc = Pstr_eval {pexp_desc = Pexp_poly (alphaExp "NOT_A_MATCH" !locNone, Some a); pexp_loc = !locNone}; pstr_loc = !locNone}]
+   | Mod a -> [{pstr_desc = Pstr_module ("NOT_A_MATCH", a); pstr_loc = !locNone}]
+   | Modty a -> [{pstr_desc = Pstr_modtype ("NOT_A_MATCH", a); pstr_loc = !locNone}]
+   | Tydec a -> [{pstr_desc = Pstr_type ["NOT_A_MATCH", a]; pstr_loc = !locNone}]
+   | Cldec a -> [{pstr_desc = Pstr_class [a]; pstr_loc = !locNone}]
+   | Cldesc a -> [{pstr_desc = Pstr_modtype ("NOT_A_MATCH", {pmty_desc = Pmty_signature [{psig_desc = Psig_class [a]; psig_loc = !locNone}]; pmty_loc = !locNone}); pstr_loc = !locNone}]
+   | Cltydec a -> [{pstr_desc = Pstr_class_type [a]; pstr_loc = !locNone}]
+   | Clfield a -> [{pstr_desc = Pstr_class [{pci_virt = Asttypes.Concrete; 
+                                             pci_params = ([], !locNone); 
+                                             pci_name = "NOT_A_MATCH"; 
+                                             pci_expr = {pcl_desc = Pcl_structure (alphaPat !locNone, [a]); 
+                                                         pcl_loc = !locNone}; 
+                                             pci_variance = []; 
+                                             pci_loc = !locNone}]; 
+                    pstr_loc = !locNone}]
+   | Clexp a -> [{pstr_desc = Pstr_class [{pci_virt = Asttypes.Concrete; pci_params = ([], !locNone); pci_name = "NOT_A_MATCH"; pci_expr = a; pci_variance = []; pci_loc = !locNone}]; pstr_loc = !locNone}]
+   | Sigitem a -> [{pstr_desc = Pstr_modtype ("NOT_A_MATCH", {pmty_desc = Pmty_signature [a]; pmty_loc = !locNone}); pstr_loc = !locNone}]
+   | Clty a -> [{pstr_desc = Pstr_modtype ("NOT_A_MATCH", {pmty_desc = Pmty_signature [{psig_desc = Psig_class [{pci_virt = Asttypes.Concrete; 
+                                                                                                                 pci_params = ([], !locNone); 
+                                                                                                                 pci_name = "NOT_A_MATCH"; 
+                                                                                                                 pci_expr = a; pci_variance = []; 
+                                                                                                                 pci_loc = !locNone}]; 
+                                                                                        psig_loc = !locNone}]; 
+                                                           pmty_loc = !locNone}); 
+                 pstr_loc = !locNone}]
+   | Cltyfield a -> [{pstr_desc = Pstr_modtype ("NOT_A_MATCH", {pmty_desc = Pmty_signature [{psig_desc = Psig_class_type [{pci_virt = Asttypes.Concrete; 
+                                                                                                                           pci_params = ([], !locNone); 
+                                                                                                                           pci_name = "NOT_A_MATCH"; 
+                                                                                                                           pci_expr = {pcty_desc = Pcty_signature (alphaTyp !locNone, [a]); 
+                                                                                                                                       pcty_loc = !locNone}; 
+                                                                                                                           pci_variance = []; 
+                                                                                                                           pci_loc = !locNone}]; 
+                                                                                             psig_loc = !locNone}]; 
+                                                                pmty_loc = !locNone}); 
+                      pstr_loc = !locNone}]
+   in
+ 
+   let ids = strLIdsOf unAst in
+   StrLIdMap.fold (fun id binding shadowed -> 
+     match safeLookup astTypeIds id with
+       (_, true)::tl -> id :: shadowed
+     | _ -> shadowed) ids []
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ (* XXXXXXXXXXXXXXXXX  Single-point Modification Enumerators  XXXXXXXXXXXXXXX *)
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ 
+ let totalFixNesteds = ref 0
+ let totalDelays = ref 0
+ let matchCache : expression list ref = ref []
+ let matchCacheExceptions : expression list ref = ref []
+ let fixNestedTrysMatchsFunctions exp =
+   let replaceExp = replaceExp (Exp exp) in (* pre-bind the first argument *)
+   totalFixNesteds := !totalFixNesteds + 1;
+   let catchAll = (alphaPat !locNone, alphaExp "temporaryPlaceholder" !locNone) in
+   let rec lastSeq e =
+     match e.pexp_desc with
+       Pexp_sequence(_, e') -> lastSeq e'
+     | Pexp_let(_, _, e') -> lastSeq e'
+     | _ -> e in
+   let flattenDepthPEList peList =
+     let rec flattenPE d revPEList (pat, exp) =
+       let flattenPE = flattenPE (d+1) in
+       match exp.pexp_desc with 
+         Pexp_match(e', peList') ->           List.fold_left flattenPE ((d, (pat, {exp with pexp_desc = Pexp_match(e', [])}))           :: revPEList) peList'
+       | Pexp_try(e', peList') ->             List.fold_left flattenPE ((d, (pat, {exp with pexp_desc = Pexp_try(e', [])}))             :: revPEList) peList'
+       | Pexp_function(l', dOpt', peList') -> List.fold_left flattenPE ((d, (pat, {exp with pexp_desc = Pexp_function(l', dOpt', [])})) :: revPEList) peList'
+       | Pexp_sequence(e1, e2) -> 
+           let flattenTail = List.rev (flattenPE [] (pat, e2)) in (* pat doesn't really matter, since it can only be used in the head of the returned list, which will be modified anyway *)
+           (match flattenTail with
+             [] -> (d, (pat, exp)) :: revPEList
+           | hd::tl ->
+               List.rev_append tl ((d, (pat, {exp with pexp_desc = Pexp_sequence(e1, snd (snd hd))})) :: revPEList) (* this takes the front of the list, and wraps the sequence back around it *)
+           )
+       | Pexp_let(r, peList, e) ->
+           let flattenTail = List.rev (flattenPE [] (pat, e)) in  (* pat doesn't really matter, since it can only be used in the head of the returned list, which will be modified anyway *)
+           (match flattenTail with
+             [] -> (d, (pat, exp)) :: revPEList
+           | hd::tl ->
+               List.rev_append tl ((d, (pat, {exp with pexp_desc = Pexp_let(r, peList, snd (snd hd))})) :: revPEList) (* this takes the front of the list, and wraps the let back around it *)
+           )
+       | _ -> (d, (pat, exp)) :: revPEList in
+     List.rev (List.fold_left (flattenPE 0) []  peList) in
+   let flattenPEList peList = (List.map snd (flattenDepthPEList peList)) in
+   let rec stripTemporaries exp =
+     let filterCA peList = List.filter (function pe -> pe <> catchAll) peList in
+     let peStrip (p, e) = (p, stripTemporaries e) in
+     let recStrip peList = List.map peStrip (filterCA peList) in
+     match exp.pexp_desc with 
+       Pexp_match(e', peList) ->          {exp with pexp_desc = Pexp_match(e', recStrip peList)}
+     | Pexp_try(e', peList) ->            {exp with pexp_desc = Pexp_try(e', recStrip peList)}
+     | Pexp_function(l', dOpt, peList) -> {exp with pexp_desc = Pexp_function(l', dOpt, recStrip peList)}
+     | Pexp_let(r, peList, e') ->         {exp with pexp_desc = Pexp_let(r, peList, stripTemporaries e')}
+     | Pexp_sequence(e1, e2) ->           {exp with pexp_desc = Pexp_sequence(e1, stripTemporaries e2)}
+     | _ -> exp in
+   let checkNoTemporaries exp =
+     match exp.pexp_desc with 
+       Pexp_match(_, peList) | Pexp_try(_, peList) | Pexp_function(_, _, peList) ->
+         not (List.exists (function pe -> pe = catchAll) (flattenPEList peList))
+     | _ -> true in
+   let checkRightLength exp target =
+     match exp.pexp_desc with
+       Pexp_match(_, peList) | Pexp_try(_, peList) | Pexp_function(_, _, peList) ->
+         List.length(flattenPEList peList) = target
+     | _ -> true in
+   let rec checkNoEmpties exp =
+     match exp.pexp_desc with
+       Pexp_match(_, peList) | Pexp_try(_, peList) | Pexp_function(_, _, peList) ->
+         (List.length peList > 0) && (List.for_all (checkNoEmpties <<== snd) peList)
+     | Pexp_sequence(e1, e2) -> checkNoEmpties e2
+     | Pexp_let(r, peList, e) -> checkNoEmpties e
+     | _ -> true in
+   let rebuildToSingleRecur e' followupMods target =
+     (followup [replaceExp (declareException "temporaryPlaceholder")
+        (function () -> e')
+        (function _ -> (checkNoTemporaries e') && (checkRightLength e' target) && (checkNoEmpties e'))
+        "Reparenthesized nested matches, trys or functions one at a time."
+        (t("Exp_TryMatch_Reparenthesize"))
+        exp.pexp_loc]
+        followupMods) in     
+   let rebuildNestedTryMatch (exp' : expression) : astMod list =
+     let rec appendToExp exp peAppend = (* attaches the (pat, exp) pair peAppend to any open match or try in exp *)
+       let mapAllNewPELists newExpDesc peList' = List.map (function peList -> {exp with pexp_desc = newExpDesc peList}) (allNewPELists peList' peAppend) in
+       match exp.pexp_desc with
+         Pexp_match(e', peList) ->          mapAllNewPELists (fun peL -> Pexp_match(e', peL))          peList
+       | Pexp_try(e', peList) ->            mapAllNewPELists (fun peL -> Pexp_try(e', peL))            peList
+       | Pexp_function(l', dOpt, peList) -> mapAllNewPELists (fun peL -> Pexp_function(l', dOpt, peL)) peList
+       | Pexp_sequence(e1, e2) ->
+           List.map (function e2' -> {exp with pexp_desc = Pexp_sequence(e1, e2')}) (appendToExp e2 peAppend)
+       | Pexp_let(r, peList, e) ->
+           List.map (function e' -> {exp with pexp_desc = Pexp_let(r, peList, e')}) (appendToExp e peAppend)
+       | _ -> []
+     and allNewPELists peList peAdd =
+       let revPeList = List.rev peList in
+       match revPeList with
+         ca :: (p,e) :: front when (ca = catchAll) -> rebuildPELists peAdd (p,e) front
+       | (p, e) :: front -> rebuildPELists peAdd (p,e) front (* can't be one case because of the guard *)
+       | [] -> [[peAdd; catchAll]]
+     and rebuildPELists peAdd (p,e) front =
+       let insertPE = List.rev (catchAll :: peAdd :: (p,e) :: front) in
+       let recursiveInsertPE =
+         (match e.pexp_desc with
+           Pexp_match _ | Pexp_try _ | Pexp_function _ | Pexp_sequence _ | Pexp_let _ ->
+             List.map (function e' -> List.rev (catchAll :: (p, e') :: front)) (appendToExp e peAdd)
+         | _ -> []) in   
+       insertPE :: recursiveInsertPE in
+     let rec delaySingleRecurs exp peList targetLen : astMod list =
+       totalDelays := !totalDelays + 1;
+       match peList with
+         [] -> [rebuildToSingleRecur (stripTemporaries exp) (function _ -> []) targetLen]
+       | pe'' :: peList' ->
+           let allAppends = appendToExp exp pe'' in
+           let laterSingleRecurs expWpe = function _ -> (delaySingleRecurs expWpe peList' targetLen) in (* expWpe is exp, with pe appended within it *)
+           List.map (function expWpe -> rebuildToSingleRecur exp (laterSingleRecurs expWpe) targetLen) allAppends in
+     let flattenAndDelay newExpDesc peList =
+       let flat = (flattenPEList peList) in
+       delaySingleRecurs {exp' with pexp_desc = newExpDesc} flat (List.length flat) in
+     match exp'.pexp_desc with
+       Pexp_match(e', peList') ->           flattenAndDelay (Pexp_match(e', []))           peList'
+     | Pexp_try(e', peList') ->             flattenAndDelay (Pexp_try(e', []))             peList'
+     | Pexp_function(l', dOpt', peList') -> flattenAndDelay (Pexp_function(l', dOpt', [])) peList'
+     | _ -> [] in
+   let isNestedTryMatch peList = 
+     List.exists (function pat_exp ->
+       match (lastSeq (snd pat_exp)).pexp_desc with
+         Pexp_match _ | Pexp_try _ | Pexp_function _ -> true
+       | _ -> false) peList in
+   let flatPEList exp = match exp.pexp_desc with 
+     Pexp_match(_, peList) | Pexp_try(_, peList) | Pexp_function(_, _, peList) -> flattenPEList peList | _ -> [] in
+   let isCached exp = 
+     let flatPE = flatPEList exp in
+         (List.exists (fun exp' -> locInside exp.pexp_loc exp'.pexp_loc && (flatPEList exp') = flatPE) !matchCache) && 
+     not (List.exists (fun exp' -> locInside exp.pexp_loc exp'.pexp_loc) !matchCacheExceptions) in
+   let cache suggestions = 
+     matchCache := exp :: !matchCache; 
+     let rec whitelistLeftSeqs exp =
+       match exp.pexp_desc with
+         Pexp_sequence(e1, e2) -> matchCacheExceptions := e1 :: !matchCacheExceptions
+       | Pexp_let(r, peList, e) -> matchCacheExceptions := List.rev_append (List.map snd peList) !matchCacheExceptions
+       | Pexp_match(_, peList) | Pexp_try(_, peList) | Pexp_function(_, _, peList) -> 
+           List.iter (fun (_,e) -> whitelistLeftSeqs e) peList
+       | _ -> ()
+     in whitelistLeftSeqs exp;
+     suggestions in 
+   match exp.pexp_desc with
+     Pexp_match(_, pat_exp_list) | Pexp_try(_, pat_exp_list) | Pexp_function(_, _, pat_exp_list) ->
+       if (isNestedTryMatch pat_exp_list) then begin 
+         if (isCached exp) then ((* print_string "cached, ignoring\n"; Printcode.expression std_formatter exp; *) print_string "\n"; [])
+         else ((* print_string "Not ignored: "; Printcode.expression std_formatter exp; print_string "\n"; *) cache (rebuildNestedTryMatch exp))
+       end else []
+   | _ -> assert false; []
+ 
+ 
+ 
+ 
+ let destructStr str locOpt =
+   let replaceStr = replaceStr (Str str) in (* pre-bind the first argument *)
+   match locOpt with
+     None -> []
+   | Some loc -> 
+       let truncatedStructure = 
+         List.rev (List.filter (function sItem -> locBefore sItem.pstr_loc loc || locInside loc sItem.pstr_loc) str)
+       in
+       begin match truncatedStructure with
+         [] -> []
+       | hd :: tl ->
+           [recurStritemStr (hd, (function str_item' -> List.rev (str_item' :: tl)))]
+       end 
+             
+ let destructStrItem strItem locOpt = 
+   let replaceStritem = replaceStritem (StrItem strItem) in (* pre-bind the first argument *)
+   if not (shouldTryFix strItem.pstr_loc locOpt) then [] else
+   let genericSingleReplacement =
+     (replaceStritem (declareException "RemoveStritem")
+        (function () -> alphaStritem "RemoveStritem" strItem.pstr_loc)
+        alwaysValid
+        "Replaced stritem with _"
+        (t("Stritem_Remove"))
+        strItem.pstr_loc) in
+   let otherSingleReplacements = 
+     match strItem.pstr_desc with
+       Pstr_eval e -> 
+         (* let _ = e, so just evaluate e *)
+         (* Possible errors:
+          * Any expression error
+          *)
+         (* Possible fixes:
+          * fixing the subexpression
+          *)
+         [recurExpStritem (e, (function exp' -> {strItem with pstr_desc = Pstr_eval exp'}))]
+     | Pstr_value(rec_flag, pat_exp_list) -> 
+         (* let (rec) bindings *)
+         (* Possible errors:
+          * Any errors in bindings
+          *)
+         (* Possible fixes:
+          * deleting the whole list
+          * marking the pattern recursive if it wasn't already
+          * fixing an individual expression to match the pattern it's bound to
+          * fixing an individual pattern to not constrain the expression it binds
+          *)
+         let removeAll = 
+           (replaceStritem []
+              (function () -> {strItem with pstr_desc = Pstr_value (Asttypes.Recursive, [])})
+              alwaysValid
+              ("Removed the binding list at " ^ (sourceFromLoc strItem.pstr_loc))
+              (t("Str_Value_RemoveAll"))
+              strItem.pstr_loc) in
+         let fixRec = 
+           (replaceStritem []
+              (function () -> {strItem with pstr_desc = Pstr_value (Asttypes.Recursive, pat_exp_list)})
+              alwaysValid
+              ("Added rec flag to " ^ (sourceFromLoc strItem.pstr_loc))
+              (t("Str_Value_FixRec"))
+              strItem.pstr_loc) in
+         let fixPatExps = 
+           let processSinglePatExp n (pat, exp) =
+             [
+              recurPatStritem (pat, (function pat' ->
+                {strItem with pstr_desc = 
+                 Pstr_value(rec_flag, (replaceNthWith pat_exp_list n (pat', exp)))}));
+              recurExpStritem (exp, (function exp' ->
+                {strItem with pstr_desc = 
+                 Pstr_value(rec_flag, (replaceNthWith pat_exp_list n (pat, exp')))}));
+            ] in
+           map_at_and_flatten processSinglePatExp pat_exp_list in
+         if (rec_flag <> Asttypes.Recursive) 
+         then fixRec ::  removeAll :: fixPatExps
+         else removeAll :: fixPatExps
+     | Pstr_primitive(prim, value_desc) -> 
+         (* external foo : tau = "c-function" *)
+         (* Possible errors:
+          * Any type error from transl_type
+          *)
+         (* Possible fixes:
+          * fix the type
+          *)
+         [recurTypStritem (value_desc.pval_type, (function ty' ->
+             {strItem with pstr_desc = 
+              Pstr_primitive (prim, {pval_type = ty';
+                                     pval_prim = value_desc.pval_prim})}));
+        ]
+     | Pstr_type str_ty_list -> 
+         (* type declarations *)
+         (* Possible errors:
+          * Any type error from transl_type
+          *)
+         (* Possible fixes:
+          * fix a type subexpression
+          *)
+         let fixStrTys =
+           let processSingleStrTy n (str, ty) =
+             recurTypdecStritem (ty, (function ty' ->
+                {strItem with pstr_desc = 
+                 Pstr_type (replaceNthWith str_ty_list n (str, ty'))}))
+           in
+           map_at processSingleStrTy str_ty_list
+         in fixStrTys
+     | Pstr_exception(name, exn) -> 
+         (* exception Foo of Bar *)
+         (* Possible errors:
+          * Any error from transl_type
+          *)
+         (* Possible fixes:
+          * remove the body list altogether
+          * generalize one of the types in the list -- but polymorphic exceptions not allowed? not sure what to do
+          *)
+         [(replaceStritem []
+             (function () -> {strItem with pstr_desc = Pstr_exception(name, [])})
+             alwaysValid
+             ("Removed body of exception constructor " ^ (sourceFromLoc strItem.pstr_loc))
+             (t("Str_Exception_RemoveBody"))
+             strItem.pstr_loc)
+        ]
+     | Pstr_exn_rebind(newName, oldName) -> 
+         (* exception Foo = Baz *)
+         (* Possible errors:
+          * Unbound_exception
+          * Not_an_exception
+          *)
+         (* Possible fixes:
+          * SingleReplace with newly declared exception
+          *)
+         [(replaceStritem [] 
+             (function () -> {strItem with pstr_desc = Pstr_exception(newName, [])})
+             alwaysValid
+             ("Unaliased exception " ^ (sourceFromLoc strItem.pstr_loc))
+             (t("Str_ExnRebind_Unalias"))
+             strItem.pstr_loc)
+        ]
+     | Pstr_module(name, modexp) -> 
+         (* module Name = ModuleExpression *)
+         (* Possible errors:
+          * Any module error
+          *)
+         (* Possible fixes:
+          * fixing the module
+          *)
+         [recurModStritem (modexp, (function mod' -> {strItem with pstr_desc = Pstr_module(name, mod')}))]
+     | Pstr_recmodule(str_modty_modexp_list) -> 
+         (* module rec Name1 : Modty1 = ModExp1 and Name2 : Modty2 = ModExp2 and ... *)
+         (* Possible errors:
+          * Any module expression error
+          * Any module type error
+          *)
+         (* Possible fixes:
+          * Remove a single binding
+          * Remove all bindings
+          * Fix a module expression
+          * Fix a module type
+          *)
+         let removeAll =
+           (replaceStritem []
+              (function () -> {strItem with pstr_desc = Pstr_recmodule []})
+              alwaysValid
+              ("Removed the module binding list at " ^ (sourceFromLoc strItem.pstr_loc))
+              (t("Str_Recmodule_RemoveAll"))
+              strItem.pstr_loc) in
+         let fixModModtys =
+           let processSingleModModty n (name, mty, mdl) =
+             [
+              recurModStritem (mdl, (function mdl' ->
+                 {strItem with pstr_desc = 
+                  Pstr_recmodule (replaceNthWith str_modty_modexp_list n (name, mty, mdl'))}));
+              recurModtyStritem (mty, (function mty' ->
+                 {strItem with pstr_desc = 
+                  Pstr_recmodule (replaceNthWith str_modty_modexp_list n (name, mty', mdl))}));
+              (replaceStritem []
+                 (function () -> {strItem with pstr_desc = Pstr_recmodule (removeNth n str_modty_modexp_list)})
+                 alwaysValid
+                 ("Removed module binding " ^ string_of_int(n))
+                 (t("Str_Recmodule_RemoveOne"))
+                 strItem.pstr_loc)
+            ] in
+           map_at_and_flatten processSingleModModty str_modty_modexp_list in
+         removeAll :: fixModModtys
+     | Pstr_modtype(name, modty) -> 
+         (* module type Name = ModuleType *)
+         (* Possible errors:
+          * Any module type error
+          *)
+         (* Possible fixes:
+          * fixing the module type
+          *)
+         [recurModtyStritem (modty, (function mty' ->
+             {strItem with pstr_desc = 
+              Pstr_modtype(name, mty')}));
+        ]
+     | Pstr_open name -> 
+         (* open ModuleName *)
+         (* Possible errors:
+          * Unbound_module
+          * Structure_expected
+          *)
+         (* Possible fixes:
+          * Remove the open directive, even if it causes later errors
+          *)
+         [(replaceStritem (declareException "OpenDirectiveRemoved")
+             (function () -> 
+               {strItem with pstr_desc = 
+                Pstr_eval (alphaExp "OpenDirectiveRemoved" strItem.pstr_loc)})
+             alwaysValid
+             ("Removed the directive " ^ (sourceFromLoc strItem.pstr_loc))
+             (t("Str_Open_Remove"))
+             strItem.pstr_loc)
+        ]
+     | Pstr_class class_dec_list -> 
+         (* class (virtual) (type_params) Name1 = ClsExp1 and Name2 : ClsTy2 = ClsExp2 and ... *)
+         (* Possible errors:
+          * Any class declaration error
+          *)
+         (* Possible fixes:
+          * Remove a single binding
+          * Remove all bindings
+          * Fix a class declaration
+          *)
+         let removeAll =
+           (replaceStritem [] 
+              (function () -> {strItem with pstr_desc = Pstr_class []})
+              alwaysValid
+              ("Removed the class binding list at " ^ (sourceFromLoc strItem.pstr_loc))
+              (t("Str_Class_RemoveAll"))
+              strItem.pstr_loc) in
+         let fixClassDecs =
+           let processSingleClass n cls =
+             [
+              recurCldecStritem (cls, (function cls' -> {strItem with pstr_desc = Pstr_class (replaceNthWith class_dec_list n cls')}));
+              (replaceStritem []
+                 (function () -> {strItem with pstr_desc = Pstr_class (removeNth n class_dec_list)})
+                 alwaysValid
+                 ("Removed class binding " ^ string_of_int(n))
+                 (t("Str_Class_RemoveOne"))
+                 strItem.pstr_loc)
+            ] in
+           map_at_and_flatten processSingleClass class_dec_list in
+         removeAll :: fixClassDecs
+     | Pstr_class_type class_ty_dec_list ->
+         (* class type (virtual) (type_params) Name1 = ClsSig1 and Name2 = ClsSig2 and ... *)
+         (* Possible errors:
+          * Any class type declaration error
+          *)
+         (* Possible fixes:
+          * Remove a single binding
+          * Remove all bindings
+          * Fix a class type declaration
+          *)
+         let removeAll =
+           (replaceStritem []
+              (function () -> {strItem with pstr_desc = Pstr_class_type []})
+              alwaysValid
+              ("Removed the class binding list at " ^ (sourceFromLoc strItem.pstr_loc))
+              (t("Str_Class_RemoveAll"))
+              strItem.pstr_loc) in
+         let fixClassTyDecs =
+           let processSingleClassTy n clsty =
+             [
+              recurCltydecStritem (clsty, (function clsty' ->
+                {strItem with pstr_desc = 
+                 Pstr_class_type (replaceNthWith class_ty_dec_list n clsty')}));
+              (replaceStritem []
+                 (function () -> {strItem with pstr_desc = Pstr_class_type (removeNth n class_ty_dec_list)})
+                 alwaysValid
+                 ("Removed class binding " ^ string_of_int(n))
+                 (t("Str_ClassType_RemoveOne"))
+                 strItem.pstr_loc)
+            ] in
+           map_at_and_flatten processSingleClassTy class_ty_dec_list in
+         removeAll :: fixClassTyDecs
+     | Pstr_include modexp -> 
+         (* include ModuleExpression *)
+         (* Possible errors:
+          * Any module error
+          *)
+         (* Possible fixes:
+          * fixing the module
+          *)
+         [recurModStritem (modexp, (function mod' -> 
+             {strItem with pstr_desc = 
+              Pstr_include mod'}));
+         ]
+   in [followup [genericSingleReplacement] (fun _ -> otherSingleReplacements)]
+ 
+ let destructPat pat locOpt = 
+   let replacePat = replacePat (Pat pat) in (* pre-bind the first argument *)
+   if not (shouldTryFix pat.ppat_loc locOpt) then [] else
+   let genericSingleReplacement =
+     (replacePat [] 
+        (function () -> alphaPat pat.ppat_loc)
+        alwaysValid
+        "Replaced pattern with _"
+        (t("Pat_Remove"))
+        pat.ppat_loc) in
+   let otherSingleReplacements =
+     match pat.ppat_desc with
+       Ppat_any -> []
+     | Ppat_var s -> []
+     | Ppat_alias(p, s) ->
+         [
+          recurPatPat (p, (function p' ->
+            {pat with ppat_desc = 
+             Ppat_alias(p', s)}));
+          (replacePat []
+             (function () -> {pat with ppat_desc = Ppat_var s})
+             alwaysValid
+             "Removed subpattern and replaced with aliased variable"
+             (t("Pat_Alias_RemoveSubpat"))
+             p.ppat_loc)
+        ]
+     | Ppat_constant c -> []
+     | Ppat_tuple pList ->
+         let recurOrInsert =
+           let processSinglePat n p =
+             [
+              recurPatPat (p, (function p' ->
+                {pat with ppat_desc = 
+                 Ppat_tuple(replaceNthWith pList n p')}));
+              (replacePat []
+                 (function () -> {pat with ppat_desc = Ppat_tuple(removeNth n pList)})
+                 alwaysValid
+                 ("Removed subpattern " ^ (sourceFromLoc p.ppat_loc))
+                 (t("Pat_Tuple_RemoveSubpat"))
+                 p.ppat_loc)
+            ] in
+           map_at_and_flatten processSinglePat pList in
+         let addPat =
+           let insertSinglePat n _ =
+             (replacePat []
+                (function () -> {pat with ppat_desc = Ppat_tuple(insertNth pList n (alphaPat !locNone))})
+                alwaysValid
+                ("Inserted new pattern before pattern " ^ string_of_int(n))
+                (t("Pat_Tuple_InsertSubpat"))
+                pat.ppat_loc) in
+           map_between insertSinglePat pList in
+         List.flatten (recurOrInsert :: addPat :: [])
+     | Ppat_construct(id, pOpt, b) -> 
+         (match pOpt with
+           None -> []
+         | Some p -> [ recurPatPat (p, function p' ->
+             {pat with ppat_desc =
+              Ppat_construct(id, Some p', b)}) ])
+     | Ppat_variant(l, pOpt) -> 
+         (match pOpt with
+           None -> []
+         | Some p -> [ recurPatPat (p, function p' ->
+             {pat with ppat_desc =
+              Ppat_variant(l, Some p')}) ])
+     | Ppat_record idpList -> []
+     | Ppat_array pList -> 
+         let recurOrInsert =
+           let processSinglePat n p =
+             [
+              recurPatPat (p, (function p' ->
+                {pat with ppat_desc = 
+                 Ppat_array(replaceNthWith pList n p')}));
+              (replacePat []
+                 (function () -> {pat with ppat_desc = Ppat_array(removeNth n pList)})
+                 alwaysValid
+                 ("Removed subpattern " ^ (sourceFromLoc p.ppat_loc))
+                 (t("Pat_Array_RemoveSubpat"))
+                 p.ppat_loc)
+            ] in
+           map_at_and_flatten processSinglePat pList in
+         recurOrInsert
+     | Ppat_or(p1, p2) -> 
+         [recurPatPat (p1, (function p1' -> {pat with ppat_desc = Ppat_or(p1', p2)}));
+          recurPatPat (p2, (function p2' -> {pat with ppat_desc = Ppat_or(p1, p2')}));
+          (replacePat []
+             (function () -> p1)
+             alwaysValid
+             ("Removed one branch of an or pattern")
+             (t("Pat_Or_RemovePat"))
+             p2.ppat_loc);
+          (replacePat []
+             (function () -> p2)
+             alwaysValid
+             ("Removed one branch of an or pattern")
+             (t("Pat_Or_RemovePat"))
+             p1.ppat_loc)
+        ]
+     | Ppat_constraint(p, ty) -> 
+         [recurPatPat (p, (function p' -> {pat with ppat_desc = Ppat_constraint(p', ty)}));
+          recurTypPat (ty, (function t' -> {pat with ppat_desc = Ppat_constraint(p, t')}));
+          (replacePat []
+             (function () -> p)
+             alwaysValid
+             ("Remove pattern constraint")
+             (t("Pat_Constraint_RemoveConstraint"))
+             ty.ptyp_loc)
+        ]
+     | Ppat_type t -> []
+   in [followup [genericSingleReplacement] (fun _ -> otherSingleReplacements)]
+ 
+ let destructMod mdl locOpt =
+   let replaceMod = replaceMod (Mod mdl) in (* pre-bind the first argument *)
+   if not (shouldTryFix mdl.pmod_loc locOpt) then [] else
+   let genericSingleReplacement =
+     (replaceMod []
+        (function () -> {mdl with pmod_desc = Pmod_structure []})
+        alwaysValid
+        "Removed module expression"
+        (t("Mod_Remove"))
+        mdl.pmod_loc) in
+   let otherSingleReplacements = 
+     match mdl.pmod_desc with
+       Pmod_ident id -> []
+     | Pmod_structure str -> 
+         [
+          recurStrMod (str, (function str' ->
+             {mdl with pmod_desc = 
+              Pmod_structure str'}));
+        ]
+     | Pmod_functor(s, mty, mexp) -> 
+         [
+          recurModMod (mexp, (function mexp' ->
+             {mdl with pmod_desc = 
+              Pmod_functor(s, mty, mexp')}));
+          recurModtyMod (mty, (function mty' ->
+             {mdl with pmod_desc = 
+              Pmod_functor(s, mty', mexp)}));
+        ]
+     | Pmod_apply(mexp1, mexp2) -> 
+         [
+          recurModMod (mexp1, (function mexp1' ->
+             {pmod_desc = Pmod_apply(mexp1', mexp2);
+              pmod_loc = mdl.pmod_loc}));
+          recurModMod (mexp2, (function mexp2' ->
+             {mdl with pmod_desc = 
+              Pmod_apply(mexp1, mexp2')}));
+        ]
+     | Pmod_constraint(mexp, mty) -> 
+         [
+          (replaceMod []
+             (function () -> {mdl with pmod_desc = mexp.pmod_desc})
+             alwaysValid
+             "Relaxed constraint on module"
+             (t("Mod_Constraint_Relax"))
+             mty.pmty_loc);
+          recurModMod (mexp, (function mexp' ->
+             {mdl with pmod_desc = 
+              Pmod_constraint(mexp', mty)}));
+          recurModtyMod (mty, (function mty' ->
+             {mdl with pmod_desc = 
+              Pmod_constraint(mexp, mty')}));
+        ] 
+   in [followup [genericSingleReplacement] (fun _ -> otherSingleReplacements)]
+ 
+ 
+ 
+ let destructModty mty locOpt = []
+ let destructClass cls locOpt = []
+ let destructCldesc cld locOpt = []
+ let destructClassty clsty locOpt = []
+ let destructClasstydec clstydec locOpt = []
+ let destructClfield clf locOpt = []
+ let destructClexp cle locOpt = []
+ let destructSigitem sit locOpt = []
+ let destructClty clt locOpt = []
+ let destructCltf cltf locOpt = []
+ let destructTypdec typ locOpt = []
+ let destructTyp typ locOpt =
+   let replaceTyp = replaceTyp (Typ typ) in (* pre-bind the first argument *)
+   if not (shouldTryFix typ.ptyp_loc locOpt) then [] else
+   match typ.ptyp_desc with
+     Ptyp_any -> 
+       (* Possible fixes: 
+        * none 
+        *)
+       []
+   | Ptyp_constr(id, ty_list) ->
+       (* Possible fixes:
+        * generalize the entire type to 'a
+        * fix some local problem within the type list
+        *)
+       let relaxType = 
+         (replaceTyp []
+            (fun () -> alphaTyp typ.ptyp_loc)
+            alwaysValid
+            ("Generalized type at " ^ (sourceFromLoc typ.ptyp_loc))
+            (t("Typ_Constr_Generalize"))
+            typ.ptyp_loc) in
+       let processSingleTyp n typ =
+         recurTypTyp (typ, (function typ' -> 
+            {typ with ptyp_desc = 
+             Ptyp_constr(id, replaceNthWith ty_list n typ')})) in
+       let fixType = (map_at processSingleTyp ty_list) in
+       relaxType :: fixType
+   | _ -> []
+ 
+ let destructExp exp locOpt inMulti inTriage =
+   let replaceExp = replaceExp (Exp exp) in (* pre-bind the first argument *)
+   if not (shouldTryFix exp.pexp_loc locOpt) then [] else
+   let genericSingleReplacements =
+     [(replaceExp (declareException "ExpRemoved")
+          (function () -> alphaExp "ExpRemoved" exp.pexp_loc)
+          alwaysValid
+          ("Replaced expression " ^ (sourceFromLoc exp.pexp_loc) ^ " with _")
+          (t("Exp_Remove"))
+          exp.pexp_loc);
+      (replaceExp (declareException "ChangedType")
+         (function () -> {pexp_desc = Pexp_sequence(exp, alphaExp "ChangedType" exp.pexp_loc); pexp_loc = exp.pexp_loc})
+         alwaysValid
+         ("Adapted a single expression " ^ (sourceFromLoc exp.pexp_loc) ^ " with ; [[...]]")
+         (t("Exp_Adapt"))
+         exp.pexp_loc)] in
+   let otherSingleReplacements =
+     match exp.pexp_desc with
+       Pexp_ident name -> 
+         let identFixes = tryIDs name exp.pexp_loc (function id' -> 
+           (replaceExp []
+              (function () -> {exp with pexp_desc = Pexp_ident id'})
+              alwaysValid
+              ("Replaced id " ^ (longidentToStr name) ^ " with id " ^ (longidentToStr id'))
+              (t("Exp_Ident_FixId"))
+              exp.pexp_loc)
+                                                   ) in
+         let refFix = 
+           (replaceExp []
+              (function () -> {exp with pexp_desc = Pexp_apply({pexp_desc = Pexp_ident (strToLongident "!"); pexp_loc = exp.pexp_loc}, ["", exp])})
+              alwaysValid
+              ("Dereferenced a ref-cell " ^ (longidentToStr name))
+              (t("Exp_Ident_Deref"))
+              exp.pexp_loc) in
+         refFix :: identFixes
+     | Pexp_constant const -> []        
+     | Pexp_let (rec_flag, pat_exp_list, ex) ->
+         (* Possible fixes:
+          * setting the rec flag
+          * fixing a subpattern in a single binding
+          * fixing a subexpression in a single binding
+          * generalizing a single binding
+          * generalizing all bindings
+          * generalizing the target expression
+          * removing a broken binding (note: could do all subsets, but that's 2^n)
+          * fixing a subexpression in the target expression
+          * hoisting nested lets into one binding list
+          *)
+         let fixRec = 
+           [(replaceExp []
+               (function () -> {exp with pexp_desc = Pexp_let(Asttypes.Recursive, pat_exp_list, ex)})
+               alwaysValid
+               "Changed let to be recursive"
+               (t("Exp_Let_FixRec"))
+               (locSub exp.pexp_loc ex.pexp_loc))
+           ] in
+         let fixPatExps = 
+           let processSinglePatExp n (patN, expN) =
+             [
+              recurPatExp (patN, (function patN' ->
+                 {exp with pexp_desc = 
+                  Pexp_let(rec_flag, (replaceNthWith pat_exp_list n (patN', expN)), ex)}));
+              recurExpExp (expN, (function expN' ->
+                 {exp with pexp_desc = 
+                  Pexp_let(rec_flag, (replaceNthWith pat_exp_list n (patN, expN')), ex)}));
+            ] in
+           map_at_and_flatten processSinglePatExp pat_exp_list in
+         let generalizeAllBindings =
+           [(replaceExp (declareException "ReplacedBindings")
+               (function () -> {exp with pexp_desc = 
+                                Pexp_let(rec_flag, List.map (fun (pat, exp) -> (pat, alphaExp "ReplacedBindings" exp.pexp_loc)) pat_exp_list, ex)})
+               alwaysValid
+               ("Replaced all bound subexpressions with (Pervasives.raise ReplacedBindings)")
+               (t("Exp_Let_ReplaceAllBindings"))
+               (locSub exp.pexp_loc ex.pexp_loc))
+           ] in
+         let deleteItems =
+           let removeSingleExp n =
+             (replaceExp [] 
+                (function () -> if (List.length pat_exp_list = 1)
+                then {exp with pexp_desc = ex.pexp_desc}
+                else {exp with pexp_desc = 
+                      Pexp_let(rec_flag, removeNth n pat_exp_list, ex)})
+                alwaysValid
+                ("Removed binding " ^ string_of_int(n) ^ " (zero-indexed) from let-binding")
+                (t("Exp_Let_DeleteBinding"))
+                exp.pexp_loc) in
+           map_c removeSingleExp pat_exp_list in
+         let fixTarget = 
+ (*          fprintf std_formatter "Fixing inner expression of let:\n";
+           Printcode.expression std_formatter ex;
+           fprintf std_formatter "\n"; flush stdout; *)
+           [recurExpExp (ex, (function ex' ->
+               {exp with pexp_desc = 
+                Pexp_let(rec_flag, pat_exp_list, ex')}));
+          ] in
+         let hoistInnerLets = 
+           let rec hoist curHoists =
+             let exp = List.hd curHoists in
+             match exp.pexp_desc with
+               Pexp_let(recFlag, pat_exp_list, ex) ->
+                 (match ex.pexp_desc with
+                   Pexp_let(inner_recFlag, inner_pat_exp_list, inner_ex) ->
+                     let hoistedExp = 
+                       {exp with pexp_desc = 
+                        Pexp_let(Asttypes.Recursive, List.rev_append (List.rev pat_exp_list) inner_pat_exp_list, inner_ex)}
+                     in hoist (hoistedExp :: curHoists)
+                 | _ -> curHoists)
+             | _ -> curHoists in
+           let rebuildTorecur exp = 
+             let endLoc = 
+               match exp.pexp_desc with
+                 Pexp_let(_, _, inner_ex) -> locSub exp.pexp_loc inner_ex.pexp_loc
+               | _ -> exp.pexp_loc in
+             (replaceExp [] 
+                (function () -> exp)
+                alwaysValid
+                ("Joined several let-bindings into one recursive binding list: \n" ^ (sourceFromLoc endLoc))
+                (t("Exp_Let_HoistInner"))
+                endLoc) in
+           List.map rebuildTorecur (hoist [exp]) in
+         List.flatten (fixRec :: fixPatExps :: generalizeAllBindings :: deleteItems :: fixTarget :: hoistInnerLets :: [])
+     | Pexp_constraint(exp', sty1, sty2) ->
+         (* Possible fixes:
+          * fix a subexpression
+          * remove the constraint
+          *)
+         [
+          recurExpExp (exp', (function exp' -> 
+             {exp with pexp_desc = 
+              Pexp_constraint(exp', sty1, sty2)}));
+          (replaceExp []
+             (function () -> {exp with pexp_desc = exp'.pexp_desc})
+             alwaysValid
+             (match sty1 with
+               None -> "Removed constraint at " ^ (sourceFromLoc exp'.pexp_loc)
+             | Some ty -> "Removed constraint " ^ (sourceFromLoc ty.ptyp_loc) ^ " at " ^ (sourceFromLoc exp'.pexp_loc))
+             (t("Exp_Constraint_RemoveConstraint"))
+             exp'.pexp_loc)
+        ]
+     | Pexp_tuple exp_list -> 
+         (* Possible fixes:
+          * generalize the entire tuple to 'a
+          * generalize a specific item to 'a
+          * remove an item
+          * add an item
+          *)
+         let generalizeItem =
+           let processSingleExp n exp =
+             recurExpExp (exp, function ex' ->
+               {exp with pexp_desc = 
+                Pexp_tuple(replaceNthWith exp_list n ex')}) in
+           map_at processSingleExp exp_list in
+         let deleteItem =
+           let removeSingleExp n =
+             (replaceExp []
+                (function () -> {exp with pexp_desc = Pexp_tuple(removeNth n exp_list)})
+                alwaysValid
+                ("Removed field " ^ string_of_int(n) ^ " (zero-indexed) from tuple " ^ (sourceFromLoc exp.pexp_loc))
+                (t("Exp_Tuple_DeleteItem"))
+                exp.pexp_loc) in
+           map_c removeSingleExp exp_list in
+         let addGeneralItem  =
+           let insertSingleExp n eOpt =
+             let nthLoc = match eOpt with
+               None -> {loc_start = exp.pexp_loc.loc_end; loc_end = exp.pexp_loc.loc_end; loc_ghost = true}
+             | Some e -> {loc_start = e.pexp_loc.loc_end; loc_end = e.pexp_loc.loc_end; loc_ghost = true} in
+             (replaceExp (declareException "TupleFieldInserted")
+                (function () -> {exp with pexp_desc = Pexp_tuple(insertNth exp_list n (alphaExp "TupleFieldInserted" nthLoc))})
+                alwaysValid
+                ("Inserted new field before field " ^ string_of_int(n) ^ " (zero-indexed) into tuple " ^ (sourceFromLoc exp.pexp_loc))
+                (t("Exp_Tuple_AddItem"))
+                exp.pexp_loc) in
+           map_between insertSingleExp exp_list in
+         let swapArgs =
+           let swap n m = (* assume n < m *)
+             let (front, nAndTail) = splitAt n exp_list in
+             let (nAndMid, mAndTail) = splitAt (m-n) nAndTail in
+             match (front, nAndMid, mAndTail) with
+               (front, n::mid, m::tail) -> front @ (m::mid) @ (n::tail)
+             | _ -> exp_list in
+           let relocate n m = 
+             let (min, max) = if (n < m) then (n,m) else (m,n) in
+             let (front, minAndTail) = splitAt min exp_list in
+             let (minAndMid, maxAndTail) = splitAt (max-min) minAndTail in
+             if (n < m) then
+               match (front, minAndMid, maxAndTail) with
+                 (front, minAndMid, m::tail) -> front @ (m::minAndMid) @ tail
+               | _ -> exp_list
+             else
+               match (front, minAndMid, maxAndTail) with
+                 (front, n::mid, maxAndTail) -> front @ mid @ (n::maxAndTail)
+               | _ -> exp_list in
+           let allSwaps = List.filter (fun (m,n) -> (m < n)) 
+               (List.flatten (map_c (fun n -> map_c (fun m -> (n,m)) exp_list) exp_list)) in
+           let swapToMod (n,m) =
+             [(replaceExp []
+                (fun () -> {exp with pexp_desc = Pexp_tuple(swap n m)})
+                alwaysValid
+                ("Swapped argument " ^ (string_of_int n) ^ " with argument " ^ (string_of_int m))
+                (t("Exp_Tuple_SwapArgs"))
+                (locJoin (List.nth exp_list n).pexp_loc (List.nth exp_list m).pexp_loc));
+              (replaceExp []
+                 (fun () -> {exp with pexp_desc = Pexp_tuple(relocate n m)})
+                 alwaysValid
+                 ("Relocated argument " ^ (string_of_int m) ^ " to position " ^ (string_of_int n))
+                 (t("Exp_Tuple_RelocateArgs"))
+                 (locJoin (List.nth exp_list n).pexp_loc (List.nth exp_list m).pexp_loc));
+              (replaceExp []
+                 (fun () -> {exp with pexp_desc = Pexp_tuple(relocate m n)})
+                 alwaysValid
+                 ("Relocated argument " ^ (string_of_int n) ^ " to position " ^ (string_of_int m))
+                 (t("Exp_Tuple_RelocateArgs"))
+                 (locJoin (List.nth exp_list n).pexp_loc (List.nth exp_list m).pexp_loc))
+            ] in
+           List.flatten (List.map swapToMod allSwaps) in
+         List.flatten (generalizeItem :: deleteItem :: addGeneralItem :: swapArgs :: [])
+     | Pexp_construct (id, exp_opt, b) -> 
+         (* Possible fixes:
+          * generalize the body of the constructor to 'a
+          * remove the body of the constructor
+          * find some local fix in the expression if there is one
+          * ad-hoc fix A (A (x, y, z)) into A (A (x,y), z)
+          * ad-hoc fix [x,y,z] into [x;y;z]
+          * ad-hoc fix () into []
+          * ad-hoc fix [] into ()
+          *)
+         let generalizeBody =
+           let (exnName, replacementMessage) = match exp_opt with
+             None -> ("ConstructBodyAdded", "Inserted generic body into constructor ")
+           | Some _ -> ("ConstructBodyGeneralized", "Generalized body of constructor ") in
+           (replaceExp (declareException exnName)
+              (function () -> {exp with pexp_desc = Pexp_construct (id, Some (alphaExp exnName !locNone), false)})
+              alwaysValid
+              (replacementMessage ^ (sourceFromLoc exp.pexp_loc))
+              (t("Exp_Construct_GeneralizeBody"))
+              exp.pexp_loc) in
+         let removeBodyOrTag =
+           match exp_opt with
+             None -> []
+           | Some body -> 
+               [(replaceExp [] 
+                  (function () -> {exp with pexp_desc = Pexp_construct (id, None, false)})
+                  alwaysValid
+                  ("Removed body of constructor " ^ (sourceFromLoc exp.pexp_loc))
+                  (t("Exp_Construct_DeleteBody"))
+                  exp.pexp_loc);
+                (replaceExp []
+                   (function () -> body)
+                   alwaysValid
+                   ("Removed construct tag")
+                   (t("Exp_Construct_DeleteTag"))
+                   exp.pexp_loc)
+              ] in
+         let fixTuplefiedList = 
+ (*          fprintf std_formatter "Trying to untuplefy expression:\n"; Printcode.expression std_formatter exp; fprintf std_formatter "\n"; flush stdout; *)
+           match (id, exp_opt) with
+             (Longident.Lident id', None) when (id' = "()" || id' = "[]") ->
+               [(replaceExp []
+                   (fun () -> {exp with pexp_desc = Pexp_construct(Longident.Lident (if id' = "()" then "[]" else "()"), None, b)})
+                   alwaysValid
+                   "Transformed () into [] or vice versa"
+                   (t("Exp_Construct_FixUnitList"))
+                   exp.pexp_loc)]
+           | ((Longident.Lident "::"), Some ({pexp_desc = Pexp_tuple [{pexp_desc = Pexp_tuple items; pexp_loc = l1}; {pexp_desc = Pexp_construct(Longident.Lident "[]", None, false); pexp_loc = l2}]; pexp_loc = l})) ->
+               let newExp = List.fold_right 
+                   (fun (item : expression) (accu : expression) -> 
+                     {pexp_desc = Pexp_construct(strToLongident "::", Some {pexp_desc = Pexp_tuple([item; accu]); pexp_loc = item.pexp_loc}, false); 
+                      pexp_loc = locJoin item.pexp_loc accu.pexp_loc}) items 
+                   {pexp_desc = Pexp_construct(strToLongident "[]", None, false); pexp_loc = l2} in
+               [(replaceExp []
+                   (fun () -> newExp)
+                   alwaysValid
+                   "Transformed a list of a single tuple into a list of the tuple's elements"
+                   (t("Exp_Construct_FixTuplelist"))
+                   exp.pexp_loc)]
+           | _ -> [] in
+         let childrenFixes = 
+           match exp_opt with
+             None -> []
+           | Some {pexp_desc = Pexp_tuple subexps; pexp_loc = loc'} ->
+               let processSingleExp n subexp =
+                 recurExpExp (subexp, function ex' ->
+                   {exp with pexp_desc = 
+                    Pexp_construct(id, Some {pexp_desc = Pexp_tuple(replaceNthWith subexps n ex'); pexp_loc = loc'}, b)}) in
+               map_at processSingleExp subexps
+           | Some {pexp_desc = Pexp_construct (id2, Some {pexp_desc = Pexp_tuple subexps; pexp_loc = loc3}, b2); pexp_loc = loc2} when id2 = id ->
+               begin 
+                 match subexps with
+                   e1::e2::e3::[] -> 
+                     let newExp = {exp with pexp_desc = 
+                                     Pexp_construct (id,
+                                                     Some ({pexp_desc = Pexp_tuple [{pexp_desc = 
+                                                                                     Pexp_construct (id2,
+                                                                                                     Some ({pexp_desc = Pexp_tuple [e1;e2]; pexp_loc = loc2}),
+                                                                                                     b2);
+                                                                                     pexp_loc = loc2};
+                                                                                    e3];
+                                                            pexp_loc = locJoin loc2 loc3}),
+                                                     b)
+                                   } in
+                     [(replaceExp []
+                         (fun () -> newExp)
+                         alwaysValid
+                         "Rotated A (A (x,y,z)) into A (A (x,y), z)"
+                         (t("Exp_Construct_RotateConstructs"))
+                         exp.pexp_loc)]
+                 | _ -> []
+               end
+           | Some exp' -> 
+               [recurExpExp (exp', function ex' -> {exp with pexp_desc = Pexp_construct(id, Some ex', b)});
+                recurExpExp ({exp' with pexp_desc = Pexp_tuple [exp']}, function ex' -> {exp with pexp_desc = Pexp_construct(id, Some ex', b)});
+              ] in
+         (generalizeBody :: (removeBodyOrTag @ childrenFixes @ fixTuplefiedList))
+     | Pexp_record (idExpList, eOpt) ->
+         let fixIdExps = 
+           let processIdExp n (id, ex) =
+             recurExpExp(ex, function ex' -> {exp with pexp_desc = Pexp_record(replaceNthWith idExpList n (id, ex'), eOpt)})
+             :: tryIDs id exp.pexp_loc (function id' -> 
+              (replaceExp [] 
+                 (function () -> {exp with pexp_desc = Pexp_record(replaceNthWith idExpList n (id', ex), eOpt)})
+                 alwaysValid
+                 ("Replaced id " ^ (longidentToStr id) ^ " with id " ^ (longidentToStr id') ^ " in record")
+                 (t("Exp_Record_FixId"))
+                 ex.pexp_loc);
+                                     ) in
+           map_at_and_flatten processIdExp idExpList in
+         let optFix = 
+           match eOpt with None -> [] | Some e ->
+             [recurExpExp(e, function e' ->
+                 {exp with pexp_desc = 
+                  Pexp_record(idExpList, Some e')});
+            ] in
+         List.flatten (optFix :: fixIdExps :: [])
+     | Pexp_field(e, id) ->
+         let fixExp = 
+           recurExpExp(e, function e' ->
+              {exp with pexp_desc = 
+               Pexp_field(e', id)}) in
+         let fixId = tryIDs id exp.pexp_loc (function id' ->
+           (replaceExp [] 
+              (function () -> {exp with pexp_desc = Pexp_field(e, id')})
+              alwaysValid
+              ("Replaced id " ^ (longidentToStr id) ^ " with id " ^ (longidentToStr id') ^ " in field expression")
+              (t("Exp_Field_FixId"))
+              {loc_start = e.pexp_loc.loc_end; loc_end = exp.pexp_loc.loc_end; loc_ghost = true})) in
+         fixExp :: fixId
+     | Pexp_setfield(e1, id, e2) ->
+         let fixExp1 = recurExpExp(e1, function e' -> {exp with pexp_desc = Pexp_setfield(e', id, e2)}) in
+         let fixExp2 = recurExpExp(e2, function e' -> {exp with pexp_desc = Pexp_setfield(e1, id, e')}) in
+         let fixId = tryIDs id exp.pexp_loc (function id' ->
+           (replaceExp []
+              (function () -> {exp with pexp_desc = Pexp_setfield(e1, id', e2)})
+              alwaysValid
+              ("Replaced id " ^ (longidentToStr id) ^ " with id " ^ (longidentToStr id') ^ " in setfield expression")
+              (t("Exp_Setfield_FixId"))
+              {loc_start = e1.pexp_loc.loc_end; loc_end = e2.pexp_loc.loc_start; loc_ghost = true})) in
+         fixExp1 :: fixExp2 :: fixId
+     | Pexp_send(e, s) ->
+         let fixExp = recurExpExp(e, function e' -> {exp with pexp_desc = Pexp_send(e', s)}) in
+         let fixStr = tryStrs exp.pexp_loc (function s' ->
+           (replaceExp []
+              (function () -> {exp with pexp_desc = Pexp_send(e, s')})
+              alwaysValid
+              ("Replaced str " ^ s ^ " with str " ^ s' ^ " in send expression")
+              (t("Exp_Send_FixStr"))
+              {loc_start = e.pexp_loc.loc_end; loc_end = exp.pexp_loc.loc_end; loc_ghost = true})) in
+         fixExp :: fixStr
+     | Pexp_setinstvar(s, e) ->
+         let fixExp = recurExpExp(e, function e' -> {exp with pexp_desc = Pexp_setinstvar(s, e')}) in
+         let fixStr = tryStrs exp.pexp_loc (function s' ->
+           (replaceExp []
+              (function () -> {exp with pexp_desc = Pexp_setinstvar(s', e)})
+              alwaysValid
+              ("Replaced str " ^ s ^ " with str " ^ s' ^ " in setinstvar expression")
+              (t("Exp_Setinstvar_FixStr"))
+              {loc_start = exp.pexp_loc.loc_start; loc_end = e.pexp_loc.loc_start; loc_ghost = true})) in
+         fixExp :: fixStr
+     | Pexp_override seList ->
+         let processStrExp n (s, e) =
+           let fixExp = recurExpExp(e, function e' -> {exp with pexp_desc = Pexp_override(replaceNthWith seList n (s, e'))}) in
+           let fixStr = tryStrs exp.pexp_loc (function s' ->
+             (replaceExp []
+                (function () -> {exp with pexp_desc = Pexp_override(replaceNthWith seList n (s', e))})
+                alwaysValid
+                ("Replaced str " ^ s ^ " with str " ^ s' ^ " in override expression")
+                (t("Exp_Override_FixStr"))
+                {loc_start = exp.pexp_loc.loc_start; loc_end = e.pexp_loc.loc_start; loc_ghost = true})) in
+           fixExp :: fixStr in
+         map_at_and_flatten processStrExp seList
+     | Pexp_poly(e, tyOpt) ->
+         let fixExp = recurExpExp(e, function e' -> {exp with pexp_desc = Pexp_poly(e', tyOpt)}) in
+         let fixTy = match tyOpt with None -> [] | Some ty ->
+           [recurTypExp(ty, (function ty' -> {exp with pexp_desc = Pexp_poly(e, Some ty')}))] in
+         fixExp :: fixTy
+     | Pexp_object patClsfieldList -> [] (* NOT COMPLETE *)       
+     | Pexp_variant(l, eOpt) ->
+         (* `Lab(eOpt) *)
+         (* Possible errors:
+          * Undefined label
+          * error in the expression (if present)
+          *)
+         (* Possible fixes:
+          * fix the expression if present
+          *)
+         (match eOpt with
+           None -> 
+             [(replaceExp (declareException "VariantBody")
+                 (function () -> {exp with pexp_desc = Pexp_variant(l, Some (alphaExp "VariantBody" !locNone))})
+                 alwaysValid
+                 "Added arbitrary body to variant"
+                 (t("Exp_Variant_AddBody"))
+                 exp.pexp_loc);
+            ]
+         | Some e ->
+             [
+              recurExpExp(e, function ex' -> {exp with pexp_desc = Pexp_variant(l, Some ex')});
+              (replaceExp (declareException "SingleReplaceVariantBody")
+                 (function () -> {exp with pexp_desc = Pexp_variant(l, Some (alphaExp "SingleReplaceVariantBody" e.pexp_loc))})
+                 alwaysValid
+                 "SingleReplace body of variant"
+                 (t("Exp_Variant_SingleReplaceSubexp"))
+                 e.pexp_loc);
+            ])
+     | Pexp_letmodule(name, modExp, exp') ->
+         (* let name = modExp in exp' *)
+         (* Possible errors:
+          * any module expression error
+          * any expression error
+          *)
+         (* Possible fixes:
+          * delete the entire expression
+          * fix the module expression
+          * fix the expression
+          *)
+         [
+          recurModExp(modExp, (function mex' -> {exp with pexp_desc = Pexp_letmodule(name, mex', exp')}));
+          recurExpExp(exp', (function ex' -> {exp with pexp_desc = Pexp_letmodule(name, modExp, ex')}));
+        ]
+     | Pexp_array expList ->
+         (* [| e1; e2; ... |] *)
+         (* Possible errors:
+          * any error expression in any subexpression
+          *)
+         (* Possible fixes:
+          * delete the entire array expression
+          * any recursive fix of a subexpression
+          *)
+         let processSingleSubexp n exp = recurExpExp(exp, function ex' -> {exp with pexp_desc = Pexp_array(replaceNthWith expList n ex')}) in
+         map_at processSingleSubexp expList
+     | Pexp_new id -> []
+     | Pexp_sequence(e1, e2) ->
+         (* e1 ; e2 *)
+         (* Possible errors:
+          * any expression error in either e1 or e2
+          *)
+         (* Possible fixes:
+          * recursively fix either expression
+          *)
+         [ 
+           recurExpExp(e1, (function e' -> {exp with pexp_desc = Pexp_sequence(e', e2)}));
+           recurExpExp(e2, (function e' -> {exp with pexp_desc = Pexp_sequence(e1, e')}));
+         ]
+     | Pexp_while(guard, body) ->
+         (* e1 ; e2 *)
+         (* Possible errors:
+          * any expression error in either e1 or e2
+          *)
+         (* Possible fixes:
+          * recursively fix either expression
+          *)
+         [
+          recurExpExp(guard, (function g' -> {exp with pexp_desc = Pexp_while(g', body)}));
+          recurExpExp(body, (function b' -> {exp with pexp_desc = Pexp_while(guard, b')}));
+        ]
+     | Pexp_ifthenelse(guard, iftrue, iffalseOpt) -> 
+         (* if guard then iftrue (else iffalse) *)
+         (* Possible errors:
+          * any expression error in guard, iftrue, or iffalse
+          * dangling elses
+          *)
+         (* Possible fixes:
+          * delete the whole expression
+          * fix each expression
+          * reassociate elses outwards
+          * AD-HOC: fix any expression and delete the other two
+          *)
+         let mainTests = 
+           [
+            recurExpExp(guard, (function g' -> {exp with pexp_desc = Pexp_ifthenelse(g', iftrue, iffalseOpt)}));
+            recurExpExp(iftrue, (function t' -> {exp with pexp_desc = Pexp_ifthenelse(guard, t', iffalseOpt)}));
+          ] in
+         let elseTests =
+           match iffalseOpt with
+             None -> (* see if there's a dangling else problem *)
+               (match iftrue.pexp_desc with
+                 Pexp_ifthenelse(g2, if2, Some else2) ->
+                   [ replaceExp []
+                       (function () -> {exp with pexp_desc = Pexp_ifthenelse(guard, {iftrue with pexp_desc = Pexp_ifthenelse(g2, if2, None)}, Some else2)})
+                       alwaysValid
+                       "Reassociated dangling else"
+                       (t("Exp_If_DanglingElse"))
+                       else2.pexp_loc;
+                   ]
+               | _ -> [])
+           | Some iffalse -> (* fix the false branch *)
+               [
+                recurExpExp(iffalse, (function f' -> {exp with pexp_desc = Pexp_ifthenelse(guard, iftrue, Some f')}));
+                (replaceExp []
+                   (function () -> {exp with pexp_desc = Pexp_ifthenelse(guard, iftrue, None)})
+                   alwaysValid
+                   "Removed else branch of if expression"
+                   (t("Exp_If_RemoveElse"))
+                   iffalse.pexp_loc);
+              ] in
+         List.rev_append mainTests elseTests
+     | Pexp_for(v, init, term, dir, body) ->
+         (* for v = init (to | downto) term do body done *)
+         (* Possible fixes:
+          * fix init, term, or body
+          *)
+         [
+          recurExpExp(init, (function i' -> {exp with pexp_desc = Pexp_for(v, i', term, dir, body)}));
+          recurExpExp(term, (function t' -> {exp with pexp_desc = Pexp_for(v, init, t', dir, body)}));
+          recurExpExp(body, (function b' -> {exp with pexp_desc = Pexp_for(v, init, term, dir, b')}));
+        ]
+     | Pexp_when(matchGuard, matchCase) ->
+         (* match ... | exp when MatchGuard -> MatchCase *)
+         (* Possible errors:
+          * guard is faulty
+          * expression is faulty
+          *)
+         (* Possible fixes:
+          * remove the guard
+          * fix the guard
+          * fix the expression
+          *)
+         [
+          (replaceExp (declareException "RemovedGuard")
+             (function () -> {exp with pexp_desc = matchCase.pexp_desc})
+             alwaysValid
+             "Removed `when' guard on match case"
+             (t("Exp_When_RemoveGuard"))
+             matchGuard.pexp_loc);
+          recurExpExp(matchGuard, (function g' -> {exp with pexp_desc = Pexp_when(g', matchCase)}));
+          recurExpExp(matchCase, (function c' -> {exp with pexp_desc = Pexp_when(matchGuard, c')}));
+        ]
+     | Pexp_function(lab, defaultOpt, peList) ->
+         (* fun p1 -> fun p2 -> .. pn -> body, where p1..pn could be labeled or optional
+          * function p1 -> e1 | p2 when g2 -> e2 ... *)
+         (* Possible errors:
+          * any pattern error
+          * any default expression's error
+          * any case/body's expression error
+          * too many arguments
+          * too few arguments
+          * swapped or rotated arguments
+          *)
+         (* Possible fixes:
+          * fix any patterns
+          * fix any expressions
+          * hoist inner function bodies (remove one curried argument)
+          * insert an additional function body (add one curried argument) 
+          * swap or rotate arguments
+          *)
+         let fixPatExps = 
+           let numCases = List.length peList in
+           let processSinglePatExp n (p, e) =
+             [
+              recurPatExp(p, (function pat' -> {exp with pexp_desc = Pexp_function(lab, defaultOpt, (replaceNthWith peList n (pat', e)))}));
+              recurExpExp(e, (function exp' -> {exp with pexp_desc = Pexp_function(lab, defaultOpt, (replaceNthWith peList n (p, exp')))}));
+              (replaceExp (declareException "RemovedCase")
+                 (function () ->
+                   {exp with pexp_desc = 
+                    Pexp_function(lab, defaultOpt, (replaceNthWith peList n 
+                                                      (alphaPat p.ppat_loc, alphaExp "RemovedCase" e.pexp_loc)))})
+                 (fun _ -> numCases > 1)
+                 ("Generalized case " ^ string_of_int n)
+                 (t("Exp_Function_GeneralizedCase"))
+                 (locJoin p.ppat_loc e.pexp_loc));
+            ] in
+           map_at_and_flatten processSinglePatExp peList in
+         let fixDefault =
+           match defaultOpt with
+             None -> []
+           | Some d ->
+               [
+                (replaceExp []
+                   (function () -> {exp with pexp_desc = Pexp_function(lab, None, peList)})
+                   alwaysValid
+                   "Removed argument's default expression"
+                   (t("Exp_Function_RemoveDefault"))
+                   d.pexp_loc);
+                recurExpExp(d, (function d' -> {exp with pexp_desc = Pexp_function(lab, Some d', peList)}));
+              ] in
+         let addArgumentBefore = 
+           (* fun x -> y ===> fun _ -> fun x -> y *)
+           [(replaceExp []
+               (function () ->
+                 {exp with pexp_desc = 
+                  Pexp_function("", None, 
+                                [alphaPat !locNone, 
+                                 {exp with pexp_desc = Pexp_function(lab, defaultOpt, peList)}])})
+               alwaysValid
+               ("Added new parameter to function before parameter " ^ (sourceFromLoc (fst (List.hd peList)).ppat_loc))
+               (t("Exp_Function_AddParamBefore"))
+               exp.pexp_loc);
+          ] in
+         let addArgumentAfter =
+           if (List.length peList = 1) then
+             let pe = List.hd peList in
+             match (snd pe).pexp_desc with
+               Pexp_function _ -> []
+             | _ ->
+                 (* fun x -> y ===> fun x -> fun _ -> y *)
+                 [(replaceExp []
+                     (function () ->
+                       {exp with pexp_desc = 
+                        Pexp_function(lab, defaultOpt, 
+                                      [(fst pe), 
+                                       {exp with pexp_desc = 
+                                        Pexp_function("", None, [alphaPat !locNone, (snd pe)])}])})
+                     alwaysValid
+                     "Added new parameter to function as last parameter"
+                     (t("Exp_Function_AddParamAfter"))
+                     exp.pexp_loc);
+                 ]
+           else [] in
+         let curryArgs = 
+           if (List.length peList = 1) then
+             let pe = List.hd peList in
+             match (fst pe).ppat_desc with
+               Ppat_tuple pList ->
+                 [(replaceExp []
+                     (fun () -> List.fold_right (fun p accu -> {exp with pexp_desc = Pexp_function("", None, [p, accu])}) pList (snd pe))
+                     alwaysValid
+                     "Changed a tupled function into a curried one"
+                     (t("Exp_Function_CurryArgs"))
+                     ((fst pe).ppat_loc))]
+             | _ -> []
+           else [] in
+         let uncurryArgs = 
+           let rec tupledArgsAndBody ((revPList : pattern list), body) =
+             match body.pexp_desc with
+               Pexp_function(l', dOpt', peList') ->
+                 if (List.length peList' = 1) then
+                   let (p, e) = List.hd peList' in
+                   tupledArgsAndBody (p :: revPList, e)
+                 else (revPList, body)
+             | _ -> (revPList, body) in
+           if (List.length peList = 1) then
+             let (p, e) = List.hd peList in
+             let (revPList, body) = tupledArgsAndBody ([p], e) in
+             if (body = e) then []
+             else
+               let pLoc = List.fold_left (fun accu p -> locJoin accu p.ppat_loc) !locNone revPList in
+               let newPat = {ppat_loc = pLoc; ppat_desc = Ppat_tuple (List.rev revPList)} in
+               [(replaceExp []
+                   (fun () -> {exp with pexp_desc = Pexp_function(lab, defaultOpt, [newPat, body])})
+                   alwaysValid
+                   "Changed a curried function into one taking a tuple"
+                   (t("Exp_Function_UncurryArgs"))
+                   pLoc)]
+           else [] in
+         let removeArgument =
+           if (List.length peList = 1) then
+             let pe = List.hd peList in
+             match (snd pe).pexp_desc with
+               Pexp_function _ -> []
+             | _ -> 
+                 [(replaceExp []
+                     (function () -> {exp with pexp_desc = (snd pe).pexp_desc})
+                     alwaysValid
+                     ("Removed parameter " ^ (sourceFromLoc (fst pe).ppat_loc))
+                     (t("Exp_Function_RemoveParam"))
+                     (fst pe).ppat_loc);
+                ]
+           else [] in
+         let swapArgs =
+           let rec getFunArgsAndBody ex =
+             try
+               match ex.pexp_desc with
+                 Pexp_function(_, _, peList) ->
+                   let (p1, e1) = (List.hd peList) in 
+                   let (args', body) = getFunArgsAndBody e1 in
+                   (p1 :: args', body)
+               | _ -> [], ex
+             with _ -> [], ex in
+           let funOfArgsAndBody args body =
+             List.fold_right (fun arg body -> {pexp_desc = Pexp_function("", None, [arg, body]);
+                                               pexp_loc = locJoin arg.ppat_loc body.pexp_loc}) 
+               args body in
+           let (allArgs, innerBody) = getFunArgsAndBody exp in
+           let swap n m = (* assume n < m *)
+             let (front, nAndTail) = splitAt n allArgs in
+             let (nAndMid, mAndTail) = splitAt (m-n) nAndTail in
+             match (front, nAndMid, mAndTail) with
+               (front, n::mid, m::tail) -> front @ (m::mid) @ (n::tail)
+             | _ -> allArgs in
+           let relocate n m = 
+             let (min, max) = if (n < m) then (n,m) else (m,n) in
+             let (front, minAndTail) = splitAt min allArgs in
+             let (minAndMid, maxAndTail) = splitAt (max-min) minAndTail in
+             if (n < m) then
+               match (front, minAndMid, maxAndTail) with
+                 (front, minAndMid, m::tail) -> front @ (m::minAndMid) @ tail
+               | _ -> allArgs
+             else
+               match (front, minAndMid, maxAndTail) with
+                 (front, n::mid, maxAndTail) -> front @ mid @ (n::maxAndTail)
+               | _ -> allArgs in
+           let allSwaps = List.filter (fun (m,n) -> (m < n)) 
+               (List.flatten (map_c (fun n -> map_c (fun m -> (n,m)) allArgs) allArgs)) in
+           let swapToMod (n,m) =
+             [(replaceExp []
+                (fun () -> funOfArgsAndBody (swap n m) innerBody)
+                alwaysValid
+                ("Swapped parameter " ^ (string_of_int n) ^ " with parameter " ^ (string_of_int m))
+                (t("Exp_Function_SwapArgs"))
+                (locJoin (List.nth allArgs n).ppat_loc (List.nth allArgs m).ppat_loc));
+              (replaceExp []
+                 (fun () -> funOfArgsAndBody (relocate n m) innerBody)
+                 alwaysValid
+                 ("Relocated parameter " ^ (string_of_int m) ^ " to position " ^ (string_of_int n))
+                 (t("Exp_Function_RelocateArgs"))
+                 (locJoin (List.nth allArgs n).ppat_loc (List.nth allArgs m).ppat_loc));
+              (replaceExp []
+                 (fun () -> funOfArgsAndBody (relocate m n) innerBody)
+                 alwaysValid
+                 ("Relocated parameter " ^ (string_of_int n) ^ " to position " ^ (string_of_int m))
+                 (t("Exp_Funtion_RelocateArgs"))
+                 (locJoin (List.nth allArgs n).ppat_loc (List.nth allArgs m).ppat_loc))
+            ] in
+           List.flatten (List.map swapToMod allSwaps) in
+         let fixNestedFunctions = fixNestedTrysMatchsFunctions exp in
+         List.flatten (fixPatExps :: fixDefault :: swapArgs :: addArgumentAfter :: addArgumentBefore :: curryArgs :: uncurryArgs :: removeArgument :: fixNestedFunctions :: [])
+     | Pexp_try (tExp, pat_exp_list) ->
+         (* try tExp with pat1 -> exp1 | pat2 -> exp2 ... *)
+         (* Possible errors:
+          * any expression error
+          * any pattern error
+          * non-exhaustive match error
+          *)
+         (* Possible fixes:
+          * fix tExp
+          * fix each pattern or expression
+          * add a generic catch-all case
+          * reparenthesize nested trys, matches
+          *)
+         let fixExp = [recurExpExp(tExp, (function e' -> {exp with pexp_desc = Pexp_try(e', pat_exp_list)}))] in
+         let fixPatExps = 
+           let processSinglePatExp n (pat, exp) =
+             [
+              recurPatExp (pat, (function pat' -> {exp with pexp_desc = Pexp_try(tExp, (replaceNthWith pat_exp_list n (pat', exp)))}));
+              recurExpExp (exp, (function exp' -> {exp with pexp_desc = Pexp_try(tExp, (replaceNthWith pat_exp_list n (pat, exp')))}));
+            ] in
+           map_at_and_flatten processSinglePatExp pat_exp_list in
+         let catchAll =
+           [(replaceExp (declareException "CatchAllTry")
+               (function () ->
+                 {exp with pexp_desc = 
+                  Pexp_try(tExp, List.rev ((alphaPat !locNone, alphaExp "CatchAllTry" !locNone) :: 
+                                           (List.rev pat_exp_list)))})
+               alwaysValid
+               "Added catch-all case to try expression"
+               (t("Exp_Try_CatchAll"))
+               exp.pexp_loc);
+          ] in
+         let fixNestedTrys = fixNestedTrysMatchsFunctions exp in
+         List.flatten (fixExp :: fixPatExps :: fixNestedTrys :: catchAll :: [])
+     | Pexp_apply (fExp, lab_exp_list) ->
+         (* fExp (~lab1:e1) (~lab2:e2) ... *)
+         (* Possible errors:
+          * Wrong labels
+          * Wrong expressions
+          * Too many arguments
+          * Too few arguments
+          * Curried arguments
+          * Uncurried arguments
+          * wrong order of arguments
+          * Wrong associativity
+          * mistakenly wrote rec.field := exp instead of rec.field <- exp
+          *)
+         (* Possible fixes:
+          * remove labels
+          * fix function
+          * fix subexpressions
+          * remove a subexpression
+          * add a subexpression
+          * generalize the entire application
+          * swap pairs of arguments
+          * relocate one argument to another position
+          * rotate two applications ((f g) h) <-> (f (g h))
+          * Curry or un-Curry arguments
+          *)
+         let removeLabels =
+           let removeLabel (lab, exp) = ("", exp) in
+           [(replaceExp []
+               (function () -> {exp with pexp_desc = Pexp_apply (fExp, List.map removeLabel lab_exp_list)})
+               alwaysValid
+               "Removed labels from function arguments"
+               (t("Exp_Apply_RemoveLabels"))
+               exp.pexp_loc);
+          ] in
+         let fixSetfield =
+           try 
+             match (fExp.pexp_desc, (snd (List.hd lab_exp_list)).pexp_desc) with
+               (Pexp_ident(Longident.Lident ":="), Pexp_field(e, id)) ->
+                 [(replaceExp []
+                     (function () -> {exp with pexp_desc = Pexp_setfield(e,id, (snd (List.hd (List.tl (lab_exp_list)))))})
+                     alwaysValid
+                     "Replaced binding assignment with field assignment"
+                     (t("Exp_Apply_SingleReplaceBinding"))
+                     fExp.pexp_loc);
+                ]
+             | _ -> []
+           with _ -> [] in
+         let fixFun = [followup [recurExpExp (fExp, (function ex' -> {exp with pexp_desc = Pexp_apply(ex', lab_exp_list)}))] (fun _ -> [TriggerTriage (Exp exp, (fun x -> x))])] in
+         let funValidate =
+           let argLocs = List.fold_left (fun l (_, e) -> locJoin l e.pexp_loc) !locNone lab_exp_list in
+           (fun thisrepl otherFixes -> List.for_all (fun (md, _) -> match md with SingleRepl r -> not (locInside r.trep_loc argLocs) | TriageRepl r -> true) otherFixes) in 
+         registerValidate (Exp fExp) funValidate;
+         let fixArg =
+           let processSingleLabExp n (lab, ex) =
+ (*            fprintf std_formatter "Fixing argument subexpression:\n";
+             Printcode.expression std_formatter ex;
+             fprintf std_formatter "\n"; 
+             flush stdout; *)
+             recurExpExp (ex, function ex' -> {exp with pexp_desc = Pexp_apply(fExp, replaceNthWith lab_exp_list n (lab,ex'))}) in
+           map_at processSingleLabExp lab_exp_list in
+         let deleteArg =
+           let removeSingleExp n =
+             (replaceExp []
+                (function () -> 
+                  if (List.length lab_exp_list = 1) 
+                  then {exp with pexp_desc = fExp.pexp_desc}
+                  else {exp with pexp_desc = 
+                        Pexp_apply(fExp, removeNth n lab_exp_list)})
+                alwaysValid
+                ("Removed argument " ^ (sourceFromLoc (snd (List.hd (snd (splitAt n lab_exp_list)))).pexp_loc) ^ " from argument list of " ^ (sourceFromLoc exp.pexp_loc))
+                (t("Exp_Apply_DeleteArg"))
+                (snd (List.hd (snd (splitAt n lab_exp_list)))).pexp_loc) in
+           map_c removeSingleExp lab_exp_list in
+         let addGeneralArg =
+           let insertSingleExp n eOpt =
+             let nthLoc = match eOpt with
+               None -> {loc_start = exp.pexp_loc.loc_end; loc_end = exp.pexp_loc.loc_end; loc_ghost = true}
+             | Some (_, e) -> {loc_start = e.pexp_loc.loc_end; loc_end = e.pexp_loc.loc_end; loc_ghost = true} in
+             (replaceExp (declareException "ArgumentInserted")
+                (function () -> 
+                  {pexp_desc = Pexp_apply(fExp, insertNth lab_exp_list n ("", (alphaExp "ArgumentInserted" nthLoc))); 
+                   pexp_loc = nthLoc})
+                alwaysValid
+                ("Inserted new field before field " ^ string_of_int(n) ^ " (zero-indexed) into argument list " ^ (sourceFromLoc exp.pexp_loc))
+                (t("Exp_Apply_AddArg"))
+                nthLoc) in
+           map_between insertSingleExp lab_exp_list in
+         let swapArgs =
+           let swap n m = (* assume n < m *)
+             let (front, nAndTail) = splitAt n lab_exp_list in
+             let (nAndMid, mAndTail) = splitAt (m-n) nAndTail in
+             match (front, nAndMid, mAndTail) with
+               (front, n::mid, m::tail) -> front @ (m::mid) @ (n::tail)
+             | _ -> lab_exp_list in
+           let relocate n m = 
+             let (min, max) = if (n < m) then (n,m) else (m,n) in
+             let (front, minAndTail) = splitAt min lab_exp_list in
+             let (minAndMid, maxAndTail) = splitAt (max-min) minAndTail in
+             if (n < m) then
+               match (front, minAndMid, maxAndTail) with
+                 (front, minAndMid, m::tail) -> front @ (m::minAndMid) @ tail
+               | _ -> lab_exp_list
+             else
+               match (front, minAndMid, maxAndTail) with
+                 (front, n::mid, maxAndTail) -> front @ mid @ (n::maxAndTail)
+               | _ -> lab_exp_list in
+           let allSwaps = List.filter (fun (m,n) -> (m < n)) 
+               (List.flatten (map_c (fun n -> map_c (fun m -> (n,m)) lab_exp_list) lab_exp_list)) in
+           let swapToMod (n,m) =
+             [(replaceExp []
+                (fun () -> {exp with pexp_desc = Pexp_apply(fExp, swap n m)})
+                alwaysValid
+                ("Swapped argument " ^ (string_of_int n) ^ " with argument " ^ (string_of_int m))
+                (t("Exp_Apply_SwapArgs"))
+                (locJoin (snd (List.nth lab_exp_list n)).pexp_loc (snd (List.nth lab_exp_list m)).pexp_loc));
+              (replaceExp []
+                 (fun () -> {exp with pexp_desc = Pexp_apply(fExp, relocate n m)})
+                 alwaysValid
+                 ("Relocated argument " ^ (string_of_int m) ^ " to position " ^ (string_of_int n))
+                 (t("Exp_Apply_RelocateArgs"))
+                 (locJoin (snd (List.nth lab_exp_list n)).pexp_loc (snd (List.nth lab_exp_list m)).pexp_loc));
+              (replaceExp []
+                 (fun () -> {exp with pexp_desc = Pexp_apply(fExp, relocate m n)})
+                 alwaysValid
+                 ("Relocated argument " ^ (string_of_int n) ^ " to position " ^ (string_of_int m))
+                 (t("Exp_Apply_RelocateArgs"))
+                 (locJoin (snd (List.nth lab_exp_list n)).pexp_loc (snd (List.nth lab_exp_list m)).pexp_loc))
+            ] in
+           List.flatten (List.map swapToMod allSwaps) in
+         let uncurryArgs = 
+           if (List.length lab_exp_list > 1) then
+             let firstLoc = (snd (List.hd lab_exp_list)).pexp_loc in
+             let (argsAsList, loc) = List.fold_right (fun (lab, item) (accu, l) -> 
+               ((item :: accu), locJoin item.pexp_loc l)) lab_exp_list ([], firstLoc) in
+             [(replaceExp []
+                 (fun () -> {exp with pexp_desc = Pexp_apply(fExp, ["", {pexp_desc = Pexp_tuple argsAsList; pexp_loc = loc}])})
+                 alwaysValid
+                 "Changed a curried function into one taking a tuple"
+                 (t("Exp_Apply_UncurryArgs"))
+                 loc)]
+           else [] in
+         let curryArgs =
+           match lab_exp_list with
+             [(l, {pexp_desc = Pexp_tuple args; pexp_loc = loc})] ->
+               [(replaceExp []
+                   (fun () -> {exp with pexp_desc = Pexp_apply(fExp, List.map (fun arg -> ("", arg)) args)})
+                   alwaysValid
+                   "Changed a tuple of arguments into curried form"
+                   (t("Exp_Apply_CurryArgs"))
+                   loc)]
+           | _ -> [] in
+         let rotateApply =
+           let rotateL =
+             match lab_exp_list with
+               [] -> []
+             | (l, e') :: leList ->
+                 [(replaceExp []
+                     (function () ->
+                       {exp with pexp_desc = 
+                        Pexp_apply(fExp, [l, {pexp_desc = Pexp_apply(e', leList); pexp_loc = e'.pexp_loc}])})
+                     alwaysValid
+                     "Reassociated expression to the left"
+                     (t("Exp_Apply_RotateL"))
+                     (locJoin fExp.pexp_loc e'.pexp_loc));
+                ] in
+           let rotateR =
+             match lab_exp_list with
+               [] -> []
+             | (l, e') :: leList ->
+                 match e'.pexp_desc with
+                   Pexp_apply(gExp, gLEList) -> 
+                     [(replaceExp []
+                         (function () ->
+                           {exp with pexp_desc = 
+                            Pexp_apply(gExp, 
+                                       ["", 
+                                        {pexp_desc = Pexp_apply(fExp, List.rev_append (List.rev gLEList) leList);
+                                         pexp_loc = fExp.pexp_loc}])})
+                         alwaysValid
+                         "Reassociated expression to the right"
+                         (t("Exp_Apply_RotateR"))
+                         (locJoin e'.pexp_loc gExp.pexp_loc));
+                    ]
+                 | _ -> [] in
+           List.rev_append rotateL rotateR in
+         List.flatten (removeLabels :: fixSetfield :: fixFun :: fixArg :: deleteArg :: addGeneralArg :: curryArgs :: uncurryArgs :: swapArgs :: rotateApply :: [])
+     | Pexp_match (e, pat_exp_list) ->
+         (* match e with pat_exp_list *)
+         (* Possible errors:
+          * e is wrong
+          * some pattern doesn't have the right type
+          * nested pattern escaped to outer level
+          * non-exhaustive match error
+          *)
+         (* Possible fixes:
+          * fix e
+          * fix each pattern or expression
+          * try to reparenthesize -- change match m with A | B -> match n with (Z | Y -> foo | C -> bar) to be correct
+          * add a catch-all case
+          *)
+         let fixExp = [recurExpExp(e, (function e' -> {exp with pexp_desc = Pexp_match(e', pat_exp_list)}))] in
+         let fixCases =
+           let numCases = List.length pat_exp_list in
+           let processSingleCase n (pat', exp') =
+             (replaceExp (declareException "CaseReplaced")
+                (function () -> {exp with pexp_desc = Pexp_match(e, replaceNthWith pat_exp_list n (alphaPat pat'.ppat_loc, alphaExp "CaseReplaced" exp'.pexp_loc))})
+                (fun _ -> numCases > 1)
+                "Generalized an entire case"
+                (t("Exp_Match_FixCase"))
+                (locJoin pat'.ppat_loc exp'.pexp_loc)) in
+           map_at processSingleCase pat_exp_list in
+         let fixPatExps = 
+           let processSinglePatExp n (pat, exp) =
+             [
+              recurPatExp (pat, (function pat' -> {exp with pexp_desc = Pexp_match(e, (replaceNthWith pat_exp_list n (pat', exp)))}));
+              recurExpExp (exp, (function exp' -> {exp with pexp_desc = Pexp_match(e, (replaceNthWith pat_exp_list n (pat, exp')))}));
+            ] in
+           map_at_and_flatten processSinglePatExp pat_exp_list in
+         let catchAll =
+           [(replaceExp (declareException "CatchAllMatch")
+               (function () ->
+                 {exp with pexp_desc = 
+                  Pexp_match(e, List.rev ((alphaPat !locNone, alphaExp "CatchAllMatch" !locNone) :: 
+                                          (List.rev pat_exp_list)))})
+               alwaysValid
+               "Added catch-all case to match expression"
+               (t("Exp_Match_CatchAll"))
+               exp.pexp_loc);
+          ] in
+         let fixNestedMatches = fixNestedTrysMatchsFunctions exp in
+         let triggerTriage = (TriggerTriage (Exp exp, (fun x -> x))) :: catchAll in
+         List.flatten (fixExp :: fixCases :: fixPatExps :: fixNestedMatches :: triggerTriage :: [])
+     | Pexp_lazy e ->
+         (* lazy someExp *)
+         (* Possible errors:
+          * Any expression error
+          * Should not be lazy
+          *)
+         (* Possible fixes:
+          * fixing the subexpression
+          * Removing the laziness
+          *)
+         [
+          (replaceExp []
+             (function () -> {exp with pexp_desc = e.pexp_desc})
+             alwaysValid
+             ("Removed laziness on expression " ^ (sourceFromLoc exp.pexp_loc))
+             (t("Exp_Lazy_RemoveLazy"))
+             exp.pexp_loc);
+          recurExpExp (e, (function exp' -> {exp with pexp_desc = Pexp_lazy exp'}));
+        ]
+     | Pexp_assert e -> 
+         (* assert someExp *)
+         (* Possible errors:
+          * Any expression error
+          *)
+         (* Possible fixes:
+          * fixing the subexpression
+          *)
+         [recurExpExp (e, (function exp' -> {exp with pexp_desc = Pexp_assert exp'}))]
+     | Pexp_assertfalse -> []
+   in 
+   let genericAndOther fallbacks = [followup genericSingleReplacements (fun _ -> [Attempt(otherSingleReplacements, noFollowups, fallbacks)])] in
+   let triggerTriage = (fun _ -> [TriggerTriage(Exp exp, (fun x -> x))]) in
+   if inMulti then 
+     let idempotentSingleReplacement =
+       (replaceExp [] (function () -> exp) alwaysValid "Did Nothing" (t("Exp_Identity")) exp.pexp_loc) in
+     [Attempt([idempotentSingleReplacement], noFollowups, (fun _ -> genericAndOther triggerTriage))]
+   else genericAndOther (fun _ -> [Attempt([TriggerMulti(Exp exp, (fun x -> x))], noFollowups, triggerTriage)])
+ 
+ let destructNode astThing locOpt inMulti inTriage =
+   match astThing with
+     Exp exp -> destructExp exp locOpt inMulti inTriage
+   | StrItem strItem -> destructStrItem strItem locOpt
+   | Str str -> destructStr str locOpt 
+   | Pat pat -> destructPat pat locOpt
+   | Typ typ -> destructTyp typ locOpt
+   | Mod md -> destructMod md locOpt
+   | Modty mty -> destructModty mty locOpt
+   | Tydec tyd -> destructTypdec tyd locOpt
+   | Cldec cld -> destructClassty cld locOpt
+   | Cldesc cld -> destructCldesc cld locOpt
+   | Cltydec ctd -> destructClasstydec ctd locOpt
+   | Clfield clf -> destructClfield clf locOpt
+   | Clexp cle -> destructClexp cle locOpt
+   | Clty clt -> destructClty clt locOpt
+   | Cltyfield cltf -> destructCltf cltf locOpt
+   | Sigitem sit -> destructSigitem sit locOpt
+ 
+ 
+ 
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ (* XXXXXXXXXXXXXXXXXXXX  Triage Modification Enumerators  XXXXXXXXXXXXXXXXXX *)
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ let triageNode astThing =
+   ignore(declareException "ELIDED_CODE");
+   ignore(declareException "ChangedType");
+   let expexpify ctx = fun x -> Exp (ctx (toExp x)) in
+   let patexpify ctx = fun x -> Exp (ctx (toPat x)) in
+   let elision = alphaExp "ELIDED_CODE" in
+   let adapter = alphaExp "ChangedType" in
+   let adaptThing t = match t with
+     Exp e -> Exp {pexp_desc = Pexp_sequence(e, adapter e.pexp_loc); pexp_loc = e.pexp_loc} 
+   | Pat p -> Pat (alphaPat p.ppat_loc)
+   | _ -> print_string "adaptThing"; raise DynamicTypeError in
+   let alphaThing t = match t with
+     Exp e -> Exp (elision e.pexp_loc)
+   | Pat p -> Pat (alphaPat p.ppat_loc)
+   | _ -> print_string "alphaThing"; raise DynamicTypeError in
+   
+   match astThing with
+     Exp exp ->
+       let expexpexpify ctx = fun x y -> Exp (ctx (toExp x) (toExp y)) in
+       begin match exp.pexp_desc with
+       | Pexp_constant c -> []
+       | Pexp_ident id -> []
+       | Pexp_assertfalse -> []
+       | Pexp_assert e -> 
+           let eCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+             Pexp_assert _ -> {exp' with pexp_desc = Pexp_assert e}
+           | _ -> exp') in
+           [TriageElide [astThing, [(* Exp e *)], [(Exp e, adaptThing, eCtx (Exp (elision e.pexp_loc)), adaptThing, eCtx)]]]
+       | Pexp_tuple eList ->
+           (* how would I implement checking for both an erroneous subexp and a missing subexp? *)
+           let expCtxMakers =
+             let blankList = List.map (fun e -> elision e.pexp_loc) eList in
+             let expCtxMaker n en =
+               let expCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+                 Pexp_tuple(eList') -> {exp' with pexp_desc = Pexp_tuple(replaceNthWith eList' n hole')}
+               | _ -> exp') in
+               let knockoutExp exp' = expCtx exp' (Exp (elision en.pexp_loc)) in
+               (Exp en, adaptThing, knockoutExp, adaptThing, expCtx) in
+             map_at expCtxMaker eList in
+           [TriageElide [astThing, [] (* List.rev_map (fun (h, _, _, _, _) -> h) expCtxMakers *), expCtxMakers]]
+       | Pexp_array eList -> 
+           let expCtxMakers =
+             let blankList = List.map (fun e -> elision e.pexp_loc) eList in
+             let expCtxMaker n en =
+               let expCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+                 Pexp_array(eList') -> {exp' with pexp_desc = Pexp_array(replaceNthWith eList' n hole')}
+               | _ -> exp') in
+               let knockoutExp exp' = expCtx exp' (Exp (elision en.pexp_loc)) in
+               (Exp en, adaptThing, knockoutExp, adaptThing, expCtx) in
+             map_at expCtxMaker eList in
+           [TriageElide [astThing, [] (* List.rev_map (fun (h, _, _, _, _) -> h) expCtxMakers *), expCtxMakers]]
+       | Pexp_sequence(e1,e2) -> 
+           let sndCtxMaker =
+             let sndCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+               Pexp_sequence(f, _) -> {exp' with pexp_desc = Pexp_sequence(f, hole')}
+             | _ -> exp') in
+             let knockoutSnd exp' = sndCtx exp' (Exp (elision e1.pexp_loc)) in
+             (Exp e2, adaptThing, knockoutSnd, adaptThing, sndCtx) in
+           let fstCtxMaker =
+             let fstCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+               Pexp_sequence(_, s) -> {exp' with pexp_desc = Pexp_sequence(hole', s)}
+             | _ -> exp') in
+             let knockoutFst exp' = fstCtx exp' (Exp (elision e2.pexp_loc)) in
+             (Exp e1, adaptThing, knockoutFst, adaptThing, fstCtx) in
+           [TriageElide [astThing, [(* Exp e1; Exp e2 *)], [sndCtxMaker; fstCtxMaker]]]
+       | Pexp_ifthenelse (guard, iftrue, iffalseOpt) ->
+           let (elseE, elseLoc) = match iffalseOpt with None -> (adapter !locNone, !locNone) | Some e -> (e, e.pexp_loc) in
+           let elseCtxMaker =
+             let elseCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with 
+               Pexp_ifthenelse(g, t, _) -> {exp' with pexp_desc = Pexp_ifthenelse(g, t, Some hole')}
+             | _ -> exp') in
+             let knockoutElse exp' = elseCtx exp' (Exp (elision elseLoc)) in
+             (Exp elseE, adaptThing, knockoutElse, adaptThing, elseCtx) in
+           let thenCtxMaker =
+             let thenCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+               Pexp_ifthenelse(g, _, e) -> {exp' with pexp_desc = Pexp_ifthenelse(g, hole', e)}
+             | _ -> exp') in
+             let knockoutThen exp' = thenCtx exp' (Exp (elision iftrue.pexp_loc)) in
+             (Exp iftrue, adaptThing, knockoutThen, adaptThing, thenCtx) in
+           let guardCtxMaker =
+             let guardCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+               Pexp_ifthenelse(_, t, e) -> {exp' with pexp_desc = Pexp_ifthenelse(hole', t, e)}
+             | _ -> exp') in
+             let knockoutGuard exp' = guardCtx exp' (Exp (elision guard.pexp_loc)) in
+             let idealCtx = expexpify (fun hole' -> {exp with pexp_desc =
+                                                     Pexp_ifthenelse(hole', elision iftrue.pexp_loc, Some (elision elseLoc))}) in
+             (Exp guard, adaptThing, knockoutGuard, adaptThing <<== idealCtx, guardCtx) in
+           (* let holes = (Exp guard) :: (Exp iftrue) :: (match iffalseOpt with None -> [] | Some e -> [Exp e]) in *)
+           [TriageElide [astThing, [], [guardCtxMaker; thenCtxMaker; elseCtxMaker]]]
+       | Pexp_apply (fExp, lab_exp_list) ->
+           let funCtxMaker =
+             let funCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+               Pexp_apply(_, leList) -> {exp' with pexp_desc = Pexp_apply(hole', leList)}
+             | _ -> exp') in
+             let knockoutFun exp' = funCtx exp' (Exp (elision fExp.pexp_loc)) in
+             (Exp fExp, adaptThing, knockoutFun, adaptThing, funCtx) in
+           let argCtxMakers =
+             let argCtxMaker n (l, e) =
+               let argCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+                 Pexp_apply(f, leList) -> {exp' with pexp_desc = Pexp_apply(f, replaceNthWith leList n (l, hole'))}
+               | _ -> exp') in
+               let knockoutArg exp' = argCtx exp' (Exp (elision e.pexp_loc)) in
+               (Exp e, adaptThing, knockoutArg, adaptThing, argCtx) in
+             map_at argCtxMaker lab_exp_list in
+           [TriageElide [astThing, [] (* (Exp fExp) :: (List.rev_map (fun (h, _, _, _, _) -> h) argCtxMakers) *), (List.rev_append argCtxMakers [funCtxMaker])]]
+       | Pexp_match (e, pat_exp_list) -> 
+           let exppatexpify ctx = fun x y -> Exp (ctx (toExp x) (toPat y)) in
+           (* phase 1: just the matched expression *)
+           let blankMatch = {exp with pexp_desc = Pexp_match (e, [alphaPat e.pexp_loc, elision e.pexp_loc])} in
+           let matchCtxMaker =
+             let matchCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+               Pexp_match(_, peList) -> {exp' with pexp_desc = Pexp_match(hole', peList)}
+             | _ -> exp') in
+             let knockoutMatch exp' = matchCtx exp' (Exp (elision e.pexp_loc)) in
+             (Exp e, adaptThing, knockoutMatch, adaptThing, matchCtx) in
+           let phase1elided = map_and_flatten (fun (p,e) -> [Exp e; Pat p]) pat_exp_list in
+           let phase1 = (Exp blankMatch, phase1elided, [matchCtxMaker]) in
+           (* phase 2: the matched expression and the patterns *)
+           let rec stripLeafExps exp =
+             match exp.pexp_desc with 
+               Pexp_match(e, peList) -> 
+                 let (peList', elidedLists) = List.split (List.map (fun (p, e) -> let (newE, elided) = stripLeafExps e in ((p, newE), elided)) peList) in
+                 let joinedElided = List.fold_left List.rev_append [] elidedLists in
+                 ({exp with pexp_desc = Pexp_match(e, peList')}, joinedElided)
+             | Pexp_try(e, peList) -> 
+                 let (peList', elidedLists) = List.split (List.map (fun (p, e) -> let (newE, elided) = stripLeafExps e in ((p, newE), elided)) peList) in
+                 let joinedElided = List.fold_left List.rev_append [] elidedLists in
+                 ({exp with pexp_desc = Pexp_try(e, peList')}, joinedElided)
+             | Pexp_function(l, dOpt, peList) -> 
+                 let (peList', elidedLists) = List.split (List.map (fun (p, e) -> let (newE, elided) = stripLeafExps e in ((p, newE), elided)) peList) in
+                 let joinedElided = List.fold_left List.rev_append [] elidedLists in
+                 ({exp with pexp_desc = Pexp_function(l, dOpt, peList')}, joinedElided)
+             | Pexp_sequence(e1, e2) -> 
+                 let (e2', elidedE2) = stripLeafExps e2 in
+                 ({exp with pexp_desc = Pexp_sequence(elision e1.pexp_loc, e2')}, ((Exp e1) :: elidedE2))
+             | Pexp_let(r, peList, e) ->
+                 let (e', elidedE) = stripLeafExps e in
+                 let (blankPEs, es) = List.split (List.map (fun (p,e) -> ((p,elision e.pexp_loc), Exp e)) peList) in
+                 ({exp with pexp_desc = Pexp_let(r, blankPEs, e')}, (List.rev_append es elidedE))
+             | _ -> (elision exp.pexp_loc, [Exp exp]) in
+           let (strippedTree, phase2elided) = stripLeafExps exp in
+           let patCtxMakers =
+             let patCtxMaker n (pn, en) =
+               let patCtx = exppatexpify (fun exp' hole' -> match exp'.pexp_desc with
+                 Pexp_match(e, peList) -> {exp' with pexp_desc = Pexp_match(e, replaceNthWith peList n (hole', elision en.pexp_loc))}
+               | _ -> exp') in
+               let knockoutPat exp' = patCtx exp' (Pat (alphaPat { loc_start = {Lexing.dummy_pos with pos_cnum = -666} ; 
+                                                                   loc_end =   {Lexing.dummy_pos with pos_cnum = -666} ; 
+                                                                   loc_ghost = true })) in
+               let idealCtx = patexpify (fun pat' -> {strippedTree with pexp_desc = Pexp_match(e, 
+                                                                                      [(pat', elision en.pexp_loc);
+                                                                                       (alphaPat pn.ppat_loc, elision en.pexp_loc)])}) in
+               (Pat pn, adaptThing, knockoutPat, adaptThing <<== idealCtx, patCtx) in
+             map_at patCtxMaker pat_exp_list in
+           let phase2 = (Exp strippedTree, phase2elided, patCtxMakers) in
+           (* phase 3: just the expressions *)
+           let expCtxMakers =
+             let expCtxMaker n (pn, en) =
+               let expCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+                 Pexp_match(e, peList) -> {exp' with pexp_desc = Pexp_match(e, replaceNthWith peList n (pn, hole'))}
+               | _ -> exp') in
+               let knockoutExp exp' = expCtx exp' (Exp (elision en.pexp_loc)) in
+               let idealCtx = expexpify (fun hole' -> {exp with pexp_desc = Pexp_match(elision e.pexp_loc, 
+                                                                                      [(toPat (adaptThing (Pat pn)), hole');
+                                                                                       (alphaPat pn.ppat_loc, elision en.pexp_loc)])}) in
+               (Exp en, adaptThing, knockoutExp, adaptThing <<== idealCtx, expCtx) in
+             map_at expCtxMaker pat_exp_list in
+           let phase3 = (astThing, [], expCtxMakers) in
+           [TriageElide [phase1; phase2; phase3]]
+       | Pexp_try (e, pat_exp_list) -> 
+           let exppatexpify ctx = fun x y -> Exp (ctx (toExp x) (toPat y)) in
+           (* phase 1: just the matched expression *)
+           let blankMatch = {exp with pexp_desc = Pexp_try (e, [alphaPat e.pexp_loc, elision e.pexp_loc])} in
+           let tryCtxMaker =
+             let tryCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+               Pexp_try(_, peList) -> {exp' with pexp_desc = Pexp_try(hole', peList)}
+             | _ -> exp') in
+             let knockoutMatch exp' = tryCtx exp' (Exp (elision e.pexp_loc)) in
+             (Exp e, adaptThing, knockoutMatch, adaptThing, tryCtx) in
+           let phase1elided = map_and_flatten (fun (p,e) -> [Exp e; Pat p]) pat_exp_list in
+           let phase1 = (Exp blankMatch, phase1elided, [tryCtxMaker]) in
+           (* phase 2: the tryed expression and the patterns *)
+           let rec stripLeafExps exp =
+             match exp.pexp_desc with 
+               Pexp_match(e, peList) -> 
+                 let (peList', elidedLists) = List.split (List.map (fun (p, e) -> let (newE, elided) = stripLeafExps e in ((p, newE), elided)) peList) in
+                 let joinedElided = List.fold_left List.rev_append [] elidedLists in
+                 ({exp with pexp_desc = Pexp_match(e, peList')}, joinedElided)
+             | Pexp_try(e, peList) -> 
+                 let (peList', elidedLists) = List.split (List.map (fun (p, e) -> let (newE, elided) = stripLeafExps e in ((p, newE), elided)) peList) in
+                 let joinedElided = List.fold_left List.rev_append [] elidedLists in
+                 ({exp with pexp_desc = Pexp_try(e, peList')}, joinedElided)
+             | Pexp_function(l, dOpt, peList) -> 
+                 let (peList', elidedLists) = List.split (List.map (fun (p, e) -> let (newE, elided) = stripLeafExps e in ((p, newE), elided)) peList) in
+                 let joinedElided = List.fold_left List.rev_append [] elidedLists in
+                 ({exp with pexp_desc = Pexp_function(l, dOpt, peList')}, joinedElided)
+             | Pexp_sequence(e1, e2) -> 
+                 let (e2', elidedE2) = stripLeafExps e2 in
+                 ({exp with pexp_desc = Pexp_sequence(elision e1.pexp_loc, e2')}, ((Exp e1) :: elidedE2))
+             | Pexp_let(r, peList, e) ->
+                 let (e', elidedE) = stripLeafExps e in
+                 let (blankPEs, es) = List.split (List.map (fun (p,e) -> ((p,elision e.pexp_loc), Exp e)) peList) in
+                 ({exp with pexp_desc = Pexp_let(r, blankPEs, e')}, (List.rev_append es elidedE))
+             | _ -> (elision exp.pexp_loc, [Exp exp]) in
+           let (strippedTree, phase2elided) = stripLeafExps exp in
+           let patCtxMakers =
+             let patCtxMaker n (pn, en) =
+               let patCtx = exppatexpify (fun exp' hole' -> match exp'.pexp_desc with
+                 Pexp_try(e, peList) -> {exp' with pexp_desc = Pexp_try(e, replaceNthWith peList n (hole', elision en.pexp_loc))}
+               | _ -> exp') in
+               let knockoutPat exp' = patCtx exp' (Pat (alphaPat { loc_start = {Lexing.dummy_pos with pos_cnum = -666} ; 
+                                                                   loc_end =   {Lexing.dummy_pos with pos_cnum = -666} ; 
+                                                                   loc_ghost = true })) in
+               let idealCtx = patexpify (fun pat' -> {strippedTree with pexp_desc = Pexp_try(e, 
+                                                                                      [(pat', elision en.pexp_loc);
+                                                                                       (alphaPat pn.ppat_loc, elision en.pexp_loc)])}) in
+               (Pat pn, adaptThing, knockoutPat, adaptThing <<== idealCtx, patCtx) in
+             map_at patCtxMaker pat_exp_list in
+           let phase2 = (Exp strippedTree, phase2elided, patCtxMakers) in
+           (* phase 3: just the expressions *)
+           let expCtxMakers =
+             let expCtxMaker n (pn, en) =
+               let expCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+                 Pexp_try(e, peList) -> {exp' with pexp_desc = Pexp_try(e, replaceNthWith peList n (pn, hole'))}
+               | _ -> exp') in
+               let knockoutExp exp' = expCtx exp' (Exp (elision en.pexp_loc)) in
+               let idealCtx = expexpify (fun hole' -> {exp with pexp_desc = Pexp_try(elision e.pexp_loc, 
+                                                                                      [(toPat (adaptThing (Pat pn)), hole');
+                                                                                       (alphaPat pn.ppat_loc, elision en.pexp_loc)])}) in
+               (Exp en, adaptThing, knockoutExp, adaptThing <<== idealCtx, expCtx) in
+             map_at expCtxMaker pat_exp_list in
+           let phase3 = (astThing, [], expCtxMakers) in
+           [TriageElide [phase1; phase2; phase3]]
+       | Pexp_function(lab, defaultOpt, peList) -> 
+           let exppatexpify ctx = fun x y -> Exp (ctx (toExp x) (toPat y)) in
+           (* phase 1: just the default expression *)
+           let phase1 = 
+             match defaultOpt with 
+               None -> None 
+             | Some def ->
+                 let blankMatch = {exp with pexp_desc = Pexp_function(lab, Some def, [alphaPat def.pexp_loc, elision def.pexp_loc])} in
+                 let functionCtxMaker =
+                   let functionCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+                     Pexp_function(lab, _, peList) -> {exp' with pexp_desc = Pexp_function(lab, Some hole', peList)}
+                   | _ -> exp') in
+                   let knockoutMatch exp' = functionCtx exp' (Exp (elision def.pexp_loc)) in
+                   (Exp def, adaptThing, knockoutMatch, adaptThing, functionCtx) in
+                 let phase1elided = map_and_flatten (fun (p,e) -> [Exp e; Pat p]) peList in
+                 Some (Exp blankMatch, phase1elided, [functionCtxMaker]) in
+           (* phase 2: the matched expression and the patterns *)
+           let rec stripLeafExps exp =
+             match exp.pexp_desc with 
+               Pexp_match(e, peList) -> 
+                 let (peList', elidedLists) = List.split (List.map (fun (p, e) -> let (newE, elided) = stripLeafExps e in ((p, newE), elided)) peList) in
+                 let joinedElided = List.fold_left List.rev_append [] elidedLists in
+                 ({exp with pexp_desc = Pexp_match(e, peList')}, joinedElided)
+             | Pexp_try(e, peList) -> 
+                 let (peList', elidedLists) = List.split (List.map (fun (p, e) -> let (newE, elided) = stripLeafExps e in ((p, newE), elided)) peList) in
+                 let joinedElided = List.fold_left List.rev_append [] elidedLists in
+                 ({exp with pexp_desc = Pexp_try(e, peList')}, joinedElided)
+             | Pexp_function(l, dOpt, peList) -> 
+                 let (peList', elidedLists) = List.split (List.map (fun (p, e) -> let (newE, elided) = stripLeafExps e in ((p, newE), elided)) peList) in
+                 let joinedElided = List.fold_left List.rev_append [] elidedLists in
+                 ({exp with pexp_desc = Pexp_function(l, dOpt, peList')}, joinedElided)
+             | Pexp_sequence(e1, e2) -> 
+                 let (e2', elidedE2) = stripLeafExps e2 in
+                 ({exp with pexp_desc = Pexp_sequence(elision e1.pexp_loc, e2')}, ((Exp e1) :: elidedE2))
+             | Pexp_let(r, peList, e) ->
+                 let (e', elidedE) = stripLeafExps e in
+                 let (blankPEs, es) = List.split (List.map (fun (p,e) -> ((p,elision e.pexp_loc), Exp e)) peList) in
+                 ({exp with pexp_desc = Pexp_let(r, blankPEs, e')}, (List.rev_append es elidedE))
+             | _ -> (elision exp.pexp_loc, [Exp exp]) in
+           let (strippedTree, phase2elided) = stripLeafExps exp in
+           let patCtxMakers =
+             let patCtxMaker n (pn, en) =
+               let patCtx = exppatexpify (fun exp' hole' -> match exp'.pexp_desc with
+                 Pexp_function(l, dOpt, peList) -> {exp' with pexp_desc = Pexp_function(l, dOpt, replaceNthWith peList n (hole', elision en.pexp_loc))}
+               | _ -> exp') in
+               let knockoutPat exp' = patCtx exp' (Pat (alphaPat { loc_start = {Lexing.dummy_pos with pos_cnum = -666} ; 
+                                                                   loc_end =   {Lexing.dummy_pos with pos_cnum = -666} ; 
+                                                                   loc_ghost = true })) in
+               let idealCtx = patexpify (fun pat' -> {strippedTree with pexp_desc = Pexp_function(lab, defaultOpt, 
+                                                                                                  [(pat', elision en.pexp_loc);
+                                                                                                   (alphaPat pn.ppat_loc, elision en.pexp_loc)])}) in
+               (Pat pn, adaptThing, knockoutPat, adaptThing <<== idealCtx, patCtx) in
+             map_at patCtxMaker peList in
+           let phase2 = (Exp strippedTree, phase2elided, patCtxMakers) in
+           (* phase 3: just the expressions *)
+           let expCtxMakers =
+             let expCtxMaker n (pn, en) =
+               let expCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+                 Pexp_function(l, dOpt, peList) -> {exp' with pexp_desc = Pexp_function(l, dOpt, replaceNthWith peList n (pn, hole'))}
+               | _ -> exp') in
+               let knockoutExp exp' = expCtx exp' (Exp (elision en.pexp_loc)) in
+               let idealCtx = expexpify (fun hole' -> {exp with pexp_desc = Pexp_function(lab, defaultOpt, 
+                                                                                          [(toPat (adaptThing (Pat pn)), hole');
+                                                                                           (alphaPat pn.ppat_loc, elision en.pexp_loc)])}) in
+               (Exp en, adaptThing, knockoutExp, adaptThing <<== idealCtx, expCtx) in
+             map_at expCtxMaker peList in
+           let phase3 = (astThing, [], expCtxMakers) in
+           [TriageElide (match phase1 with Some phase1 -> [phase1; phase2; phase3] | None -> [phase2; phase3])]
+       | Pexp_let (recFlag, peList, e) ->
+           let exppatexpify ctx = fun x y -> Exp (ctx (toExp x) (toPat y)) in
+           (* phase 1: binding patterns *)
+           let blankBodies = {exp with pexp_desc = Pexp_let(recFlag, List.map (fun (p, e) -> (p, elision e.pexp_loc)) peList, elision e.pexp_loc)} in
+           let patCtxMakers =
+             let patCtxMaker n (pn, en) =
+               let patCtx = exppatexpify (fun exp' hole' -> match exp'.pexp_desc with
+                 Pexp_let(rFlag, peList, e) -> {exp' with pexp_desc = Pexp_let(rFlag, replaceNthWith peList n (hole', elision en.pexp_loc), e)}
+               | _ -> exp') in
+               let knockoutPat exp' = patCtx exp' (Pat (alphaPat { loc_start = {Lexing.dummy_pos with pos_cnum = -666} ; 
+                                                                   loc_end =   {Lexing.dummy_pos with pos_cnum = -666} ; 
+                                                                   loc_ghost = true })) in
+               let idealCtx = patexpify (fun pat' -> {exp with pexp_desc = Pexp_let(recFlag, [pat', elision pat'.ppat_loc], elision e.pexp_loc)}) in
+               (Pat pn, adaptThing, knockoutPat, adaptThing <<== idealCtx, patCtx) in
+             map_at patCtxMaker peList in
+           let phase1elisions = (Exp e) :: (List.rev_map (fun (p, e) -> Exp e) peList) in
+           let phase1 = (Exp blankBodies, phase1elisions, patCtxMakers) in
+           (* phase 2: bound expressions *)
+           let blankInner = {exp with pexp_desc = Pexp_let(recFlag, peList, elision e.pexp_loc)} in
+           let expCtxMakers =
+             let expCtxMaker n (pn, en) =
+               let expCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+                 Pexp_let(rFlag, peList, e) -> {exp' with pexp_desc = Pexp_let(rFlag, replaceNthWith peList n (pn, hole'), e)}
+               | _ -> exp') in
+               let knockoutExp exp' = expCtx exp' (Exp (elision en.pexp_loc)) in
+               (Exp en, adaptThing, knockoutExp, adaptThing, expCtx) in
+             map_at expCtxMaker peList in
+           let phase2elisions = [Exp e] in
+           let phase2 = (Exp blankInner, phase2elisions, expCtxMakers) in
+           (* phase 3: body expression *)
+           let eCtxMaker =
+             let eCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+               Pexp_let(rFlag, peList, _) -> {exp' with pexp_desc = Pexp_let(rFlag, peList, hole')}
+             | _ -> exp') in
+             let knockoutMatch exp' = eCtx exp' (Exp (elision e.pexp_loc)) in
+             (Exp e, adaptThing, knockoutMatch, adaptThing, eCtx) in
+           let phase3 = (astThing, [], [eCtxMaker]) in
+           [TriageElide [phase1; phase2; phase3]]
+       | Pexp_constraint(exp', sty1, sty2) -> []
+       | Pexp_construct (id, exp_opt, b) -> []
+       | Pexp_record (idExpList, eOpt) -> []
+       | Pexp_field(e, id) -> []
+       | Pexp_setfield(e1, id, e2) -> []
+       | Pexp_send(e, s) -> []
+       | Pexp_setinstvar(s, e) -> []
+       | Pexp_override seList -> []
+       | Pexp_poly(e, tyOpt) -> []
+       | Pexp_object patClsfieldList -> []
+       | Pexp_variant(l, eOpt) -> []
+       | Pexp_letmodule(name, modExp, exp') -> []
+       | Pexp_new id -> []
+       | Pexp_while(guard, body) -> 
+           let guardCtxMaker =
+             let guardCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+               Pexp_while(_, body) -> {exp' with pexp_desc = Pexp_while(hole', body)}
+             | _ -> exp') in
+             let knockoutGuard exp' = guardCtx exp' (Exp (elision guard.pexp_loc)) in
+             (Exp guard, adaptThing, knockoutGuard, adaptThing, guardCtx) in
+           let bodyCtxMaker =
+             let bodyCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+               Pexp_while(guard, _) -> {exp' with pexp_desc = Pexp_while(guard, hole')}
+             | _ -> exp') in
+             let knockoutBody exp' = bodyCtx exp' (Exp (elision body.pexp_loc)) in
+             (Exp body, adaptThing, knockoutBody, adaptThing, bodyCtx) in
+           [TriageElide [(Exp exp, [], [guardCtxMaker; bodyCtxMaker])]]
+       | Pexp_for(v, init, term, dir, body) -> 
+           let initCtxMaker =
+             let initCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+               Pexp_for(v, _, term, dir, body) -> {exp' with pexp_desc = Pexp_for(v, hole', term, dir, body)}
+             | _ -> exp') in
+             let knockoutGuard exp' = initCtx exp' (Exp (elision init.pexp_loc)) in
+             (Exp init, adaptThing, knockoutGuard, adaptThing, initCtx) in
+           let termCtxMaker =
+             let termCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+               Pexp_for(v, init, _, dir, body) -> {exp' with pexp_desc = Pexp_for(v, init, hole', dir, body)}
+             | _ -> exp') in
+             let knockoutGuard exp' = termCtx exp' (Exp (elision term.pexp_loc)) in
+             (Exp term, adaptThing, knockoutGuard, adaptThing, termCtx) in
+           let bodyCtxMaker =
+             let bodyCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+               Pexp_for(v, init, term, dir, _) -> {exp' with pexp_desc = Pexp_for(v, init, term, dir, hole')}
+             | _ -> exp') in
+             let knockoutBody exp' = bodyCtx exp' (Exp (elision body.pexp_loc)) in
+             (Exp body, adaptThing, knockoutBody, adaptThing, bodyCtx) in
+           [TriageElide [(Exp exp, [], [initCtxMaker; termCtxMaker; bodyCtxMaker])]]
+       | Pexp_when(guard, case) -> 
+           let guardCtxMaker =
+             let guardCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+               Pexp_when(_, case) -> {exp' with pexp_desc = Pexp_when(hole', case)}
+             | _ -> exp') in
+             let knockoutGuard exp' = guardCtx exp' (Exp (elision guard.pexp_loc)) in
+             (Exp guard, adaptThing, knockoutGuard, adaptThing, guardCtx) in
+           let caseCtxMaker =
+             let caseCtx = expexpexpify (fun exp' hole' -> match exp'.pexp_desc with
+               Pexp_when(guard, _) -> {exp' with pexp_desc = Pexp_when(guard, hole')}
+             | _ -> exp') in
+             let knockoutBody exp' = caseCtx exp' (Exp (elision case.pexp_loc)) in
+             (Exp case, adaptThing, knockoutBody, adaptThing, caseCtx) in
+           [TriageElide [(Exp exp, [], [guardCtxMaker; caseCtxMaker])]]
+       | Pexp_lazy e -> []
+       end
+   | _ -> (* print_string ("Failure: not an Exp: " ^ (nameOf astThing) ^ "\n"); *) []
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ let addPrologue prologue program = List.rev_append (List.rev prologue) program
+ let totalMods = ref 0
+ let totalInterestingNodes = ref 0
+ let totalAttempts = ref 0
+ let rec explore outerCtx searchCtx innerCtxLst typeAst locOpt astThing : searchResults =
+ 
+ 
+   let rec attemptSearcher searcher (mods, followups, fallbacks) : searchResults =
+     incr totalAttempts;
+     decr totalMods;
+     let modsThatWorked = map_and_flatten searcher (List.rev mods) in (* List.fold_left List.rev_append [] (List.rev_map searcher mods) in *)
+     match modsThatWorked with
+       [] -> map_and_flatten searcher (fallbacks ()) (* List.fold_left List.rev_append [] (List.rev_map searcher (fallbacks ())) *)
+     | _ -> 
+         let moreMods = map_and_flatten searcher (followups ()) in (* List.fold_left List.rev_append [] (List.rev_map searcher (followups ())) in *)
+         let validMods = List.filter (fun (r, _) -> match r with SingleRepl r -> r.trep_validate() | _ -> true) modsThatWorked in
+         List.rev_append validMods moreMods
+  
+   and search inMulti inTriage outerCtx searchCtx innerCtxLst  astmod : searchResults =
+     incr totalMods;
+     match astmod with
+       Attempt (mods, followups, fallbacks) ->
+         attemptSearcher (search inMulti inTriage outerCtx searchCtx innerCtxLst) (mods, followups, fallbacks)
+     | TriggerSingle (hole, ctx) ->
+         searchSingle inMulti inTriage (outerCtx <<== ctx) ctx (narrowContext innerCtxLst ctx) hole
+     | TriggerMulti (hole, ctx) -> 
+         if (not inMulti) then searchMulti inMulti inTriage (outerCtx <<== ctx) ctx (narrowContext innerCtxLst ctx) hole else []
+     | TriggerTriage (hole, ctx) ->
+         if (!Clflags.no_triage) then [] 
+         else if (inTriage) then [] 
+         else searchTriage inMulti inTriage (outerCtx <<== ctx) ctx (narrowContext innerCtxLst ctx) hole
+     | _ -> print_string ("Should not have happened!  Modification is search-specific: " ^ (astRevisionName astmod) ^ "\n"); 
+         raise DynamicTypeError 
+ 
+   and searchSingle inMulti inTriage outerCtx searchCtx innerCtxLst astThing : searchResults =
+     incr totalInterestingNodes;
+     let mods = destructNode astThing locOpt inMulti inTriage in
+     let rec trySingleMod md =
+       incr totalMods;
+       match md with
+         Attempt (mods, followups, fallbacks) ->
+           attemptSearcher trySingleMod (mods, followups, fallbacks)
+       | SingleRecur (hole, ctx) ->
+           searchSingle inMulti inTriage (outerCtx <<== ctx) (searchCtx <<== ctx) (narrowContext innerCtxLst ctx) hole
+       | SingleReplace r ->
+           let revision = r.trep_revision () in
+           let newProg = toStr (outerCtx revision) in
+           begin try 
+             let ast = addPrologue !globalPrologue (addPrologue r.trep_prologue newProg) in
+             let (typedAST, _) = typeAst ast in
+             let newR = SingleRepl {r with trep_type = findType typedAST (itemLocation revision)} in
+             [newR, (outerCtx, searchCtx, (widestContext innerCtxLst))]
+           with y -> [] end
+       | _ -> search inMulti inTriage outerCtx searchCtx innerCtxLst md
+     in map_and_flatten trySingleMod (List.rev mods) (* List.fold_left List.rev_append [] (List.rev_map trySingleMod mods) *)
+ 
+   and searchMulti inMulti inTriage outerCtx searchCtx innerCtxLst astThing : searchResults =
+     (* print_string "Multisearch not implemented\n"; *)
+     []
+ 
+   and searchTriage inMulti inTriage outerCtx searchCtx innerCtxLst astThing : searchResults =
+     incr totalInterestingNodes;
+     let tryExp exp outerCtx =
+       try 
+         ignore(typeAst (addPrologue !globalPrologue (toStr (outerCtx exp)))); true
+       with _ -> false in
+     let triageRepl (p, i, t, a, o, d, g, l, r) =
+       TriageRepl {ttri_prologue = p; ttri_idealctx = i; ttri_triaged = t; ttri_adapted = a; ttri_original = o; ttri_desc = d; ttri_tag = g; ttri_locs = l; ttri_replaced = r} in
+     let mods = triageNode astThing in
+     let rec tryTriageMod md =
+       incr totalMods;
+       match md with
+         Attempt (mods, followups, fallbacks) ->
+           attemptSearcher tryTriageMod (mods, followups, fallbacks)
+       | TriageElide phases ->
+           let processRefExp refExp elidedExps =
+             if elidedExps = [] then [] else (* if nothing's been changed, why bother re-searching what already failed? *)
+             let singleSearch = search inMulti true outerCtx searchCtx innerCtxLst (TriggerSingle (refExp, (fun x -> x))) in
+             let wrapSingle (md, (outerCtx', searchCtx', innerCtx')) =
+               match md with
+                 SingleRepl r -> (triageRepl ([], searchCtx', elidedExps, [], astThing,
+                                              "Knocked out all leaf expressions, and " ^ r.trep_desc, t("Triage_SingleFix"),
+                                              List.rev_map itemLocation elidedExps, {r with trep_replaced = (if r.trep_replaced = refExp then astThing else r.trep_replaced)}), 
+                                  (outerCtx, searchCtx', widestContext innerCtxLst))
+               | TriageRepl r -> print_string "Should not have happened!\n"; raise DynamicTypeError
+             in List.rev_map wrapSingle singleSearch in
+           let processElisions elisions elidedExps =
+             (* figure out which subexpressions don't typecheck even in an ideal context *)
+             let revTypecorrectInIdeal = List.rev_map (function (hole, _, _, ideal, _) as el -> (el, tryExp (ideal hole) outerCtx)) elisions in
+             (* and knock them out of consideration *)
+             let (mustBeKnockedout, elided) = List.fold_left (fun (accuKO, accuEl) ((hole, _, knockout, _, _) as el, tcInIdeal) -> 
+               if tcInIdeal then (accuKO, accuEl) else (knockout :: accuKO, el :: accuEl)) ([], []) revTypecorrectInIdeal in
+             let knockedOut = List.fold_left (fun exp ko -> ko exp) astThing mustBeKnockedout in
+             (* adapt everything else, then greedily unadapt them *)
+             let (adaptRest, adaptedHoles) = List.fold_left (fun (accuExp, accuEl) ((hole, adapt, _, _, ctx) as el, tcInIdeal) -> 
+               if tcInIdeal then (ctx accuExp (adapt hole), el :: accuEl) else (accuExp, accuEl)) (knockedOut, []) revTypecorrectInIdeal in
+             let (minAdapted, minAdaptedHoles) = 
+               let unAdaptIfPossible (accuExp, accuEl) ((hole, _, _, _, ctx) as el) = 
+                 if tryExp hole (outerCtx <<== (ctx accuExp)) then (ctx accuExp hole, accuEl) else (accuExp, el :: accuEl) in
+               List.fold_left unAdaptIfPossible (adaptRest, []) adaptedHoles in
+             (* for those knocked out, try individual fixes *)
+             let elideAllButOne = map_at
+                 (fun n lst -> (List.fold_left (fun accu f -> accu <<== f) (fun x -> x) lst, 
+                                List.nth elided n, 
+                                List.rev_map (fun (h, _, _, _, _) -> h) (removeNth n elided)))  (* for each list below, compose all the functions together, and return the nth thing and all-but-nth *)
+                 (map_c (fun n -> removeNth n mustBeKnockedout) mustBeKnockedout) in            (* construct the list of lists where one element was removed *)
+             (* for each one of these all-but-one-knockedout contexts *)
+             let processSingleHole (ko, (hole, _, _, _, ctx), knockedOut) =
+               (* search for a single-point fix to them, since other problems have been elided *)
+               let searchMds = search inMulti true outerCtx searchCtx innerCtxLst (TriggerSingle(hole, (ctx minAdapted))) in
+               (* again greedily remove as many unnecessary adaptations as possible *)
+               let unAdaptIfPossible (md, (outerCtx', searchCtx', innerCtx')) = 
+                 let (rev, rctx) = match md with
+                   SingleRepl r -> (r.trep_revision ()), searchCtx'
+                 | TriageRepl r -> (r.ttri_replaced.trep_revision()), r.ttri_idealctx in
+                 List.fold_left (* this returns a new context which undoes the adaptations, and a list of those still adapted *)
+                   (fun (accu, adapted) (hole, _, _, _, ctx) -> if tryExp hole (outerCtx <<== (ctx (accu rev))) then ((fun rev' -> ctx (accu rev') hole), adapted) else (accu, hole :: adapted)) 
+                   (rctx, []) adaptedHoles in
+               (* wrap the found changes in a TriageRepl, which indicates what has been knocked out or adapted *)
+               let fullKnockedOut = List.rev_append elidedExps knockedOut in
+               let wrapSingleFix (md, (outerCtx', searchCtx', innerCtx')) =
+                 let (newSearchCtx, adapted) = unAdaptIfPossible (md, (outerCtx', searchCtx', innerCtx')) in
+                 match md with
+                   SingleRepl r -> (triageRepl ([], newSearchCtx, fullKnockedOut, adapted, astThing,
+                                                "1Adapted some expressions, knocked some out, and " ^ r.trep_desc, t("Triage_Elide"),
+                                                List.rev_map itemLocation (List.rev_append fullKnockedOut adapted), r), (outerCtx, newSearchCtx, widestContext innerCtxLst))
+                 | TriageRepl r -> (triageRepl ([], newSearchCtx, fullKnockedOut, adapted, astThing,
+                                                "2Adapted some expressions, knocked some out, and " ^ r.ttri_desc, r.ttri_replaced.trep_tag,
+                                                List.rev_map itemLocation (List.rev_append fullKnockedOut adapted), r.ttri_replaced), (outerCtx, newSearchCtx, widestContext innerCtxLst))
+               in List.rev_map wrapSingleFix searchMds in
+             (* put it all together: process each hole as above *)
+             map_and_flatten processSingleHole elideAllButOne in
+           let rec processTriagePhaseList triagePhases =
+             match triagePhases with
+               [] -> []
+             | (refExp, elidedExps, elisions) :: tl ->
+                 if (tryExp refExp outerCtx) then
+                   processTriagePhaseList tl
+                 else
+                   List.rev_append (processRefExp refExp elidedExps) (processElisions elisions elidedExps) in
+           processTriagePhaseList phases
+       | _ -> search inMulti true outerCtx searchCtx innerCtxLst md
+     in map_and_flatten tryTriageMod mods
+       
+   in (search false false outerCtx searchCtx innerCtxLst (TriggerSingle (astThing, searchCtx)))
+ 
+ 
+ 
+ 
+ let seminalSearch typeAst ast locOpt : (replacement * (astContext * astContext)) list =
+   let fixes = explore (fun x -> x) (fun x -> x) (makeContext 5) typeAst locOpt (Str ast) in
+   List.map (fun (rep, (outerCtx, _, innerCtx)) -> (rep, (innerCtx, outerCtx))) fixes
+ 
+ ;;
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ 
+ 
+ 
+ (* XXXXXXXXXXXXXXXXXXXX  Ranking and Reporting  XXXXXXXXXXXXXXXXXXXXXX *)
+ 
+ (* Thoughts: reorder this list, in desired sorted order.  Is that possible?  Is there a consistent sort order? *)
+ let initTags () = List.iter (fun s -> ignore(t s)) [
+   "Triage_SingleFix"; "Triage_Elide";
+   "Exp_Apply_AddArg"; "Exp_Apply_DeleteArg"; "Exp_Apply_FixArg";  "Exp_Apply_FixFun"; "Exp_Apply_GeneralizeApply"; "Exp_Apply_CurryArgs"; "Exp_Apply_UncurryArgs";
+   "Exp_Apply_SwapArgs"; "Exp_Apply_RelocateArgs"; "Exp_Apply_RemoveLabels";  "Exp_Apply_SingleReplaceBinding"; "Exp_Apply_RotateL"; "Exp_Apply_RotateR";
+   "Exp_Apply_RemoveFun"; "Exp_Ident_FixId"; "Exp_Ident_Deref";
+   "Exp_Array_FixSubexp"; "Exp_Assert_FixSubexp";  "Exp_Constraint_FixSubexp"; "Exp_Constraint_RemoveConstraint";
+   "Exp_Construct_DeleteBody"; "Exp_Construct_FixSubexp";  "Exp_Construct_GeneralizeBody"; "Exp_Construct_FixTuplelist"; "Exp_Construct_RotateConstructs"; "Exp_Construct_FixUnitList";
+   "Exp_Field_FixId"; "Exp_Field_FixSubexp"; "Exp_For_FixBody";  "Exp_For_FixInit"; "Exp_For_FixTerm"; "Exp_Function_AddParamAfter";
+   "Exp_Function_SwapArgs"; "Exp_Function_RelocateArgs"; "Exp_Adapt"; "Exp_Function_CurryArgs"; "Exp_Function_UncurryArgs";
+   "Exp_Function_AddParamBefore"; "Exp_Function_FixDefault";  "Exp_Function_FixSubexp"; "Exp_Function_FixSubpat";
+   "Exp_Function_GeneralizedCase"; "Exp_Function_RemoveDefault";  "Exp_Function_RemoveParam"; "Exp_If_FixElse"; "Exp_If_FixTest";
+   "Exp_If_FixThen"; "Exp_If_RemoveElse"; "Exp_If_DanglingElse"; "Exp_Lazy_FixSubexp";  "Exp_Lazy_RemoveLazy"; "Exp_Let_DeleteBinding"; "Exp_Let_FixRec";
+   "Exp_Let_FixSubexp"; "Exp_Let_FixSubpat"; "Exp_Let_FixTarget";  "Exp_Let_HoistInner"; "Exp_Letmodule_FixExp";
+   "Exp_Letmodule_FixModexp"; "Exp_Let_ReplaceAllBindings"; "Exp_Match_CatchAll"; "Exp_Match_FixCase";
+   "Exp_Match_FixMatchexp"; "Exp_Match_FixSubexp";  "Exp_Match_FixSubpat"; "Exp_Object_Removed"; "Exp_Override_FixStr";
+   "Exp_Override_FixSubexp"; "Exp_Poly_FixSubexp"; "Exp_Poly_FixTy";  "Exp_Record_FixId"; "Exp_Record_FixIdExp";
+   "Exp_Record_FixOptSubexp"; "Exp_Remove"; "Exp_Send_FixStr";  "Exp_Send_FixSubexp"; "Exp_Sequence_FixLeft";
+   "Exp_Sequence_FixRight"; "Exp_Setfield_FixId";  "Exp_Setfield_FixSubexp1"; "Exp_Setfield_FixSubexp2";
+   "Exp_Setinstvar_FixStr"; "Exp_Setinstvar_FixSubexp";  "Exp_Try_CatchAll"; "Exp_Try_FixBody"; "Exp_Try_FixSubexp";
+   "Exp_Try_FixSubpat"; "Exp_TryMatch_Reparenthesize";  "Exp_Tuple_AddItem"; "Exp_Tuple_DeleteItem";
+   "Exp_Variant_AddBody";  "Exp_Variant_FixSubexp"; "Exp_Variant_SingleReplaceSubexp";
+   "Exp_When_FixCase"; "Exp_When_FixGuard"; "Exp_When_RemoveGuard";  "Exp_While_FixBody"; "Exp_While_FixGuard";
+   "Mod_Apply_FixNestedApp1"; "Mod_Apply_FixNestedApp2";  "Mod_Constraint_FixNestedMod"; "Mod_Constraint_FixNestedType";
+   "Mod_Constraint_Relax"; "Mod_Functor_FixNestedMod";  "Mod_Functor_FixNestedType"; "Mod_Remove"; "Mod_Structure_FixStr";
+   "Pat_Alias_FixSubpat"; "Pat_Alias_RemoveSubpat"; "Pat_Remove";  "Pat_Tuple_FixSubpat"; "Pat_Tuple_InsertSubpat";
+   "Pat_Tuple_RemoveSubpat"; "Prog_Truncate"; "Str_Class_FixClass";  "Str_Class_RemoveAll"; "Str_Class_RemoveOne";
+   "Str_ClassType_FixClassType"; "Str_ClassType_RemoveOne";  "Str_Eval_Subexpression"; "Str_Exception_RemoveBody";
+   "Str_ExnRebind_Unalias"; "Str_Include_FixModexp"; "Stritem_Remove";  "Str_Modtype_FixModty"; "Str_Module_FixModexp"; "Str_Open_Remove";
+   "Str_Primitive_FixType"; "Str_Recmodule_Modty";  "Str_Recmodule_Module"; "Str_Recmodule_RemoveAll";
+   "Str_Recmodule_RemoveOne"; "Str_Type_FixType"; "Str_Value_FixRec";  "Str_Value_RemoveAll"; "Str_Value_Subexpression";
+   "Str_Value_Subpattern"; "Typ_Constr_FixSubtyp";  "Typ_Constr_Generalize"; "TAGS_INITIALIZED"
+ ] 
+ 
+ module ModDominanceMap = Map.Make(struct type t = int * int let compare = compare end)
+ type dominance = Does | DoesNot | Maybe | NotSure
+ let string_of_dom d = match d with Does -> "Does" | DoesNot -> "DoesNot" | Maybe -> "Maybe" | NotSure -> "NotSure"
+ let modDominance = ref ModDominanceMap.empty
+ 
+ 
+ 
+ let domRel = [ (* most specific rules must come first *)
+   ("Triage_SingleFix", "Triage_Elide", Does);
+   ("Triage_Elide", "Triage_SingleFix", DoesNot);
+   ("Exp_TryMatch_Reparenthesize", "*", Does); 
+   ("*", "Exp_TryMatch_Reparenthesize", DoesNot);
+   ("Exp_Tuple_RelocateArgs", "Exp_Tuple_SwapArgs", DoesNot);
+   ("Exp_Tuple_SwapArgs", "Exp_Tuple_RelocateArgs", Does);
+   ("Exp_Apply_RelocateArgs", "Exp_Apply_SwapArgs", DoesNot);
+   ("Exp_Apply_SwapArgs", "Exp_Apply_RelocateArgs", Does);
+   ("Exp_Function_RelocateArgs", "Exp_Function_SwapArgs", DoesNot);
+   ("Exp_Function_SwapArgs", "Exp_Function_RelocateArgs", Does);
+   ("Exp_Apply_RotateL", "Exp_Apply_RotateR", NotSure);
+   ("Exp_Apply_RotateR", "Exp_Apply_RotateL", NotSure);
+ (*  ("Exp_Adapt", "Exp_Construct_FixTuplelist", DoesNot); *)
+   ("Exp_Construct_FixTuplelist", "*", Does);
+   ("Exp_Apply_RelocateArgs", "*", Does);
+   ("Exp_Apply_SwapArgs", "*", Does);
+   ("Exp_Function_RelocateArgs", "*", Does);
+   ("Exp_Function_SwapArgs", "*", Does);
+   ("Exp_Apply_RotateR", "*", Does);
+   ("Exp_Apply_RotateL", "*", Does);
+   ("Exp_Function_CurryArgs", "Exp_Apply_CurryArgs", DoesNot);
+   ("Exp_Function_UncurryArgs", "Exp_Apply_UncurryArgs", DoesNot);
+   ("Exp_Apply_CurryArgs", "Exp_Function_CurryArgs", DoesNot);
+   ("Exp_Apply_UncurryArgs", "Exp_Function_UncurryArgs", DoesNot);
+   ("Exp_Function_CurryArgs", "*", Does);
+   ("Exp_Function_UncurryArgs", "*", Does);
+   ("Exp_Apply_CurryArgs", "*", Does);
+   ("Exp_Apply_UncurryArgs", "*", Does);
+   ("Stritem_Remove", "Exp_Remove", DoesNot);
+   ("Exp_Tuple_DeleteItem", "Exp_Adapt", DoesNot);
+   ("Exp_Tuple_*", "Exp_Adapt", Does);
+   ("Exp_Adapt", "Exp_Tuple_DeleteArg", Does);
+   ("Exp_Adapt", "Exp_Tuple_*", DoesNot);
+   ("Exp_Apply_DeleteArg", "Exp_Adapt", DoesNot);
+   ("Exp_Apply_*", "Exp_Adapt", Does);
+   ("Exp_Adapt", "Exp_Apply_DeleteArg", Does);
+   ("Exp_Adapt", "Exp_Apply_*", DoesNot);
+ (*  ("Exp_Adapt", "*", Does);*)
+   ("*", "Exp_Apply_DeleteArg", Does);
+   ("*", "Exp_Function_Remove*", Does);
+   ("*", "Exp_Function_GeneralizedCase", Does);
+   ("*", "Exp_Match_FixCase", Does);
+   ("*", "Mod_Remove", Does);
+   ("*", "Pat_Remove", Does);
+   ("*", "Stritem_Remove", Does);
+   ("*", "Exp_Remove", Does);
+   ("*", "Prog_Truncate", Does);
+   ("*", "Exp_Let_ReplaceAllBindings", Does);
+   ("*", "Str_Value_RemoveAll", Does); 
+ ]
+ 
+ 
+ 
+ 
+ let initDominance () = 
+   (* make sure all tags have been seen *)
+   try (ignore(ModDominanceMap.find (t("TAGS_INITIALIZED"), t("TAGS_INITIALIZED")) !modDominance)) 
+   with Not_found -> begin
+     initTags();
+     let tags = TagMap.fold (fun k _ tags -> k :: tags) !modTags [] in
+     (* empty the dominance map *)
+     modDominance := ModDominanceMap.empty;
+     (* initialize the map to the identity mapping *)
+     modDominance := TagMap.fold 
+         (fun k1 d1 mprev -> TagMap.fold 
+             (fun k2 d2 map -> (if (d1=d2) then ModDominanceMap.add (d1, d2) Does map else map))
+             !modTags 
+             mprev)
+         !modTags
+         ModDominanceMap.empty;
+     (* add any manually described pairs.  * is the wildcard, representing total dominance up to that point in the name *)
+     modDominance := List.fold_right
+         (fun (t1, t2, rel) map -> 
+           let star_idx1 = try String.index t1 '*' with _ -> -1 in
+           let star_idx2 = try String.index t2 '*' with _ -> -1 in
+           let prefix1 = try String.sub t1 0 star_idx1 with _ -> t1 in
+           let prefix2 = try String.sub t2 0 star_idx2 with _ -> t2 in
+           let k1s = (List.filter (fun s1 -> (try (String.sub s1 0 star_idx1) with _ -> s1) = prefix1) tags) in
+           let k2s = (List.filter (fun s2 -> (try (String.sub s2 0 star_idx2) with _ -> s2) = prefix2) tags) in
+           List.fold_right (fun k1 map ->
+             let d1 = t(k1) in
+             List.fold_right (fun k2 map -> ModDominanceMap.add (d1, t(k2)) rel map) 
+               k2s map)
+             k1s map)
+         domRel
+         !modDominance;
+   end
+ let smartFindDom t map = (try ModDominanceMap.find t map with Not_found -> DoesNot)
+ 
+ 
+ 
+ (* Based on algorithm in Zhang & Shasha, 1987 *)
+ (* Based further on Barnard 1995 *)
+ type teOp = 
+     TEDelNode of int * int
+   | TEInsNode of int * int
+   | TEDelTree of int * int
+   | TEInsTree of int * int
+   | TEChange  of int * int
+   | TERotR    of int * int * int * int
+   | TERotL    of int * int * int * int
+   | TENone
+ let treeEditDistance t1 t2 pr =
+   let rec treeSize t = 1 + List.fold_left (+) 0 (List.rev_map treeSize t.past_kids) in
+   let gammaIns x = 2 in (* change these later *)
+   let gammaDel x = 2 in
+   let gammaSwap x y = 2 in
+   let gammaDelTree x = (gammaDel x) * (treeSize x) / 2 in
+   let gammaInsTree x = max ((gammaIns x) * (treeSize x) / 2) 1 in
+   let gammaChange x y = if equalNode x y then 0 else ((gammaDel x) + (gammaIns y)) / 3 in
+   let gammaRotR b1 a1 b2 a2 = ((gammaChange a1 a2) + (gammaChange b1 b2)) / 2 + 2 in 
+   let gammaRotL a1 b1 a2 b2 = ((gammaChange a1 a2) + (gammaChange a2 b2)) / 2 + 2 in
+   let postorderLRNumbering t =
+     let len = treeSize t in
+     let n = Array.make (len+1) t in
+     let p = Array.make (len+1) (-1) in
+     let rec postorder (startIdx, sibIdxs) node =
+       let (lastKidIdx, revKidIdxs) = List.fold_left postorder (startIdx, []) node.past_kids in
+       let myIdx = lastKidIdx + 1 in
+       n.(myIdx) <- node;
+       List.iter (fun kidIdx -> (p.(kidIdx) <- myIdx)) revKidIdxs;
+       (myIdx, myIdx :: sibIdxs) in 
+     ignore(postorder (0, []) t);
+     (len, n, p) in
+   let computeLeftmost (len, p) =
+     let l = Array.make (len+1) (-1) in
+     for i = 1 to len do
+       if l.(i) = -1 then
+         l.(i) <- i; (* I am my leftmost *)
+       if (p.(i) <> -1) && (l.(p.(i)) = -1) then 
+         l.(p.(i)) <- l.(i) (* if my parent isn't set, set parent *)
+     done;
+     l in
+   let keyrootsLR (len, l, p) =
+     let (_, revKeyroots) = Array.fold_left (fun (curIdx,curLRkeyroots) _ ->
+       if (curIdx = 0) then (curIdx + 1, curLRkeyroots) else
+       if ((curIdx < len) && (l.(curIdx) <> l.(p.(curIdx)))) then
+         (curIdx + 1, curIdx :: curLRkeyroots)
+       else
+         (curIdx + 1, curLRkeyroots)
+                                            ) (0,[]) l in
+     let keyroots = Array.of_list (List.rev (len::revKeyroots)) in
+     (Array.length keyroots, keyroots) in
+   let (len1, n1, p1) = postorderLRNumbering t1 in
+   let (len2, n2, p2) = postorderLRNumbering t2 in
+   let l1 = computeLeftmost (len1, p1) in
+   let l2 = computeLeftmost (len2, p2) in
+   let (lenKR1, keyroots1) = keyrootsLR (len1, l1, p1) in
+   let (lenKR2, keyroots2) = keyrootsLR (len2, l2, p2) in
+   let min xs = List.fold_left 
+       (fun (wacc, cacc) (w', c') -> if w' < wacc then (w', c') else (wacc, cacc)) (List.hd xs) xs in
+   let treedist = Array.make_matrix (len1 + 1) (len2 + 1) ((gammaDelTree t1)+(gammaInsTree t2)) in
+   let treeedit = Array.make_matrix (len1 + 1) (len2 + 1) [] in
+   let computeTreedist i j =
+     let li = l1.(i) in
+     let lj = l2.(j) in
+     let forestdist = Array.make_matrix (i-li + 2) (j-lj + 2) ((gammaDelTree n1.(i)) + (gammaInsTree n2.(j))) in
+     let forestedit = Array.make_matrix (i-li + 2) (j-lj + 2) [] in
+     forestdist.(0).(0) <- 0;
+     forestedit.(0).(0) <- [TENone];
+     for i' = li to i do
+       forestdist.(i'-li+1).(0) <- forestdist.(l1.(i')-li).(0) + gammaDelTree(n1.(i'));
+       forestedit.(i'-li+1).(0) <- TEDelTree(i',lj) :: forestedit.(l1.(i')-li).(0);
+     done;
+     for j' = lj to j do
+       forestdist.(0).(j'-lj+1) <- forestdist.(0).(l2.(j')-lj) + gammaInsTree(n2.(j'));
+       forestedit.(0).(j'-lj+1) <- TEInsTree(li,j') :: forestedit.(0).(l2.(j')-lj);
+     done;
+     for i' = li to i do
+       for j' = lj to j do
+         let rotates =
+           List.flatten 
+             [ 
+               (try
+                 let a1 = i'        and b2 = j'        in               (*     /a\                 /b\   *)
+                 let c1 = a1-1      and a2 = b2-1      in               (*   /b\  c     ===>      d /a\  *)
+                 let b1 = l1.(c1)-1 and c2 = a2-1      in               (*  d   e                  e   c *)
+                 let e1 = b1-1      and d2 = l2.(a2)-1 in
+                 let d1 = l1.(e1)-1 and e2 = l2.(c2)-1 in
+                 assert (l1.(d1) >= l1.(b1) && l2.(e2) >= l2.(a2) && l1.(a1) = l1.(b1) && l2.(a2) >= l2.(b2));
+                 [ (forestdist.(l1.(d1)-li).(l2.(d2)-lj) + treedist.(d1).(d2) + treedist.(e1).(e2) + treedist.(c1).(c2) + (gammaRotR n1.(b1) n1.(a1) n2.(b2) n2.(a2)),
+                    TERotR(b1,a1,b2,a2) :: forestedit.(l1.(d1)-li).(l2.(d2)-lj) @ treeedit.(d1).(d2) @ treeedit.(e1).(e2) @ treeedit.(c1).(c2))
+                 ]
+               with _ -> []);
+               (try
+                 let fapp1 = i' in
+                 let gapp1fArgs1 = List.filter (fun k -> k >= l1.(fapp1) && k < fapp1 && p1.(k) = fapp1) (Array.to_list keyroots1) in
+                 let f1 = l1.(List.hd gapp1fArgs1)-1 in
+                 let (gapp1, fArgs1) = (List.hd gapp1fArgs1, List.tl gapp1fArgs1) in
+                 let gArgs1 = List.filter (fun k -> k >= l1.(gapp1) && k < gapp1 && p1.(k) = gapp1) (Array.to_list keyroots1) in
+                 let g1 = l1.(List.hd gArgs1)-1 in
+                 let gandfArgs1 = gArgs1 @ fArgs1 in
+                 let gapp2 = j' in
+                 let fapp2 = j' - 1 in
+                 let g2 = l2.(fapp2)-1 in
+                 let gandfArgs2 = List.filter (fun k -> k >= l2.(fapp2) && k < fapp2 && p2.(k) = fapp2) (Array.to_list keyroots2) in
+                 let f2 = l2.(List.hd gandfArgs2) - 1 in
+                 let allFGArgs12 = List.combine gandfArgs1 gandfArgs2 in
+                 assert (List.length gandfArgs1 = List.length gandfArgs2 && g1 > f1 && f2 > g2);
+                 [ (forestdist.(l1.(fapp1)-li).(l2.(gapp2)-lj) + (gammaRotR n1.(g1) n1.(f1) n2.(g2) n2.(f2)) +  List.fold_left (fun acc (arg1, arg2) -> acc + treedist.(arg1).(arg2)) 0 allFGArgs12,
+                    TERotR(g1,f1,g2,f2) :: forestedit.(l1.(fapp1)-li).(l2.(gapp2)-lj) @ (List.fold_left (fun acc (arg1, arg2) -> treeedit.(arg1).(arg2) @ acc) [] allFGArgs12))
+                 ]
+               with _ -> [])
+             ] in
+         let m =
+           min ([ (forestdist.(    i'  -li).(    j'+1-lj) + gammaDel(n1.(i')), TEDelNode(i',j') :: forestedit.(i'-li).(j'+1-lj));
+                  (forestdist.(    i'+1-li).(    j'  -lj) + gammaIns(n2.(j')), TEInsNode(i',j') :: forestedit.(i'+1-li).(j'-lj));
+                  (forestdist.(l1.(i') -li).(    j'+1-lj) + gammaDelTree(n1.(i')), TEDelTree(i',j') :: forestedit.(l1.(i')-li).(j'+1-lj));
+                  (forestdist.(    i'+1-li).(l2.(j') -lj) + gammaInsTree(n2.(j')), TEInsTree(i',j') :: forestedit.(i'+1-li).(l2.(j')-lj));
+                ] @ rotates) in
+         if (l1.(i') = li && l2.(j') = lj) then begin
+           let (minFD, teOp) =
+             min [ m;
+                   (forestdist.(  i'  -li).(    j'  -lj) + gammaChange n1.(i') n2.(j'), TEChange(i',j') :: forestedit.(i'-li).(j'-lj));
+                 ] in
+           treedist.(i').(j') <- minFD;
+           treeedit.(i').(j') <- teOp;
+           forestdist.(i'+1-li).(j'+1-lj) <- minFD;
+           forestedit.(i'+1-li).(j'+1-lj) <- teOp;
+         end else begin
+           let (minFD, teOp) =
+             min [ m;
+                   (forestdist.(l1.(i')  -li).(l2.(j')  -lj) + treedist.(i').(j'), treeedit.(i').(j') @ forestedit.(l1.(i')-li).(l2.(j')-lj));
+                 ] in
+           forestdist.(i'+1-li).(j'+1-lj) <- minFD;
+           forestedit.(i'+1-li).(j'+1-lj) <- teOp;
+         end;
+       done;
+     done;
+     () in
+   let printEditScript f script =
+     List.iter (fun action ->
+       flush stdout;
+       match action with
+         TENone -> ()
+       | TEDelNode(i',j') -> print_string ("Delete node (cost " ^ (string_of_int (gammaDel n1.(i'))) ^ ") " ^ (fst n1.(i').past_data) ^ ": "); f n1.(i'); print_string "\n"
+       | TEInsNode(i',j') -> print_string ("Insert node (cost " ^ (string_of_int (gammaIns n2.(j'))) ^ ") " ^ (fst n2.(j').past_data) ^ ": "); f n2.(j'); print_string "\n"
+       | TEDelTree(i',j') -> print_string ("Delete tree (cost " ^ (string_of_int (gammaDelTree n1.(i'))) ^ ") " ^ (fst n1.(i').past_data) ^ ": "); smartPrintTo std_formatter n1.(i').past_node; print_string "\n"
+       | TEInsTree(i',j') -> print_string ("Insert tree (cost " ^ (string_of_int (gammaInsTree n2.(j'))) ^ ") " ^ (fst n2.(j').past_data) ^ ": "); smartPrintTo std_formatter n2.(j').past_node; print_string "\n"
+       | TEChange (i',j') -> if (gammaChange n1.(i') n2.(j') > 0) then 
+           (print_string ("Change node (cost " ^ (string_of_int (gammaChange n1.(i') n2.(j'))) ^ ") from " ^ (fst n1.(i').past_data) ^ ": "); f n1.(i'); print_string (" to " ^ (fst n2.(j').past_data) ^ ": "); f n2.(j');  print_string "\n")
+       | TERotR   (lc1, r1, r2, rc2) -> print_string ("Rotate nodes right (cost " ^ (string_of_int (gammaRotR n1.(lc1) n1.(r1) n2.(r2) n2.(rc2))) ^ ")\n");
+       | TERotL   (rc1, r1, r2, lc2) -> print_string ("Rotate nodes right (cost " ^ (string_of_int (gammaRotR n1.(rc1) n1.(r1) n2.(r2) n2.(lc2))) ^ ")\n");
+               ) (List.rev script)
+   in
+   for x = 1 to lenKR1 do
+     for y = 1 to lenKR2 do
+       if (n1.(keyroots1.(x-1)).past_node = n2.(keyroots2.(y-1)).past_node) then begin
+         treedist.(keyroots1.(x-1)).(keyroots2.(y-1)) <- 0; (* there's no cost to not change a tree *)
+         treeedit.(keyroots1.(x-1)).(keyroots2.(y-1)) <- treeedit.(l1.(keyroots1.(x-1))).(l2.(keyroots2.(y-1))); (* so the only edits are the prior forest, if any *)
+       end else
+         computeTreedist keyroots1.(x-1) keyroots2.(y-1)
+     done
+   done;
+   if pr then (
+     Printcode.showExns();
+ (*    printNamedLocatedAST t1; printNamedLocatedAST t2;  *)
+     printEditScript (fun n -> Location.print std_formatter (snd n.past_data); smartPrintTo std_formatter n.past_node) treeedit.(len1).(len2);
+     Printcode.hideExns();
+    );
+   treedist.(len1).(len2)
+ 
+ 
+ let testTreeDiff () =
+   let mT a kids = {past_data = (a, !locNone); past_node = (Str alphaStr); past_idxs = ASTMap.empty; past_kids = kids} in
+   let mL a = mT a [] in
+   let prog1 = mT "x" [ mL "y"; mL "z"; mT "a" [ mT "b" [ mL "w"; mL "v"; mL "d"; mL "e" ] ; mL "c" ] ] in
+   let prog2 = mT "x" [ mL "y"; mL "z"; mT "b" [ mL "w"; mL "v"; mL "d"; mT "a" [ mL "e" ; mL "c" ] ] ] in
+   let td = treeEditDistance prog1 prog2 true in
+   print_string ("Tree edit distance is " ^ (string_of_int td) ^ "\n")
+ 
+ 
+ 
+ 
+ 
+ let printChange out_fm (md, (ctx, progCtx)) =
+   let output_string ignoreMe = fprintf out_fm "@[%s@]@?" in
+   flush stderr; flush stdout;
+   if out_fm != std_formatter then output_string out_fm "<pre>\n";
+   let splitLines str =
+     let rec splitHelp str acc =
+       if str = "" then List.rev acc else 
+       try 
+         let nlidx = String.index str '\n' in
+         let head = String.sub str 0 nlidx in
+         let tail = String.sub str (nlidx+1) ((String.length str) - nlidx - 1) in
+         splitHelp tail (head::acc)
+       with _ -> List.rev (str :: acc) in
+     splitHelp str [] in
+   let rec noTempMod s =
+     let rec matchStr s t i =
+       try
+         let startIdx = String.index_from s i t.[0] in
+         if (String.sub s startIdx (String.length t)) = t then Some startIdx else matchStr s t (startIdx+1)
+       with _ -> None in
+     let modname = "Seminalprefixtemp." in
+     match matchStr s modname 0 with
+       None -> s
+     | Some idx -> 
+         let restlen = String.length s - (idx + (String.length modname)) in
+         noTempMod ((String.sub s 0 idx) ^ (String.sub s (idx + (String.length modname)) restlen)) in
+   
+   begin match md with
+   | SingleRepl md ->
+       Location.print out_fm md.trep_loc; 
+       if out_fm != std_formatter then begin
+         let debugONLYTagLookup t =
+           let ans = ref "" in
+           TagMap.iter (fun k1 d1 -> if d1 = t then ans := k1) !modTags;
+           !ans in
+         output_string out_fm ("Modification tag is " ^ debugONLYTagLookup md.trep_tag ^ "\n"); 
+         output_string out_fm md.trep_desc; output_string out_fm "\n"
+       end;
+       let origProg = md.trep_replaced in
+       let replProg = (md.trep_revision ()) in
+       let origStr = (smartPrintTo str_formatter origProg; flush_str_formatter ()) in
+       let replStr = (smartPrintTo str_formatter replProg; flush_str_formatter ()) in
+       output_string out_fm "Try replacing\n";
+       let splitOrig = splitLines origStr in
+       List.iter (fun s -> output_string out_fm ("    " ^ s ^ "\n")) splitOrig;
+       output_string out_fm "with\n";
+       let splitRepl = splitLines replStr in
+       List.iter (fun s -> output_string out_fm ("    " ^ s ^ "\n")) splitRepl;
+       output_string out_fm "of type\n";
+       let splitType = splitLines (smartPrintTypeTo str_formatter md.trep_type; flush_str_formatter ()) in
+       List.iter (fun s -> output_string out_fm ("    " ^ (noTempMod s) ^ "\n")) splitType;
+       if (List.length splitOrig < 3) then begin
+         output_string out_fm "within context\n";
+         let splitCtxt = splitLines (smartPrintTo str_formatter (ctx replProg); flush_str_formatter ()) in
+         List.iter (fun s -> output_string out_fm ("    " ^ s ^ "\n")) splitCtxt;
+       end; 
+       begin
+         match (findShadowedIDs origProg) with
+           [] -> ()
+         | idList -> 
+             output_string out_fm "The following ids may be shadowed and causing problems:\n    ";
+             List.iter (fun s -> output_string out_fm (s ^ "  ")) idList;
+             output_string out_fm "\n";
+       end;
+       (*          let tED = (treeEditDistance (makeNamedLocatedAST origProg) (makeNamedLocatedAST replProg) false) in
+          output_string out_fm "Tree edit distance is "; print_int tED; output_string out_fm "\n";  *)
+       (* fix this to be a shorter context, even at the topmost level *)
+   | TriageRepl md ->
+       output_string out_fm "Triaged the following locations:\n";
+       List.iter (Location.print out_fm) (List.stable_sort (fun m n -> compare m.loc_start.pos_cnum n.loc_end.pos_cnum) md.ttri_locs);
+       output_string out_fm "And modified the following location:\n";
+       Location.print out_fm md.ttri_replaced.trep_loc;
+       if out_fm != std_formatter then begin
+         let debugONLYTagLookup t =
+           let ans = ref "" in
+           TagMap.iter (fun k1 d1 -> if d1 = t then ans := k1) !modTags;
+           !ans in
+         output_string out_fm ("Modification tag is " ^ debugONLYTagLookup md.ttri_tag ^ "\n");
+         output_string out_fm md.ttri_desc ; output_string out_fm "\n";
+       end;
+       let origProg = md.ttri_replaced.trep_replaced in
+       let replProg = (md.ttri_replaced.trep_revision ()) in
+       let origStr = (smartPrintTo str_formatter origProg; flush_str_formatter ()) in
+       let replStr = (smartPrintTo str_formatter replProg; flush_str_formatter ()) in
+       output_string out_fm "Your code has several type errors.  ";
+       if (md.ttri_adapted != []) then begin
+         output_string out_fm "The following subexpressions are type-correct on their own, but do not fit with the rest of the program:";
+         List.iter (fun thing ->
+           let str = (smartPrintTo str_formatter thing; flush_str_formatter ()) in
+           let split = splitLines str in
+           List.iter (fun s -> output_string out_fm ("\n    " ^ s ^ "\n")) split;
+                   ) md.ttri_adapted;
+       end;
+       output_string out_fm "If you ignore other surrounding code, try replacing\n";
+       let splitOrig = splitLines origStr in
+       List.iter (fun s -> output_string out_fm ("    " ^ s ^ "\n")) splitOrig;
+       output_string out_fm "with\n";
+       let splitRepl = splitLines replStr in
+       List.iter (fun s -> output_string out_fm ("    " ^ s ^ "\n")) splitRepl;
+       output_string out_fm "The actual replacement has type\n";
+       let splitType = splitLines (smartPrintTypeTo str_formatter md.ttri_replaced.trep_type; flush_str_formatter ()) in
+       List.iter (fun s -> output_string out_fm ("    " ^ (noTempMod s) ^ "\n")) splitType;
+       if (List.length splitOrig < 3) then begin
+         output_string out_fm "within context\n";
+         let splitCtxt = splitLines (smartPrintTo str_formatter (ctx (md.ttri_idealctx replProg)); flush_str_formatter ()) in
+         List.iter (fun s -> output_string out_fm ("    " ^ s ^ "\n")) splitCtxt;
+       end; 
+       begin
+         match (findShadowedIDs origProg) with
+           [] -> ()
+         | idList -> 
+             output_string out_fm "The following ids may be shadowed and causing problems:\n    ";
+             List.iter (fun s -> output_string out_fm (s ^ "  ")) idList;
+             output_string out_fm "\n";
+       end;
+   end;
+   if out_fm == std_formatter then
+     output_string out_fm "==============================\n"
+   else
+     output_string out_fm "<hr></pre>\n"
+ 
+ 
+ 
+ module FixSet = Set.Make(struct type t = (replacement * (astContext * astContext)) let compare = (fun x y -> try compare (fst x) (fst y) with _ -> 1) end)
+ let rankFixes ast (fixList : (replacement * (astContext * astContext)) list) diagOutput : (replacement * (astContext * astContext)) list =
+   let (++) x f = f x in
+   let removeDominated fixList =
+     (* Retain only those modifications that are not superceded by *)
+     (* a dominant kind of operation that is strictly smaller *)
+     
+     initDominance (); 
+     
+     let fixSet = List.fold_left (fun s e -> FixSet.add e s) FixSet.empty fixList in
+     let containedBy lst1 lst2 = List.for_all (fun l1 -> List.exists (locInside l1) lst2) lst1 in
+     let same y e = y.trep_tag = e.trep_tag && y.trep_loc = e.trep_loc && y.trep_replaced = e.trep_replaced & y.trep_revision() = e.trep_revision() in
+     let domSingleSingle y e = 
+       (y != e) && ((smartFindDom (y.trep_tag, e.trep_tag) !modDominance) = Does) &&
+       if (y.trep_tag = t("Exp_TryMatch_Reparenthesize")) then
+         (((e.trep_tag != y.trep_tag) && ((locInside y.trep_loc e.trep_loc) || (locInside e.trep_loc y.trep_loc))) (* TryMatch dominates all fixes, even those smaller than it... *)
+        || ((e.trep_tag = y.trep_tag) && (locInside y.trep_loc e.trep_loc) && (not (locInside e.trep_loc y.trep_loc)))) (* except for strictly smaller TryMatch fixes *)
+       else if (y.trep_tag = t("Exp_Adapt")) then
+         (((e.trep_tag != y.trep_tag) && ((locInside y.trep_loc e.trep_loc) || (locInside e.trep_loc y.trep_loc))) (* Adapt dominates all fixes, even those smaller than it... *)
+        || ((e.trep_tag = y.trep_tag) && (locInside e.trep_loc y.trep_loc) && (not (locInside y.trep_loc e.trep_loc)))) (* except for strictly larger Adapt fixes *)
+       else
+         (locInside y.trep_loc e.trep_loc) (* and y is smaller than e, and strictly smaller if they're they same exact type *) 
+           && ((y.trep_tag != e.trep_tag) || (not (locInside e.trep_loc y.trep_loc))) in
+     let domSingleTriage y e = 
+       let handleReparens y e =
+         let elocs = e.ttri_replaced.trep_loc :: e.ttri_locs in
+         let compare y e = (* is e' the same modification, but knocked out? *)
+           let yrep = y.trep_revision() in
+           let erep = e.ttri_replaced.trep_revision() in
+           let elision = alphaExp "ELIDED_CODE" in
+           let isKnockout yExp eExp = (yExp = eExp || eExp = elision yExp.pexp_loc) in
+           let rec compare yExp eExp =
+             match yExp.pexp_desc, eExp.pexp_desc with
+               Pexp_match(y1, yPE), Pexp_match(e1, ePE) -> isKnockout y1 e1 && (try List.for_all2 (fun (yp, ye) (ep, ee) -> yp = ep && compare ye ee) yPE ePE with _ -> false)
+             | Pexp_try(y1, yPE), Pexp_try(e1, ePE) -> isKnockout y1 e1 && (try List.for_all2 (fun (yp, ye) (ep, ee) -> yp = ep && compare ye ee) yPE ePE with _ -> false)
+             | Pexp_function(yL, ydOpt, yPE), Pexp_function(eL, edOpt, ePE) -> yL = eL && ydOpt = edOpt && (try List.for_all2 (fun (yp, ye) (ep, ee) -> yp = ep && compare ye ee) yPE ePE with _ -> false)
+             | Pexp_sequence (y1, y2), Pexp_sequence (e1, e2) -> compare y1 e1 && compare y2 e2
+             | Pexp_let (yr, yPE, ye), Pexp_let (er, ePE, ee) -> compare ye ee && (try List.for_all2 (fun (yp, ye) (ep, ee) -> yp = ep && compare ye ee) yPE ePE with _ -> false)
+             | _, _ -> isKnockout yExp eExp in
+           try compare (toExp yrep) (toExp erep) with _ -> false in
+         (y.trep_tag = t("Exp_TryMatch_Reparenthesize")) &&
+         (((e.ttri_replaced.trep_tag != y.trep_tag) && ((containedBy [y.trep_loc] elocs) || (containedBy elocs [y.trep_loc]))) (* TryMatch dominates all fixes, even those smaller than it... *)
+        || ((e.ttri_replaced.trep_tag = y.trep_tag) && (((containedBy elocs [y.trep_loc]) && (not (containedBy [y.trep_loc] elocs))) || compare y e))) in (* except for strictly larger TryMatch fixes *)
+       let elocs = e.ttri_replaced.trep_loc :: e.ttri_locs in
+       (* ((smartFindDom (y.trep_tag, e.ttri_tag) !modDominance) = Does) && *)
+       (y.trep_tag = t("Exp_Adapt") && (containedBy elocs [y.trep_loc] || containedBy [y.trep_loc] elocs)) ||
+       (handleReparens y e) ||
+       (containedBy [y.trep_loc] elocs && (domSingleSingle y e.ttri_replaced || same y e.ttri_replaced)) in
+     let domTriageSingle y e =
+       let ylocs = y.ttri_replaced.trep_loc :: y.ttri_locs in
+       (* ((smartFindDom (y.ttri_tag, e.trep_tag) !modDominance) = Does) && *)
+       (y.ttri_locs != []) &&
+       (not (containedBy [e.trep_loc] ylocs && (domSingleSingle e y.ttri_replaced || same e y.ttri_replaced))) &&
+       containedBy ylocs [e.trep_loc] &&
+       (e.trep_tag != t("Exp_TryMatch_Reparenthesize") && e.trep_tag != t("Exp_Adapt")) in
+     let domTriageTriage y e =
+       let ylocs = y.ttri_replaced.trep_loc :: y.ttri_locs in
+       let elocs = e.ttri_replaced.trep_loc :: e.ttri_locs in
+       (y != e) && ((smartFindDom (y.ttri_tag, e.ttri_tag) !modDominance) = Does) &&
+       if (containedBy y.ttri_locs e.ttri_locs && containedBy e.ttri_locs y.ttri_locs) then
+         (domSingleSingle y.ttri_replaced e.ttri_replaced || same y.ttri_replaced e.ttri_replaced)
+       else if (y.ttri_replaced.trep_tag = t("Exp_TryMatch_Reparenthesize")) then
+         (e.ttri_replaced.trep_tag != y.ttri_replaced.trep_tag &&
+          (containedBy elocs [y.ttri_replaced.trep_loc] || containedBy [y.ttri_replaced.trep_loc] elocs) &&
+          domSingleSingle y.ttri_replaced e.ttri_replaced) ||
+          (e.ttri_replaced.trep_tag = y.ttri_replaced.trep_tag &&
+           containedBy ylocs elocs && not (containedBy elocs ylocs))
+       else if (e.ttri_replaced.trep_tag = t("Exp_TryMatch_Reparenthesize")) then
+         false
+       else if (containedBy ylocs elocs) then
+         if (containedBy elocs ylocs) then
+           (domSingleSingle y.ttri_replaced e.ttri_replaced) || 
+           ((smartFindDom (y.ttri_tag, e.ttri_tag) !modDominance = Does) &&
+            (y.ttri_replaced.trep_revision() = e.ttri_replaced.trep_revision()))
+         else
+           true
+       else false in
+     let dominantTypeSmallerMod y e =
+       (y != e) &&
+       (match y, e with
+       | SingleRepl y, SingleRepl e -> domSingleSingle y e
+       | SingleRepl y, TriageRepl e -> domSingleTriage y e
+       | TriageRepl y, SingleRepl e -> domTriageSingle y e 
+       | TriageRepl y, TriageRepl e -> domTriageTriage y e 
+       ) in
+     
+ 
+     (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+     if diagOutput != std_formatter then begin
+       let output_string out_fm = fprintf out_fm "@[%s@]@?" in
+       let hackSameType (y', _) (e', _) =
+         match y', e' with
+           TriageRepl _, TriageRepl _ | SingleRepl _, SingleRepl _ -> true | _ -> false in
+       let domArr : bool array array = Array.make_matrix (List.length fixList) (List.length fixList) false in
+       output_string diagOutput "<p>Is x a dominantMod over y?</p>\n";
+       if (List.length fixList < 100) then begin
+         output_string diagOutput "<table id=\"dominance\">\n";
+         output_string diagOutput "<tr><td>x\\y</td>"; List.iter (fun i -> output_string diagOutput ("<td><a href=\"#mod" ^ (string_of_int i) ^ "\">" ^ (string_of_int i) ^ "</a></td>")) (tabulate (List.length fixList)); output_string diagOutput "</tr>\n";
+         ignore (map_at (fun i md -> output_string diagOutput ("<tr><td><a href=\"#mod" ^ (string_of_int i) ^ "\">" ^ (string_of_int i) ^ "</a></td>");
+           ignore (map_at (fun j md' ->
+             output_string diagOutput "<td class=\"";
+             output_string diagOutput (match (fst md)  with SingleRepl _ -> "sr " | TriageRepl _ -> "tr ");
+             output_string diagOutput (match (fst md') with SingleRepl _ -> "sc " | TriageRepl _ -> "tc ");
+             output_string diagOutput "\">";
+             output_string diagOutput (if (dominantTypeSmallerMod (fst md) (fst md')) then (domArr.(i).(j) <- true; "T</td>") else "F</td>")
+                          ) fixList);
+           output_string diagOutput "</tr>\n") fixList);
+         output_string diagOutput "</table>\n";
+       end else
+         output_string diagOutput "Too many modifications to print a meaningful table\n";
+       for x = 0 to (List.length fixList) - 1 do
+         for y = x to (List.length fixList) - 1 do
+           if (domArr.(x).(y) = true && domArr.(y).(x) = true) then output_string diagOutput ("<p>Error: Mods " ^ (string_of_int x) ^ " and " ^ (string_of_int y) ^ " are mutually dominant.</p>\n"); 
+         done;
+       done;
+       output_string diagOutput "<table border=1>\n";
+       ignore (map_at (fun i md -> output_string diagOutput ("<tr><td><a name=\"mod" ^ (string_of_int i) ^ "\" />Mod " ^ (string_of_int i) ^ "</td><td>"); printChange diagOutput md; output_string diagOutput "</td></tr>\n") fixList);
+       output_string diagOutput "</table>\n";
+     end;
+     (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ 
+ 
+     FixSet.elements (FixSet.filter (fun e -> not (FixSet.exists (fun y -> dominantTypeSmallerMod (fst y) (fst e)) fixSet)) fixSet) in
+                                    (* such that there is no other mod y which dominates this mod e *)
+   let filterInvalid fixList =
+     let pseudoFixes = List.rev_map (fun (md, (c1, c2)) -> (md, (c1, (fun x -> x), c2))) fixList in
+     List.filter (function (md, ctx) -> match md with SingleRepl md -> md.trep_validate() | TriageRepl md -> true) fixList in
+   let sortByTreeEditDistance fixList =
+     let fixTreeDists = List.map (fun (x, (_, progCtxX)) ->
+       match x with
+         SingleRepl x ->
+           let uast = makeNamedLocatedAST (x.trep_replaced) in
+           let uastX = makeNamedLocatedAST (x.trep_revision ()) in
+           print_string "."; flush stdout;
+           treeEditDistance uast uastX false
+       | TriageRepl x -> 
+           let uast = makeNamedLocatedAST (x.ttri_original) in
+           let uastX = makeNamedLocatedAST (x.ttri_idealctx (x.ttri_replaced.trep_revision())) in
+           treeEditDistance uast uastX false) fixList in
+     let fixDistList = List.combine fixList fixTreeDists in
+     let sortedOutput = List.stable_sort (fun (fixX, distX) (fixY, distY) -> compare distX distY) fixDistList in
+     fst (List.split sortedOutput) in
+   let sortMultisAndTriages fixList =
+     let (multisTriages, others) = List.partition (function (x, _) -> match x with SingleRepl _ -> false | _ -> true) fixList in
+     multisTriages @ others in
+   let removeDotsIfUnneeded fixList =
+     let replStr a = (smartPrintTo str_formatter a; flush_str_formatter ()) in
+     let substring (s1 : string) (s2 : string) = 
+       let ssat i =
+         try (String.sub s2 i (String.length s1)) = s1 with _ -> false in
+       List.exists ssat (tabulate ((String.length s2) - (String.length s1) + 1)) in
+     match (List.partition (function (x, _) -> 
+       match x with
+         SingleRepl r -> substring "[[...]]" (replStr (r.trep_revision()))
+       | TriageRepl r -> r.ttri_locs != []) fixList) with
+       _, [] -> fixList
+     | _, noDots -> noDots in
+   let secondFilterInvalid fixList =
+     let validated = List.stable_sort (fun (x, _) (y, ctx) ->
+       match x with
+         SingleRepl r ->
+           (try
+             let validate = List.assoc r.trep_replaced !validations in
+             if (validate x [y, ctx]) then 0 else 1
+           with _ -> 0)
+       | _ -> 0) fixList in
+     List.stable_sort (fun (x, _) (y, _) ->
+       match x with
+         SingleRepl r -> if r.trep_tag = t("Exp_Ident_FixId") then 1 else 0
+       | _ -> 0) validated in
+   let sortBySize fixList = 
+     List.stable_sort (fun (x, _) (y, _) -> 
+       let xLoc = match x with SingleRepl x -> x.trep_loc | TriageRepl x -> List.fold_left locJoin x.ttri_replaced.trep_loc x.ttri_locs in
+       let yLoc = match y with SingleRepl y -> y.trep_loc | TriageRepl y -> List.fold_left locJoin y.ttri_replaced.trep_loc y.ttri_locs in
+       compare (locLen xLoc) (locLen yLoc)) fixList in
+   let sortByType fixList =
+     List.stable_sort (fun (x, _) (y, _) -> 
+       let xTag = match x with SingleRepl x -> x.trep_tag | TriageRepl x -> x.ttri_tag in
+       let yTag = match y with SingleRepl y -> y.trep_tag | TriageRepl y -> y.ttri_tag in
+       compare xTag yTag) fixList in
+   let showFirst n fixList =
+     let rec take n tail acc =
+       if n = 0 then List.rev acc else 
+       match tail with
+         [] -> List.rev acc
+       | hd::tl -> take (n-1) tl (hd :: acc)
+     in take n fixList [] in
+   fixList 
+     ++ sortMultisAndTriages
+     ++ filterInvalid
+     ++ removeDominated
+     ++ removeDotsIfUnneeded
+     ++ sortBySize 
+     ++ secondFilterInvalid
+ (*    ++ sortByTreeEditDistance  *)
+ (*    ++ sortByType *)
+     ++ showFirst 15
+ 
+ 
+ (* XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX *)
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+     
+ (* 
+    Generic algorithm: 
+    SingleRecur down the AST, given the location and the structure, to the smallest node containing the error
+    Starting from the deepest node, attempt to generalize the node.  If it fails, pop up to a higher node.
+    If it succeeds, attempt to generalize the siblings of that node (independently of the first modification).
+    If any of those succeed, attempt generalizing all smaller subtrees of that sibling, to find the tightest change which could work.
+ *)
+ 
+ let hookSeminal parseToAST typeAST inputfile outputprefix initial_env interface implementation = 
+   let timeTypeChecking = ref 0.0 in
+ 
+   let typeAST ast =
+     Location.set_warning_fmt str_formatter;
+     try
+       let ans = typeAST ast in
+       ignore (flush_str_formatter ());
+       Location.reset_warnings ();
+       ans
+     with err ->
+       (ignore (flush_str_formatter ());
+        Location.reset_warnings ();
+        raise err) in
+   let typeAST ast =
+     let (ans, timeTC, _) = timeFn (fun () -> typeAST ast) (fun td -> timeTypeChecking := !timeTypeChecking +. td) in
+     ans in
+ 
+   let print_string = fprintf std_formatter "@[%s@]@?" in (* rebind print_string to use the formatters *)
+   let fixedErrors : exn list ref = ref [] in
+ 
+ 
+   let splitLines str =
+     let rec splitHelp str acc =
+       if str = "" then List.rev acc else 
+       try 
+         let nlidx = String.index str '\n' in
+         let head = String.sub str 0 nlidx in
+         let tail = String.sub str (nlidx+1) ((String.length str) - nlidx - 1) in
+         splitHelp tail (head::acc)
+       with _ -> List.rev (str :: acc) in
+     splitHelp str [] in
+ 
+   let rec noTempMod s =
+     let rec matchStr s t i =
+       try
+         let startIdx = String.index_from s i t.[0] in
+         if (String.sub s startIdx (String.length t)) = t then Some startIdx else matchStr s t (startIdx+1)
+       with _ -> None in
+     let modname = "Seminalprefixtemp." in
+     match matchStr s modname 0 with
+       None -> s
+     | Some idx -> 
+         let restlen = String.length s - (idx + (String.length modname)) in
+         noTempMod ((String.sub s 0 idx) ^ (String.sub s (idx + (String.length modname)) restlen)) in
+ 
+ 
+   let handleError exn ast loc = 
+     let sTime = Sys.time() in 
+         
+     Location.set_warning_fmt str_formatter;
+     let fixes = seminalSearch typeAST ast (Some loc) in
+     Location.reset_warnings ();
+     ignore (flush_str_formatter ());
+     let eTime = Sys.time() in 
+     
+     let diagOutput = open_out "testoutput.html" in
+     let out_fm = formatter_of_out_channel diagOutput in
+     let output_string out_fm = fprintf out_fm "@[%s@]@?" in
+     output_string out_fm ("<html>\n" ^
+                               "  <head><title>Diagnostic output for " ^ loc.loc_start.pos_fname ^ "</title>" ^
+                               "        <style type=\"text/css\">\n" ^
+                               "table hr { display: none }\npre { margin: 0; padding: 0}\n" ^
+                               "table#dominance { border: 0; margin: 0; padding: 5px; border-spacing: 0 0; border-collapse: collapse }\n" ^
+                               "table#dominance td { border: 1px solid black; text-align: center }\n" ^
+                               "td.sr.sc { background: #DFD; border: 0; margin: 0; padding: 3px }\n" ^
+                               "td.sr.tc { background: #DFF; border: 0; margin: 0; padding: 3px }\n" ^
+                               "td.tr.sc { background: #DFF; border: 0; margin: 0; padding: 3px }\n" ^
+                               "td.tr.tc { background: #DDF; border: 0; margin: 0; padding: 3px }\n" ^
+                               "</style></head>\n" ^
+                               "  <body>\n\n" ^
+                               "     <h3>Contents</h3>\n" ^
+                               "     <p><ul>\n" ^
+                               "        <li><a href=\"#Dominance\">Dominance output</a></li>\n" ^
+                               "        <li><a href=\"#Suggestions\">Seminal suggestions</a></li>\n" ^
+                               "     </ul></p>\n");
+     output_string out_fm "<a name=\"Dominance\" /><h3>Dominance output</h3>\n";
+     
+     let (rankedFixes, _, rankingTime) = timeFn (fun () -> rankFixes ast fixes out_fm) (fun _ -> ()) in
+     
+ 
+     output_string out_fm "\n\n";
+     output_string out_fm "<a name=\"Suggestions\" /><h3>Seminal suggestions</h3>\n";
+     (* output_string std_formatter ("==================================================================\n");
+     output_string std_formatter ("       \tFilename\tRuntime           \t#nodes\t#atmpts\t#mods\t#matchs\tTimeTC\n");
+     output_string std_formatter ("Total: " 
+                                  ^ "\t" ^ inputfile
+                                  ^ "\t" ^ (time_delta eTime sTime)
+                                  ^ "\t" ^ (string_of_int !totalInterestingNodes) 
+                                  ^ "\t" ^ (string_of_int !totalAttempts)                              
+                                  ^ "\t" ^ (string_of_int !totalMods) 
+                                  ^ "\t" ^ (string_of_int !totalDelays) 
+                                  ^ "\t" ^ (time_delta !timeTypeChecking 0.)
+                                  ^ "\n"); *)
+     output_string out_fm ("<table border=1>");
+     output_string out_fm ("<tr><td>Filename</td><td>Runtime</td><td>#nodes</td><td>#attempts</td><td>#mods</td><td>#matchs</td><td>TimeTC</td></tr>\n");
+     output_string out_fm ("<tr><td>" ^ inputfile
+                           ^ "</td><td>" ^ (time_delta eTime sTime)
+                           ^ "</td><td>" ^ (string_of_int !totalInterestingNodes) 
+                           ^ "</td><td>" ^ (string_of_int !totalAttempts)                              
+                           ^ "</td><td>" ^ (string_of_int !totalMods) 
+                           ^ "</td><td>" ^ (string_of_int !totalDelays) 
+                           ^ "</td><td>" ^ (time_delta !timeTypeChecking 0.)
+                           ^ "</td></tr></table>\n");
+     timeTypeChecking := 0.; (* reset total time type checking *)
+     totalInterestingNodes := 0;
+     
+ 
+     List.iter (fun fmtr ->
+       if fmtr != std_formatter then output_string fmtr "<pre>";
+       output_string fmtr ("------------------------------------------------------------------\n");
+       let mock_error = (mock_report_error exn; flush_str_formatter ()) in
+       output_string fmtr (noTempMod mock_error);
+       output_string fmtr ("Relevant code: " ^ sourceFromLoc loc ^ "\n");
+       output_string fmtr ("------------------------------------------------------------------\n");
+       if fmtr != std_formatter then output_string fmtr "</pre>";
+       (match rankedFixes with
+         [] -> output_string fmtr "<pre>Couldn't find repairs.</pre>\n";
+       | _  -> List.iter (printChange fmtr) rankedFixes; 
+       ); 
+ 
+               ) [out_fm; std_formatter];
+     output_string out_fm ("\n\n" ^
+                           "  </body>\n" ^
+                           "</html>\n");
+     close_out_noerr diagOutput;
+     rankedFixes in
+   
+   
+   let makeNextFile (fc : out_channel) ic loc n prevProg (fix, (dispCtx, ctx)) =
+     let fc_fmt = formatter_of_out_channel fc in
+     let replacement = fix.trep_revision () in
+     let wholeReplProg = (ctx replacement) in
+     let progLoc = itemLocation wholeReplProg in
+     Printcode.showExns ();
+     smartPrintTo fc_fmt (Str fix.trep_prologue);
+     smartPrintTo fc_fmt wholeReplProg;
+     let restOfOrigProg = (List.filter (function sItem -> not (locInside sItem.pstr_loc progLoc)) prevProg) in
+     smartPrintTo fc_fmt (Str restOfOrigProg);
+     Printcode.hideExns ();
+     (fix.trep_prologue @ (toStr wholeReplProg) @ restOfOrigProg) in
+ 
+ 
+   let writeFile fin fout start stop =
+     let fc = open_out fout in
+     let ic = open_in fin in
+     seek_in ic start;
+     let buf = Buffer.create stop in
+     Buffer.add_channel buf ic stop;
+     Buffer.output_buffer fc buf;
+     close_in ic;
+     close_out fc in
+   let preprocess ast errloc =
+     let (astprefix, astsuffix) = List.partition (function sItem -> locBefore sItem.pstr_loc errloc || locInside errloc sItem.pstr_loc) (addPrologue !globalPrologue ast) in
+     let revastfrag = List.rev astprefix in
+     let opens = List.filter (function sItem -> (match sItem.pstr_desc with Pstr_open _ -> true | _ -> false)) revastfrag in
+     match revastfrag with
+       [] -> []
+     | [hd] -> ast
+     | hd::tl ->
+         let srcloc = List.fold_left (fun accu stritem -> locJoin accu stritem.pstr_loc) !locNone tl in
+         if srcloc = !locNone then ast else
+         let tmpprefixfile = "seminalprefixtemp.ml" in
+         let tmpmlifile =    "seminalprefixtemp.mli" in
+         let tmpcmifile =    "seminalprefixtemp.cmi" in
+         let tmpcmofile =    "seminalprefixtemp.cmo" in
+         let cleanupTempFiles = (fun () -> 
+           List.iter 
+             (fun fname -> try flush stdout; Misc.remove_file fname with _ -> ()) 
+             [ tmpcmifile; tmpcmofile; tmpprefixfile; tmpmlifile ]) in
+         cleanupTempFiles ();
+ 
+         ignore(initial_env());
+         writeFile srcloc.loc_start.pos_fname tmpprefixfile 0 (srcloc.loc_end.pos_cnum);
+         Location.set_warning_fmt str_formatter;
+         implementation Format.err_formatter tmpprefixfile (Filename.chop_suffix tmpmlifile ".mli");
+         Location.reset_warnings ();
+         ignore (flush_str_formatter ());
+ 
+         at_exit cleanupTempFiles; 
+         Clflags.objfiles := tmpcmofile :: !Clflags.objfiles;
+         begin
+           let openloc = {loc_start = {pos_fname = errloc.loc_start.pos_fname;
+                                       pos_lnum = 1;
+                                       pos_bol = 0;
+                                       pos_cnum = 0};
+                          loc_end = {pos_fname = errloc.loc_end.pos_fname;
+                                     pos_lnum = 1;
+                                     pos_bol = 0;
+                                     pos_cnum = String.length("open Seminalprefixtemp")};
+                          loc_ghost = errloc.loc_ghost} in
+           let openMod = {pstr_desc = Pstr_open (strToLongident (String.capitalize (String.lowercase (Filename.chop_suffix tmpmlifile ".mli")))); 
+                          pstr_loc = openloc} in
+           (openMod :: (List.rev opens)) @ (hd :: astsuffix)
+         end in
+ 
+   let rec attemptParse n curfile ast = 
+     let fixfile = (outputprefix ^ ".fix." ^ string_of_int n ^ ".ml") in
+     try
+       Location.set_warning_fmt str_formatter;
+       let tAST = typeAST ast in
+       let warnings = flush_str_formatter () in
+       if (String.length warnings > 0) then 
+         fprintf err_formatter "@[%s@]@?" ("\n\n" ^ warnings ^ "\n");
+       Location.reset_warnings ();
+       if n = 1 then tAST else (at_exit (fun () -> Misc.remove_file (outputprefix ^ ".cmi")); raise (FixedErrors []))
+     with x ->
+       ignore(flush_str_formatter ()); (* clear any warnings out *)
+       Location.reset_warnings (); (* reset warnings from the try block *)
+       fixedErrors := x :: !fixedErrors;
+       if (n > 1) then (
+         raise (FixedErrors (List.rev (TooManyErrors :: !fixedErrors)))
+       ) else (
+         match x with 
+           Typecore.Error(loc, _)
+         | Typetexp.Error(loc, _) 
+         | Typedecl.Error(loc, _) 
+         | Typeclass.Error(loc, _)
+         | Typemod.Error(loc, _) -> 
+             (* setup *)
+             if (n = 1) then begin
+               collectStrIDs ast;
+               collectTypeIDs ast;
+             end;
+ 
+             (* preprocess *)
+             locNone := { loc_start = {Lexing.dummy_pos with pos_cnum = -2; pos_fname = curfile} ; 
+                          loc_end =   {Lexing.dummy_pos with pos_cnum = -3; pos_fname = curfile} ; 
+                          loc_ghost = true };
+             let ast = if (n = 1) then preprocess ast loc else ast in  
+ 
+             (* print_string ("Collected strings and ids are:\n"); *)
+             (* printStrLIdMap !astStrLIds; *)
+             (* printNamedLocatedAST (makeNamedLocatedAST (Str ast)); *)
+ 
+             (* search *)
+             totalDelays := 0;
+             totalFixNesteds := 0;
+             totalMods := 0;
+             let fixes = handleError x ast loc in
+             (* reporting and cleanup *)
+             let newAst = 
+               match (List.filter (fun (f, _) -> match f with SingleRepl _ -> true | _ -> false) fixes) with
+               | (SingleRepl fix, (dispCtx, ctx))::otherfixes ->
+                   let replacement = fix.trep_revision () in
+                   let wholeReplProg = (ctx replacement) in
+                   let progLoc = itemLocation wholeReplProg in
+                   let restOfOrigProg = (List.filter (function sItem -> not (locInside sItem.pstr_loc progLoc)) ast) in
+                   (!globalPrologue @ fix.trep_prologue @ (toStr wholeReplProg) @ restOfOrigProg)
+               | (TriageRepl fix, (dispCtx, ctx))::otherfixes ->
+                   let replacement = fix.ttri_replaced.trep_revision() in
+                   let wholeReplProg = (ctx (fix.ttri_idealctx replacement)) in
+                   let progLoc = itemLocation wholeReplProg in
+                   let restOfOrigProg = (List.filter (function sItem -> not (locInside sItem.pstr_loc progLoc)) ast) in
+                   (!globalPrologue @ fix.ttri_prologue @ (toStr wholeReplProg) @ restOfOrigProg)
+               | _ -> exit 1 in
+             attemptParse (n+1) fixfile newAst
+         | _ -> raise x
+       )
+   in
+   let ret = attemptParse 1 inputfile (parseToAST inputfile) in (ret, (FixedErrors !fixedErrors))
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/driver/seminal.mli seminalOcaml/driver/seminal.mli
*** ocaml-3.08.4/driver/seminal.mli	1969-12-31 16:00:00.000000000 -0800
--- seminalOcaml/driver/seminal.mli	2009-01-19 09:37:56.291964291 -0800
***************
*** 0 ****
--- 1,21 ----
+ open Misc
+ open Config
+ open Format
+ open Parsetree
+ open Location
+ open Lexing
+ 
+ exception TooManyErrors
+ exception FixedErrors of exn list
+ 
+ val hookSeminal: 
+     (string -> Parsetree.structure) -> 
+       (Parsetree.structure -> 
+         Typedtree.structure * Typedtree.module_coercion) -> 
+           string -> 
+             string -> 
+               (unit -> Env.t) ->
+                 (formatter -> string -> string -> unit) ->
+                   (formatter -> string -> string -> unit) ->
+                     (Typedtree.structure * Typedtree.module_coercion) * exn
+ 
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/emacs/README seminalOcaml/emacs/README
*** ocaml-3.08.4/emacs/README	2002-08-04 19:05:42.000000000 -0700
--- seminalOcaml/emacs/README	2009-01-19 09:38:01.067889857 -0800
***************
*** 1,4 ****
!         O'Caml emacs mode, snapshot of $Date: 2002/08/05 02:05:42 $
  
  The files in this archive define a caml-mode for emacs, for editing
  Objective Caml and Objective Label programs, as well as an
--- 1,4 ----
!         O'Caml emacs mode, snapshot of $Date: 2005/12/09 03:02:42 $
  
  The files in this archive define a caml-mode for emacs, for editing
  Objective Caml and Objective Label programs, as well as an
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/Makefile seminalOcaml/Makefile
*** ocaml-3.08.4/Makefile	2005-01-31 02:30:47.000000000 -0800
--- seminalOcaml/Makefile	2009-01-19 09:39:11.394626899 -0800
***************
*** 10,23 ****
  #                                                                       #
  #########################################################################
  
! # $Id: Makefile,v 1.186.2.7 2005/01/31 10:30:47 doligez Exp $
  
  # The main Makefile
  
  include config/Makefile
  include stdlib/StdlibModules
  
! CAMLC=boot/ocamlrun boot/ocamlc -nostdlib -I boot
  CAMLOPT=boot/ocamlrun ./ocamlopt -nostdlib -I stdlib
  COMPFLAGS=-warn-error A $(INCLUDES)
  LINKFLAGS=
--- 10,23 ----
  #                                                                       #
  #########################################################################
  
! # $Id: Makefile,v 1.7 2006/05/30 21:02:22 blerner Exp $
  
  # The main Makefile
  
  include config/Makefile
  include stdlib/StdlibModules
  
! CAMLC=boot/ocamlrun boot/ocamlc -nostdlib -I boot -g
  CAMLOPT=boot/ocamlrun ./ocamlopt -nostdlib -I stdlib
  COMPFLAGS=-warn-error A $(INCLUDES)
  LINKFLAGS=
***************
*** 42,48 ****
  
  PARSING=parsing/linenum.cmo parsing/location.cmo parsing/longident.cmo \
    parsing/syntaxerr.cmo parsing/parser.cmo \
!   parsing/lexer.cmo parsing/parse.cmo parsing/printast.cmo
  
  TYPING=typing/ident.cmo typing/path.cmo \
    typing/primitive.cmo typing/types.cmo \
--- 42,49 ----
  
  PARSING=parsing/linenum.cmo parsing/location.cmo parsing/longident.cmo \
    parsing/syntaxerr.cmo parsing/parser.cmo \
!   parsing/lexer.cmo parsing/parse.cmo \
!   parsing/printast.cmo parsing/printcode.cmo
  
  TYPING=typing/ident.cmo typing/path.cmo \
    typing/primitive.cmo typing/types.cmo \
***************
*** 82,95 ****
    asmcomp/emitaux.cmo asmcomp/emit.cmo asmcomp/asmgen.cmo \
    asmcomp/asmlink.cmo asmcomp/asmlibrarian.cmo asmcomp/asmpackager.cmo
  
! DRIVER=driver/pparse.cmo driver/errors.cmo driver/compile.cmo \
!   driver/main_args.cmo driver/main.cmo
  
  OPTDRIVER= driver/pparse.cmo driver/opterrors.cmo driver/optcompile.cmo \
    driver/optmain.cmo
  
! TOPLEVEL=driver/pparse.cmo driver/errors.cmo driver/compile.cmo \
!   toplevel/genprintval.cmo toplevel/toploop.cmo \
    toplevel/trace.cmo toplevel/topdirs.cmo toplevel/topmain.cmo
  
  TOPLEVELLIB=toplevel/toplevellib.cma
--- 83,96 ----
    asmcomp/emitaux.cmo asmcomp/emit.cmo asmcomp/asmgen.cmo \
    asmcomp/asmlink.cmo asmcomp/asmlibrarian.cmo asmcomp/asmpackager.cmo
  
! DRIVER=driver/pparse.cmo driver/seminal.cmo driver/errors.cmo \
!   driver/compile.cmo driver/main_args.cmo driver/main.cmo
  
  OPTDRIVER= driver/pparse.cmo driver/opterrors.cmo driver/optcompile.cmo \
    driver/optmain.cmo
  
! TOPLEVEL=driver/pparse.cmo driver/seminal.cmo driver/errors.cmo \
!   driver/compile.cmo toplevel/genprintval.cmo toplevel/toploop.cmo \
    toplevel/trace.cmo toplevel/topdirs.cmo toplevel/topmain.cmo
  
  TOPLEVELLIB=toplevel/toplevellib.cma
***************
*** 281,287 ****
  
  ocamlc: $(COMPOBJS)
  	$(CAMLC) $(LINKFLAGS) -o ocamlc $(COMPOBJS)
! 	@sed -e 's|@compiler@|$$topdir/boot/ocamlrun $$topdir/ocamlc|' \
  	  driver/ocamlcomp.sh.in > ocamlcomp.sh
  	@chmod +x ocamlcomp.sh
  
--- 282,288 ----
  
  ocamlc: $(COMPOBJS)
  	$(CAMLC) $(LINKFLAGS) -o ocamlc $(COMPOBJS)
! 	@sed -e 's|@compiler@|$$topdir/boot/ocamlrun $$topdir/ocamlc -g|' \
  	  driver/ocamlcomp.sh.in > ocamlcomp.sh
  	@chmod +x ocamlcomp.sh
  
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/Makefile.nt seminalOcaml/Makefile.nt
*** ocaml-3.08.4/Makefile.nt	2004-11-29 00:50:45.000000000 -0800
--- seminalOcaml/Makefile.nt	2009-01-19 09:39:11.490624907 -0800
***************
*** 38,44 ****
  
  PARSING=parsing/linenum.cmo parsing/location.cmo parsing/longident.cmo \
    parsing/syntaxerr.cmo parsing/parser.cmo \
!   parsing/lexer.cmo parsing/parse.cmo parsing/printast.cmo
  
  TYPING=typing/ident.cmo typing/path.cmo \
    typing/primitive.cmo typing/types.cmo \
--- 38,45 ----
  
  PARSING=parsing/linenum.cmo parsing/location.cmo parsing/longident.cmo \
    parsing/syntaxerr.cmo parsing/parser.cmo \
!   parsing/lexer.cmo parsing/parse.cmo \
!   parsing/printast.cmo parsing/printcode.cmo
  
  TYPING=typing/ident.cmo typing/path.cmo \
    typing/primitive.cmo typing/types.cmo \
***************
*** 78,91 ****
    asmcomp/emitaux.cmo asmcomp/emit.cmo asmcomp/asmgen.cmo \
    asmcomp/asmlink.cmo asmcomp/asmlibrarian.cmo asmcomp/asmpackager.cmo
  
! DRIVER=driver/pparse.cmo driver/errors.cmo driver/compile.cmo \
!   driver/main_args.cmo driver/main.cmo
  
  OPTDRIVER=driver/pparse.cmo driver/opterrors.cmo driver/optcompile.cmo \
    driver/optmain.cmo
  
! TOPLEVEL=driver/pparse.cmo driver/errors.cmo driver/compile.cmo \
!   toplevel/genprintval.cmo toplevel/toploop.cmo \
    toplevel/trace.cmo toplevel/topdirs.cmo toplevel/topmain.cmo
  
  TOPLEVELLIB=toplevel/toplevellib.cma
--- 79,92 ----
    asmcomp/emitaux.cmo asmcomp/emit.cmo asmcomp/asmgen.cmo \
    asmcomp/asmlink.cmo asmcomp/asmlibrarian.cmo asmcomp/asmpackager.cmo
  
! DRIVER=driver/pparse.cmo driver/seminal.cmo driver/errors.cmo \
!   driver/compile.cmo driver/main_args.cmo driver/main.cmo
  
  OPTDRIVER=driver/pparse.cmo driver/opterrors.cmo driver/optcompile.cmo \
    driver/optmain.cmo
  
! TOPLEVEL=driver/pparse.cmo driver/seminal.cmo driver/errors.cmo \
!   driver/compile.cmo toplevel/genprintval.cmo toplevel/toploop.cmo \
    toplevel/trace.cmo toplevel/topdirs.cmo toplevel/topmain.cmo
  
  TOPLEVELLIB=toplevel/toplevellib.cma
***************
*** 613,621 ****
--- 614,624 ----
  	rm -f tools/*.cm* tools/*.$(O) tools/*.$(S)
  
  depend: beforedepend
+ 	mv .depend old.depend
  	(for d in utils parsing typing bytecomp asmcomp driver toplevel; \
  	 do $(CAMLDEP) $(DEPFLAGS) $$d/*.mli $$d/*.ml; \
  	 done) > .depend
+ 	rm old.depend
  
  alldepend:: depend
  
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/otherlibs/labltk/camltk/Makefile.gen.nt seminalOcaml/otherlibs/labltk/camltk/Makefile.gen.nt
*** ocaml-3.08.4/otherlibs/labltk/camltk/Makefile.gen.nt	2002-06-07 06:31:21.000000000 -0700
--- seminalOcaml/otherlibs/labltk/camltk/Makefile.gen.nt	2009-01-19 09:40:01.101769479 -0800
***************
*** 36,42 ****
--- 36,44 ----
  	) > _cTk.ml
  	../../../boot/ocamlrun ../compiler/pp < _cTk.ml > cTk.ml
  	rm -f _cTk.ml
+ 	mv .depend old.depend
  	$(CAMLDEP) -slash -I ../support [a-z]*.mli [a-z]*.ml > .depend
+ 	rm old.depend
  
  ../compiler/pp.exe:
  	cd ../compiler; $(MAKEREC) pp.exe
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/otherlibs/labltk/labltk/Makefile.gen.nt seminalOcaml/otherlibs/labltk/labltk/Makefile.gen.nt
*** ocaml-3.08.4/otherlibs/labltk/labltk/Makefile.gen.nt	2002-06-07 06:31:21.000000000 -0700
--- seminalOcaml/otherlibs/labltk/labltk/Makefile.gen.nt	2009-01-19 09:40:34.985249971 -0800
***************
*** 33,39 ****
--- 33,41 ----
  	) > _tk.ml
  	../../../boot/ocamlrun ../compiler/pp < _tk.ml > tk.ml
  	rm -f _tk.ml
+ 	mv .depend old.depend
  	$(CAMLDEP) -slash -I ../support [a-z]*.mli [a-z]*.ml > .depend
+ 	rm old.depend
  
  clean:
  	rm -f *.cm* *.ml *.mli *.$(O) *.$(A)
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/parsing/location.ml seminalOcaml/parsing/location.ml
*** ocaml-3.08.4/parsing/location.ml	2005-01-12 09:01:58.000000000 -0800
--- seminalOcaml/parsing/location.ml	2009-01-19 09:41:29.200307419 -0800
***************
*** 243,249 ****
    end
  ;;
  
! let prerr_warning loc w = print_warning loc err_formatter w;;
  
  let echo_eof () =
    print_newline ();
--- 243,257 ----
    end
  ;;
  
! let warn_fmt = ref err_formatter;;
! let reset_warnings () = 
!   pp_print_flush !warn_fmt (); 
!   warn_fmt := err_formatter;;
! let set_warning_fmt ppf = 
!   pp_print_flush !warn_fmt ();
!   warn_fmt := ppf;;
! 
! let prerr_warning loc w = print_warning loc !warn_fmt w;;
  
  let echo_eof () =
    print_newline ();
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/parsing/location.mli seminalOcaml/parsing/location.mli
*** ocaml-3.08.4/parsing/location.mli	2005-01-12 09:01:58.000000000 -0800
--- seminalOcaml/parsing/location.mli	2009-01-19 09:41:29.260306165 -0800
***************
*** 50,55 ****
--- 50,58 ----
  val print: formatter -> t -> unit
  val print_warning: t -> formatter -> Warnings.t -> unit
  val prerr_warning: t -> Warnings.t -> unit
+ val reset_warnings: unit -> unit
+ val set_warning_fmt: formatter -> unit
+ 
  val echo_eof: unit -> unit
  val reset: unit -> unit
  
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/parsing/printcode.ml seminalOcaml/parsing/printcode.ml
*** ocaml-3.08.4/parsing/printcode.ml	1969-12-31 16:00:00.000000000 -0800
--- seminalOcaml/parsing/printcode.ml	2009-01-19 09:41:30.944287314 -0800
***************
*** 0 ****
--- 1,3156 ----
+ (***********************************************************************)
+ (*                                                                     *)
+ (*                           Objective Caml                            *)
+ (*                                                                     *)
+ (*             Damien Doligez, projet Para, INRIA Rocquencourt         *)
+ (*                                                                     *)
+ (*  Copyright 1999 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.               *)
+ (*                                                                     *)
+ (***********************************************************************)
+ 
+ (* $Id: printcode.ml,v 1.14 2006/09/29 19:30:26 blerner Exp $ *)
+ 
+ (* NOTE TO SELF: Need two levels of indentation - one which is start of cur line,
+ 	and one which is offset from prev char 
+ 	-- DEPRECIATED *)
+ (* NOTE TO SELF: Could get rid of some extra parentheses by:
+ 	in INFIX function applications, check to make sure that if the precedences are
+ 	equal between the current function and the parent, also make sure that the
+ 	functions are the same - this would require an additional parameter to be passed
+ 	all the way down for every expression call - eep! *)
+ (* NOTE TO SELF: "let" expressions have the "in" subexpression contain the chain of
+ 	other lets, there is currently a check to prevent nesting at the top of expression,
+ 	but the first indent is still there, this can be removed by turning expression from
+ 	... -> doc to ... -> doc list.  This will also make the "in" clauses line up with the lets,
+ 	instead of putting them on the last line (when they fit). *)
+ 
+ open Asttypes;;
+ open Format;;
+ open Lexing;;
+ open Location;;
+ open Parsetree;;
+ 
+ (*open PrettyPrint;;*)
+ (********************************************************************************)
+ let strlen	= String.length;;
+ let identity x = x;;
+ let nl		= "\n";;
+ 
+ let rec iswhitespace s =
+ 	let result = ref true in
+ 	let len = strlen s in
+ 	for i = 0 to len - 1 do
+ 		if not (s.[i] == ' ' || s.[i] == '\t' || s.[i] == '\n') then
+ 			result := false;
+ 	done;
+ 	!result(*false*)
+ ;;
+ 
+ type mode =
+ 	| Flat
+ 	| Break
+ ;;
+ 
+ type doc =
+ 	| DocNil
+ 	| DocCons			of doc * doc
+ 	| DocText			of string
+ 	| DocNest			of int * doc
+ 	| DocBreak			of string
+ 	| DocHardBreak
+ 	| DocLeftMargin	of int * doc
+ 	| DocGroup			of doc
+ ;;
+ 
+ let (^^) x y			= DocCons(x,y);;
+ let empty				= DocNil;;
+ let text s				= DocText(s);;
+ let break				= DocBreak(" ");;
+ let bnsp					= DocBreak("");;
+ let hardbreak			= DocHardBreak;;
+ let align i x				= DocLeftMargin(i,x);;
+ let breakWith s		= DocBreak(s);;
+ let nest x				= DocNest(2,x);;
+ let nestX i x			= DocNest(i,x);;
+ let group d				= DocGroup(d);;
+ 
+ type sdoc =
+ 	| SNil
+ 	| SText				of string * sdoc
+ 	| SLine				of int * sdoc		(* newline + spaces *)
+ ;;
+ 
+ let rec sdocToString = function
+ 	| SNil				-> ""
+ 	| SText(s,d)		-> s ^ sdocToString d
+ 	| SLine(i,d)		->
+ 			(match d with
+ 				| SNil -> ""			(* avoid newlines if not used *)
+ 				| SText (s, d) when (iswhitespace s) -> sdocToString d
+ 				| _ ->
+ 						let prefix = String.make (max i 0) ' ' in
+ 						nl ^ prefix ^ sdocToString d
+ 			)
+ ;;
+ 
+ let rec fits t w k = function
+ 	| _ when w < 0					-> false
+ 	| []							-> true
+ 	| (i,m,DocNil)				:: z -> fits t w k z
+ 	| (i,m,DocLeftMargin(l,x))	:: z -> fits t w k ((k,m,x)::z) (*(fits w (w) 0 [(0,m,x)]) && (fits t t k z)*)
+ 	| (i,m,DocHardBreak)		:: z -> true(*fits t w k z*) (*true*) (* false ?*)
+ 	| (i,m,DocCons(x,y))		:: z -> fits t w k ((i,m,x)::(i,m,y)::z)
+ 	| (i,m,DocNest(j,x))		:: z -> fits t w k ((i+j,m,x)::z)
+ 	| (i,m,DocText(s))			:: z -> fits t (w - strlen s) (k + strlen s) z
+ 	| (i,Flat, DocBreak(s))		:: z -> fits t (w - strlen s) (k + strlen s) z
+ 	| (i,Break,DocBreak(_))		:: z -> true 
+ 	| (i,m,DocGroup(x))			:: z -> fits t w k ((i,Flat,x)::z)
+ ;;
+ 
+ let rec minLength = function 
+ 	| []					-> 0
+ 	| DocNil			:: z -> minLength z
+ 	| DocLeftMargin(l,x):: z -> (minLength [x]) + (minLength z)
+ 	| DocCons(x,y)		:: z -> (minLength [x]) + (minLength [y]) + (minLength z)
+ 	| DocNest(j,x)		:: z -> j + (minLength [x]) + (minLength z)
+ 	| DocText(s)		:: z -> (strlen s) + (minLength z)
+ 	| DocBreak(s)		:: z -> (strlen s) + (minLength z)
+ 	| DocHardBreak 		:: z -> minLength z
+ 	| DocGroup(x)		:: z -> (minLength [x]) + (minLength z)
+ ;;
+ 
+ let rec format w k = 
+ 	function
+ 	(* w = line width
+ 	 * k = length used so far
+ 	 * i = number of indent characters (spaces)
+ 	 * m = mode (Flat or Break) *)
+ 	| []							-> SNil
+ 	| (i,m,DocNil)				:: z -> format w k z
+ 	| (i,m,DocLeftMargin(l,x))	:: z -> format w k ((k,m,x)::z)
+ 	| (i,m,DocCons(x,y))		:: z -> format w k ((i,m,x)::(i,m,y)::z)
+ 	| (i,m,DocNest(j,x))		:: z -> format w k ((i+j,m,x)::z)
+ 	| (i,m,DocText(s))			:: z -> SText(s,format w (k + strlen s) z)
+ 	| (i,Flat, DocBreak(s))		:: z -> SText(s,format w (k + strlen s) z)
+ 	| (i,Break,DocBreak(s))		:: z -> SLine(i,format w i z)
+ 	| (i,m,DocHardBreak)		:: z -> SLine(i,format w i z)
+ 	| (i,m,DocGroup(x))			:: z -> if fits w (w-k) k ((i,Flat,x)::z)
+ 											then format w k ((i,Flat ,x)::z)
+ 											else format w k ((i,Break,x)::z)
+ ;;
+ 
+ let (+|:) x y = match x,y with
+ 				| DocNil, _   -> y
+ 				| _, DocNil   -> x
+ 				| _, _        -> x ^^ break ^^ y
+ ;;
+ let (+|) x y = match x,y with
+ 				| DocNil, _   -> y
+ 				| _, DocNil   -> x
+ 				| _, _        -> group (x ^^ break ^^ y)
+ ;;
+ 
+ let binop left op right = group (nest
+ 									( group (left +|: op)
+ 										+|: right
+ 									)
+ 								)
+ ;;
+ 
+ let intText x = text (string_of_int x);;
+ let floatText x = text (string_of_float x);;
+ let boolText x = text (string_of_bool x);;
+ 
+ 
+ let (^~) x y = match x,y with
+ 				| DocNil, _   -> y
+ 				| _, []
+ 				| _, [DocNil]   -> x :: []
+ 				| _, _        -> x :: bnsp :: y;;
+ let (^^~) x y = match x,y with
+ 				| [], _
+ 				| [DocNil], _   -> y
+ 				| _, []
+ 				| _, [DocNil]   -> x
+ 				| _, _        -> x @ bnsp :: y;;
+ let (^|) x y = match x,y with
+ 				| DocNil, _   -> y
+ 				| _, []
+ 				| _, [DocNil]   -> x :: []
+ 				| _, _        -> x :: break :: y;;
+ let (^^|) x y = match x,y with
+ 				| [], _
+ 				| [DocNil], _   -> y
+ 				| _, []
+ 				| _, [DocNil]   -> x
+ 				| _, _        -> x @ break :: y;;
+ let (+|:) x y = match x,y with
+ 				| DocNil, _   -> y
+ 				| _, DocNil   -> x
+ 				| _, _        -> x ^^ break ^^ y
+ ;;
+ let (+|) x y = match x,y with
+ 				| DocNil, _   -> y
+ 				| _, DocNil   -> x
+ 				| _, _        -> group (x ^^ break ^^ y)
+ ;;
+ let (+~:) x y = match x,y with
+ 				| DocNil, _   -> y
+ 				| _, DocNil   -> x
+ 				| _, _        -> x ^^ bnsp ^^ y
+ ;;
+ let (+~) x y = match x,y with
+ 				| DocNil, _   -> y
+ 				| _, DocNil   -> x
+ 				| _, _        -> group (x ^^ bnsp ^^ y)
+ ;;
+ let rec doclist_2_doc_aux x =
+ 	match x with
+ 		| [] -> empty
+ 		| hd::[] -> hd
+ 		| hd::tl -> group ((doclist_2_doc_aux tl) ^^ hd)
+ ;;
+ let doclist_2_doc x =
+ 	match x with
+ 		| [] -> empty
+ 		| _ -> group ( doclist_2_doc_aux (List.rev x) )
+ ;;
+ (*type doc_or_space_x_doc_x_space = YesSpace of doc | SpaceSpec of bool * doc * bool;;
+ let ( ^- ) x y = (true, x, false) :: y :: [];;
+ let ( ^~ ) x y = (false, x, true) :: y :: [];;
+ let ( ^+ ) x y = (true, x, true) :: y :: [];;
+ let ( ^| ) x y = YesSpace(x) :: y :: [];;
+ let (+|+) = ( +| )
+ ;;
+ let (+|-) x y = match x,y with
+ 				| DocNil, _   -> y
+ 				| _, DocNil   -> x
+ 				| _, _        -> group (x ^^ bnsp ^^ y)
+ ;;
+ let rec doclist_2_doc_aux x =
+ 	match x with
+ 		| []						-> empty
+ 		| YesSpace(hd)::[] -> hd
+ 		| SpaceSpec(_,hd,_)::[] -> hd
+ 		| SpaceSpec(_,hd1,false)::tl ->
+ 			(+|-) (doclist_2_doc_aux tl) hd1
+ 		| SpaceSpec(_,hd1,true)::(SpaceSpec(false,_,_) as hd)::tl ->
+ 			(+|-) (doclist_2_doc_aux (hd::tl)) hd1
+ 		| SpaceSpec(_,hd1,true)::(SpaceSpec(true,_,_) as hd)::tl ->
+ 			(+|+) (doclist_2_doc_aux (hd::tl)) hd1
+ 		| SpaceSpec(_,hd,true)::tl
+ 		| YesSpace(hd)::tl ->
+ 			(+|+) (doclist_2_doc_aux tl) hd
+ ;;
+ let doclist_2_doc x =
+ 	match x with
+ 		| [] -> empty
+ 		| _ -> group ( doclist_2_doc_aux (List.rev x) )
+ ;;*)
+ (*let rec doclist_2_doc_aux f x =
+ 	match x with
+ 		| [] -> empty
+ 		| hd::[] -> hd
+ 		| hd::tl -> f (doclist_2_doc_aux f tl) hd
+ ;;
+ let doclist_2_doc x =
+ 	match x with
+ 		| [] -> empty
+ 		| _ -> group ( doclist_2_doc_aux ( +| ) (List.rev x) )
+ ;;*)
+ 
+ let rec doclist_2_flatdoc_aux x =
+ 	match x with
+ 		| [] -> empty
+ 		| hd::[] -> hd
+ 		| hd::tl -> ( ^^ ) hd (doclist_2_flatdoc_aux tl)
+ 		(*| hd::tl -> ( +|: ) f hd (doclist_2_flatdoc_aux tl)*)
+ ;;
+ let doclist_2_flatdoc x =
+ 	match x with
+ 		| [] -> empty
+ 		| _ -> group ( doclist_2_flatdoc_aux x )
+ ;;
+ 
+ let parenGroup test doc =
+ 	if (test) then
+ 		group ( (*nest*) ( 													(* nest ?*)
+ 			(*text "(" +~ (nestX (-2) ( (nest doc) +~ text ")"))*)
+ 			text "(" ^^ (*+~:*) (nest doc) ^^ (*+~:*) text ")"
+ 		))
+ 	else
+ 		group (doc);
+ ;;
+ let parenGroupAlways test doc =
+ 	group ( (*nest*) ((text "(" ^^ (*+~:*) doc ^^ (*+~:*) text ")") ))			(* nest ?*)
+ ;;
+ 
+ let pretty w doc = 
+     let sdoc = format w 0 [0,Flat,DocGroup(doc)] in
+     let str  = sdocToString sdoc in
+         print_endline str
+ ;;
+ 
+ (********************************************************************************)
+ 
+ type associativity = NON | RIGHT | LEFT;;
+ type precedence =
+ 	PREC_NOPAREN
+ |	PREC_IN
+ |	PREC_below_SEMI
+ |	PREC_SEMI
+ |	PREC_LET
+ |	PREC_below_WITH
+ |	PREC_FUN							(* made up to distinguish between "function" which has match cases, and "fun" which has multiple args *)
+ |	PREC_FUNCTION
+ |	PREC_WITH
+ |	PREC_AND
+ |	PREC_THEN
+ |	PREC_ELSE
+ |	PREC_LESSMINUS						(* <- *)
+ |	PREC_COLONEQUAL						(* := *)
+ |	PREC_AS
+ |	PREC_BAR							(* |  *)
+ |	PREC_below_COMMA
+ |	PREC_COMMA
+ |	PREC_ARROW							(* -> *)
+ |	PREC_OR
+ |	PREC_BARBAR							(* || *)
+ |	PREC_AMPERSAND
+ |	PREC_AMPERAMPER						(* &  *) (* && *)
+ |	PREC_below_EQUAL
+ |	PREC_INFIXOP0
+ |	PREC_EQUAL
+ |	PREC_LESS
+ |	PREC_GREATER
+ |	PREC_INFIXOP1
+ |	PREC_COLONCOLON						(* :: *)
+ |	PREC_INFIXOP2
+ |	PREC_PLUS
+ |	PREC_MINUS
+ |	PREC_MINUSDOT						(* -. *)
+ |	PREC_INFIXOP3
+ |	PREC_STAR
+ |	PREC_INFIXOP4
+ |	PREC_unary_minux
+ |	PREC_constant_constructor
+ |	PREC_constr_appl
+ |	PREC_below_SHARP
+ |	PREC_SHARP
+ |	PREC_below_DOT
+ |	PREC_DOT
+ |	PREC_BACKQUOTE
+ |	PREC_BEGIN
+ |	PREC_CHAR
+ |	PREC_FALSE
+ |	PREC_FLOAT
+ |	PREC_INT
+ |	PREC_INT32
+ |	PREC_INT64
+ |	PREC_LBRACE
+ |	PREC_LBRACELESS
+ |	PREC_LBRACKET
+ |	PREC_LBRACKETBAR
+ |	PREC_LIDENT
+ |	PREC_LPAREN
+ |	PREC_NEW
+ |	PREC_NATIVEINT
+ |	PREC_PREFIXOP
+ |	PREC_STRING
+ |	PREC_TRUE
+ |	PREC_UIDENT
+ |	PREC_NONE;;
+ let precVal x = match x with
+ 	|	PREC_NOPAREN -> 0
+ 	|	PREC_IN -> 3
+ 	|	PREC_below_SEMI -> 4
+ 	|	PREC_SEMI -> 4
+ 	|	PREC_LET -> 5
+ 	|	PREC_below_WITH -> 6
+ 	|	PREC_FUN -> 7
+ 	|	PREC_FUNCTION -> 7
+ 	|	PREC_WITH -> 7
+ 	|	PREC_AND -> 8
+ 	|	PREC_THEN -> 9
+ 	|	PREC_ELSE -> 10
+ 	|	PREC_LESSMINUS					(* <- *) -> 11
+ 	|	PREC_COLONEQUAL					(* := *) -> 12
+ 	|	PREC_AS -> 13
+ 	|	PREC_BAR						(* |  *) -> 14
+ 	|	PREC_below_COMMA -> 15
+ 	|	PREC_COMMA -> 16
+ 	|	PREC_ARROW						(* -> *) -> 17
+ 	|	PREC_OR -> 18
+ 	|	PREC_BARBAR						(* || *) -> 18
+ 	|	PREC_AMPERSAND -> 19
+ 	|	PREC_AMPERAMPER					(* &  *) (* && *) -> 19
+ 	|	PREC_below_EQUAL -> 20
+ 	|	PREC_INFIXOP0 -> 21
+ 	|	PREC_EQUAL -> 21
+ 	|	PREC_LESS -> 21
+ 	|	PREC_GREATER -> 21
+ 	|	PREC_INFIXOP1 -> 22
+ 	|	PREC_COLONCOLON					(* :: *) -> 23
+ 	|	PREC_INFIXOP2 -> 24
+ 	|	PREC_PLUS -> 24
+ 	|	PREC_MINUS -> 24
+ 	|	PREC_MINUSDOT					(* -. *) -> 24
+ 	|	PREC_INFIXOP3 -> 25
+ 	|	PREC_STAR -> 25
+ 	|	PREC_INFIXOP4 -> 26
+ 	|	PREC_unary_minux -> 27
+ 	|	PREC_constant_constructor -> 28
+ 	|	PREC_constr_appl -> 29
+ 	|	PREC_below_SHARP -> 30
+ 	|	PREC_SHARP -> 31
+ 	|	PREC_below_DOT -> 32
+ 	|	PREC_DOT -> 33
+ 	|	PREC_BACKQUOTE -> 34
+ 	|	PREC_BEGIN -> 34
+ 	|	PREC_CHAR -> 34
+ 	|	PREC_FALSE -> 34
+ 	|	PREC_FLOAT -> 34
+ 	|	PREC_INT -> 34
+ 	|	PREC_INT32 -> 34
+ 	|	PREC_INT64 -> 34
+ 	|	PREC_LBRACE -> 34
+ 	|	PREC_LBRACELESS -> 34
+ 	|	PREC_LBRACKET -> 34
+ 	|	PREC_LBRACKETBAR -> 34
+ 	|	PREC_LIDENT -> 3434
+ 	|	PREC_LPAREN -> 34
+ 	|	PREC_NEW -> 34
+ 	|	PREC_NATIVEINT -> 34
+ 	|	PREC_PREFIXOP -> 34
+ 	|	PREC_STRING -> 34
+ 	|	PREC_TRUE -> 34
+ 	|	PREC_UIDENT -> 34
+ 	|	PREC_NONE -> 100
+ ;;
+ 
+ let strToPrec str = match str with
+ 	| "#" -> PREC_SHARP
+ 	| "&" -> PREC_AMPERSAND
+ 	| "&&" -> PREC_AMPERAMPER
+ 	| "`" -> PREC_BACKQUOTE
+ 	| "(" -> PREC_LPAREN
+ 	| ")" -> PREC_LPAREN
+ (*	| "*" -> PREC_STAR*)				(* say it's times instead of star *)
+ 	| "," -> PREC_COMMA
+ 	| "->" -> PREC_ARROW
+ 	| "." -> PREC_DOT
+ 	| "::" -> PREC_COLONCOLON
+ 	| ":=" -> PREC_COLONEQUAL
+ 	| ";" -> PREC_SEMI
+ 	| "<" -> PREC_LESS
+ 	| "<-" -> PREC_LESSMINUS
+ 	| "=" -> PREC_EQUAL
+ 	| "[" -> PREC_LBRACKET
+ 	| "[|" -> PREC_LBRACKETBAR
+ 	| "]" -> PREC_LBRACKET
+ 	| "{" -> PREC_LBRACE
+ 	| "{<" -> PREC_LBRACELESS
+ 	| "|" -> PREC_BAR
+ 	| "||" -> PREC_BARBAR
+ 	| "|]" -> PREC_LBRACKETBAR
+ 	| ">" -> PREC_GREATER
+ 	| "}" -> PREC_LBRACE
+ 	| "!=" -> PREC_INFIXOP0
+ (*	| "+" -> PREC_PLUS*)				(* say it's infix instead *)
+ (*	| "-" -> PREC_MINUS*)				(* say it's infix instead *)
+ 	| "-." -> PREC_MINUSDOT
+ 	| "!" -> PREC_PREFIXOP
+ 	| "~" -> PREC_PREFIXOP
+ 	| "?" -> PREC_PREFIXOP
+ 	| "mod"
+ 	| "land"
+ 	| "lor"
+ 	| "lxor" -> PREC_INFIXOP3
+ 	| "lsl"
+ 	| "asr" -> PREC_INFIXOP4
+ (*	| "="*)
+ (*	| "<"*)
+ (*	| ">"*)
+ (*	| "|"*)
+ (*	| "&"*)
+ 	| "$" -> PREC_INFIXOP0
+ 	| "@"
+ 	| "^" -> PREC_INFIXOP1
+ 	| "+"
+ 	| "-" -> PREC_INFIXOP2
+ 	| "*"
+ 	| "/"
+ 	| "%" -> PREC_INFIXOP3
+ 	| "**" -> PREC_INFIXOP4
+ 	| "==" -> PREC_EQUAL
+ 	| _ -> PREC_NOPAREN					(* user-defined infix functions *)
+ ;;
+ 
+ exception EX_AST_NOT_POSSIBLE
+ ;;
+ 
+ let hideExns = ref true;;
+ 
+ let is_infix s =
+ 	try
+ 		let lc = Char.lowercase s.[0] in
+ 		if (lc = '_' || lc = '{' || lc = '(' || ('a' <= lc && lc <= 'z') || ('0' <= lc && lc <= '9')) then
+ 			((*fprintf ppf "%s %c %d" "YES" lc (int_of_char lc);*) false)
+ 		else
+ 			((*fprintf ppf "%s %c %d" "NO" lc (int_of_char lc);*) true)
+ 	with
+ 		Invalid_argument _ -> (* raise EX_AST_NOT_POSSIBLE *) (*text "There was no string!\n";*)
+ 	      false
+ ;;
+ 
+ let fmt_position l =
+ 	group (
+ 		if l.pos_fname = "" && l.pos_lnum = 1
+ 		then intText l.pos_cnum
+ 		else if l.pos_lnum = -1
+ 		then (text l.pos_fname) ^^ text "[" ^^ intText l.pos_cnum ^^ text "]"
+ 		else (text l.pos_fname) ^^ text "[" ^^ intText l.pos_lnum ^^ text "," ^^
+ 			intText l.pos_bol ^^ text "+" ^^ intText (l.pos_cnum - l.pos_bol) ^^ text
+ 			"]";
+ 	)
+ ;;
+ 
+ let fmt_location loc =
+ 	group (
+ 		text "(" ^^ fmt_position loc.loc_start ^^ text ".." ^^ fmt_position loc.loc_end  ^^
+ 		if loc.loc_ghost then break ^^ text "ghost" else empty
+ 	)
+ ;;
+ 
+ let rec fmt_longident_aux x =
+ 	match x with
+ 	| Longident.Lident (s) -> text s;
+ 	| Longident.Ldot (y, s) -> (fmt_longident_aux y) ^^ (text ".") ^^ (text s);
+ 	| Longident.Lapply (y, z) -> group (
+ 			fmt_longident_aux y ^^ text "(" ^^ fmt_longident_aux z ^^ text ")"
+ 		)
+ ;;
+ 
+ let fmt_longident x = fmt_longident_aux x;;
+ 
+ let boxToStr box =
+ 	let sd = format 999999 0 [0, Flat, box] in
+ 	let str = sdocToString sd in
+ 	str;
+ ;;
+ 
+ let longidentToStr id =
+ 	let box = fmt_longident id in
+ 	boxToStr box
+ ;;
+ 
+ let fmt_constant x =
+ 	match x with
+ 	| Const_int (i) -> intText i;
+ 	| Const_char (c) -> text ("'" ^ (Char.escaped c) ^ "'");		(*fprintf f "%02x" (Char.code c);*)
+ 	| Const_string (s) -> text ("\"" ^ (String.escaped s) ^ "\"");
+ 	| Const_float (s) -> text s;
+ 	| Const_int32 (i) -> text (Int32.to_string i);	(*fprintf f "%ld" i;*)
+ 	| Const_int64 (i) -> text (Int64.to_string i);	(*fprintf f "%Ld" i;*)
+ 	| Const_nativeint (i) -> text (Nativeint.to_string i);	(*fprintf f "%nd" i;*)
+ ;;
+ 
+ let fmt_mutable_flag x =
+ 	match x with
+ 	| Immutable -> empty;
+ 	| Mutable -> text "mutable";
+ ;;
+ 
+ let fmt_virtual_flag x =
+ 	match x with
+ 	| Virtual -> text "virtual";
+ 	| Concrete -> empty;
+ ;;
+ 
+ let fmt_rec_flag x =
+ 	match x with
+ 	| Nonrecursive -> empty;
+ 	| Recursive -> text "rec";
+ 	| Default -> empty;
+ ;;
+ 
+ let fmt_direction_flag x =
+   match x with
+   | Upto -> text "to";
+   | Downto -> text "downto";
+ ;;
+ 
+ let fmt_private_flag x =
+   match x with
+   | Public -> empty;
+   | Private -> text "private";
+ ;;
+ 
+ let fmt_variance x =
+   match x with
+   | (false, false) -> empty;
+   | (true, false) -> text "+";
+   | (false, true) -> text "-";
+   | (true, true) -> raise EX_AST_NOT_POSSIBLE;	(* bug *)
+ ;;
+ 
+ let line indent s (*...*) = (* shouldn't be used *)
+   nestX indent s
+ ;;
+ 
+ let print f s (*...*) =
+ 	s (*...*)
+ ;;
+ 
+ let rec boxIter_aux2 joinf f lst =
+ 	match lst with
+ 	| [] -> empty;
+ 	| hd::tl ->  (joinf
+ 			(f hd)
+ 			(boxIter_aux2 joinf f tl)
+ 		);
+ ;;
+ let rec boxIter_aux f lst =
+ 	boxIter_aux2 (+|:) f lst
+ ;;
+ let rec boxIter f lst =
+ 	group ( (*nest*) (
+ 		(boxIter_aux f lst)
+ 	))
+ ;;
+ let rec boxIter2 f lst =
+ 	let join x y = match x,y with
+ 					| DocNil, _   -> y
+ 					| _, DocNil   -> x
+ 					| _, _        -> x ^^ hardbreak ^^ y in
+ 	group ( (*nest*) (
+ 		(boxIter_aux2 join f lst)
+ 	))
+ ;;
+ 
+ let list f prec ass l = List.iter (f prec ass) l;;
+ let list2 f1 f2 prec ass l =
+ 	match l with
+ 		| [] -> empty;
+ 		| hd::[] -> (f1 prec ass hd);
+ 		| hd::tl -> group ((f1 prec ass hd) +~: (*+|:*) boxIter_aux (f2 prec ass) tl);
+ ;;
+ let list_sep f sep prec ass l =
+ 	match l with
+ 		| [] -> empty;
+ 		| hd::[] -> (f prec ass hd);
+ 		| hd::tl -> let f2 = (fun prec2 ass2 hd2 -> group ( (if (sep != "") then text sep else empty) +| (f prec2 ass2 hd2))) in
+ (*			((group ((f prec ass hd) :: text sep))) :: (boxIter (f2 prec ass) tl));*)
+ 			group ( (f prec ass hd) +~: (*+|:*) (boxIter_aux (f2 prec ass) tl));
+ ;;
+ let list_sep_nobinding f sep prec ass l =
+ 	match l with
+ 		| [] -> empty;
+ 		| hd::[] -> (f prec ass hd);
+ 		| hd::tl -> let f2 = (fun prec2 ass2 hd2 -> group ( (if (sep != "") then text sep else empty) +| (f prec2 ass2 hd2))) in
+ (*			((group ((f prec ass hd) :: text sep))) :: (boxIter (f2 prec ass) tl));*)
+ 			group ( (f prec ass hd) +|: (boxIter_aux (f2 prec ass) tl));
+ ;;
+ let list_comma f l = list_sep f "," PREC_COMMA PREC_COMMA l;;
+ let list2Tuple f1 f2 prec ass l =
+ 	match l with
+ 		| [] -> empty, empty;
+ 		| hd::[] -> ((f1 prec ass hd), empty);
+ 		| hd::tl -> ((f1 prec ass hd), boxIter_aux (f2 prec ass) tl);
+ ;;
+ 
+ let list2Tuple2 f1 f2 prec ass l =
+ 	match l with
+ 		| [] -> (empty, empty), empty;
+ 		| hd::[] -> ((f1 prec ass hd), empty);
+ 		| hd::tl -> ((f1 prec ass hd), boxIter_aux (f2 prec ass) tl);
+ ;;
+ 
+ let rec list_sep_aslist_aux leadlist f lst =
+ 	match lst with
+ 		| [] -> [];
+ 		| hd::tl -> (*leadlist @ (f hd) @ (_aux leadlist f tl)*)
+ 			(group (doclist_2_doc (leadlist ^^| (f hd)))) ^| list_sep_aslist_aux leadlist f tl
+ and list_sep_aslist leadlist f sep prec ass l =
+ 	match l with
+ 		| [] -> [empty];
+ 		| hd::[] ->  (leadlist ^^| (f prec ass hd));
+ 		| hd::tl -> (*(group (doclist_2_doc (leadlist @ (f prec ass hd)))) :: (_aux [text sep] (f prec ass) tl)*)
+ 			(*leadlist @ (f prec ass hd) @ (list_sep_aslist_aux [text sep] (f prec ass) tl)*)
+ 			leadlist ^^| (f prec ass hd) ^^| (list_sep_aslist_aux (text sep (*^| []*)::[]) (f prec ass) tl)
+ ;;
+ 
+ let rec boxIter_aux_boxlist f lst = 
+ 	match lst with
+ 	| [] -> [];
+ 	| hd::tl ->  (
+ 			(f hd) ^|
+ 			(boxIter_aux_boxlist f tl)
+ 		);
+ ;;
+ let rec boxIter_aux_boxlist2 f lst = 
+ 	match lst with
+ 	| [] -> [];
+ 	| hd::tl ->  (
+ 			(f hd) ^^|
+ 			(boxIter_aux_boxlist2 f tl)
+ 		);
+ ;;
+ let list2_boxlist_x_boxlistlist_x_boxlist (f1:precedence -> precedence -> 'a -> doc list) f2 prec ass l =
+ 	let rec boxIter_aux_boxlist2 f lst = 
+ 		match lst with
+ 		| [] -> [[]];
+ 		| hd::tl ->  (
+ 				(f hd) ::
+ 				(boxIter_aux_boxlist2 f tl)
+ 			); in
+ 	match l with
+ 		| [] -> [], [[]], [];
+ 		| hd::[] -> f1 prec ass hd, [[empty]], [empty];
+ 		| hd::tl -> 
+ 			let last, rest =
+ 				(match List.rev tl with
+ 					| [] -> None, []
+ 					| hd2::tl2 -> Some hd2, List.rev tl2) in
+ 			(f1 prec ass hd),
+ 			(boxIter_aux_boxlist2 (f2 prec ass) rest),
+ 			(match last with Some x -> (f2 prec ass x) | None -> [])
+ ;;
+ let rec flatten (x : 'a list list) =
+ 	match x with
+ 		| [] -> [];
+ 		| hd::tl -> hd ^^| flatten tl
+ ;;
+ let rec flattenF f (x : 'a list list) =
+ 	match x with
+ 		| [] -> [];
+ 		| hd::tl -> (f hd) ^^| flattenF f tl
+ ;;
+ let list2_boxlist f1 f2 prec ass l =
+ 	match l with
+ 		| [] -> [];
+ 		| hd::[] -> [f1 prec ass hd];
+ 		| hd::tl -> (f1 prec ass hd) ^| (boxIter_aux_boxlist (f2 prec ass) tl);
+ ;;
+ let list2_boxlist2 (f1:precedence -> precedence -> 'a -> doc list) f2 prec ass l =
+ 	match l with
+ 		| [] -> [];
+ 		| hd::[] -> f1 prec ass hd;
+ 		| hd::tl -> (f1 prec ass hd) ^^| (boxIter_aux_boxlist2 (f2 prec ass) tl);
+ ;;
+ (*let rec boxlist_2_box_aux (l : doc list) : doc =
+ 	match List.rev l with
+ 		| [] -> empty
+ 		| hd::[] -> hd
+ 		| hd1::hd2::tl -> ((boxlist_2_box_aux tl) +| hd2) +| hd1
+ and boxlist_2_box (l : doc list) : doc =
+ 	(*boxlist_2_box_aux l*)
+ 	match l with
+ 		| [] -> empty
+ 		| hd::[] -> hd
+ 		| hd1::hd2::tl -> (hd1 +| hd2) +| boxlist_2_box tl
+ ;;*)
+ let list_sep_boxlist (f: precedence -> precedence -> 'a -> doc) sep prec ass l : doc list =
+ 	match l with
+ 		| [] -> [];
+ 		| hd::[] -> [f prec ass hd];
+ 		| hd::tl -> let f2 = (fun prec2 ass2 hd2 -> group (
+ 								(if (sep != "") then text sep else empty) +| (f prec2 ass2 hd2)
+ 							)) in
+ (*			((group ((f prec ass hd) :: text sep))) :: (boxIter (f2 prec ass) tl));*)
+ 			(f prec ass hd) ^| (boxIter_aux_boxlist (f2 prec ass) tl);
+ ;;
+ let list_sep_boxlist2 f sep prec ass l =
+ 	match l with
+ 		| [] -> [empty];
+ 		| hd::[] -> (f prec ass hd);
+ 		| hd::tl -> let f2 = fun prec2 ass2 hd2 -> 
+ 				(
+ 					((if (sep != "") then text sep else empty) +|
+ 					doclist_2_doc (f prec2 ass2 hd2))
+ 					:: []
+ 				) in
+ (*			((group ((f prec ass hd) :: text sep))) :: (boxIter (f2 prec ass) tl));*)
+ 			(*group ( doclist_2_doc ( *) ((
+ 				(f prec ass hd) ^^| (boxIter_aux_boxlist2 (f2 prec ass) tl)
+ 			) );
+ ;;(*
+ 
+ let list_sep2Tuple f sep prec ass l =
+ 	match l with
+ 		| [] -> [empty], empty;
+ 		| hd::[] -> ((f prec ass hd), empty);
+ 		| hd::tl ->
+ 			let f2 = (fun prec2 ass2 hd2 -> (if (sep != "") then text sep else empty) :: (f prec2 ass2 hd2)) in
+ 			((f prec ass hd), boxIter_aux_boxlist (f2 prec ass) tl);
+ ;;*)
+ 
+ let option f x =
+   match x with
+   | None -> text "None";
+   | Some x ->
+       group ( text "Some" +| (nest (f PREC_NOPAREN PREC_NOPAREN x)) ); (* Group ?*)
+ ;;
+ 
+ let longident li = fmt_longident li;;
+ let string s = text "\"" ^^ text s ^^ text "\"";;
+ let bool x = text (string_of_bool x);;
+ let label x = text "label=\"" ^^ text x ^^ text "\"";;
+ 
+ let stringP prec parentPrec s = string s;;
+ 
+ let textP prec parentPrec s = text s;;
+ 
+ let rec _printtuple f sep prec precParent x =
+     match x with
+         hd::md::tl ->
+             begin
+                 group ( doclist_2_doc (
+ 					((f prec precParent) hd) ^~
+ 					text sep ^|
+ 					(_printtuple f sep prec precParent (md::tl))
+ 					:: []
+ 				));
+             end
+         | hd::tl ->
+             begin
+ 				group ( doclist_2_doc (
+ 					((f prec precParent) hd) ^|
+ 					(_printtuple f sep prec precParent tl)
+ 					:: []
+                 ));
+             end
+         | [] -> empty;
+ ;;
+ let printtuple f prec parentPrec x =
+ 	parenGroup (precVal(PREC_COMMA) < precVal(prec) || parentPrec == PREC_COMMA)
+ 	(*	text "(" +~*)
+ 		(_printtuple f "," PREC_COMMA PREC_COMMA x)
+ 	(*	+~ text ")"*)
+ ;;
+ 
+ let rec _exp_printlist f sep print_sep prec precParent x =
+ 	match x with
+ 		| [] -> empty;
+ 		| hd::tl ->
+ 			begin
+ 				match hd.pexp_desc with
+ 					| Pexp_tuple (value::sublist) ->
+ 						begin
+ 							group ( doclist_2_doc (
+ 								(if (print_sep) then text sep else empty) ^|
+ 								((f prec precParent) value) ^~
+ 								(_exp_printlist f sep true prec precParent(sublist))
+ 								:: []
+ 							))
+ 						end;
+ 					| Pexp_construct (Longident.Lident ("::"), Some eo, b) ->
+ 						begin
+ 							group (
+ 								(_exp_printlist f sep true prec precParent(eo::[]))
+ 							)
+ 						end;
+ 					(*| Pexp_construct (il, eo, b)  -> (option i indet f ppf eo; bool i indet ppf b);*)
+ 					| _ -> (empty(*(f i indet ppf) hd;*))
+ 			end;
+ and __exp_printlist f sep print_end prec precParent x =
+   match x.pexp_desc with
+   | Pexp_construct(Longident.Lident ("[]"), _, _) -> text "[]"
+   | Pexp_construct(Longident.Lident ("::"), Some y, _) -> 
+       __exp_printlist f sep print_end prec precParent y
+   | Pexp_tuple(arg1 :: arg2 :: []) -> 
+       group ( doclist_2_doc (
+               ((f prec precParent) arg1) ^|
+               (match arg2.pexp_desc with
+               | Pexp_construct(Longident.Lident ("[]"), _, _) -> 
+                   if (print_end) then (text sep ^| (text "[]" :: [])) else [empty]
+               | _ ->
+                   (text sep) ^|
+                   ((__exp_printlist f sep print_end prec precParent arg2) :: [])
+               )
+                             )
+              )
+   | _ -> f prec precParent x
+ and exp_printlist f prec parentPrec x =
+ (*	parenGroup (precVal(PREC_LBRACKET) < precVal(prec) || parentPrec == PREC_LBRACKET)
+ *)		(nest (group ( doclist_2_doc (
+ 			(match x with
+ 				| None -> empty;
+ 				| Some y -> 
+                     let chaseTail =
+                       let rec chaser arg =
+                         match arg.pexp_desc with
+                           Pexp_tuple(args) -> 
+                             (match (List.rev args) with
+                               {pexp_desc = Pexp_construct(Longident.Lident ("::"), Some arg', _); pexp_loc = _} :: _ -> chaser arg'
+                             | x :: _ -> x
+                             | [] -> arg)
+                         | _ -> arg
+                       in chaser y in
+                     match chaseTail.pexp_desc with
+                       Pexp_construct(Longident.Lident ("[]"), None, _) ->
+ 			            text "[" +~
+                           (__exp_printlist f ";" false PREC_SEMI PREC_SEMI (y)) +~ 
+                           text "]"
+                     | _ -> (__exp_printlist f "::" true PREC_SEMI PREC_SEMI y)
+ 			)
+ 			:: []
+ 		))))
+ ;;
+ 
+ let rec _pat_printlist f sep print_sep prec precParent x =
+ 	match x with
+ 		| [] -> empty;
+ 		| hd::tl ->
+ 			begin
+ 				match hd.ppat_desc with
+ 					| Ppat_tuple (value::sublist) ->
+ 						begin
+ 							group ( doclist_2_doc (
+ 								(if (print_sep) then text sep else empty) ^|
+ 								(f prec precParent value) ^|
+ 								(_pat_printlist f sep true prec precParent(sublist))
+ 								:: []
+ 							))
+ 						end;
+ 					| Ppat_construct (Longident.Lident ("::"), Some eo, b) ->
+ 						begin
+ 							group (
+ 								(_pat_printlist f sep true prec precParent(eo::[]))
+ 							)
+ 						end;
+ 					(*| Pexp_construct (il, eo, b)  -> (option i indet f ppf eo; bool i indet ppf b);*)
+ 					| _ -> (text sep +| ((f prec precParent) hd))
+ 			end;
+ and pat_printlist f prec parentPrec x =
+ 	begin
+ 		match x with
+ 			| None -> empty;
+ 			| Some y -> _pat_printlist f "::" false PREC_COLONCOLON PREC_COLONCOLON (y::[]);
+     end
+ ;;
+ 
+ let rec print_function prec parentPrec (p, eo, l) =
+ 	(*(option expression eo) ::*)
+ 	(match l with
+ 		| (p2,e2)::[] -> begin
+ 				(* if there are multiple args then it's not a patern-match, and this one is a "fun", otherwise it is a "function" *)
+ 				let thisPrec = (match (e2.pexp_desc) with
+ 					| Pexp_function (_,_,(p3,e3)::[]) -> PREC_FUN;
+ 					| _ ->  PREC_FUNCTION;
+ 				) in
+ 				let tup = pattern_x_expression_case_no_lead_no_newline PREC_FUN thisPrec (p2, e2) in
+ 				(
+ 					if (parentPrec != PREC_FUNCTION && parentPrec != PREC_FUN) then (* don't print out "fun x ->" twice! *)
+ 						text "fun"
+ 					else
+ 						empty;
+ 				),
+ 				(fst tup) ^^| [],			(* args *)
+ 				(expression PREC_ARROW thisPrec (snd tup))		(* expr *)
+ 			end
+ 		| _ -> begin
+ 					text "function", [empty],
+ 					group ( nest (
+ 						(boxIter (pattern_x_expression_case PREC_NOPAREN PREC_FUNCTION) l)
+ 					))
+ 			end
+ 	)
+ 	(*:: (list2 pattern_x_expression_case_no_lead l)*)
+ 
+ (* precidence and associativity *)
+ and core_type prec parentPrec x =
+ (*  line i indet ppf "core_type %a\n" fmt_location x.ptyp_loc;*)
+ 	(*let i = i+1 in*)
+ 	match x.ptyp_desc with
+ 	| Ptyp_any -> text "_";					(* high prec *)
+ 	| Ptyp_var (s) -> text "\'" ^^ text s;		(* high prec *)
+ 	| Ptyp_arrow (l, ct1, ct2) ->
+ 		(*line indent ppf "Ptyp_arrow\n";*)
+ 		parenGroup (precVal(PREC_ARROW) < precVal(prec) || parentPrec == PREC_ARROW)
+ 			(
+ 				doclist_2_doc
+ 				(
+ 					(*text l ::*)
+ 					(core_type PREC_ARROW PREC_ARROW ct1) ^|
+ 					text "->" ^|
+ 					(core_type PREC_ARROW PREC_ARROW ct2)
+ 					:: []
+ 				)
+ 			)
+ 	| Ptyp_tuple l ->
+ 		parenGroupAlways (precVal(PREC_STAR) < precVal(prec) || parentPrec == PREC_STAR)
+ 			(
+ 				(list_sep_nobinding core_type "*" PREC_STAR PREC_STAR l)
+ 			)
+ 	| Ptyp_constr (li, l) ->
+ 		(*line i indet ppf "Ptyp_constr %a\n" fmt_longident li;*)
+ 		parenGroup (precVal(PREC_below_SHARP) < precVal(prec) || parentPrec == PREC_below_SHARP)
+ 			(
+ 				doclist_2_doc
+ 				(
+ 		  (*print ppf "{{";
+ 		  list i indent core_type ppf PREC_NONE PREC_NONE l; (* NOTE: No idea where why we're not printing this *)
+ 		  print ppf "}}";*)
+ 					(list_sep core_type " " PREC_NONE PREC_NONE l) ^|
+ 					(fmt_longident li)
+ 	(*				(match l with 
+ 						| [] -> (fmt_longident li)
+ 						| [a] -> (core_type PREC_below_SHARP PREC_below_SHARP a) :: (fmt_longident li)	(* PREC_STRING ? *)
+ 						| _ -> (text "(" ::
+ 									(list_sep core_type ","
+ 		(*							(list2 0 indent
+ 										(fun i2 indent2 ppf2 prec2 ass2 b -> (core_type i2 indent2 ppf2 prec2 ass2 b)))
+ 										(fun i2 indent2 ppf2 prec2 ass2 b -> (print ppf2 ", "; core_type i2 indent2 ppf2 prec2 ass2 b)))
+ 		*)								PREC_COMMA PREC_COMMA l)
+ 									:: text ")")
+ 					)
+ 	*)
+ 					:: []
+ 				)
+ 			)
+ 	| Ptyp_variant (l, closed, low) ->
+ 		(*line indent ppf "Ptyp_variant closed=%s\n" (string_of_bool closed);*)
+ 		parenGroup (precVal(PREC_LBRACKET) < precVal(prec) || parentPrec == PREC_LBRACKET)
+ 			(
+ 				doclist_2_doc
+ 				(
+ 					text "[" ^~
+ 					(if (closed == false) then text ">" else empty) ^|
+ 					(match low with
+ 						| None -> 
+ 							(list_sep label_x_bool_x_core_type_list "|" PREC_LBRACKET PREC_LBRACKET l) :: []
+ 						| Some lox -> (text "<" ^|
+ 							(list_sep label_x_bool_x_core_type_list "|" PREC_LESS PREC_LESS l)
+ 							^| text ">" ^|
+ 							(boxIter (textP PREC_NONE PREC_NONE) lox)
+ 							:: [])
+ 					) ^^~
+ 					text "]"
+ 					:: []
+ 				)
+ 			)
+ 	| Ptyp_object (l) ->
+ 		(*line indent ppf "Ptyp_object\n";*)
+ 		parenGroup (precVal(PREC_LESS) < precVal(prec) || parentPrec == PREC_LESS)
+ 			(
+ 				doclist_2_doc
+ 				(
+ 					text "<" ^|
+ 					(boxIter (core_field_type PREC_LESS PREC_LESS) l) ^|
+ 					text ">"
+ 					:: []
+ 				)
+ 			)
+ 	| Ptyp_class (li, l, low) ->
+ 		parenGroup (precVal(PREC_SHARP) < precVal(prec) || parentPrec == PREC_SHARP)
+ 			(
+ 				doclist_2_doc
+ 				(
+ 					(match l with 
+ 						| [] -> [empty];
+ 						| [a] -> [(core_type PREC_NOPAREN PREC_NOPAREN a)]
+ 						| _ -> (text "(" ^~ (list_comma core_type l) ^~ text ")" :: [])
+ 					) ^^|
+ 					text "#" ^|
+ 					(fmt_longident li) ^|
+ 					(match low with
+ 						| [] -> [empty];
+ 						| _ -> (text "[>" ^~ (boxIter (textP PREC_LBRACKET PREC_LBRACKET) low) ^~ text "]" :: [])
+ 					)
+ 				)
+ 			)
+ 	| Ptyp_alias (ct, s) ->
+ 		parenGroup (precVal(PREC_AS) < precVal(prec) || parentPrec == PREC_AS)
+ 			(
+ 				doclist_2_doc
+ 				(
+ 					(core_type PREC_AS PREC_AS ct) ^|
+ 					text "as" ^|
+ 					(text "\'" ^^ text s)
+ 					:: []
+ 				)
+ 			)
+ 	| Ptyp_poly (sl, ct) ->
+ 		parenGroup (precVal(PREC_DOT) < precVal(prec) || parentPrec == PREC_DOT)
+ 			(
+ 				(boxIter (fun x -> (text "\'" ^^ text x)) sl) ^^
+ 				(match sl with
+ 					| [] -> empty;
+ 					| _ -> text ".";
+ 				) ^^
+ 				(core_type PREC_DOT PREC_DOT ct)
+ 			)
+ 	
+ and core_field_type prec parentPrec x =
+   (*line indent ppf "core_field_type %a\n" fmt_location x.pfield_loc;*)
+   nest (
+ 	(match x.pfield_desc with
+ 		| Pfield (s, ct) ->
+ 		  text s ^^ text ":" +|
+ 		  (core_type prec parentPrec ct);
+ 		| Pfield_var -> text "..";
+ 	)
+   )
+ 
+ and pattern prec parentPrec x =
+ (*  line i indet ppf "pattern %a\n" fmt_location x.ppat_loc;*)
+ 	group ( nest ( doclist_2_doc (
+ 		match x.ppat_desc with
+ 		| Ppat_any -> [text "_"];
+ 		| Ppat_var (s) -> [text s];
+ 		| Ppat_alias (p, s) ->
+ 			(*line indent ppf "Ppat_alias \"%s\"\n" s;*)
+ 			(parenGroup (precVal(PREC_AS) < precVal(prec) || parentPrec == PREC_AS)
+ 				(
+ 					(pattern PREC_AS PREC_AS p)
+ 				)) ^|
+ 			text "as" ^|
+ 			text s
+ 			:: [];
+ 		| Ppat_constant (c) -> [fmt_constant c];
+ 		| Ppat_tuple (l) ->
+ 			(*print ppf "TUPLE ";*)
+ 			(printtuple pattern prec parentPrec l)
+ 			(*print ppf " -> ";		(*NOTE: this does not work when stack patterns*)*)
+ 			:: [];
+ 		| Ppat_construct (li, po, b) ->
+ 			(match li with
+ 				| Longident.Lident ("::") -> ((*print ppf "LIST "; *)pat_printlist pattern PREC_COLONCOLON PREC_COLONCOLON po) :: [];
+ 				| _ -> (match po with
+ 							| None -> [fmt_longident li];
+ 							| Some px -> begin
+ (*								parenGroup (precVal(PREC_NONE) < precVal(prec) || parentPrec == PREC_NONE)
+ *)									(
+ 										(fmt_longident li) ^|
+ 										(pattern PREC_NONE PREC_NONE px)
+ 										:: [];
+ 									)
+ 								end
+ 						);
+ 			)
+ 		| Ppat_variant (l, po) ->
+ 			(*line indent ppf "Ppat_variant \"%s\"\n" l;*)
+ 			parenGroup (precVal(PREC_BACKQUOTE) < precVal(prec) || parentPrec == PREC_BACKQUOTE)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						(text "`" ^^ text l) ^|
+ 						(match po with
+ 							| None -> empty;
+ 							| Some px -> (pattern PREC_STRING PREC_STRING px);
+ 						)
+ 						:: [];
+ 					)
+ 				)
+ 			:: [];
+ 		| Ppat_record (l) ->
+ 			(*line indent ppf "Ppat_record\n";*)
+ 			parenGroup (precVal(PREC_LBRACE) < precVal(prec) || parentPrec == PREC_LBRACE)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						text "{" ^|
+ 						(list2 longident_x_pattern_no_lead longident_x_pattern PREC_LBRACE PREC_LBRACE l) ^|
+ 						text "}"
+ 						:: [];
+ 					)
+ 				)
+ 			:: [];
+ 		| Ppat_array (l) ->
+ 			(*line indent ppf "Ppat_array\n";*)
+ 			parenGroup (precVal(PREC_LBRACKETBAR) < precVal(prec) || parentPrec == PREC_LBRACKETBAR)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						text "[|" ^|
+ 						(list_sep pattern ";" PREC_SEMI PREC_SEMI l) ^|
+ 						text "|]"
+ 						:: [];
+ 					)
+ 				)
+ 			:: [];
+ 		| Ppat_or (p1, p2) ->
+ 			(pattern PREC_BAR PREC_BAR p1) ^|
+ 			((*hardbreak ^^ *)text "|") ^|
+ 			(pattern PREC_BAR PREC_BAR p2)
+ 			:: [];
+ 		| Ppat_constraint (p, ct) ->
+ 			parenGroupAlways (precVal(PREC_NONE) < precVal(prec) || parentPrec == PREC_NONE) (* PREC_COLON ?*)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						(pattern PREC_NOPAREN PREC_NOPAREN p) ^|
+ 						text ":" ^|
+ 						(core_type PREC_NOPAREN PREC_NOPAREN ct)
+ 						:: [];
+ 					)
+ 				)
+ 			:: [];
+ 		| Ppat_type li ->
+ 			(*line indent ppf "PPat_type";*)
+ 			parenGroup (precVal(PREC_SHARP) < precVal(prec) || parentPrec == PREC_SHARP)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						text "#" ^|
+ 						(fmt_longident li)
+ 						:: [];
+ 					)
+ 				)
+ 			:: [];
+ 	)))
+ 
+ and expression prec parentPrec x =
+ (*  line i indet ppf "expression %a\n" fmt_location x.pexp_loc; *)
+ 	let willnest = (match x.pexp_desc with
+ 		| Pexp_let(_,_,_) when (prec == PREC_IN && parentPrec == PREC_IN) -> identity
+ 		| Pexp_sequence(_,_) -> identity
+ 		| _ -> nest) in
+ 	group ( willnest ( (*doclist_2_doc*) (
+ 		(match x.pexp_desc with
+ 		| Pexp_ident (li) -> fmt_longident li;
+ 		| Pexp_constant (c) -> fmt_constant c;
+ 		| Pexp_let (rf, l, e) ->
+ 			parenGroup (precVal(PREC_LET) < precVal(prec) || parentPrec == PREC_LET)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						let a,b,c = list2_boxlist_x_boxlistlist_x_boxlist let_def let_def_no_lead PREC_NOPAREN PREC_NOPAREN l in
+ 						doclist_2_doc (
+ 							text "let" ^|
+ 							(fmt_rec_flag rf) ^|
+ 							a ^^|
+ 							(match c with [] -> [] | _ -> [text "in"])
+ 						) ^|
+ 						(flatten b) ^^|
+ 						(*
+ 						text "let" ::
+ 						(fmt_rec_flag rf) ::
+ 						(list2 pattern_x_expression_def pattern_x_expression_def_no_lead PREC_NONE PREC_NONE l) ::
+ 						*)
+ 						(match c with
+ 							| [] ->
+ 								doclist_2_doc (
+ 									c ^^|
+ 									text "in"
+ 									:: []
+ 								)
+ 							| _ -> empty
+ 						) ^|
+ 						let willnest = (match e.pexp_desc with
+ 							| Pexp_let(_,_,_) -> identity
+ 							| _ -> nest) in
+ 						group ( willnest (
+ 							(expression PREC_IN PREC_IN e)
+ 						))
+ 						::[]
+ 					)
+ 				)
+ 		| Pexp_function (p, eo, l) ->
+ 			parenGroup (precVal(PREC_FUNCTION) < precVal(prec) && parentPrec != PREC_FUNCTION && parentPrec != PREC_FUN)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						(*line i indet ppf "Pexp_function \"%s\"\n" p;*)
+ 						let (a, b, c) = (print_function prec parentPrec (p, eo, l)) in
+ 						(match c with
+ 							| DocNil	(*function *)	-> a ^| b ^^| (align 2 c) :: []
+ 							| _ 		(*fun*)		-> a ^| b ^^| c :: []
+ 						)
+ 					)
+ 				)
+ 		| Pexp_apply (e, l) ->
+             let sourceFromLoc loc =
+               try 
+                 let ic = open_in loc.loc_start.pos_fname in
+                 let n = (loc.loc_end.pos_cnum - loc.loc_start.pos_cnum) in 
+                 let src = String.create n in 
+                 seek_in ic (loc.loc_start.pos_cnum); 
+                 Pervasives.really_input ic src 0 n;
+                 close_in ic;
+                 src
+               with _ -> "" in
+ 			(match (e.pexp_desc, l) with
+ 				| (Pexp_ident(idRaise), ((_, {pexp_desc = Pexp_construct(idExn, o, b); pexp_loc = _}) :: _)) when (!hideExns && idRaise = Longident.parse "Pervasives.raise" && (String.sub (longidentToStr idExn) 0 8) = "SEMINAL_") ->
+                     let eloc = {loc_start = {e.pexp_loc.loc_start with pos_fname = x.pexp_loc.loc_start.pos_fname};
+                                 loc_end = {e.pexp_loc.loc_end with pos_fname = x.pexp_loc.loc_end.pos_fname};
+                                 loc_ghost = e.pexp_loc.loc_ghost} in
+                     let str = sourceFromLoc eloc in
+ 					(*if (is_infix str) then
+ 					  text "[[infix-op]]"
+                     else*)
+                     if (String.length (longidentToStr idExn) > 15 && (String.sub (longidentToStr idExn) 0 15) = "SEMINAL_ELIDED_") then
+                       text "[[...other program...]]"
+                     else
+                       text "[[...]]"
+ 				| _ -> (* INFIX-ness *)
+ 				begin group (
+ 					(*line i ppf "(";*)
+ 					let expToStr e = boxToStr (expression PREC_NOPAREN PREC_NOPAREN e) in
+ 					let str = expToStr e in
+ 					let eprec = strToPrec str in
+                     let eloc = {loc_start = {e.pexp_loc.loc_start with pos_fname = x.pexp_loc.loc_start.pos_fname};
+                                 loc_end = {e.pexp_loc.loc_end with pos_fname = x.pexp_loc.loc_end.pos_fname};
+                                 loc_ghost = e.pexp_loc.loc_ghost} in
+                     let str = sourceFromLoc eloc in
+                     let str = if str.[0] = '(' then String.sub str 1 ((String.length str)-2) else str in
+ 					if (is_infix str) then
+ 						begin
+ 							(*print ppf "INFIX ";*)
+ 							match l with
+ 								| (_,a1)::(_,a2)::[] ->	(* two args *)
+ 									begin
+ 										(*print ppf " [[pv: %d" (precVal prec);
+ 										print ppf " epv: %d]] " (precVal eprec);*)
+ 										(* infix is diff, we need to compare the function, not the other way around *)
+ 										parenGroup (precVal(eprec) < precVal(prec) || (parentPrec == eprec))
+ 											(
+ 											(*binop
+ 												(expression eprec eprec a1)
+ 												(expression eprec eprec e)
+ 												(expression eprec eprec a2)
+ 											*)
+ 												let arg1 = (expression eprec eprec a1) in
+ 												let op   = (expression eprec eprec e) in
+ 												let arg2 = (expression eprec eprec a2) in
+ 												(if (minLength [arg1] < minLength [arg2]) then
+ 													(arg1 +| op) +| arg2
+ 												else
+ 													arg1 +| (op +| arg2)
+ 												)
+ 												(* which grouping ? *)
+ 											)
+ 									end;
+ 								| _ ->						(* <2 args *)
+ 									begin
+ 										parenGroup (precVal(eprec) < precVal(prec) || (parentPrec == eprec))
+ 											(
+ 												doclist_2_doc
+ 												(
+ 													group ( doclist_2_doc (
+ 														text "(" ^|
+ 														(expression eprec eprec e) ^|
+ 														text ")"
+ 														:: []
+ 													)) ^|	(* need spce! *)
+ 													(boxIter (fun (_, a) -> expression eprec eprec a) l)
+ 													:: []
+ 												)
+ 											)
+ 									end;
+ 						end
+ 					else
+ 						begin
+ 							parenGroupAlways (true)
+ 								(
+ 									doclist_2_doc
+ 									(
+ 										(*print ppf "PREFIX ";*)
+ 										(expression PREC_NONE PREC_NONE e) ^|
+ 										(*printtuple i label_x_expression ppf l;*)
+ 										(list_sep label_x_expression "" PREC_NONE PREC_NONE l)		(* these are the args *)
+ 										:: []
+ 									)
+ 								)
+ 						end;
+ 					(*print ppf ")";*)
+ 				) end
+ 			)
+ 		| Pexp_match (e, l) ->
+ 			(*line i indet ppf "Pexp_match\n";*)
+ 			(*hardbreak ^^ *)
+ 			(parenGroupAlways true 		(* always parenthesize match statements *)
+ 				(align 4 ( (* 2x nest 2 *)
+ 					group (
+ 						text "match" +|
+ 						(expression PREC_WITH PREC_WITH e) +|
+ 						text "with"
+ 					) +|
+ 					group ( (*nest*) (		(* nesting done by align *)
+ 						hardbreak ^^ (boxIter2 (pattern_x_expression_case_match PREC_WITH PREC_WITH) l)
+ 					))
+ 				))
+ 			)
+ 		| Pexp_try (e, l) ->
+ 			(*hardbreak ^^ *)
+ 			(parenGroupAlways true
+ 				(align 4 ( (* 2x nest 2 *)
+ 					group (
+ 						text "try" +|		(* always parenthesize try statements *)
+ 						(expression PREC_WITH PREC_WITH e) +|
+ 						text "with"
+ 					) +|
+ 					group ( (*nest*) (		(* nesting done by align *)
+ 						 hardbreak ^^ (boxIter2 (pattern_x_expression_case_match PREC_WITH PREC_WITH) l)
+ 					))
+ 				))
+ 			)
+ 		| Pexp_tuple (l) ->
+ 			(*print ppf "TUPLE ";*)
+ 			(printtuple expression prec parentPrec l)
+ 		| Pexp_construct (li, eo, b) ->
+ 			(match li with
+ 				| Longident.Lident ("::") -> ((*print ppf "LIST "; *)exp_printlist expression prec parentPrec eo);
+ 				| _ -> (match eo with
+ 							| None -> fmt_longident li;
+ 							| Some ex -> group
+ 								(
+ 									doclist_2_doc
+ 									(
+ 										text "(" ^~
+ 										((fmt_longident li) ^|
+ 										(expression PREC_NOPAREN PREC_NOPAREN ex) :: []) ^^~
+ 										text ")"
+ 										:: []
+ 									)
+ 								)
+ 						);
+ 			)
+ 		| Pexp_variant (l, eo) ->
+ 			(*line i indet ppf "Pexp_variant\n";*)
+ 			parenGroup (precVal(PREC_BACKQUOTE) < precVal(prec) || parentPrec == PREC_BACKQUOTE)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						(text "`" ^^ text l) ^|
+ 						(match eo with
+ 							| None -> empty;
+ 							| Some ex -> (expression PREC_NOPAREN PREC_NOPAREN ex);
+ 						)
+ 						:: []
+ 					)
+ 				)
+ 		| Pexp_record (l, eo) ->
+ 			(*line i indet ppf "Pexp_record\n";*)
+ 			parenGroup (precVal(PREC_LBRACE) < precVal(prec) || parentPrec == PREC_LBRACE)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						text "{" ^|
+ 						(match eo with
+ 							| Some ex -> 
+ 								begin
+ 									(expression PREC_WITH PREC_WITH ex) ^|
+ 									text "with" ^|
+ 									(list2 longident_x_expression_no_lead longident_x_expression PREC_WITH PREC_WITH l)
+ 									:: []
+ 								end
+ 							| _ -> 
+ 									(list2 longident_x_expression_no_lead longident_x_expression PREC_NOPAREN PREC_NOPAREN l)
+ 									:: []
+ 						) ^^|
+ 						text "}"
+ 						:: []
+ 					)
+ 				)
+ 		| Pexp_field (e, li) ->
+ 			(*line i indet ppf "Pexp_field\n";*)
+ 			parenGroup (precVal(PREC_DOT) < precVal(prec) || parentPrec == PREC_DOT)
+ 				(
+ 					(*binop
+ 						(expression PREC_DOT PREC_DOT e)
+ 						(text ".")
+ 						(fmt_longident li)
+ 					*)
+ 					(expression PREC_DOT PREC_DOT e) ^^
+ 					(text ".") ^^
+ 					(fmt_longident li)
+ 				)
+ 		| Pexp_setfield (e1, li, e2) ->
+ 			(*line i indet ppf "Pexp_setfield\n";*)
+ 			parenGroup (precVal(PREC_LESSMINUS) < precVal(prec) || parentPrec == PREC_LESSMINUS)	(* PREC_DOT? *)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						((expression PREC_DOT PREC_DOT e1) ^^ text
+ 						"." ^^
+ 						(longident li)) ^|
+ 						text "<-" ^|
+ 						(expression PREC_LESSMINUS PREC_LESSMINUS e2)
+ 						:: []
+ 					)
+ 				)
+ 		| Pexp_array (l) ->
+ 			(*line i indet ppf "Pexp_array\n";*)
+ 			parenGroup (precVal(PREC_LBRACKETBAR) < precVal(prec) || parentPrec == PREC_LBRACKETBAR)
+ 				(
+ 					group ( nest ( doclist_2_doc (
+ 						text "[|" ^|
+ 						(list_sep expression ";" PREC_SEMI PREC_SEMI l) ^|
+ 						text "|]"
+ 						:: []
+ 					)))
+ 				)
+ 		| Pexp_ifthenelse (e1, e2, eo) ->
+ 			(*line i indet ppf "Pexp_ifthenelse\n";*)
+ 			parenGroupAlways true
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						text "if" ^|
+ 						(expression PREC_THEN PREC_THEN e1) ^|
+ 						text "then" ^|
+ 						(expression PREC_THEN PREC_THEN e2) ^|
+ 						(match eo with
+ 							| None -> [empty];
+ 							| Some ex -> begin
+ 									text "else" ^|
+ 									(expression PREC_ELSE PREC_ELSE ex)
+ 									:: []
+ 							end
+ 						)
+ 					)
+ 				)
+ 		| Pexp_sequence (e1, e2) ->
+ 			(*line i indet ppf "Pexp_sequence\n";*)
+ 			parenGroup (precVal(PREC_SEMI) < precVal(prec)) (* || parentPrec == PREC_SEMI)*)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						group (
+ 							(expression PREC_SEMI PREC_SEMI e1) ^^
+ 							text ";"
+ 						) ^|
+ 						(expression PREC_SEMI PREC_SEMI e2)
+ 						:: []
+ 					)
+ 				)
+ 		| Pexp_while (e1, e2) ->
+ 			(*line i indet ppf "Pexp_while\n";*)
+ 			(*parenGroup (precVal(PREC_SEMI || parentPrec == PREC_SEMI) < precVal(prec) *)
+ 			group
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						group ( nest ( doclist_2_doc (
+ 							text "while" ^|
+ 							(expression PREC_SEMI PREC_SEMI e1) (* PREC_SEMI or PREC_NONE ? *)
+ 							:: []
+ 						))) ^|
+ 						group ( nest ( doclist_2_doc (
+ 							text "do" ^|
+ 							(expression PREC_SEMI PREC_SEMI e2)
+ 							:: []
+ 						))) ^|
+ 						text "done"
+ 						:: []
+ 					)
+ 				)
+ 		| Pexp_for (s, e1, e2, df, e3) ->
+ 			(*line indent ppf "Pexp_for \"%s\" %a\n" s fmt_direction_flag df;*)
+ 			(*parenGroup ((precVal(PREC_SEMI || parentPrec == PREC_SEMI) < precVal(prec))*)
+ 			group
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						(*
+ 						text "for" ::
+ 						text s ::
+ 						text "=" ::
+ 						(expression PREC_EQUAL PREC_EQUAL e1) ::
+ 						(fmt_direction_flag df) ::
+ 						(expression PREC_SEMI PREC_SEMI e2) :: (* ?? *)
+ 						text "do" ::
+ 						group ( nest (
+ 							(expression PREC_SEMI PREC_SEMI e3)
+ 						)) ::
+ 						text "done"
+ 						:: []
+ 						*)
+ 						group ( nest ( doclist_2_doc (
+ 							text "for" ^|
+ 							text s ^|
+ 							text "=" ^|
+ 							(expression PREC_EQUAL PREC_EQUAL e1) ^|
+ 							(fmt_direction_flag df)
+ 							:: []
+ 						))) ^|
+ 						group ( nest ( doclist_2_doc (
+ 							(expression PREC_SEMI PREC_SEMI e2) ^| (* ?? *)
+ 							text "do"
+ 							:: []
+ 						))) ^|
+ 						group ( nest ( doclist_2_doc (
+ 							(expression PREC_SEMI PREC_SEMI e3)
+ 							:: []
+ 						))) ^|
+ 						text "done"
+ 						:: []
+ 					)
+ 				)
+ 		| Pexp_constraint (e, cto1, cto2) ->
+ 			(**line i indet ppf "Pexp_constraint\n";*)
+ 			parenGroupAlways (precVal(PREC_NONE) < precVal(prec) || parentPrec == PREC_NONE)
+ 				(
+ 					doclist_2_doc
+ 					(
+ (*						parenGroup (precVal(PREC_NOPAREN) < precVal(prec) || parentPrec == PREC_NOPAREN)		(* PREC_COLON *)
+ *)							(
+ 								(expression PREC_NOPAREN PREC_NOPAREN e)
+ 							) ^|
+ 						group ( nest ( doclist_2_doc (
+ 							text ":" ^|
+ 							(match cto1 with
+ 								None -> begin
+ 										match cto2 with
+ 											| None -> []
+ 											| Some ctx3 -> (text ">" ^| (core_type PREC_NOPAREN PREC_NOPAREN ctx3) :: [])
+ 									end
+ 								| Some ctx1 -> begin
+ 										(core_type PREC_NOPAREN PREC_NOPAREN ctx1) ^|
+ 										(match cto2 with
+ 											| None -> []
+ 											| Some ctx2 -> (text ":>" ^| (core_type PREC_NOPAREN PREC_NOPAREN ctx2) :: [])
+ 										)
+ 									end
+ 							)
+ 						)))
+ 						:: []
+ 					)
+ 				)
+ 		| Pexp_when (e1, e2) ->
+ 			(*line indent ppf "Pexp_when\n";*)
+ 			parenGroup (precVal(PREC_ARROW) < precVal(prec) || parentPrec == PREC_ARROW)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						group ( nest ( doclist_2_doc (
+ 							text "when" ^|
+ 							(expression PREC_ARROW PREC_ARROW e1)
+ 							:: []
+ 						))) ^|
+ 						text "->" ^|
+ 						nest (expression PREC_ARROW PREC_ARROW e2)
+ 						:: []
+ 					)
+ 				)
+ 		| Pexp_send (e, s) ->
+ 			(*line indent ppf "Pexp_send \"%s\"\n" s;*)
+ 			parenGroup (precVal(PREC_SHARP) < precVal(prec) || parentPrec == PREC_SHARP)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						((expression PREC_SHARP PREC_SHARP e) ^^ text "#") ^|
+ 						text s
+ 						:: []
+ 					)
+ 				)
+ 		| Pexp_new (li) -> text "new" +| (fmt_longident li);
+ 		| Pexp_setinstvar (s, e) ->
+ 			(*line indent ppf "Pexp_setinstvar \"%s\"\n" s;*)
+ 			parenGroup (precVal(PREC_ARROW) < precVal(prec) || parentPrec == PREC_ARROW)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						text s ^|
+ 						text "<-" ^|
+ 						(expression PREC_ARROW PREC_ARROW e)
+ 						:: []
+ 					)
+ 				)
+ 		| Pexp_override (l) ->
+ 			(*line indent ppf "Pexp_override\n";*)
+ 			parenGroup (precVal(PREC_LESS) < precVal(prec) || parentPrec == PREC_LESS)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						text "<" ^|
+ 						(boxIter (fun x -> (string_x_expression PREC_SEMI PREC_SEMI x) ^^ text ";") l) ^|
+ 						text ">"
+ 						:: []
+ 					)
+ 				)
+ 		| Pexp_letmodule (s, me, e) ->
+ 			(*line indent ppf "Pexp_letmodule \"%s\"\n" s;*)
+ 			parenGroup (precVal(PREC_LET) < precVal(prec) || parentPrec == PREC_LET)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						text "let" ^|
+ 						text "module" ^|
+ 						text s ^|
+ 						group ( nest (
+ 							(module_expr (*PREC_IN PREC_IN *)me)
+ 						)) ^|
+ 						text "in" ^|
+ 						group ( nest (
+ 							(expression PREC_IN PREC_IN e)
+ 						))
+ 						:: []
+ 					)
+ 				)
+ 		| Pexp_assert (e) ->
+ 			(*line indent ppf "Pexp_assert";*)
+ 			(*text "assert" +|*)
+ 			expression prec parentPrec e
+ 		| Pexp_assertfalse ->
+ 			(*line indent ppf "Pexp_assertfalse";*)
+ 			empty
+ 		| Pexp_lazy (e) ->
+ 			(*line indent ppf "Pexp_lazy";*)
+ 			parenGroup (precVal(PREC_below_SHARP) < precVal(prec) || parentPrec == PREC_below_SHARP)
+ 				(
+ 					doclist_2_doc
+ 					(
+ 						text "lazy" ^|
+ 						(expression PREC_below_SHARP PREC_below_SHARP e)
+ 						:: []
+ 					)
+ 				)
+ 		| Pexp_poly (e, cto) ->
+ 			(*line indent ppf "Pexp_poly\n";*)
+ 			doclist_2_doc
+ 			(
+ 				(*text "poly" ::*)
+ 				(expression PREC_NOPAREN PREC_NOPAREN e) ^|
+ 				(option core_type cto)
+ 				:: []
+ 			)
+ 		| Pexp_object s ->
+ 			doclist_2_doc
+ 			(
+ 				(*line indent ppf "Pexp_object";*)
+ 				text "object" ^|
+ 				group ( nest ( doclist_2_doc (
+ 					(class_structure PREC_NOPAREN PREC_NOPAREN s)
+ 					:: []
+ 				))) ^|
+ 				text "end"
+ 				:: []
+ 			)
+ 		)
+ 	)))
+ 
+ and value_description prec parentPrec x =
+ 	(*line i indet ppf "value_description\n";*)
+ 	parenGroup (precVal(PREC_EQUAL) < precVal(prec) || parentPrec == PREC_EQUAL)
+ 		(
+ 			doclist_2_doc
+ 			(
+ 				(core_type PREC_EQUAL PREC_EQUAL x.pval_type) ^|
+ 				text "=" ^|
+ 				(boxIter text x.pval_prim)
+ 				:: []
+ 			)
+ 		)
+ 
+ and exception_declaration x =
+ 	match x with
+ 		| [] -> empty;
+ 		| _ -> group ( nest ( doclist_2_doc (
+ 				text "of" ^|
+ 				(list_sep core_type "of" PREC_NOPAREN PREC_NOPAREN x)
+ 				:: []
+ 			)))
+ 	;
+ 
+ and class_type prec parentPrec x =
+ (*	line indent ppf "class_type %a\n" fmt_location x.pcty_loc;*)
+ 	group ( nest ( doclist_2_doc (
+ 		match x.pcty_desc with
+ 		| Pcty_constr (li, l) ->
+ 			(*line indent ppf "Pcty_constr %a\n" fmt_longident li;*)
+ 			(match l with
+ 				| [] -> empty
+ 				| _ -> group ( nest ( doclist_2_doc (
+ 						text "[" ^|
+ 						(list_sep core_type "," PREC_COMMA PREC_COMMA l) ^|
+ 						text "]"
+ 						:: []
+ 					)))
+ 			) ::
+ 			(fmt_longident li)
+ 			:: []
+ 		| Pcty_signature (cs) ->
+ 			(*line indent ppf "Pcty_signature\n";*)
+ 			text "object" ^|
+ 			group ( nest ( doclist_2_doc (
+ 				(class_signature PREC_NOPAREN PREC_NOPAREN cs)
+ 				:: []
+ 			))) ^|
+ 			text "end"
+ 			:: []
+ 		| Pcty_fun (l, co, cl) ->
+ 			(*line indent ppf "Pcty_fun \"%s\"\n" l;*)
+ 			(*text "+++++++++++++++++++ Pcty_fun - unsure +++++++++++++++++++" ^|*)
+ 			(if (l != "") then
+ 				let str = String.sub l 1 (String.length l - 2) in
+ 				text str ^|
+ 				text ":"
+ 				:: []
+ 			else
+ 				[]) ^^|
+ 			(core_type prec parentPrec co) ^|
+ 			text "->" ^|
+ 			(class_type PREC_NONE PREC_NONE cl)
+ 			:: []
+ 	)))
+ 
+ and class_signature prec parentPrec (ct, l) =
+ (* aka class_sig_body *)
+ 	(*line indent ppf "class_signature\n";*)
+ 	group ( nest ( doclist_2_doc (
+ 		(core_type prec parentPrec ct) ^|
+ 		(boxIter (class_type_field prec parentPrec) l)
+ 		:: []
+ 	)))
+ 	
+ and class_sig_fields prec parentPrec x =
+ 	match x with
+ 		| [] -> []
+ 		| hd::tl ->
+ 			(class_type_field prec parentPrec hd) ^|
+ 			(class_sig_fields prec parentPrec tl)
+ 
+ and class_type_field prec parentPrec x =
+ 	group ( nest ( doclist_2_doc (
+ 		match x with
+ 			| Pctf_inher (ct) ->
+ 				(*line indent ppf "Pctf_inher\n";*)
+ 				text "inherit" ^|
+ 				class_type prec parentPrec ct
+ 				:: []
+ 			| Pctf_val (s, mf, cto, loc) ->
+ 				(*(text "{{Pctf_val \"" ^^*)
+ 				text "val" ^|
+ 				(fmt_mutable_flag mf) ^|
+ 				text s ^|
+ 				text ":" ^|
+ 				(option core_type cto)
+ 				:: []
+ 			| Pctf_virt (s, pf, ct, loc) ->
+ 				(*(text "{{Pctf_virt \"" ^^*)
+ 				text "method" ^|
+ 				(fmt_private_flag pf) ^|
+ 				text "virtual" ^|
+ 				text s ^|
+ 				text ":" ^|
+ 				(core_type PREC_NOPAREN PREC_NOPAREN ct)
+ 				:: []
+ 			| Pctf_meth (s, pf, ct, loc) ->
+ 				(*(text "{{Pctf_meth \"" ^^*)
+ 				text "method" ^|
+ 				(fmt_private_flag pf) ^|
+ 				text s ^|
+ 				text ":" ^|
+ 				(core_type PREC_NOPAREN PREC_NOPAREN ct)
+ 				:: []
+ 			| Pctf_cstr (ct1, ct2, loc) ->
+ 				(*text "{{Pctf_cstr \n" ^|*)
+ 				text "constraint" ^|
+ 				(core_type PREC_NOPAREN PREC_NOPAREN ct1) ^| (* PREC_EQUALS ?*)
+ 				text "=" ^|
+ 				(core_type PREC_NOPAREN PREC_NOPAREN ct2) (* PREC_EQUALS ?*)
+ 				:: []
+ 	)))
+ 
+ and class_description prec parentPrec (x:Parsetree.class_description) =
+ 	group ( nest ( doclist_2_doc (
+ 		(fmt_virtual_flag x.pci_virt) ^|
+ 		let param_x_var = (List.combine (fst x.pci_params) x.pci_variance) in
+ 		(class_type_parameters PREC_NONE PREC_NONE param_x_var) ^^|
+ 		text x.pci_name ^|
+ 		text ":" ^|
+ 		(match x.pci_expr.pcty_desc with (*the class_fun_binding doesn't print an equal, so if we need one, print it*)
+ 			| Pcty_fun(_, _, _) -> empty;
+ 			| _ -> text "="
+ 		) ^|
+ 		group ( nest ( doclist_2_doc (
+ 			(class_type PREC_EQUAL PREC_EQUAL x.pci_expr)
+ 			:: []
+ 		)))
+ 		:: []
+ 	)))
+ 	
+ and class_type_parameters prec parentPrec x =
+ 	match x with
+ 		| [] -> [];
+ 		| _ -> 
+ 			text "[" ^|
+ 			(type_parameter_list PREC_LBRACKET PREC_LBRACKET x) ^|
+ 			text "]"
+ 			:: []
+ 
+ and class_type_declaration prec parentPrec (x:Parsetree.class_type_declaration) =
+ 	group ( nest ( doclist_2_doc (
+ 		(fmt_virtual_flag x.pci_virt) ^|
+ 		let param_x_var = List.combine (fst x.pci_params) x.pci_variance in
+ 		(class_type_parameters PREC_NONE PREC_NONE param_x_var) ^^|
+ 		text x.pci_name ^|
+ 		(match x.pci_expr.pcty_desc with (*the class_fun_binding doesn't print an equal, so if we need one, print it*)
+ 			| Pcty_fun(_, _, _) -> empty;
+ 			| _ -> text "="
+ 		) ^|
+ 		group ( nest ( doclist_2_doc (
+ 			(class_type PREC_EQUAL PREC_EQUAL x.pci_expr)
+ 			:: []
+ 		)))
+ 		:: []
+ 	)))
+   (*
+   line indent ppf "class_type_declaration %a\n" fmt_location x.pci_loc;
+   let indent = indent+1 in
+   line indent ppf "pci_virt = %a\n" fmt_virtual_flag x.pci_virt;
+   line indent ppf "pci_params =\n";
+   string_list_x_location (indent+1) (indent+1) ppf PREC_NOPAREN PREC_NOPAREN x.pci_params;
+   line indent ppf "pci_name = \"%s\"\n" x.pci_name;
+   line indent ppf "pci_expr =\n";
+   class_type (indent+1) (indent+1) ppf prec parentPrec x.pci_expr;
+   *)
+ 
+ and labeled_simple_pattern prec parentPrec (l, eo, p) =
+ 	let fmt_longident = text in
+ 	let longidentToStr = identity in
+ 	group ( nest ( doclist_2_doc (
+ 		(match p.ppat_desc with
+ 			| Ppat_var (v) -> (* label_var *)
+ 				text "~" ^~
+ 				(fmt_longident l) ^|
+ 				(pattern PREC_NONE PREC_NONE p)
+ 				:: []
+ 			| Ppat_constraint (_, _) -> (* label_let_pattern *)
+ 				text "~(" ^~
+ 				(fmt_longident l) ^|
+ 				text ":" ^|
+ 				(pattern PREC_NONE PREC_NONE p) ^|
+ 				(match eo with
+ 					| None -> [empty]
+ 					| Some ex -> text "=" ^|
+ 						(expression PREC_EQUAL PREC_EQUAL ex)
+ 						:: []
+ 				) ^^~
+ 				text ")"
+ 				:: []
+ 			| _ -> (* simple_patern *)
+ 				(if ((longidentToStr l) == "") then
+ 					(pattern PREC_NONE PREC_NONE p)
+ 					:: []
+ 				else
+ 					text "label" ^|
+ 					(pattern PREC_NONE PREC_NONE p)
+ 					:: []
+ 				)
+ 		)
+ 	)))
+ 
+ and class_expr prec parentPrec x =
+ (*	line "class_expr %a\n" fmt_location x.pcl_loc;*)
+ 	group ( nest ( doclist_2_doc (
+ 		(match x.pcl_desc with
+ 			| Pcl_constr (li, l) ->
+ 				(match l with
+ 					| [] -> empty
+ 					| _ -> group ( nest ( doclist_2_doc (
+ 							text "[" ^|
+ 							(list_comma core_type l) ^|
+ 							text "]"
+ 							:: []
+ 						)))
+ 				) ::
+ 				(fmt_longident li)
+ 				:: []
+ 			| Pcl_structure (cs) ->
+ 				text "object" ^|
+ 				group ( nest ( doclist_2_doc (
+ 					(class_structure prec parentPrec cs)
+ 					:: []
+ 				)))
+ 				:: []
+ 			| Pcl_fun (l, eo, p, e) ->
+ 				(labeled_simple_pattern PREC_NONE PREC_NONE (l, eo, p)) ::
+ 				(class_fun_binding PREC_NONE PREC_NONE e)
+ 				(*:: []*)
+ 			| Pcl_apply (ce, l) ->
+ 				(class_expr prec parentPrec ce) ^|
+ 				(boxIter (label_x_expression PREC_NONE PREC_NONE) l)
+ 				:: []
+ 			| Pcl_let (rf, l, ce) ->
+ 				text "let" ^|
+ 				(fmt_rec_flag rf) ^|
+ 				(list2 pattern_x_expression_def pattern_x_expression_def_no_lead PREC_NONE PREC_NONE l) ^|
+ 				text "in" ^|
+ 				(class_expr prec parentPrec ce)
+ 				:: []
+ 			| Pcl_constraint (ce, ct) ->
+ 				text ":" ^|
+ 				(class_type prec parentPrec ct) ^|
+ 				text "=" ^|
+ 				(class_expr prec parentPrec ce)
+ 				:: []
+ 		)
+ 	)))
+ 
+ and class_structure prec parentPrec (p, l) =
+ (*	text "{{ class_structure }}"*)
+ 	group ( nest ( doclist_2_doc (
+ 		text "(" ^|
+ 		group ( nest ( doclist_2_doc (
+ 			(pattern PREC_NOPAREN PREC_NOPAREN p)
+ 			:: []
+ 		))) ^|
+ 		group ( nest ( doclist_2_doc (
+ 			(boxIter (class_field PREC_NOPAREN PREC_NOPAREN) l)
+ 			:: []
+ 		))) ^|
+ 		text ")"
+ 		:: []
+ 	)))
+ 
+ and class_field prec parentPrec x =
+ 	group ( nest ( doclist_2_doc (
+ 		match x with
+ 			| Pcf_inher (ce, so) ->
+ 				text "inherit" ^|
+ 				(class_expr prec parentPrec ce) ^|
+ 				(match so with
+ 					| None -> [empty];
+ 					| Some sx -> text "as" ^| text sx :: [];
+ 				)
+ 			| Pcf_val (s, mf, e, loc) ->
+ 				text "val" ^|
+ 				(fmt_mutable_flag mf) ^|
+ 				text s ^|
+ 				(match e.pexp_desc with
+ 					| Pexp_constraint(seq, t, t') ->
+ 						(type_constraint PREC_EQUAL PREC_EQUAL (t, t')) ^|
+ 						text "=" ^|
+ 						(expression PREC_EQUAL PREC_EQUAL seq)
+ 						:: []
+ 					| _ ->
+ 						text "=" ^|
+ 						(expression PREC_EQUAL PREC_EQUAL e)
+ 						:: []
+ 				)
+ 			| Pcf_virt (s, pf, ct, loc) ->
+ 				text "method" ^|
+ 				(fmt_private_flag pf) ^|
+ 				text "virtual" ^|
+ 				text s ^|
+ 				text ":" ^|
+ 				(core_type prec parentPrec ct)
+ 				:: []
+ 			| Pcf_meth (s, pf, e, loc) ->
+ 				text "method" ^|
+ 				(fmt_private_flag pf) ^|
+ 				text s ^|
+ 				(* "" || ":" || "=" *)
+ 				(expression PREC_NOPAREN PREC_NOPAREN e)
+ 				:: []
+ 			| Pcf_cstr (ct1, ct2, loc) ->
+ 				text "constraint" ^|
+ 				constrain PREC_NOPAREN PREC_NOPAREN (ct1, ct2, loc)
+ 				:: []
+ 			| Pcf_let (rf, l, loc) ->
+ 				text "******************* ERROR - Pcf_let not in grammer *******************"
+ 				(* :: (list2 pattern_x_expression_def pattern_x_expression_def_no_lead l)*)
+ 				:: []
+ 			| Pcf_init (e) ->
+ 				(*line i indet ppf "Pcf_init\n";*)
+ 				text "initializer" ^|
+ 				(expression prec parentPrec e)
+ 				:: []
+ 	)))
+ 
+ and type_constraint prec parentPrec (t, t') =
+ 	group ( nest ( doclist_2_doc (
+ 		(match t with
+ 			| None -> [empty];
+ 			| Some t1 -> text ":" ^| (core_type PREC_NOPAREN PREC_NOPAREN t1) :: [];
+ 		) ^^|
+ 		(match t' with
+ 			| None -> [empty];
+ 			| Some t2 -> text ":>" ^| (core_type PREC_NOPAREN PREC_NOPAREN t2) :: [];
+ 		)
+ 		@ []
+ 	)))
+ 
+ and class_fun_binding prec parentPrec x =
+ 	(match x.pcl_desc with (*the class_fun_binding doesn't print an equal, so if we need one, print it*)
+ 		| Pcl_constraint(_, _)
+ 		| Pcl_fun(_, _, _, _) -> empty;
+ 		| _ -> text "="
+ 	) ^|
+ 	group ( nest ( doclist_2_doc (
+ 		(class_expr PREC_EQUAL PREC_EQUAL x)
+ 		:: []
+ 	)))
+ 	:: []
+ 		
+ and class_declaration prec parentPrec x =
+ 	group ( nest ( doclist_2_doc (
+ 		(fmt_virtual_flag x.pci_virt) ^|
+ 		let param_x_var = List.combine (fst x.pci_params) x.pci_variance in
+ 		(class_type_parameters PREC_NONE PREC_NONE param_x_var) ^^|
+ 		text x.pci_name ^|
+ 		(class_fun_binding PREC_NONE PREC_NONE x.pci_expr)
+   (*
+   line i indet ppf "class_declaration %a\n" fmt_location x.pci_loc;
+   let i = i+1 in
+   line i indet ppf "pci_virt = %a\n" fmt_virtual_flag x.pci_virt;
+   line i indet ppf "pci_params =\n";
+   string_list_x_location (i+1) ppf x.pci_params;
+   line i indet ppf "pci_name = \"%s\"\n" x.pci_name;
+   line i indet ppf "pci_expr =\n";
+   class_expr (i+1) ppf x.pci_expr;
+   *)
+ 	)))
+ 	
+ and type_parameter_list prec parentPrec x =
+ 	doclist_2_doc
+ 	(
+ 		(list_sep_boxlist type_parameter "," PREC_NONE PREC_NONE x)
+ 	)
+ 	(*list_comma type_parameter x*)
+ 
+ (*and type_parameter prec parentPrec (id, var) =
+ 	(fmt_variance var) ::
+ 	text "\'" :: text id*)
+ 
+ and module_type x =
+ (*	line indent ppf "module_type %a\n" fmt_location x.pmty_loc;*)
+ 	group ( nest ( doclist_2_doc (
+ 		(match x.pmty_desc with
+ 			| Pmty_ident (li) -> (*line i indet ppf "Pmty_ident %a\n" fmt_longident li;*)
+ 				(fmt_longident li)
+ 				:: []
+ 			| Pmty_signature (s) ->
+ 				text "sig" ^|
+ 				group ( nest ( doclist_2_doc (
+ 					(signature s)
+ 					:: []
+ 				))) ^|
+ 				text "end"
+ 				:: []
+ 			| Pmty_functor (s, mt1, mt2) ->
+ 				(*line indent ppf "Pmty_functor \"%s\"\n" s;*)
+ 				text "functor" ^|
+ 				text "(" ^~
+ 				(text s ^^ text ":") ^|
+ 				(module_type mt1) ^~
+ 				text ")" ^|
+ 				text "->" ^|
+ 				(module_type mt2)
+ 	  (* line i indet ppf "---------------------------- OR ----------------------------";
+ 	  line i indet ppf "(%s:" s;
+       module_type 0 ppf mt1;
+ 	  print ppf ")"; (* handled in psig_,module *)*)
+ 				:: []
+ 			| Pmty_with (mt, l) ->
+ 				(*line i indet ppf "Pmty_with\n";*)
+ 				(module_type mt) ^|
+ 				text "with" ^|
+ 				group ( nest ( doclist_2_doc (
+ 					(list_sep longident_x_with_constraint "and" PREC_AND PREC_AND l)
+ 					:: []
+ 				)))
+ 				:: []
+ 		)
+ 	)))
+ 
+ and signature x = 
+ 	group ( nest ( doclist_2_doc (
+ 		(boxIter (signature_item PREC_NOPAREN PREC_NOPAREN) x)
+ 		:: []
+ 	)))
+ 
+ and signature_item unusedPrec unusedPrec2 x =
+ (*	line indent ppf "signature_item %a\n" fmt_location x.psig_loc;*)
+ 	group ( nest ( doclist_2_doc (
+ 		(match x.psig_desc with
+ 			| Psig_value (s, vd) ->
+ 				(*line indent ppf "Psig_value \"%s\"\n" s;*)
+ 				(match vd.pval_prim with
+ 					| [] -> begin
+ 							text "val" ^|
+ 							text s ^|
+ 							(core_type PREC_NOPAREN PREC_NOPAREN vd.pval_type)
+ 							:: []
+ 						end
+ 					| _ -> begin
+ 							text "external" ^|
+ 							text s ^|
+ 							(core_type PREC_NOPAREN PREC_NOPAREN vd.pval_type) ^|
+ 							(boxIter text vd.pval_prim)
+ 							:: []
+ 						end
+ 				)
+ 			| Psig_type (l) ->
+ 				(*text "type" ::
+ 				let (a, b) = list_sep2Tuple string_x_type_declaration "and" PREC_AND PREC_AND l in
+ 				a ::
+ 				b
+ 				:: []*)
+ 				text "type" ^|
+ 				group ( nest ( doclist_2_doc (
+ 					(list_sep_boxlist2 string_x_type_declaration "and" PREC_AND PREC_AND l)
+ 				)))
+ 				:: []
+ 			| Psig_exception (s, ed) ->
+ 				(*line i indet ppf "Psig_exception \"%s\"\n" s;*)
+ 				text "exception" ^|
+ 				text s ^|
+ 				(exception_declaration ed)
+ 				:: []
+ 			| Psig_module (s, mt) ->
+ 				(*line i indet ppf "Psig_module \"%s\"\n" s;*)
+ 				(* it is from here that the functor which is an application is used. so inline its processing *)
+ 				text "module" ^|
+ 				text s ^|
+ 				(module_declaration mt)
+ 				:: []
+ 			| Psig_recmodule decls ->
+ 				(*line i indet ppf "Psig_recmodule\n";*)
+ 				text "module" ^|
+ 				text "rec" ^|
+ 				group ( nest ( doclist_2_doc (
+ 					(list_sep string_x_module_type "and" PREC_AND PREC_AND decls)
+ 					:: []
+ 				)))
+ 				:: []
+ 			| Psig_modtype (s, md) ->
+ 				(*line i indet ppf "Psig_modtype \"%s\"\n" s;*)
+ 				text "module" ^|
+ 				text "type" ^|
+ 				text s ^|
+ 				(modtype_declaration md)
+ 				@ []
+ 			| Psig_open (li) ->
+ 				text "open" ^|
+ 				(fmt_longident li)
+ 				:: []
+ 			| Psig_include (mt) ->
+ 				text "include" ^|
+ 				(module_type mt)
+ 				:: []
+ 			| Psig_class (l) ->
+ 				(*line i indet ppf "Psig_class\n";*)
+ 				text "class" ^|
+ 				group ( nest ( doclist_2_doc (
+ 					(list_sep class_description "and" PREC_AND PREC_AND l)
+ 					:: []
+ 				)))
+ 				:: []
+ 			| Psig_class_type (l) ->
+ 				(*line i indet ppf "Psig_class_type\n";*)
+ 				text "class" ^|
+ 				text "type" ^|
+ 				group ( nest ( doclist_2_doc (
+ 					(list_sep class_type_declaration "and" PREC_AND PREC_AND l)
+ 					:: []
+ 				)))
+ 				:: []
+ 		)
+ 	)))
+ 
+ and module_declaration mt =
+ 	group ( nest ( doclist_2_doc (
+ 		(match mt.pmty_desc with
+ 			|  Pmty_functor (s, mt1, mt2) ->
+ 				text "(" ^~ 
+ 				(text s ^^ text ":") ^|
+ 				(module_type mt1) ^~
+ 				text ")" ^|
+ 				(module_declaration mt2)
+ 				:: []
+ 			| _ ->
+ 				(module_type mt)
+ 				:: []
+ 		)
+ 	)))
+ 
+ and modtype_declaration x =
+ 	match x with
+ 		| Pmodtype_abstract -> [empty];(*line i indet ppf "Pmodtype_abstract\n";*)
+ 		| Pmodtype_manifest (mt) ->
+ 			(*line i indet ppf "Pmodtype_manifest\n";*)
+ 			text "=" ^|
+ 			group ( nest ( doclist_2_doc (
+ 				(module_type mt)
+ 				:: []
+ 			)))
+ 			:: []
+ 
+ and module_expr x =
+ (*	line indent ppf "module_expr %a\n" fmt_location x.pmod_loc;*)
+ 	group ( nest ( doclist_2_doc (
+ 		(match x.pmod_desc with
+ 			| Pmod_ident (li) -> fmt_longident li :: [];
+ 			| Pmod_structure (s) ->
+ 				(*line i indet ppf "Pmod_structure\n";*)
+ 				text "struct" ^|
+ 				group ( nest ( doclist_2_doc (
+ 					(structure s)
+ 					:: []
+ 				))) ^|
+ 				text "end"
+ 				:: []
+ 			| Pmod_functor (s, mt, me) ->
+ 				text "functor" ^|
+ 				text "(" ^~
+ 				(text s ^^ text ":") ^|
+ 				(module_type mt) ^~
+ 				text ")" ^|
+ 				text "->" ^|
+ 				(module_expr me)
+ 				:: []
+ 			| Pmod_apply (me1, me2) ->
+ 				(*line i indet ppf "Pmod_apply\n";*)
+ 				(module_expr me1) ^|
+ 				text "(" ^~
+ 				(module_expr me2) ^~
+ 				text ")"
+ 				:: []
+ 			| Pmod_constraint (me, mt) ->
+ 				text "(" ^~
+ 				(module_expr me) ^|
+ 				text ":" ^|
+ 				(module_type mt) ^~
+ 				text ")"
+ 				:: []
+ 		)
+ 	)))
+ 
+ and structure x = boxIter (structure_item PREC_NOPAREN PREC_NOPAREN) x
+ 
+ and structure_item unusedPrec1 unusedPrec2 x =
+ (*	line i indet ppf "\nstructure_item %a\n" fmt_location x.pstr_loc;*)
+   if (match x.pstr_desc with
+     Pstr_open id -> longidentToStr id = "Seminalprefixtemp"
+   | Pstr_exception (s, _) -> (try (String.sub s 0 8 = "SEMINAL_") with _ -> false)
+   | _ -> false) then empty else
+   group ( (*nest*) ( doclist_2_doc (
+ 		(match x.pstr_desc with
+ 			| Pstr_eval (e) ->
+ 				(*line i indet ppf "Pstr_eval\n";
+ 				line i indet ppf "--------------- ???????????????? ---------------";*)
+ 				group ( nest ( doclist_2_doc (
+ 					(expression PREC_NOPAREN PREC_NOPAREN e)
+ 					:: []
+ 				)))
+ 				^~ text ";; "
+ 				:: []
+ 			| Pstr_value (rf, l) ->
+ 				(*line i indet ppf "Pstr_value\n";
+ 				line i indet ppf "--------------- ???????????????? ---------------";*)
+ 				(*(list2 pattern_x_expression_def pattern_x_expression_def_no_lead PREC_NONE PREC_NONE l) ::*)
+ 				let a,b,c = list2_boxlist_x_boxlistlist_x_boxlist let_def let_def_no_lead PREC_NOPAREN PREC_NOPAREN l in
+ 				doclist_2_doc (
+ 					text "let" ^|
+ 					(fmt_rec_flag rf) ^|
+ 					a
+ 				) ^|
+ 				(flatten b) ^^|
+ 				(*
+ 				text "let" ::
+ 				(fmt_rec_flag rf) ::
+ 				(list2 pattern_x_expression_def pattern_x_expression_def_no_lead PREC_NONE PREC_NONE l) ::
+ 				*)
+ 				c
+ 				(*let tup = list2Tuple pattern_x_expression_def pattern_x_expression_def_no_lead PREC_NOPAREN PREC_NOPAREN l in
+ 				text "let" ::
+ 				(fmt_rec_flag rf) ::
+ 				(fst tup) ::
+ 				(snd tup) ::*)
+ 				(*
+ 				let tup = list2Tuple2 pattern_x_expression_def_2Tuple pattern_x_expression_def_no_lead PREC_NOPAREN PREC_NOPAREN l in
+ 				group ( (*nest*) ( doclist_2_doc (
+ 					 (
+ 						text "let" ::
+ 						(fmt_rec_flag rf) ::
+ 						(fst (fst tup)) ::
+ 						(snd (fst tup))
+ 						:: []
+ 					) @
+ 					(snd tup)
+ 					:: []
+ 				))) ::
+ 				*)
+ 				^^~ text ";; "
+ 				:: []
+ 			| Pstr_primitive (s, vd) ->
+ 				(*line i indet ppf "Pstr_primitive \"%s\"\n" s;*)
+ 				text "external" ^|
+ 				(text s ^^ text ":") ^|
+ 				(value_description PREC_NOPAREN PREC_NOPAREN vd)
+ 				^~ text ";; "
+ 				:: []
+ 			| Pstr_type (l) ->
+ 				(*line i indet ppf "Pstr_type\n";*)
+ 				type_as_list l
+ 				:: []
+ 			| Pstr_exception (s, ed) ->
+ 				(*line i indet ppf "Pstr_exception \"%s\"\n" s;*)
+ 				(text "exception" ^|
+ 				text s ^|
+ 				(match ed with
+ 					| [] -> []
+ 					| _ -> text "of" ^|
+ 						(list_sep_nobinding core_type "*" PREC_STAR PREC_STAR ed)	(*(exception_declaration ed)*)
+ 						:: []
+ 				)
+ 				^^~ text ";; "
+ 				:: [])
+ 			| Pstr_exn_rebind (s, li) ->
+ 				(*line i indet ppf "Pstr_exn_rebind \"%s\" %a\n" s fmt_longident li;*)
+ 				text "exception" ^|
+ 				text s ^|
+ 				text "=" ^|
+ 				(fmt_longident li)
+ 				^~ text ";; "
+ 				:: []
+ 			| Pstr_module (s, mb) ->
+ 				(*line i indet ppf "Pstr_module \"%s\"\n" s;*)
+ 				text "module" ^|
+ 				text s ^|
+ 				(module_binding mb)
+ 				@ []
+ 			| Pstr_recmodule bindings ->
+ 				(*line i indet ppf "Pstr_recmodule\n";*)
+ 				text "module" ^|
+ 				text "rec" ^|
+ 				group ( nest ( doclist_2_doc (
+ 					(list_sep string_x_modtype_x_module "and" PREC_AND PREC_AND bindings)
+ 					:: []
+ 				)))
+ 				^~ text ";; "
+ 				:: []
+ 			| Pstr_modtype (s, mt) ->
+ 				(*line i indet ppf "Pstr_modtype \"%s\"\n" s;*)
+ 				text "module" ^|
+ 				text "type" ^|
+ 				text s ^|
+ 				text "=" ^|
+ 				(module_type mt)
+ 				^~ text ";; "
+ 				:: []
+ 			| Pstr_open (li) ->
+ 				(text "open" ^|
+ 				(fmt_longident li)
+ 				^~ text ";; "
+ 				:: [])
+ 			| Pstr_class (l) ->
+ 				text "class" ^|
+ 				group ( nest ( doclist_2_doc (
+ 					(list_sep class_declaration "and" PREC_AND PREC_AND l)
+ 					:: []
+ 				)))
+ 				^~ text ";; "
+ 				:: []
+ 			| Pstr_class_type (l) ->
+ 				(*line i indet ppf "Pstr_class_type\n";*)
+ 				text "class" ^|
+ 				text "type" ^|
+ 				(list_sep class_type_declaration "and" PREC_AND PREC_AND l)
+ 				^~ text ";; "
+ 				:: []
+ 			| Pstr_include me ->
+ 				text "include" ^|
+ 				(module_expr me)
+ 				^~ text ";; "
+ 				:: []
+ 		)
+ 	)))
+   
+ and module_binding mb =
+ 	(match mb.pmod_desc with
+ 		| Pmod_constraint (me, mt) ->
+ 			text ":" ^|
+ 			(module_type mt) ^|
+ 			text "=" ^|
+ 			(module_expr me)
+ 			:: []
+ 		| Pmod_functor (s, mt, mb2) ->
+ 			text "(" ^~
+ 			text s ^|
+ 			text ":" ^|
+ 			(module_type mt) ^~
+ 			text ")" ^|
+ 			(module_binding mb2)
+ 			@ []
+ 		| Pmod_ident (_)
+ 		| Pmod_structure (_)
+ 		| Pmod_apply (_, _) ->
+ 			raise EX_AST_NOT_POSSIBLE;
+ 	)
+ 
+ and string_x_module_type prec parentPrec (s, mty) =
+ 	group ( nest ( doclist_2_doc (
+ 		text s ^|
+ 		group ( nest ( doclist_2_doc (
+ 			(module_type mty)
+ 			:: []
+ 		)))
+ 		:: []
+ 	)))
+ 
+ and string_x_modtype_x_module unusedPrec1 unusedPrec2 (s, mty, modl) =
+ 	group ( nest ( doclist_2_doc (
+ 		text s ^|
+ 		group ( nest ( doclist_2_doc (
+ 			(module_type mty) ^|
+ 			(module_expr modl)
+ 			:: []
+ 		)))
+ 		:: []
+ 	)))
+ 
+ and longident_x_with_constraint prec parentPrec (li, wc) =
+ 	(*list_sep i with_constraint "\nand " ppf wc;*)
+ 	(with_constraint prec parentPrec (li, wc))
+ 	
+ and with_constraint prec parentPrec (li, x) =
+ 	group ( nest ( doclist_2_doc (
+ 		(match x with
+ 			| Pwith_type (td) ->
+ 				(*line i indet ppf "Pwith_type\n";*)
+ 				text "type" ^|
+ 				(type_parameters (List.combine td.ptype_params td.ptype_variance)) ^^|
+ 				(fmt_longident li) ^|
+ 				text "=" ^|
+ 				(match td.ptype_manifest with
+ 					| None -> empty;
+ 					| Some man -> (core_type PREC_EQUAL PREC_EQUAL man)
+ 				) ^|
+ 				(*let sep = ("\n" ^ (String.make (2*indent) ' ') ^ "constraint") in*)
+ 				group ( nest ( doclist_2_doc (
+ 					(list_sep constrain "constraint" (*sep*) PREC_NOPAREN PREC_NOPAREN td.ptype_cstrs)
+ 					:: []
+ 				)))
+ 				(*:: group ( nest ( doclist_2_doc ( type_declaration td ))*)
+ 				:: []
+ 			| Pwith_module (li2) ->
+ 				text "module" ^|
+ 				(fmt_longident li) ^|
+ 				text "=" ^|
+ 				(fmt_longident li2)
+ 				:: []
+ 		)
+ 	)))
+   
+ and constrain prec parentPrec (c1, c2, loc) =
+ 	parenGroup (precVal(PREC_EQUAL) < precVal(prec) || parentPrec == PREC_EQUAL)
+ 		(
+ 			doclist_2_doc
+ 			(
+ 				(core_type PREC_EQUAL PREC_EQUAL c1) ^|
+ 				text "=" ^|
+ 				(core_type PREC_EQUAL PREC_EQUAL c2)
+ 				:: []
+ 			)
+ 		)
+   
+ and type_parameters x =
+ 	(match x with
+ 		| [] -> [empty];
+ 		| hd::[] ->
+ 			[(type_parameter PREC_NONE PREC_NONE hd)]
+ 		| _ -> (
+ 			(*group ( nest ( doclist_2_doc ( *) ((
+ 				text "(" ^~
+ 				(list_sep_boxlist type_parameter "," PREC_NONE PREC_NONE x) ^^~
+ 				(*(type_parameter hd) ::*)
+ 				text ")"
+ 				(*:: (type_parameters tail)*)
+ 				:: []
+ 			))
+ 			)
+ 	)
+ 				
+ and type_parameter unusedPrec1 unusedPrec2 (id, var) =
+ 	group ( doclist_2_doc (
+ 		(match var with
+ 			| (true, false) -> text "+";
+ 			| (false, true) -> text "-";
+ 			| (_, _) -> empty;
+ 		) ^|
+ 		(text "\'" ^^ text	id)
+ 		:: []
+ 	))
+ 
+ and type_kind (x, xo) =
+ 	(*group ( nest ( doclist_2_doc ( *) (((
+ 		(match (x, xo) with
+ 			| (Ptype_abstract, None) ->
+ 				empty
+ 				:: []
+ 			| (Ptype_abstract, Some ct) ->
+ 				text "=" ^|
+ 				(core_type PREC_EQUAL PREC_EQUAL ct)
+ 				:: []
+ 			| (Ptype_variant(cd, pflag), None) ->
+ 				text "=" ^|
+ 				(fmt_private_flag pflag) ^|
+ 				nest ( doclist_2_flatdoc (constructor_declarations cd) )
+ 				:: []
+ 			| (Ptype_variant(cd, pflag), Some ct) ->
+ 				text "=" ^|
+ 				(core_type PREC_EQUAL PREC_EQUAL ct) ^|
+ 				text "=" ^|
+ 				(fmt_private_flag pflag) ^|
+ 				(*text "|" ::*)		(* optional *)
+ 				nest ( ( doclist_2_flatdoc (constructor_declarations cd) ) )
+ 				:: []
+ 			| (Ptype_record(ld, pflag), None) ->
+ 				text "=" ^|
+ 				(fmt_private_flag pflag) ^|
+ 				text "{" ^|
+ 				(label_declarations ld) ^^|
+ 				(*text ";" ::*)		(* optional *)
+ 				text "}"
+ 				:: []
+ 			| (Ptype_record(ld, pflag), Some ct) ->
+ 				text "=" ^|
+ 				(core_type PREC_EQUAL PREC_EQUAL ct) ^|
+ 				text "=" ^|
+ 				(fmt_private_flag pflag) ^|
+ 				text "{" ^|
+ 				(label_declarations ld) ^^|
+ 				text "}"
+ 				:: []
+ 		)
+ 	)))
+ 
+ and constructor_declarations cd =
+ 	let constructor_declaration prec parentPrec x = string_x_core_type_list PREC_STAR PREC_STAR x in
+ 	(*let sep = ("\n" ^ (String.make (2*indent) ' ') ^ "| " ) in*)
+ 	(list_sep_boxlist2 constructor_declaration "|" (*sep*) PREC_BAR PREC_BAR cd)
+ 	
+ and label_declarations x =
+ 	let label_declaration prec parentPrec (lbl, mf, pt) =
+ 		(fmt_mutable_flag mf) ^|
+ 		text lbl ^|
+ 		text ":" ^|
+ 		(core_type PREC_NOPAREN PREC_NOPAREN pt) (*PREC_COLON PREC_COLON pt;)*)
+ 		:: []
+ 		in
+ 	(list_sep_boxlist2 label_declaration ";" PREC_SEMI PREC_SEMI x)
+ 	@ []
+ (*
+   | Ptype_variant (l, priv) ->
+       line i indet ppf "Ptype_variant %a\n" fmt_private_flag priv;
+       list (i+1) string_x_core_type_list " of " ppf l;
+   | Ptype_record (l, priv) ->
+       line i indet ppf "Ptype_record %a\n" fmt_private_flag priv;
+       list (i+1) string_x_mutable_flag_x_core_type ppf l;
+ *)
+ 
+ and type_as_list l =
+ 	doclist_2_doc
+ 	(
+ 		let leadlist = [text "type"] in
+ 		(list_sep_aslist leadlist string_x_type_declaration "and" PREC_AND PREC_AND l)
+ 		^^~ text ";; "
+ 		:: []
+ 	)
+ 	(*
+ 	group (
+ 	text "type" ::
+ 	(*group ( nest ( doclist_2_doc ( *) ((
+ 		(list_sep string_x_type_declaration "and" PREC_AND PREC_AND l)
+ 	))) ::
+ 	text ";; ";)
+ 	*)
+ 
+ and string_x_type_declaration prec parentPrec (s, td) : doc list =
+ 	(*line i indet ppf "%s" s;*)
+ 	(* text "also" :: *)
+ 	(*group*) ( (*nest*) ( 
+ 		(type_declaration_list (s, td))
+ 	))
+ 	
+ and type_declaration (s, td) : doc=
+ 	doclist_2_doc
+ 	(
+ 		(type_declaration_list (s, td))
+ 	)
+   
+ and type_declaration_list (s, td) : doc list=
+ 	let one = List.combine td.ptype_params td.ptype_variance in
+ 	let three = (td.ptype_kind, td.ptype_manifest) in
+ 	begin
+ 		(*doclist_2_doc*)
+ 		(
+ 			(type_parameters one) ^^|
+ 			(if (s != "") then
+ 				text s
+ 			else
+ 				empty) ^|
+ 			( (type_kind three) ) ^^|
+ 			group ( nest ( doclist_2_doc (
+ 				((*let sep = ("\n" ^ (String.make (2*indent) ' ') ^ "constraint" ) in*)
+ 					(list_sep constrain "constraint" (*sep*) PREC_NOPAREN PREC_NOPAREN td.ptype_cstrs)
+ 					:: []
+ 				)
+ 			)))
+ 			:: []
+ 		)
+ 	end;
+ (*	
+   (match x.ptype_manifest with
+ 	  | None -> ();
+ 	  | Some man -> core_type 0 ppf man);
+   list_sep i constrain "\nconstraint " ppf x.ptype_cstrs;
+ 
+   line i indet ppf "type_declaration %a\n" fmt_location x.ptype_loc;
+   let i = i+1 in
+   line i indet ppf "ptype_params =\n";
+   list (i+1) string ppf x.ptype_params;
+   line i indet ppf "ptype_cstrs =\n";
+   list (i+1) core_type_x_core_type_x_location ppf x.ptype_cstrs;
+   line i indet ppf "ptype_kind =\n";
+   type_kind (i+1) ppf x.ptype_kind;
+   line i indet ppf "ptype_manifest =\n";
+   option (i+1) core_type ppf x.ptype_manifest;
+ *)
+ 
+ and core_type_x_core_type_x_location prec parentPrec (ct1, ct2, l) =
+ (*	line i ppf "<constraint> %a\n" fmt_location l;*)
+ 	group ( nest ( doclist_2_doc (
+ 		(core_type prec parentPrec ct1) ^|
+ 		(core_type prec parentPrec ct2)
+ 		:: []
+ 	)))
+ 
+ and string_x_core_type_list prec parentPrec (s, l) =
+ 	text s ^|
+ 	(match l with [] -> empty | _ -> text "of") ^|
+ 	(*group ( nest ( doclist_2_doc ( *) (((
+ 		(*list_sep core_type sep l;*)
+ 		(list_sep_nobinding core_type "*" PREC_STAR PREC_STAR l)
+ 	)))
+ 	:: []
+ 
+ and string_x_mutable_flag_x_core_type prec parentPrec (s, mf, ct) =
+ 	(text "\"" ^^ text s  ^^ text "\"") ^|
+ 	(fmt_mutable_flag mf) ^|
+ 	group ( nest ( doclist_2_doc (
+ 		(core_type prec parentPrec ct)
+ 		:: []
+ 	)))
+ 	:: []
+ 
+ and string_list_x_location prec parentPrec (l, loc) =
+ (*	line i ppf "<params> %a\n" fmt_location loc;*)
+ 	(boxIter text l)
+ 
+ and longident_x_pattern prec parentPrec (li, p) =
+ 	parenGroup (precVal(PREC_BAR) < precVal(prec) || parentPrec == PREC_BAR)
+ 		(
+ 			doclist_2_doc
+ 			(
+ 				text "|" ^|
+ 				(longident_x_pattern_no_lead PREC_BAR PREC_BAR (li, p))
+ 				:: []
+ 			)
+ 		)
+   
+ and longident_x_pattern_no_lead prec parentPrec (li, p) =
+ 	parenGroup (precVal(PREC_ARROW) < precVal(prec) || parentPrec == PREC_ARROW)
+ 		(
+ 			doclist_2_doc
+ 			(
+ 				(fmt_longident li) ^|
+ 				text "->" ^|
+ 				group ( (*nest*) ( doclist_2_doc (
+ 					(pattern PREC_ARROW PREC_ARROW p)
+ 					:: []
+ 				)))
+ 				:: []
+ 			)
+ 		)
+ 
+ and pattern_x_expression_case prec parentPrec (p, e) =
+ (*	parenGroup (precVal(PREC_BAR) < precVal(prec) || parentPrec == PREC_BAR)*)
+ 		(
+ 			doclist_2_doc
+ 			(
+ 				let tup = pattern_x_expression_case2Tuple prec parentPrec (p, e) in
+ 				(fst tup) ^|
+ 				(snd tup)
+ 				:: []
+ 			)
+ 		)
+ 
+ and pattern_x_expression_case_match prec parentPrec (p, e) =
+ (*	parenGroup (precVal(PREC_BAR) < precVal(prec) || parentPrec == PREC_BAR)*)
+ 		((*hardbreak ^^*)
+ 		group ( nest (
+ 			doclist_2_doc
+ 			(
+              match (p.ppat_desc, e.pexp_desc) with
+                Ppat_any, Pexp_apply({pexp_desc = Pexp_ident(idRaise); pexp_loc = _}, [_, {pexp_desc = Pexp_construct(idExn, o, b); pexp_loc = _}])
+                when (!hideExns && 
+                      idRaise = Longident.parse "Pervasives.raise" && 
+                      (String.length (longidentToStr idExn) >= 19) && (String.sub (longidentToStr idExn) 0 19) = "SEMINAL_ELIDED_CODE" &&
+                      p.ppat_loc.loc_end.pos_cnum = -666) ->
+                        group (
+                        text "|" +~: text "[[...other pattern...]]" +~: text "->" +~: text "[[...other program...]]"
+                       ) :: []
+              | _ ->
+ 				 let (a, b) = pattern_x_expression_case_no_lead prec parentPrec (p, e) in
+ 				 
+ 				 group ( (*nest*) (doclist_2_doc (
+ 					               text "|" ^|
+ 					               a @
+ 					               []
+ 				      ))) ^|
+ 				      (nest (b))
+ 				      :: []
+ 				          (*
+ 				             let tup = pattern_x_expression_case2Tuple prec parentPrec (p, e) in
+ 				             (hardbreak +|:
+ 				             (fst tup)) ::
+ 				             (snd tup)
+ 				             :: []
+ 				           *)
+ 			)
+ 		)))
+ 		
+ and pattern_x_expression_case2Tuple prec parentPrec (p, e) =
+ (*	parenGroup (precVal(PREC_BAR) < precVal(prec) || parentPrec == PREC_BAR)*)
+ 		(
+ 			let tup = pattern_x_expression_case_no_lead prec parentPrec (p, e) in
+ 			group ( nest ( doclist_2_doc (
+ 				text "|" ^|
+ 				(fst tup)
+ 			))),
+ 			(snd tup)
+ 		)
+   
+ and pattern_x_expression_case_no_lead_no_newline prec parentPrec (p, e) : (doc list * Parsetree.expression) =
+ 	(*line 1 ppf "";*)
+ 	(*pattern 0 indent ppf PREC_ARROW PREC_ARROW p;*)
+ 	(pattern PREC_ARROW parentPrec p) ^|
+ 	(if (parentPrec != PREC_FUN) then (* we don't print "function x ->" if parent is a function *)
+ 		[text "->"]
+ 	else
+ 		[]
+ 	),
+ 	(*(expression PREC_ARROW PREC_ARROW e)*)
+ 	e
+ 	(*(expression PREC_ARROW parentPrec e)*)
+ 
+ and pattern_x_expression_case_no_lead prec parentPrec (p, e) =
+ 	let ((one : doc list), two) = pattern_x_expression_case_no_lead_no_newline prec parentPrec (p, e) in
+ 	one,
+ 	(expression PREC_ARROW parentPrec two)
+ (*	group ( (*nest*) ( doclist_2_doc (
+ 		let tup = pattern_x_expression_case_no_lead_no_newline prec parentPrec (p, e) in
+ 		(fst tup) ::
+ 		(snd tup)
+ 	))
+ *)
+ 
+ and function_2_type_x_arglist_x_arrow_x_expression prec parentPrec x =
+ 	(match x.pexp_desc with
+ 		| Pexp_function (p, eo, l) ->
+ 			(match l with
+ 				| (p2,e2)::[] -> begin
+ 						(* if there are multiple args then it's not a patern-match, and this one is a "fun", otherwise it is a "function" *)
+ 						let thisPrec = (match (e2.pexp_desc) with
+ 								| Pexp_function (_,_,(p3,e3)::[]) -> PREC_FUN;
+ 								| _ -> PREC_FUN;(*PREC_FUNCTION;*)
+ 							) in
+ 						let tup = (pattern_x_expression_case_no_lead_no_newline PREC_FUN thisPrec (p2, e2)) in
+ 						let ((t, t'), al, a, (eo, b)) = function_2_type_x_arglist_x_arrow_x_expression PREC_FUN thisPrec (snd tup) in
+ 						let last = (match eo with
+ 							| None -> ""
+ 							| Some ex -> "=") in
+ 						let (exp, b2), arrow = (match al with
+ 								| [] -> 
+ 									let is_function = (match eo with
+ 											| None -> true
+ 											| Some ex -> false
+ 										) && b == empty in
+ 									(if (is_function) then None, b else Some (snd tup), empty),
+ 									text last		(* if it's not a fun, use this function's expression *)
+ 								| _ -> (eo, empty), text last				(* it is a fun, so use the child's expression, while comsuming the argument *)
+ 							) in
+ 						((
+ 							if (parentPrec != PREC_FUNCTION && parentPrec != PREC_FUN) then (* don't print out "fun x ->" twice! *)
+ 								text "fun"
+ 							else
+ 								empty;
+ 						), empty),
+ 						(fst tup)^^|al,			(* args *) (*(fst tup)@al*)
+ 						arrow,
+ 						(exp, b2)		(* expr *)
+ 					end
+ 				| _ -> begin
+ 							(text "=", text "function"), [], empty,
+ 							(None, group ( nest ( doclist_2_doc (
+ 								(boxIter (pattern_x_expression_case PREC_NOPAREN PREC_FUNCTION) l)
+ 								:: []
+ 							))))
+ 					end
+ 			)
+ 		| _ -> (empty, empty), [], text "=", (Some x, empty)
+ 	)
+ 
+ and let_def prec parentPrec (p,e) : doc list =
+ 	let ((t, t'), args, arrow, (eo, doc)) = function_2_type_x_arglist_x_arrow_x_expression PREC_FUN PREC_FUN e
+ 			(*match e.pexp_desc with 
+ 					|  Pexp_function (p, eo, l) ->
+ 						let (d, e, f) = print_function prec parentPrec (p, eo, l) in
+ 						e, text "=", f
+ 					| _ -> text "=", (expression PREC_EQUAL parentPrec e), empty
+ 			*) in
+ 	(pattern PREC_EQUAL parentPrec p) ^|
+ 	t ^|
+ 	t' ^|
+ 	(doclist_2_flatdoc args) ^|	(* flat args optional *)
+ 	arrow ^|
+ 	(match eo with
+ 		| None -> empty
+ 		| Some ex -> (expression PREC_NOPAREN PREC_NOPAREN (*PREC_EQUAL PREC_EQUAL *)ex)
+ 	) ^|
+ 	doc
+ 	:: []
+ 
+ and let_def_no_lead  prec parentPrec (p, e) : doc list =
+ 	let ((t, t'), args, arrow, (eo, doc)) = function_2_type_x_arglist_x_arrow_x_expression PREC_FUN PREC_FUN e
+ 				(*match e.pexp_desc with 
+ 						|  Pexp_function (p, eo, l) ->
+ 							let (d, e, f) = print_function prec parentPrec (p, eo, l) in
+ 							e, text "=", f
+ 						| _ -> text "=", (expression PREC_EQUAL parentPrec e), empty
+ 				*) in
+ 	text "and" ^|
+ 	(pattern PREC_EQUAL parentPrec p) ^|
+ 	t ^|
+ 	t' ^|
+ 	(doclist_2_flatdoc args) ^|	(* flat args optional *)
+ 	arrow ^|
+ 	(match eo with
+ 		| None -> empty
+ 		| Some ex -> (expression PREC_EQUAL PREC_EQUAL ex)
+ 	) ^|
+ 	doc
+ 	:: []
+ 	
+ and pattern_x_expression_def prec parentPrec (p, e)(*rf, (p, e)*) =
+ (*	parenGroup (precVal(PREC_EQUAL) < precVal(prec) || parentPrec == PREC_EQUAL)*)
+ 		 ( doclist_2_doc (
+ 			(*(pattern PREC_EQUAL PREC_EQUAL p) :: text*)
+ 			(*let rec printFunc = fun x ->
+ 				(match x.pexp_desc with
+ 					| Pexp_function (p, eo, l) ->
+ 						let (d, e, f) = print_function prec parentPrec (p, eo, l) in
+ 						let (g, h, i) = printFunc f in
+ 						e :: g :: h :: i, empty, empty
+ 					| _ -> text "=", (expression PREC_EQUAL parentPrec e), empty
+ 				) in*)
+ 			let ((t, t'), args, arrow, (eo, doc)) = function_2_type_x_arglist_x_arrow_x_expression PREC_FUN PREC_FUN e
+ 							(*match e.pexp_desc with 
+ 									|  Pexp_function (p, eo, l) ->
+ 										let (d, e, f) = print_function prec parentPrec (p, eo, l) in
+ 										e, text "=", f
+ 									| _ -> text "=", (expression PREC_EQUAL parentPrec e), empty
+ 							*) in
+ 			(
+ 				(pattern PREC_EQUAL parentPrec p) ^|
+ 				t ^|
+ 				t' ^|
+ 				empty ^|
+ 				(doclist_2_flatdoc args) ^| (* group args together, flat optional *)
+ 				arrow ^|
+ 				(match eo with
+ 					| None -> empty
+ 					| Some ex -> (expression PREC_EQUAL PREC_EQUAL ex)
+ 				) ^|
+ 				doc
+ 				:: []
+ 			)
+ 			(*
+ 			(*(pattern PREC_EQUAL PREC_EQUAL p) :: text*)
+ 			(
+ 				(pattern PREC_EQUAL parentPrec p) :: text
+ 				"="
+ 			) ::
+ 			(*(expression PREC_EQUAL PREC_EQUAL e)*)
+ 			(expression PREC_EQUAL parentPrec e)
+ 			*)
+ 		))
+ 
+ and pattern_x_expression_def_2Tuple prec parentPrec (p, e)(*rf, (p, e)*) =
+ (*	parenGroup (precVal(PREC_EQUAL) < precVal(prec) || parentPrec == PREC_EQUAL)*)
+ 		(
+ 			(*(pattern PREC_EQUAL PREC_EQUAL p) :: text*)
+ 			doclist_2_doc
+ 			(
+ 				(pattern PREC_EQUAL PREC_EQUAL p) ^|
+ 				text "="
+ 				:: []
+ 			),
+ 			(*(expression PREC_EQUAL PREC_EQUAL e)*)
+ 			(expression PREC_EQUAL PREC_EQUAL e)
+ 		)
+ 
+ and pattern_x_expression_def_no_lead prec parentPrec (p, e)(*rf, (p, e)*) =
+ 	(*print ppf "\n";*)
+ (*	parenGroup (precVal(PREC_AND) < precVal(prec) || parentPrec == PREC_AND)*)
+ 		( doclist_2_doc (
+ 			let ((t, t'), args, arrow, (eo, doc)) = function_2_type_x_arglist_x_arrow_x_expression PREC_FUN PREC_FUN e
+ 							(*match e.pexp_desc with 
+ 									|  Pexp_function (p, eo, l) ->
+ 										let (d, e, f) = print_function prec parentPrec (p, eo, l) in
+ 										e, text "=", f
+ 									| _ -> text "=", (expression PREC_EQUAL parentPrec e), empty
+ 							*) in
+ 			(
+ 				text "and" ^|
+ 				(pattern PREC_EQUAL parentPrec p) ^|
+ 				t ^|
+ 				t' ^|
+ 				(doclist_2_flatdoc args) ^|	(*flat args optional *)
+ 				arrow ^|
+ 				(match eo with
+ 					| None -> empty
+ 					| Some ex -> (expression PREC_EQUAL PREC_EQUAL ex)
+ 				) ^|
+ 				doc
+ 				:: []
+ 			)
+ 			(*
+ 			text "and" ::
+ 			(*(fmt_rec_flag rf) ::*)
+ 			(pattern PREC_AND PREC_AND p) :: (* PREC_AND < PREC_EQUAL *)
+ 			text"=" ::
+ 			(expression PREC_EQUAL PREC_EQUAL e)
+ 			*)
+ 		))
+ 
+ and string_x_expression prec parentPrec (s, e) =
+ (*	line i ppf "<override> \"%s\"\n" s*)
+ 	parenGroup (precVal(PREC_LBRACELESS ) < precVal(prec)|| parentPrec == PREC_LBRACELESS)
+ 		(
+ 			group ( nest ( doclist_2_doc (
+ 				(expression PREC_LBRACELESS PREC_LBRACELESS e)
+ 				:: []
+ 			)))
+ 		)
+ 
+ and longident_x_expression prec parentPrec (li, e) =
+ 	doclist_2_doc
+ 	(
+ 		text ";" ^|
+ 		(*longident_x_expression_no_lead i indent ppf PREC_SEMI PREC_SEMI (li, e);*)
+ 		(longident_x_expression_no_lead prec parentPrec (li, e))
+ 		:: []
+ 	)
+ 	
+ and longident_x_expression_no_lead prec parentPrec (li, e) =
+ 	parenGroup (precVal(PREC_SEMI) < precVal(prec) || parentPrec == PREC_SEMI)
+ 		(
+ 			doclist_2_doc
+ 			(
+ 				(fmt_longident li) ^|
+ 				text "=" ^|
+ 				(*(expression PREC_EQUAL PREC_EQUAL e)*)
+ 				(expression prec parentPrec e)
+ 				:: []
+ 			)
+ 		)
+ 		
+ and label_x_expression prec parentPrec (l,e) =
+ (*	line i indet ppf "<label> \"%s\"\n" l*)
+ 	(expression prec parentPrec e)
+ 
+ and label_x_bool_x_core_type_list prec parentPrec x =
+ 	match x with
+ 		| Rtag (l, b, ctl) ->
+ 			(*line indent ppf "Rtag \"%s\" %s\n" l (string_of_bool b);*)
+ 			doclist_2_doc
+ 			(
+ 				text l ^|
+ 				text "of" ^|
+ 				(if (b) then text "&" else empty;) ^|
+ 				group ( nest ( doclist_2_doc (
+ 					(list_sep core_type "&" PREC_NOPAREN PREC_NOPAREN ctl)
+ 					:: []
+ 				)))
+ 				:: []
+ 			)
+ 		| Rinherit (ct) ->
+ 			(*line i ppf "Rinherit\n";*)
+ 			group ( nest ( doclist_2_doc (
+ 				(core_type PREC_NONE PREC_NONE ct) (* PREC_NOPAREN ? *)
+ 				:: []
+ 			)))
+ ;;
+ 
+ let rec toplevel_phrase x =
+ 	match x with
+ 		| Ptop_def (s) ->
+ 			doclist_2_doc
+ 			(
+ 				(*line i indet ppf "Ptop_def\n";*)
+ 				(structure (*PREC_NOPAREN PREC_NOPAREN *)s)
+ 				^~ text ";; "
+ 				:: []
+ 			)
+ 		| Ptop_dir (s, da) ->
+ 			doclist_2_doc
+ 			(
+ 				(*line i indet ppf "Ptop_dir \"%s\"\n" s;*)
+ 				text "#" ^|
+ 				text s ^|
+ 				(directive_argument da)
+ 				:: []
+ 			)
+ 
+ and directive_argument x =
+ 	match x with
+ 		| Pdir_none -> empty;
+ 		| Pdir_string (s) -> text s;
+ 		| Pdir_int (i) -> intText i;
+ 		| Pdir_ident (li) -> (fmt_longident li);
+ 		| Pdir_bool (b) -> boolText b;
+ ;;
+ 
+ 
+ let init ppf func x =
+ 	let box = func PREC_NOPAREN PREC_NOPAREN x in
+ 	let sd = format 80 0 [0, Flat, box] in
+ 	let str = sdocToString sd in
+ 	fprintf ppf "%s" str
+ ;;
+ 
+ let listInit ppf func x =
+ 	let box = boxIter (func PREC_NOPAREN PREC_NOPAREN) x in
+ 	let sd = format 80 0 [0, Flat, box] in
+ 	let str = sdocToString sd in
+ 	fprintf ppf "%s" str
+ ;;
+ 
+ let wrap func prec1 prec2 x = func x;;
+ 
+ (* publicness *)
+ let interface ppf x = listInit ppf signature_item x;;
+ 
+ let implementation ppf x = listInit ppf structure_item x;;
+ 
+ let top_phrase ppf x = init ppf (wrap toplevel_phrase) x;;
+ 
+ let expression ppf x = init ppf expression x;;
+ let pattern ppf x = init ppf pattern x;;
+ let stritem ppf x = init ppf structure_item x;;
+ let modexp ppf x = init ppf (wrap module_expr) x;;
+ let coretype ppf x = init ppf core_type x;;
+ let modtyp ppf x = init ppf (wrap module_type) (*PREC_NOPAREN PREC_NOPAREN *)x;;
+ let cldec ppf (x : class_declaration) = listInit ppf class_declaration [x];;
+ let cltydec ppf x = init ppf class_type_declaration x;;
+ let tydec ppf x = init ppf (wrap type_declaration) (*PREC_NOPAREN PREC_NOPAREN *)("", x);;
+ let classfld ppf x = init ppf class_field x;;
+ 
+ let clexp ppf (x : class_expr) = init ppf class_expr x;;
+ let sigitem ppf x = init ppf signature_item x;;
+ let clty ppf x = init ppf class_type x;;
+ let cltf ppf x = init ppf class_type_field x;;
+ 
+ let cldesc ppf (x : class_description) = init ppf class_description x;;
+ let showExns () = hideExns := false; ();;
+ let hideExns () = hideExns := true; ();;
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/parsing/printcode.mli seminalOcaml/parsing/printcode.mli
*** ocaml-3.08.4/parsing/printcode.mli	1969-12-31 16:00:00.000000000 -0800
--- seminalOcaml/parsing/printcode.mli	2009-01-19 09:41:30.000291002 -0800
***************
*** 0 ****
--- 1,40 ----
+ (***********************************************************************)
+ (*                                                                     *)
+ (*                           Objective Caml                            *)
+ (*                                                                     *)
+ (*             Damien Doligez, projet Para, INRIA Rocquencourt         *)
+ (*                                                                     *)
+ (*  Copyright 1999 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.               *)
+ (*                                                                     *)
+ (***********************************************************************)
+ 
+ (* $Id: printcode.mli,v 1.7 2006/05/06 01:18:09 blerner Exp $ *)
+ 
+ open Parsetree;;
+ open Format;;
+ 
+ val interface : formatter -> signature_item list -> unit;;
+ val implementation : formatter -> structure_item list -> unit;;
+ val top_phrase : formatter -> toplevel_phrase -> unit;;
+ 
+ val expression : formatter -> expression -> unit;;
+ val pattern : formatter -> pattern -> unit;;
+ val stritem : formatter -> structure_item -> unit;;
+ val modexp : formatter -> module_expr -> unit;;
+ val coretype : formatter -> core_type -> unit;;
+ val modtyp : formatter -> module_type -> unit;;
+ val cldec : formatter -> class_declaration -> unit;;
+ val cldesc : formatter -> class_description -> unit;;
+ val cltydec : formatter -> class_type_declaration -> unit;;
+ val tydec : formatter -> type_declaration -> unit;;
+ val classfld : formatter -> class_field -> unit;;
+ 
+ val clexp : formatter -> class_expr -> unit;;
+ val sigitem : formatter -> signature_item -> unit;;
+ val clty : formatter -> class_type -> unit;;
+ val cltf : formatter -> class_type_field -> unit;; 
+ 
+ val showExns : unit -> unit;;
+ val hideExns : unit -> unit;;
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/tools/cvt_emit.bak seminalOcaml/tools/cvt_emit.bak
*** ocaml-3.08.4/tools/cvt_emit.bak	1969-12-31 16:00:00.000000000 -0800
--- seminalOcaml/tools/cvt_emit.bak	2009-01-19 09:42:01.211862570 -0800
***************
*** 0 ****
--- 1,153 ----
+ #!/projects/null/swlab8/blerner/projects/seminal/seminalOcaml/bin/ocamlrun
+ Tß)*VDC2"@(()*…c(`¨
+ „5?[on2$	]�()*^ž()*^ž()*^Ÿ()*^¢(]¤(]™()*^›(]¦(]¦(]§(]K()*^©(]«(]™(]˜()*^›()*^£(]¥(]š()*^ª(]¬(]š(c!]Ö(cC%c!c%C
+ +óÿÿÿI(
+ ]Ç
+ ]ÈhhaÒ()*&c!](c!]O(]�%g
+ ^ž]�("g
+ ^ž]�(!&!&&^ž(g
+ ^ž]�("g
+ ^ž]�(!&!&&^ž(Y]˜Z(h()*VDC
+ ]Ç
+ ohaÒo2'	()*]­
+ „V	]È'5?[ˆ)ÿÿÿÿ]Èÿÿÿÿh`¨c]¦cVnÿÿÿÿ@]È'(m]Èmh`¨co@2&,�ÿÿÿ,œÿÿÿch&)*‡‡
+ ]Ço}V5%$)*‡‡
+ ]Ço}V5%`¨(h6'h6')*_×]”(Y]�ZThY]˜Z(h(]�]˜()*c_()*‡‡
+ ]Ço}V5%`¡()*]Çh`¡(VDC	Y]�ZTh2%c(,ãÿÿÿc]–%l¶6'l¶6')*_×]•(6^%~V5&^É
+ ‡0†:	T
+ „-T(2%]Ç
+ ,Ïÿÿÿc%6^P(5^ÌV5^ÌV5%d(c(V5(5(‡ˆÿ5%()*]Ç]Ç
+ n]ÈhhaÒhaÒ(gÿÿÿÿu(‡(m()*^V(()*^V((6@[6@[+øÿÿÿ	+îÿÿÿ6?	+Øÿÿÿ	+Åÿÿÿ	+µÿÿÿ	+«ÿÿÿliv„gTg>iv
+ ÿÿÿÿ6]~6]~6]~6 ]~6!]~6"]~	+^ÿÿÿ+Hÿÿÿ	+9ÿÿÿ+ÿÿÿ	+ÿÿÿ	:+üþÿÿ
+ +Èþÿÿ	,ºûÿÿc]”i]•j]•	+«þÿÿ
+ +žþÿÿ+’þÿÿ	+„þÿÿ	+Zþÿÿ+4þÿÿ	+&þÿÿ	+þÿÿ	+ÿýÿÿ	+ðýÿÿ
+ +äýÿÿ+Ùýÿÿ%+´ýÿÿ	,Œûÿÿ(+ˆýÿÿ	+týÿÿ	+èüÿÿ+Ýüÿÿ+Ñüÿÿ+Áüÿÿ+±üÿÿ+œüÿÿ+�üÿÿ+‚üÿÿ+vüÿÿ"+füÿÿ +Vüÿÿ+Aüÿÿ+2üÿÿ!+"üÿÿ
+ +üÿÿ+üÿÿ	:,+þûÿÿ	+èûÿÿ?
+ +Õûÿÿ+Åûÿÿ
+ +¹ûÿÿ6#^é.
+ 
+ 	+ ûÿÿ	+—ûÿÿ	+‹ûÿÿ	+�ûÿÿ	+xûÿÿ	+lûÿÿ>	+\ûÿÿ	+Pûÿÿ	+Gûÿÿ	+>ûÿÿ	+2ûÿÿ	+(ûÿÿ	+ûÿÿ	+ûÿÿ),*	+ûÿÿ213	+õúÿÿ79	+çúÿÿ	+Þúÿÿ	+Òúÿÿ>	+Ãúÿÿ	+¶úÿÿBD	+¥úÿÿG	+™úÿÿLKM02468:<>@BDFHJL_acegkmoqsuwy{}ƒƒƒ‡‰‹���>QB9$Tû)*V
+ D
+ 2&()*VDC„(ˆÿÿÿÿ2&5%8$%5&8$%)*VDC@2&(VDC2!8$&c()*VDC
+ !2"@(c()*VDC
+ !2&c()*VDC"2'()*VDC2#&()*VVDCDC"	2#@(
+ Uc(5'8$%)*VVDCDC"2'Uc(5(8$%)*VVDCDC#	2$U(5)8$%)*VV!DCDC	
+ 2 	'U(5*8$%)*VDC
+ !V2&(d()*VDC
+ !U2&(c()*VVDCDC"V2'(	Ud(5+8$%)*VVDCDC"U2'(	Uc(5,8$%)*VDC^hyU2&(c()*VDCyU2&(c()*VDC
+ DC^„(2&5?[)*VDC
+ DCyV(2&5?[)*VDC
+ C^hyU2&(c()*VDC
+ CyU2&(c()*VDC
+ C^„(2"@(c()*VDC
+ CyV(2"@(c()*VDC
+ !V(2&5?[VDC
+ DC2!
+ DC@@@(5-()*VVDCDC2"@@(Uc(5.8$%)*V0V)DCDC"…2#@(	2#@(	
+ (
+ ()*„(V
+ D
+ ÿÿÿÿ2&5/6
+ @[)*V/V&DCDC"…@2'@2'&&)*V/V&DCDC"ˆ@2'@2'&&)*ƒ�„´V±D
+ V€D
+ VwCCC"…5"…c@@@(	"…c@@@(	c@@@(	"…c@@@(	"…c@@@(	c@@@(	T-T)V&D
+ VCC"…
+ c@@(c@@(ix
+ o"3"3"h')*ƒ‹„®V«D
+ V{D
+ VrCCC"ˆ3"ˆc@@@(	"ˆc@@@(	c@@@(	"ˆc@@@(	"ˆc@@@(	c@@@(	T,T(V%D
+ VCC"ˆ
+ c@@(c@@(ix
+ o"1"1"h')*,Òýÿÿ,þÿÿ,<þÿÿÿÿÿ!
+ †(&	)*VDC
+ !V
+ @2'@2'!!@()*,Îÿÿÿhh')*VDC
+ !V	@2&2&%,Üÿÿÿc%)*VVDCDC"@2'U(508$%)*,Íÿÿÿh')*VDC!@2&()*,ãÿÿÿh&c&VD
+ (518$%VC
+ (528$%h&,ùÿÿ+ôÿÿÿ	+áÿÿÿ	+Îÿÿÿ	,ùÿÿ7$	,'ùÿÿ+¸ÿÿÿ	,2ùÿÿ	,@ùÿÿ+žÿÿÿ	,Qùÿÿ,bùÿÿ,tùÿÿ,†ùÿÿ+eÿÿÿ	,®ùÿÿ,Öùÿÿ,úÿÿ,/úÿÿ,Dúÿÿ,Yúÿÿ,…úÿÿ,±úÿÿ,Éúÿÿ,Þúÿÿ,üúÿÿ,ûÿÿ,2ûÿÿ,Iûÿÿ,gûÿÿ,ƒûÿÿ+çþÿÿ
+ +³þÿÿ	,Žûÿÿ,­ûÿÿ,Õûÿÿ,üÿÿ"(+Hþÿÿ
+ 	!#%')+-/24379<>=BBFHGKMOQ>)+93T¼)*o(‡aˆz‡àˆö	‡ø
+ …þàÿÿÿ((‡AˆZ‡ÀˆÖ	‡Ø
+ …Þ ((‡'ƒ\	†(54(55(ƒ		„
+ 	56(57(]ÔVd]ÈhS(l]Èl\hSgdql0niSg
+ l
+ qrl0njSg
+ rl0nkS(‡ˆÿ588$%(+ìÿÿÿ	+‡ÿÿÿ	+cÿÿÿ	+?ÿÿÿ	+4ÿÿÿ
+ >99TÉ)*~V5?[RyV(2$)*†5?[RyV(ÿÿÿÿ2')*^()*h')*‡]Ç~V5:8$%Y#cdZ(6CyVc([)*‡]Ç}V5;8$%Y			]Ç
+  cdZ(6CyVc([)*‡ÿÿÿÿ]Ç~V5<8$%')*]Çÿÿÿÿ')*‡]Ç}V5=8$%]Ç$)*h]Ç$89&89&)*]Ç„(!hR!hS(89&89&)*]Ç
+ „(]Èhÿÿÿÿ	}U\R!S	zUîÿÿÿc(c?h]Çÿÿÿÿ	}UM\R
+ ÷ÿÿÿ
+ ‹þÿÿÿ
+ ŒT%TTƒST	TT]ÔVdTgTeCnI	zUµÿÿÿc]ÇCyV(C]ÈhIc]Çÿÿÿÿ	}U¡\R
+ ‡"ƒ\x†#-Trƒ	„
+ #g\CS€gnCSTgg\CS€gtCSTV
+ ]ÔVCST7l\CS€gdql0nCS€g
+ l
+ qrl0nCS€g
+ rl0nCSTg\CS€CS€	zUaÿÿÿc(]ÇChaÒ]ÇCnI]ÇChaÒ]ÇCnI(€]ÇCnI()*V?DCh?h?+Þÿÿÿ83	"Cÿÿÿÿ]ÇpCn]È]ÇhhaÒ]Ç?	+‘ÿÿÿ83	"(5>()*c]Çÿÿÿÿ	}U\R!	zUñÿÿÿc()*‡‡]Ço}U‡
+ ]Ço}V5?8$%aÒ()*‡‡
+ ]Ço}V5@8$%`Ó()*‡‡
+ ]Ço}V5A8$%]ÈhaÒ(]Ç
+ ]ÈhhaÒ()*]Èh`Ó(+ðÿÿÿ	+Ûÿÿÿ	+°ÿÿÿ	+‰ÿÿÿ	+Tÿÿÿ	+/ÿÿÿ	+ãþÿÿ	+‹ýÿÿ	+Výÿÿ
+ +Jýÿÿ+?ýÿÿ	+!ýÿÿ
+ +ýÿÿ+
+ ýÿÿ	,ýûÿÿ+õüÿÿ+Òüÿÿ	,üÿÿ+¼üÿÿ+�üÿÿ+büÿÿ+1üÿÿ+$üÿÿ	+üÿÿ
+ 	"$&(*>9BT!?[V+öÿÿÿ?&c&)*^Æc(c]ß
+ DCh]ã
+ DCöÿÿÿivÿÿÿÿ
+ lqpÿÿÿÿh?	+Ôÿÿÿlÿÿÿÿlþÿÿÿlýÿÿÿlüÿÿÿlûÿÿÿlúÿÿÿlùÿÿÿløÿÿÿl÷ÿÿÿlöÿÿÿlõÿÿÿlôÿÿÿlóÿÿÿlòÿÿÿlñÿÿÿlðÿÿÿlïÿÿÿlîÿÿÿlíÿÿÿlìÿÿÿlëÿÿÿ6C?
+ +‹ÿÿÿ6D
+ 
+  "$&(*,.044886=?> "9ETKcMcLGhEDC>McK(G(G
+ (GF(G
+ F()*GnD^É()*‡
+ D^É?(c()*D^É()*‡o
+ ]ÈhDaÒ?(c()*o
+ ]ÈhDaÒ(GGo
+ ]ÈhGDaÒ(dM(	:ihhhhh	]Ç6F8$"	+áÿÿÿ>()*h8$>$+ñÿÿÿ%	:hhhhhhhl]Èl]È">()*]Ç"
+ ˆTdMcD]ÇEn}V¼D]ÇGEon|VGEoh	D
+ GD8B TB7ED]Çjp8$"
+ GEon}V5G8$!]È		G
+ EohGD8B JG
+ FnLGoMcMGoMEoKG	hOÿÿÿÿ	}U\^
+ h|Vo_	zUäÿÿÿcE	Dh
+ 8B EnK()*_¯
+ h|VGM
+ GGFnEDC>M()*_®
+ h|VGM
+ GGFnEDC>M(5H	+Ïÿÿÿ	+žÿÿÿ	+¦þÿÿ6I
+ +‚þÿÿ
+ +wþÿÿ+Gþÿÿ	+&þÿÿ	+þÿÿ	+îýÿÿ	+àýÿÿ	+Éýÿÿ	+·ýÿÿ	+¬ýÿÿ	+¢ýÿÿ	+™ýÿÿ	+�ýÿÿ	+nýÿÿ
+ 
+ ">9JTlc3&)*	8J#
+ Œ
+ C!2&W#-08J!IdIg(8$!3!g)8$!1%5K8$!1%c(c8J"8$!1%g3&)*8J#
+ Œ
+ C!2&W9c(5L8$ !C8$!!c8$$!e8$L%8J!h!]Çþÿÿÿi8B#8$!1%8J!h!]Ç„c^Éƒ\c^É„']Ç„(c^É„\!d^Éƒ`d^Éƒ{5M8$!!5N8$!T5O8$!!5P8$!1%]Çh	T8\^Él\yV{V^É
+ l{yUl`yV^É8$!{UÅÿÿÿc(CVcI(5Q8$%c?h?+çÿÿÿ	+�ÿÿÿ6R
+ ,|þÿÿ‚þÿÿÚþÿÿáþÿÿ7$8J!!c8$L!
+ >		9Sc8$P!:9T�caml_alloc_dummycaml_update_dummycaml_array_get_addrcaml_array_get_floatcaml_array_getcaml_array_set_addrcaml_array_set_floatcaml_array_setcaml_array_unsafe_get_floatcaml_array_unsafe_getcaml_array_unsafe_set_addrcaml_array_unsafe_set_floatcaml_array_unsafe_setcaml_make_vectcaml_make_arraycaml_comparecaml_equalcaml_notequalcaml_lessthancaml_lessequalcaml_greaterthancaml_greaterequalcaml_output_valuecaml_output_value_to_stringcaml_output_value_to_buffercaml_format_floatcaml_float_of_stringcaml_int_of_floatcaml_float_of_intcaml_neg_floatcaml_abs_floatcaml_add_floatcaml_sub_floatcaml_mul_floatcaml_div_floatcaml_exp_floatcaml_floor_floatcaml_fmod_floatcaml_frexp_floatcaml_ldexp_floatcaml_log_floatcaml_log10_floatcaml_modf_floatcaml_sqrt_floatcaml_power_floatcaml_sin_floatcaml_sinh_floatcaml_cos_floatcaml_cosh_floatcaml_tan_floatcaml_tanh_floatcaml_asin_floatcaml_acos_floatcaml_atan_floatcaml_atan2_floatcaml_ceil_floatcaml_eq_floatcaml_neq_floatcaml_le_floatcaml_lt_floatcaml_ge_floatcaml_gt_floatcaml_float_comparecaml_classify_floatcaml_gc_statcaml_gc_quick_statcaml_gc_counterscaml_gc_getcaml_gc_setcaml_gc_minorcaml_gc_majorcaml_gc_full_majorcaml_gc_major_slicecaml_gc_compactioncaml_hash_univ_paramcaml_input_valuecaml_input_value_from_stringcaml_marshal_data_sizecaml_int_comparecaml_int_of_stringcaml_format_intcaml_int32_negcaml_int32_addcaml_int32_subcaml_int32_mulcaml_int32_divcaml_int32_modcaml_int32_andcaml_int32_orcaml_int32_xorcaml_int32_shift_leftcaml_int32_shift_rightcaml_int32_shift_right_unsignedcaml_int32_of_intcaml_int32_to_intcaml_int32_of_floatcaml_int32_to_floatcaml_int32_comparecaml_int32_formatcaml_int32_of_stringcaml_int32_bits_of_floatcaml_int32_float_of_bitscaml_int64_negcaml_int64_addcaml_int64_subcaml_int64_mulcaml_int64_divcaml_int64_modcaml_int64_andcaml_int64_orcaml_int64_xorcaml_int64_shift_leftcaml_int64_shift_rightcaml_int64_shift_right_unsignedcaml_int64_of_intcaml_int64_to_intcaml_int64_of_floatcaml_int64_to_floatcaml_int64_of_int32caml_int64_to_int32caml_int64_of_nativeintcaml_int64_to_nativeintcaml_int64_comparecaml_int64_formatcaml_int64_of_stringcaml_int64_bits_of_floatcaml_int64_float_of_bitscaml_nativeint_negcaml_nativeint_addcaml_nativeint_subcaml_nativeint_mulcaml_nativeint_divcaml_nativeint_modcaml_nativeint_andcaml_nativeint_orcaml_nativeint_xorcaml_nativeint_shift_leftcaml_nativeint_shift_rightcaml_nativeint_shift_right_unsignedcaml_nativeint_of_intcaml_nativeint_to_intcaml_nativeint_of_floatcaml_nativeint_to_floatcaml_nativeint_of_int32caml_nativeint_to_int32caml_nativeint_comparecaml_nativeint_formatcaml_nativeint_of_stringcaml_ml_open_descriptor_incaml_ml_open_descriptor_outcaml_ml_out_channels_listcaml_channel_descriptorcaml_ml_close_channelcaml_ml_channel_sizecaml_ml_channel_size_64caml_ml_set_binary_modecaml_ml_flush_partialcaml_ml_flushcaml_ml_output_charcaml_ml_output_intcaml_ml_output_partialcaml_ml_outputcaml_ml_seek_outcaml_ml_seek_out_64caml_ml_pos_outcaml_ml_pos_out_64caml_ml_input_charcaml_ml_input_intcaml_ml_inputcaml_ml_seek_incaml_ml_seek_in_64caml_ml_pos_incaml_ml_pos_in_64caml_ml_input_scan_linecaml_lex_enginecaml_new_lex_enginecaml_md5_stringcaml_md5_chancaml_get_global_datacaml_get_section_tablecaml_reify_bytecodecaml_realloc_globalcaml_get_current_environmentcaml_invoke_traced_functioncaml_static_alloccaml_static_freecaml_static_release_bytecodecaml_static_resizecaml_obj_is_blockcaml_obj_tagcaml_obj_set_tagcaml_obj_blockcaml_obj_dupcaml_obj_truncatecaml_lazy_follow_forwardcaml_lazy_make_forwardcaml_get_public_methodcaml_parse_enginecaml_install_signal_handlercaml_ml_string_lengthcaml_create_stringcaml_string_getcaml_string_setcaml_string_equalcaml_string_notequalcaml_string_comparecaml_string_lessthancaml_string_lessequalcaml_string_greaterthancaml_string_greaterequalcaml_blit_stringcaml_fill_stringcaml_is_printablecaml_bitvect_testcaml_sys_exitcaml_sys_opencaml_sys_closecaml_sys_file_existscaml_sys_removecaml_sys_renamecaml_sys_chdircaml_sys_getcwdcaml_sys_getenvcaml_sys_get_argvcaml_sys_system_commandcaml_sys_timecaml_sys_random_seedcaml_sys_get_configcaml_sys_read_directorycaml_terminfo_setupcaml_terminfo_backupcaml_terminfo_standoutcaml_terminfo_resumecaml_register_named_valuecaml_weak_createcaml_weak_setcaml_weak_getcaml_weak_get_copycaml_weak_checkcaml_final_registercaml_final_releasecaml_ensure_stack_capacitycaml_dynlink_open_libcaml_dynlink_close_libcaml_dynlink_lookup_symbolcaml_dynlink_add_primitivecaml_dynlink_get_current_libs„•¦¾p$T�-Out_of_memory�)Sys_error�'Failure�0Invalid_argument�+End_of_file�0Division_by_zero�)Not_found�-Match_failure�.Stack_overflow�.Sys_blocked_io�.Assert_failure�:Undefined_recursive_module,really_input%input @ F@ @ G@&output A C D F@ A C D G@%%.12g!."%d%false$true.bool_of_string$true%false+char_of_int/Pervasives.Exit_jð_jÿð_jð_jïÿÿÿÿÿÿ_j_j<°5Pervasives.do_at_exit@(List.nth#nth)List.map2*List.iter2/List.fold_left20List.fold_right2-List.for_all2,List.exists2 @@,List.combine°'list.mlÔK-List.rev_map2"tl"hd@"\'"\\"\n"\t(Char.chr@5String.rcontains_from4String.contains_from2String.rindex_from1String.index_from +String.blit+String.fill*String.sub@)Sys.Break&3.08.4@ 	%Lexing.lex_refill: cannot grow bufferÀ @@ÿÀ A@@@!`	 Unterminated `...` at character +emit_char '!'-emit_string "!""; ,8üÿýÿÿÿþÿ8ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ8ÿÿÿÿ	ÿÿÿÿ
+ 0
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ ÿÿ	ÿÿÿÿÿÿ
+ 0ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ	ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ	ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ      @@„•¦¾|=! UÐÐÐÐ@°@$CharAyÐ@°@(Cvt_emitAS@AB°@&LexingAJÐ@°@$ListAs@AC°@*PervasivesAdÐÐÐ@°@(Std_exitAT@A°@&StringAB@B°@#SysAEÐ@°P-Match_failureCG@ACD°Q-Out_of_memoryC@ÐÐÐ@°R0Invalid_argumentCC@A°S'FailureCBÐÐ@°T)Not_foundCF@A°U)Sys_errorCA@BC°V+End_of_fileCDÐÐ@°W0Division_by_zeroCE@A°X.Stack_overflowCHÐÐ@°Y.Sys_blocked_ioCI@A°Z.Assert_failureCJÐ@°[:Undefined_recursive_moduleCK@ABCDE„•¦¾ë$‰o  %Array0©·˜Ý–eÂÓcV6Ò“@<  &Lexing0AS\6j�ÞS�¡ õà¹(  $Char0  Õ…F€¶”š/°ÊNa  *Pervasives0qøˆE;&‰XF
+ rðt“  &String0þÈ)+± -,{‹K§¸:}‹  (Cvt_emit0q¡)ô'J�Iüz›Ø   $List0Z2ü5kÑ�`¿óaßÓ  #Sys0ŒÎw
+ B·ÐäØUiÁ]xAÖ  (Std_exit0Ì¬˜QË;ï«ÆM÷2µ7@CODEaœDLPTDLLSPRIMtDATASYMB�CRCSÿCaml1999X008
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/tools/ocamlcp.ml seminalOcaml/tools/ocamlcp.ml
*** ocaml-3.08.4/tools/ocamlcp.ml	2005-03-09 07:49:09.000000000 -0800
--- seminalOcaml/tools/ocamlcp.ml	2009-01-19 09:42:02.535851176 -0800
***************
*** 83,88 ****
--- 83,91 ----
    let _where = option "-where"
    let _nopervasives = option "-nopervasives"
    let _dparsetree = option "-dparsetree"
+   let _dprintcode = option "-dprintcode"
+   let _use_seminal = option "-seminal"
+   let _no_triage = option "-no-triage"
    let _drawlambda = option "-drawlambda"
    let _dlambda = option "-dlambda"
    let _dinstr = option "-dinstr"
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/tools/ocamldep.bak seminalOcaml/tools/ocamldep.bak
*** ocaml-3.08.4/tools/ocamldep.bak	1969-12-31 16:00:00.000000000 -0800
--- seminalOcaml/tools/ocamldep.bak	2009-01-19 09:42:00.175804172 -0800
***************
*** 0 ****
--- 1,1276 ----
+ #!/projects/null/swlab8/blerner/projects/seminal/seminalOcaml/bin/ocamlrun
+ Tß)*VDC2"@(()*…c(`¨
+ „5?[on2$	]�()*^ž()*^ž()*^Ÿ()*^¢(]¤(]™()*^›(]¦(]¦(]§(]K()*^©(]«(]™(]˜()*^›()*^£(]¥(]š()*^ª(]¬(]š(c!]Ö(cC%c!c%C
+ +óÿÿÿI(
+ ]Ç
+ ]ÈhhaÒ()*&c!](c!]O(]�%g
+ ^ž]�("g
+ ^ž]�(!&!&&^ž(g
+ ^ž]�("g
+ ^ž]�(!&!&&^ž(Y]˜Z(h()*VDC
+ ]Ç
+ ohaÒo2'	()*]­
+ „V	]È'5?[ˆ)ÿÿÿÿ]Èÿÿÿÿh`¨c]¦cVnÿÿÿÿ@]È'(m]Èmh`¨co@2&,�ÿÿÿ,œÿÿÿch&)*‡‡
+ ]Ço}V5%$)*‡‡
+ ]Ço}V5%`¨(h6'h6')*_×]”(Y]�ZThY]˜Z(h(]�]˜()*c_()*‡‡
+ ]Ço}V5%`¡()*]Çh`¡(VDC	Y]�ZTh2%c(,ãÿÿÿc]–%l¶6'l¶6')*_×]•(6^%~V5&^É
+ ‡0†:	T
+ „-T(2%]Ç
+ ,Ïÿÿÿc%6^P(5^ÌV5^ÌV5%d(c(V5(5(‡ˆÿ5%()*]Ç]Ç
+ n]ÈhhaÒhaÒ(gÿÿÿÿu(‡(m()*^V(()*^V((6@[6@[+øÿÿÿ	+îÿÿÿ6?	+Øÿÿÿ	+Åÿÿÿ	+µÿÿÿ	+«ÿÿÿliv„gTg>iv
+ ÿÿÿÿ6]~6]~6]~6 ]~6!]~6"]~	+^ÿÿÿ+Hÿÿÿ	+9ÿÿÿ+ÿÿÿ	+ÿÿÿ	:+üþÿÿ
+ +Èþÿÿ	,ºûÿÿc]”i]•j]•	+«þÿÿ
+ +žþÿÿ+’þÿÿ	+„þÿÿ	+Zþÿÿ+4þÿÿ	+&þÿÿ	+þÿÿ	+ÿýÿÿ	+ðýÿÿ
+ +äýÿÿ+Ùýÿÿ%+´ýÿÿ	,Œûÿÿ(+ˆýÿÿ	+týÿÿ	+èüÿÿ+Ýüÿÿ+Ñüÿÿ+Áüÿÿ+±üÿÿ+œüÿÿ+�üÿÿ+‚üÿÿ+vüÿÿ"+füÿÿ +Vüÿÿ+Aüÿÿ+2üÿÿ!+"üÿÿ
+ +üÿÿ+üÿÿ	:,+þûÿÿ	+èûÿÿ?
+ +Õûÿÿ+Åûÿÿ
+ +¹ûÿÿ6#^é.
+ 
+ 	+ ûÿÿ	+—ûÿÿ	+‹ûÿÿ	+�ûÿÿ	+xûÿÿ	+lûÿÿ>	+\ûÿÿ	+Pûÿÿ	+Gûÿÿ	+>ûÿÿ	+2ûÿÿ	+(ûÿÿ	+ûÿÿ	+ûÿÿ),*	+ûÿÿ213	+õúÿÿ79	+çúÿÿ	+Þúÿÿ	+Òúÿÿ>	+Ãúÿÿ	+¶úÿÿBD	+¥úÿÿG	+™úÿÿLKM02468:<>@BDFHJL_acegkmoqsuwy{}ƒƒƒ‡‰‹���>QB9$T)*V
+ D
+ 2&()*|V
+ $eq
+ o		n	n2 n2 n	n$)*cÿÿÿÿ	}UH\n^nÿÿÿÿ?	T\C^C_€ÿÿÿÿC~VC^"…àÿÿÿcC_	zUºÿÿÿc()*"…._{V^2$o$_{V^2$o$)*nn
+ 	,‰ÿÿÿ	^^$)*+Óÿÿÿ+ÿÿÿ
+ ,ÇþÿÿO|V	hh$
+ eq
+ oh^^	
+ h 
+ h c	h$)*"^"ˆ^_2'_()*Y	#Z(CyV
+ D_([)*"
+ ^_2&)*fÿÿÿÿq
+ zVcT5%6
+ @[^"†^_ˆ2&h_(_()*Y"Z(CyVD
+ ([)*nn
+ ?{V0^^"h}VI^C^"h}VIC({V^^"†({V(@[)*+Žÿÿÿ
+ ,Öþÿÿ,õþÿÿ,ÿÿÿ+\ÿÿÿ,ÿÿÿOkqÿÿÿÿh	{U\^	#	ÿÿÿÿzUìÿÿÿcÿÿÿÿj	{U%\^h^_h""	ÿÿÿÿzUÝÿÿÿci{Vd	^h
+ ^i_h_(	)*?Oÿÿÿÿh	{U\C^	"I	ÿÿÿÿzUìÿÿÿcC()*?hOÿÿÿÿ	}U\^	C"I	zUìÿÿÿcC()*VDC
+ _2&(VDC
+ h"^
+ ,Öÿÿÿi&:()*†(^	@ÿÿÿÿ2&,æÿÿÿcOÿÿÿÿ&)*O
+ „:(c^	h"^iÿÿÿÿ	}U\^	"_	zUëÿÿÿc()*cOÿÿÿÿ	}U\^	"	zUïÿÿÿc()*O
+ „:(c^	!^iÿÿÿÿ	}U\^	!_	zUìÿÿÿc()*cOÿÿÿÿ	}U\^	!	zUðÿÿÿc()*‡‡Oo}U‡	Oo}V5&8$%{V$ÿÿÿÿh	{U\n^	n_	ÿÿÿÿzUêÿÿÿc(cÿÿÿÿ	}U\n^	n_	zUêÿÿÿc()*‡‡	Oo}V5'8$%nÿÿÿÿ	}U\_	zUñÿÿÿc()*‡‡	Oo}V5(8$%„:(^	^iÿÿÿÿ	}U\n^	_	zUìÿÿÿc(VDC
+ Oˆ	h^	&2%:(,àÿÿÿ%)*VDCOn2&()*V/DChOÿÿÿÿ	}U\^	n_	zUìÿÿÿcOn2&c()*,¯ÿÿÿh"^
+ ,¸ÿÿÿh"()*OO„„:(cˆT^	n^hÿÿÿÿ	}U\^	_	zUîÿÿÿccÿÿÿÿ	}U\^	n_	zUìÿÿÿc(O
+ „:(c^	^iÿÿÿÿ	}U\^	_	zUîÿÿÿc()*:^hÿÿÿÿ	}U\^Q	zUïÿÿÿc()*„:(c!^iÿÿÿÿ	}U\!_	zUïÿÿÿc(+Îÿÿÿ	+¢ÿÿÿ
+ 	+jÿÿÿ	+ÿÿÿ	+äþÿÿ
+ +‰þÿÿ	+þÿÿ	+ãýÿÿ	+nýÿÿ	+Iýÿÿ	+ýÿÿ	+æüÿÿ	+§üÿÿ	+•üÿÿ	,§øÿÿ+Züÿÿ	+üÿÿ	+âûÿÿ6)?
+ +=ûÿÿl
+ +Âùÿÿ
+ 
+ 
+ ! #&(*>9*Tû)*V
+ D
+ 2&()*VDC„(ˆÿÿÿÿ2&5+8$%5,8$%)*VDC@2&(VDC2!8$&c()*VDC
+ !2"@(c()*VDC
+ !2&c()*VDC"2'()*VDC2#&()*VVDCDC"	2#@(
+ Uc(5-8$%)*VVDCDC"2'Uc(5.8$%)*VVDCDC#	2$U(5/8$%)*VV!DCDC	
+ 2 	'U(508$%)*VDC
+ !V2&(d()*VDC
+ !U2&(c()*VVDCDC"V2'(	Ud(518$%)*VVDCDC"U2'(	Uc(528$%)*VDC^hyU2&(c()*VDCyU2&(c()*VDC
+ DC^„(2&5?[)*VDC
+ DCyV(2&5?[)*VDC
+ C^hyU2&(c()*VDC
+ CyU2&(c()*VDC
+ C^„(2"@(c()*VDC
+ CyV(2"@(c()*VDC
+ !V(2&5?[VDC
+ DC2!
+ DC@@@(53()*VVDCDC2"@@(Uc(548$%)*V0V)DCDC"…2#@(	2#@(	
+ (
+ ()*„(V
+ D
+ ÿÿÿÿ2&556
+ @[)*V/V&DCDC"…@2'@2'&&)*V/V&DCDC"ˆ@2'@2'&&)*ƒ�„´V±D
+ V€D
+ VwCCC"…5"…c@@@(	"…c@@@(	c@@@(	"…c@@@(	"…c@@@(	c@@@(	T-T)V&D
+ VCC"…
+ c@@(c@@(ix
+ o"3"3"h')*ƒ‹„®V«D
+ V{D
+ VrCCC"ˆ3"ˆc@@@(	"ˆc@@@(	c@@@(	"ˆc@@@(	"ˆc@@@(	c@@@(	T,T(V%D
+ VCC"ˆ
+ c@@(c@@(ix
+ o"1"1"h')*,Òýÿÿ,þÿÿ,<þÿÿÿÿÿ!
+ †(&	)*VDC
+ !V
+ @2'@2'!!@()*,Îÿÿÿhh')*VDC
+ !V	@2&2&%,Üÿÿÿc%)*VVDCDC"@2'U(568$%)*,Íÿÿÿh')*VDC!@2&()*,ãÿÿÿh&c&VD
+ (578$%VC
+ (588$%h&,ùÿÿ+ôÿÿÿ	+áÿÿÿ	+Îÿÿÿ	,ùÿÿ7$	,'ùÿÿ+¸ÿÿÿ	,2ùÿÿ	,@ùÿÿ+žÿÿÿ	,Qùÿÿ,bùÿÿ,tùÿÿ,†ùÿÿ+eÿÿÿ	,®ùÿÿ,Öùÿÿ,úÿÿ,/úÿÿ,Dúÿÿ,Yúÿÿ,…úÿÿ,±úÿÿ,Éúÿÿ,Þúÿÿ,üúÿÿ,ûÿÿ,2ûÿÿ,Iûÿÿ,gûÿÿ,ƒûÿÿ+çþÿÿ
+ +³þÿÿ	,Žûÿÿ,­ûÿÿ,Õûÿÿ,üÿÿ"(+Hþÿÿ
+ 	!#%')+-/24379<>=BBFHGKMOQ>)+99T¼)*o(‡aˆz‡àˆö	‡ø
+ …þàÿÿÿ((‡AˆZ‡ÀˆÖ	‡Ø
+ …Þ ((‡'ƒ\	†(5:(5;(ƒ		„
+ 	5<(5=(]ÔVd]ÈhS(l]Èl\hSgdql0niSg
+ l
+ qrl0njSg
+ rl0nkS(‡ˆÿ5>8$%(+ìÿÿÿ	+‡ÿÿÿ	+cÿÿÿ	+?ÿÿÿ	+4ÿÿÿ
+ >9?TÉ)*~V5?[RyV(2$)*†5?[RyV(ÿÿÿÿ2')*^()*h')*‡]Ç~V5@8$%Y#cdZ(6CyVc([)*‡]Ç}V5A8$%Y			]Ç
+  cdZ(6CyVc([)*‡ÿÿÿÿ]Ç~V5B8$%')*]Çÿÿÿÿ')*‡]Ç}V5C8$%]Ç$)*h]Ç$8?&8?&)*]Ç„(!hR!hS(8?&8?&)*]Ç
+ „(]Èhÿÿÿÿ	}U\R!S	zUîÿÿÿc(c?h]Çÿÿÿÿ	}UM\R
+ ÷ÿÿÿ
+ ‹þÿÿÿ
+ ŒT%TTƒST	TT]ÔVdTgTeCnI	zUµÿÿÿc]ÇCyV(C]ÈhIc]Çÿÿÿÿ	}U¡\R
+ ‡"ƒ\x†#-Trƒ	„
+ #g\CS€gnCSTgg\CS€gtCSTV
+ ]ÔVCST7l\CS€gdql0nCS€g
+ l
+ qrl0nCS€g
+ rl0nCSTg\CS€CS€	zUaÿÿÿc(]ÇChaÒ]ÇCnI]ÇChaÒ]ÇCnI(€]ÇCnI()*V?DCh?h?+Þÿÿÿ89	"Cÿÿÿÿ]ÇpCn]È]ÇhhaÒ]Ç?	+‘ÿÿÿ89	"(5D()*c]Çÿÿÿÿ	}U\R!	zUñÿÿÿc()*‡‡]Ço}U‡
+ ]Ço}V5E8$%aÒ()*‡‡
+ ]Ço}V5F8$%`Ó()*‡‡
+ ]Ço}V5G8$%]ÈhaÒ(]Ç
+ ]ÈhhaÒ()*]Èh`Ó(+ðÿÿÿ	+Ûÿÿÿ	+°ÿÿÿ	+‰ÿÿÿ	+Tÿÿÿ	+/ÿÿÿ	+ãþÿÿ	+‹ýÿÿ	+Výÿÿ
+ +Jýÿÿ+?ýÿÿ	+!ýÿÿ
+ +ýÿÿ+
+ ýÿÿ	,ýûÿÿ+õüÿÿ+Òüÿÿ	,üÿÿ+¼üÿÿ+�üÿÿ+büÿÿ+1üÿÿ+$üÿÿ	+üÿÿ
+ 	"$&(*>9HT!?[V+öÿÿÿ?&c&)*^Æc(c]ß
+ DCh]ã
+ DCöÿÿÿivÿÿÿÿ
+ lqpÿÿÿÿh?	+Ôÿÿÿlÿÿÿÿlþÿÿÿlýÿÿÿlüÿÿÿlûÿÿÿlúÿÿÿlùÿÿÿløÿÿÿl÷ÿÿÿlöÿÿÿlõÿÿÿlôÿÿÿlóÿÿÿlòÿÿÿlñÿÿÿlðÿÿÿlïÿÿÿlîÿÿÿlíÿÿÿlìÿÿÿlëÿÿÿ6I?
+ +‹ÿÿÿ6J
+ 
+  "$&(*,.044886=?> "9KT0)*VEDC
+ ^„(2&5?[)*VEDC
+ C"V(2&5?[VECC"U2%(c()*,áÿÿÿDO!rD^%VEDCC"VA(2!A(5?[)*,ÒÿÿÿDO!r
+ D^	Y!	D_Z(6CyV"AD_CIdDOvC}V&	([VEDCC"V	2!@(2%c()*,ÙÿÿÿDO!rD^%)*DO!rD^
+ VIEDC
+ C"V(V1EDC
+ 	C"V(	VEDC
+ C"V(&5?[5?[5?[V EDCC"V
+ CÿÿÿÿI(2!A(c()*,ÒÿÿÿDO!r
+ D^!D_()*DO!r
+ D^A
+ D_CIdDOvC}V&(7$D!s(+ðÿÿÿ
+ +»ÿÿÿ+—ÿÿÿ,þÿÿ	+ÿÿÿ	+ëþÿÿ
+ +uþÿÿ+3þÿÿ
+ 
+ >()*VEDC#2&()*,âÿÿÿD?hOÿÿÿÿ	}U\C^"I	zUìÿÿÿcC(VEDC"2%c()*,åÿÿÿDhOÿÿÿÿ	}U\^!	zUðÿÿÿc(VEC^hyU2%(c()*,áÿÿÿDO!rD^%VEDC^„A(2!A(5?[)*,ÓÿÿÿDO!r
+ D^	Y!	D_Z(6CyV"AD_CIdDOvC}V&	([VEDC^„	2!@(2%c()*,ÚÿÿÿDO!rD^%)*DO!rD^
+ VIEDC
+ ^„(V1EDC
+ 	^„(	VEDC
+ ^„(&5?[5?[5?[V EDC^„
+ CÿÿÿÿI(2!A(c()*,ÓÿÿÿDO!r
+ D^!D_()*DO!r
+ D^A
+ D_CIdDOvC}V&(VEDC2!!r
+ ^A_(c()*D
+ O8Kjp8$"zV.c^
+ ,¼ÿÿÿcÿÿÿÿ	}U\^!	zUðÿÿÿcJ(C(D8*!C@(cDOÿÿÿÿ	}U\cD_	zUðÿÿÿccI(7Ki8$"8$"h^h@(ldl
+ _J(+õÿÿÿ	+Ûÿÿÿ	+³ÿÿÿ	+£ÿÿÿ	+›ÿÿÿ	+Qÿÿÿ
+ +úþÿÿ+Øþÿÿ	,®úÿÿ	+Jþÿÿ	+/þÿÿ+¼ýÿÿ+|ýÿÿ	+8ýÿÿ	+íüÿÿ
+ +tüÿÿ	
+ >9LT5)*^(6M^b(5N^Y(5O^V(]Q(5P^S(5Q^R(5R6S6T	+ðÿÿÿ	+åÿÿÿ	+Òÿÿÿ6U6V	+Ãÿÿÿ	+¸ÿÿÿ	+¬ÿÿÿ
+ 
+ >9WT5)*^(6X^{(5Y^n(5Z^V(]f(5[^h(5\^g(5]6^6_	+ðÿÿÿ	+åÿÿÿ	+Òÿÿÿ6`6a	+Ãÿÿÿ	+¸ÿÿÿ	+¬ÿÿÿ
+ 
+ >9bT5)*^(6c^’(5d^‡(5e^V(](5f^�(5g^€(5h6i6j	+ðÿÿÿ	+åÿÿÿ	+Òÿÿÿ8K
+ ÿÿÿÿ6k^ˆ6l^�	+¸ÿÿÿ	+­ÿÿÿ	+¡ÿÿÿ
+ 
+ >9mTKcMcLGhEDC>McK(G(G
+ (GF(G
+ F()*GnD^É()*‡
+ D^É?(c()*D^É()*‡o
+ ]ÈhDaÒ?(c()*o
+ ]ÈhDaÒ(GGo
+ ]ÈhGDaÒ(dM(	:ihhhhh	]Ç6n8$"	+áÿÿÿ>()*h8$>$+ñÿÿÿ%	:hhhhhhhl]Èl]È">()*]Ç"
+ ˆTdMcD]ÇEn}V¼D]ÇGEon|VGEoh	D
+ GD8H TB7KD]Çjp8$"
+ GEon}V5o8$!]È		G
+ EohGD8H JG
+ FnLGoMcMGoMEoKG	hOÿÿÿÿ	}U\^
+ h|Vo_	zUäÿÿÿcE	Dh
+ 8H EnK()*_¯
+ h|VGM
+ GGFnEDC>M()*_®
+ h|VGM
+ GGFnEDC>M(5p	+Ïÿÿÿ	+žÿÿÿ	+¦þÿÿ6q
+ +‚þÿÿ
+ +wþÿÿ+Gþÿÿ	+&þÿÿ	+þÿÿ	+îýÿÿ	+àýÿÿ	+Éýÿÿ	+·ýÿÿ	+¬ýÿÿ	+¢ýÿÿ	+™ýÿÿ	+�ýÿÿ	+nýÿÿ
+ 
+ ">9rTòc(C%!F(!F(c!F(c!F(GoG
+ oF^(GoG
+ oE^(G
+ F^(GˆGG
+ oE^(G
+ F^()*G
+ oD^()*`Å
+ W"*2_!G
+ MGM	i2&?[c!cj2&c!ck2&YGC^!l@ZTCyVcl@T[
+ DC2&5sG!cl2&]¼V]½E^y(D^y()*,bÿÿÿG
+ GGGGGGMM
+ GM	Y	ch"Z(GM
+ MMMMMCyVD
+ (
+ +~ÿÿÿI[c(cGhD8* cM(Gjph^h^8r^8r^	hhC8* IhhD8* JhhE8* KhhF8* LM(5t?6u?hhhhhh8r8rhhhld8rld^8rld^hld^hld^>
+ +cÿÿÿ+Kÿÿÿ	+Dÿÿÿ?
+ 	+Ëþÿÿ	+'þÿÿ+þÿÿ+÷ýÿÿ+äýÿÿ+Ðýÿÿ+Æýÿÿ+¼ýÿÿ+²ýÿÿ+¨ýÿÿ
+ +žýÿÿ	+—ýÿÿ
+ >9vTò!
+ G
+ G!GGG GGGG	G
+ GGGGGGGGGGFGGG>()*V)EDCC"
+ „(†
+ 2"'	2"'	dhh>()*VJVBFEDCFEDC}V2#'}V2#''&&VC
+ V2%D
+ (5?[VEDV2%(5?[VC
+ VED2!'E
+ (5w8$%)*VGEDCC"
+ „iA(†2"
+ EDC#A(
+ 2"
+ EDC		#A(
+ 5x()*VEDCC"
+ hyU†T2&(c()*V+EDCC"
+ „&†
+ 2"'	2"'	c()*V_VXFEDCFEDC~V „
+ &"
+ EC2"2"'„&
+ "
+ EC	2"		2"'
+ (
+ ()*V8V2EDC"
+ DCƒE
+ 2"2"'E
+ 2"2"&c(c()*V8V1EDC"
+ DCƒE
+ 2"2"&E
+ 2"2"'
+ (c()*VEDCA2&()*V*V$EDCEDCC"
+ ƒ(""2&d(Vgÿÿÿÿ(c()*VTVNEDCEDCC"
+ „2"V2&(†hh>2"V2&(hh>2"V2&(c(d()*VEDC
+ 2"!2&c()*VEDC2#"2'	()*VEDC!V2"V2&(d()*VEDC!U2"U2&(c(VEC2!2!n(c()*VEDC
+ 2"@2&(h&)*DCV#EDC!V
+ "@T"@2"2&	()*,Êÿÿÿ6y&)*VEDC!V"T2"2&()*,×ÿÿÿh&)*"hy()*c"h"&dhh>(Vc(d()*VV!!'
+ (
+ ()*VV!!'
+ (
+ ()*VF
+ TcVF
+ Tc
+ }VDV:EDC!!~V#'VEDC
+ 
+ ##'5z8$%	5{8$%}VFV<EDC
+ !!~V		#'VEDC##'5|8$%	5}8$%~VT>()*VF
+ TcVF
+ Tc
+ ~VT>(VF
+ (c(+óÿÿÿ	+Âÿÿÿ
+ +ùþÿÿ
+ ,Qúÿÿ,�úÿÿ,Òúÿÿ,äúÿÿ,õúÿÿ+¼þÿÿ+™þÿÿ,ûÿÿc	+ƒþÿÿ,Hûÿÿ+qþÿÿ,cûÿÿ,�ûÿÿ,îûÿÿ	,'üÿÿ,eüÿÿ,vüÿÿ+0þÿÿ
+ +!þÿÿ,¢üÿÿ,üüÿÿ,ýÿÿ,+ýÿÿ,Hýÿÿ+øýÿÿ+Âýÿÿ	,Yýÿÿ,kýÿÿ+€ýÿÿ
+ 
+  "$&(*,.02468:<>@B>"(#+ÿÿÿ
+ +	ùÿÿ?9~T})*{Vc^É
+ ƒ$1„\g\""2&ƒ\
+ "2&2&„\"2&"
+ DC
+ !"l 2&()*]Ç
+ ,„ÿÿÿcl &)*^É
+ ƒ(ƒ{"
+ o8H#@(	h! 
+ oÿÿÿÿ8H#@()*~V(^É
+ †_‡:¿ÿÿÿ
+ ŒTeTd†0`T[‡{S‡ÀS@ÿÿÿ
+ W@@@@DDDD@@@@@DD@@DDDD@DDDD@D@@DDD@@@DDDD@@@@@DD@@DDDD@DDDD@D@@DDDTT„`(2&)*,jÿÿÿ]Ç&)*~V5?[^ÉyV2'^ÉyV„(ÿÿÿÿ2'2')*,¸ÿÿÿ]Ç'	ƒ(ƒ{56
+ @[g}(g)()*DhC8$/$)*EDn}V"DC8$? DnJ()*DhC$)*]Ç
+ DnE}V"DCh
+ 8H J()*h}Uh}U]Ço}V5€8$!DnE}V"DC		8H J()*DE~Vd"C_ÊJ()*E
+ ?	T\CjpICDn}Uñÿÿÿc7KC}V7KDn|V7KIT5�8$!C]È	Dhh
+ C8H ICK(cJFIC]ÇK(cJ(D()*‡D~V5‚8$%C^É()*‡‡	Do}V5ƒ8$%]È	hC8H (DhC8H'†dT8K}V7KT
+ ]È
+ h>(+Ýÿÿÿ	+Ïÿÿÿ	+œÿÿÿ	+}ÿÿÿ	+tÿÿÿ	+kÿÿÿ	+Xÿÿÿ	+ýþÿÿ
+ +Ýþÿÿ+šþÿÿ+nþÿÿ+]þÿÿ+4þÿÿ	+!þÿÿ	+þÿÿ	+ðýÿÿ	+�ýÿÿ
+ +Áüÿÿ
+ +¢üÿÿ	>9„T…~Vc(R
+ ƒ%
+ 8„"2%0443	$)*8„"1%)*"4üÿÿÿ%)*!4úÿÿÿ%4øÿÿÿ%)*8$J!
+ ]Ç
+ ,–ÿÿÿÄÿÿÿÒÿÿÿßÿÿÿéÿÿÿc%
+ (	+ùÿÿÿ&~V8„!8„!
+ %R
+ ƒ%8„"2%0443	$)*8„"1%)*h"	8„"4üÿÿÿ%)*c!8„"4úÿÿÿ%4øÿÿÿ%)*8$J!
+ ]Ç
+ 8„!
+ ,uÿÿÿ±ÿÿÿ¿ÿÿÿÑÿÿÿáÿÿÿc%8$&8$&~Vc(R
+ ƒ%
+ 8$-"2%0443	$)*8$."1%)*"4üÿÿÿ%)*!4úÿÿÿ%8$+!4øÿÿÿ%)*8$J!
+ ]Ç
+ ,‘ÿÿÿ¿ÿÿÿÍÿÿÿÚÿÿÿäÿÿÿc%
+ @&)*R
+ àÿÿÿ
+ ŒT.W"TT	2+ºÿÿÿ(3&2&8$!&„F8$!T	
+  ^&	 #&„ci8H"&6…8?!8$"6†8$"&„sT5‡8H!8$"6ˆ8$"yV
+ &	 "&&	 ^’&	 ln#&	 ^b&)*'	 ^{&)*R
+ ßÿÿÿ
+ ŒWT�WXX___c____________________________lp_ttt____x_È____Ì____È________ÐlpÈttt_È__Ø_(È___Ì�È__È
+ %T'6‰&T]T-TER
+ ¨ÿÿÿ
+ Œ T+W!!%%%%%%%%%%%!%%%%!%%%%%!%%%%%!%%!T
+ &+ÿÿÿ(TßTÁ+óþÿÿ(R
+ ¨ÿÿÿ
+ Œ T+W!!%%%%%%%%%%%!%%%%!%%%%%!%%%%%!%%!T
+ &+‰þÿÿ(R
+ ¨ÿÿÿ
+ Œ T+W!!%%%%%%%%%%%!%%%%!%%%%%!%%%%%!%%!T+$þÿÿ(+ýýÿÿ(	+îýÿÿ(&+”ýÿÿ(
+ +cýÿÿ(
+ +7ýÿÿ(
+ +ýÿÿ(+ðüÿÿ()*,
+ ’üÿÿþÿÿh&
+ )*ƒNƒn^P(gu]Çÿÿÿÿ_Ê^P()*}V8„%Rƒ*
+ 8„"2&VDC
+ 8$!8„"2&&)*Vo
+ 8„!
+ ,¦ÿÿÿ89!&o8H')*!
+ DC]Çhl $)*yV„(|V	8H'	8H"V	h8H T	
+ o8H ()*]Ç~Vh@(R
+ ‡1†: ]Çoÿÿÿÿ8H#]O@(„-i2&2&,¼ÿÿÿYdh"Z(6CyVc&[)*]Ço8H#6Š8$"8$%+æÿÿÿ
+ +Åÿÿÿ	+6ÿÿÿ
+ +ÿÿÿ+éþÿÿ	+€þÿÿ
+ +^þÿÿ
+ +×úÿÿ
+ +núÿÿ+cúÿÿ+=úÿÿ
+ +¿ùÿÿ+žùÿÿ	>9‹TÕYJG!
+ CEDh}VG	G
+ Go{XV$G!c†T
+ #Gn	M2!Z(CyVc([)*h{V…P	hG'gPhG#°ÿÿÿ2&((	+ùÿÿÿ&"%g8„!
+ !
+ +êÿÿÿi'c&!
+ +ôÿÿÿ&&&&h&)*?I!%+~V)(%*^É
+ ƒ%ƒ@-!2%+~V*"&*^É
+ ‡AU‡^+…ÿÿÿ
+ ŒTØW)4&TÅc)"2%‡[µ¥ÿÿÿ
+ W)4&TŸc)"2%ƒ
+ ƒ‡ ‹àÿÿÿ
+ W!!-----------1-=------------IR--bnc)"2%TTc) "2%c)"2%)4&02,+üþÿÿ
+ 4
+ &c)"2%-!2%c)"2%*"&0443*8‹$)*,!1%)*#V
+ h"*!T%"4üÿÿÿ%)*!V	c!(!T#!4úÿÿÿ%c!"4øÿÿÿ%&)*&)*&)*#&~V&^É
+ ‡0†:	T'„-T!yVh&o8H##&2%)*!~V & ^É
+ ƒ Bƒ%! ,’ÿÿÿ% +{ÿÿÿ +lÿÿÿ +]ÿÿÿ +Pÿÿÿ
+ 	 8‹$2&~V&^É
+ ƒ ƒ>&(2%~Vl@(^É
+ ƒbxƒhƒvl@(i@(~Vh@(^É
+ ƒoƒvh@(j@(~V
+ 6Œ'^É
+ ƒvi8H"6�8$"'	k@(l@(6Ž')*%)*Vc!Tc+ëÿÿÿ"@@')*Vh"T"@@')*@@')*~Vo8H#"&^É
+ ƒ%ƒ>	2'o8H#"&o8H#
+ 2+¡ÿÿÿ2+zÿÿÿ2+Qÿÿÿ+<ÿÿÿ
+ 8‹$)*,vÿÿÿh')*3!&)*#!%)*~Vc"4îÿÿÿ%^É
+ ƒ<c"4îÿÿÿ%4úÿÿÿ4øÿÿÿ4îÿÿÿ,´ÿÿÿ¿ÿÿÿ4øÿÿÿ&)*#!%)*~Vgh#4ìÿÿÿ%^É
+ ƒ<gh#4ìÿÿÿ%4úÿÿÿ!
+ DC
+ 4øÿÿÿ4ìÿÿÿ+¶ÿÿÿ
+ 4öÿÿÿ&	)*"!%)*~V5�"4êÿÿÿ%^É
+ ƒ<5�"4êÿÿÿ%4öÿÿÿ4êÿÿÿ+Åÿÿÿ
+ 4úÿÿÿ&C
+ VC#cI(&C
+ VCi8H"#cI(&)*8$J!
+ ]Çh?
+ +Îÿÿÿ+®ÿÿÿ
+ 
+ 	,�úÿÿ×ûÿÿâûÿÿüûÿÿüÿÿ„üÿÿäüÿÿýÿÿzþÿÿ¯þÿÿûþÿÿKÿÿÿc%)*V@89!6‘8H&()*g8„!
+ !"&)*c"%8„!8„!()*Y]OZ(6CyV&[)*6’#8$%)*6“')*#8$%)*]Ç{V5”^Éi8H"8$"6•8$"Tg.i8H"8$!8$"6–8$"8$"6—8$"8$"6˜8$&c"8„!8„!(8„	!&c(8$+%+÷ÿÿÿ8$/!&c(c()*+õÿÿÿ	+íÿÿÿ 
+ !M!M()*dh6™G')*c!h6šlÿÿÿÿA"i@@hh6›8$iiiihlNlNöÿÿÿl
+ lNhhhh>(c(5œ8$"6�8$&5ž8$"6Ÿ8$&8$+%)*8$/!M+ìÿÿÿM()*GGGG>(%c%)*#+ñÿÿÿM+æÿÿÿM()*GG@()*MM()*G()*i|V0!
+ MGG|VGTdjGqGGo8$"8$"
+ &()*G()*Go&)*i|V!
+ MGGoM%({V(ÿÿÿÿ()*G()*M()*GGy()*G()*i{VM()*GG{V
+ chhA&()*ch')*GG{V@GmAi'()*Gi{VGG{V	cjhA"GÿÿÿÿM()*GMGG{Vch???hA&()*ch')*ci')*GG{V@GmAi'()*GG{VclhA&()*GG{V
+ ckhA&()*c"cG%)*d"cG%)*g')*f')*e')*d')*ch')*d]Èh_Êi')*8$!&)*8$!&)*8$!&)*]Ç')*GG{V'()*T\c"G…õÿÿÿcM!V!%!!cJcKcLcMcM	cMGM%)*FEDC
+ MMMM()*GGGG>()*"&)*G()*G()*M()*M()*GV
+ clhA"GVF
+ VDC
+ G!L(c()*GVF@LG!GVc?hA&()*Gi{V"GG{VcihA"d"c"GÿÿÿÿM(fh')*GMGG{Vc@GmAh'GGyVG&()*"Vd"CG@@I()*C
+ VOC
+ DCCDDG{V%
+ W""XVGnII(	c(	VGnII(	c(I()*]Ç')*?A&)*"%)*VDC^V(2&5?[)*VDC
+ ^V@(2"@(c@()*W,@Obv’¦%‡ÁÌE
+ VC
+ C	,½ÿÿÿCGGo"I(c(D
+ VD
+ VJ(c(E
+ VD
+ K(c(D
+ VC
+ D
+ &%GGoG	zV%(G
+ VDC
+ G!
+ "M(c(CGoM"cM
+ (DCD
+ VtC
+ DC
+ W/d&''G}V'&G
+ V&G}V'GonG	}V'&&c(DCGGoE
+ VPC
+ C	,|þÿÿC
+ V"C	YC"ZT6CyVT[To
+ ‡
+ n
+ &	G	n'c(DCGGoG}V!GoƒG}VTgTdD@@J(CE@K(C
+ G!
+ "G@M(G!
+ CE
+ GoMGnM(D
+ V!C
+ DCG}Vƒ‡c(&c(%)*GoM&)*h')*!dM
+ Gon
+ G8$"
+ M	G	GoMG	&)*G%cG%)*]ÇhG'dMdMG%)*E
+ GnMG&D
+ VC
+ CD
+ JhyVcI(?[D
+ VC
+ C
+ (?[)*c@?C
+ VCIJ(IJ(cIcJ(ch@(g]ñ+ôÿÿÿ	+èÿÿÿ	+Åÿÿÿ6 ?
+ +¬ÿÿÿ+‹ÿÿÿ+tÿÿÿ+aÿÿÿl
+ Êš;	+Oÿÿÿ	+Dÿÿÿ	+8ÿÿÿ
+ +ÿÿÿ
+ +øþÿÿ+äþÿÿ+µþÿÿ
+ +•þÿÿ
+ +¡üÿÿ
+ 
+ ,Ëïÿÿ+Aüÿÿ
+ +/üÿÿ
+ + üÿÿhh6¡lÿÿÿÿAlÿÿÿÿ@@
+ +üÿÿ
+ +¬ûÿÿ
+ +Šûÿÿ
+ +Oûÿÿ
+ +Dûÿÿ+ûÿÿ+çúÿÿ+´úÿÿ	+§úÿÿ	+šúÿÿ	+Žúÿÿ	+‚úÿÿ+qúÿÿ	+Yúÿÿ	+8úÿÿ
+  +	úÿÿ
+ "+Úùÿÿ+Áùÿÿ
+ +²ùÿÿ
+ +¢ùÿÿ+’ùÿÿ+‚ùÿÿ+mùÿÿ+_ùÿÿ+Qùÿÿ+Cùÿÿ+5ùÿÿ+&ùÿÿ+ùÿÿ+ùÿÿ!+æøÿÿ"+Éøÿÿ+¦øÿÿ
+ +™øÿÿ+Œøÿÿ&+bøÿÿ'+8øÿÿ"+øÿÿ
+ +øÿÿ*+ì÷ÿÿ	+Ú÷ÿÿ	+Î÷ÿÿ	+¾÷ÿÿ	+±÷ÿÿ	+¥÷ÿÿ;+’÷ÿÿ
+ +n÷ÿÿ
+ +^÷ÿÿ	+R÷ÿÿ+÷ÿÿ	+÷ÿÿ	+÷öÿÿ	+æöÿÿ+Êöÿÿ	+ªöÿÿ	+’öÿÿ	+yöÿÿ	+göÿÿ	+`öÿÿ
+ 
+ @UX+	öÿÿl lP8H"
+ ,×îÿÿ+íõÿÿ
+ +Çõÿÿ
+ +®õÿÿ	+¡õÿÿ
+ +“õÿÿl8„!
+ !8$!8$!9+hõÿÿ2!2!2!2!2!I!I!	I!
+ @!@!@!@!?!A!7!6!8!<!>!@!>!;!;!;!:!<!2!2!6!6! ?!!?!"?!#?!$?!%5!&:!':!(:!):!*c!+e!,k!-j!.l!/k!0k!	+2ôÿÿ
+ +!ôÿÿ
+ +ôÿÿ+ôÿÿ
+ +äóÿÿ	+Òóÿÿ
+ n+Âóÿÿ
+ <+§óÿÿ	+‹óÿÿ
+ 
+ dfhkmov{}ˆŠŒ�+óÿÿ
+ +Ùíÿÿ
+ A+Îíÿÿ
+ >+Ãíÿÿ>+¸íÿÿCw+¥íÿÿ	E+„íÿÿ
+ +qíÿÿ.8$M!		„„]_ac`lnprtmomo–˜šœ™€€ƒ…‡Œ���ŽŽ‘�� ¢¥¥±³µ ¢¤¦¨€y}�~€†XZXZ^`bY\\_\„†kmvxz|~‘“•—xz|~€‚„‹�Ž�•••™›�Ÿ¢¢§©>n¡9¢Tò)*VDC
+ DC^V(
+ 2&	5?[~V(^É„ 2%(]Ç
+ ,àÿÿÿYg 8H"!Z(6CyV([!
+ h89#!89
+ &)*DCWBE
+ !l ]Çoo8H"h8H#]Ço8H#
+ 8$"8$"A(	()*EC!]Çn8$&)*Y			8Kh Z(CyVD
+ 6£8‹"e8$L%CyVD
+ 6¤8‹"c8$L%[Wcjq�­ûI—åî9Ch%CC{VBC^	Y8$!!ZT(6CyVD6¥^ÌVT5¦A@[T[€(TöCiI(ChI(CC{VC^!€(TÊCC{VC^I€(T¬CC{V@C^	Y	]O!ZT(6CyVD6§^ÌVT5¨A@[T[€(T^CC{V@C^	Y	]OIZT(6CyVD6©^ÌVT5ªA@[T[€(TCC{V@C^	Y	]!ZT(6CyVD6«^ÌVT5¬A@[T[€(TÂCC{V@C^	Y	]IZT(6CyVD6­^ÌVT5®A@[T[€(TtC
+ 289	&DCC{V;C^89"VC^!€(6¯6°6± 6²8$"A@[T C	T\C^!€ÿÿÿÿC{Uêÿÿÿc(?@[	{V		^T5³W+FZC6´^ÌV5µ^ÌV6¶8‹ TcTcTDEDC		6·8‹ T)C	6¸8‹ TC	6¹8‹ T#5º^U5»^V8„!@[8„!@[)*VC
+ TOlÈ8„!C
+ 
+ 
+ +	,ÿÿÿ€T˜\C^
+ ]Ç‡ic^É„-bY
+ "ZT6CyV?!T[	Y
+ ,ƒüÿÿ!ZT%CyVD
+ ?!TCyV
+ D
+ !T[€T"Y!ZTCyVD
+ ?!T[€C{Udÿÿÿc(
+ )*gÈ8„!#8„!6¼8‹&)*6½8‹#!!89	&Y6¾"ccZT6CyVc6¿?6ÀA@T[	Y6Á"ccZT6CyVc6Â?6ÃA@T[
+ 8$"8$&5Ä@[)*EDCW6Å8‹$	C	6Æ6Ç6È 6É8‹$)*8$"8$&)*VDC8$"+Ýÿÿÿ89#8$&5Ê(5Ë?6Ì?6Í?	,úÿÿ+Ëÿÿÿ
+ +yÿÿÿ+nÿÿÿ
+ +ÿÿÿ
+ +øþÿÿ
+ +Úþÿÿh?
+ 
+ +úýÿÿ
+ + úÿÿ	,úÿÿ+ƒúÿÿ+0úÿÿ
+ 
+ +úÿÿ	
+ 
+ >9ÎT–g ]Èhl	}U%\ejph^É6Ï8‹"8H 	zUÝÿÿÿc(g]È	gh8$? ()*gh8$/$8$:!lÿÿÿÿ^±8$F!()*‡‡
+ ]Ço}V5Ð8$%_°(]Çh_°(+õÿÿÿ	+Ðÿÿÿ	+¹ÿÿÿ	+¨ÿÿÿ	+�ÿÿÿ	+Uÿÿÿ
+ 
+ >9ÑT„D&G%c]â%?E&E&G%G&G&G&G
+ &G&G%)*!rlÿÿÿ?oo}V2&()*!]]li!s]]^Z
+ ^X^V6Ò8W^S^R^S^V2&()*!]rl!]r^ol<l!s]r^o
+ ^m^m^k6Ó8b^h^g^h^V2&	(d!shy()*!^!(5Ô!]!]!]^"^^"^^"()*]x"]y()*]�"]�()*5Õ^V5Ö8$%&)*5×^V5Ø8$%&)*…ÿÿÿ?…5Ù8$%&g7DrJgÿÿÿ?DC^l7DrC^ns
+ DC_(c!"(c]â?%c!"(gk^Évlj^Évli^Évh^Énnu()*8$!8$"8Ñ%)*+êÿÿÿ	+ÇÿÿÿOhl6	}U\C_	zUðÿÿÿc5Ú?hl78$"l6n	}U2\g7rr
+ 
+ ^C	"IC!
+ C^u
+ C_	zUÐÿÿÿccJ()*g7hChC8* DJ(chl7^@(+ôÿÿÿ	+Øÿÿÿ	+_ÿÿÿ
+ +ÿÿÿ
+ +ÿÿÿ+ÿÿÿ	+Øþÿÿ
+ ,¬ýÿÿ+¹þÿÿ,Àýÿÿ+šþÿÿ,ìýÿÿ+{þÿÿ8m„ +dþÿÿT+Qþÿÿ+)þÿÿ
+ +þÿÿ	+þÿÿ
+ 
+  >h6Û]À@
+ +Cýÿÿ+7ýÿÿ++ýÿÿ+ýÿÿ+ýÿÿ+ýÿÿ+ûüÿÿ	+ïüÿÿ
+ +àüÿÿ
+ +Öüÿÿ
+ +Éüÿÿ+¼üÿÿ
+ GGGGG
+ GGGGF>
+ 
+ >9ÜTºlè|V5Ý8$!"	Yl€l@k@i@8$*#@Z(6CyV2%[)*VC
+ T5Þ,°ÿÿÿc%lè|V5ß8$!"	Yg€6à_×]ØZ(6CyV2%[)*,Èÿÿÿc%)*gÿÿÿ8Ü
+ F!s	6á8‹ &‡"V5â8$%^É„.	h8H'ÿÿÿÿ2%,Õÿÿÿ]Çÿÿÿÿ%)*]Ç]Ço
+ †5ã8$%h8H'Y!
+ ƒ
+ h8H#TZ(6CyV([Y!
+ ]Ço8H#ZT6CyVT[6ä^ËV(()*]Ç
+ ƒ	ÿÿÿÿ"V8$&8$"8$&]Ç
+ 8„!l"8„"cÿÿÿÿ	}UT\^É
+ ƒ"8ƒ\	8„"T3yV
+ 5å8„"T#^É„"
+ 5æ8„"Tg\8„"T5ç8„"	zU®ÿÿÿcg"8„"8„%)*]Ç]Ç~V]Ç]Ç]Ço8H#8H!8H!^Ë(!VO]Çj}U5èjh8H#^ÌV;]Çj}U5éjh8H#^ÌV']Çk}U5êkh8H#^ÌV]Çk}U5ëkh8H#^Ì(]Çi}Uc^Él/zV]Çi}Uc^Él\zV]Çj}Ud^Él:z(†5?[^É
+ l/yUl\yUl:yV(ÿÿÿÿ2%,Òÿÿÿ]Çÿÿÿÿ%)*^É
+ l/yUl\yUl:y()*]Ç]Ç~V]Ç]Ç]Ço8H#^Ë(!V']Çj}U5ìjh8H#^ÌV]Çk}U5íkh8H#^Ì(]Çi}Uc^Él/z(g/8H	&)*^Él/y()*]Ç
+ 8„!l'8„"cÿÿÿÿ	}U$\^É„'	8„"T
+ ^É8„"	zUÞÿÿÿcg'8„"8„%+¯ÿÿÿ6î6ï6ð	+™ÿÿÿ	+Œÿÿÿ	+xÿÿÿ
+ +Gÿÿÿ	+$ÿÿÿ	Y5ñ]ÞZT6CyV5òT[6ó
+ !
+ 
+ >
+ 
+ 6ô6õ6ö	+Îþÿÿ	+¼þÿÿ	+^þÿÿ
+ +þÿÿ	+×ýÿÿ	Y5÷]ÞZT6CyV5øT[	+<ýÿÿ
+ 
+ >
+ 
+ 6ù6ú6ûFGGGG	G
+ G	
+ 
+ >
+ 
+ 8K6ü^ÌV]5ý^ÌV25þ^ÌV5ÿ6
+ @[G	GGGGGF	E
+ DC>
+ TEG	GGGGG	F
+ EDC>
+ T!G	GGGGGFE	D
+ C>
+ 
+ G	GGGGGFED	C+)üÿÿ+ñûÿÿ+Çûÿÿ	+§ûÿÿ+”ûÿÿh8Ü
+ D!
+ +Eûÿÿ
+ +3ûÿÿ+åúÿÿ		>9TÙ)*VDC2#!@(()*VDC
+ !2"@(c()*VVDCDC"V2'(	Ud(c()*…c(ÿÿÿÿ2"@()*VDC^V(2"@(c(VDCV2!
+ DC@@(h@(56
+ @[)*VVDCDC"V2'(	Ud(c(…c(dx2!in()*]Ç~V(^É
+ ÷ÿÿÿ
+ ‹þÿÿÿ
+ ŒTTƒTT	3'2&)*]Ç~Vo8H#@(^É
+ ÷ÿÿÿ
+ ‹þÿÿÿ
+ ŒTTƒTT	2'o8H#@1&,cÿÿÿ¥ÿÿÿch&)*]Ç~V(]Çn~V5?[^Én^ÉyV2&c2&)*,Ãÿÿÿc&Y	8!Z(6CyV([i8$x|Vd8$x|()*ou8$!uth}()*n8$!uuth}()*‡mnÿÿÿÿs(ms(…c(g8$"h8$> 
+ „5?[
+ h8$/ o2%)*g]È
+ ,Áÿÿÿ%gh8$> 
+ „c(
+ h8$/ c2%)*g]È
+ ,Ñÿÿÿc%DC8L')*8L!+èÿÿÿ89	"()*]Çˆc^É„+]Çÿÿÿÿi8H#8&(Y]ÚZ(6CyVc([V%DC8"8"
+ ]ÙV(]ÙV(2%5?[)*8H!
+ ,Çÿÿÿ%VDC8"
+ ]ÙV(2%5?[)*8!U]ÙV(5?[,Çÿÿÿ%)*V
+ C
+ !?(c()*VC
+ %c()*Yc!h!Z(h![58$ !8$#!?[5?
+ +êÿÿÿ	+Ñÿÿÿ	,üÿÿ,.üÿÿ,Cüÿÿ,küÿÿ,|üÿÿ,–üÿÿ,»üÿÿ+¢ÿÿÿ	+Œÿÿÿ	+hÿÿÿ	+4ÿÿÿ	+ïþÿÿ	+Èþÿÿ	+°þÿÿ	+Žþÿÿ	+Vþÿÿ	,¾üÿÿ+þÿÿ	+íýÿÿ	+Õýÿÿ	+¾ýÿÿ	+¤ýÿÿ	+“ýÿÿ	+Mýÿÿ
+ 
+  "$&(*,.033>97K	Y5]ÞZT&6CyVY5]ÞZT6CyV5T[T[66	6
+ 6666666666666666666h?6?lõlöll66 6!6"6#6$6%8K6&^ÌV5'^ÌV5(^ÌV	5)T5*T5+
+ 
+  "$&( ",.02468:<>@BDFHJ>&&9,T%CVc(c8,@(CV5-(7,8!8$&c?h?h?h?h?h?h?h?h?h?h?h?h?h?h?h?h?h?h?h?h?h?h?6.?6/?h?h?h?h?8,?8,?h?h?h?h?h?h?h?h?h?h?h?i?h?h?h?h?h?h?h?h?h?h?h?h?h?h?h?l
+ ?h?5+,ÿÿÿ6+ÿÿÿ
+ 
+  "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz>>>90:91Tgc3&)*8r#
+ Œ
+ C!2&W'8r!!8r!I8r%€8r!I8r%€8r!I5?[)*8$:!
+ 8r!IdIcIYT\c!|U÷ÿÿÿcZT6CyVcT[8$F!CCÿÿÿÿCA(Y±c?	T\€C^É
+ l0}Ul9{UêÿÿÿcC?	T\€C^É
+ l0|Vl9~UêÿÿÿcCCoC8H#]OIC?	T\€]ÇC{V
+ C^É„"ìÿÿÿcC?	T\€]ÇC{V
+ C	^É„"ëÿÿÿc]ÇC{VCCoÿÿÿÿC
+ 8H#IZ(6CyU
+ 5CyU[528%53?h?h?+)ÿÿÿ64
+ ,‚þÿÿˆþÿÿ	+Ðþÿÿ
+ ?95TýCh{VC@hI[(€%)*!h?h]Çÿÿÿÿ	}U\^Él
+ yV€	zUêÿÿÿcc8¢c"
+ FEDC+¸ÿÿÿ	8¢b 66
+ 8¢f#c	8¢I"8¢b 	!!
+ C
+ ^V€C(W $4IWl|57(58(59(5:(5;(5<(C6=8$"6>8$&C6?^ÌV	6@8$&5A(C
+ 6B@6C8H&C6D^ÌV	6E8$&5F(C6G8$"6H8$&C
+ ()*VTh]Çÿÿÿÿ	}UI\^É„AdOh8* T(^É„acOh8* T^É!
+ DC_	zU¹ÿÿÿc(!!
+ C
+ ^(!!
+ C
+ ^(‡A…Z
+ dlAo@(‡a…z
+ clao@(5I(W $(,04gu(gd(gf(gl(gs(gc(ge(gm(gp(gv(gx(+Ãÿÿÿil^hl^	+�ÿÿÿ
+ +|ÿÿÿ+iÿÿÿ+ÿÿÿ6Jh"	+vþÿÿh?
+ 
+ +åýÿÿ6K?
+ +Âýÿÿ
+ 
+ >9LTh)*C
+ �VYƒHC
+ V@C	Y5M6N]Þ^ËZT6CyVcT[
+ Vc(Y	
+ #dZ(8$CyVc([c(7$]åI2'CC
+ V&C	Y	 dZ(8$CyVc([c(c8¢!€()*C'cC8¢I"I(cC8¢I"7¢1I()*8L"
+ CnI()*8L!V++ãÿÿÿ	6O8¢f 6P8¢f c8¢I"€()*C	!
+ EDCCFDFon†5QT@
+ DC6R^ËV
+ 
+ #Vc(
+ 	DF
+ CF6S8¢f$	6T8¢f 6U8¢f 6V8¢f$5WC^ËV5XC^ËV5YT5ZC^ËVFC85"T	EDCA
+ EDCFoA(cI()*Fm
+ h}V7$?[Eoÿÿÿÿh?h?h	}U/\nD^Él
+ yV	CF}V€	DF}V€	zUÓÿÿÿc	DF
+ CF6[
+ 8¢f 5\8$!c?h?h	}U\n
+ D^É
+ ƒ
+ gCCyVCCyV8$!TÔCCyVCF{V	g.8$!T½8$!T¶CCyVDF{V8$!T g.8$!T˜CC}VCC{VŠ8$!TƒCCyVCCyVK5]8$!CCFÿÿÿÿ	}U\g 8$!	zUðÿÿÿcCFDFÿÿÿÿ	}U\g^8$!	zUðÿÿÿcCC~VCC|Vg
+ 8$!DF{V5^8$!€I	zUÿÿÿc()*Fm
+ h}V7$?[C?Eÿÿÿÿ	}U\D^Él
+ yV€	zUéÿÿÿcþÿÿÿC~V7$?[7$8$+!C]æc?6_8$!cEoÿÿÿÿ	}UT\CV
+ 5`8$!cICFyU	CFyVd]çDFyU	DFyVc]çnD^É
+ 8$!l
+ yI	zU®ÿÿÿcc]çC]è7$8$+%	c8v!8v!A(dh8v!h8v!A(ch8v!h8v!A()*chi>M(cGG
+ A(gÿÿÿÿhi>iA(d8r8rA	+åÿÿÿ	+Öÿÿÿ	+Äÿÿÿ	+°ÿÿÿ	+�ÿÿÿ	+Šÿÿÿ6a?h?h?h?
+ +­þÿÿ	+*ýÿÿ
+ ,]ûÿÿ+ýÿÿ6b
+ GGFEDC+Åüÿÿ
+ +	;üÿÿ
+ +ÿûÿÿ8¢1?
+ +Öûÿÿ+Æûÿÿ+¸ûÿÿ+¨ûÿÿ "$&)),.>9cT�)*WC@(DC
+ @2&5d8%)*Y!g.8H
+ #
+ 2"o8H#@Z(6CyVc]Ço8H#@([)*@(c"
+ VDC?	+æÿÿÿ89'5e(h&,rÿÿÿ+ôÿÿÿ	,�ÿÿÿ+Ïÿÿÿ
+ @9fT\)*WFFEDC8cC]Ç„8c#V6g8¢f$
+ 8c
+ 6h8¢f 8c
+ 6i8¢f$C
+ 8c
+ 6j8¢f$5k?6l?	+›ÿÿÿ
+ A9mTŸ%V*DC2!iDDDCA
+ h@@?@h?6nA@(5o%V*DC2!iDDDCA
+ h@@?@h?6pA@(5q%)*yV	??%8?!2"??!@%)*}V2&yV	??%"%)*l8v$)*k8v$)*j8v$)*i8v$5r8$%d8v"
+ (d8v"
+ 89%d8v"
+ ?(d8v"h!@?(d8v"
+ (5?[c8v"h@(d8v"h8v"
+ @(c8v"
+ (d8v"h8v"
+ h!@?@(c(c(d8v"h8v"
+ h!@?@(d8v"h8v"
+ h@?@(d8v"h8v"
+ @(d8v"h8v"
+ h@?@(d8v"h8v"
+ @(c8v"
+ ?%d8v"
+ ?%d8v"k6si6t$g8v"k8v"h8v"
+ A%f8v"i8v"
+ @%f8v"i8v"l6uj6v$f8v"i8v"
+ @%f8v"i8v"l6wi6x$d8v"
+ (d8v"k6yi6z$c8v"
+ (d8v"h8v"
+ !@(c(c(d8v"h8v"
+ !@(d8v"h8v"
+ @(d8v"h8v"
+ @(d8v"h8v"
+ VC
+ C
+ C
+ �VD
+ VTD
+ ?%	89!@%f8v"j8v"h8v"
+ @@%c8v"
+ 89!?%d8v"h8v"
+ @%e8v"h8v"
+ @%d8v"h8v"
+ @%c8v"
+ 89!?%e8v"h8v"
+ @%c8v"
+ ?	%c8v"
+ 89!?
+ %c8v"
+ 89!?%c8v"
+ ?%c8v"
+ (e8v"h8v"@%g8v"j8v"h8v"
+ A%c8v"h@(e8v"h8v"@(g8v"j8v"h8v"
+ A(c8v"
+ ?%d8v"
+ 89!?%d8v"k6{i6|$g8v"k8v"h8v"
+ A%e8v"h8v"
+ 89!@%d8v"
+ (d8v"k6}i6~$c(d8v"h8v"@(e8v"i8v"@(d8v"h8v"h@@%f8v"j8v"h8v"
+ @@%c8v"
+ 89!?%d8v"h8v"
+ @%d8v"h8v"
+ @%c8v"
+ 89!?%c8v"h@%e8v"h8v"
+ ?@%c8v"
+ ?%c8v"
+ ?%c8v"
+ 89!?%c8v"
+ 89!?	%c8v"
+ (g8v"j8v"h8v"
+ A%c8v"h@(e8v"h8v"@(e8v"h8v"
+ @(e8v"h8v"@(c8v"h@(f8v"j8v"i8v"h8v"C89#!
+ DCh8c!	D@>(c8v"
+ (e8v"h8v"@%d8v"h8v"EDC>%c8c!h@(d8v"h8c!89!@(e8v"h8v"EDC>%d8v"h8v"EDC>%c8v"
+ (c8v"
+ (d8v"h8v"
+ 89!@%f8v"j8v"h8v"
+ 89!A%e8v"h8v"89!@%c8v"h@%d8v"
+ ?%d8v"k6i6€$f8v"i8v"
+ @%f8v"i8v"l6�i6‚$d8v"
+ (d8v"k6ƒi6„$d8v"h8v"
+ 89!@(d8v"
+ %f8v"i8v"
+ @	%c%c(f8v"i8v"h8v"@@(e8v"h8v"?@(d8v"h8v"?@(d8v"h8v"?@(e8v"h8v"?@(e8v"h8v"?@(c8v"
+ ?(c(f8v"j8v"h8v"h8c!>(g8v"k8v"j8v"h8v"h8c!DCA!>(e8v"h8v"h8c!h>(f8v"j8v"h8v"h8c!>(e8v"i8v"h8v"h8c!h@!>(g8v"l8v"j8v"h8v"h8c!?@!>(g8v"k8v"j8v"h8v"h8c!?@!>(c8v"
+ (g8v"j8v"h8v"
+ Dh@6…@@6†8$"A%f8v"j8v"h8v"
+ Dh@6‡@@6ˆ8$"A%g8v"j8v"h8v"
+ A%e8v"h8v"
+ 6‰A%e8v"h8v"89!@%c8v"h@%d8v"
+ ?%d8v"k6Ši6‹$d8v"h8v"
+ 89!@(d8v"
+ (c%c(e8v"h8v"?@(e8v"h8v"?@(d8v"h8v"?@(d8v"h8v"?@(e8v"h8v"?@(f8v"j8v"h8v"h8c!?>(f8v"j8v"h8v"h8c!>(e8v"h8v"h8c!A(e8v"h8v"@(c8v"h@(g8v"k8v"j8v"h8v"C89#!
+ DCh8c!	D@>(e8v"h8v"@(c8v"h@(g8v"k8v"j8v"h8v"C89#!
+ DCh8c!	D@>(c8v"
+ (d8v"
+ %e8v"h8v"
+ @%e8v"i8v"DC6Œ8$"A(c8v"
+ DhC6�8$"A(g8v"j8v"i8v"6Ž8$"A(d8v"h8v"
+ h6�8$"A(d8v"
+ DhCA(c8v"
+ DhCA(d8v"h8v"
+ hA(c8v"
+ h6�A(c8v"
+ ?%c(c8v"
+ ?(c8v"
+ (e8v"h8v"DC@	!@(c8v"
+ ?!@(c8v"
+ (e8v"h8v"
+ @	%c8v"
+ (d8v"h8v"
+ 89!@%f8v"j8v"h8v"
+ 89!A%f8v"j8v"h8v"
+ A%d8v"h8v"
+ 89!h6‘A%d8v"h8v"EDCh@@A%f8v"i8v"h8v"
+ 89!@%f8v"i8v"h8v"
+ 89!@%e8v"h%c8v"
+ 89!?%d8v"h8v"h?A%d8v"h8v"
+ ?@	%g8v"j8v"h8v"
+ ?A%e8v"h8v"hA%f8v"i8v"
+ @%g8v"l8v"l8v"k8v"i8v"
+ >%e8v"h8v"hh@@?!?6’A%e8v"i8v"h8v"
+ 'e8v"i8v"h8v"
+ 'e8v"i8v"h8v"
+ 'e8v"i8v"h8v"
+ 'e8v"i8v"h8v"
+ 'e8v"h8v"
+ 6“'e8v"h8v"
+ 6”'e8v"h8v"
+ 6•'e8v"h8v"
+ 6–'e8v"h8v"
+ 6—'e8v"h8v"
+ 6˜'e8v"h8v"
+ 6™'e8v"h8v"
+ 6š'e8v"h8v"
+ 6›'e8v"h8v"
+ 6œ'e8v"h8v"
+ 6�'e8v"h8v"
+ 6ž'd8v"h8v"
+ &g8v"j8v"h8v"
+ A%g8v"k8v"h8v"h6Ÿ@@6 @@6¡@@6¢6£"?!@%g8v"k8v"h8v"h6¤@@6¥@@6¦@@6§6¨"?!@%g8v"k8v"h8v"
+ 'e8v"h8v"
+ @%c8v"
+ %c8v"
+ ?%d8v"
+ ?%d8v"k6©i6ª$c8v"
+ ?%c8v"
+ ?%c8v"hhA%c8v"h@	%d8v"
+ %d8v"k6«i6¬$d8v"
+ %5­%d8v"k6®i6¯$e8v"i8v"
+ DCA%e8v"h8v"
+ @%g8v"i8v"h6°@@6±@@6²6³"?!@%g8v"i8v"l6´k6µ$g8v"i8v"h6¶@@6·@@6¸6¹"?!@%g8v"i8v"l6ºk6»$g8v"i8v"
+ &g8v"i8v"l6¼k6½$d8v"
+ DC
+ @
+ %d8v"k6¾i6¿$e8v"i8v"89!?%e8v"i8v"l6Ài6Á$5Â%e8v"i8v"89!!%e8v"i8v"l6Ãi6Ä$d8v"h8v"h6Å@@i"@%c8v"
+ ?%e8v"i8v"89!?%e8v"i8v"l6Æi6Ç$5È%e8v"h8v"
+ @%c8v"h@(d8v"h8v"@(c8v"
+ 6É@(c8v"
+ (d8v"h8v"
+ @(c8v"
+ (c8v"
+ DC6Ê8$"@(d8v"h8v"
+ 6Ë8$"@(c8v"
+ ??!@(c8v"h@(e8v"h8v"@(d8v"h8v"
+ i8c!?@@(e8v"h8v"
+ @(c8v"
+ (e8v"h8v"DCA%c8v"
+ (d8v"h8v"EDCh@@A%d8v"h8v"h@@(f8v"i8v"h8v"@@(c8v"
+ (d8v"h8v"EDCh@@A%c8v"
+ (e8v"h8v"
+ @%e8v"h8v"@(e8v"h8v"h@@(f8v"i8v"h8v"89!?@(d8v"h8v"89!h@(e8v"h8v"h@@(g8v"j8v"h8v"@@(e8v"h8v"h@@(g8v"j8v"h8v"@@(c8v"h@(e8v"h8v"@(c8v"h?@(e8v"h8v"
+ ??@(c8v"
+ ?h@(c%c%c8v"
+ (e8v"h8v"
+ @%c8v"
+ 89!?%d8v"h8v"h?A%d8v"h8v"
+ ?@%e8v"h8v"hh@@?!?6ÌA%e8v"h8v"
+ @%c8v"
+ ?%c%c8v"
+ ?%e8v"h8v"
+ &c8v"hhA%c8v"h@%c8v"
+ ?
+ %e8v"i8v"89!?%e8v"i8v"l6Íi6Î$e8v"i8v"89!!%e8v"i8v"l6Ïi6Ð$e8v"i8v"89!?%5Ñ%e8v"i8v"l6Òi6Ó$d8v"
+ %d8v"k6Ôi6Õ$f8v"i8v"
+ @	%f8v"i8v"l6Öi6×$e8v"h8v"@(e8v"h8v"h@@(c8v"h@(e8v"h8v"@(e8v"h8v"h@@(g8v"j8v"h8v"@@(c8v"h@(d8v"h8v"
+ @(c8v"h@(e8v"h8v"@(f8v"j8v"i8v"h8v"89#!
+ DCDCh8c!	89!>@(
+ e8v"h8v"@(c(5Ø(c8v"
+ ?h@(c8v"hi89!@@(c8v"hh89!@@(e8v"h8v"h89!@@(g8v"j8v"i8v"h89!@@(g8v"j8v"i8v"h8v"?89!@@(g8v"l8v"j8v"i8v"?89!@@(c(c8v"h@(d8v"
+ 89%e8v"h8v"@(5Ù(5Ú(5Û(c8v"h@(e8v"h8v"@(c8v"h@(e8v"h8v"@(d8v"h8v"
+ @(c(c8v"
+ 89%c8v"h@(e8v"h8v"@(f8v"j8v"h8v"
+ A(c8v"h@(e8v"h8v"@(g8v"k8v"i8v"h8v"89#!
+ DCh8c!?h89!>?@(e8v"h8v"
+ ?@(c8v"h@(e8v"h8v"@(c8v"
+ h@%e8v"h8v"
+ 89!@%c8v"
+ (f8v"h8v"
+ @%c8v"
+ (g8v"j8v"h8v"
+ Dh@6Ü@@6Ý8$"A%f8v"j8v"h8v"
+ Dh@6Þ@@6ß8$"A%g8v"j8v"h8v"
+ A%e8v"h8v"
+ 6àA%c8v"
+ (d8v"
+ VD
+ VTC
+ (7v	?[c8v"
+ ?%c%c8v"h@%d8v"h8v"h@@%e8v"h8v"89!@%d8v"
+ ?%5á%d8v"h8v"
+ hA%f8v"i8v"h8v"
+ h@A%g8v"i8v"h8v"
+ 89!A%d8v"hih@A%d8v"hi89!A%f8v"i8v"hi89!@A%e8v"i8v"hh89!A%5â%e8v"i8v"6ãi89!A%g8v"k8v"i8v"
+ 89!?i89!A%c8v"h@(e8v"h8v"@(c8v"
+ (c8v"
+ ?(f8v"i8v"h8v"
+ 89!A(c8v"hiA(d(c(c8v"h@(e8v"h8v"@(d8v"
+ 89%c(c8v"h@(d8v"h8v"@(c8v"
+ (e8v"h8v"
+ 89!@?%c8v"h@(e8v"h8v"@(c8v"h@(e8v"h8v"@(e8v"h8v"
+ @(d8v"h8v"h@(ch!@(e8v"h8v"
+ @%c8v"
+ (c8v"
+ ?(c8v"
+ ?(c8v"
+ ?(c8v"
+ ?(c8v"
+ ?(c8v"
+ ?(c8v"
+ ?(c8v"
+ (c8v"
+ m?(c8v"
+ 6ä8$"?(c8v"
+ ]Q?(c8v"
+ ]f?(c8v"
+ ]?(c8v"
+ (c8v"
+ (c8v"
+ (d8v"
+ (d8v"
+ (e8v"
+ (c8v"
+ (c8v"
+ (c8v"
+ (c8v"
+ (c8v"
+ (c8v"
+ (c8v"
+ (5å(5æ(5ç(5è(5é(5ê(5ë(5ì(5í(5î(5ï(5ð(c8v"
+ (5ñ(5ò(5ó(5ô(c8v"
+ ?(e8v"h8v"
+ @(c8v"
+ (5õ(5ö(5÷(5ø(c8v"
+ ?(e8v"h8v"
+ @(c8v"
+ ?(e8v"h8v"
+ @(c8v"
+ ?(e8v"h8v"
+ @(c8v"
+ ?(e8v"h8v"
+ @(f8v"i8v"
+ @(c8v"
+ ?(e8v"h8v"
+ @(c8v"
+ ?(e8v"h8v"
+ @(c8v"
+ ?(e8v"h8v"
+ @(c8v"h@(d8v"h8v"
+ ?@(d8v"h8v"
+ ?@(d8v"h8v"
+ ?@(d8v"6ù@(d8v"6ú@(c8v"
+ (c(d(c(d(d(c(c(d(d(c(c(c(c(c(5û(5ü(c8v"8v
+ @[c8v"8v
+ @[c8v"8v
+ @[c8v"8v
+ @[)*!
+ V¤DCVxDCVCD
+ VT�Ch6ý@@6þ@@6ÿ@@6@@
+ 6@@66"?!@%h	6@@6@@6@@6@@66	"?!@%
+ c6
+ @@6@@6@@66"?!@%c6@@?!6@@6@@66"?!@%)*!
+ V�DCVhDCV;D
+ VTvCh6@@6@@6@@
+ 6@@66"?!@%h6@@6@@6@@66"?!@%	c6@@6 @@6!6""?!@%c?!6#@@6$@@6%6&"?!@%C
+ W#############################C
+ (c@()*6'@@()*8c!8c!>8m@[7m?[)*70
+ CV
+ 6(8$"T?@(DiDCA?@()*C6)^ÌUeWžžžžžžžžžžžžžžžžžžžžžžžžžžžžžC
+ W&2TqC
+ m??%T%C
+ ]Q??%C
+ ]f??%C
+ ]??%W:::::::::::::::::::::::::::::C
+ WTC
+ !??%c6*@@i6+8$""@%]Çˆc^É„-]Çÿÿÿÿi8H'6,8$&)*c6-@@6.@@j"@%C
+ WNNNNNNNNNNNNNNNNNNNNNNNNNNNNNC
+ WT%C6/^ÌVTD
+ VTE
+ ƒTc%?%c8c!@(c8c!@(c8c!@()*8c!??@(h8c!C@(h8c!C@(c8c!@(c8c!@(c8c!@(c8c!@(c8c!@(c8c!@(c8c!@(c8c!@(c8c!@(c8c!@(g]ñ+ðÿÿÿ	+âÿÿÿ	+Ôÿÿÿ	+Æÿÿÿ	+¸ÿÿÿ	+ªÿÿÿ	+œÿÿÿ	+Žÿÿÿ	+€ÿÿÿ	+rÿÿÿ	+bÿÿÿ	+Rÿÿÿ	+>ÿÿÿ	+/ÿÿÿ	+!ÿÿÿ	+ÿÿÿ+µþÿÿ+•þÿÿ	+oþÿÿ
+ +¤ýÿÿ,Úÿÿ,1Úÿÿ+„ýÿÿ	+gýÿÿ	,VÚÿÿ,sÚÿÿ+Nýÿÿ	+3ýÿÿ	+"ýÿÿ	+ïüÿÿ
+ +/üÿÿ+Pûÿÿ60]À61]À62636465666768lð-696:6;6<	+ûÿÿ	+ûÿÿ	+ÿúÿÿ	+ïúÿÿ	+çúÿÿ	+ßúÿÿ	+Øúÿÿ	+Ñúÿÿ	+Êúÿÿ	+Ãúÿÿ	+¼úÿÿ	+µúÿÿ	+®úÿÿ	+§úÿÿ	+ úÿÿ	+™úÿÿ	+’úÿÿ	+‹úÿÿ	+„úÿÿ	+}úÿÿ	+púÿÿ	+_úÿÿ	+Núÿÿ	+6úÿÿ	+úÿÿ	+úÿÿ	+öùÿÿ	+àùÿÿ	+Ñùÿÿ	+»ùÿÿ	+¬ùÿÿ	+–ùÿÿ	+‡ùÿÿ	+qùÿÿ	+[ùÿÿ	+Lùÿÿ	+6ùÿÿ	+'ùÿÿ	+ùÿÿ	+ùÿÿ	+ìøÿÿ	+Ýøÿÿ	+Õøÿÿ	+Íøÿÿ	+Åøÿÿ	+½øÿÿ	+°øÿÿ	+šøÿÿ	+‹øÿÿ	+ƒøÿÿ	+{øÿÿ	+søÿÿ	+køÿÿ	+^øÿÿ	+Vøÿÿ	+Nøÿÿ	+Føÿÿ	+>øÿÿ	+6øÿÿ	+.øÿÿ	+&øÿÿ	+øÿÿ	+øÿÿ	+øÿÿ	+øÿÿ	+þ÷ÿÿ	+ñ÷ÿÿ	+ä÷ÿÿ	+×÷ÿÿ	+Ê÷ÿÿ	+½÷ÿÿ	+°÷ÿÿ	+£÷ÿÿ	+–÷ÿÿ	+‰÷ÿÿ	+|÷ÿÿ	+o÷ÿÿ	+b÷ÿÿ	+U÷ÿÿ	+D÷ÿÿ	+3÷ÿÿ	+"÷ÿÿ	+÷ÿÿ	+ýöÿÿ	+ðöÿÿ	+áöÿÿ	+Òöÿÿ	+Ãöÿÿ	+´öÿÿ	+¥öÿÿ	+–öÿÿ	+‡öÿÿ	+zöÿÿƒ+böÿÿ„+Uöÿÿ	+?öÿÿ	+)öÿÿ	+öÿÿ	+öÿÿ	+íõÿÿ	+Ýõÿÿ’+¿õÿÿ	+²õÿÿ	+œõÿÿ	+Œõÿÿ	+…õÿÿ	+uõÿÿ	+_õÿÿ	+Oõÿÿ	+Hõÿÿ	+Aõÿÿ	+0õÿÿ	+õÿÿ	+õÿÿ	+óôÿÿ	+Ýôÿÿ	+Íôÿÿ¢+£ôÿÿ£+…ôÿÿ¤+{ôÿÿ¥+^ôÿÿ¦+>ôÿÿ§+'ôÿÿ¨+ôÿÿ©+íóÿÿª+Ëóÿÿ«+²óÿÿ¬+¨óÿÿ­+—óÿÿ®+{óÿÿ¯+`óÿÿ°+Nóÿÿ±+Eóÿÿ²+4óÿÿ	+óÿÿ	+óÿÿµ+ìòÿÿ¶+Ìòÿÿ·+œòÿÿ¸+kòÿÿ	+^òÿÿº+Fòÿÿ	+9òÿÿ¼+òÿÿ½+òÿÿ	+õñÿÿ	+åñÿÿ	+Íñÿÿ	+�ñÿÿ	+wñÿÿ	+gñÿÿ	+Jñÿÿ	+4ñÿÿ	+$ñÿÿ	+ñÿÿ	+ñÿÿ	+÷ðÿÿ	+áðÿÿ	+Ñðÿÿ	+»ðÿÿ	+«ðÿÿ	+£ðÿÿ	+›ðÿÿ	+“ðÿÿ	+}ðÿÿ	+mðÿÿ	+]ðÿÿ	+Vðÿÿ	+)ðÿÿ	+ýïÿÿ	+Ùïÿÿ	+¼ïÿÿ	+¥ïÿÿ	+Žïÿÿ	+|ïÿÿ	+tïÿÿ	+mïÿÿ	+Wïÿÿ	+ïÿÿ	+ïÿÿ	+ðîÿÿ	+Úîÿÿ	+Êîÿÿ	+ªîÿÿ	+‘îÿÿ	+{îÿÿ	+kîÿÿ	+Rîÿÿ	+<îÿÿÏ+ îÿÿê+îÿÿÑ+óíÿÿã+äíÿÿÓ+Èíÿÿî+¾íÿÿï+£íÿÿÖ+‡íÿÿÝé+jíÿÿØ+Níÿÿó+3íÿÿô+"íÿÿõ+íÿÿö+ýìÿÿß+çìÿÿø+Öìÿÿù+Íìÿÿú+¼ìÿÿû+¤ìÿÿïý+|ìÿÿý+bìÿÿþ+Gìÿÿÿ+2ìÿÿ+ìÿÿ	+ìÿÿé+ìÿÿê+ûëÿÿ	+éëÿÿ	+Ïëÿÿ	+½ëÿÿ	+§ëÿÿ	+—ëÿÿ	+wëÿÿ	+^ëÿÿ	+>ëÿÿ	+%ëÿÿ	+ëÿÿ	+éêÿÿ	+Ðêÿÿ	+ºêÿÿ+¢êÿÿ	+•êÿÿ+pêÿÿ	+cêÿÿ	+Dêÿÿ	++êÿÿ+êÿÿ	+ùéÿÿ+Üéÿÿ	+Ïéÿÿ	+¹éÿÿ	+šéÿÿ	+„éÿÿ	+téÿÿ+]éÿÿ	+Aéÿÿ	+)éÿÿ	+éÿÿ	+éÿÿ	+ùèÿÿ	+èèÿÿ	+Òèÿÿ	+Âèÿÿ'+ªèÿÿ(+ èÿÿ+„èÿÿ*+ièÿÿ++Xèÿÿ"-+4èÿÿ+èÿÿ&+ûçÿÿ/+ñçÿÿ+Õçÿÿ1+ºçÿÿ+¥çÿÿ3+�çÿÿ+rçÿÿ+[çÿÿ+>çÿÿ"-9+
+ çÿÿ+íæÿÿ$/;+¹æÿÿ:+¡æÿÿ;+„æÿÿ#+oæÿÿ=+eæÿÿ5+Væÿÿ&+Aæÿÿ7+2æÿÿA+ æÿÿB+æÿÿC+üåÿÿD+ëåÿÿ,+ÖåÿÿF+ÅåÿÿG+´åÿÿ:+¥åÿÿI+�åÿÿ-+oåÿÿ6AM+.åÿÿ7BN+íäÿÿM+Íäÿÿ=+·äÿÿ@+ŸäÿÿA+‡äÿÿB+oäÿÿC+WäÿÿD+?äÿÿE+'äÿÿF+äÿÿG+÷ãÿÿH+ßãÿÿI+ÇãÿÿJ+¯ãÿÿK+—ãÿÿL+zãÿÿM+]ãÿÿN+@ãÿÿO+#ãÿÿP+ãÿÿUa+Þâÿÿa+¬âÿÿb+”âÿÿc+{âÿÿd+Yâÿÿe+?âÿÿf+$âÿÿg+âÿÿP+âÿÿi+Þáÿÿj+¼áÿÿk+—áÿÿl+yáÿÿm+Záÿÿn+7áÿÿo+áÿÿ	+áÿÿr+öàÿÿ	+éàÿÿt+Ôàÿÿu+´àÿÿ	+§àÿÿ	+˜àÿÿ	+‘àÿÿy+€àÿÿ	+nàÿÿ	+Wàÿÿ	+Dàÿÿ	+1àÿÿ	+àÿÿ	+ðßÿÿ	+×ßÿÿ	+¸ßÿÿ�+ ßÿÿy+‘ßÿÿ	+„ßÿÿ	+Hßÿÿ	+8ßÿÿ	+"ßÿÿ	+æÞÿÿ	+ÖÞÿÿ	+ÀÞÿÿ	+¥Þÿÿ	+‚Þÿÿ	+]Þÿÿ	+EÞÿÿ	+-Þÿÿ	+Þÿÿ	+ýÝÿÿ	+åÝÿÿ	+ÞÝÿÿ•+ÕÝÿÿ	+ÈÝÿÿ	+®Ýÿÿ}+™Ýÿÿ�+ˆÝÿÿ‘+vÝÿÿ’+ZÝÿÿ“+@Ýÿÿ”+ Ýÿÿ•+ðÜÿÿ–+¿Üÿÿ	+²Üÿÿ”+€Üÿÿ•+MÜÿÿ–+$Üÿÿ	+Üÿÿ	+äÛÿÿ™+­Ûÿÿ	+ŠÛÿÿ	+ƒÛÿÿ	+tÛÿÿ	+\Ûÿÿ	+DÛÿÿ	+,Ûÿÿ	+Ûÿÿ	+üÚÿÿ	+ÝÚÿÿ	+ÖÚÿÿ£+ÍÚÿÿ±+µÚÿÿ©+¦Úÿÿ	+ŒÚÿÿš+wÚÿÿ	+jÚÿÿœ+NÚÿÿ°+6Úÿÿž+!Úÿÿ²+Úÿÿ³+þÙÿÿ´+âÙÿÿµ+¿Ùÿÿ¶+£Ùÿÿ	+–Ùÿÿ	+‰Ùÿÿ¹+hÙÿÿº+GÙÿÿ	+/Ùÿÿ	+!Ùÿÿ½+Ùÿÿ¾+èØÿÿ	+ÛØÿÿ	+ Øÿÿ	+�Øÿÿ	+zØÿÿ	+dØÿÿ	+NØÿÿ	+>ØÿÿË+Øÿÿ	+ØÿÿÌ+ü×ÿÿÍ+ç×ÿÿÎ+Ö×ÿÿÏ+Å×ÿÿÐ+«×ÿÿÑ+™×ÿÿÒ+„×ÿÿÓ+l×ÿÿÔ+T×ÿÿÕ+?×ÿÿÖ+×ÿÿ×+×ÿÿ	+íÖÿÿ	+×Öÿÿ	+ÐÖÿÿÄ+»Öÿÿ	+®ÖÿÿÞ+’Öÿÿß+rÖÿÿÈ+]Öÿÿá+HÖÿÿâ+7Öÿÿ	+Öÿÿ	+Öÿÿ	+óÕÿÿä+ÓÕÿÿå+»Õÿÿ	+®Õÿÿæ+�Õÿÿç+ˆÕÿÿè+sÕÿÿé+bÕÿÿê+JÕÿÿë+5Õÿÿì+Õÿÿí+Õÿÿî+íÔÿÿï+ØÔÿÿð+·Ôÿÿñ+{Ôÿÿ	+eÔÿÿ	+OÔÿÿä+6Ôÿÿ	+/Ôÿÿ	+(Ôÿÿç+Ôÿÿ	+Ôÿÿä+íÓÿÿ	+àÓÿÿæ+ÄÓÿÿý+¬Óÿÿè+�Óÿÿÿ+xÓÿÿ+XÓÿÿë+CÓÿÿ+2Óÿÿ+!Óÿÿ	+Óÿÿ	+ðÒÿÿ	+ÚÒÿÿ	+¿Òÿÿ÷+¡Òÿÿ	+šÒÿÿ	+“Òÿÿú+uÒÿÿ	+hÒÿÿ	+RÒÿÿ	+BÒÿÿ	+9Òÿÿ	+,Òÿÿ+Òÿÿ	+Òÿÿ	+øÑÿÿ	+ëÑÿÿ	+àÑÿÿ>î8v
+ >
+ +¬Ñÿÿ+›Ñÿÿ+ŠÑÿÿ+xÑÿÿ
+ >49=Tägÿÿÿÿl^M	c3&)*8r#
+ ŒI
+ C!2&WJJZ^bf‘•™ÄäíKz©ÈÞèõþ$6Tƒ¸¼¿ÂÆÊÎÒÖÚÞâæêîòöúþ
+ "&*.26:>BFJNR[dmvˆ‘•chih 1%1%gU(gP(8r!
+ ]Çþÿÿÿi8H#
+ 8L"V8c!?A[?
+ (gB(gC(8r!
+ ]Çþÿÿÿi8H#
+ 8L"V8c!?A[?(8r!	Y8L"Z(6CyV?([8r!?(Y8r!]O?Z(6CyV8c!6>A[[8r!!?(8r!	Y]Çÿÿÿÿh8H#]c?Z(6CyV8c!6?A[[8r!	Y]Çÿÿÿÿh8H#]|?	Z(6CyV8c!6@A[[8r!	Y]Çÿÿÿÿh8H#]“?Z(6CyV8c!6AA[[c!G
+ 8c!I4!M
+ c!?(dhih d8r"?(d8r"?(e8r"!?(e"?(f"?(8r!
+ ]Çÿÿÿÿi8H#8c!?A[c8c!@I3!1%8c!6B8c"c8c!@I3!1%8c!6C
+ 8c"GÿÿÿÿMG
+ FÿÿÿÿEDC>MgM(dG	^hG	^8r#jG	^kG	^8r#	ci]O
+  1%gK(d(c(g(gD(g3(gH(gM(g(g8(g(g(g(g(g(g(gI(gJ(g0(g1(g(g,(g-(g.(g/(gF(g*(g+(g(g(g(g!(g#(gE(g"(5D(g@(g6(g7(8r!?(8r!?(8r!?(8r!?(8r!?(8r!?(8r!?(g(8c!h8r"?A[gm3&)*8r#
+ Œ
+ C!2&W=˜œ¬°´¸¼ÖæC8c!@I1%C
+ VD
+ V	I1%cI(5E6
+ @[c!8c!IY3!ZT@	CyV5D
+ �V'ƒT'C
+ VChIj	A[5F6
+ @[TTT[c!1%1%dhih 1%1%1%1%1%C
+ VChIh	A[5G6
+ @[chih 1%1%gÿÿÿÿj^M	g†3&)*8r#
+ Œ
+ C!2&W		-=IU‚·Àc(GhG	^8r#	]Çhih	 1%d8r"!!1%d"!1%e"!1%c!V1%8c!6H
+ 8c"c8r"!d8r"!1%chih 8r!h]Çÿÿÿÿ	}U\^É!	zUïÿÿÿc1%
+ CiA[c8r"!1%g�3&)*8r#
+ Œ
+ C!2&Wchkh$chih$c()*W.9D5I8¢f&5J8¢f&5K8¢f&C
+ 8?!6L8¢f'C
+ 6M8¢f'C
+ 6N8¢f'C
+ 6O8¢f')*GVC
+ TC
+ FFoVTDn>M()*~V~V(h8H'^É
+ ƒ__Ê2&2&]Ç
+ ,Äÿÿÿch&)*8r"
+ ‡a©ÿÿÿT‡AÉÿÿÿTÐÿÿÿ8r"
+ ‡a©ÿÿÿT‡AÉÿÿÿTÐÿÿÿ
+ lpn8?%)*8r"Ðÿÿÿ8r"Ðÿÿÿl
+ p8r"Ðÿÿÿldpnn
+ ‡ˆÿc!U8c!8r!?A[8?%‡n"†u&’ÿÿÿ
+ Wg
+ (Tg(g	(„bg((Chz(ChC8H#I(C]ÇC~VeC]Çp]È	C]ÇhhC8H ICCS€(IcI(5P?6Ql•8"l]È
+ ?h?
+ +Ýÿÿÿ+¦ÿÿÿ+‘ÿÿÿ8c?h?
+ +ÿÿÿ	+Kÿÿÿ+üþÿÿ	+²þÿÿ	+Ÿþÿÿ	+7þÿÿ	+Þýÿÿ6R
+ 	,³÷ÿÿÂ÷ÿÿƒûÿÿŠûÿÿŽüÿÿ�üÿÿ„ýÿÿ‹ýÿÿ
+ >9STìY8S!
+ �Vƒ„JT2!TcZ(8SCyVD
+ WTc(c(c(2%[)*Y8S"h8v!Z(8SCyV)D
+ WT^[
+ [
+ [6T8cC^ËV![7mCyV6U8cC^ËV![7v	CyU7mCyUT8c!6V8cC^ËV!?8m@[[gJ8v!U	g8v!Vc(%,ÿÿÿ+âÿÿÿ
+ +Qÿÿÿ8=!8=!8=!8=!
+ >9WT…)*WCE"XV	CF"I(C2&C2"D2&WE!89	&C&)*C
+ W	
+ 
+ "1";AMc(D2"E2&C2!89	&C"D2!89	&C3!89	&C2&C2+œÿÿÿ89	&D2&)*C
+ VD1&()*C
+ W%C"D!89	&C
+ C"D3!89	&D"E2&)*WC1&CE'CE&C
+ C"D&C"D&)*C
+ W+2?JUc(C2&C2!89	&C"D2'D2'C2+´ÿÿÿ89	&C2"D2&C2"D&C&D&C"D&D&)*C
+ W!(3@QQ\ft|‘�\®ÀÀËÜÀò!øþ
+ òò*c(C&D3"E2&D2#E3&C2"D2+§ÿÿÿ89	&C2"D3&C2!89	&C"D2'D2'C2+cÿÿÿ89	"D2'C2"D&C2"D"E2&C2"D2"E2'C2"D2&D2"E2"G2&C2"D#E'C2&D2&C2+Ýþÿÿ89	&D4
+ "ECF"2&C2"D'C
+ C!"D4!89	&C"D&)*1+ëÿÿÿ89	&D
+ WC&C&)*C
+ W"C&C3&D2"ECF"2&C2"D+µÿÿÿ89	&)*VDC3"2&(D&C(D&)*C
+ W
+ 
+ #0>_mvDC"(C+×ÿÿÿ89	"(D!89	"(D4üÿÿÿ"CF&C	+©ÿÿÿ89
+ "F89#4üÿÿÿ+‘ÿÿÿ89	"(D
+ VC4üÿÿÿ"(C"(C4üÿÿÿ"(C!89	"()*C
+ W&1C&C3"c(D4úÿÿÿ"ECF"2&C2"D2&C2"D4úÿÿÿ&)*389'D"E&C(D&)*C
+ W)8EN\ˆ‘ž«C4òÿÿÿ"(D4ôÿÿÿ"(DC"(C+Âÿÿÿ89	"(D!89	"(D"(D4üÿÿÿ"CF&C	+‹ÿÿÿ89
+ "F89#4üÿÿÿ4öÿÿÿ+lÿÿÿ89	"(D4öÿÿÿ"(C"(C4
+ !89	"(C!89	"(C4üÿÿÿ"()*389#c()*W	C4úÿÿÿ&(D&)*C
+ W)5GSC"D!89	&C
+ C"D3!89	&E"F2&C2"D4ìÿÿÿ+±ÿÿÿ89	&D4îÿÿÿ"E2&C2"D&)*W,3C1&CE4êÿÿÿ&CE&C
+ C"D&D4ìÿÿÿ&C4êÿÿÿ&)*F4üÿÿÿ&)*F&E&D!89	&Wc(C+çÿÿÿ89	&C+Õÿÿÿ89	&C"D&)*D+ìÿÿÿ89	"F#,»ÿÿÿE%)*VC&()*Wc(C&)*^(+öÿÿÿ
+ ?8~!
+ C?
+ ,hùÿÿ+Íÿÿÿ
+ ,¢ùÿÿýùÿÿ+¶ÿÿÿ
+ +’ÿÿÿ,ýùÿÿ6úÿÿ+Aÿÿÿ	,aúÿÿ	,	Éúÿÿüÿÿ<üÿÿzüÿÿœüÿÿ0ýÿÿuýÿÿ•ýÿÿQþÿÿ^þÿÿvþÿÿÝþÿÿÿÿÿ	>9XTp?I(7SCyVD8SE8c
+ 6Y8¢18¢f$7mCyVD8m6Z8¢18¢f$5CyVD6[8¢18¢f'[8cI]ÙVÞYÑ7XC8XI!
+ 8$:!	Y­5\8"V^!
+ 8XC8X"5]8"6^8$"]ÙV5_8$"h@h@@T5`
+ 8XC8XG#
+ C6a8$""D6b8$""T:5c8"V0!
+ 8XC8X"5d8"6e8XC8XG#
+ C6f8$""8$F!!ZT8$F!![Z(	+×þÿÿiI%(7,"V8$B!8$B%c8$C"8r!
+ 8W%7,"V8$B!h8$B!?@(c8$C"8r!
+ 8W%)*Y=]Ç]È		]Çh8$? ^ËVdTg	h8H#l	h8H#^ËV?[Z(CyV5g8$%(C
+ V8%(C
+ V87$8$+!5h6i8
+ "	C6j8‹ 
+ ]àhzV8!5k8‹!e8$L!(()*V8DC
+ ]Çn…M!5l8¢!]Çn2&8¢!!5m8¢!]Ç2&5n8¢%)*V!8¢!,ªÿÿÿ]Ç&()*]Ç~V(^É„ 
+ 2&2&)*]Ç~Vc(^É„ g\_Êg _Ê2&^É_Ê2&g 8H"U8¢%,Žÿÿÿch"
+ ]Çn]È
+ ,¡ÿÿÿch"8¢%)*DC	YC5o8$"!6p8"6q8$"]ÙV
+ 5r8$"T5s8$"@6t8$"@@Z(6CyVIY85u8$"!6v8"CV5wT5x8$"	6y8$"@	@@Z(6CyV@([[)*O~Vc(^^ËU^ËV?(2&VChD"
+ VCC&D2%5?[8H!
+ ,±ÿÿÿ,ÒÿÿÿC%)*7^ËV(CV6z8$"8$&8&Y 8,8"
+ ]äh@@C8$"IZ(6CyVD6{8¢18¢f#dI([c?h?h?h?
+ +¶ÿÿÿ+�ÿÿÿ
+ +qÿÿÿ
+ +Šþÿÿ6|
+ DC	+Pþÿÿ
+ +Ìýÿÿh?
+ +Aýÿÿ+0ýÿÿ6}?
+ +Ùüÿÿ
+ +ªüÿÿ+‚üÿÿ
+ +‹ûÿÿ6~h80I7!h6+#ûÿÿ?6€A@6�?6‚A@6ƒ?6„A@6…?6†A@8Î#CVeTc8$L!
+ !#%')>9‡c8$P!:9ˆ�caml_alloc_dummycaml_update_dummycaml_array_get_addrcaml_array_get_floatcaml_array_getcaml_array_set_addrcaml_array_set_floatcaml_array_setcaml_array_unsafe_get_floatcaml_array_unsafe_getcaml_array_unsafe_set_addrcaml_array_unsafe_set_floatcaml_array_unsafe_setcaml_make_vectcaml_make_arraycaml_comparecaml_equalcaml_notequalcaml_lessthancaml_lessequalcaml_greaterthancaml_greaterequalcaml_output_valuecaml_output_value_to_stringcaml_output_value_to_buffercaml_format_floatcaml_float_of_stringcaml_int_of_floatcaml_float_of_intcaml_neg_floatcaml_abs_floatcaml_add_floatcaml_sub_floatcaml_mul_floatcaml_div_floatcaml_exp_floatcaml_floor_floatcaml_fmod_floatcaml_frexp_floatcaml_ldexp_floatcaml_log_floatcaml_log10_floatcaml_modf_floatcaml_sqrt_floatcaml_power_floatcaml_sin_floatcaml_sinh_floatcaml_cos_floatcaml_cosh_floatcaml_tan_floatcaml_tanh_floatcaml_asin_floatcaml_acos_floatcaml_atan_floatcaml_atan2_floatcaml_ceil_floatcaml_eq_floatcaml_neq_floatcaml_le_floatcaml_lt_floatcaml_ge_floatcaml_gt_floatcaml_float_comparecaml_classify_floatcaml_gc_statcaml_gc_quick_statcaml_gc_counterscaml_gc_getcaml_gc_setcaml_gc_minorcaml_gc_majorcaml_gc_full_majorcaml_gc_major_slicecaml_gc_compactioncaml_hash_univ_paramcaml_input_valuecaml_input_value_from_stringcaml_marshal_data_sizecaml_int_comparecaml_int_of_stringcaml_format_intcaml_int32_negcaml_int32_addcaml_int32_subcaml_int32_mulcaml_int32_divcaml_int32_modcaml_int32_andcaml_int32_orcaml_int32_xorcaml_int32_shift_leftcaml_int32_shift_rightcaml_int32_shift_right_unsignedcaml_int32_of_intcaml_int32_to_intcaml_int32_of_floatcaml_int32_to_floatcaml_int32_comparecaml_int32_formatcaml_int32_of_stringcaml_int32_bits_of_floatcaml_int32_float_of_bitscaml_int64_negcaml_int64_addcaml_int64_subcaml_int64_mulcaml_int64_divcaml_int64_modcaml_int64_andcaml_int64_orcaml_int64_xorcaml_int64_shift_leftcaml_int64_shift_rightcaml_int64_shift_right_unsignedcaml_int64_of_intcaml_int64_to_intcaml_int64_of_floatcaml_int64_to_floatcaml_int64_of_int32caml_int64_to_int32caml_int64_of_nativeintcaml_int64_to_nativeintcaml_int64_comparecaml_int64_formatcaml_int64_of_stringcaml_int64_bits_of_floatcaml_int64_float_of_bitscaml_nativeint_negcaml_nativeint_addcaml_nativeint_subcaml_nativeint_mulcaml_nativeint_divcaml_nativeint_modcaml_nativeint_andcaml_nativeint_orcaml_nativeint_xorcaml_nativeint_shift_leftcaml_nativeint_shift_rightcaml_nativeint_shift_right_unsignedcaml_nativeint_of_intcaml_nativeint_to_intcaml_nativeint_of_floatcaml_nativeint_to_floatcaml_nativeint_of_int32caml_nativeint_to_int32caml_nativeint_comparecaml_nativeint_formatcaml_nativeint_of_stringcaml_ml_open_descriptor_incaml_ml_open_descriptor_outcaml_ml_out_channels_listcaml_channel_descriptorcaml_ml_close_channelcaml_ml_channel_sizecaml_ml_channel_size_64caml_ml_set_binary_modecaml_ml_flush_partialcaml_ml_flushcaml_ml_output_charcaml_ml_output_intcaml_ml_output_partialcaml_ml_outputcaml_ml_seek_outcaml_ml_seek_out_64caml_ml_pos_outcaml_ml_pos_out_64caml_ml_input_charcaml_ml_input_intcaml_ml_inputcaml_ml_seek_incaml_ml_seek_in_64caml_ml_pos_incaml_ml_pos_in_64caml_ml_input_scan_linecaml_lex_enginecaml_new_lex_enginecaml_md5_stringcaml_md5_chancaml_get_global_datacaml_get_section_tablecaml_reify_bytecodecaml_realloc_globalcaml_get_current_environmentcaml_invoke_traced_functioncaml_static_alloccaml_static_freecaml_static_release_bytecodecaml_static_resizecaml_obj_is_blockcaml_obj_tagcaml_obj_set_tagcaml_obj_blockcaml_obj_dupcaml_obj_truncatecaml_lazy_follow_forwardcaml_lazy_make_forwardcaml_get_public_methodcaml_parse_enginecaml_install_signal_handlercaml_ml_string_lengthcaml_create_stringcaml_string_getcaml_string_setcaml_string_equalcaml_string_notequalcaml_string_comparecaml_string_lessthancaml_string_lessequalcaml_string_greaterthancaml_string_greaterequalcaml_blit_stringcaml_fill_stringcaml_is_printablecaml_bitvect_testcaml_sys_exitcaml_sys_opencaml_sys_closecaml_sys_file_existscaml_sys_removecaml_sys_renamecaml_sys_chdircaml_sys_getcwdcaml_sys_getenvcaml_sys_get_argvcaml_sys_system_commandcaml_sys_timecaml_sys_random_seedcaml_sys_get_configcaml_sys_read_directorycaml_terminfo_setupcaml_terminfo_backupcaml_terminfo_standoutcaml_terminfo_resumecaml_register_named_valuecaml_weak_createcaml_weak_setcaml_weak_getcaml_weak_get_copycaml_weak_checkcaml_final_registercaml_final_releasecaml_ensure_stack_capacitycaml_dynlink_open_libcaml_dynlink_close_libcaml_dynlink_lookup_symbolcaml_dynlink_add_primitivecaml_dynlink_get_current_libs„•¦¾7¢xV0
+ $�-Out_of_memory�)Sys_error�'Failure�0Invalid_argument�+End_of_file�0Division_by_zero�)Not_found�-Match_failure�.Stack_overflow�.Sys_blocked_io�.Assert_failure�:Undefined_recursive_module,really_input%input @ F@ @ G@&output A C D F@ A C D G@%%.12g!."%d%false$true.bool_of_string$true%false+char_of_int/Pervasives.Exit_jð_jÿð_jð_jïÿÿÿÿÿÿ_j_j<°5Pervasives.do_at_exit@°(array.mlÐD*Array.blit*Array.fill)Array.sub,Array.Bottom@(List.nth#nth)List.map2*List.iter2/List.fold_left20List.fold_right2-List.for_all2,List.exists2 @@,List.combine°'list.mlÔK-List.rev_map2"tl"hd@"\'"\\"\n"\t(Char.chr@5String.rcontains_from4String.contains_from2String.rindex_from1String.index_from +String.blit+String.fill*String.sub@)Sys.Break&3.08.4@@"%d_iÿÿÿÿ_i_i_i_i_i_iÿÿÿÿ_i€_iÿÿÿ@"%d_jÿÿÿÿÿÿÿÿ_j_j_j_j_j_jÿÿÿÿÿÿÿÿ_j€_jÿÿÿÿÿÿÿ@"%d_nÿÿÿÿ_n_n_n_n_n_nÿÿÿÿ_n_n@ 	%Lexing.lex_refill: cannot grow bufferÀ @@ÿÀ A@@@,syntax error.Parsing.YYexit3Parsing.Parse_error@2Set.remove_min_elt°@@@ @@'Set.bal'Set.bal'Set.bal'Set.bal@°)buffer.mliI4Buffer.add_substring>Buffer.add: cannot grow buffer*Buffer.nth*Buffer.sub@!'!'!"!"!%3printf: bad format @.bad box format/bad box name ho:bad tag name specification   9bad integer specification*bad format")." (	"'', giving up at character number # ``)fprintf: !
+ £@C!.!>"</!>!<2Format.Empty_queue� @"%s"%s.bool_of_string)a boolean-int_of_string*an integer-int_of_string*an integer/float_of_string'a float/float_of_string'a float !  (one of: #(?)&--help%-help9%s: unknown option `%s'.
+ 	1%s: wrong argument `%s'; option `%s' expects %s.
+ 	#%s: option `%s' needs an argument.
+ (%s: %s.
+ �%-help�&--help"%s#%s
+ %-help= Display this list of options%-help&--help= Display this list of options&--help�%-help(  %s %s
+ !}!|!{+  %s %s %s
+ &<none>'Arg.Bad(Arg.Help(Arg.Stop@$%02x0Digest.substring@_i_jÐA_j,Random.int64_i,Random.int32*Random.int!xÜbR+ÍF4ôúÐ±JÎ$x£ÄÈlG%TgÖ‘Ç,�ñw06Á“'7+ñ‘	†K:F¹|‘ÚHÓtcZÅ¡–/>ÓY�Á2>vn íŒ†'›b"?áµŸ?xá †9Ï=Ãš�”dÄL6Ä?}#®SOýóY1~$èN~á˜ä3÷"Ë¾Þ(Q¹dé*Y“=LÐ·ïÿ
+ ýª"ëÇ.’.2yŽÜ( L2o<½íGù<Ö*Õ�O7ï×h9b6oÃ–z@	5Filename.open_temp_file: temp dir nonexistent or full G@	0Filename.temp_file: temp dir nonexistent or full A C E@(%s%06x%s7Filename.chop_extension4Filename.chop_suffix "\\$\\\""\""./".\#../#..\"./#../!."..!/&TMPDIR$/tmp$'\''!."..!\$TEMP!.!."..!/&Cygwin$Unix%Win32°+filename.ml{I@°-utils/misc.mlzJ0>> Fatal error: 0Misc.Fatal_error@(OCAMLLIB'CAMLLIB	E/projects/null/swlab8/blerner/projects/seminal/seminalOcaml/lib/ocaml	H/projects/null/swlab8/blerner/projects/seminal/seminalOcaml/bin/ocamlrun"cc	Bgcc -fno-defer-pop -Wall -D_FILE_OFFSET_BITS=64 -D_REENTRANT -fPIC*gcc -Wl,-E<-lm  -ldl -lcurses -lpthread	-gcc -Wall -D_FILE_OFFSET_BITS=64 -D_REENTRANT$gcc )-lm  -ldl&ld -r &ld -r &ranlib+/usr/bin/nm0/usr/bin/objcopy#-pg,Caml1999X008,Caml1999I010,Caml1999O006,Caml1999A007,Caml1999Y009,Caml1999Z010,Caml1999M010,Caml1999N009$.mli$i386'default)linux_elf".o".s".a#.so&Cygwin$Unix%Win32(camlprog%a.out,camlprog.exe@   @@8Linenum.parse_sharp_line ,8ýÿþÿÿÿ	B8ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ8ÿÿ	ÿÿ	
+ 	
+ †	
+ 
+ 
+ †ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ	
+ 	
+ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
+ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ	
+ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ      @"%s:this syntax is deprecated.	Gthis function application is partial,
+ maybe some arguments are missing.	8labels were omitted in the application of this function.	&this expression should have type unit.:this match case is unused.7this pattern is unused.!.(this is  	“this pattern is fragile. It would hide
+ the addition of new constructors to the data types it matches.
+ Here is an example of a more robust pattern:
+ 	ethis pattern is fragile. It would hide
+ the addition of new constructors to the data types it matches.	=the following methods are overriden by the inherited class:
+  !  	\this pattern-matching is not exhaustive.
+ Here is an example of a value that is not matched:
+ 	(this pattern-matching is not exhaustive.	? hides a previously
+ defined instance variable of the same name.	(this definition of an instance variable  Z@"el/Warnings.Errors@(norepeat$TERM"%a-Warning: %a@. @A 3Characters %i-%i:@.(%s%s%s%i$%s%i*%s%i%s@.%s  ° ÿ@ 3Characters %i-%i:@."  #
+   "  "# "   à&File "(", line -, characters !-!: @.Longident.flat� @	DSyntax error: '%s' expected, the highlighted '%s' might be unmatched?%aSyntax error: '%s' expected@.>%aThis '%s' might be unmatched.%aSyntax error/Syntaxerr.Error6Syntaxerr.Escape_error@�"::¸�"[]@@�"::´�"[]@@&parser#end&struct!)!(!)!(!)!(#end#sig!)!(#end&object!)!(!)!(�&option!?�&option!? #end&object!?!?!?!?  �"::!+!-"-.!*!=!<!>"or"||!&"&&":=   #set%Array   #set&String#end&object!)!(¸�"()@@#end%begin  #get%Array!)!(  #get&String!]![!}!{!}!{"|]"[|�@!]![ ">}"{<@ !?!?�"::!}!{!]![—@"|]"[|!)!(!)!( @@ @@ A@ @A�&option!?�&option!? ”@·@@@�@!-!+!-"-.!*!=!<!>"or"||!&"&&":="()"::%false$true�"[]�"()�%false�$true“@“A!-"-.     #set&Array3    #set&Array2   #set&Array1   #set(Genarray    #get&Array3   #get&Array2  #get&Array1  #get(Genarray�(Bigarray'unsafe_!- !~!-  %falsep	
+  @ !"#$%&'(./456789:;<=?@ABCDEFHIJKMNPQRSTUVWXYZ[\^_`abcdfghijk@H)*+,-0123>GLO]e@
+ Üÿÿ
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+             !!""$%(((''--))))........23334444444667788999*****AAAADEEFFFFFFGH:##IJ++++++++PMMLLNOOKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKRRRRRRRRRRRRRRRRRRRRRRRRRRRRRR//bbccccdeeff@@TTUUggVV^^hhaa__=====5555555QQQQQQQQQQQQQQQQQQiimmllnqqppppppppoootuuu,,rrvssyzz||>>}}}}}~~ƒƒ„„‚‚††‡‡��……BB00xx€€€ˆ<]]]]]]]jjjjjjXX‰‰‰‰‰‰‰‰‰‰‰‰‰‰‰‰‰‰wwwww\\[[kk{{{CC11						WYY??;;&&SS``ZZ
+ Ü	
+ þ<“Â•’–—èé˜”ÃÈê½ÔÕëìí	¡Ö× ŸÙÛãQ¥ #Ÿ$™!åð‘ÀéÛ¶µ´·°²§¨©ª«±³¬Á¯ÑíjìLK9G"òõÊ
+ ÜÚ“&£­®¦ÊiajžÄ+›šœ�ž ›¥™Æ%�­æåûÙØ¢2(ÓÒ !MÉ¾—úøñ÷ó�<Í5>×ÕÔØÖÞP'‹v�n‰hk".-ïîëêèçÿýÝÒgmn°H:=IBMC?’WR¤{yrmŽo$ÇËÝÜÅ'&)(,*œüªþ3o_pálNº»¼O¶äâà�;:76WÎãáßz€SUŒswu]��Šl…8Ì`p0/§¢š˜¤«h[kß¹¸Q@NÏ”†z�tƒ†ŽYeda`qwTP<‘X‚�T~x^\q1X^sÐ„‰Š|‚·]cbuvytUC=L}‹‡ˆxV{E�Œ
+ /?CJ0@D1LMN3®4“_b‚»5qk¯[l°íò_Z¥[\iÃÿ&z<ÄââÅ±²v`BË>?½–6'É(ijªðÕ§7Ÿ<-8zKH9:;Œ<…=>†ŽW‹äåŸb)I‡/x*0¼½FÚ×—¾¿ØÙÏ˜î !"#Þ€mnorß¨
+ þ€,%tº*&Ãÿÿ×Ñ½(Wÿœ'|º*ð*´d&²&ÿQ$œ'‰¯Ëÿdÿº*|%œ'Žœ'ûÿº*!4+N*¨º*œ'~nï.gÕ±±±½ÿFÎM7’+,Í+,Bwl)1ø(2)Ë%<”¦6¶ŸÒ'l)lb|,%�Ÿ½ÈËkÿ°ç±Ø+ÍÍÁl)º*áÿÖÌÓæÿ*l)¶ŸÕ™@õ:úã½œ'œ'œ'œ'œ'œ'œ'œ'œ'œ'œ'œ'œ'œ'œ'œ'œ'œ'œ'œ'œ'‡º*º*„*½œ'½*ï×^ŒdÿŽ×ü’±±±Ÿl)TÎ™Öñ)Wÿ#>RÍÍ)¯Lïÿ„œ'a[Wl)#l)b""<Ïl)??œ'œ'Ò'”ÿxœ'!°×|1œ'1œ'Rÿœ'Šÿûæÿ²þ (3�0Wÿ{‡s^|+7ûÅfÿŽtœ'l)Ø+f,f,a,�Ø+a,ggggyhhgyya,yhœ'œ'œ'S½½a,Î“MÍY^.¯5‘Ÿ@Íûÿœ'œ'œ'²Î^:H(FGA’ë#ÍZNžë#ë#š…UÍXn©}_;XeÍÖ¯.ÿ=l)1·ÿÑl)l)l)l)l)¡ÿÍ(ŸŸ­izl)9+²^Hÿ°Ø+¨Ø+¬Ø+�l)œ'œ'œ' (®Îl)^Ó^)ÿ�ÒÍÍîœ'Öœl)™Š,Ìà|+„jZÿœ'TÎ¦Ë�<ÿ˜×ÿ@ÚèÓ^Š¢+mŽÿÖ“îH(ÖŽ�êë#Å�)ü°Í"ÍÍë_±A}œ'#Ø;ííí# ÿÍœ'¡¢Íœ'”ÿœ'^Gÿœ'œ'œ'œ'ÍxÚÿ.|^¥ã½(ÍúîËÿò„*–´ôxeÿçºÿûMóÏÐÕØ+_dÿŽ^5^.Ï*	ÙÖÑ×Oë#"Í§ë±Í¯±Ýçÿ·
+ l)Ø+YØ+Ø+|�gÍ (Jl)Xÿ3â„*)ƒ(éÇû´eÿœeÿÍœ'œ'œ'“^Jÿ1×ÿ..^ÍTœÖÍ„Þî“G#fÍ±}Íœ'#æ�æÿî¯“)œ'þûÛØ+Ø+Ø+iXkJLîß:“ÖÍ±|îÆÿ))œ' œ'œeÿ*œäõUÍ‘“ÍÏÖœü�œ'Ûû)^“ñ.ó.4)Í
+ þG©¦)à)d»ÿ3‡55ûc
+ n©Ð
+ ðƒà)©T#±$< ™[#ï(òÿqNÿ¡2'N'ý�#55–#à)\Á=	É©‡>û§#©#*#*7ŸcòÿÊSÿ\C¡25-?ê#]¦)û#ž¦)‡´!¹eÊ-á�Mº'“.¢›ót{hŠ	÷	V©­îVÑ°©R!L=¡-?5ÿÖÑIòÿxÿ9ÿ}ÿôÔ&Iê#þ+€"©„"ž"ãEš2-Ñ¡?÷Z½¼ÿè$à)»ÿ$‹ Ý,U§þ Ú!"£!÷ÔD±ìãt¸"�Qÿ‰â'#¸ ."Ý&Ö"„ÿ3ê$ç¡& #ÉL"E¨ª%!C&ÿ…,&í"f"O½
+ íÃ.ýÿÛS‹ÿªþ²ÿÿ®¨ÿËý†‡þ€¼þÿÿåO²�x7ÿÌýòü{IÂ[þÞÿÎàêüçýëÿ`ÿýáýF=ýÙýêBéS•ªóÿ
+ ùþbVˆ€Ü­ÿ·ù�ƒÿ3ÿËŒ�èþ`ŸÿM;ÐÐeýõuÿná÷^>ÿ&ÿÿQ ýÿ`þÿ¸e
+ [âEK¯tŠXUgNØÚAZ{Q\s])¢qÆ3€!§©Õƒ]×�„ÖÌµÖã·!®À³{pRÐ´
+ cMtuÈçš=Æóã¹çŠù/¨žÃÄ�¦‘…32UG‡&àà3yD®’/… ˆtüýþ…Tq(qqqçAÏ€GB q¼¶{ê…q^Ð€22Pf›|¦?à‹Ï…èWfÀIöqG÷ûÖ0©$˜øKùW3Fm3Åô´‰XáWý•þq�…§ìi4CáUëOîÞß4ÜÓf-L  iwx 2ik–Ef¶¸QÕfc(ùÕøÕœ�iiôãdPzeæn6µ™%æ½4‡iF¦ÝoýÁè(qô22°‘+-íqÅ4Ð4¿ÀÁå´=]ëÝ5®ïi¡rp6YÄäyZÿçé”q7qrf­tì{r=ç¦qWæçG=Bq¹.Srrte€=(=={(Ç¡`RyÅ8r=q¡{ÞÞ,,4à5î€5Ù¡6áHG6ÕJçR=×qÛê=ér,fÏ{ÏçLMªëì]Ï_]…�æ=¡=íœÏÏÏÏ{|H\î¡"sÎÏæï±etßbc÷îXFvôëï‰jÆÿ^qÿöÆÏ÷ä	#JÏøF»ù¼ðÞñäÏ ÏÆÞÆÕéP£¥®ÏÆæÏq(ÞÓsqqqOqqŸwyfä×£öÖ9÷OcqÞÕ7øpàùtÞ~|¯°±úx
+ q:;äq£äõ7ÃúqÆ~}|<¸7Þ®Þ7&qõ*Ì7Ð778Þ	ÍSÛ†}ðÂé75t8"Ü=Ýo¦&áÑ¤~j|®7q>
+ (*¢7-áTÒ‰7Þ,ª
+ Ý Rö}"µ77Äéuµõééæ7RR7©'S«|·+ÓáÍÂÓÔR“3Ë"Iß¹4t&qHRtIR¬R}˜
+ ™€;€º­q'š®ÒÓÔ,ãuOc:;ÂÛÃˆ~¹ß'ÄÖ×-‚9=>uº...Ù-­Â»Z‰u¼y"-ŽÛ.¼&“”•O–—O-îaÓ¡áIBOb¾u§¤Û.-,ÓÓüOÇOO®²"KOcÓR¿ÇGOqFÀ­Át�.Ž‰ŠJZÂÓ‰t€;ÈJÓqÚ»qOÓJ�@KO‹ãq8F8-ÓÓcØO58$RRÓ@(RºOíóO8888678'æé®@6³8¼ƒ¶��Sç.Å¿9¨¯PÌ®b®8%¤ÁrÔZ¿8æ-PP8�©f„M�çþï8P88ƒ.„I.„8DP8fPIP.à€�âÈ®ËƒW@IuII#Ly¸#P¹#W#WIW##÷ø#ºQòªâu²9#Srâ+++dv«¬9³´Ir=Bd;Ie+9999.Xö’ ÷IÞVY_9ø,#ùßIÞ+I`a?$Cšß��##9##›P[^ö9~÷±öh9÷+øæ#ù�øijù9æ99èry}v|vvv9~ø9uù9v’žÔ‰¨¸vÇÔËÔÑ$PPà$P$$çäì$$ð$añò.ûóË$...ü..=�+Z .0Î1.v2EN5ÑÒÓÔÔP
+ TWYŒek¥l$‚.rqsuvwÖ×+±x+.$$}$$Ù~†ž¡+�£¦¢.«Û­$¬r³ƒ„…†‡ˆ‰Š‹Œ�Ž��‘’“”•a—´ºÛrÊ"äåæñ£±uò
+ óŸõù#ÔëA;();ø9:D+NQ;ESRv\wvTU,Wl;V;;Y`gvh,mn„}J;Œz«v¬°,…,,·½¾‚¿ÂÊÙÎÆ;,Ïåçèáû;vuñü;Rú,r±V;;,{¦HJ,;a;wæwwwà­,,ç¡ÞOwæ±V±,+wŸ÷¶+++Ô++êÉ^·Ê„ZCÔZOÔ+w‘Í@Zãé J±|	ZZZZ+.érvw¾�¡Z®+dêëì²2Dãö¢u[æ.™í+ZRatuZˆvZG’vvvvvZîZZï±vZrZŸZŸ|±wŸðañvÊRŸŸŸŸvR@ŸvRRRwwŸÊR±±ŸwdŸrwPŸvŸŸRâRŸŸHŸwRH¡RRHHHŸŸwHŸËŸŸŸŸ±vHŸ±H+-12HŸËŸHrH+ŸPwrŸŸŸGŸŸGÉŸdGwGGwwwwwG¿vwdGvawGwv±wGGGw›œ�w¡¡¡¡Þ¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡‘¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡¡w¡¡¡¡¡¡¡¡¡¡¡¡¡¡ú¡¡ûãüýþ¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿w¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿w¿w¿¿¿¿¿¿¿¿w¿¿á¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿ÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞßÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞÞããããããããããããããããããããããããããããããããããããããããããããããããããããããããããôããããããããããããããããããããããááááááááááááááááááááááááááááááááááááááááááááááááááááááááöááááááááááááááááááááááááßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßßùßßßßßßßßßßßßßßßßßßßßßßßßôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôôÖôôôôôôôôôôôôôôôôôôôôôôôöööööööööööööööööööööööööööööööööööööööööööööööööööööööö×öööööööööööööööööööööööùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùùù©ùùùùùùùùùùùùùùùùùùùùùùùÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖ¨ÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖÖ××××××××××××××××××××××××××××××××××××××××××±××××××××××××××××××©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©©Ð©©©©©©©©©©©©©©©¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨¨Ñ¨¨¨¨¨¨¨¨¨¨¨¨¨¨±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±±²±±±±±±±±±±±±±±±ÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐÐ³ÐÐÐÐÐÐÐÐÐÐÐÐÐÐÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑÑ¬ÑÑÑÑÑÑÑÑÑÑÑÑÑÑ²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²²¼²²²²²²²²²²²²²²³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³³½³³³³³³³³³³³³³³¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬Á¬¬¬¬¬¬¬¬¬¬¬¬¬¬¬¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼®¼¼¼¼¼¼¼¼¼¼¼¼¼¼¼½½½½½½½½½½½½½½½½½½½½½½½½½½½½½½½½½½½½½½½¯½½½½½½½½½½½½½½½ÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁ–ÁÁÁÁÁÁÁÁÁÁÁÁÁÁÁ®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®®»®®®®®®®®®®®®®®®¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¿¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯–––––––––––––––––––––––––––––––––––––À–––––––––––––––»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»»¾»»»»»»»»»»»»»»¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¸¿¿¿¿¿¿¿¿¿¿¿¿¿¿ÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÀÂÀÀÀÀÀÀÀÀÀÀÀÀÀÀ¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾¾Ä¾¾¾¾¾¾¾¾¾¾¾¾¾¾¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¹¸¸¸¸¸¸¸¸¸¸¸¸¸ÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂÂºÂÂÂÂÂÂÂÂÂÂÂÂÂÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÃÄÄÄÄÄÄÄÄÄÄÄÄÄ¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹È¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹¹ººººººººººººººººººººººººººººÇººººººººººººººººººÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÆÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÃÈÃÈÃÈÈÈÈÈÈÈÈÈÈÈÈÈÈÈÈÈÈÈ
+ ÈÈÈÈÈÈÈÈÈÈÈÈÈÈÈÈÈÇÈÇÈÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÅÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÇÆÇÆÇÆÇÆÆÆÆÆÆÆÆÆÆÆÆÆÆÆÆÆ	2ÆÆ2222Æ2ÆÆÆ2ÆÆÆÆÆÆÆÆÆ
+ Æ
+ Æ
+ Æ
+ 
+ 
+ 2
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 2222
+ 
+ 
+ Ï1
+ 
+ 12111
+ 1
+ 
+ 
+ 1
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ 
+ Å
+ Å
+ Å
+ ÅÅÅ1ÅÅÅÅÅÅÅÅÅÅÅ1111ÅÅÅÉÅÅ1ÅÅÅÅÅÅÅÅÅÅÅÅÅ	Å	Å	Å																	Ë															Ï	Ï	Ï	ÏÏÏÏÏÏÏÏÏÏÏÏÏÏÏ´ÏÏÏÏÏÏÏÏÏÏÏÏÏÏÏÉÏÉÏÉÏÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉÎÉÉÉÉÉÉÉÉÉÉÉÉÉÉÉËÉËÉËÉËËËËËËËËËËËËËËËÍËËËËËËËËËËËËËËË´Ë´Ë´Ë´´´´´´´´´´´´´´´Ì´´´´´´´´´´´´´´´Î´Î´Î´ÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎ•ÎÎÎÎÎÎÎÎÎÎÎÎÎÎÎÍÎÍÎÍÎÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍµÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÌÍÌÍÌÍÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌÆÌÌÌÌÌÌÌÌÌÌÌÌÌÌÌ•Ì•Ì•Ì•••••••••••••••••„••••••••••••µ•µ•µ•µµµµµµµµµµµ/µµµµµ‡µµµµµµµµµµµµµ*µÆµÆÆÆµÆÆÆÆÆÆÆÆÆÆÆfÆÆÆÆÆÆÆÆÆÆÆÆÆÆÆgÆÆ,Æ„Æ„„„„„„„„„„„„„„„„ˆ„„„„„„/„„„„„„„/„„‡„‡‡‡„/‡//‡‡‡‡//‡‡‡‡‡e‡/‡‡//‡‡‡‡//‡/J‡‡‡‡‡‡fffff‡‡f‡ffffffffcfffggggfgfgffgggfAggggfffffgfgfggffˆˆˆˆgˆgˆggˆˆˆgdˆˆˆˆgggggˆgˆgˆˆggˆˆˆˆˆˆˆˆˆˆˆeeeeeˆˆeˆeeebeeeeeeeeeeeeeeeeeeccccceececcc_cccccAcccAYcAcAAccAccccccddddcdcdcAdddAddddAddHAddA€€€€€€ddd€d€€dd€ddddbbbb€€bddbdbbbbbbbbbbbAbbbbbbbbbb____bb_b_______YY__Y__øYYYY___Y_______YY__Y_YYY	
+ YYY¿ !"#$%&'IB)*+,-.	
+ Z !\"#$%&'B)*+,-.	
+ ¸ !"#$%&'ÐB)*+,-¿.¿¿¿¿¿¿¿¿¿¿S¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿¿Z¿ZZ¿¿¿¿¿¿ZZ¿¿Z¿¿¿¿RZ¿ZZZ>\ZZ\\\\Z\ZZ\\\Z?\ZZZ\\ZZ\\\¸¸\¸@¸\¸\\Ê¸¸¸\\Ð¸ÐAÐ¸ÊÐÐÐÐ¸¸¸BÐSS¸¸SS¸ÇS¸DÇÐSSSÐSÐÐÇJÇDÐÇÐSSSERRRSSR>RS>KSRRR>>R>>>F?>?R?R?R>???>RR>?R@R@>>@?>@>?4@@@?0A@A??A?A?@AAAB@B@RAB.B@@BDBBDA@@DABDADJDDDAABJD+DBAA%BJJJDEDDDBB-JEDDBDBEKEEDDKJEDDJDDKKKFJDKFEJJDE#DFFFE)KFEK*EKFKK4F404F04F44F000400R.4R04.40RRR0...44R00.40+R%.R+R.%.-+++RR%%%-..+R%.---+-%++%%-++#-%%-+#%)--#*##)-*#)))***)#@Ó*##))*##)*#*”•))–	**)—*˜™š›œ�žŸW ¡#$%¢£¤¥¦)“*+“-“““.“““““““““““““““hh“““““h“[“hh“““““h“““““hh“hhh	
+ [hhhhhh !"#$%&'(	
+ )*+,-. !"#$%&'”•–e)—*+,-˜.™š›œ�žghiŸOj3#¢£	¥n¦)*V-pW !#$%'	)*+-.W !#$%'Œ�	)*+-.W !#$%'èèèè)*+-.èèèèèèèèèèèèèèèèèèèèèèèèéé­ééèèèèèéééééééééééééééééééééééé®	éééééWe !#$%')*+-f.ghiOjkEe#delm%n)o*-pFfghiOjke#glmhn)o*-pfghiOjke#�lm%n)o*e-pfghiOjke#lfmghinOj)koƒ*#-plfmghinOj)ko*e#-plmn)o*-pghiOjk1e#Œn)*-pghiOjke#n)*-pghiOjäkä#ään)*-pääääääääÚäÚäÒÚÚäääääÚÚÚÚÚÚÒÚÚÚÚä@ÓÚÚÚÚÚ	ääääääÜääÝääO	#$Þ'ßà)á*-ÝO	#$Þ'ß)á*-O	#$')*-‚ÈÉ#$ÈÉÊ'ÊËÌÍËÌÍ)Î¥*Î-ÏÏÐÑÒÓÔÐÑÒÓÔÕÕÖ×Ö×ÈÉØÙÊØÙËÌÚÍÛÛÎÏÈÉÐÑÒÓÔÊËÌÍÕÎÖ×ÏØÙÐÑÒÓÔÜÛÈÉÕÊÖ×ËÌÍØÙÎöÏÛ±±ÐÑÒÓÔ±±±Õ±Ö×±ØÙ±±±±±”•–Û±—±±˜±±™±š›œ�ž±ÈÉŸÈÉÊËË¢£ÎÎÏ¦ÏÐÑÒÓÔÐÑÒÓÔÏÕÕÖ×ÐÖ×ØÙÙÛÛÑÒÓÔ
+ [â$§}Wbn‹Ž�gân^
+ =(E+‰$.&¸Ó¨
+ 'JhùÒØÚS5gB8:IW12�GE«	f>	$nVi sKLMfghijTyÂs$sˆ(.ze}12	?ÜWÁaXAWk�€“GI«WWU?XkUÈ«Xÿ*¤WåWk0O2°gÐWTÎ#½¾	bDeeàTµ¶X~UsXýÚDU0P2¦ÒU\ÜñØWÚÝÞ./åâ 5à ïUWóoëAiéûVÿ]µ¶?TdeÑ	UìXùúûy¿EW$g?dÄh?NW+.$WmGdUg;EFYkTn	GGƒ¦©./aúPRV<·ÙˆßºA(aZXhijZTTÕoXXUkTÓ~XszTkE«¬€»Kg¤}~UkU™šñó UódZg(ÎW³Òk°B(ÓUa ËUÃÄUE>YDKñíË>?ËDEW'SK 79dUgW#YZ\E??UUídeUgòóU÷øùûüYSúW?ú`ú>?5 Z&U|?#$%{IW"./b&We+5./;##A�b:;e(¹�AY¡7?>>#X=?(W´jWE#gxPK¿.UjUh=jWÀYbCEeÑeA>K5d"J†YUŒzYZ”?(/è??dgìž>?"ñ£gúA=,-'	I­E³¾KÉ5Ì8[:?57¹¾60e¾>?Á+,-dÄ>?>?5\7$(^B5>?BCe:>?fNhijNe>=]ë>sbEeò\zSK÷øùûüef7[aYZ> h“edI—v˜>?(¤7P3(#>=>?;D°F>e/hI=7>H6;hSE;·'>EKAe>ÂKCHeeYZ>?°YÝÞd>[â…dZãg012>eÊm>>w(Ð>}>Ze>–ZG>e>ƒ>…=d’hkE$eKee e?e$üeW'YZ+e.eWed5g8:;¿·WÂW»WkG_??Bk	k(k îïNáV7aVf>hijdedeEs>? Kz€	Y3XX3(D3d>“g>?mo>TU=WX	¤XeE#íWK°i keW	YZ<k>fhijdSgËksV>Ò>eYzØ>ÚWÝÞâ	>\ “òX÷øùXûü>eeW 	°<e*+,--J?keU>\W DÅ"UJ& #BC+nX./TUDWXN :S ;]eD WA\'iGÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÛ aF>e æ«jesDDWWWh€P+.<< ><   ;?DeW(>DDG éD  QDX=(W TD Ea¾D KÄT	Y=Ë L>YZEWSSKXd€[gf#hij>WYZ#W>~sT0¬2dòzGð÷øùúûüËò1jD;Ä¤ª“H¥ÂPTUBWX˜]G"#g&Ëi°óá("/ÇR&i|Ãé\;ìÆ>Q(A=CÂ aÿÿHxEÿÿÿÿìòÿÿKö÷øùÿÿûüÿÿÿÿÿÿWEYZÿÿÿÿÿÿK¦ÿÿÿÿÿÿdjÿÿgÿÿÿÿkÿÿÿÿtÿÿÿÿÿÿºÿÿdÿÿ"gÿÿÿÿ&ÿÿ/ÿÿ7ÿÿ9:;ÿÿ>?(ÿÿÿÿÿÿÿÿÿÿÿÿAÿÿÿÿÿÿ+ÿÿÿÿ.ÿÿSÿÿ=ÿÿ?(ñZóÿÿE;ÿÿÿÿùÿÿKÿÿefÿÿ¾ÿÿGÿÿÿÿÿÿÄWjYZÿÿÿÿEÿÿÿÿÿÿÿÿNKdÿÿÿÿgÿÿÿÿkaÿÿÿÿÿÿÿÿYÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿÿÿÿÿÿÿ€ÿÿÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿWÿÿYÿÿÿÿ¾E(ÿÿ`ÿÿÿÿKÿÿ#ÿÿÿÿÿÿ¥ÿÿÿÿÿÿÿÿn«¬Yÿÿ=ÿÿ?ÿÿÿÿÿÿÿÿÿÿEd;ÿÿg>KÿÿÿÿÿÿCËÿÿˆÿÿHÿÿÿÿWÿÿYZÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿdÿÿÿÿgÿÿ kÿÿÿÿÿÿ¥ÿÿÿÿÿÿÿÿÿÿ«òÿÿÿÿ÷øùÿÿûüÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿ#ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÎÿÿÿÿÑÿÿ ÿÿÿÿÿÿE;ÿÿÿÿ>"Kÿÿ&ÿÿÿÿHÿÿèÿÿ/ÿÿYÿÿ'(ÿÿñÿÿÿÿÿÿÿÿÿÿdÿÿÿÿgÿÿAÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿ?ÿÿÿÿÿÿÿÿÿÿEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿTUVÿÿÿÿÿÿWÿÿYZÿÿÿÿÿÿjd	
+  ÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./0123ÿÿ5678ÿÿÿÿ;<=>?ÿÿABCDEÿÿGHÿÿÿÿKLMNOÿÿQÿÿ¾TUÿÿWXYZÿÿ\]ÿÿ_`abÿÿde7g9:;kÿÿ>?ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿIÿÿÿÿLÿÿÿÿÿÿÿÿQÿÿSÿÿÿÿÿÿÿÿÿÿÿÿZÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿefÿÿÿÿ	
+  ÿÿÿÿÿÿÿÿ#ÿÿ#$ÿÿÿÿ'()*+,-./0123ÿÿ5678;ÿÿ;>=>?ÿÿABCDEHGHÿÿKLMNOÿÿQÿÿÿÿTUÿÿWXYZÿÿ\]ÿÿ_`abÿÿdeÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿ	
+  ÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./0123ÿÿ5678ÿÿÿÿ;ÿÿ=>?ÿÿABCDEÿÿGHÿÿKLMNOÿÿQÿÿÿÿTUÿÿWXYZÿÿ\]ÿÿ_`abÿÿdeÿÿgÿÿÿÿÿÿkÿÿÿÿ	
+  ÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./0123ÿÿ5678ÿÿÿÿ;ÿÿ=>?ÿÿABCDEÿÿGHÿÿKLMNOÿÿQÿÿÿÿTUÿÿWXYZÿÿ\]ÿÿ_`abÿÿdeÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿÿÿÿÿ	
+  ÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./0123ÿÿ5678ÿÿÿÿ;ÿÿ=>?ÿÿABCDEGHÿÿÿÿKLMNOÿÿQÿÿÿÿTUÿÿWXYZÿÿ\]ÿÿ_`abÿÿdeÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿ	
+  ÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./0123ÿÿ5678ÿÿÿÿ;ÿÿ=>?ÿÿABCDEGHÿÿÿÿKLMNOÿÿQÿÿÿÿTUÿÿWXYZÿÿ\]ÿÿ_`abÿÿdeÿÿgÿÿÿÿÿÿkÿÿ	
+  ÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./0123ÿÿ5678ÿÿÿÿ;ÿÿ=>?ÿÿABCDEGHÿÿÿÿKLMNOÿÿQÿÿÿÿTUÿÿWXYÿÿÿÿ\]ÿÿ_`abÿÿdeÿÿgÿÿÿÿÿÿkÿÿÿÿ	
+  ÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./0123ÿÿ5678ÿÿÿÿ;ÿÿ=>?ÿÿABCDEGHÿÿÿÿKLMNOÿÿQÿÿÿÿTUÿÿWXYÿÿÿÿ\]ÿÿ_`abÿÿdeÿÿgÿÿÿÿÿÿkÿÿÿÿ	
+  ÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./0123ÿÿ5678ÿÿÿÿ;ÿÿ=>?ÿÿABCDEGHÿÿÿÿKLMNOÿÿQÿÿÿÿTUÿÿWXYÿÿÿÿ\]ÿÿ_`abÿÿdeÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./ÿÿÿÿÿÿ3ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKLMNÿÿÿÿQÿÿÿÿTUÿÿWXYZÿÿ\ÿÿÿÿ_`aÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./ÿÿÿÿÿÿ3ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKLMNÿÿÿÿQÿÿÿÿTUÿÿWXYZÿÿ\ÿÿÿÿ_`aÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿ\ÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYÿÿÿÿ\ÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿ\ÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYÿÿÿÿ\ÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYÿÿÿÿ\ÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYÿÿÿÿ\ÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYÿÿÿÿ\ÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿ\ÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,ÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿ\ÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,ÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿ\ÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,ÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿ\ÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿ\ÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿ\ÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+,-./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿÿÿÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿ\ÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+ÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+ÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+ÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*+ÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿABCDEÿÿÿÿÿÿÿÿKÿÿMNÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()*ÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿKÿÿMÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()ÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿKÿÿMÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()ÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿKÿÿMÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()ÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿÿÿKÿÿMÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()ÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿÿÿKÿÿMÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#$ÿÿÿÿ'()ÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿ=ÿÿÿÿÿÿAÿÿDEÿÿÿÿÿÿK	Mÿÿÿÿ ÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿ_ÿÿaÿÿÿÿdÿÿgÿÿÿÿk	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿDÿÿ$ÿÿÿÿ'(ÿÿÿÿÿÿÿÿ./ÿÿÿÿTUÿÿWXÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿiÿÿÿÿÿÿKÿÿMÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿÿÿdÿÿgÿÿÿÿk	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ$ÿÿÿÿ'(ÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿ	ÿÿÿÿÿÿ ÿÿÿÿ=ÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿKÿÿMÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿdÿÿgÿÿÿÿk	ÿÿÿÿ DÿÿÿÿÿÿÿÿTUÿÿWXÿÿ$ÿÿÿÿ'(ÿÿÿÿÿÿ./ÿÿÿÿiÿÿ	ÿÿÿÿÿÿ ÿÿÿÿ=ÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿdÿÿgÿÿÿÿk	ÿÿÿÿ DÿÿÿÿÿÿÿÿTUÿÿWXÿÿ$ÿÿÿÿ'(ÿÿÿÿÿÿ./ÿÿÿÿiÿÿ	ÿÿÿÿÿÿ ÿÿÿÿ=ÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿdÿÿgÿÿÿÿk	ÿÿÿÿ DÿÿÿÿÿÿÿÿTUÿÿWXÿÿ$ÿÿÿÿ'(ÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿiÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿdÿÿgÿÿÿÿk	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ$ÿÿÿÿ'(ÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿdÿÿgÿÿÿÿk	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ$ÿÿÿÿ'(ÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿdÿÿgÿÿÿÿk	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ$ÿÿÿÿ'(ÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿdÿÿgÿÿÿÿk	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ$ÿÿÿÿ'(ÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿdÿÿgÿÿÿÿk	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ$ÿÿÿÿ'(ÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿdÿÿgÿÿÿÿk	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ$ÿÿÿÿ'(ÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿdÿÿgÿÿÿÿk	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ$ÿÿÿÿ'(ÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿdÿÿgÿÿÿÿk	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ$ÿÿÿÿ'(ÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿdÿÿgÿÿÿÿk	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ$ÿÿÿÿ'(ÿÿÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWÿÿYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿdÿÿgÿÿÿÿk	ÿÿÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ$ÿÿÿÿ'(ÿÿÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿ_ÿÿaÿÿdÿÿgkÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#ÿÿÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿ7ÿÿ9:;ÿÿÿÿ>?ÿÿ=>ÿÿÿÿAÿÿÿÿDEÿÿÿÿLÿÿÿÿKÿÿQÿÿSÿÿÿÿÿÿÿÿTUZWXYZÿÿ\ÿÿÿÿÿÿÿÿefdegÿÿÿÿkÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#ÿÿÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿÿÿ./ÿÿÿÿ7ÿÿ9:;ÿÿÿÿ>?ÿÿ=>ÿÿÿÿAÿÿÿÿDEÿÿÿÿLÿÿÿÿKÿÿQÿÿSÿÿÿÿÿÿTUZWXYZÿÿ\ÿÿÿÿÿÿefÿÿdegkÿÿÿÿÿÿÿÿÿÿÿÿ'(ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#ÿÿÿÿÿÿ(ÿÿ=ÿÿÿÿÿÿ./ÿÿÿÿE7ÿÿ9:;Kÿÿ>?ÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEYZLÿÿÿÿKÿÿQÿÿSÿÿdÿÿWTUZWXYZÿÿÿÿefdÿÿÿÿgÿÿÿÿkÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#ÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿAÿÿDEÿÿÿÿKÿÿÿÿÿÿTUÿÿWXY#ÿÿ\ÿÿÿÿ(ÿÿÿÿÿÿÿÿd./gÿÿÿÿÿÿkÿÿÿÿÿÿÿÿ=ÿÿÿÿAÿÿDEÿÿÿÿKÿÿÿÿÿÿTUÿÿWXY#ÿÿ\ÿÿÿÿ(ÿÿÿÿÿÿÿÿd./gÿÿÿÿ7k9:;ÿÿÿÿ>?ÿÿ=ÿÿÿÿÿÿAÿÿÿÿDEÿÿÿÿLÿÿÿÿKÿÿQÿÿSÿÿÿÿÿÿÿÿTUZWXYZÿÿÿÿefdÿÿÿÿgÿÿÿÿkÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#ÿÿÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿ7ÿÿ9:;ÿÿÿÿ>?ÿÿ=ÿÿÿÿÿÿAÿÿÿÿÿÿEÿÿÿÿLÿÿÿÿKÿÿQÿÿSÿÿÿÿÿÿÿÿTUZWXYZÿÿÿÿefdÿÿÿÿgÿÿÿÿkÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#ÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿAÿÿEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿÿÿdÿÿgÿÿÿÿkEÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿY#ÿÿÿÿÿÿÿÿ(ÿÿÿÿÿÿd./gÿÿÿÿ7ÿÿ9:;ÿÿÿÿ>?ÿÿ=ÿÿÿÿÿÿAÿÿÿÿÿÿEÿÿÿÿLÿÿÿÿKÿÿQÿÿSÿÿÿÿÿÿÿÿTUZWXYZÿÿÿÿefdÿÿÿÿgÿÿÿÿkÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#ÿÿÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿAÿÿÿÿÿÿEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZÿÿÿÿÿÿÿÿÿÿdÿÿÿÿgÿÿÿÿkÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#ÿÿÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿAÿÿÿÿÿÿE(ÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿWXYZ=ÿÿÿÿÿÿÿÿÿÿÿÿÿÿEdÿÿÿÿgÿÿKÿÿkÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿWÿÿYZÿÿÿÿÿÿ
+ ÿÿdÿÿÿÿgÿÿÿÿÿÿkÿÿÿÿÿÿÿÿÿÿ !ÿÿÿÿÿÿÿÿ&ÿÿ(ÿÿÿÿÿÿÿÿÿÿÿÿ012ÿÿ45678ÿÿÿÿÿÿÿÿ=>?@ÿÿBCÿÿEÿÿGHIÿÿKÿÿÿÿÿÿOÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿYZÿÿÿÿ]ÿÿÿÿÿÿÿÿbcdeÿÿÿÿj
+ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ !ÿÿÿÿÿÿÿÿ&ÿÿ(ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ012ÿÿ45678ÿÿÿÿÿÿÿÿ=>?@ÿÿBCEÿÿGHIÿÿKÿÿÿÿÿÿOÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿZÿÿÿÿ]ÿÿÿÿÿÿÿÿbcdeÿÿÿÿj
+ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ !ÿÿÿÿÿÿÿÿ&ÿÿ(ÿÿÿÿÿÿÿÿÿÿÿÿ012ÿÿ45678ÿÿÿÿÿÿÿÿ=>?@ÿÿBCÿÿEÿÿGHIÿÿKÿÿÿÿÿÿOÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿZÿÿÿÿ]ÿÿÿÿÿÿÿÿbcdeÿÿÿÿÿÿjÿÿÿÿ	ÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ0123ÿÿ5ÿÿ78ÿÿÿÿÿÿÿÿ=>?ÿÿÿÿBÿÿDEÿÿGÿÿÿÿÿÿKLÿÿÿÿÿÿQTUÿÿWXYZ ]ÿÿÿÿ`bÿÿdefiÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ(ÿÿÿÿÿÿ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ ÿÿÿÿ=ÿÿÿÿAÿÿÿÿÿÿEÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ(ÿÿWÿÿYZ./ÿÿÿÿÿÿÿÿÿÿÿÿÿÿdÿÿÿÿgÿÿÿÿ=ÿÿÿÿÿÿAÿÿÿÿÿÿEÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿWYZÿÿÿÿÿÿÿÿÿÿdÿÿÿÿgÿÿÿÿÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿ?ÿÿEÿÿÿÿÿÿÿÿJKÿÿÿÿ(ÿÿÿÿÿÿÿÿÿÿÿÿÿÿYZÿÿÿÿÿÿÿÿÿÿÿÿÿÿd>gÿÿÿÿDEÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ(ÿÿWÿÿYZ\ÿÿÿÿÿÿÿÿÿÿÿÿdeÿÿgÿÿÿÿ=ÿÿÿÿÿÿÿÿÿÿÿÿÿÿEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿYZÿÿÿÿÿÿÿÿÿÿÿÿdgÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ(ÿÿÿÿ=ÿÿÿÿÿÿÿÿÿÿÿÿEÿÿÿÿÿÿKÿÿÿÿ=ÿÿÿÿÿÿÿÿEÿÿÿÿYZÿÿKÿÿÿÿ(ÿÿÿÿÿÿÿÿdÿÿgÿÿYZÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=dÿÿgÿÿÿÿÿÿEÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ(ÿÿYZÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿdÿÿgÿÿÿÿÿÿ=ÿÿÿÿÿÿEÿÿÿÿÿÿÿÿKÿÿ(ÿÿÿÿÿÿÿÿÿÿÿÿÿÿYZÿÿÿÿÿÿ=dÿÿÿÿgÿÿÿÿE(ÿÿÿÿÿÿKÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿYZ=ÿÿÿÿÿÿ(EdÿÿÿÿgKÿÿÿÿÿÿÿÿ=ÿÿYZ(ÿÿE(ÿÿÿÿÿÿdKÿÿgÿÿÿÿÿÿÿÿÿÿÿÿÿÿYZÿÿÿÿÿÿE(ÿÿÿÿEdKÿÿgÿÿKÿÿÿÿÿÿÿÿÿÿYÿÿÿÿÿÿYÿÿÿÿ(ÿÿEdÿÿÿÿgdKgÿÿÿÿÿÿÿÿÿÿÿÿYÿÿ ÿÿE(ÿÿÿÿÿÿdKgÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿYÿÿÿÿ'(ÿÿÿÿÿÿÿÿÿÿEdÿÿÿÿgKÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿYÿÿÿÿEÿÿÿÿÿÿÿÿKdgÿÿÿÿÿÿWÿÿYZ(ÿÿÿÿÿÿÿÿÿÿ'(ÿÿdÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿÿÿÿÿ=EÿÿÿÿÿÿÿÿKEÿÿÿÿKÿÿÿÿÿÿYZÿÿ(ÿÿÿÿÿÿYZÿÿ(dÿÿÿÿÿÿÿÿÿÿÿÿdÿÿÿÿÿÿÿÿ=ÿÿÿÿÿÿÿÿÿÿ=EÿÿÿÿÿÿÿÿKEÿÿÿÿÿÿÿÿKÿÿÿÿYZÿÿYZÿÿ(dÿÿÿÿÿÿÿÿÿÿ(dÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ=ÿÿÿÿ(ÿÿÿÿÿÿ=EÿÿÿÿÿÿÿÿÿÿKEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿ=ÿÿÿÿÿÿYZÿÿEÿÿÿÿYZKdÿÿÿÿÿÿÿÿÿÿdÿÿÿÿÿÿÿÿYZÿÿÿÿÿÿÿÿdÿÿÿÿÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ7(9:;=ÿÿ>?ÿÿ(ÿÿÿÿEÿÿÿÿÿÿÿÿÿÿKÿÿÿÿ=ÿÿÿÿÿÿÿÿÿÿSÿÿE=ÿÿYZZKÿÿÿÿEÿÿÿÿÿÿÿÿdKefYZÿÿÿÿ
+ YZdÿÿÿÿÿÿÿÿÿÿÿÿÿÿdÿÿÿÿÿÿÿÿ !ÿÿ#ÿÿÿÿ&ÿÿÿÿ)*+,-ÿÿÿÿ012ÿÿ45678ÿÿÿÿ;ÿÿ=>?@ÿÿBCÿÿÿÿÿÿGHIÿÿÿÿÿÿMNOÿÿÿÿÿÿÿÿÿÿÿÿÿÿWÿÿÿÿÿÿÿÿ\]ÿÿÿÿÿÿbceÿÿ	jÿÿ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ0123ÿÿ5ÿÿ78ÿÿÿÿÿÿ>?ÿÿÿÿBÿÿDÿÿÿÿGÿÿÿÿÿÿLÿÿÿÿÿÿQTUÿÿWXÿÿZÿÿ#]ÿÿÿÿ`ÿÿbÿÿÿÿef./iÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ>ÿÿÿÿAÿÿÿÿDÿÿÿÿÿÿÿÿÿÿ
+ ÿÿÿÿÿÿÿÿSTÿÿÿÿÿÿXÿÿZÿÿ\ !ÿÿeÿÿg&ÿÿ(ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ012ÿÿ45678ÿÿÿÿÿÿÿÿ=>?@ÿÿBCÿÿEÿÿGHIÿÿKÿÿÿÿÿÿOÿÿÿÿÿÿÿÿÿÿÿÿÿÿY
+ ]ÿÿÿÿÿÿÿÿbcdeÿÿÿÿÿÿÿÿj !ÿÿÿÿÿÿÿÿ&ÿÿ(ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ012ÿÿ45678ÿÿÿÿÿÿÿÿ=>?@ÿÿBCÿÿEÿÿGHIÿÿKÿÿÿÿÿÿOÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ]ÿÿÿÿÿÿbcdeÿÿÿÿÿÿjÿÿÿÿÿÿÿÿÿÿ#ÿÿÿÿÿÿÿÿÿÿ)*+,-ÿÿÿÿ012ÿÿÿÿ5ÿÿ78ÿÿÿÿ;ÿÿÿÿ>?ÿÿÿÿBCÿÿÿÿÿÿGÿÿÿÿÿÿÿÿÿÿMNOÿÿÿÿÿÿ
+ WÿÿÿÿZÿÿ\]ÿÿÿÿÿÿÿÿbÿÿefÿÿ !ÿÿÿÿÿÿÿÿ&ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ012ÿÿ45678ÿÿÿÿÿÿÿÿ=>?@ÿÿBCÿÿÿÿÿÿGHIÿÿÿÿÿÿÿÿÿÿOÿÿÿÿÿÿÿÿÿÿÿÿ
+ ÿÿÿÿÿÿ]ÿÿÿÿÿÿÿÿbcÿÿeÿÿÿÿÿÿÿÿj !ÿÿÿÿÿÿÿÿ&ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ012ÿÿ45678ÿÿÿÿÿÿÿÿ=>?@ÿÿBCÿÿÿÿÿÿGHIÿÿÿÿÿÿÿÿÿÿOÿÿÿÿÿÿUÿÿ	
+ ÿÿÿÿÿÿ]ÿÿÿÿÿÿÿÿbcÿÿeÿÿÿÿÿÿÿÿj !ÿÿÿÿÿÿÿÿ&ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ012ÿÿ45678ÿÿÿÿÿÿÿÿ=>?@ÿÿBCÿÿÿÿÿÿGHIÿÿÿÿÿÿÿÿÿÿOÿÿÿÿÿÿÿÿÿÿÿÿ
+ ÿÿÿÿÿÿ]ÿÿÿÿÿÿÿÿbcÿÿeÿÿÿÿÿÿÿÿj !ÿÿÿÿÿÿÿÿ&ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ012ÿÿ45678ÿÿÿÿÿÿÿÿ=>?@ÿÿBCÿÿÿÿÿÿGHIÿÿÿÿÿÿÿÿÿÿOÿÿÿÿÿÿÿÿÿÿW
+ ÿÿÿÿÿÿ]ÿÿÿÿÿÿÿÿbcÿÿeÿÿÿÿÿÿÿÿj !ÿÿÿÿÿÿÿÿ&ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ012ÿÿ45678ÿÿÿÿÿÿÿÿ=>?@ÿÿBCÿÿÿÿÿÿGHIÿÿÿÿÿÿÿÿÿÿOÿÿÿÿÿÿÿÿÿÿW
+ ÿÿÿÿÿÿ]ÿÿÿÿÿÿÿÿbcÿÿeÿÿÿÿÿÿÿÿj !ÿÿÿÿÿÿÿÿ&ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ012ÿÿ45678ÿÿÿÿÿÿ=>?@BCÿÿÿÿÿÿGHIÿÿÿÿÿÿÿÿÿÿOÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ]ÿÿÿÿÿÿÿÿbcÿÿe0123j5ÿÿ78ÿÿÿÿÿÿÿÿÿÿ>?ÿÿBÿÿDÿÿG ÿÿÿÿLÿÿÿÿÿÿÿÿQÿÿÿÿÿÿÿÿÿÿZÿÿÿÿ]ÿÿÿÿ`ÿÿbÿÿÿÿefÿÿÿÿiÿÿ0123ÿÿ5ÿÿ78ÿÿÿÿÿÿÿÿÿÿ>?ÿÿBÿÿÿÿÿÿG ÿÿÿÿÿÿLÿÿÿÿÿÿÿÿQÿÿÿÿÿÿÿÿÿÿZÿÿÿÿ]ÿÿÿÿ`ÿÿbÿÿÿÿefÿÿÿÿÿÿÿÿ0123ÿÿ5ÿÿ78ÿÿÿÿÿÿÿÿÿÿ>?ÿÿBÿÿÿÿÿÿG ÿÿÿÿÿÿLÿÿÿÿÿÿÿÿQÿÿÿÿÿÿÿÿÿÿZÿÿÿÿ]ÿÿ`ÿÿbÿÿefÿÿÿÿÿÿÿÿ0123ÿÿ5ÿÿ78ÿÿÿÿÿÿ>?ÿÿBÿÿÿÿÿÿGÿÿÿÿÿÿÿÿL0123Q5ÿÿ78ÿÿÿÿZ>?]ÿÿB`DbÿÿGefÿÿÿÿL0123Q5ÿÿ78ÿÿÿÿÿÿÿÿZ>?]B`ÿÿbGefÿÿÿÿLÿÿÿÿÿÿÿÿQÿÿÿÿÿÿÿÿÿÿÿÿZÿÿÿÿ]ÿÿÿÿ`ÿÿbÿÿÿÿefÿÿÿÿÿÿÿÿ012ÿÿÿÿ5ÿÿ78ÿÿÿÿÿÿÿÿÿÿ>?ÿÿB	ÿÿÿÿGÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿUÿÿÿÿZÿÿÿÿ]ÿÿÿÿÿÿÿÿbÿÿÿÿefÿÿÿÿÿÿ012ÿÿÿÿ5ÿÿ78ÿÿÿÿÿÿÿÿÿÿ>?ÿÿBÿÿÿÿÿÿGÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿZÿÿÿÿ]ÿÿÿÿÿÿÿÿbÿÿÿÿefÿÿÿÿÿÿ012ÿÿÿÿ5ÿÿ78ÿÿÿÿÿÿÿÿÿÿ>?ÿÿBÿÿÿÿÿÿGÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿZÿÿÿÿ]ÿÿÿÿÿÿÿÿbÿÿÿÿefÿÿÿÿÿÿ012ÿÿÿÿ5ÿÿ78ÿÿÿÿÿÿÿÿÿÿ>?ÿÿBÿÿÿÿÿÿGÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿZÿÿÿÿ]ÿÿÿÿÿÿÿÿbÿÿÿÿefÿÿÿÿÿÿ012ÿÿÿÿ5ÿÿ78ÿÿÿÿÿÿ>?ÿÿÿÿBÿÿÿÿÿÿÿÿG79:;ÿÿÿÿ>?ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿZÿÿÿÿ]ÿÿÿÿÿÿÿÿbÿÿSefÿÿÿÿÿÿ7Z9:;ÿÿÿÿ>?ÿÿÿÿef
+ 7ÿÿ9:;Lÿÿ>?QÿÿSÿÿÿÿÿÿÿÿZÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿSÿÿefÿÿÿÿÿÿZ0123ÿÿ5678ÿÿefÿÿ>?
+ ÿÿÿÿÿÿÿÿÿÿGHÿÿÿÿÿÿLÿÿÿÿOÿÿQÿÿÿÿÿÿÿÿÿÿÿÿZÿÿÿÿ]ÿÿÿÿ`ÿÿbÿÿÿÿe0123ÿÿ5678ÿÿÿÿÿÿÿÿ>?
+ ÿÿÿÿÿÿÿÿÿÿGHÿÿÿÿÿÿLÿÿÿÿOÿÿQÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ]ÿÿÿÿ`ÿÿbÿÿÿÿe012ÿÿÿÿ5678ÿÿÿÿÿÿÿÿ>?
+ ÿÿÿÿÿÿÿÿÿÿGHÿÿÿÿÿÿÿÿÿÿÿÿOÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ]ÿÿÿÿÿÿÿÿbÿÿÿÿe012ÿÿÿÿ5678ÿÿÿÿÿÿÿÿÿÿ>?ÿÿÿÿÿÿÿÿÿÿGHÿÿÿÿÿÿOÿÿÿÿÿÿÿÿÿÿÿÿ]ÿÿÿÿbÿÿeÿÿ#ÿÿÿÿÿÿÿÿ#)*+,-)*+,-ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿÿÿÿÿÿÿ;ÿÿBCÿÿÿÿÿÿBCÿÿÿÿMNÿÿÿÿMNÿÿÿÿXÿÿÿÿ\ÿÿÿÿÿÿÿÿ\ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#ÿÿÿÿÿÿ)*+,-ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿÿÿÿÿÿÿÿÿBCÿÿÿÿÿÿÿÿÿÿ#ÿÿÿÿÿÿMN)*+,-Tÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\ÿÿÿÿ;ÿÿÿÿÿÿÿÿÿÿBCÿÿÿÿÿÿÿÿÿÿÿÿMNÿÿÿÿÿÿÿÿTÿÿÿÿÿÿÿÿ#ÿÿÿÿ\)*+,-ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿÿÿÿÿÿÿÿÿBCÿÿÿÿÿÿÿÿÿÿ#ÿÿÿÿÿÿMN)*+,-ÿÿÿÿÿÿÿÿÿÿ\ÿÿÿÿÿÿÿÿ;ÿÿÿÿÿÿÿÿÿÿBCÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿMNÿÿ#ÿÿÿÿÿÿTÿÿ)*+,-ÿÿ\ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿÿÿÿÿBCÿÿÿÿÿÿÿÿÿÿÿÿÿÿMNOÿÿÿÿÿÿÿÿÿÿÿÿÿÿ#ÿÿÿÿ\ÿÿ#)*+,-)*+,-ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿÿÿÿÿÿÿ;ÿÿBCÿÿÿÿBCÿÿÿÿÿÿÿÿMNÿÿÿÿÿÿÿÿNÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ\ÿÿÿÿÿÿ7\9:;ÿÿÿÿ>?ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿLÿÿÿÿÿÿPQÿÿSÿÿÿÿÿÿÿÿÿÿÿÿZÿÿÿÿÿÿÿÿÿÿÿÿÿÿbÿÿÿÿef
+ ‘AMPERAMPERAMPERSANDANDASASSERTBACKQUOTEBARBARBARBARRBRACKETBEGINCLASSCOLONCOLONCOLONCOLONEQUALCOLONGREATERCOMMACONSTRAINTDODONEDOTDOTDOTDOWNTOELSEENDEOFEQUALEXCEPTIONEXTERNALFALSEFORFUNFUNCTIONFUNCTORGREATERGREATERRBRACEGREATERRBRACKETIFININCLUDEINHERITINITIALIZERLAZYLBRACELBRACELESSLBRACKETLBRACKETBARLBRACKETLESSLBRACKETGREATERLESSLESSMINUSLETLPARENMATCHMETHODMINUSMINUSDOTMINUSGREATERMODULEMUTABLENEWOBJECTOFOPENORPLUSPRIVATEQUESTIONQUESTIONQUESTIONQUOTERBRACERBRACKETRECRPARENSEMISEMISEMISHARPSIGSTARSTRUCTTHENTILDETOTRUETRYTYPEUNDERSCOREVALVIRTUALWHENWHILEWITH	CHARFLOATINFIXOP0INFIXOP1INFIXOP2INFIXOP3INFIXOP4INTINT32INT64LABELLIDENTNATIVEINTOPTLABELPREFIXOPSTRINGUIDENT@“#int“%int32“%int64“)nativeint�6the start of a comment�8not the end of a comment’"!=°1parsing/lexer.mll—P°1parsing/lexer.mll¢R°1parsing/lexer.mll¸P•	"Illegal backslash escape in string6Comment not terminated=String literal not terminated	4This comment contains an unterminated string literal6Illegal character (%s)	4Illegal backslash escape in string or character (%s)	2`%s' is a keyword, it cannot be used as label name	FInteger literal exceeds the range of representable integers of type %s+Lexer.Error  #andB  "asC  &assertD  %beginI  %classJ  *constraintP  "doQ  $doneR  &downtoU  $elseV  #endW  )exceptionZ  (external[  %false\  #for]  #fun^  (function_  'functor`  "ifd  "ine  'includef  'inheritg  +initializerh  $lazyi  #letr  %matcht  &methodu  &moduley  'mutablez  #new{  &object|  "of}  $open~  "or  'privateA  #recG  #sigL  &structN  $thenO  "toQ  $trueR  #tryS  $typeT  #valV  'virtualW  $whenX  %whileY  $withZ  #mod•#mod  $land•$land  #lor•#lor  $lxor•$lxor  #lsl–#lsl  #lsr–#lsr  #asr–#asr@,
+ .¶ÿ·ÿà&IlÄÿ�´ ÌÿCÙüEHUÝÿßÿâÿB{e]/ðÿx™â²‘í½ÿÿœºûÿŠiøÿñÿòÿóÿ_-]p7ýg­…ibírïÿîÿêÿaNsíÿuìÿvëÿuèÿ�çÿ,æÿ	-æÿ¾å	.	ÚÿÖÿ×ÿØÿÔÿQ	ÍÿÎÿÏÿÊÿÇÿt	ÃÿÅÿ—	º	gôÿõÿöÿ>ýÿþÿÌ	ƒÿ°üÿúÿ‘Ûùÿ¢ÜÕå÷ÿM	
+ 7
+ í^
+ íðö.ø
+ .ÿÿÿÿÿÿGDC>Aÿÿ964ÿÿ/.,*&$?ÿÿÿÿÿÿ!ÿÿ
+ 
+ 	ÿÿBÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
+ 
+ 
+ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿFÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿE@#ÿÿÿÿÿÿÿÿÿÿ-ÿÿÿÿÿÿÿÿÿÿ7ÿÿÿÿA=ÿÿÿÿ
+ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
+ .ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ;ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ@ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿSÿÿÿÿSTSVÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿnÿÿxÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ…ÿÿ|ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ‘”ÿÿ”ÿÿÿÿ
+ ¾$&&$%RXpRX€QW&’$	!f#                          
+ "dac`]P_^K$?9$9778888888888>DPGJL$66666666v&|OOOOOOOOOO8888888888e)                        =        €,ÿÿÿÿz…�‘ÿÿR>ŒQ•ŒŒ–“)VŒŒUR“=Q<UTÿÿZZZZZZZZZZZZZZZ:kkkkkkkkkkZklkkkZZkkkjÿÿigÿÿbÿÿÿÿÿÿhZZZZzZZyZ[ZZZZ\ZZ{YZNM77wZZ1.0.71/-200/.-3420/-34ÿÿ11111111115555555555p0o555555EEEEEEEEEEs1rut0555555                                                                5555555555555555.FFFFFFFFFF€‡5555555q/-&                                                      ˆ        '''''''''����������''''+'‚‚‚‚‚‚‚‚‚‚8888888888'***************************8''''''''P'''����������''''''P{{{{{{{{{{OOOOOOOOOO'(,((((((((((((((((((((((((((''********************************HHHHHHHHHHHHHHHHHHHHHH(((((((((((((((((((((((( ((((((((                                                               66666666IIIIIIIIII.IIIIII6/-IIIIII                                                              '''''''''''''''((((((((((()'(((((((((((((((((((((((((('('((((((((((((((((((((((((((URQƒƒƒƒƒƒƒƒƒƒUTƒƒƒƒƒƒOOOOOOOOOOƒƒƒƒƒƒ((((((((((((((((((((((((((((((((((((((((((((((((((((((*((((((((**********,*****************************************************„„„„„„„„„„„„„„„„ÿÿ„„„„„„**************************************************************'C'''C'''''BBBBBBBBBB''''''MMMMMMMMMC'MCMMMMMCCCA''MZZZZMMZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZZÿÿZZZZZZZZZZkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk~~~~~~~~~~kkkŒ‹ksks}ŠŠŠŠŠŠŠŠŠŠŽŽŽŽŽŽŽŽŽŽssŽŽŽŽŽŽsss‰))))))))))ŽŽŽŽŽŽ))))))))))))ÿÿ
+ ¾ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ%QWoSV‡SV–ÿÿÿÿÿÿÿÿÿÿ‘ÿÿÿÿÿÿ$;0$0220000000000=CFIK$33333333tux9999999999z<‚SVy„��‘T<ŒT“‹‹•ÿÿÿÿÿÿ’yÿÿTŒ‹ÿÿÿÿÿÿUU”UÿÿÿÿÿÿÿÿÿÿÿÿUÿÿUÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ	ÿÿÿÿ			ÿÿÿÿÿÿ		ÿÿ			ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ						ÿÿÿÿÿÿÿÿÿÿ
+ ÿÿÿÿ
+ 
+ 
+ ÿÿÿÿÿÿ
+ 
+ ÿÿ
+ 
+ 
+ ÿÿÿÿÿÿÿÿÿÿÿÿ		
+ ÿÿ
+ 
+ 
+ 
+ 
+ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTÿÿ			ÿÿÿÿÿÿ
+ 
+ ÿÿÿÿ’ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿU”
+ ÿÿ
+ ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿrrÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿrÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ77ÿÿrÿÿÿÿÿÿÿÿ7ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ7ÿÿ7ÿÿ7ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿrÿÿÿÿÿÿ11111111114444444444m1ÿÿmÿÿÿÿÿÿ444444BBBBBBBBBBÿÿmÿÿÿÿ1ÿÿmmÿÿm1ÿÿÿÿÿÿÿÿÿÿ444444ÿÿÿÿÿÿÿÿÿÿ           ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ                          ÿÿÿÿÿÿÿÿ ÿÿ                          5555555555ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ555555ÿÿÿÿÿÿÿÿÿÿ5EEEEEEEEEEÿÿÿÿÿÿ†ÿÿÿÿ†ÿÿ5ÿÿ555555ÿÿÿÿÿÿmÿÿ5ÿÿ5ÿÿÿÿÿÿ†ÿÿÿÿ                       ÿÿ                               †        !ÿÿÿÿ!!!ÿÿÿÿÿÿ!!ÿÿ!!!~~~~~~~~~~!ÿÿ!!!!!����������ÿÿ8888888888ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ!!ÿÿ!!!!!!!!!!!!!!!!!!!!!!!!!!8!"!ÿÿ"""ÿÿÿÿÿÿ""P"""ŠŠŠŠŠŠŠŠŠŠ"ÿÿ"""""ÿÿÿÿP����������ÿÿÿÿÿÿÿÿÿÿPPPPPPPPPPÿÿ""†""""""""""""""""""""""""""ÿÿ"ÿÿ"ÿÿÿÿÿÿÿÿ!!!!!!!!!!!!!!!!!!!!!!!!ÿÿ!!!!!!!!AAAAAAAAAAÿÿÿÿÿÿÿÿÿÿÿÿÿÿAAAAAAÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿAAAAAAÿÿÿÿÿÿÿÿ""""""""""""""""""""""""#""""""""##########ÿÿÿÿÿÿÿÿÿÿÿÿÿÿ##########################ÿÿÿÿÿÿÿÿ#ÿÿ##########################66666666ÿÿÿÿÿÿÿÿÿÿÿÿHHHHHHHHHHÿÿÿÿÿÿÿÿ6ÿÿÿÿHHHHHHÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ6ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ6ÿÿ6HHHHHH#######################ÿÿ###############################ÿÿ########'ÿÿÿÿ'''ÿÿÿÿÿÿ''ÿÿ'''ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ'ÿÿ'''''ÿÿÿÿÿÿÿÿ(ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ(((((((((((ÿÿÿÿÿÿÿÿÿÿ'((((((((((((((((((((((((((ÿÿÿÿÿÿ'('((((((((((((((((((((((((((OOÿÿÿÿOÿÿÿÿÿÿÿÿ}}}}}}}}}}ÿÿÿÿÿÿÿÿOÿÿO}}}}}}ÿÿÿÿÿÿÿÿÿÿÿÿÿÿOOOOOOOOOOÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ}}}}}}ÿÿÿÿÿÿÿÿÿÿ(((((((((((((((((((((((ÿÿ(((((((((((((((((((((((((((((((*((((((((***********ÿÿÿÿÿÿÿÿÿÿÿÿ**************************ÿÿÿÿÿÿÿÿ*ÿÿ**************************ƒƒƒƒƒƒƒƒƒƒÿÿÿÿÿÿÿÿÿÿÿÿÿÿƒƒƒƒƒƒÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿOÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿƒƒƒƒƒƒÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ***********************ÿÿ*******************************ÿÿ********+:ÿÿ+++:ÿÿÿÿ++ÿÿ+++::::::::::+ÿÿ+++++ÿÿÿÿÿÿÿÿÿÿÿÿÿÿMÿÿÿÿMMMÿÿÿÿÿÿMMÿÿMMMÿÿÿÿÿÿÿÿÿÿ:ÿÿ+ÿÿÿÿM:MMMMMÿÿÿÿÿÿÿÿÿÿÿÿ:ÿÿÿÿÿÿ:ÿÿ:ÿÿYÿÿ:YYY+ÿÿ+YYÿÿYYYMÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿYÿÿYYYYYÿÿÿÿÿÿÿÿÿÿÿÿÿÿZÿÿÿÿZZZMÿÿMZZÿÿZZZÿÿÿÿÿÿÿÿÿÿÿÿÿÿYÿÿÿÿZÿÿZZZZZÿÿÿÿÿÿ[ÿÿÿÿ[[[ÿÿÿÿÿÿ[[ÿÿ[[[ÿÿÿÿYÿÿYÿÿÿÿÿÿÿÿÿÿ[Z[[[[[ÿÿÿÿÿÿÿÿÿÿÿÿ\ÿÿÿÿ\\\ÿÿÿÿÿÿ\\ÿÿ\\\ÿÿÿÿÿÿZÿÿZÿÿÿÿ[ÿÿ\:\\\\\ÿÿÿÿÿÿbÿÿÿÿbbbÿÿÿÿÿÿbbÿÿbbbÿÿÿÿÿÿ[ÿÿ[ÿÿÿÿÿÿÿÿb\bbbbbÿÿÿÿÿÿhÿÿÿÿhhhÿÿÿÿÿÿhhÿÿhhhÿÿÿÿÿÿÿÿÿÿÿÿ\ÿÿ\ÿÿhbhhhhhÿÿÿÿÿÿkÿÿÿÿkkkÿÿÿÿÿÿkkÿÿkkkÿÿÿÿÿÿÿÿÿÿÿÿbÿÿbÿÿkhkkkkkÿÿÿÿÿÿlÿÿÿÿlllÿÿÿÿÿÿllÿÿlllÿÿÿÿÿÿÿÿwÿÿhÿÿhwlklllllÿÿwwwwwwwwwwÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿkÿÿkÿÿÿÿlÿÿÿÿÿÿÿÿÿÿÿÿˆÿÿÿÿˆÿÿÿÿÿÿÿÿÿÿwÿÿÿÿÿÿÿÿÿÿwÿÿÿÿÿÿÿÿÿÿÿÿÿÿlˆlÿÿwÿÿˆÿÿwÿÿwÿÿÿÿÿÿwˆˆˆˆˆˆˆˆˆˆÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ‰‰‰‰‰‰‰‰‰‰ˆÿÿÿÿÿÿÿÿÿÿˆ‰‰‰‰‰‰ÿÿÿÿÿÿÿÿÿÿˆÿÿÿÿÿÿˆÿÿˆÿÿÿÿÿÿˆŽŽŽŽŽŽŽŽŽŽ‰‰‰‰‰‰ÿÿŽŽŽŽŽŽÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿŽŽŽŽŽŽÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿˆÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ
+ .
+ $
+ .''
+ .
+ J$$$
+ JÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTˆ‹TˆÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTUÿÿÿÿÿÿÿÿÿÿÿÿÿÿOPÿÿÿÿOOOOOOOOOOPÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿPPPPPPPPPPÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿTÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ	*ÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿÿ@   @@*@[%a%a@]@.(@[%a@]@.4@[I/O error:@ %s@]@.#.ml#.ml$.mli$.cmi @@$.cmo$.cmx$.mli$.mli @@$.cmi	1Ocaml and preprocessor have incompatible versions &camlpp*%s %s > %s4Preprocessing error
+ ! ! !
+ $.mli$.mli#.ml$.cmx$.cmi$.cmi#.ml#.ml$.cmx$.cmo$.cmx!/7@[Bad -I option: %s@]@. ": &\
+     9Ocamldep.Outdated_version	,Usage: ocamldep [-I <dir>] [-native] <files>	6<command>  Pipe sources through preprocessor <command>#-pp	H  (for Windows) Use forward slash / instead of backslash \ in file paths&-slash	F  Generate dependencies for a pure native-code project (no .cmo files)'-native	3<dir>  Add <dir> to the list of include directories"-I@@„•¦¾/Ž…P ‰ÐÐÐÐÐ@°@#ArgAÎ@A°@%ArrayAjÐ@°@&BufferA„@AB°@$CharAÐÐÐ@°@'ClflagsA0@A°@&ConfigA,Ð@°@&DependAX@AB°@&DigestAÑÐ@°@(FilenameA@ACD°@&FormatA¢ÐÐÐ@°@'HashtblAL@A°@%Int32AW@B°@%Int64AbÐÐ@°@%LexerAS@A°@&LexingArÐ@°@'LinenumA5@ABCE°@$ListAyÐÐÐÐÐÐ@°@(LocationAc@A°@)LongidentAfÐ@°@$MiscA@AB°@)NativeintAmÐÐ@°@(OcamldepA‡@A°@%ParseAW@BC°@&ParserA=ÐÐ@°@'ParsingAv@A°@*PervasivesAdÐ@°@&PrintfA‹Ð@°@&RandomAÜ@ABCD°@#SetA~ÐÐÐ@°@(Std_exitAˆ@A°@&StringAHÐ@°@)SyntaxerrAm@AB°@#SysAKÐÐ@°@(TerminfoA1@A°@(WarningsALÐ@°P-Match_failureCG@ABCE°Q-Out_of_memoryC@ÐÐÐ@°R0Invalid_argumentCC@A°S'FailureCBÐÐ@°T)Not_foundCF@A°U)Sys_errorCA@BC°V+End_of_fileCDÐÐ@°W0Division_by_zeroCE@A°X.Stack_overflowCHÐÐ@°Y.Sys_blocked_ioCI@A°Z.Assert_failureCJÐ@°[:Undefined_recursive_moduleCK@ABCDFG„•¦¾è˜BÔ  %Lexer0q€ÔPúƒ±µÝ{}Q1ó  $List0Z2ü5kÑ�`¿óaßÓ  %Array0©·˜Ý–eÂÓcV6Ò“@<  &Depend0^OTžv4ûÞºÏåja,]"  &Random0¬Yúh»ßÒZ¿‘Ûæ–Ÿ  &Printf0¾‚ÏÀx~˜7�>‰ÑŠì  (Ocamldep0|+l	âÄÝ©WÎQÿþ’  (Std_exit0Ì¬˜QË;ï«ÆM÷2µ7  'Linenum0>6'pf%å#›bôÊY•½  'Clflags0ŒÙŽ’¨W¼ƒp/?ñË¦?´  &Lexing0AS\6j�ÞS�¡ õà¹(  %Parse0¨´N¼Ö·º»B‹Sµrô  &String0þÈ)+± -,{‹K§¸:}‹  &Buffer0EôfÎFòÚäç}ØP__  )Syntaxerr0¢__MPÀýšSNKWÂ1w¢  )Nativeint0£À&p­Ò¥XKä¢QôP  &Digest0ÿwì\"¥	£kx¤J§xâ  &Config0ŸVŒf>­‘´ÞU�Žqw  $Char0  Õ…F€¶”š/°ÊNa  )Parsetree0uéu¾ø¾€ãéË´AW  'Parsing0p6à »õ+±ñÔè¦R: æ  (Asttypes0ô-Ë¶Ò¤Ÿ(ûmx`sð  %Int640M.ßpiÖ€wyS¼ÌìU  (Filename0 ñõØä}‰r#ögÛ@/³  (Warnings00Ûk�(¡ÌY5ŠÛ•  $Misc0Û¬˜ÿcÜW6«†i‘Z  (Terminfo0•ÝKIthÄ/§Ûädw|  'Hashtbl0!òáÜf{çèTõsÁ‚·  &Format0gø¥',ð÷oj$ðt  #Obj0t~øÀ'•–èãêÓØ‘í  #Sys0ŒÎw
+ B·ÐäØUiÁ]xAÖ  %Int320+îoCäß…m·U£raC  #Set0¡¦ÄÑÅžAPÃŒE6  #Arg0|ÇÓLàžÎ5”Äð  *Pervasives0qøˆE;&‰XF
+ rðt“  )Longident0+¥³`Cfi“eûØÉer  (Location0*”bž Ãåg–xìœ+1à  &Parser0NVÛ×Úû¯¢ü<£
+ õ@CODEÎˆDLPTDLLSPRIMtDATA7¶SYMBCCRCSüCaml1999X008
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/toplevel/toploop.ml seminalOcaml/toplevel/toploop.ml
*** ocaml-3.08.4/toplevel/toploop.ml	2004-06-12 01:55:47.000000000 -0700
--- seminalOcaml/toplevel/toploop.ml	2009-01-19 09:42:03.659835970 -0800
***************
*** 297,302 ****
--- 297,303 ----
            List.iter
              (fun ph ->
                if !Clflags.dump_parsetree then Printast.top_phrase ppf ph;
+               if !Clflags.dump_printcode then Printcode.top_phrase ppf ph;
                if not (execute_phrase !use_print_results ppf ph) then raise Exit)
              (!parse_use_file lb);
            true
***************
*** 404,409 ****
--- 405,411 ----
        first_line := true;
        let phr = try !parse_toplevel_phrase lb with Exit -> raise PPerror in
        if !Clflags.dump_parsetree then Printast.top_phrase ppf phr;
+       if !Clflags.dump_printcode then Printcode.top_phrase ppf phr;
        ignore(execute_phrase true ppf phr)
      with
      | End_of_file -> exit 0
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/toplevel/topmain.ml seminalOcaml/toplevel/topmain.ml
*** ocaml-3.08.4/toplevel/topmain.ml	2003-07-25 05:18:25.000000000 -0700
--- seminalOcaml/toplevel/topmain.ml	2009-01-19 09:42:03.727834560 -0800
***************
*** 81,86 ****
--- 81,87 ----
           \032    default setting is a (all warnings are non-fatal)";
  
       "-dparsetree", Arg.Set dump_parsetree, " (undocumented)";
+      "-dprintcode", Arg.Set dump_printcode, " (undocumented)";
       "-drawlambda", Arg.Set dump_rawlambda, " (undocumented)";
       "-dlambda", Arg.Set dump_lambda, " (undocumented)";
       "-dinstr", Arg.Set dump_instr, " (undocumented)";
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/utils/ccomp.ml seminalOcaml/utils/ccomp.ml
*** ocaml-3.08.4/utils/ccomp.ml	2005-02-02 07:39:40.000000000 -0800
--- seminalOcaml/utils/ccomp.ml	2009-01-19 09:42:16.127093555 -0800
***************
*** 76,82 ****
    let quoted_archive = Filename.quote archive in
    match Config.ccomp_type with
      "msvc" ->
!       command(Printf.sprintf "link /lib /nologo /debugtype:cv /out:%s %s"
                               quoted_archive (quote_files file_list))
    | _ ->
        let r1 =
--- 76,82 ----
    let quoted_archive = Filename.quote archive in
    match Config.ccomp_type with
      "msvc" ->
!       command(Printf.sprintf "link /lib /nologo /debug /out:%s %s"
                               quoted_archive (quote_files file_list))
    | _ ->
        let r1 =
diff -Nacr --exclude='*cvsignore*' --exclude='*CVS*' --exclude='*TESTS*' ocaml-3.08.4/utils/clflags.ml seminalOcaml/utils/clflags.ml
*** ocaml-3.08.4/utils/clflags.ml	2003-07-17 01:38:28.000000000 -0700
--- seminalOcaml/utils/clflags.ml	2009-01-19 09:42:16.147101112 -0800
***************
*** 50,55 ****
--- 50,58 ----
  and dllpaths = ref ([] : string list)   (* -dllpath *)
  and make_package = ref false            (* -pack *)
  let dump_parsetree = ref false          (* -dparsetree *)
+ let dump_printcode = ref false          (* -dprintcode *)
+ and use_seminal = ref false             (* -seminal *)
+ and no_triage = ref false               (* -no-triage *)
  and dump_rawlambda = ref false          (* -drawlambda *)
  and dump_lambda = ref false             (* -dlambda *)
  and dump_instr = ref false              (* -dinstr *)
