install new script latexdiff

git-svn-id: svn://tug.org/texlive/trunk@16379 c570f23f-e606-0410-a88d-b1316a301751

5 files changed, 4199 insertions, 0 deletions

diff --git a/Build/source/texk/texlive/linked_scripts/Makefile.am b/Build/source/texk/texlive/linked_scripts/Makefile.am
index 913f41c6032..a64a07b55a3 100644
--- a/Build/source/texk/texlive/linked_scripts/Makefile.am
+++ b/Build/source/texk/texlive/linked_scripts/Makefile.am
@@ -66,6 +66,9 @@ nobase_dist_script_SCRIPTS = \
 	fragmaster/fragmaster.pl \
 	glossaries/makeglossaries \
 	latex2man/latex2man \
+	latexdiff/latexdiff.pl \
+	latexdiff/latexdiff-vc \
+	latexdiff/latexrevise \
 	latexmk/latexmk.pl \
 	listings-ext/listings-ext.sh \
 	mkjobtexmf/mkjobtexmf.pl \
diff --git a/Build/source/texk/texlive/linked_scripts/Makefile.in b/Build/source/texk/texlive/linked_scripts/Makefile.in
index 94c58fad1e7..4db676fc95f 100644
--- a/Build/source/texk/texlive/linked_scripts/Makefile.in
+++ b/Build/source/texk/texlive/linked_scripts/Makefile.in
@@ -215,6 +215,9 @@ nobase_dist_script_SCRIPTS = \
 	fragmaster/fragmaster.pl \
 	glossaries/makeglossaries \
 	latex2man/latex2man \
+	latexdiff/latexdiff.pl \
+	latexdiff/latexdiff-vc \
+	latexdiff/latexrevise \
 	latexmk/latexmk.pl \
 	listings-ext/listings-ext.sh \
 	mkjobtexmf/mkjobtexmf.pl \
diff --git a/Build/source/texk/texlive/linked_scripts/latexdiff/latexdiff-vc b/Build/source/texk/texlive/linked_scripts/latexdiff/latexdiff-vc
new file mode 100755
index 00000000000..3e9a3f246de
--- /dev/null
+++ b/Build/source/texk/texlive/linked_scripts/latexdiff/latexdiff-vc
@@ -0,0 +1,430 @@
+#!/usr/bin/perl -w
+# Place the following 2 lines at beginning to make script independent of location of perl
+#eval 'exec perl -w -S $0 ${1+"$@"}'
+#    if 0; # not running under some shell
+#
+# latexdiff-vc  - wrapper script for applying latexdiff to rcs managed files
+#                 and for automatised creation of postscript or pdf from difference file
+#
+#   Copyright (C) 2005  F J Tilmann (tilmann@esc.cam.ac.uk)
+#
+#   Contributors: S Utcke, H Bruyninckx
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License Version 2 as published by
+#    the Free Software Foundation.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# Detailed usage information at the end of the file
+#
+# version 0.25:
+#   - bbl is allowed as alternative extension (instead of .tex)
+#   
+use Getopt::Long ;
+use Pod::Usage qw/pod2usage/ ;
+use File::Temp qw/tempdir/ ;
+use File::Basename qw/dirname/;
+use strict ;
+
+# Option names
+my ($version,$help,$postscript,$pdf,$force,$dir,$cvs,$rcs,$svn,$diffcmd,$patchcmd,@revs);
+# Preset Variables
+my $latexdiff="latexdiff"; # Program for making the comparison
+my $vc="";
+my $tempdir=tempdir(CLEANUP => 1);
+# Variables
+my ($file1,$file2,$diff,$diffbase,$answer,$options,$infile,$append,$dirname,$cwd);
+my (@files,@ldoptions,@tmpfiles,@ptmpfiles,@difffiles); # ,
+
+
+Getopt::Long::Configure('pass_through','bundling');
+
+GetOptions('revision|r:s' => \@revs,
+           'cvs' => \$cvs,
+           'rcs' => \$rcs,
+           'svn' => \$svn,
+           'dir|d:s' => \$dir,
+           'postscript|ps' => \$postscript,
+           'pdf' => \$pdf,
+           'force' => \$force,
+           'version' => \$version,
+	   'help|h' => \$help);
+
+if ( $help ) {
+  pod2usage(1) ;
+}
+
+if ( $version ) {
+  die "This is LATEXDIFF-VC 0.25\n" ;
+}
+
+if ( $cvs ) {
+  $vc="CVS";
+}
+if ( $rcs ) {
+  die "Cannot specify more than one of --cvs, --rcs or --svn." if ($vc);
+  $vc="RCS";
+}
+if ( $svn ) {
+  die "Cannot specify more than one of --cvs, --rcs or --svn." if ($vc);
+  $vc="SVN";
+}
+
+# check whether the first file name got misinterpreted as an option to an empty -r option
+if ( @revs && -f $revs[$#revs] ) {
+  unshift @ARGV,$revs[$#revs];
+  $revs[$#revs]="";
+}
+# check whether the first file name got misinterpreted as an option to an empty -d option
+if ( defined($dir) && -f $dir ) {
+  unshift @ARGV,$dir;
+  $dir="";
+}
+
+$file2=pop @ARGV;
+( defined($file2) && $file2 =~ /\.(tex|bbl)$/ ) or pod2usage("Must specify at least one tex or bbl file");
+
+if (! $vc && scalar(@revs)>0 ) {
+  # have to guess $vc
+  # check whether we have a special name
+  if ( $0 =~ /-cvs$/ ) {
+    $vc="CVS";
+  } elsif ( $0 =~ /-rcs$/ ) {
+    $vc="RCS";
+  } elsif ( $0 =~ /-svn$/ ) {
+    $vc="SVN";
+  } elsif ( -e "CVSROOT" || defined($ENV{"CVSROOT"}) ) {
+    print STDERR "Guess you are using CVS ...\n";
+    $vc="CVS";
+  } elsif ( -e "$file2,v" ) {
+    print STDERR "Guess you are using RCS ...\n";
+    $vc="RCS";
+  } elsif ( -d ".svn" ) {
+    print STDERR "Guess you are using SVN ...\n";
+    $vc="SVN";
+  } else {
+    print STDERR "Cannot figure out version control system, so I default to CVS\n";
+    $vc="CVS";
+  }
+}
+
+if (defined($dir) && $dir=~/^\.\/?/ ) {
+  print STDERR "You wrote selected -dir=.  but you do not really like to do that, do you ?\n";
+  exit 10
+}
+
+if ( scalar(@revs)>0 ) {
+  if ( $vc eq "CVS" ) { 
+    $diffcmd  = "cvs diff -u -r"; 
+    $patchcmd = "patch -R -p0";
+  } elsif ( $vc eq "RCS" ) {
+    $diffcmd  = "rcsdiff -u -r";  
+    $patchcmd = "patch -R -p0";
+  } elsif ( $vc eq "SVN" ) {
+    $diffcmd  = "svn diff -r ";  
+    $patchcmd = "patch -R -p0";
+  } else {
+    print STDERR "Unknown versioning system $vc \n";
+    exit 10;
+  }
+}
+
+
+# make file list (last arguments), initial arguments have to be passed to latexdiff
+# We assume an argument is a valid file rather than a latexdiff argument
+# if it has extension .tex or .bbl
+
+@files=($file2);
+while( $file1=pop @ARGV ) {
+  if ( $file1 =~ /\.(tex|bbl)$/ ) {
+    # $file1 looks like a valid file name and is prepended to file list
+    unshift @files, $file1 ;
+  } else {
+    # $file1 looks like an option for latexdiff, push it back to argument stack
+    unshift @ldoptions, $file1 ;
+  }
+}
+
+if ( scalar(@revs) == 0 ) {
+  pod2usage("When -r option is not used, two .tex files (old and new) must be given on the command line") unless @files==2;
+    #  compare two files
+  $file1=shift @files ;
+}
+
+if ( scalar(@revs) == 2 ) {
+  $append = "-diff$revs[0]-$revs[1]";
+} elsif ( scalar(@revs) == 1 || $revs[0] ) {
+  $append = "-diff$revs[0]";
+} else {
+  $append = "-diff";
+}
+
+if ( defined ($dir) && ! $dir ) {
+  # bare -d option => choose directory name
+  ($dir=$append) =~ s/^-//;
+}
+
+if ( ($vc eq "SVN" || $vc eq "CVS") && scalar(@revs)) {
+  length($revs[$#revs]) > 0 or $revs[$#revs]="HEAD";
+  length($revs[0]) > 0 or $revs[0]="HEAD";
+}
+
+#exit ; 
+
+
+# cycle through all files
+
+@difffiles=();
+while ( $infile=$file2=shift @files ) {
+  print STDERR "Working on  $infile \n";
+  if ( scalar(@revs) == 1 ) {
+    ($file1=$infile) =~ s/\.(tex|bbl)/-oldtmp-$$.$1/ ;
+    push @tmpfiles,$file1;
+    # compare file with previous version ($revs[0]="") or specified version
+    system("$diffcmd$revs[0] $infile| $patchcmd -o$file1") ;
+  } elsif ( scalar(@revs) == 2 ) {
+    ($file1=$infile) =~ s/\.(tex|bbl)/-oldtmp-$$.$1/ ;
+    $file2 =~ s/\.(tex|bbl)/-newtmp-$$.$1/ ;
+    push @tmpfiles,$file2;
+    system("$diffcmd$revs[1] $infile | $patchcmd -o$file2")  ;
+    system("$diffcmd$revs[0] $infile | $patchcmd -o$file1")  ;
+  }
+
+  if ( -z $file1 || -z $file2) {
+    print STDERR "One or both of the files to compare are empty. Possibly something went wrong in the retrieval of older versions. Aborting ...\n" ;
+    exit(10);
+  }
+
+  # Get name of difference file
+  if ( defined($dir) ) {
+    $diff="$dir/$infile" ; 
+  } else {
+    ($diff=$infile) =~ s/\.(tex|bbl)$/$append.$1/ ;
+  }
+  # make directories if needed
+  $dirname=dirname($diff) ;
+  system("mkdir -p $dirname") unless ( -e $dirname );
+
+  # Remaining options are passed to latexdiff
+  $options = join(" ",@ldoptions);
+
+  if ( -e $diff && ! $force ) {
+    print STDERR "OK to overwrite existing file $diff (y/n)? ";
+    $answer = <STDIN> ;
+    unless ($answer =~ /^y/i ) {
+      unlink @tmpfiles;
+      die "Abort ... " ;
+    }
+  }
+  print "Running $latexdiff\n";
+  unless ( system("$latexdiff $options $file1 $file2 > $diff") == 0 ) { 
+    print STDERR  "Something went wrong in $latexdiff. Deleting $diff and abort\n" ; unlink $diff ; exit(5) 
+  };
+  print "Generated difference file $diff\n";
+
+  if ( ( $postscript or $pdf ) and !( scalar(@revs) && greptex( qr/\\document(?:class|style)/ , $diff ) ) ) {
+    # save filename for later processing if postscript or pdf conversion is requested and either two-file mode was used (scalar(@revs)==0) or the diff file contains documentclass statement (ie. is a root document)
+    push @difffiles, $diff ;
+  }
+  
+  unlink @tmpfiles;
+}
+
+foreach $diff ( @difffiles ) {
+  chomp($cwd=(`pwd`));
+  if  (defined($dir)) {
+    ( $diff =~ s/$dir\/?// ) ;
+    chdir $dir ; 
+  }
+  @ptmpfiles=();
+  ( $diffbase=$diff) =~ s/\.(tex)$// ;
+
+  # adapt magically changebar styles to [pdftex] display driver if pdf output was selected
+  if ( $pdf ) {
+    system("sed \"s/Package\\[dvips\\]/Package[pdftex]/\" $diff > $diff.tmp$$ ; \\mv $diff.tmp$$ $diff");
+  }
+  print STDERR "PDF: $pdf Postscript: $postscript cwd $cwd\n";
+
+  if ( system("grep -q \'^[^%]*\\\\bibliography\' $diff") == 0 ) { 
+    if ( $postscript) {
+      system("latex --interaction=batchmode $diff; bibtex $diffbase");
+      push @ptmpfiles, "$diffbase.bbl","$diffbase.bbl" ; 
+    } elsif ( $pdf ) {
+      system("pdflatex --interaction=batchmode $diff; bibtex $diffbase");
+      push @ptmpfiles, "$diffbase.bbl","$diffbase.bbl" ; 
+    }
+  }
+
+  if ( $postscript ) {
+    my $dvi="$diffbase.dvi";
+    my $ps="$diffbase.ps";
+
+    system("latex --interaction=batchmode $diff; latex $diff; dvips -o $ps $dvi");
+    push @ptmpfiles, "$diffbase.aux","$diffbase.log",$dvi ;
+    print "Generated postscript file $ps\n";
+  } 
+  elsif ( $pdf ) {
+    system("pdflatex --interaction=batchmode $diff; pdflatex $diff");
+    push @ptmpfiles, "$diffbase.aux","$diffbase.log";
+  }
+  unlink @ptmpfiles;
+  chdir $cwd;
+}
+
+# greptex returns 1 if regex is not matched in filename
+# 0 if there is a match
+sub greptex {
+  my ($regex,$filename)=@_;
+  my ($i)=0;
+  open (FH, $filename) or die("Couldn't open $filename: $!");
+  while (<FH>) {
+    next if /^\s*%/;    # skip comment lines
+    if ( m/$regex/ ) {
+      close(FH);
+      return(0);
+    }
+    # only scan 25 lines
+    $i++;    
+    last if $i>25 ;
+  }
+  close(FH);
+  return(1);
+}
+
+
+=head1 NAME
+
+latexdiff-vc - wrapper script that calls latexdiff for different versions of a file under version management (CVS, RCS or SVN)
+
+=head1 SYNOPSIS
+
+B<latexdiff-vc> [ F<latexdiff-options> ] [ F<latexdiff-vc-options> ]  B<-r> [F<rev1>] [B<-r> F<rev2>]  F<file1.tex> [ F<file2.tex> ...]
+
+ or
+
+B<latexdiff-vc> [ F<latexdiff-options> ]  [ F<latexdiff-vc-options> ][ B<--postscript> | B<--pdf> ]  F<old.tex> F<new.tex>
+
+=head1 DESCRIPTION
+
+I<latexdiff-vc> is a wrapper script that applies I<latexdiff> to a
+file, or multiple files under version control (CVS or RCS), and optionally runs the
+sequence of C<latex> and C<dvips> or C<pdflatex> commands necessary to
+produce pdf or postscript output of the difference tex file(s). It can
+also be applied to a pair of files to automatise the generation of difference
+file in postscript or pdf format.
+
+=head1 OPTIONS
+
+=over 4
+
+=item B<--rcs>, B<--svn>, or B<--cvs>
+
+Set the version system. 
+If no version system is specified, latexdiff-vc will venture a guess.
+
+latexdiff-cvs and latexdiff-rcs are variants of latexdiff-vc which default to 
+the respective versioning system. However, this default can still be overridden using the options above.
+
+=item B<-r>, B<-r> F<rev> or B<--revision>, B<--revision=>F<rev>
+
+Choose revision (under RCS, CVS or SVN). One or two B<-r> options can be
+specified, and the resulting in different behaviour:
+
+=over 4
+
+=item B<latexdiff-vc> -r F<file.tex> ...
+
+compares F<file.tex> with the most recent version checked into RCS.
+
+=item B<latexdiff-vc> -r F<rev1> F<file.tex> ...
+
+compares F<file.tex> with revision F<rev1>.
+
+=item B<latexdiff-vc> -r F<rev1> -r F<rev2> F<file.tex> ...
+
+compares revisions F<rev1> and F<rev2> of F<file.tex>.
+
+Multiple files can be specified for all of the above options. All files must have the
+extension C<.tex>, though.
+
+=item B<latexdiff-vc>  F<old.tex> F<new.tex>
+
+compares two files.
+
+=back
+
+The name of the difference file is generated automatically and
+reported to stdout.
+
+=item B<-d> or B<--dir>  B<-d> F<path> or B<--dir=>F<path>
+
+Rather than appending the string C<diff> and optionally the version
+numbers given to the output-file, this will prepend a directory name C<diff> 
+to the
+original filename, creating the directory and subdirectories should they not exist already.  This is particularly useful in order to clone a
+complete directory hierarchy.  Optionally, a pathname F<path> can be specified, which is prepended instead of C<diff>.
+
+=item B<--ps> or B<--postscript>
+
+Generate postscript output from difference file.  This will run the
+sequence C<latex; latex; dvips> on the difference file (do not use
+this option in the rare cases, where three C<latex> commands are
+required if you care about correct referencing).  If the difference
+file contains a C<\bibliography> tag, run the sequence C<latex;
+bibtex; latex; latex; dvips>.
+
+=item B<--pdf>
+
+Generate pdf output from difference file using C<pdflatex>. This will
+run the sequence C<pdflatex; pdflatex> on the difference file, or
+C<pdflatex; bibtex; pdflatex; pdflatex> for files requiring bibtex.
+
+=item B<--force>
+
+Overwrite existing diff files without asking for confirmation. Default 
+behaviour is to ask for confirmation before overwriting an existing difference
+file.
+
+=item B<--help> or
+B<-h>
+
+Show help text
+
+=item B<--version>
+
+Show version number
+
+=back
+
+All other options are passed on to C<latexdiff>.
+
+=head1 SEE ALSO
+
+L<latexdiff>
+
+=head1 PORTABILITY
+
+I<latexdiff-vc> uses external commands and is therefore
+limited to Unix-like systems. It also requires the RCS version control
+system and latex to be installed on the system.  Modules from Perl 5.8
+or higher are required.
+
+
+=head1 AUTHOR
+
+Copyright (C) 2005 Frederik Tilmann
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License Version 2
+Contributors: S Utcke, H Bruyninckx
+
+=cut
+
diff --git a/Build/source/texk/texlive/linked_scripts/latexdiff/latexdiff.pl b/Build/source/texk/texlive/linked_scripts/latexdiff/latexdiff.pl
new file mode 100755
index 00000000000..03c70c3ac4e
--- /dev/null
+++ b/Build/source/texk/texlive/linked_scripts/latexdiff/latexdiff.pl
@@ -0,0 +1,3240 @@
+#!/usr/bin/perl -w
+# latexdiff - differences two latex files on the word level
+#             and produces a latex file with the differences marked up.
+#
+#   Copyright (C) 2004-2007  F J Tilmann (tilmann@esc.cam.ac.uk)
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License Version 2 as published by
+#    the Free Software Foundation.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# Detailed usage information at the end of the file
+#
+# Version 0.5  A number of minor improvements based on feedback
+#              Deleted blocks are now shown before added blocks
+#              Package specific processing
+#
+# Version 0.43 unreleased typo in list of styles at the end
+#              Add protect to all \cbstart, \cbend commands
+#              More robust substitution of deleted math commands
+#
+# Version 0.42 November 06  Bug fixes only
+#
+# Version 0.4   March 06 option for fast differencing using UNIX diff command, several minor bug fixes (\par bug, improved highlighting of textcmds)
+#
+# Version 0.3   August 05 improved parsing of displayed math, --allow-spaces 
+#               option, several minor bug fixes
+#
+# Version 0.25  October 04 Fix bug with deleted equations, add math mode commands to safecmd, add | to allowed interpunctuation signs
+# Version 0.2   September 04 extension to utf-8 and variable encodings
+# Version 0.1   August 04    First public release
+
+# Inserted block for stand-alone version replaces
+# use Algorithm::Diff qw(traverse_sequences);
+# in standard version
+# The following BEGIN block contains a verbatim copy of
+# Ned Konz' Algorithm::Diff package version 1.15 except
+# that all POD documentation has been stripped out.
+# I encourage you to download and install the Algorithm::Diff
+# package and use the standard latexdiff version instead
+# (current distribution available from http://search.cpan.org/~nedkonz/Algorithm-Diff-1.15
+#  the most recent version can be found via  http://search.cpan.org/search?module=Algorithm::Diff )
+# Please note that the LICENCSE for Algorithm::Diff :
+#   "Copyright (c) 2000-2002 Ned Konz.  All rights reserved.
+#    This program is free software;
+#    you can redistribute it and/or modify it under the same terms
+#    as Perl itself."
+# The stand-alone version of latexdiff is provided as a convenience
+# for latex users with no knowledge of PERL who do not wish to install
+# additional packages to be able to use latexdiff.  If you believe
+# the inlining of Algorithm::Diff violates its license please contact
+# me and I will modify the latexdiff distribution accordingly.
+# Frederik Tilmann (tilmann@esc.cam.ac.uk)
+BEGIN { 
+package Algorithm::Diff;
+use strict;
+use vars qw($VERSION @EXPORT_OK @ISA @EXPORT);
+use integer;    # see below in _replaceNextLargerWith() for mod to make
+                # if you don't use this
+require Exporter;
+@ISA       = qw(Exporter);
+@EXPORT    = qw();
+@EXPORT_OK = qw(LCS diff traverse_sequences traverse_balanced sdiff);
+$VERSION = sprintf('%d.%02d so', (q$Revision: 1.15 $ =~ /\d+/g));
+
+# McIlroy-Hunt diff algorithm
+# Adapted from the Smalltalk code of Mario I. Wolczko, <mario@wolczko.com>
+# by Ned Konz, perl@bike-nomad.com
+
+
+# Create a hash that maps each element of $aCollection to the set of positions
+# it occupies in $aCollection, restricted to the elements within the range of
+# indexes specified by $start and $end.
+# The fourth parameter is a subroutine reference that will be called to
+# generate a string to use as a key.
+# Additional parameters, if any, will be passed to this subroutine.
+#
+# my $hashRef = _withPositionsOfInInterval( \@array, $start, $end, $keyGen );
+
+sub _withPositionsOfInInterval
+{
+	my $aCollection = shift;    # array ref
+	my $start       = shift;
+	my $end         = shift;
+	my $keyGen      = shift;
+	my %d;
+	my $index;
+	for ( $index = $start ; $index <= $end ; $index++ )
+	{
+		my $element = $aCollection->[$index];
+		my $key = &$keyGen( $element, @_ );
+		if ( exists( $d{$key} ) )
+		{
+			unshift ( @{ $d{$key} }, $index );
+		}
+		else
+		{
+			$d{$key} = [$index];
+		}
+	}
+	return wantarray ? %d : \%d;
+}
+
+# Find the place at which aValue would normally be inserted into the array. If
+# that place is already occupied by aValue, do nothing, and return undef. If
+# the place does not exist (i.e., it is off the end of the array), add it to
+# the end, otherwise replace the element at that point with aValue.
+# It is assumed that the array's values are numeric.
+# This is where the bulk (75%) of the time is spent in this module, so try to
+# make it fast!
+
+sub _replaceNextLargerWith
+{
+	my ( $array, $aValue, $high ) = @_;
+	$high ||= $#$array;
+
+	# off the end?
+	if ( $high == -1 || $aValue > $array->[-1] )
+	{
+		push ( @$array, $aValue );
+		return $high + 1;
+	}
+
+	# binary search for insertion point...
+	my $low = 0;
+	my $index;
+	my $found;
+	while ( $low <= $high )
+	{
+		$index = ( $high + $low ) / 2;
+
+		#		$index = int(( $high + $low ) / 2);		# without 'use integer'
+		$found = $array->[$index];
+
+		if ( $aValue == $found )
+		{
+			return undef;
+		}
+		elsif ( $aValue > $found )
+		{
+			$low = $index + 1;
+		}
+		else
+		{
+			$high = $index - 1;
+		}
+	}
+
+	# now insertion point is in $low.
+	$array->[$low] = $aValue;    # overwrite next larger
+	return $low;
+}
+
+# This method computes the longest common subsequence in $a and $b.
+
+# Result is array or ref, whose contents is such that
+# 	$a->[ $i ] == $b->[ $result[ $i ] ]
+# foreach $i in ( 0 .. $#result ) if $result[ $i ] is defined.
+
+# An additional argument may be passed; this is a hash or key generating
+# function that should return a string that uniquely identifies the given
+# element.  It should be the case that if the key is the same, the elements
+# will compare the same. If this parameter is undef or missing, the key
+# will be the element as a string.
+
+# By default, comparisons will use "eq" and elements will be turned into keys
+# using the default stringizing operator '""'.
+
+# Additional parameters, if any, will be passed to the key generation routine.
+
+sub _longestCommonSubsequence
+{
+	my $a      = shift;    # array ref
+	my $b      = shift;    # array ref
+	my $keyGen = shift;    # code ref
+	my $compare;           # code ref
+
+	# set up code refs
+	# Note that these are optimized.
+	if ( !defined($keyGen) )    # optimize for strings
+	{
+		$keyGen = sub { $_[0] };
+		$compare = sub { my ( $a, $b ) = @_; $a eq $b };
+	}
+	else
+	{
+		$compare = sub {
+			my $a = shift;
+			my $b = shift;
+			&$keyGen( $a, @_ ) eq &$keyGen( $b, @_ );
+		};
+	}
+
+	my ( $aStart, $aFinish, $bStart, $bFinish, $matchVector ) =
+	  ( 0, $#$a, 0, $#$b, [] );
+
+	# First we prune off any common elements at the beginning
+	while ( $aStart <= $aFinish
+		and $bStart <= $bFinish
+		and &$compare( $a->[$aStart], $b->[$bStart], @_ ) )
+	{
+		$matchVector->[ $aStart++ ] = $bStart++;
+	}
+
+	# now the end
+	while ( $aStart <= $aFinish
+		and $bStart <= $bFinish
+		and &$compare( $a->[$aFinish], $b->[$bFinish], @_ ) )
+	{
+		$matchVector->[ $aFinish-- ] = $bFinish--;
+	}
+
+	# Now compute the equivalence classes of positions of elements
+	my $bMatches =
+	  _withPositionsOfInInterval( $b, $bStart, $bFinish, $keyGen, @_ );
+	my $thresh = [];
+	my $links  = [];
+
+	my ( $i, $ai, $j, $k );
+	for ( $i = $aStart ; $i <= $aFinish ; $i++ )
+	{
+		$ai = &$keyGen( $a->[$i], @_ );
+		if ( exists( $bMatches->{$ai} ) )
+		{
+			$k = 0;
+			for $j ( @{ $bMatches->{$ai} } )
+			{
+
+				# optimization: most of the time this will be true
+				if ( $k and $thresh->[$k] > $j and $thresh->[ $k - 1 ] < $j )
+				{
+					$thresh->[$k] = $j;
+				}
+				else
+				{
+					$k = _replaceNextLargerWith( $thresh, $j, $k );
+				}
+
+				# oddly, it's faster to always test this (CPU cache?).
+				if ( defined($k) )
+				{
+					$links->[$k] =
+					  [ ( $k ? $links->[ $k - 1 ] : undef ), $i, $j ];
+				}
+			}
+		}
+	}
+
+	if (@$thresh)
+	{
+		for ( my $link = $links->[$#$thresh] ; $link ; $link = $link->[0] )
+		{
+			$matchVector->[ $link->[1] ] = $link->[2];
+		}
+	}
+
+	return wantarray ? @$matchVector : $matchVector;
+}
+
+sub traverse_sequences
+{
+	my $a                 = shift;                                  # array ref
+	my $b                 = shift;                                  # array ref
+	my $callbacks         = shift || {};
+	my $keyGen            = shift;
+	my $matchCallback     = $callbacks->{'MATCH'} || sub { };
+	my $discardACallback  = $callbacks->{'DISCARD_A'} || sub { };
+	my $finishedACallback = $callbacks->{'A_FINISHED'};
+	my $discardBCallback  = $callbacks->{'DISCARD_B'} || sub { };
+	my $finishedBCallback = $callbacks->{'B_FINISHED'};
+	my $matchVector = _longestCommonSubsequence( $a, $b, $keyGen, @_ );
+
+	# Process all the lines in @$matchVector
+	my $lastA = $#$a;
+	my $lastB = $#$b;
+	my $bi    = 0;
+	my $ai;
+
+	for ( $ai = 0 ; $ai <= $#$matchVector ; $ai++ )
+	{
+		my $bLine = $matchVector->[$ai];
+		if ( defined($bLine) )    # matched
+		{
+			&$discardBCallback( $ai, $bi++, @_ ) while $bi < $bLine;
+			&$matchCallback( $ai,    $bi++, @_ );
+		}
+		else
+		{
+			&$discardACallback( $ai, $bi, @_ );
+		}
+	}
+
+	# The last entry (if any) processed was a match.
+	# $ai and $bi point just past the last matching lines in their sequences.
+
+	while ( $ai <= $lastA or $bi <= $lastB )
+	{
+
+		# last A?
+		if ( $ai == $lastA + 1 and $bi <= $lastB )
+		{
+			if ( defined($finishedACallback) )
+			{
+				&$finishedACallback( $lastA, @_ );
+				$finishedACallback = undef;
+			}
+			else
+			{
+				&$discardBCallback( $ai, $bi++, @_ ) while $bi <= $lastB;
+			}
+		}
+
+		# last B?
+		if ( $bi == $lastB + 1 and $ai <= $lastA )
+		{
+			if ( defined($finishedBCallback) )
+			{
+				&$finishedBCallback( $lastB, @_ );
+				$finishedBCallback = undef;
+			}
+			else
+			{
+				&$discardACallback( $ai++, $bi, @_ ) while $ai <= $lastA;
+			}
+		}
+
+		&$discardACallback( $ai++, $bi, @_ ) if $ai <= $lastA;
+		&$discardBCallback( $ai, $bi++, @_ ) if $bi <= $lastB;
+	}
+
+	return 1;
+}
+
+sub traverse_balanced
+{
+	my $a                 = shift;                                  # array ref
+	my $b                 = shift;                                  # array ref
+	my $callbacks         = shift || {};
+	my $keyGen            = shift;
+	my $matchCallback     = $callbacks->{'MATCH'} || sub { };
+	my $discardACallback  = $callbacks->{'DISCARD_A'} || sub { };
+	my $discardBCallback  = $callbacks->{'DISCARD_B'} || sub { };
+	my $changeCallback    = $callbacks->{'CHANGE'};
+	my $matchVector = _longestCommonSubsequence( $a, $b, $keyGen, @_ );
+
+	# Process all the lines in match vector
+	my $lastA = $#$a;
+	my $lastB = $#$b;
+	my $bi    = 0;
+	my $ai    = 0;
+	my $ma    = -1;
+	my $mb;
+
+	while (1)
+	{
+
+		# Find next match indices $ma and $mb
+		do { $ma++ } while ( $ma <= $#$matchVector && !defined $matchVector->[$ma] );
+
+		last if $ma > $#$matchVector;    # end of matchVector?
+		$mb = $matchVector->[$ma];
+
+		# Proceed with discard a/b or change events until
+		# next match
+		while ( $ai < $ma || $bi < $mb )
+		{
+
+			if ( $ai < $ma && $bi < $mb )
+			{
+
+				# Change
+				if ( defined $changeCallback )
+				{
+					&$changeCallback( $ai++, $bi++, @_ );
+				}
+				else
+				{
+					&$discardACallback( $ai++, $bi, @_ );
+					&$discardBCallback( $ai, $bi++, @_ );
+				}
+			}
+			elsif ( $ai < $ma )
+			{
+				&$discardACallback( $ai++, $bi, @_ );
+			}
+			else
+			{
+
+				# $bi < $mb
+				&$discardBCallback( $ai, $bi++, @_ );
+			}
+		}
+
+		# Match
+		&$matchCallback( $ai++, $bi++, @_ );
+	}
+
+	while ( $ai <= $lastA || $bi <= $lastB )
+	{
+		if ( $ai <= $lastA && $bi <= $lastB )
+		{
+
+			# Change
+			if ( defined $changeCallback )
+			{
+				&$changeCallback( $ai++, $bi++, @_ );
+			}
+			else
+			{
+				&$discardACallback( $ai++, $bi, @_ );
+				&$discardBCallback( $ai, $bi++, @_ );
+			}
+		}
+		elsif ( $ai <= $lastA )
+		{
+			&$discardACallback( $ai++, $bi, @_ );
+		}
+		else
+		{
+
+			# $bi <= $lastB
+			&$discardBCallback( $ai, $bi++, @_ );
+		}
+	}
+
+	return 1;
+}
+
+sub LCS
+{
+	my $a = shift;                                           # array ref
+	my $matchVector = _longestCommonSubsequence( $a, @_ );
+	my @retval;
+	my $i;
+	for ( $i = 0 ; $i <= $#$matchVector ; $i++ )
+	{
+		if ( defined( $matchVector->[$i] ) )
+		{
+			push ( @retval, $a->[$i] );
+		}
+	}
+	return wantarray ? @retval : \@retval;
+}
+
+sub diff
+{
+	my $a      = shift;    # array ref
+	my $b      = shift;    # array ref
+	my $retval = [];
+	my $hunk   = [];
+	my $discard = sub { push ( @$hunk, [ '-', $_[0], $a->[ $_[0] ] ] ) };
+	my $add = sub { push ( @$hunk, [ '+', $_[1], $b->[ $_[1] ] ] ) };
+	my $match = sub { push ( @$retval, $hunk ) if scalar(@$hunk); $hunk = [] };
+	traverse_sequences( $a, $b,
+		{ MATCH => $match, DISCARD_A => $discard, DISCARD_B => $add }, @_ );
+	&$match();
+	return wantarray ? @$retval : $retval;
+}
+
+sub sdiff
+{
+	my $a      = shift;    # array ref
+	my $b      = shift;    # array ref
+	my $retval = [];
+	my $discard = sub { push ( @$retval, [ '-', $a->[ $_[0] ], "" ] ) };
+	my $add = sub { push ( @$retval, [ '+', "", $b->[ $_[1] ] ] ) };
+	my $change = sub {
+		push ( @$retval, [ 'c', $a->[ $_[0] ], $b->[ $_[1] ] ] );
+	};
+	my $match = sub {
+		push ( @$retval, [ 'u', $a->[ $_[0] ], $b->[ $_[1] ] ] );
+	};
+	traverse_balanced(
+		$a,
+		$b,
+		{
+			MATCH     => $match,
+			DISCARD_A => $discard,
+			DISCARD_B => $add,
+			CHANGE    => $change,
+		},
+		@_
+	);
+	return wantarray ? @$retval : $retval;
+}
+
+1;
+}
+import Algorithm::Diff qw(traverse_sequences);
+# End of inserted block for stand-alone version
+
+use Getopt::Long ;
+use strict ;
+use utf8 ;
+
+my ($algodiffversion)=split(/ /,$Algorithm::Diff::VERSION);
+
+
+my ($versionstring)=<<EOF ;
+This is LATEXDIFF 0.5  (Algorithm::Diff $Algorithm::Diff::VERSION)
+  (c) 2004-2007 F J Tilmann
+EOF
+
+# Configuration variables: these have to be visible from the subroutines
+my $MINWORDSBLOCK=3; # minimum number of tokens to form an independent block
+                     # shorter identical blocks will be merged to the previous word
+my $FLOATENV='(?:figure|table|plate)[\w\d*@]*' ;   # Environments in which FL variants of defined commands are used
+my $PICTUREENV='(?:picture|DIFnomarkup)[\w\d*@]*' ;   # Environments in which all change markup is removed
+my $MATHENV='(?:equation|displaymath|DOLLARDOLLAR)' ;           # Environments turning on display math mode (code also knows about \[ and \]
+my $MATHREPL='displaymath';  # Environment introducing deleted maths blocks
+my $MATHARRENV='(?:eqnarray|align|gather|multiline|flalign)[*]?' ;           # Environments turning on eqnarray math mode
+my $MATHARRREPL='eqnarray*';  # Environment introducing deleted maths blocks
+my $ARRENV='(?:array|[pbvBV]matrix)'; # Enviroments making arrays in math mode.  The underlining style does not cope well with those - as a result in-text math environments are surrounded by \mbox{ } if any of these commands is used in an inline math block
+my $COUNTERCMD='(?:footnote|part|section|subsection|subsubsection|paragraph|subparagraph)';  # textcmds which are associated with a counter
+                                        # If any of these commands occur in a deleted block
+                                        # they will be succeeded by an \addtocounter{...}{-1}
+                                        # for the associated counter such that the overall numbers
+                                        # should be the same as in the new file
+
+# Markup strings
+# If at all possible, do not change these as parts of the program
+# depend on the actual name (particularly post-processing)
+# At the very least adapt subroutine postprocess to new tokens.
+my $ADDMARKOPEN='\DIFaddbegin ';   # Token to mark begin of appended text
+my $ADDMARKCLOSE='\DIFaddend ';   # Token to mark end of appended text
+my $ADDOPEN='\DIFadd{';  # To mark begin of added text passage
+my $ADDCLOSE='}';        # To mark end of added text passage
+my $ADDCOMMENT='DIF > ';   # To mark added comment line
+my $DELMARKOPEN='\DIFdelbegin ';   # Token to mark begin of deleted text
+my $DELMARKCLOSE='\DIFdelend ';   # Token to mark end of deleted text
+my $DELOPEN='\DIFdel{';  # To mark begin of deleted text passage
+my $DELCLOSE='}';        # To mark end of deleted text passage
+my $DELCMDOPEN='%DIFDELCMD < ';  # To mark begin of deleted commands (must begin with %, i.e., be a comment
+my $DELCMDCLOSE="%%%\n";    # To mark end of deleted commands (must end with a new line)
+my $AUXCMD='%DIFAUXCMD' ; #  follows auxiliary commands put in by latexdiff to make difference file legal
+                          # auxiliary commands must be on a line of their own
+my $DELCOMMENT='DIF < ';   # To mark deleted comment line
+
+
+# main local variables:
+my @TEXTCMDLIST=();  # array containing patterns of commands with text arguments
+my @TEXTCMDEXCL=();  # array containing patterns of commands without text arguments (if a pattern
+                     # matches both TEXTCMDLIST and TEXTCMDEXCL it is excluded)
+my @CONTEXT1CMDLIST=();  # array containing patterns of commands with text arguments (subset of text commands),
+                         # but which cause confusion if used out of context (e.g. \caption). 
+                         # In deleted passages, the command will be disabled but its argument is marked up
+                         # Otherwise they behave exactly like TEXTCMD's 
+my @CONTEXT1CMDEXCL=();  # exclude list for above, but always empty
+my @CONTEXT2CMDLIST=();  # array containing patterns of commands with text arguments, but which fail cause confusion
+                         # if used out of context (e.g. \title). They and their arguments will be disabled in deleted
+                         # passages
+my @CONTEXT2CMDEXCL=();  # exclude list for above, but always empty
+
+my @SAFECMDLIST=();  # array containing patterns of safe commands (which do not break when in the argument of DIFadd or DIFDEL)
+my @SAFECMDEXCL=();
+
+my ($i,$j,$l);
+my ($old,$new);
+my ($line);
+my ($newpreamble,$oldpreamble);
+my (@newpreamble,@oldpreamble,@diffpreamble,@diffbody);
+my ($latexdiffpreamble);
+my ($oldbody, $newbody, $diffbo);
+my ($oldpost, $newpost);
+my ($diffall);
+# Option names
+my ($type,$subtype,$floattype,$config,$preamblefile,$encoding,
+    $showpreamble,$showsafe,$showtext,$showconfig,$showall,
+    $replacesafe,$appendsafe,$excludesafe,
+    $replacetext,$appendtext,$excludetext,
+    $replacecontext1,$appendcontext1,
+    $replacecontext2,$appendcontext2,
+    $help,$verbose,$version,$ignorewarnings,$allowspaces,$flatten,$debug);
+my (@configlist,
+    @appendsafelist,@excludesafelist,
+    @appendtextlist,@excludetextlist,
+    @appendcontext1list,@appendcontext2list,
+    @packagelist);
+my ($assign,@config);
+# Hash where keys corresponds to the names of  all included packages (including the documentclass as another package
+# the optional arguments to the package are the values of the hash elements
+my ($pkg,%packages);
+# Defaults
+$type='UNDERLINE';
+$subtype='SAFE';
+$floattype='FLOATSAFE';
+
+$verbose=0;
+$debug=1; 
+# define character properties
+sub IsNonAsciiPunct { return <<'END'    # Unicode punctuation but excluding ASCII punctuation
++utf8::IsPunct
+-utf8::IsASCII
+END
+}
+sub IsNonAsciiS { return <<'END'       # Unicode symbol but excluding ASCII
++utf8::IsS
+-utf8::IsASCII
+END
+}
+
+
+
+  my %verbhash;
+
+Getopt::Long::Configure('bundling');
+GetOptions('type|t=s' => \$type, 
+	   'subtype|s=s' => \$subtype, 
+	   'floattype|f=s' => \$floattype, 
+	   'config|c=s' => \@configlist,
+	   'preamble|p=s' => \$preamblefile,
+	   'encoding|e=s' => \$encoding,
+	   'exclude-safecmd|A=s' => \@excludesafelist,
+	   'replace-safecmd=s' => \$replacesafe,
+	   'append-safecmd|a=s' => \@appendsafelist,
+	   'exclude-textcmd|X=s' => \@excludetextlist,
+	   'replace-textcmd=s' => \$replacetext,
+	   'append-textcmd|x=s' => \@appendtextlist,
+	   'replace-context1cmd=s' => \$replacecontext1,
+	   'append-context1cmd=s' => \@appendcontext1list,
+	   'replace-context2cmd=s' => \$replacecontext2,
+	   'append-context2cmd=s' => \@appendcontext2list,
+	   'show-preamble' => \$showpreamble,
+	   'show-safecmd' => \$showsafe,
+	   'show-textcmd' => \$showtext,
+	   'show-config' => \$showconfig,
+	   'show-all' => \$showall,
+           'packages=s' => \@packagelist,
+	   'verbose|V' => \$verbose,
+	   'ignore-warnings' => \$ignorewarnings,
+	   'allow-spaces' => \$allowspaces,
+	   'flatten' => \$flatten,
+	   'version' => \$version,
+	   'help|h|H' => \$help);
+
+if ( $help ) {
+  usage() ;
+}
+
+
+if ( $version ) {
+  die $versionstring ; 
+}
+
+print STDERR $versionstring if $verbose; 
+
+if (defined($showall)){
+  $showpreamble=$showsafe=$showtext=$showconfig=1;
+}
+
+# setting extra preamble commands
+if (defined($preamblefile)) {
+  $latexdiffpreamble=join "\n",(extrapream($preamblefile),"");
+} else {
+  $latexdiffpreamble=join "\n",(extrapream($type,$subtype,$floattype),"");
+}
+
+# setting up @SAFECMDLIST and @SAFECMDEXCL
+if (defined($replacesafe)) {
+  init_regex_arr_ext(\@SAFECMDLIST,$replacesafe);
+} else {
+  init_regex_arr_data(\@SAFECMDLIST, "SAFE COMMANDS");
+}
+foreach $appendsafe ( @appendsafelist ) {
+  init_regex_arr_ext(\@SAFECMDLIST, $appendsafe);
+}
+foreach $excludesafe ( @excludesafelist ) {
+  init_regex_arr_ext(\@SAFECMDEXCL, $excludesafe);
+}
+
+# Special: treat all cite commands as safe except in UNDERLINE and FONTSTRIKE mode
+# (there is a conflict between citation and ulem package, see
+# package documentation)
+if ( uc($type) ne "UNDERLINE" && uc($type) ne "FONTSTRIKE" && uc($type) ne "CULINECHBAR" ) {
+  push (@SAFECMDLIST, qr/^cite.*$/);
+}
+
+# setting up @TEXTCMDLIST and @TEXTCMDEXCL
+if (defined($replacetext)) {
+  init_regex_arr_ext(\@TEXTCMDLIST,$replacetext);
+} else {
+  init_regex_arr_data(\@TEXTCMDLIST, "TEXT COMMANDS");
+}
+foreach $appendtext ( @appendtextlist ) {
+  init_regex_arr_ext(\@TEXTCMDLIST, $appendtext);
+}
+foreach $excludetext ( @excludetextlist ) {
+  init_regex_arr_ext(\@TEXTCMDEXCL, $excludetext);
+}
+
+
+# setting up @CONTEXT1CMDLIST ( @CONTEXT1CMDEXCL exist but is always empty )
+if (defined($replacecontext1)) {
+  init_regex_arr_ext(\@CONTEXT1CMDLIST,$replacecontext1);
+} else {
+  init_regex_arr_data(\@CONTEXT1CMDLIST, "CONTEXT1 COMMANDS");
+}
+foreach $appendcontext1 ( @appendcontext1list ) {
+  init_regex_arr_ext(\@CONTEXT1CMDLIST, $appendcontext1);
+}
+
+
+# setting up @CONTEXT2CMDLIST ( @CONTEXT2CMDEXCL exist but is always empty )
+if (defined($replacecontext2)) {
+  init_regex_arr_ext(\@CONTEXT2CMDLIST,$replacecontext2);
+} else {
+  init_regex_arr_data(\@CONTEXT2CMDLIST, "CONTEXT2 COMMANDS");
+}
+foreach $appendcontext2 ( @appendcontext2list ) {
+  init_regex_arr_ext(\@CONTEXT2CMDLIST, $appendcontext2);
+}
+
+
+
+
+# setting configuration variables
+@config=();
+foreach $config ( @configlist ) {
+  if (-f $config ) {
+    open(FILE,$config) or die ("Couldn't open configuration file $config: $!");
+    while (<FILE>) {
+      chomp;
+      next if /^\s*#/ || /^\s*%/ || /^\s*$/ ;
+      push (@config,$_);
+    }
+    close(FILE);
+  }
+  else {
+#    foreach ( split(",",$config) ) {
+#      push @config,$_;
+#    }
+     push @config,split(",",$config)
+  }
+}
+foreach $assign ( @config ) {
+  $assign=~ m/\s*(\w*)\s*=\s*(\S*)\s*$/ or die "Illegal assignment $assign in configuration list (must be variable=value)";  
+  if ( $1 eq "MINWORDSBLOCK" ) { $MINWORDSBLOCK = $2; }
+  elsif ( $1 eq "FLOATENV" ) { $FLOATENV = $2 ; }
+  elsif ( $1 eq "PICTUREENV" ) { $PICTUREENV = $2 ; }
+  elsif ( $1 eq "MATHENV" ) { $MATHENV = $2 ; }
+  elsif ( $1 eq "MATHREPL" ) { $MATHREPL = $2 ; }
+  elsif ( $1 eq "MATHARRENV" ) { $MATHARRENV = $2 ; }
+  elsif ( $1 eq "MATHARRREPL" ) { $MATHARRREPL = $2 ; }
+  elsif ( $1 eq "ARRENV" ) { $ARRENV = $2 ; }
+  elsif ( $1 eq "COUNTERCMD" ) { $COUNTERCMD = $2 ; }
+  else { die "Unknown variable $1 in assignment.";}
+}
+
+
+foreach $pkg ( @packagelist ) {
+  map { $packages{$_}="" } split(/,/,$pkg) ;
+}
+
+if ($showpreamble) {
+  print "\nPreamble commands:\n";
+  print $latexdiffpreamble ;
+}
+
+if ($showsafe) {
+  print "\nCommands safe within scope of $ADDOPEN $ADDCLOSE and $DELOPEN $DELCLOSE (unless excluded):\n";
+  print_regex_arr(@SAFECMDLIST);
+  print "\nCommands not safe within scope of $ADDOPEN $ADDCLOSE and $DELOPEN $DELCLOSE :\n";
+  print_regex_arr(@SAFECMDEXCL);
+}
+
+if ($showtext) {
+  print "\nCommands with last argument textual (unless excluded) and safe in every context:\n";
+  print_regex_arr(@TEXTCMDLIST);
+  print "\nContext1 commands (last argument textual, command will be disabled in deleted passages, last argument will be shown as plain text):\n";
+  print_regex_arr(@CONTEXT1CMDLIST);
+  print "\nContext2 commands (last argument textual, command ant its argument will be disabled in deleted passages):\n";
+  print_regex_arr(@CONTEXT2CMDLIST);  
+  print "\nExclude list of Commands with last argument not textual (overrides patterns above):\n";
+  print_regex_arr(@TEXTCMDEXCL);
+}
+
+if ($showconfig) {
+  print "Configuration variables:\n";
+  print "MINWORDSBLOCK=$MINWORDSBLOCK\n";
+  print "FLOATENV=$FLOATENV\n";
+  print "PICTUREENV=$PICTUREENV\n";
+  print "MATHENV=$MATHENV\n";
+  print "MATHREPL=$MATHREPL\n";
+  print "MATHARRENV=$MATHARRENV\n";
+  print "MATHARRREPL=$MATHARRREPL\n";
+  print "ARRENV=$ARRENV\n";
+  print "COUNTERCMD=$COUNTERCMD\n";
+}
+if ($showconfig || $showtext || $showsafe || $showpreamble) {
+  exit 0; }
+if ( @ARGV != 2 ) { 
+  print STDERR "2 and only 2 non-option arguments required.  Write latexdiff -h to get help\n";
+  exit(2);
+}
+
+# Are extra spaces between command arguments permissible?
+my $extraspace;
+if ($allowspaces) {
+  $extraspace='\s*'; 
+} else {
+  $extraspace='';
+}
+
+# append context lists to text lists (as text property is implied)
+push @TEXTCMDLIST, @CONTEXT1CMDLIST;
+push @TEXTCMDLIST, @CONTEXT2CMDLIST;
+
+
+# Patterns. These are used by some of the subroutines, too
+# I can only define them down here because value of extraspace depends on an option
+  my $pat0 = '(?:[^{}]|\\\{|\\\})*';
+  my $pat1 = '(?:[^{}]|\\\{|\\\}|\{'.$pat0.'\})*';
+  my $pat2 = '(?:[^{}]|\\\{|\\\}|\{'.$pat1.'\})*'; # 
+  my $pat3 = '(?:[^{}]|\\\{|\\\}|\{'.$pat2.'\})*';
+  my $pat4 = '(?:[^{}]|\\\{|\\\}|\{'.$pat3.'\})*';
+  my $brat0 = '(?:[^\[\]]|\\\[|\\\])*'; 
+
+  my $quotemarks = '(?:\'\')|(?:\`\`)';
+  my $punct='[0.,\/\'\`:;\"\?\(\)\[\]!~\p{IsNonAsciiPunct}\p{IsNonAsciiS}]';
+  my $number='-?\d*\.\d*';
+  my $mathpunct='[+=<>\-\|]';
+  my $and = '&';
+  my $coords= '[\-.,\s\d]*';
+# word: sequence of letters or accents followed by letter
+  my $word='(?:[-\w\d*]|\\\\[\"\'\`~^][A-Za-z\*])+';
+  my $cmdleftright='\\\\(?:left|right)\s*(?:[()\[\]|]|\\\\(?:[|{}]|\w+))';
+
+  my $cmdoptseq='\\\\[\w\d\*]+'.$extraspace.'(?:(?:\['.$brat0.'\]|\{'. $pat4 . '\}|\(' . $coords .'\))'.$extraspace.')*';
+  my $oneletcmd='\\\\.(?:\['.$brat0.'\]|\{'. $pat4 . '\})*';
+  my $math='\$(?:[^$]|\\\$)*?\$|\\\\[(].*?\\\\[)]';
+#  my $math='\$(?:[^$]|\\\$)*\$';
+  my $comment='%.*?\n';
+  my $pat=qr/(?:\A\s*)?(?:${and}|${quotemarks}|${number}|${word}|$cmdleftright|${cmdoptseq}|${math}|${oneletcmd}|${comment}|${punct}|${mathpunct}|\{|\})\s*/ ;
+
+
+
+# now we are done setting up and can start working   
+my ($oldfile, $newfile) = @ARGV;
+
+$encoding=guess_encoding($newfile) unless defined($encoding);
+
+$encoding = "utf8" if $encoding =~ m/^utf8/i ;
+if (lc($encoding) eq "utf8" ) {
+  binmode(STDOUT, ":utf8");
+  binmode(STDERR, ":utf8");
+}
+
+$old=read_file_with_encoding($oldfile,$encoding);
+$new=read_file_with_encoding($newfile,$encoding);
+
+
+
+
+# reset time
+exetime(1);
+($oldpreamble,$oldbody,$oldpost)=splitdoc($old,'\\\\begin\{document\}','\\\\end\{document\}');
+
+
+($newpreamble,$newbody,$newpost)=splitdoc($new,'\\\\begin\{document\}','\\\\end\{document\}');
+
+
+if ($flatten) {
+  $oldbody=flatten($oldbody,$oldpreamble,$oldfile,$encoding);
+  $newbody=flatten($newbody,$newpreamble,$newfile,$encoding);
+}
+
+if ( length $oldpreamble && length $newpreamble ) {
+  @oldpreamble = split /\n/, $oldpreamble;
+  @newpreamble = split /\n/, $newpreamble;
+  
+  %packages=list_packages(@newpreamble) unless %packages;
+  if (defined $packages{"hyperref"} ) {
+    print STDERR "hyperref package detected.\n" if $verbose ;
+    $latexdiffpreamble =~ s/\{\\DIFadd\}/{\\DIFaddtex}/g;
+    $latexdiffpreamble =~ s/\{\\DIFdel\}/{\\DIFdeltex}/g;
+    $latexdiffpreamble .= join "\n",(extrapream("HYPERREF"),"");
+  }
+  # insert dummy first line such that line count begins with line 1 (rather than perl's line 0) - just so that line numbers inserted by linediff are correct
+  unshift @newpreamble,'';
+  unshift @oldpreamble,'';
+  print STDERR "Differencing preamble.\n" if $verbose;
+  @diffpreamble = linediff(\@oldpreamble, \@newpreamble);
+  # remove dummy line again
+  shift @diffpreamble; 
+  push @diffpreamble,$latexdiffpreamble;
+  push @diffpreamble,'\begin{document}';
+}
+elsif ( !length $oldpreamble && !length $newpreamble ) {
+  @diffpreamble=();
+} else {
+  print STDERR "Either both texts must have preamble or neither text must have the preamble.\n";
+  exit(2);
+}
+
+if (defined $packages{"amsmath"} ) {
+  print STDERR "amsmath package detected.\n" if $verbose ;
+  $MATHARRREPL='align*';
+}
+
+print STDERR "Preprocessing body.  " if $verbose;
+my ($oldleadin,$newleadin)=preprocess($oldbody,$newbody);
+
+
+# run difference algorithm
+@diffbody=bodydiff($oldbody, $newbody);
+$diffbo=join("",@diffbody);
+print STDERR "(",exetime()," s)\n","Postprocessing body. \n " if $verbose;
+postprocess($diffbo);
+$diffall =join("\n",@diffpreamble) ;
+$diffall .= "$newleadin$diffbo" ;
+$diffall .= "\\end{document}$newpost" if length $newpreamble ;
+if ( lc($encoding) ne "utf8" && lc($encoding) ne "ascii" ) {
+  print STDERR "Encoding output file to $encoding\n" if $verbose;
+  $diffall=Encode::encode($encoding,$diffall);
+  binmode STDOUT;
+}
+print $diffall;
+
+
+print STDERR "(",exetime()," s)\n","Done.\n" if $verbose;
+
+
+
+## guess_encoding(filename)
+## reads the first 20 lines of filename and looks for call of inputenc package
+## if found, return the option of this package (encoding), otherwise return ascii
+sub guess_encoding {
+  my ($filename)=@_;
+  my ($i,$enc);
+  open (FH, $filename) or die("Couldn't open $filename: $!");
+  $i=0;
+  while (<FH>) {
+    next if /^\s*%/;    # skip comment lines
+    if (m/\\usepackage\[(\w*?)\]\{inputenc\}/) {
+      close(FH);
+      return($1);
+    }
+    last if (++$i > 20 ); # scan at most 20 non-comment lines
+  }
+  close(FH);
+  return("ascii");
+}
+
+
+sub read_file_with_encoding {
+  my ($output);
+  my ($filename, $encoding) = @_;
+
+  if (lc($encoding) eq "utf8" ) {
+    open (FILE, "<:utf8",$filename) or die("Couldn't open $filename: $!");
+    local $/ ; # locally set record operator to undefined, ie. enable whole-file mode
+    $output=<FILE>;
+  } elsif ( lc($encoding) eq "ascii") {
+    open (FILE, $filename) or die("Couldn't open $filename: $!");
+    local $/ ; # locally set record operator to undefined, ie. enable whole-file mode
+    $output=<FILE>;
+  } else {
+    require Encode;
+    open (FILE, "<",$filename) or die("Couldn't open $filename: $!");
+    local $/ ; # locally set record operator to undefined, ie. enable whole-file mode
+    $output=<FILE>;
+    print STDERR "Converting $filename from $encoding to utf8\n" if $verbose;
+    $output=Encode::decode($encoding,$output);
+  }
+  close FILE;
+  return $output;
+}
+
+# %packages=list_packages(@preamble)
+# scans the arguments for \documentclass and \usepackage statements and constructs a hash
+# whose keys are the included packages, and whose values are the associated optional arguments
+sub list_packages {
+  my (@preamble)=@_;
+  my %packages=();
+  foreach $line ( @preamble ) {
+    # get rid of comments
+    $line=~s/(?<!\\)%.*$// ;
+    if ( $line =~ m/\\(?:documentclass|usepackage)(?:\[(.+?)\])?\{(.*?)\}/ ) {
+#      print STDERR "Found something: |$line|\n";
+      if (defined($1)) {
+	$packages{$2}=$1;
+      } else {
+	$packages{$2}="";
+      }
+    }
+  }
+  return (%packages);
+}
+
+# flatten($text,$preamble,$filename,$encoding)
+# expands \input and \include commands within text
+# premable is scanned for includeonly commands
+# encoding is the encoding
+sub flatten {
+  my ($text,$preamble,$filename,$encoding)=@_;
+  my ($includeonly,$dirname,$fname,$newpage,$replacement);
+  require File::Basename ; 
+  require File::Spec ; 
+  $dirname = File::Basename::dirname($filename);
+
+  if ( ($includeonly) = ($preamble =~ m/\\includeonly{(.*?)}/ ) ) {
+    $includeonly =~ s/,/|/g;
+  } else {
+    $includeonly = '.*?';
+  }
+
+  print STDERR "DEBUG: includeonly $includeonly\n";
+
+  $text=~s/\\input{(.*?)}|\\include{(${includeonly}(?:\.tex)?)}/{ 
+	    $fname = $1 if defined($1)  ;
+	    $fname = $2 if defined($2) ;       
+            #      # add tex extension unless there is a three letter extension already 
+            $fname .= ".tex" unless $fname =~ m|\.\w{3}|;
+            print STDERR "Include file $fname\n" if $verbose;
+            print STDERR "DEBUG looking for file ",File::Spec->catfile($dirname,$fname), "\n";
+            # content of file becomes replacement value, add \newpage if the command was include
+            $replacement=read_file_with_encoding(File::Spec->catfile($dirname,$fname), $encoding) or die
+                "Couldn't find file ",File::Spec->catfile($dirname,$fname),": $!";
+	    $newpage=(defined($2)? " \\newpage " : "") ;
+	    "$newpage$replacement$newpage";
+          }/exg;
+
+  return($text);
+}
+
+
+# print_regex_arr(@arr)
+# prints regex array without x-ism expansion put in by pearl to stdout
+sub print_regex_arr {
+  my $dumstring;
+  $dumstring = join(" ",@_);     # PERL generates string (?-xism:^ref$) for quoted refex ^ref$
+  $dumstring =~ s/\(\?-xism:\^(.*?)\$\)/$1/g;   # remove string and ^,$ marks before output
+  print $dumstring,"\n";
+}
+
+
+# @lines=extrapream($type)
+# reads line from appendix (end of file after __END__ token)
+sub extrapream {
+  my $type;
+  my @retval=("%DIF PREAMBLE EXTENSION ADDED BY LATEXDIFF") ;
+  my ($copy);
+
+  while (@_) {
+    $copy=0;
+    $type=shift ;
+    if ( -f $type ) {
+      open (FILE,$type) or die "Cannot open preamble file $type: $!";
+      print STDERR "Reading preamble file $type\n" if $verbose ;
+      while (<FILE>) {
+	chomp ;
+	if ( $_ =~ m/%DIF PREAMBLE/ ) {
+	  push (@retval,"$_"); 
+	} else {
+	  push (@retval,"$_ %DIF PREAMBLE"); 
+	}
+      }
+    } 
+    else {    # not (-f $type)
+      $type=uc($type);   # upcase argument
+      print STDERR "Preamble Internal Type $type\n" if $verbose;
+      while (<DATA>) {
+	if ( m/^%DIF $type/ ) {
+	  $copy=1; }
+	elsif ( m/^%DIF END $type/ ) {
+	  last; }
+	chomp;
+	push (@retval,"$_ %DIF PREAMBLE") if $copy;
+      }
+      if ( $copy == 0 ) {
+	print STDERR "\nPreamble style $type not implemented.\n";
+        print STDERR "Write latexdiff -h to get help with available styles\n";
+        exit(2);
+      }
+      seek DATA,0,0;    # rewind DATA handle to file begin
+    }
+  }
+  push (@retval,"%DIF END PREAMBLE EXTENSION ADDED BY LATEXDIFF")  ;
+  return @retval;
+}
+
+
+# ($part1,$part2,$part3)=splitdoc($text,$word1,$word2)
+# splits $text into 3 parts at $word1 and $word2.
+# if neither $word1 nor $word2 exist, $part1 and $part3 are empty, $part2 is $text
+# If only $word1 or $word2 exist but not the other, output an error message.
+
+# NB this version avoids $` and $' for performance reason although it only makes a tiny difference
+# (in one test gain a tenth of a second for a 30s run)
+sub splitdoc {
+  my ($text,$word1,$word2)=@_;
+  my ($part1,$part2,$part3)=("","","");
+  my ($rest,$pos);
+
+  if ( $text =~ m/(^[^%]*)($word1)/mg ) {
+    $pos=pos $text;
+    $part1=substr($text,0,$pos-length($2));
+    $rest=substr($text,$pos);
+    if ( $rest =~ m/(^[^%]*)($word2)/mg ) {
+      $pos=pos $rest;
+      $part2=substr($rest,0,$pos-length($2));
+      $part3=substr($rest,$pos);
+    } 
+    else {
+      die "$word1 and $word2 not in the correct order or not present as a pair." ;
+    }
+  } else {
+    $part2=$text;
+    die "$word2 present but not $word1." if ( $text =~ m/(^[^%]*)$word2/ms );
+  }
+  return ($part1,$part2,$part3);
+}
+
+
+
+
+
+# bodydiff($old,$new)
+sub bodydiff {
+  my ($oldwords, $newwords) = @_;
+  my @retwords;
+
+  print STDERR "(",exetime()," s)\n","Splitting into latex tokens \n" if $verbose;
+  print STDERR "Parsing $oldfile \n" if $verbose;
+  my @oldwords = splitlatex($oldwords);
+  print STDERR "Parsing $newfile \n" if $verbose;
+  my @newwords = splitlatex($newwords);
+  my $token;
+
+  print STDERR "(",exetime()," s)\n","Pass 1: Expanding text commands and merging isolated identities with changed blocks  " if $verbose;
+  pass1(\@oldwords, \@newwords);
+
+
+  print STDERR "(",exetime()," s)\n","Pass 2: inserting DIF tokens and mark up.  " if $verbose;
+
+  @retwords=pass2(\@oldwords, \@newwords);
+
+  return(@retwords);
+}
+
+
+
+
+# @words=splitlatex($string)
+# split string according to latex rules
+# Each element of words is either
+# a word (including trailing spaces and punctuation)
+# a latex command
+sub splitlatex {
+  my ($string) = @_ ;
+  my @retval=($string =~ m/$pat/osg);  
+
+  if (length($string) != length(join("",@retval))) {
+    print STDERR "\nWARNING: Inconsistency in length of input string and parsed string:\n     This often indicates faulty or non-standard latex code.\n     In many cases you can ignore this and the following warning messages.\n Note that character numbers in the following are counted beginning after \\begin{document} and are only approximate." unless $ignorewarnings;
+    print STDERR "DEBUG Original length ",length($string),"  Parsed length ",length(join("",@retval)),"\n" if $debug;
+    print STDERR "DEBUG Input string:  |$string|\n" if (length($string)<500) && $debug;
+    print STDERR "DEBUG Token parsing: |",join("+",@retval),"|\n" if (length($string)<500) && $debug ;
+    @retval=();
+    # slow way only do this if other m//sg method fails
+    my $last = 0;
+    while ( $string =~ m/$pat/osg ) {
+      my $match=$&;
+      if ($last + length $& != pos $string  ) {
+	my $pos=pos($string);
+	my $offset=30<$last ? 30 : $last;
+	my $dum=substr($string,$last-$offset,$pos-$last+2*$offset);
+	my $dum1=$dum;
+	my $cnt=$#retval;
+	my $i;
+	$dum1 =~ s/\n/ /g;
+	unless ($ignorewarnings) {
+	  print STDERR "\n$dum1\n";
+	  print STDERR " " x 30,"^" x ($pos-$last)," " x 30,"\n";
+	  print STDERR "Missing characters near word " . (scalar @retval) . " character index: " . $last . "-" .  pos($string) . " Length: " . length($match) . " Match: |$match| (expected match marked above).\n";
+	}
+	  # put in missing characters `by hand'
+	push (@retval, substr($dum,$offset,$pos-$last-length($match)));
+#       Note: there seems to be a bug in substr with utf8 that made the following line output substr which were too long,
+#             using dum instead appears to work
+#	push (@retval, substr($string,$last, pos($string)-$last-length($match)));
+      }
+      push (@retval, $match);
+      $last=pos $string;
+    }
+
+  }
+  return @retval;
+}
+
+
+# pass1( \@seq1,\@seq2)
+# Look for differences between seq1 and seq2.
+# Where an common-subsequence block is flanked by deleted or appended blocks, 
+# and is shorter than $MINWORDSBLOCK words it is appended
+# to the last deleted or appended word.  If the block contains tokens other than words 
+# or punctuation it is not merged.
+# Deleted or appended block consisting of words and safe commands only are
+# also merged, to prevent break-up in pass2 (after previous isolated words have been removed)
+# If there are commands with textual arguments (e.g. \caption) both in corresponding 
+# appended and deleted blocks split them such that the command and opening bracket 
+# are one token, then the rest is split up following standard rules, and the closing 
+# bracket is a separate token, ie. turn
+# "\caption{This is a textual argument}" into 
+# ("\caption{","This ","is ","a ","textual ","argument","}")
+# No return value.  Destructively changes sequences
+sub pass1 {
+  my $seq1 = shift ;
+  my $seq2 = shift ;
+
+  my $len1 = scalar @$seq1;
+  my $len2 = scalar @$seq2;
+  my $wpat=qr/^(?:[a-zA-Z.,'`:;?()!]*)[\s~]*$/;   #'
+
+  my ($last1,$last2)=(-1,-1) ;
+  my $cnt=0;
+  my $block=[];
+  my $addblock=[];
+  my $delblock=[];
+  my $todo=[];
+  my $instruction=[];
+  my $i;
+  my (@delmid,@addmid,@dummy);
+
+  my ($addcmds,$delcmds,$matchindex);
+  my ($addtextblocks,$deltextblocks);
+  my ($addtokcnt,$deltokcnt,$mattokcnt)=(0,0,0);
+  my ($addblkcnt,$delblkcnt,$matblkcnt)=(0,0,0);
+
+  my $adddiscard = sub {
+                      if ($cnt > 0 ) {
+			$matblkcnt++;
+			# just after an unchanged block 
+#			print STDERR "Unchanged block $cnt, $last1,$last2 \n";
+                        if ($cnt < $MINWORDSBLOCK 
+			    && $cnt==scalar (
+				     grep { /^$wpat/ || ( /^\\([\w\d\*]+)((?:\[$brat0\]|\{$pat4\})*)/o 
+							   && iscmd($1,\@SAFECMDLIST,\@SAFECMDEXCL) 
+							   && scalar(@dummy=split(" ",$2))<3 ) }
+					     @$block) )  {
+			  # merge identical blocks shorter than $MINWORDSBLOCK 
+			  # and only containing ordinary words
+			  # with preceding different word
+			  # We cannot carry out this merging immediately as this
+			  # would change the index numbers of seq1 and seq2 and confuse
+			  # the algorithm, instead we store in @$todo where we have to merge
+                          push(@$todo, [ $last1,$last2,$cnt,@$block ]);
+			}
+			$block = []; 
+			$cnt=0; $last1=-1; $last2=-1;
+		      }
+		    };
+  my $discard=sub { $deltokcnt++;
+                    &$adddiscard; #($_[0],$_[1]);
+		    push(@$delblock,[ $seq1->[$_[0]],$_[0] ]);
+		    $last1=$_[0] };		      
+
+  my $add =   sub { $addtokcnt++;
+                    &$adddiscard; #($_[0],$_[1]);
+		    push(@$addblock,[ $seq2->[$_[1]],$_[1] ]);
+		    $last2=$_[1] };		      
+
+  my $match = sub { $mattokcnt++;
+                    if ($cnt==0) {   # first word of matching sequence after changed sequence or at beginning of word sequence
+		      $deltextblocks = extracttextblocks($delblock); 
+		      $delblkcnt++ if scalar @$delblock;
+		      $addtextblocks = extracttextblocks($addblock);
+		      $addblkcnt++ if scalar @$addblock;
+
+		      $delcmds = extractcommands($delblock);
+      		      $addcmds = extractcommands($addblock);
+		      # keygen(third argument of _longestCommonSubsequence) implies to sort on command (0th elements of $addcmd elements)
+		      # the calling format for longestCommonSubsequence has changed between versions of
+		      # Algorithm::Diff so we need to check which one we are using
+		      if ( $algodiffversion  > 1.15 ) {
+			### Algorithm::Diff 1.19
+			$matchindex=Algorithm::Diff::_longestCommonSubsequence($delcmds,$addcmds, 0, sub { $_[0]->[0] } );
+		      } else {
+			### Algorithm::Diff 1.15	
+			$matchindex=Algorithm::Diff::_longestCommonSubsequence($delcmds,$addcmds, sub { $_[0]->[0] } );
+		      }
+
+		      for ($i=0 ; $i<=$#$matchindex ; $i++) {
+			if (defined($matchindex->[$i])){
+			  $j=$matchindex->[$i];
+			  @delmid=splitlatex($delcmds->[$i][3]);
+			  @addmid=splitlatex($addcmds->[$j][3]);
+			  while (scalar(@$deltextblocks)  && $deltextblocks->[0][0]<$delcmds->[$i][1]) {
+			    my ($index,$block,$cnt)=@{ shift(@$deltextblocks) };
+			    push(@$todo, [$index,-1,$cnt,@$block]);
+			  }
+			  push(@$todo, [ $delcmds->[$i][1],-1,-1,$delcmds->[$i][2],@delmid,$delcmds->[$i][4]]);
+
+			  while (scalar(@$addtextblocks) && $addtextblocks->[0][0]<$addcmds->[$j][1]) {
+			    my ($index,$block,$cnt)=@{ shift(@$addtextblocks) };
+			    push(@$todo, [-1,$index,$cnt,@$block]);
+			  }
+			  push(@$todo, [ -1,$addcmds->[$j][1],-1,$addcmds->[$j][2],@addmid,$addcmds->[$j][4]]);
+			}
+		      }
+		      # mop up remaining textblocks
+		      while (scalar(@$deltextblocks)) {
+			my ($index,$block,$cnt)=@{ shift(@$deltextblocks) } ;
+			push(@$todo, [$index,-1,$cnt,@$block]);
+		      }
+		      while (scalar(@$addtextblocks)) {
+			my ($index,$block,$cnt)=@{ shift(@$addtextblocks) };
+			push(@$todo, [-1,$index,$cnt,@$block]);
+		      }
+		      
+		      $addblock=[];
+		      $delblock=[];
+		    }
+		    push(@$block,$seq2->[$_[1]]);  
+		    $cnt++  };
+
+  my $keyfunc = sub { join("  ",split(" ",shift())) };
+
+  traverse_sequences($seq1,$seq2, { MATCH=>$match, DISCARD_A=>$discard, DISCARD_B=>$add }, $keyfunc );
+
+
+  # now carry out the merging/splitting.  Refer to elements relative from 
+  # the end (with negative indices) as these offsets don't change before the instruction is executed
+  # cnt>0: merged small unchanged groups with previous changed blocks
+  # cnt==-1: split textual commands into components
+  foreach $instruction ( @$todo) {
+    ($last1,$last2,$cnt,@$block)=@$instruction ;
+    if ($cnt>=0) {
+      splice(@$seq1,$last1-$len1,1+$cnt,join("",$seq1->[$last1-$len1],@$block)) if $last1>=0;
+      splice(@$seq2,$last2-$len2,1+$cnt,join("",$seq2->[$last2-$len2],@$block)) if $last2>=0;
+    } else {
+      splice(@$seq1,$last1-$len1,1,@$block) if $last1>=0;
+      splice(@$seq2,$last2-$len2,1,@$block) if $last2>=0;
+    }
+  }
+
+  if ($verbose) { 
+    print STDERR "\n";
+    print STDERR "  $mattokcnt matching  tokens in $matblkcnt blocks.\n";
+    print STDERR "  $deltokcnt discarded tokens in $delblkcnt blocks.\n";
+    print STDERR "  $addtokcnt appended  tokens in $addblkcnt blocks.\n";
+  }
+}
+
+
+# extracttextblocks(\@blockindex)
+# $blockindex has the following format 
+# [ [ token1, index1 ], [token2, index2],.. ] 
+# where index refers to the index in the original old or new word sequence 
+# Returns: reference to an array of the form  
+# [[ $index, $textblock, $cnt ], ..
+# where $index index of block to be merged
+#       $textblock contains all the words to be merged with the word at $index (but does not contain this word)
+#       $cnt   is length of block
+#
+# requires: iscmd
+#
+sub extracttextblocks { 
+  my $block=shift;
+  my ($i,$token,$index);
+  my $textblock=[];
+  my $last=-1;
+  my $wpat=qr/^(?:[a-zA-Z.,'`:;?()!]*)[\s~]*$/;  #'
+  my $retval=[];
+
+  for ($i=0;$i< scalar @$block;$i++) {
+    ($token,$index)=@{ $block->[$i] };
+    # store pure text blocks
+    if ($token =~ /$wpat/ ||  ( $token =~/^\\([\w\d\*]+)((?:${extraspace}\[$brat0\]${extraspace}|${extraspace}\{$pat4\})*)/o 
+				&& iscmd($1,\@SAFECMDLIST,\@SAFECMDEXCL) 
+				&& !iscmd($1,\@TEXTCMDLIST,\@TEXTCMDEXCL))) {
+      # we have text or a command which can be treated as text
+      if ($last<0) {
+	# new pure-text block
+	$last=$index;
+      } else {
+	# add to pure-text block
+	push(@$textblock, $token); 
+      }
+    } else {
+      # it is not text
+      if (scalar(@$textblock)) {
+	push(@$retval,[ $last, $textblock, scalar(@$textblock) ]);
+      }
+      $textblock=[];
+      $last=-1;
+    }
+  }
+  # finish processing a possibly unfinished block before returning
+  if (scalar(@$textblock)) {
+    push(@$retval,[ $last, $textblock, scalar(@$textblock) ]);
+  }
+  return($retval)
+}
+
+
+
+# extractcommands( \@blockindex )
+# $blockindex has the following format 
+# [ [ token1, index1 ], [token2, index2],.. ] 
+# where index refers to the index in the original old or new word sequence 
+# Returns: reference to an array of the form  
+# [ [ "\cmd1", index, "\cmd1[optarg]{arg1}{", "arg2" ,"} " ],.. 
+# where index is just taken from input array 
+# command must have a textual argument as last argument 
+# 
+# requires: iscmd 
+# 
+sub extractcommands { 
+  my $block=shift;
+  my ($i,$token,$index,$cmd,$open,$mid,$closing);
+  my $retval=[];
+
+  for ($i=0;$i< scalar @$block;$i++) {
+    ($token,$index)=@{ $block->[$i] };
+    # check if token is an alphanumeric command sequence with at least one non-optional argument
+    # \cmd[...]{...}{last argument}  
+    # Capturing in the following results in these associations
+    # $1: \cmd[...]{...}{
+    # $2: \cmd
+    # $3: last argument
+    # $4: }  + trailing spaces
+    if ( ( $token =~ m/^(\\([\w\d\*]+)(?:${extraspace}\[$brat0\]|${extraspace}\{$pat4\})*${extraspace}\{)($pat4)(\}\s*)$/so )
+	 && iscmd($2,\@TEXTCMDLIST,\@TEXTCMDEXCL) ) {
+      #      push(@$retval,[ $2,$index,$1,$3,$4 ]);
+      ($cmd,$open,$mid,$closing) = ($2,$1,$3,$4) ;
+      $closing =~ s/\}/\\RIGHTBRACE/ ;
+      push(@$retval,[ $cmd,$index,$open,$mid,$closing ]);
+    }
+  }
+  return $retval;
+}
+
+# iscmd($cmd,\@regexarray,\@regexexcl) checks
+# return 1 if $cmd matches any of the patterns in the 
+# array $@regexarray, and none of the patterns in \@regexexcl, otherwise return 0
+sub iscmd {
+  my ($cmd,$regexar,$regexexcl)=@_;
+  my ($ret)=0;
+  foreach $pat ( @$regexar ) {
+    if ( $cmd =~ m/^${pat}$/ ) {
+      $ret=1 ; 
+      last;
+    }
+  }
+  return 0 unless $ret;
+  foreach $pat ( @$regexexcl ) {
+    return 0 if ( $cmd =~ m/^${pat}$/ );
+  }
+  return 1;
+}
+
+
+# pass2( \@seq1,\@seq2)
+# Look for differences between seq1 and seq2.  
+# Mark begin and end of deleted and appended sequences with tags $DELOPEN and $DELCLOSE
+# and $ADDOPEN and $ADDCLOSE, respectively, however exclude { } & and all comands, unless
+# they match an element of the whitelist (SAFECMD)
+# For words in TEXTCMD but not in SAFECMD, enclose interior with $ADDOPEN and $ADDCLOSE brackets
+# Deleted comment lines are marked with %DIF < 
+# Added comment lines are marked with %DIF > 
+sub pass2 {
+  my $seq1 = shift ;
+  my $seq2 = shift ;
+
+  my ($addtokcnt,$deltokcnt,$mattokcnt)=(0,0,0);
+  my ($addblkcnt,$delblkcnt,$matblkcnt)=(0,0,0);
+
+  my $retval = [];
+  my $delhunk   = [];
+  my $addhunk   = [];
+
+  my $discard = sub { $deltokcnt++;
+                      push ( @$delhunk, $seq1->[$_[0]]) };
+
+  my $add = sub { $addtokcnt++;
+                  push ( @$addhunk, $seq2->[$_[1]]) };
+
+  my $match = sub { $mattokcnt++;
+		    if ( scalar @$delhunk ) {
+                      $delblkcnt++;
+		      # mark up changes, but comment out commands
+                      push @$retval,marktags($DELMARKOPEN,$DELMARKCLOSE,$DELOPEN,$DELCLOSE,$DELCMDOPEN,$DELCMDCLOSE,$DELCOMMENT,$delhunk);
+		      $delhunk = [];
+		    }
+                    if ( scalar @$addhunk ) {
+                      $addblkcnt++;
+                      # we mark up changes, but simply quote commands
+                      push @$retval,marktags($ADDMARKOPEN,$ADDMARKCLOSE,$ADDOPEN,$ADDCLOSE,"","",$ADDCOMMENT,$addhunk);
+		      $addhunk = [];
+		    }
+		    push(@$retval,$seq2->[$_[1]]) };
+ 
+  my $keyfunc = sub { join("  ",split(" ",shift())) };
+
+  traverse_sequences($seq1,$seq2, { MATCH=>$match, DISCARD_A=>$discard, DISCARD_B=>$add }, $keyfunc );
+  # clear up unprocessed hunks
+  push @$retval,marktags($DELMARKOPEN,$DELMARKCLOSE,$DELOPEN,$DELCLOSE,$DELCMDOPEN,$DELCMDCLOSE,$DELCOMMENT,$delhunk) if scalar @$delhunk;
+  push @$retval,marktags($ADDMARKOPEN,$ADDMARKCLOSE,$ADDOPEN,$ADDCLOSE,"","",$ADDCOMMENT,$addhunk) if scalar @$addhunk;
+
+
+  if ($verbose) { 
+    print STDERR "\n";
+    print STDERR "  $mattokcnt matching  tokens. \n";
+    print STDERR "  $deltokcnt discarded tokens in $delblkcnt blocks.\n";
+    print STDERR "  $addtokcnt appended  tokens in $addblkcnt blocks.\n";
+  }
+
+  return(@$retval);
+}
+
+# marktags($openmark,$closemark,$open,$close,$opencmd,$closecmd,$comment,\@block)
+# returns ($openmark,$open,$block,$close,$closemark) if @block only contains no commands (except white-listed ones),
+# braces, ampersands, or comments
+# mark comments with $comment
+# exclude all other exceptions from scope of open, close like this
+# ($openmark, $open,...,$close, $opencomd,command, command,$closecmd, $open, ..., $close, $closemark)
+# If $opencmd begins with "%" marktags assumes it is operating on a deleted block, otherwise on an added block
+sub marktags {
+  my ($openmark,$closemark,$open,$close,$opencmd,$closecmd,$comment,$block)=@_;
+  my $word;
+  my (@argtext);
+  my $retval=[];
+  my $noncomment=0;
+  my $cmd=-1;    # -1 at beginning 0: last token written is a ordinary word 
+                 # 1: last token written is a command
+                # for keeping track whether we are just in a command sequence or in a word sequence
+  my $cmdcomment= ($opencmd =~ m/^%/);  # Flag to indicate whether opencmd is a comment (i.e. if we intend to simply comment out changed commands)
+  my ($command,$commandword,$closingbracket) ; # temporary variables needed below to remember sub-pattern matches
+
+# split this block to flatten out sequences joined in pass1
+  @$block=splitlatex(join "",@$block);
+  foreach (@$block) {
+    $word=$_; 
+    if ( $word =~ s/^%/%$comment/ ) {
+      # a comment
+      if ($cmd==1) {
+	push (@$retval,$closecmd) ;
+	$cmd=-1;
+      }
+      push (@$retval,$word); 
+      next;
+    }
+    if (! $noncomment) {
+      push (@$retval,$openmark); 
+      $noncomment=1;
+    }
+    # negative lookahead pattern (?!) in second clause is put in to avoid mathcing \( .. \) patterns
+    if ( $word =~ /^[&{}\[\]]/ || ( $word =~ /^\\(?!\()([\w*@]*)/ && !iscmd($1,\@SAFECMDLIST,\@SAFECMDEXCL)) ) {
+      # word is a command or other significant token (not in SAFECMDLIST)
+	## same conditions as in subroutine extractcommand:
+	# check if token is an alphanumeric command sequence with at least one non-optional argument
+	# \cmd[...]{...}{last argument}  
+	# Capturing in the following results in these associations
+	# $1: \cmd[...]{...}{
+	# $2: \cmd
+	# $3: last argument
+	# $4: }  + trailing spaces
+	### pre-0.3    if ( ( $token =~ m/^(\\([\w\d\*]+)(?:\[$brat0\]|\{$pat4\})*\{)($pat4)(\}\s*)$/so )
+      if ( ( $word =~ m/^(\\([\w\d\*]+)(?:${extraspace}\[$brat0\]|${extraspace}\{$pat4\})*${extraspace}\{)($pat4)(\}\s*)$/so )
+	   && iscmd($2,\@TEXTCMDLIST,\@TEXTCMDEXCL)  && ( !$cmdcomment || !iscmd($2,\@CONTEXT2CMDLIST, \@CONTEXT2CMDEXCL) )  ) {	 
+	# word is a text command - we mark up the interior of the word. But if we are in a deleted block ($cmdcomment=1) and
+        # $2 (the command) is in context2, just treat it as an ordinary command (i.e. comment it open with $opencmd)
+        # Because we do not want to disable this command
+	# here we do not use $opencmd and $closecmd($opencmd is empty) 
+	if ($cmd==1) {
+	  push (@$retval,$closecmd) ;
+	} elsif ($cmd==0) { 
+	  push (@$retval,$close) ;
+	}
+        $command=$1; $commandword=$2; $closingbracket=$4;
+	@argtext=splitlatex($3);   # split textual argument into tokens
+	# and mark it up (but we do not need openmark and closemark)
+        # insert command with initial arguments, marked-up final argument, and closing bracket
+	if ( $cmdcomment && iscmd($commandword,\@CONTEXT1CMDLIST, \@CONTEXT1CMDEXCL) ) {
+	  # context1cmd in a deleted environment; delete command itself but keep last argument, marked up
+	  push (@$retval,$opencmd);
+	  $command =~ s/\n/\n${opencmd}/sg ; # repeat opencmd at the beginning of each line
+	  # argument, note that the additional comment character is included
+          # to suppress linebreak after opening parentheses, which is important
+          # for latexrevise
+          push (@$retval,$command,"%\n{$AUXCMD\n",marktags("","",$open,$close,$opencmd,$closecmd,$comment,\@argtext),$closingbracket);
+	} else {
+	  # normal textcmd or context1cmd in an added block
+	  push (@$retval,$command,marktags("","",$open,$close,$opencmd,$closecmd,$comment,\@argtext),$closingbracket);  
+	}
+	push (@$retval,$AUXCMD,"\n") if $cmdcomment ;
+	$cmd=-1 ;
+      } else {
+	# ordinary command
+	push (@$retval,$opencmd) if $cmd==-1 ;
+	push (@$retval,$close,$opencmd) if $cmd==0 ;
+	$word =~ s/\n/\n${opencmd}/sg if $cmdcomment ;   # if opencmd is a comment, repeat this at the beginning of every line
+	push (@$retval,$word);
+	$cmd=1;
+      }
+    } else {
+      # just an ordinary word or word in SAFECMD
+      push (@$retval,$open) if $cmd==-1 ;
+      push (@$retval,$closecmd,$open) if $cmd==1 ;
+      push (@$retval,$word);
+      $cmd=0;
+    }
+  }
+  push (@$retval,$close) if $cmd==0;
+  push (@$retval,$closecmd) if $cmd==1;
+
+  push (@$retval,$closemark) if ($noncomment);
+  return @$retval;
+}
+
+# preprocess($string, ..)
+# carry out the following pre-processing steps for all arguments:
+# 1. Remove leading white-space
+# 2. mark all first empty line (in block of several) with \PAR tokens
+# 3. Convert all '\%' into '\PERCENTAGE ' to make parsing regular expressions easier
+# 4. Convert all \verb|some verbatim text| commands (where | can be an arbitrary character)
+#    into \verb{hash}
+# 5. Convert \begin{verbatim} some verbatim text \end{verbatim} into \verbatim{hash}
+# 6. Convert _n into \SUBSCRIPTNB{n} and _{nnn} into \SUBSCRIPT{nn}
+# 7. Convert ^n into \SUPERSCRIPTNB{n} and ^{nnn} into \SUPERSCRIPT{nn}
+# 8. a. Convert $$ $$ into \begin{DOLLARDOLLAR} \end{DOLLARDOLLAR}
+#    b. Convert \[ \] into \begin{SQUAREBRACKET} \end{SQUAREBRACKET}
+
+# 9. Add final token STOP to the very end.  This is put in because the algorithm works better if the last token is identical.  This is removed again in postprocessing.
+#
+# NB: step 6 and 7 is likely to  convert some "_" inappropriately, e.g. in file
+#     names or labels but it does not matter because they are converted back in the postprocessing step
+# Returns: leading white space removed in step 1
+sub preprocess {
+  my @leadin=() ;
+  for (@_) { 
+    s/^(\s*)//s;
+    push(@leadin,$1);
+    s/\n(\s*?)\n((?:\s*\n)*)/\n$1\\PAR\n$2/g ;
+    s/(?<!\\)\\%/\\PERCENTAGE /g ;  # (?<! is negative lookbehind assertion to prevent \\% from being converted
+    s/(\\verb\*?)(\S)(.*?)\2/"${1}{". tohash(\%verbhash,"${2}${3}${2}") ."}"/esg;
+    s/\\begin\{(verbatim\*?)\}(.*?)\\end\{\1\}/"\\${1}{". tohash(\%verbhash,"${2}") . "}"/esg;
+    # Convert _n or _\cmd into \SUBSCRIPTNB{n} or \SUBSCRIPTNB{\cmd} and _{nnn} into \SUBSCRIPT{nn}
+    s/_([^{\\]|\\\w+)/\\SUBSCRIPTNB{$1}/g ;
+    s/_{($pat4)}/\\SUBSCRIPT{$1}/g ;
+    # Convert ^n into \SUPERSCRIPTNB{n} and ^{nnn} into \SUPERSCRIPT{nn}
+    s/\^([^{\\]|\\\w+)/\\SUPERSCRIPTNB{$1}/g ;
+    s/\^{($pat4)}/\\SUPERSCRIPT{$1}/g ;
+    # Convert $$ $$ into \begin{DOLLARDOLLAR} \end{DOLLARDOLLAR}
+    s/\$\$(.*?)\$\$/\\begin{DOLLARDOLLAR}$1\\end{DOLLARDOLLAR}/sg;
+    # Convert \[ \] into \begin{SQUAREBRACKET} \end{SQUAREBRACKET}
+    s/(?<!\\)\\\[/\\begin{SQUAREBRACKET}/sg;
+    s/\\\]/\\end{SQUAREBRACKET}/sg;
+    # add final token " STOP"
+    $_ .= " STOP"
+  }
+  return(@leadin);
+}
+
+#hashstring=tohash(\%hash,$string)
+# creates a hash value based on string and stores in %hash
+sub tohash {
+  my ($hash,$string)=@_;
+  my (@arr,$val);
+  my ($sum,$i)=(0,1);
+  my ($hstr);
+
+  @arr=unpack('c*',$string);
+
+  foreach $val (@arr) {
+    $sum += $i*$val;
+    $i++;
+  }
+  $hstr= "$sum";
+  if (defined($hash->{$hstr}) && $string ne $hash->{$hstr}) {
+    warn "Repeated hash value for verbatim mode in spite of different content.";
+    $hstr="-$hstr";
+  }
+  $hash->{$hstr}=$string;
+  return($hstr);
+}
+
+#string=fromhash(\%hash,$fromstring)
+# restores string value stored in hash
+#string=fromhash(\%hash,$fromstring,$prependstring)
+# additionally begins each line with prependstring
+sub fromhash {
+  my ($hash,$hstr)=($_[0],$_[1]);
+  my $retstr=$hash->{$hstr};
+  if ( $#_ >= 2) {
+    $retstr =~ s/^/$_[2]/mg;
+  }
+  return $retstr;
+}
+
+
+# postprocess($string, ..)
+# carry out the following post-processing steps for all arguments:
+# * Remove STOP token from the end
+# * Replace \RIGHTBRACE by }
+# 1. Check all deleted blocks: 
+#    a.where a deleted block contains a matching \begin and
+#      \end environment (these will be disabled by a %DIFDELCMD statements), for selected environment enable enable
+#      these commands again (such that for example displayed math in a deleted equation
+#      is properly within math mode.  For math mode environments replace numbered equation
+#      environments with their display only variety (so that equation numbers in new file and
+#      diff file are identical).  Where the correct type of math environment cannot be determined
+#      use a place holder MATHMODE
+#    b.where one of the commands matching $COUNTERCMD is used as a DIFAUXCMD, add a statement
+#      subtracting one from the respective counter to keep numbering consistent with new file
+#    Replace all MATHMODE environment commands by the correct environment to achieve matching
+#    pairs
+#    c. If in-line math mode contains array environment, enclose the whole environment in \mbox'es
+# 2. Remove DIFadd, DIFdel, DIFFaddbegin , ... from picture environments
+# 3. Convert DIFadd, DIFdel, DIFFaddbegin , ... into FL varieties
+#    within floats (currently recognised float environments: plate,table,figure
+#    plus starred varieties).
+# 4. Remove empty %DIFDELCMD < lines 
+# 4. Convert \begin{SQUAREBRACKET} \end{SQUAREBRACKET} into \[ \]
+#    Convert \begin{DOLLARDOLLAR} \end{DOLLARDOLLAR} into $$ $$
+# 5. Convert  \SUPERSCRIPTNB{n} into ^n  and  \SUPERSCRIPT{nn} into ^{nnn}
+# 6. Convert  \SUBSCRIPTNB{n} into _n  and  \SUBCRIPT{nn} into _{nnn}
+# 7. Expand hashes of verb and verbatim environments
+# 8. Convert '\PERCENTAGE ' back into '\%'
+# 9.. remove all \PAR tokens
+# 10.  package specific processing:  endfloat: make sure \begin{figure} and \end{figure} are always
+#      on a line by themselves, similarly for table environment
+#  4, undo renaming of the \begin and \end in comments
+
+#
+# Note have to manually synchronize substitution commands below and 
+# DIF.. command names in the header
+sub postprocess {
+  my ($begin,$len,$cnt,$float,$delblock,$addblock);
+  # second level blocks
+  my ($begin2,$cnt2,$len2,$eqarrayblock,$mathblock);
+
+  for (@_) { 
+
+    # change $'s in comments to something harmless
+    1 while s/(%.*)\$/$1DOLLARDIF/mg ;
+
+    # Remove final STOP token
+    s/ STOP$//;
+    # Replace \RIGHTBRACE by }    
+    s/\\RIGHTBRACE/}/g;
+    # Check all deleted blocks: where a deleted block contains a matching \begin and
+    #    \end environment (these will be disabled by a %DIFDELCMD statements), enable
+    #    these commands again (such that for example displayed math in a deleted equation
+    #    is properly within math mode.  For math mode environments replace numbered equation
+    #    environments with their display only variety (so that equation numbers in new file and
+    #    diff file are identical
+    while ( m/\\DIFdelbegin.*?\\DIFdelend/sg ) {
+      $cnt=0;
+      $len=length($&);
+      $begin=pos($_) - $len;
+      $delblock=$&;
+
+
+      ### (.*?[^\n]?)\n? construct is necessary to avoid empty lines in math mode, which result in
+      ### an error
+      # displayed math environments
+      $delblock=~ s/(\%DIFDELCMD < \s*\\begin\{((?:$MATHENV)|SQUAREBRACKET)\}\s*?(?:$DELCMDCLOSE|\n))(.*?[^\n]?)\n?(\%DIFDELCMD < \s*\\end\{\2\})/\\begin{$MATHREPL}$AUXCMD\n$1$3\n\\end{$MATHREPL}$AUXCMD\n$4/sg;
+      # also transform the opposite pair \end{displaymath} .. \begin{displaymath} but we have to be careful not to interfere with the results of the transformation in the line directly above
+      $delblock=~ s/(?<!${AUXCMD}\n)(\%DIFDELCMD < \s*\\end\{((?:$MATHENV)|SQUAREBRACKET)\}\s*?(?:$DELCMDCLOSE|\n))(.*?[^\n]?)\n?(?<!${AUXCMD}\n)(\%DIFDELCMD < \s*\\begin\{\2\})/\\end{MATHMODE}$AUXCMD\n$1$3\n\\begin{MATHMODE}$AUXCMD\n$4/sg;
+
+      # now look for unpaired %DIFDELCMD < \begin{MATHENV}; if found add \begin{$MATHREPL} and insert \end{$MATHREPL} 
+      # just before end of block; again we use look-behind assertion to avoid matching constructions which have already been converted
+      if ($delblock=~ s/(?<!${AUXCMD}\n)(\%DIFDELCMD < \s*\\begin\{((?:$MATHENV)|SQUAREBRACKET)\}\s*?(?:$DELCMDCLOSE|\n))/$1\\begin{$MATHREPL}$AUXCMD\n/sg ) {
+	$delblock =~ s/(\\DIFdelend$)/\\end{$MATHREPL}$AUXCMD\n$1/s ;
+      }
+      # now look for unpaired %DIFDELCMD < \end{MATHENV}; if found add \end{MATHMODE} and insert \begin{MATHMODE} 
+      # just before end of block; again we use look-behind assertion to avoid matching constructions which have already been converted
+      if ($delblock=~ s/(?<!${AUXCMD}\n)(\%DIFDELCMD < \s*\\end\{((?:$MATHENV)|SQUAREBRACKET)\}\s*?(?:$DELCMDCLOSE|\n))/$1\\end{MATHMODE}$AUXCMD\n/sg ) {
+	$delblock =~ s/(\\DIFdelend$)/\\begin{MATHMODE}$AUXCMD\n$1/s ;
+      }
+
+
+      # equation array environment
+      $delblock=~ s/(\%DIFDELCMD < \s*\\begin\{($MATHARRENV)\}\s*?(?:$DELCMDCLOSE|\n))(.*?[^\n]?)\n?(\%DIFDELCMD < \s*\\end\{\2\})/\\begin{$MATHARRREPL}$AUXCMD\n$1$3\n\\end{$MATHARRREPL}$AUXCMD\n$4/sg;
+      $delblock=~ s/(?<!${AUXCMD}\n)(\%DIFDELCMD < \s*\\end\{($MATHARRENV)\}\s*?(?:$DELCMDCLOSE|\n))(.*?[^\n]?)\n?(?<!${AUXCMD}\n)(\%DIFDELCMD < \s*\\begin\{\2\})/\\end{MATHMODE}$AUXCMD\n$1$3\n\\begin{MATHMODE}$AUXCMD\n$4/sg;
+
+      # now look for unpaired %DIFDELCMD < \begin{MATHARRENV}; if found add \begin{$MATHARRREPL} and insert \end{$MATHARRREPL} 
+      # just before end of block; again we use look-behind assertion to avoid matching constructions which have already been converted
+      if ($delblock=~ s/(?<!${AUXCMD}\n)(\%DIFDELCMD < \s*\\begin\{($MATHARRENV)\}\s*?(?:$DELCMDCLOSE|\n))/$1\\begin{$MATHARRREPL}$AUXCMD\n/sg ) {
+	$delblock =~ s/(\\DIFdelend$)/\\end{$MATHARRREPL}$AUXCMD\n$1/s ;
+      }
+      # now look for unpaired %DIFDELCMD < \end{MATHENV}; if found add \end{MATHMODE} and insert \begin{MATHMODE} 
+      # just before end of block; again we use look-behind assertion to avoid matching constructions which have already been converted
+      if ($delblock=~ s/(?<!${AUXCMD}\n)(\%DIFDELCMD < \s*\\end\{($MATHARRENV)\}\s*?(?:$DELCMDCLOSE|\n))/$1\\end{MATHMODE}$AUXCMD\n/sg ) {
+	$delblock =~ s/(\\DIFdelend$)/\\begin{MATHMODE}$AUXCMD\n$1/s ;
+      }
+
+      # parse $delblock for deleted and reinstated eqnarray* environments - within those reinstate \\ and & commands
+      while ( $delblock =~ m/\\begin\Q{$MATHARRREPL}$AUXCMD\E\n.*?\n\\end\Q{$MATHARRREPL}$AUXCMD\E\n/sg ) {
+	$cnt2=0;
+	$len2=length($&);
+	$begin2=pos($delblock) - $len2;
+	$eqarrayblock=$&;
+	# reinstate deleted & and \\ commands
+	$eqarrayblock=~ s/(\%DIFDELCMD < \s*(\&|\\\\)\s*?(?:$DELCMDCLOSE|\n))/$1$2$AUXCMD\n/sg ;
+
+	substr($delblock,$begin2,$len2)=$eqarrayblock;
+	pos($delblock) = $begin2 + length($eqarrayblock);
+      }
+
+
+
+#    b.where one of the commands matching $COUNTERCMD is used as a DIFAUXCMD, add a statement
+#      subtracting one from the respective counter to keep numbering consistent with new file
+      $delblock=~ s/\\($COUNTERCMD)((?:${extraspace}\[$brat0\]${extraspace}|${extraspace}\{$pat4\})*\s*${AUXCMD}\n)/\\$1$2\\addtocounter{$1}{-1}${AUXCMD}\n/sg ;
+#     c. If in-line math mode contains array environment, enclose the whole environment in \mbox'es
+      while ( $delblock =~ m/($math)(\s*)/sg ) {
+	$cnt2=0;
+	$len2=length($&);
+	$begin2=pos($delblock) - $len2;
+	$mathblock="%\n\\mbox{$AUXCMD\n$1\n}$AUXCMD\n";
+        next unless $mathblock =~ m/\{$ARRENV\}/ ;
+	substr($delblock,$begin2,$len2)=$mathblock;
+	pos($delblock) = $begin2 + length($mathblock);
+      }
+
+#     splice in modified delblock
+      substr($_,$begin,$len)=$delblock;
+      pos = $begin + length($delblock);
+    }
+    # make the array modification in added blocks
+    while ( m/\\DIFaddbegin.*?\\DIFaddend/sg ) {
+      $cnt=0;
+      $len=length($&);
+      $begin=pos($_) - $len;
+      $addblock=$&;
+      while ( $addblock =~ m/($math)(\s*)/sg ) {
+	$cnt2=0;
+	$len2=length($&);
+	$begin2=pos($addblock) - $len2;
+	$mathblock="%\n\\mbox{$AUXCMD\n$1\n}$AUXCMD\n";
+        next unless $mathblock =~ m/\{$ARRENV\}/ ;
+	substr($addblock,$begin2,$len2)=$mathblock;
+	pos($addblock) = $begin2 + length($mathblock);
+      }
+
+#     splice in modified addblock
+      substr($_,$begin,$len)=$addblock;
+      pos = $begin + length($addblock);
+    }
+
+
+    ### old place for BEGINDIF, ENDDIF replacement
+    # change begin and end commands  within comments such that they
+    # don't disturb the pattern matching (if there are several \begin or \end in one line
+    # this substitution is insufficient but that appears unlikely)
+    s/(%.*)\\begin\{(.*)$/$1\\BEGINDIF\{$2/mg ;
+    s/(%.*)\\end\{(.*)$/$1\\ENDDIF\{$2/mg ;
+
+    # Replace MATHMODE environments from step 1a above by the correct Math environment
+
+    # The next line is complicated.  The negative look-ahead insertion makes sure that no \end{$MATHENV} (or other mathematical
+    # environments) are between the \begin{$MATHENV} and \end{MATHMODE} commands. This is necessary as the minimal matching 
+    # is not globally minimal but only 'locally' (matching is beginning from the left side of the string)
+    1 while s/\\begin{((?:$MATHENV)|(?:$MATHARRENV)|SQUAREBRACKET)}((?:.(?!(?:\\end{(?:(?:$MATHENV)|(?:$MATHARRENV)|SQUAREBRACKET)}|\\begin{MATHMODE})))*?)\\end{MATHMODE}/\\begin{$1}$2\\end{$1}/s;
+    1 while s/\\begin{MATHMODE}((?:.(?!\\end{MATHMODE}))*?)\\end{((?:$MATHENV)|(?:$MATHARRENV)|SQUAREBRACKET)}/\\begin{$2}$1\\end{$2}/s;
+    # convert remaining \begin{MATHMODE} \end{MATHMODE} (and not containing & or \\ )into MATHREPL environments
+    s/\\begin{MATHMODE}((?:(.(?!(?<!\\)\&|\\\\))*)?)\\end{MATHMODE}/\\begin{$MATHREPL}$1\\end{$MATHREPL}/sg;
+    # others into MATHARRREPL
+    s/\\begin{MATHMODE}(.*?)\\end{MATHMODE}/\\begin{$MATHARRREPL}$1\\end{$MATHARRREPL}/sg;
+
+    # now look for AUXCMD math-mode pairs which have only comments (or empty lines between them), and remove the added commands
+    s/\\begin{((?:$MATHENV)|(?:$MATHARRENV)|SQUAREBRACKET)}$AUXCMD\n((?:\s*%.[^\n]*\n)*)\\end{\1}$AUXCMD\n/$2/sg; 
+
+
+    # Remove all mark up within picture environments
+    while ( m/\\begin\{($PICTUREENV)\}.*?\\end\{\1\}/sg ) {
+      $cnt=0;
+      $len=length($&);
+      $begin=pos($_) - $len;
+      $float=$&;
+      $float =~ s/\\DIFaddbegin //g;
+      $float =~ s/\\DIFaddend //g;
+      $float =~ s/\\DIFadd\{($pat4)\}/$1/g;
+      $float =~ s/\\DIFdelbegin //g;
+      $float =~ s/\\DIFdelend //g;
+      $float =~ s/\\DIFdel\{($pat4)\}//g;
+      substr($_,$begin,$len)=$float;
+      pos = $begin + length($float);
+    }
+    # Convert DIFadd, DIFdel, DIFFaddbegin , ... into  varieties
+    #    within floats (currently recognised float environments: plate,table,figure
+    #    plus starred varieties).
+    while ( m/\\begin\{($FLOATENV)\}.*?\\end\{\1\}/sg ) {
+      $cnt=0;
+      $len=length($&);
+      $begin=pos($_) - $len;
+      $float=$&;
+      $float =~ s/\\DIFaddbegin /\\DIFaddbeginFL /g;
+      $float =~ s/\\DIFaddend /\\DIFaddendFL /g;
+      $float =~ s/\\DIFadd\{/\\DIFaddFL{/g;
+      $float =~ s/\\DIFdelbegin /\\DIFdelbeginFL /g;
+      $float =~ s/\\DIFdelend /\\DIFdelendFL /g;
+      $float =~ s/\\DIFdel\{/\\DIFdelFL{/g;
+      substr($_,$begin,$len)=$float;
+      pos = $begin + length($float);
+    }
+    ### former location of undo renaming of \begin and \end in comments
+
+    # remove empty DIFCMD < lines
+    s/^\Q${DELCMDOPEN}\E\n//msg;
+
+    # Expand hashes of verb and verbatim environments (note negative look behind assertion to not leak out of DIFDELCMD comments
+    s/(\\verb\*?)\{([-\d]*?)\}/"${1}". fromhash(\%verbhash,$2)/esg;
+    s/${DELCMDOPEN}\\(verbatim\*?)\{([-\d]*?)\}/"${DELCMDOPEN}\\begin{${1}}".fromhash(\%verbhash,$2,$DELCMDOPEN)."${DELCMDOPEN}\\end{${1}}"/esg;
+    s/\\(verbatim\*?)\{([-\d]*?)\}/"\\begin{${1}}".fromhash(\%verbhash,$2)."\\end{${1}}"/esg;
+    # Convert '\PERCENTAGE ' back into '\%'			       
+    s/\\PERCENTAGE /\\%/g;
+    # remove all \PAR tokens (taking care to properly keep commented out PAR's
+    # from introducing uncommented newlines - next line)
+    s/(%DIF < )([^\n]*?)\\PAR\n/$1$2\n$1\n/sg;
+    # convert PAR commands which are on a line by themselves
+    s/\n(\s*?)\\PAR\n/\n\n/sg;
+    # convert remaining PAR commands (which are preceded by non-white space characters, usually "}" ($ADDCLOSE)
+    s/\\PAR\n/\n\n/sg;
+
+    #  package specific processing: 
+    if ( defined($packages{"endfloat"})) {
+      #endfloat: make sure \begin{figure} and \end{figure} are always
+      #      on a line by themselves, similarly for table environment
+      print STDERR "endfloat package detected.\n" if $verbose ;
+      # eliminate whitespace before and after
+      s/^(\s*)(\\(?:begin|end)\{(?:figure|table)\})(\s*)$/$2/mg;
+      # split lines with remaining characters before float enviroment conmmand
+      s/^(.+)(\\(?:begin|end)\{(?:figure|table)\})/$1\n$2/mg;
+      # split lines with remaining characters after float enviroment conmmand
+      s/(\\(?:begin|end)\{(?:figure|table)\})(.+)$/$1\n$2/mg;
+    }
+    # undo renaming of the \begin and \end  and dollars in comments 
+    s/(%.*)\\BEGINDIF\{(.*)$/$1\\begin\{$2/mg ;
+    s/(%.*)\\ENDDIF\{(.*)$/$1\\end\{$2/mg ;
+    1 while s/(%.*)DOLLARDIF/$1\$/mg ;
+#   Convert \begin{SQUAREBRACKET} \end{SQUAREBRACKET} into \[ \]
+    s/\\end{SQUAREBRACKET}/\\\]/sg;
+    s/\\begin{SQUAREBRACKET}/\\\[/sg;
+# 4. Convert \begin{DOLLARDOLLAR} \end{DOLLARDOLLAR} into $$ $$
+    s/\\begin\{DOLLARDOLLAR\}(.*?)\\end\{DOLLARDOLLAR\}/\$\$$1\$\$/sg;
+# 5. Convert  \SUPERSCRIPTNB{n} into ^n  and  \SUPERSCRIPT{nn} into ^{nnn}
+    s/\\SUPERSCRIPTNB{($pat0)}/^$1/g ;
+    s/\\SUPERSCRIPT{($pat4)}/^{$1}/g ;
+    # Convert  \SUBSCRIPNB{n} into _n  and  \SUBCRIPT{nn} into _{nnn}
+    s/\\SUBSCRIPTNB{($pat0)}/_$1/g ;
+    s/\\SUBSCRIPT{($pat4)}/_{$1}/g ;
+
+  return;
+  }
+}
+
+
+# @diffs=linediff(\@seq1, \@seq2)
+# mark up lines like this
+#%DIF mm-mmdnn
+#%< old deleted line(s)
+#%DIF -------
+#%DIF mmann-nn
+#new appended line %< 
+#%DIF -------
+# Future extension: mark change explicitly
+# Assumes: traverse_sequence traverses deletions before insertions in changed sequences
+#          all line numbers relative to line 0 (first line of real file)
+sub linediff {
+  my $seq1 = shift ;
+  my $seq2 = shift ;
+
+  my $block = [];
+  my $retseq = [];
+  my @begin=('','',''); # dummy initialisation
+  my $instring ; 
+
+  my $discard = sub { @begin=('d',$_[0],$_[1]) unless scalar @$block ; 
+                      push(@$block, "%DIF < " . $seq1->[$_[0]]) };
+  my $add = sub { if (! scalar  @$block) {
+		    @begin=('a',$_[0],$_[1]) ;}
+		  elsif ( $begin[0] eq 'd' ) {
+                    $begin[0]='c'; $begin[2]=$_[1];
+		    push(@$block, "%DIF -------") }
+                  push(@$block,  $seq2->[$_[1]] . " %DIF > " ) };
+  my $match = sub { if ( scalar @$block ) {
+                      if ( $begin[0] eq 'd' && $begin[1]!=$_[0]-1) {
+			$instring = sprintf "%%DIF %d-%dd%d",$begin[1],$_[0]-1,$begin[2]; }
+		      elsif ( $begin[0] eq 'a' && $begin[2]!=$_[1]-1) {
+			$instring = sprintf "%%DIF %da%d-%d",$begin[1],$begin[2],$_[1]-1; }
+		      elsif ( $begin[0] eq 'c' ) {
+			$instring = sprintf "%%DIF %sc%s",
+			                     ($begin[1]==$_[0]-1) ? "$begin[1]" : $begin[1]."-".($_[0]-1)  , 
+			                     ($begin[2]==$_[1]-1) ? "$begin[2]" : $begin[2]."-".($_[1]-1)  ; }
+		      else {
+			$instring = sprintf "%%DIF %d%s%d",$begin[1],$begin[0],$begin[2]; }
+		      push @$retseq, $instring,@$block, "%DIF -------" ; 
+		      $block = []; 
+		    }
+		    push @$retseq, $seq2->[$_[1]]
+		  };
+  # key function: remove multiple spaces (such that insertion or deletion of redundant white space is not reported)
+  my $keyfunc = sub { join("  ",split(" ",shift())) };
+
+  traverse_sequences($seq1,$seq2, { MATCH=>$match, DISCARD_A=>$discard, DISCARD_B=>$add }, $keyfunc );
+  push @$retseq, @$block if scalar @$block; 
+
+  return wantarray ? @$retseq : $retseq ;
+}
+
+
+
+# init_regex_arr_data(\@array,"TOKEN INIT")
+# scans DATA file handel for line "%% TOKEN INIT" line
+# then appends each line not beginning with % into array (as a quoted regex)
+sub init_regex_arr_data {
+  my ($arr,$token)=@_;
+  my ($copy);
+  while (<DATA>) {
+    if ( m/^%%BEGIN $token\s*$/ ) {
+      $copy=1; }
+    elsif ( m/^%%END $token\s*/ )  {
+      last; }
+    chomp;
+    push (@$arr,qr/^$_$/) if ( $copy && !/^%/ ) ;
+  }
+  seek DATA,0,0;    # rewind DATA handle to file begin
+}
+
+
+# init_regex_arr_ext(\@array,$arg)
+# fills array with regular expressions.
+# if arg is a file name, then read in list of regular expressions from that file
+# (one expression per line)
+# Otherwise treat arg as a comma separated list of regular expressions
+sub init_regex_arr_ext {
+  my ($arr,$arg)=@_;
+  my $regex;
+  if ( -f $ arg ) {
+    open(FILE,"$arg") or die ("Couldn't open $arg: $!");
+    while (<FILE>) {
+      chomp;
+      next if /^\s*#/ || /^\s*%/ || /^\s*$/ ;
+      push (@$arr,qr/^$_$/);
+    }
+    close(FILE);
+  }
+  else {
+    # assume it is a comma-separated list of reg-ex
+    foreach $regex (split(qr/(?<!\\),/,$arg)) {
+      $regex =~ s/\\,/,/g;
+      push (@$arr,qr/^$regex$/);
+    }
+  }
+}
+
+#exetime() returns time since last execution of this command
+#exetime(1) resets this time
+my $lasttime=-1;   # global variable for persistence
+sub exetime {
+  my $reset=0;
+  my $retval;
+  if ((scalar @_) >=1) {
+    $reset=shift;
+  }
+  if ($reset) {
+    $lasttime=times();
+  }
+  else {
+    $retval=times()-$lasttime;
+    $lasttime=$lasttime+$retval;
+    return($retval);
+  }
+}
+
+
+sub usage {
+  die <<"EOF"; 
+Usage: $0 [options] old.tex new.tex > diff.tex
+
+Compares two latex files and writes tex code to stdout, which has the same
+format as new.tex but has all changes relative to old.tex marked up or commented.
+
+--type=markupstyle
+-t markupstyle         Add code to preamble for selected markup style
+                       Available styles: UNDERLINE CTRADITIONAL TRADITIONAL CFONT FONTSTRIKE INVISIBLE 
+                                         CHANGEBAR CCHANGEBAR CULINECHBAR CFONTCBHBAR
+                       [ Default: UNDERLINE ]
+
+--subtype=markstyle
+-s markstyle           Add code to preamble for selected style for bracketing
+                       commands (e.g. to mark changes in  margin)
+                       Available styles: SAFE MARGINAL DVIPSCOL
+                       [ Default: SAFE ]
+
+--floattype=markstyle
+-f markstyle           Add code to preamble for selected style which 
+                       replace standard marking and markup commands within floats
+                       (e.g., marginal remarks cause an error within floats
+                       so marginal marking can be disabled thus)
+                       Available styles: FLOATSAFE IDENTICAL
+                       [ Default: FLOATSAFE ]
+
+--encoding=enc
+-e enc                 Specify encoding of old.tex and new.tex. Typical encodings are
+                       ascii, utf8, latin1, latin9.  A list of available encodings can be 
+                       obtained by executing 
+                       perl -MEncode -e 'print join ("\\n",Encode->encodings( ":all" )) ;'
+                       [Default encoding is utf8 unless the first few lines of the preamble contain
+                       an invocation "\\usepackage[..]{inputenc} in which case the 
+                       encoding chosen by this command is asssumed. Note that ASCII (standard
+                       latex) is a subset of utf8]
+
+--preamble=file
+-p file                Insert file at end of preamble instead of auto-generating
+                       preamble.  The preamble must define the following commands
+                       \\DIFaddbegin,\\DIFaddend,\\DIFadd{..},
+                       \\DIFdelbegin,\\DIFdelend,\\DIFdel{..},
+                       and varieties for use within floats
+                       \\DIFaddbeginFL,\\DIFaddendFL,\\DIFaddFL{..},
+                       \\DIFdelbeginFL,\\DIFdelendFL,\\DIFdelFL{..}
+                       (If this option is set -t, -s, and -f options
+                       are ignored.)
+
+--exclude-safecmd=exclude-file
+--exclude-safecmd="cmd1,cmd2,..."
+-A exclude-file 
+--replace-safecmd=replace-file
+--append-safecmd=append-file
+--append-safecmd="cmd1,cmd2,..."
+-a append-file         Exclude from, replace or append to the list of regex
+                       matching commands which are safe to use within the 
+                       scope of a \\DIFadd or \\DIFdel command.  The file must contain
+                       one Perl-RegEx per line (Comment lines beginning with # or % are
+                       ignored). A literal comma within the comma-separated list must be
+                       escaped thus "\\,",   Note that the RegEx needs to match the whole of 
+                       the token, i.e., /^regex\$/ is implied and that the initial
+                       "\\" of the command is not included. The --exclude-safecmd
+                       and --append-safecmd options can be combined with the --replace-safecmd 
+                       option and can be used repeatedly to add cumulatively to the lists.
+
+--exclude-textcmd=exclude-file 
+--exclude-textcmd="cmd1,cmd2,..."
+-X exclude-file
+--replace-textcmd=replace-file
+--append-textcmd=append-file
+--append-textcmd="cmd1,cmd2,..."
+-x append-file         Exclude from, replace or append to the list of regex
+                       matching commands whose last argument is text.  See
+                       entry for --exclude-safecmd directly above for further details.
+
+--replace-context1cmd=replace-file
+--append-context1cmd=append-file
+--append-context1cmd="cmd1,cmd2,..."
+                       Replace or append to the list of regex matching commands
+                       whose last argument is text but which require a particular
+                       context to work, e.g. \\caption will only work within a figure
+                       or table.  These commands behave like text commands, except when 
+                       they occur in a deleted section, when they are disabled, but their
+                       argument is shown as deleted text.
+
+--replace-context2cmd=replace-file
+--append-context2cmd=append-file
+--append-context2cmd="cmd1,cmd2,..."
+                       As corresponding commands for context1.  The only difference is that
+                       context2 commands are completely disabled in deleted sections, including
+                       their arguments.
+
+
+--config var1=val1,var2=val2,...
+-c var1=val1,..        Set configuration variables.
+-c configfile           Available variables: 
+                          MINWORDSBLOCK (integer)
+                          FLOATENV (RegEx)
+                          PICTUREENV (RegEx)
+                          MATHENV (RegEx)
+                          MATHREPL (String)
+                          MATHARRENV (RegEx)
+                          MATHARRREPL (String)
+                          ARRENV (RegEx)
+                          COUNTERCMD (RegEx)
+                       This option can be repeated.
+
+
+--packages=pkg1,pkg2,..
+                       Tell latexdiff that .tex file is processed with the packages in list 
+                       loaded.  This is normally not necessary if the .tex file includes the
+                       preamble, as the preamble is automatically scanned for \\usepackage commands.
+                       Use of the --packages option disables automatic scanning, so if for any
+                       reason package specific parsing needs to be switched off, use --packages=none.
+                       The following packages trigger special behaviour:
+                       endfloat hyperref amsmath
+                       [ Default: scan the preamble for \\usepackage commands to determine
+                         loaded packages.]
+
+--show-preamble        Print generated or included preamble commands to stdout.
+
+--show-safecmd         Print list of regex matching and excluding safe commands.
+
+--show-textcmd         Print list of regex matching and excluding commands with text argument.
+
+--show-config          Show values of configuration variables
+
+--show-all             Show all of the above
+
+   NB For all --show commands, no old.tex or new.tex file needs to be given, and no 
+      differencing takes place.
+
+--allow-spaces         Allow spaces between bracketed or braced arguments to commands
+                       [Default requires arguments to directly follow each other without 
+                                intervening spaces]
+
+--flatten              Replace \\input and \\include commands within body by the content
+                       of the files in their argument.  If \\includeonly is present in the
+                       preamble, only those files are expanded into the document. However, 
+                       no recursion is done, i.e. \\input and \\include commands within 
+                       included sections are not expanded.  The included files are assumed to 
+                       be located in the same directories as the old and new master files,
+                       respectively, making it possible to organise files into old and new directories.
+
+--help
+-h                     Show this help text.
+
+--ignore-warnings      Suppress warnings about inconsistencies in length between input
+                       and parsed strings and missing characters. 
+
+--verbose
+-V                     Output various status information to stderr during processing.
+                       Default is to work silently.
+
+--version              Show version number.
+EOF
+}
+
+=head1 NAME
+
+latexdiff - determine and markup differences between two latex files
+
+=head1 SYNOPSIS
+
+B<latexdiff> [ B<OPTIONS> ] F<old.tex> F<new.tex> > F<diff.tex>
+
+=head1 DESCRIPTION
+
+Briefly, I<latexdiff> is a utility program to aid in the management of
+revisions of latex documents. It compares two valid latex files, here
+called C<old.tex> and C<new.tex>, finds significant differences
+between them (i.e., ignoring the number of white spaces and position
+of line breaks), and adds special commands to highlight the
+differences.  Where visual highlighting is not possible, e.g. for changes
+in the formatting, the differences are
+nevertheless marked up in the source.
+
+The program treats the preamble differently from the main document.
+Differences between the preambles are found using line-based
+differencing (similarly to the Unix diff command, but ignoring white
+spaces).  A comment, "S<C<%DIF E<gt>>>" is appended to each added line, i.e. a 
+line present in C<new.tex> but not in C<old.tex>.  Discarded lines 
+ are deactivated by prepending "S<C<%DIF E<lt>>>". Changed blocks are preceded  by
+comment lines giving information about line numbers in the original files.  Where there are insignificant
+differences, the resulting file C<diff.tex> will be similar to
+C<new.tex>.  At the end of the preamble, the definitions for I<latexdiff> markup commands are inserted.
+In differencing the main body of the text, I<latexdiff> attempts to
+satisfy the following guidelines (in order of priority):
+
+=over 3
+
+=item 1
+
+If both C<old.tex> and C<new.tex> are valid LaTeX, then the resulting
+C<diff.tex> should also be valid LateX. (NB If a few plain TeX commands
+are used within C<old.tex> or C<new.tex> then C<diff.tex> is not
+guaranteed to work but usually will).
+
+=item 2
+
+Significant differences are determined on the level of
+individual words. All significant differences, including differences
+between comments should be clearly marked in the resulting source code
+C<diff.tex>.
+
+=item 3
+
+If a changed passage contains text or text-producing commands, then
+running C<diff.tex> through LateX should produce output where added
+and discarded passages are highlighted.
+
+=item 4
+
+Where there are insignificant differences, e.g. in the positioning of
+line breaks, C<diff.tex> should follow the formatting of C<new.tex>
+
+=back
+
+For differencing the same algorithm as I<diff> is used but words
+instead of lines are compared.  An attempt is made to recognize
+blocks which are completely changed such that they can be marked up as a unit.
+Comments are differenced line by line
+but the number of spaces within comments is ignored. Commands including
+all their arguments are generally compared as one unit, i.e., no mark-up
+is inserted into the arguments of commands.  However, for a selected
+number of commands (for example, C<\caption> and all sectioning
+commands) the last argument is known to be text. This text is
+split into words and differenced just as ordinary text (use options to
+show and change the list of text commands, see below). As the
+algorithm has no detailed knowledge of LaTeX, it assumes all pairs of
+curly braces immediately following a command (i.e. a sequence of
+letters beginning with a backslash) are arguments for that command.
+As a restriction to condition 1 above it is thus necessary to surround
+all arguments with curly braces, and to not insert
+extraneous spaces.  For example, write 
+
+  \section{\textem{This is an emphasized section title}}
+
+and not
+
+  \section {\textem{This is an emphasized section title}}
+
+or
+
+  \section\textem{This is an emphasized section title}
+
+even though all varieties are the same to LaTeX (but see
+B<--allow-spaces> option which allows the second variety).
+
+For environments whose content does not conform to standard LaTeX or
+where graphical markup does not make sense all markup commands can be
+removed by setting the PICTUREENV configuration variable, set by
+default to C<picture> and C<DIFnomarkup> environments; see B<--config>
+option).  The latter environment (C<DIFnomarkup>) can be used to
+protect parts of the latex file where the markup results in illegal
+markup. You have to surround the offending passage in both the old and
+new file by C<\begin{DIFnomarkup}> and C<\end{DIFnomarkup}>. You must
+define the environment in the preambles of both old and new
+documents. I prefer to define it as a null-environment,
+
+C<\newenvironment{DIFnomarkup}{}{}>
+
+but the choice is yours.  Any markup within the environment will be
+removed, and generally everything within the environment will just be
+taken from the new file.
+
+It is also possible to difference files which do not have a preamble. 
+ In this case, the file is processed in the main document
+mode, but the definitions of the markup commands are not inserted.
+
+All markup commands inserted by I<latexdiff> begin with "C<\DIF>".  Added
+blocks containing words, commands or comments which are in C<new.tex>
+but not in C<old.tex> are marked by C<\DIFaddbegin> and C<\DIFaddend>.
+Discarded blocks are marked by C<\DIFdelbegin> and C<\DIFdelend>.
+Within added blocks all text is highlighted with C<\DIFadd> like this:
+C<\DIFadd{Added text block}>
+Selected `safe' commands can be contained in these text blocks as well
+(use options to show and change the list of safe commands, see below).
+All other commands as well as braces "{" and "}" are never put within
+the scope of C<\DIFadd>.  Added comments are marked by prepending
+"S<C<%DIF E<gt> >>".
+
+Within deleted blocks text is highlighted with C<\DIFdel>.  Deleted
+comments are marked by prepending "S<C<%DIF E<lt> >>".  Non-safe command
+and curly braces within deleted blocks are commented out with 
+"S<C<%DIFDELCMD E<lt> >>".
+
+
+
+=head1 OPTIONS
+
+=head2 Preamble
+
+The following options determine the visual markup style by adding the appropriate
+command definitions to the preamble. See the end of this section for a description of 
+available styles.
+
+=over 4
+
+=item B<--type=markupstyle> or
+B<-t markupstyle>
+
+Add code to preamble for selected markup style. This option defines
+C<\DIFadd> and C<\DIFdel> commands.
+Available styles: 
+
+C<UNDERLINE CTRADITIONAL TRADITIONAL CFONT FONTSTRIKE INVISIBLE 
+CHANGEBAR CCHANGEBAR CULINECHBAR CFONTCBHBAR>
+
+[ Default: C<UNDERLINE> ]
+
+=item B<--subtype=markstyle> or
+B<-s markstyle> 
+
+Add code to preamble for selected style for bracketing
+commands (e.g. to mark changes in  margin). This option defines
+C<\DIFaddbegin>, C<\DIFaddend>, C<\DIFdelbegin> and C<\DIFdelend> commands.
+Available styles: C<SAFE MARGINAL DVIPSCOL>
+
+[ Default: C<SAFE> ]
+
+=item B<--floattype=markstyle> or
+B<-f markstyle>
+
+Add code to preamble for selected style which 
+replace standard marking and markup commands within floats
+(e.g., marginal remarks cause an error within floats
+so marginal marking can be disabled thus). This option defines all 
+C<\DIF...FL> commands.
+Available styles: C<FLOATSAFE TRADITIONALSAFE IDENTICAL>
+
+[ Default: C<FLOATSAFE> ]
+
+=item B<--encoding=enc> or 
+B<-e enc>
+
+Specify encoding of old.tex and new.tex. Typical encodings are
+C<ascii>, C<utf8>, C<latin1>, C<latin9>.  A list of available encodings can be 
+obtained by executing 
+
+C<perl -MEncode -e 'print join ("\n",Encode->encodings( ":all" )) ;' >
+
+[Default encoding is utf8 unless the first few lines of the preamble contain
+an invocation C<\usepackage[..]{inputenc}> in which case the 
+encoding chosen by this command is asssumed. Note that ASCII (standard
+latex) is a subset of utf8]
+
+=item B<--preamble=file> or
+B<-p file>
+
+Insert file at end of preamble instead of generating
+preamble.  The preamble must define the following commands
+C<\DIFaddbegin, \DIFaddend, \DIFadd{..},
+\DIFdelbegin,\DIFdelend,\DIFdel{..},>
+and varieties for use within floats
+C<\DIFaddbeginFL, \DIFaddendFL, \DIFaddFL{..},
+\DIFdelbeginFL, \DIFdelendFL, \DIFdelFL{..}>
+(If this option is set B<-t>, B<-s>, and B<-f> options
+are ignored.)
+
+=item B<--packages=pkg1,pkg2,..> 
+
+Tell latexdiff that .tex file is processed with the packages in list
+loaded.  This is normally not necessary if the .tex file includes the
+preamble, as the preamble is automatically scanned for C<\usepackage> commands.
+Use of the B<--packages> option disables automatic scanning, so if for any
+reason package specific parsing needs to be switched off, use B<--packages=none>.
+The following packages trigger special behaviour:
+
+=over 8
+
+=item C<amsmath> 
+
+Configuration variable amsmath is set to C<align*> (Default: C<eqnarray*>)
+
+=item C<endfloat> 
+
+Ensure that C<\begin{figure}> and C<\end{figure}> always appear by themselves on a line.
+
+=item C<hyperref>
+
+Change name of C<\DIFadd> and C<\DIFdel> commands to C<\DIFaddtex> and C<\DIFdeltex> and 
+define new C<\DIFadd> and C<\DIFdel> commands, which provide a wrapper for these commands,
+using them for the text but not for the link defining command (where any markup would cause
+errors).
+
+=back
+
+[ Default: scan the preamble for C<\\usepackage> commands to determine
+  loaded packages.]
+
+
+
+=item B<--show-preamble>
+
+Print generated or included preamble commands to stdout.
+
+=back
+
+=head2 Configuration
+
+=over 4
+
+=item B<--exclude-safecmd=exclude-file> or
+B<-A exclude-file> or  B<--exclude-safecmd="cmd1,cmd2,...">
+
+=item B<--replace-safecmd=replace-file>
+
+=item B<--append-safecmd=append-file> or 
+B<-a append-file> or B<--append-safecmd="cmd1,cmd2,...">
+
+Exclude from, replace or append to the list of regular expressions (RegEx)
+matching commands which are safe to use within the 
+scope of a C<\DIFadd> or C<\DIFdel> command.  The file must contain
+one Perl-RegEx per line (Comment lines beginning with # or % are
+ignored).  Note that the RegEx needs to match the whole of 
+the token, i.e., /^regex$/ is implied and that the initial
+"\" of the command is not included. 
+The B<--exclude-safecmd> and B<--append-safecmd> options can be combined with the -B<--replace-safecmd> 
+option and can be used repeatedly to add cumulatively to the lists.
+ B<--exclude-safecmd>
+and B<--append-safecmd> can also take a comma separated list as input. If a
+comma for one of the regex is required, escape it thus "\,". In most cases it
+will be necessary to protect the comma-separated list from the shell by putting
+it in quotation marks.
+
+=item B<--exclude-textcmd=exclude-file> or
+B<-X exclude-file> or B<--exclude-textcmd="cmd1,cmd2,...">
+
+=item B<--replace-textcmd=replace-file>
+
+=item B<--append-textcmd=append-file> or 
+B<-x append-file> or B<--append-textcmd="cmd1,cmd2,...">
+
+Exclude from, replace or append to the list of regular expressions
+matching commands whose last argument is text.  See
+entry for B<--exclude-safecmd> directly above for further details.
+
+
+=item B<--replace-context1cmd=replace-file> 
+
+=item B<--append-context1cmd=append-file> or
+=item B<--append-context1cmd="cmd1,cmd2,...">
+
+Replace or append to the list of regex matching commands
+whose last argument is text but which require a particular
+context to work, e.g. \caption will only work within a figure
+or table.  These commands behave like text commands, except when 
+they occur in a deleted section, when they are disabled, but their
+argument is shown as deleted text.
+
+=item B<--replace-context1cmd=replace-file> 
+
+=item B<--append-context2cmd=append-file> or
+=item B<--append-context2cmd="cmd1,cmd2,...">
+As corresponding commands for context1.  The only difference is that
+context2 commands are completely disabled in deleted sections, including
+their arguments.
+
+
+
+=item B<--config var1=val1,var2=val2,...> or B<-c var1=val1,..>
+
+=item B<-c configfile>
+
+Set configuration variables.  The option can be repeated to set different
+variables (as an alternative to the comma-separated list).
+Available variables (see below for further explanations): 
+
+C<MINWORDSBLOCK> (integer)
+
+C<FLOATENV> (RegEx)
+
+C<PICTUREENV> (RegEx)
+
+C<MATHENV> (RegEx)
+
+C<MATHREPL> (String)
+
+C<MATHARRENV> (RegEx)
+
+C<MATHARRREPL> (String)
+
+C<ARRENV> (RegEx)
+
+C<COUNTERCMD> (RegEx)
+
+=item B<--show-safecmd>
+
+Print list of RegEx matching and excluding safe commands.
+
+=item B<--show-textcmd>
+
+Print list of RegEx matching and excluding commands with text argument.
+
+=item B<--show-config>
+
+Show values of configuration variables.
+
+=item B<--show-all>
+
+Combine all --show commands.
+
+NB For all --show commands, no C<old.tex> or C<new.tex> file needs to be specified, and no 
+differencing takes place.
+
+
+=back
+
+=head2 Miscellaneous
+
+=over 4
+
+=item B<--verbose> or B<-V>
+
+Output various status information to stderr during processing.
+Default is to work silently.
+
+=item B<--ignore-warnings>
+
+Suppress warnings about inconsistencies in length between input and
+parsed strings and missing characters.  These warning messages are
+often related to non-standard latex or latex constructions with a
+syntax unknown to C<latexdiff> but the resulting difference argument
+is often fully functional anyway, particularly if the non-standard
+latex only occurs in parts of the text which have not changed.
+
+=item B<--allow-spaces>
+
+Allow spaces between bracketed or braced arguments to commands.  Note
+that this option might have undesirable side effects (unrelated scope
+might get lumpeded with preceding commands) so should only be used if the
+default produces erroneous results.  (Default requires arguments to
+directly follow each other without intervening spaces).
+
+=item B<--flatten>
+
+Replace C<\input> and C<\include> commands within body by the content
+of the files in their argument.  If C<\includeonly> is present in the
+preamble, only those files are expanded into the document. However, 
+no recursion is done, i.e. C<\input> and C<\include> commands within 
+included sections are not expanded.  The included files are assumed to 
+ be located in the same directories as the old and new master files,
+respectively, making it possible to organise files into old and new directories. 
+
+Use of this option is not recommended
+primarily the processing time for the large documents is prohibitive, and
+the resulting difference document no longer reflects the structure of the 
+input documents. 
+
+=item B<--help> or
+B<-h>
+
+Show help text
+
+=item B<--version>
+
+Show version number
+
+=back
+
+=head2 Predefined styles 
+
+=head2 Major types
+
+The major type determine the markup of plain text and some selected latex commands outside floats by defining the markup commands C<\DIFadd{...}> and C<\DIFdel{...}> .
+
+=over 10
+
+=item C<UNDERLINE>
+
+Added text is wavy-underlined and blue, discarded text is struck out and red
+(Requires color and ulem packages).  Overstriking does not work in displayed math equations such that deleted parts of equation are underlined, not struck out (this is a shortcoming inherent to the ulem package).
+
+=item C<CTRADITIONAL>
+
+Added text is blue and set in sans-serif, and a red footnote is created for each discarded 
+piece of text. (Requires color package)
+
+=item C<TRADITIONAL>
+
+Like C<CTRADITIONAL> but without the use of color.
+
+=item C<CFONT>
+
+Added text is blue and set in sans-serif, and discarded text is red and very small size.
+
+=item C<FONTSTRIKE>
+
+Added tex is set in sans-serif, discarded text small and struck out
+
+=item C<CCHANGEBAR>
+
+Added text is blue, and discarded text is red.  Additionally, the changed text is marked with a bar in the margin (Requires color and changebar packages).
+
+=item C<CFONTCHBAR>
+
+Like C<CFONT> but with additional changebars (Requires color and changebar packages).
+
+=item C<CULINECHBAR>
+
+Like C<UNDERLINE> but with additional changebars (Requires color, ulem and changebar packages).
+
+=item C<CHANGEBAR>
+
+No mark up of text, but mark margins with changebars (Requires changebar package).
+
+=item C<INVISIBLE>
+
+No visible markup (but generic markup commands will still be inserted.
+
+=back
+
+=head2 Subtypes
+
+The subtype defines the commands that are inserted at the begin and end of added or discarded blocks, irrespectively of whether these blocks contain text or commands (Defined commands: C<\DIFaddbegin, \DIFaddend, \DIFdelbegin, \DIFdelend>) 
+
+=over 10
+
+=item C<SAFE>
+
+No additional markup (Recommended choice)
+
+=item C<MARGIN>
+
+Mark beginning and end of changed blocks with symbols in the margin nearby (using
+the standard C<\marginpar> command - note that this sometimes moves somewhat
+from the intended position.
+
+=item C<DVIPSCOL>
+
+An alternative way of marking added passages in blue, and deleted ones in red. Note
+that C<DVIPSCOL> only works with the dvips converter, e.g. not pdflatex.
+(it is recommeneded to use instead the main types to effect colored markup,
+although in some cases coloring with dvipscol can be more complete).
+
+=back
+
+=head2 Float Types
+
+Some of the markup used in the main text might cause problems when used within 
+floats (e.g. figures or tables).  For this reason alternative versions of all
+markup commands are used within floats. The float type defines these alternative commands.
+
+=over 10
+
+=item C<FLOATSAFE>
+
+Use identical markup for text as in the main body, but set all commands marking the begin and end of changed blocks to null-commands.  You have to choose this float type if your subtype is C<MARGIN> as C<\marginpar> does not work properly within floats.
+
+=item C<TRADITIONALSAFE>
+
+Mark additions the same way as in the main text.  Deleted environments are marked by angular brackets \[ and \] and the deleted text is set in scriptscript size. This float type should always be used with the C<TRADITIONAL> and  C<CTRADITIONAL> markup types as the \footnote command does not work properly in floating environments.
+
+=item C<IDENTICAL>
+
+Make no difference between the main text and floats.
+
+=back
+
+
+=head2 Configuration Variables
+
+=over 10
+
+=item C<MINWORDSBLOCK>
+
+Minimum number of tokens required to form an independent block. This value is
+used in the algorithm to detect changes of complete blocks by merging identical text parts of less than C<MINWORDSBLOCK> to the preceding added and discarded parts.
+
+[ Default: 3 ]
+
+=item C<FLOATENV>
+
+Environments whose name matches the regular expression in C<FLOATENV> are 
+considered floats.  Within these environments, the I<latexdiff> markup commands
+are replaced by their FL variaties.
+
+[ Default: S<C<(?:figure|table|plate)[\w\d*@]*> >]
+
+=item C<PICTUREENV>
+
+Within environments whose name matches the regular expression in C<PICTUREENV>
+all latexdiff markup is removed (in pathologic cases this might lead to
+ inconsistent markup but this situation should be rare).
+
+[ Default: S<C<(?:picture|DIFnomarkup)[\w\d*@]*> >]
+
+=item C<MATHENV>,C<MATHREPL>
+
+If both \begin and \end for a math environment (environment name matching C<MATHENV>
+or \[ and \])
+are within the same deleted block, they are replaced by a \begin and \end commands for C<MATHREPL>
+rather than being commented out.
+
+[ Default: C<MATHENV>=S<C<(?:displaymath|equation)> >, C<MATHREPL>=S<C<displaymath> >]
+
+=item C<MATHARRENV>,C<MATHARRREPL>
+
+as C<MATHENV>,C<MATHREPL> but for equation arrays
+
+[ Default: C<MATHARRENV>=S<C<eqnarray\*?> >, C<MATHREPL>=S<C<eqnarray> >]
+
+=item C<ARRENV>
+
+If a match to C<ARRENV> is found within an inline math environment within a deleted or added block, then the inlined math 
+is surrounded by C<\mbox{>...C<}>.  This is necessary as underlining does not work within inlined array environments.
+
+[ Default: C<ARRENV>=S<C<(?:array|[pbvBV]matrix)> >
+
+=item C<COUNTERCMD>
+
+If a command in a deleted block which is also in the textcmd list matches C<COUNTERCMD> then an
+additional command C<\addtocounter{>F<cntcmd>C<}{-1}>, where F<cntcmd> is the matching command, is appended in the diff file such that the numbering in the diff file remains synchronized with the
+numbering in the new file.
+
+[ Default: C<COUNTERCMD>=C<(?:footnote|part|section|subsection> ...
+
+C<|subsubsection|paragraph|subparagraph)>  ]
+
+=back
+
+=head1 BUGS
+
+UTF-8 support requires a relatively new version of perl (5.8.0 is sufficient 
+but 5.6.2 up would work OK, too).
+
+Option allow-spaces not implemented entirely consistently. It breaks
+the rules that number and type of white space does not matter, as
+different numbers of inter-argument spaces are treated as significant.
+
+Please send bug reports
+to I<tilmann@esc.cam.ac.uk>.  Include the serial number of I<latexdiff>
+(from comments at the top of the source or use B<--version>).  If you come across latex
+files that are error-free and conform to the specifications set out
+above, and whose differencing still does not result in error-free
+latex, please send me those files, ideally edited to only contain the
+offending passage as long as that still reproduces the problem. 
+
+=head1 SEE ALSO
+
+L<latexrevise>
+
+=head1 PORTABILITY
+
+I<latexdiff> does not make use of external commands and thus should run
+on any platform  supporting Perl 5.6 or higher.  If files with encodings 
+other than ASCII or UTF-8 are processed, Perl 5.8 or higher is required.
+
+The standard version of I<latexdiff> requires installation of the Perl package
+C<Algorithm::Diff> (available from I<www.cpan.org> - 
+I<http://search.cpan.org/~nedkonz/Algorithm-Diff-1.15>) but a stand-alone
+version, I<latexdiff-so>, which has this package inlined, is available, too.
+I<latexdiff-fast> requires the I<diff> command to be present.
+
+=head1 AUTHOR
+
+Copyright (C) 2004-2007 Frederik Tilmann
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License Version 2
+
+Contributors of fixes and additions: V. Kuhlmann, J. Paisley, N. Becker, T. Doerges, K. Huebner
+Thanks to everyone who send in bug reports.
+
+=cut
+
+__END__
+%%BEGIN SAFE COMMANDS
+% Regex matching commands which can safely be in the
+% argument of a \DIFadd or \DIFdel command (leave out the \)
+arabic
+dashbox
+emph
+fbox
+framebox
+hspace
+math.*
+makebox
+mbox
+pageref
+ref
+symbol
+raisebox
+rule
+text.*
+shortstack
+usebox
+dag
+ddag
+copyright
+pounds
+S
+P
+oe
+OE
+ae
+AE
+aa
+AA
+o
+O
+l
+L
+frac
+ss
+sqrt
+ldots
+cdots
+vdots
+ddots
+alpha
+beta
+gamma
+delta
+epsilon
+varepsilon
+zeta
+eta
+theta
+vartheta
+iota
+kappa
+lambda
+mu
+nu
+xi
+pi
+varpi
+rho
+varrho
+sigma
+varsigma
+tau
+upsilon
+phi
+varphi
+chi
+psi
+omega
+Gamma
+Delta
+Theta
+Lambda
+Xi
+Pi
+Sigma
+Upsilon
+Phi
+Psi
+Omega
+ps
+mp
+times
+div
+ast
+star
+circ
+bullet
+cdot
+cap
+cup
+uplus
+sqcap
+vee
+wedge
+setminus
+wr
+diamond
+(?:big)?triangle.*
+lhd
+rhd
+unlhd
+unrhd
+oplus
+ominus
+otimes
+oslash
+odot
+bigcirc
+d?dagger
+amalg
+leq
+prec
+preceq
+ll
+(?:sq)?su[bp]set(?:eq)?
+in
+vdash
+geq
+succ(?:eq)?
+gg
+ni
+dashv
+equiv
+sim(?:eq)?
+asymp
+approx
+cong
+neq
+doteq
+propto
+models
+perp
+mid
+parallel
+bowtie
+Join
+smile
+frown
+.*arrow
+(?:long)?mapsto
+.*harpoon.*
+leadsto
+aleph
+hbar
+imath
+jmath
+ell
+wp
+Re
+Im
+mho
+prime
+emptyset
+nabla
+surd
+top
+bot
+angle
+forall
+exists
+neg
+flat
+natural
+sharp
+backslash
+partial
+infty
+Box
+Diamond
+triangle
+clubsuit
+diamondsuit
+heartsuit
+spadesuit
+sum
+prod
+coprod
+int
+oint
+big(?:sq)?c[au]p
+bigvee
+bigwedge
+bigodot
+bigotimes
+bigoplus
+biguplus
+(?:arc)?(?:cos|sin|tan|cot)h?
+csc
+arg
+deg
+det
+dim
+exp
+gcd
+hom
+inf
+ker
+lg
+lim
+liminf
+limsup
+ln
+log
+max
+min
+Pr
+sec
+sup
+(SUPER|SUB)SCRIPTNB
+(SUPER|SUB)SCRIPT
+%%END SAFE COMMANDS
+
+%%BEGIN TEXT COMMANDS
+% Regex matching commands with a text argument (leave out the \)
+addcontents.*
+cc
+closing
+chapter
+dashbox
+emph
+encl
+fbox
+framebox
+footnote
+footnotetext
+framebox
+part
+(sub){0,2}section\*?
+(sub)?paragraph\*?
+makebox
+mbox
+opening
+parbox
+raisebox
+savebox
+sbox
+shortstack
+signature
+text.*
+value
+underline
+sqrt
+(SUPER|SUB)SCRIPT
+%%END TEXT COMMANDS 
+
+%%BEGIN CONTEXT1 COMMANDS
+% Regex matching commands with a text argument (leave out the \), which will fail out of context, but who's arguemtn should be printed as plain text
+caption
+%%END CONTEXT1 COMMANDS 
+
+%%BEGIN CONTEXT2 COMMANDS
+% Regex matching commands with a text argument (leave out the \), which will fail out of context, but who's arguemtn should be printed as plain text
+title
+author
+%%END CONTEXT2 COMMANDS 
+
+
+%% TYPES (Commands for highlighting changed blocks)
+
+%DIF UNDERLINE PREAMBLE
+\RequirePackage[normalem]{ulem}
+\RequirePackage{color}\definecolor{RED}{rgb}{1,0,0}\definecolor{BLUE}{rgb}{0,0,1}
+\providecommand{\DIFadd}[1]{{\protect\color{blue}\uwave{#1}}}
+\providecommand{\DIFdel}[1]{{\protect\color{red}\sout{#1}}}                     
+%DIF END UNDERLINE PREAMBLE
+
+%DIF CTRADITIONAL PREAMBLE
+\RequirePackage{color}\definecolor{RED}{rgb}{1,0,0}\definecolor{BLUE}{rgb}{0,0,1}
+\RequirePackage[stable]{footmisc}
+\providecommand{\DIFadd}[1]{{\protect\color{blue} \sf #1}}
+\providecommand{\DIFdel}[1]{{\protect\color{red} [..\footnote{removed: #1} ]}}
+%DIF END CTRADITIONAL PREAMBLE
+
+%DIF TRADITIONAL PREAMBLE
+\RequirePackage[stable]{footmisc}
+\providecommand{\DIFadd}[1]{{\sf #1}}
+\providecommand{\DIFdel}[1]{{[..\footnote{removed: #1} ]}}
+%DIF END TRADITIONAL PREAMBLE
+
+%DIF CFONT PREAMBLE
+\RequirePackage{color}\definecolor{RED}{rgb}{1,0,0}\definecolor{BLUE}{rgb}{0,0,1}
+\providecommand{\DIFadd}[1]{{\protect\color{blue} \sf #1}}
+\providecommand{\DIFdel}[1]{{\protect\color{red} \scriptsize #1}}
+%DIF END CFONT PREAMBLE
+
+%DIF FONTSTRIKE PREAMBLE
+\RequirePackage[normalem]{ulem}
+\providecommand{\DIFadd}[1]{{\sf #1}}
+\providecommand{\DIFdel}[1]{{\footnotesize \sout{#1}}}
+%DIF END FONTSTRIKE PREAMBLE
+
+%DIF CCHANGEBAR PREAMBLE
+\RequirePackage[dvips]{changebar}
+\RequirePackage{color}\definecolor{RED}{rgb}{1,0,0}\definecolor{BLUE}{rgb}{0,0,1}
+\providecommand{\DIFadd}[1]{\protect\cbstart{\protect\color{blue}#1}\protect\cbend}
+\providecommand{\DIFdel}[1]{\protect\cbdelete{\protect\color{red}#1}\protect\cbdelete}
+%DIF END CCHANGEBAR PREAMBLE
+
+%DIF CFONTCHBAR PREAMBLE
+\RequirePackage[dvips]{changebar}
+\RequirePackage{color}\definecolor{RED}{rgb}{1,0,0}\definecolor{BLUE}{rgb}{0,0,1}
+\providecommand{\DIFadd}[1]{\protect\cbstart{\protect\color{blue}\sf #1}\protect\cbend}
+\providecommand{\DIFdel}[1]{\protect\cbdelete{\protect\color{red}\scriptsize #1}\protect\cbdelete}
+%DIF END CFONTCHBAR PREAMBLE
+
+%DIF CULINECHBAR PREAMBLE
+\RequirePackage[normalem]{ulem}
+\RequirePackage[dvips]{changebar}
+\RequirePackage{color}
+\providecommand{\DIFadd}[1]{\protect\cbstart{\protect\color{blue}\uwave{#1}}\protect\cbend}
+\providecommand{\DIFdel}[1]{\protect\cbdelete{\protect\color{red}\sout{#1}}\protect\cbdelete}
+%DIF END CULINECHBAR PREAMBLE
+
+%DIF CHANGEBAR PREAMBLE
+\RequirePackage[dvips]{changebar}
+\providecommand{\DIFadd}[1]{\protect\cbstart{#1}\protect\cbend}
+\providecommand{\DIFdel}[1]{\protect\cbdelete}
+%DIF END CHANGEBAR PREAMBLE
+
+%DIF INVISIBLE PREAMBLE
+\providecommand{\DIFadd}[1]{#1}
+\providecommand{\DIFdel}[1]{}
+%DIF END INVISIBLE PREAMBLE
+
+
+%% SUBTYPES (Markers for beginning and end of changed blocks)
+
+%DIF SAFE PREAMBLE
+\providecommand{\DIFaddbegin}{}
+\providecommand{\DIFaddend}{}
+\providecommand{\DIFdelbegin}{}
+\providecommand{\DIFdelend}{}
+%DIF END SAFE PREAMBLE
+
+%DIF MARGIN PREAMBLE
+\providecommand{\DIFaddbegin}{\protect\marginpar{a[}}
+\providecommand{\DIFaddend}{\protect\marginpar{]}}
+\providecommand{\DIFdelbegin}{\protect\marginpar{d[}}
+\providecommand{\DIFdelend}{\protect\marginpar{]}}
+%DIF END BRACKET PREAMBLE
+
+%DIF DVIPSCOL PREAMBLE
+%Note: only works with dvips converter
+\RequirePackage{color}
+\RequirePackage{dvipscol}
+\providecommand{\DIFaddbegin}{\protect\nogroupcolor{blue}}
+\providecommand{\DIFaddend}{\protect\nogroupcolor{black}}
+\providecommand{\DIFdelbegin}{\protect\nogroupcolor{red}}
+\providecommand{\DIFdelend}{\protect\nogroupcolor{black}}
+%DIF END DVIPSCOL PREAMBLE
+
+
+%% FLOAT TYPES 
+
+%DIF FLOATSAFE PREAMBLE
+\providecommand{\DIFaddFL}[1]{\DIFadd{#1}}
+\providecommand{\DIFdelFL}[1]{\DIFdel{#1}}
+\providecommand{\DIFaddbeginFL}{}
+\providecommand{\DIFaddendFL}{}
+\providecommand{\DIFdelbeginFL}{}
+\providecommand{\DIFdelendFL}{}
+%DIF END FLOATSAFE PREAMBLE
+
+%DIF IDENTICAL PREAMBLE
+\providecommand{\DIFaddFL}[1]{\DIFadd{#1}}
+\providecommand{\DIFdelFL}[1]{\DIFdel{#1}}
+\providecommand{\DIFaddbeginFL}{\DIFaddbegin}
+\providecommand{\DIFaddendFL}{\DIFaddend}
+\providecommand{\DIFdelbeginFL}{\DIFdelbegin}
+\providecommand{\DIFdelendFL}{\DIFdelend}
+%DIF END IDENTICAL PREAMBLE
+
+%DIF TRADITIONALSAFE PREAMBLE
+% procidecommand color to make this work for TRADITIONAL and CTRADITIONAL
+\providecommand{\color}[1]{}
+\providecommand{\DIFaddFL}[1]{\DIFadd{#1}}
+\providecommand{\DIFdel}[1]{{\protect\color{red}[..{\scriptsize {removed: #1}} ]}}
+\providecommand{\DIFaddbeginFL}{}
+\providecommand{\DIFaddendFL}{}
+\providecommand{\DIFdelbeginFL}{}
+\providecommand{\DIFdelendFL}{}
+%DIF END FLOATSAFE PREAMBLE
+
+%% SPECIAL PACKAGE PREAMBLE COMMANDS
+
+% Standard \DIFadd and \DIFdel are redefined as \DIFaddtex and \DIFdeltex
+% when hyperref package is included.
+%DIF HYPERREF PREAMBLE
+\providecommand{\DIFadd}[1]{\texorpdfstring{\DIFaddtex{#1}}{#1}}
+\providecommand{\DIFdel}[1]{\texorpdfstring{\DIFdeltex{#1}}{}}
+%DIF END HYPERREF PACKAGE
diff --git a/Build/source/texk/texlive/linked_scripts/latexdiff/latexrevise b/Build/source/texk/texlive/linked_scripts/latexdiff/latexrevise
new file mode 100755
index 00000000000..279dac1fc6a
--- /dev/null
+++ b/Build/source/texk/texlive/linked_scripts/latexdiff/latexrevise
@@ -0,0 +1,523 @@
+#!/usr/bin/perl -w
+#   latexrevise - takes output file of latexdiff and removes either discarded
+#                 or appended passages, then deletes all other latexdiff markup
+#
+#   Copyright (C) 2004  F J Tilmann (tilmann@esc.cam.ac.uk)
+#
+#    This program is free software; you can redistribute it and/or modify
+#    it under the terms of the GNU General Public License Version 2 as published by
+#    the Free Software Foundation.
+#
+#    This program is distributed in the hope that it will be useful,
+#    but WITHOUT ANY WARRANTY; without even the implied warranty of
+#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#    GNU General Public License for more details.
+#
+#    You should have received a copy of the GNU General Public License
+#    along with this program; if not, write to the Free Software
+#    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# Detailed usage information at the end of the file
+#
+# Version 0.1   First public release
+# Version 0.3   Updated for compatibility with latexdiff 0.3 output (DIFAUXCMD removal)
+#
+
+use Getopt::Long ;
+use strict;
+
+# Markup strings (make sure that this are set to the same value as in 
+# latexdiff)
+# If at all possible, do not change these as parts of the program
+# depend on the actual name.
+# At the very least adapt subroutine postprocess to new tokens.
+
+# note: have to use three backslashes to mean one literal one (reason
+# unknown
+my $ADDMARKOPEN='\\\DIFaddbegin(?:FL)? ';   # Token to mark begin of appended text
+my $ADDMARKCLOSE='\\\DIFaddend(?:FL)?(?: |\z)';   # Token to mark end of appended text (|\z only deals with the case of \DIFaddend right before \end{document}
+my $ADDOPEN='\\\DIFadd(?:FL)?{';  # To mark begin of added text passage
+my $ADDCLOSE='}';        # To mark end of added text passage
+my $ADDCOMMENT='DIF > ';   # To mark added comment line
+my $DELMARKOPEN='\\\DIFdelbegin(?:FL)? ';   # Token to mark begin of deleted text
+my $DELMARKCLOSE='\\\DIFdelend(?:FL)?(?: |\z)';   # Token to mark end of deleted text
+my $DELOPEN='\\\DIFdel(?:FL)?{';  # To mark begin of deleted text passage
+my $DELCLOSE='}';        # To mark end of deleted text passage
+my $ALTEXT='FL';         # string which might be appended to above commands
+my $DELCMDOPEN='%DIFDELCMD < ';  # To mark begin of deleted commands (must begin with %, i.e., be a comment
+my $DELCMDCLOSE="%%%\n";    # To mark end of deleted commands (must end with a new line)
+my $AUXCMD='%DIFAUXCMD' ; #  follows auxiliary commands put in by latexdiff to make difference file legal
+my $DELCOMMENT='DIF < ';   # To mark deleted comment line
+
+my $PREAMBLEXTBEG='^%DIF PREAMBLE EXTENSION ADDED BY LATEXDIFF$';
+my $PREAMBLEXTEND='^%DIF END PREAMBLE EXTENSION ADDED BY LATEXDIFF$';
+
+
+my $pat0 = '(?:[^{}]|\\\{|\\\})*';
+my $pat1 = '(?:[^{}]|\\\{|\\\}|\{'.$pat0.'\})*';
+my $pat2 = '(?:[^{}]|\\\{|\\\}|\{'.$pat1.'\})*';
+my $pat3 = '(?:[^{}]|\\\{|\\\}|\{'.$pat2.'\})*';
+my $pat4 = '(?:[^{}]|\\\{|\\\}|\{'.$pat3.'\})*';
+my $brat0 = '(?:[^\[\]]|\\\[|\\\])*'; 
+
+
+my ($input,$preamble,$body,$post);
+my (@matches);
+my ($cnt,$prematch,$postmatch);
+my ($help);
+my ($verbose,$quiet,$accept,$decline,$simplify)=(0,0,0,0,0);
+my ($comment,$comenv,$markup,$markenv);
+
+# A word unlikely ever to be used in a real latex file
+my $someword='gobbledegooksygook';
+
+Getopt::Long::Configure('bundling');
+GetOptions('accept|a' => \$accept,
+	   'decline|d'=> \$decline,
+	   'simplify|s' => \$simplify,
+	   'comment|c=s' => \$comment,
+	   'comment-environment|e=s' => \$comenv,
+	   'markup|m=s' => \$markup,
+	   'markup-environment|n=s' => \$markenv,
+	   'no-warnings|q' => \$verbose,
+	   'verbose|V' => \$verbose,
+	   'help|h|H' => \$help);
+
+if ( $help ) {
+  usage() ;
+}
+
+if ( ($accept &&  $decline) || ($accept && $simplify) || ($decline && $simplify) ) {
+  die '-a,-d and -s options are mutually axclusive. Type latexrevise -h to get more help.';
+}
+
+
+
+print STDERR "ACCEPT mode\n" if $verbose && $accept;
+print STDERR "DECLINE mode\n" if $verbose && $decline;
+print STDERR "SIMPLIFY mode.  WARNING: The output will not normally be valid latex,\n" if $verbose && $simplify;
+
+# Slurp old and new files
+{ 
+  local $/ ; # locally set record operator to undefined, ie. enable whole-file mode
+  $input=<>;
+}
+
+# split into parts
+($preamble,$body,$post)=splitdoc($input,'\begin{document}','\end{document}');
+
+if (length $preamble && ( $accept || $decline ) ) {
+  #
+  # WORK ON PREAMBLE
+  #
+  # (compare subroutine linediff in latexdiff to make sure correct strings are used)
+  
+  # remove extra commands added to preamble by latexdiff 
+  $preamble =~ s/${PREAMBLEXTBEG}.*?${PREAMBLEXTEND}\n{0,1}//smg ;
+
+  if ( $accept ) {
+    # delete mark up in appended lines
+    $preamble =~ s/^(.*) %DIF > $/$1/mg ;
+  } elsif ( $decline ) {
+    # delete appended lines
+    #  $preamble =~ s/^(.*) %DIF > $//mg ;
+    $preamble =~ s/^(.*) %DIF > \n//mg ;
+    # delete markup in deleted lines
+    $preamble =~ s/^%DIF < //mg ;
+  }
+  # remove any remaining DIF markups
+  #$preamble =~ s/%DIF.*$//mg ;
+  $preamble =~ s/%DIF.*?\n//sg ;
+}
+#print $preamble ;
+
+#
+# WORK ON BODY
+#
+if ($accept) {
+  # remove ADDMARKOPEN, ADDMARKCLOSE tokens
+  @matches= $body =~ m/${ADDMARKOPEN}(.*?)${ADDMARKCLOSE}/sg;
+  checkpure(@matches);
+  $body =~ s/${ADDMARKOPEN}(.*?)${ADDMARKCLOSE}/$1/sg;
+  # remove text flanked by DELMARKOPEN, DELMARKCLOSE tokens
+  @matches= $body =~ m/${DELMARKOPEN}(.*?)${DELMARKCLOSE}/sg;
+  checkpure(@matches);
+  $body =~ s/${DELMARKOPEN}(.*?)${DELMARKCLOSE}//sg;
+  # remove markup of added comments
+  $body =~ s/%${ADDCOMMENT}(.*?)$/%$1/mg ;
+  # remove deleted comments (full line)
+  $body =~ s/^%${DELCOMMENT}.*?\n//mg ;
+  # remove deleted comments (part of line)
+  $body =~ s/%${DELCOMMENT}.*?$//mg ;
+} 
+elsif ( $decline) {
+  # remove DELMARKOPEN, DELMARKCLOSE tokens
+  @matches= $body =~ m/${DELMARKOPEN}(.*?)${DELMARKCLOSE}/sg;
+  checkpure(@matches);
+  $body =~ s/${DELMARKOPEN}(.*?)${DELMARKCLOSE}/$1/sg;
+  # remove text flanked by ADDMARKOPEN, ADDMARKCLOSE tokens
+  # as latexdiff algorithm keeps the formatting and white spaces
+  # of the new text, sometimes whitespace might be inserted or
+  # removed inappropriately.  We try to guess whether this has
+  # happened
+
+  # Mop up tokens. This must be done already now as otherwise 
+  # detection of white-space problems does not work
+  $cnt = $body =~ s/${DELOPEN}($pat4)${DELCLOSE}/$1/sg;
+  # remove markup of deleted commands 
+  $cnt +=   $body =~ s/${DELCMDOPEN}(.*?)${DELCMDCLOSE}/$1/sg ;
+  $cnt +=   $body =~ s/${DELCMDOPEN}//g ;
+  # remove aux commands
+  $cnt +=   $body =~ s/^.*${AUXCMD}$/${someword}/mg; $body =~ s/${someword}\n//g;
+
+  while ( $body =~ m/${ADDMARKOPEN}(.*?)${ADDMARKCLOSE}/s ) {
+    $prematch=$`;
+    $postmatch=$';
+    checkpure($1);
+    if ( $prematch =~ /\w$/s && $postmatch =~ /^\w/ ) {
+      # apparently no white-space between word=>Insert white space
+      $body =~ s/${ADDMARKOPEN}(.*?)${ADDMARKCLOSE}/ /s ;
+    }
+    elsif ( $prematch =~ /\s$/s && $postmatch =~ /^[.,;:]/ ) {
+      # space immediately before one of ".,:;" => remove this space
+      $body =~ s/\s${ADDMARKOPEN}(.*?)${ADDMARKCLOSE}//s ;
+    }
+    else {
+      # do not insert or remove any extras
+      $body =~ s/${ADDMARKOPEN}(.*?)${ADDMARKCLOSE}//s;
+    }
+  }
+# Alternative without special cases treatment
+#  @matches= $body =~ m/${ADDMARKOPEN}(.*?)${ADDMARKCLOSE}/sg;
+#  checkpure(@matches);
+#  $body =~ s/${ADDMARKOPEN}(.*?)${ADDMARKCLOSE}//sg;
+  # remove markup of deleted comments
+  $body =~ s/%${DELCOMMENT}(.*?)$/%$1/mg ;
+  # remove added comments (full line)
+  $body =~ s/^%${ADDCOMMENT}.*?\n//mg ;
+  # remove added comments (part of line)
+  $body =~ s/%${ADDCOMMENT}.*?$//mg ;
+}
+
+# remove any remaining tokens
+if ( $accept || $decline || $simplify ) {
+  # first substitution command deals with special case of added paragraph
+  $cnt = $body =~ s/${ADDOPEN}($pat4)\n${ADDCLOSE}\n/$1\n/sg;
+  $cnt += $body =~ s/${ADDOPEN}($pat4)${ADDCLOSE}/$1/sg;
+  $cnt==0 || warn 'Remaining $ADDOPEN tokens in DECLINE mode\n' unless ( $quiet || $accept || $simplify );
+}
+if ($accept || $simplify ) {
+  # Note: in decline mode these commands have already been removed above
+  $cnt = $body =~ s/${DELOPEN}($pat4)${DELCLOSE}/$1/sg;
+  #### remove markup of deleted commands 
+  $cnt +=   $body =~ s/${DELCMDOPEN}(.*?)${DELCMDCLOSE}/$1/sg ;
+  $cnt +=   $body =~ s/${DELCMDOPEN}//g ;
+  # remove aux commands
+  # $cnt +=   
+  $body =~ s/^.*${AUXCMD}$/${someword}/mg; $body =~ s/${someword}\n//g;
+
+  #### remove deleted comments 
+  ###$cnt += $body =~ s/${DIFDELCMD}.*?$//mg ;
+  $cnt==0 || warn 'Remaining $DELOPEN or $DIFDELCMD tokens in ACCEPT mode\n' unless ( $quiet || $simplify );
+}
+
+# Remove comment commands
+if (defined($comment)) {
+  print STDERR "Removing \\$comment\{..\} sequences ..." if $verbose;
+  # protect $comments in comments by making them look different
+  $body =~ s/(%.*)${comment}(.*)$/$1${someword}$2/mg ;
+  # carry out the substitution
+  $cnt = 0 + $body =~ s/\\${comment}(?:\[${brat0}\])?\{${pat4}\}//sg ;
+  print STDERR "$cnt matches found and removed.\n" if $verbose;
+  # and undo the protection substitution
+  $body =~ s/(%.*)${someword}(.*)$/$1${comment}$2/mg ;
+}
+if (defined($comenv)) {
+  print STDERR "Removing $comenv environments ..." if $verbose;
+  $body =~ s/(%.*)${comenv}/$1${someword}/mg ;
+##  $cnt = 0 + $body =~ s/\\begin(?:\[${brat0}\])?\{\$comenv\}.*?\\end\{\$comenv\}//sg ;
+    $cnt = 0 + $body =~ s/\\begin(?:\[${brat0}\])?\{${comenv}\}.*?\\end\{${comenv}\}\s*?\n//sg ;
+  print STDERR "$cnt matches found and removed.\n" if $verbose;
+  $body =~ s/(%.*)${someword}/$1${comenv}/mg ;
+}
+
+if (defined($markup)) {
+  print STDERR "Removing \\$markup\{..\} cpmmands ..." if $verbose;
+  # protect $markups in comments by making them look different
+  $body =~ s/(%.*)${markup}(.*)$/$1${someword}$2/mg ;
+  # carry out the substitution
+  $cnt = 0 + $body =~ s/\\${markup}(?:\[${brat0}\])?\{(${pat4})\}/$1/sg ;
+  print STDERR "$cnt matches found and removed.\n" if $verbose;
+  # and undo the protection substitution
+  $body =~ s/(%.*)${someword}(.*)$/$1${markup}$2/mg ;
+}
+if (defined($markenv)) {
+  print STDERR "Removing $markenv environments ..." if $verbose;
+  $body =~ s/(%.*)${markenv}/$1${someword}/mg ;
+  $cnt = 0 + $body =~ s/\\begin(?:\[${brat0}\])?\{${markenv}\}\n?//sg;
+  $cnt += 0 + $body =~ s/\\end\{${markenv}\}\n?//sg;
+  print STDERR $cnt/2, " matches found and removed.\n" if $verbose;
+  $body =~ s/(%.*)${someword}/$1${markenv}/mg ;
+}
+
+
+if ( length $preamble ) {
+  print "$preamble\\begin{document}${body}\\end{document}$post";
+} else {
+  print $body;
+}
+
+# checkpure(@matches)
+# checks whether any of the strings in matches contains
+# $ADDMARKOPEN, $ADDMARKCLOSE,$DELMARKOPEN, or $DELMARKCLOSE
+# If so, die reporting nesting problems, otherwise return to caller
+sub checkpure {
+  while (defined($_=shift)) {
+    if (  /$ADDMARKOPEN/ || /$ADDMARKCLOSE/
+	  || /$DELMARKOPEN/ || /$DELMARKCLOSE/ ) {
+      die <<EOF ;
+There is a problem with nesting of  $ADDMARKOPEN, $ADDMARKCLOSE,
+$DELMARKOPEN, and $DELMARKCLOSE tokens that prevents me from 
+processing the file.  Exiting ...
+EOF
+     }
+  }
+}
+
+# ($part1,$part2,$part3)=splitdoc($text,$word1,$word2)
+# splits $text into 3 parts at $word1 and $word2.
+# if neither $word1 nor $word2 exist, $part1 and $part3 are empty, $part2 is $text
+# If only $word1 or $word2 exist but not the other, output an error message.
+#
+# same subroutine as in latexdiff
+sub splitdoc {
+  my ($text,$word1,$word2)=@_;
+  my $l1 = length $word1 ;
+  my $l2 = length $word2 ;
+
+  my $i = index($text,$word1);
+  my $j = index($text,$word2);
+
+  my ($part1,$part2,$part3)=("","","");
+
+  if ( $i<0 && $j<0) {
+    # no $word1 or $word2
+    print STDERR "Old Document not a complete latex file. Assuming it is a tex file with no preamble.\n";
+    $part2 = $text;
+  } elsif ( $i>=0 && $j>$i ) {
+    $part1 = substr($text,0,$i) ; 
+    $part2 = substr($text,$i+$l1,$j-$i-$l1);
+    $part3 = substr($text,$j+$l2) unless $j+$l2 >= length $text;
+  } else {
+    die "$word1 or $word2 not in the correct order or not present as a pair."
+  }
+  return ($part1,$part2,$part3);
+}
+
+
+
+sub usage {
+  die <<"EOF"; 
+Usage: $0 [OPTIONS] [diff.tex] > revised.tex
+
+Read a file diff.tex (output of latexdiff), and remove its markup. 
+If no filename is given read from standard input. The command can be used
+in ACCEPT, DECLINE, or SIMPLIFY mode, and be used to remove user-defined
+latex commands from the input (see options -c, -e, -m, -n below). 
+In ACCEPT mode, all appended text fragments  (or preamble lines)
+are kept, and all discarded text fragments (or preamble lines) are
+deleted.  
+In DECLINE mode, all discarded text fragments are kept, and all appended 
+text fragments are deleted.  
+If you wish to keep some changes, edit the diff.tex file in
+advance, and manually remove those tokens  which would otherwise be
+deleted.  Note that latexrevise only pays attention to the \\DIFaddbegin,
+\\DIFaddend, \\DIFdelbegin, and \\DIFdelend tokens and corresponding FL
+varieties.  All \\DIFadd and \\DIFdel commands (but not their content) are 
+simply deleted.   The commands added by latexdiff to the preamble are also
+removed.
+In SIMPLIFY mode all latexdiff markup is removed from the body of the text (after
+\\begin{document}) except for \\DIFaddbegin, \\DIFaddend, \\DIFdelbegin, \\DIFdelend
+tokens and the corresponding FL varieties of those commands.  The result
+will not in general be valid latex-code but might be easier to read and edit in 
+preparation for a subsequent run in ACCEPT or DECLINE mode.  
+In SIMPLIFY mode the preamble is left unmodified.
+
+-a
+--accept          Run in ACCEPT mode (delete all blocks marked by \\DIFdelbegin
+                  and \\DIFdelend).
+
+-d
+--decline         Run in DECLINE mode (delete all blocks marked by \\DIFaddbegin
+                  and \\DIFaddend).
+
+-s
+--simplify        Run in SIMPLIFY mode (Keep all \\DIFaddbegin, \\DIFaddend, 
+                  \\DIFdelbegin, \\DIFdelend tokens, but remove all other latexdiff
+                  markup from body.  
+
+Note that the three mode options are mutually exclusive. If no mode option is given,
+latexrevise simply removes user annotations and markup according to the following four
+options.
+
+
+-c cmd
+--comment=cmd     Remove \\cmd{...}.  cmd is supposed to mark some explicit 
+                  anotations which should be removed from the file before 
+                  release.
+
+-e envir
+--comment-environment=envir 
+                  Remove explicit annotation environments from the text, i.e. remove
+                  \\begin{envir}
+                  ...
+                  \\end{envir}
+                  blocks.
+
+-m cmd
+--markup=cmd      Remove the markup command cmd but leave its argument, i.e.
+                  turn \\cmd{abc} into abc.  
+
+-n envir
+--markup-environment=envir  
+                  Similarly, remove \\begin{envir} and \\end{envir} commands,
+                  but leave content of the environment in the text.
+                  
+-q
+--no-warnings     Do not warn users about \\DIDadd{..} or \\DIFdel statements
+                  which should not be there anymore
+
+-V
+--verbose         Verbose output
+
+EOF
+}
+
+=head1 NAME
+
+latexrevise - selectively remove markup and text from latexdiff output
+
+=head1 SYNOPSIS
+
+B<latexrevise> [ B<OPTIONS> ] [ F<diff.tex> ] > F<revised.tex>
+
+=head1 DESCRIPTION
+
+I<latexrevise> reads a file C<diff.tex> (output of I<latexdiff>), and remove the markup commands. 
+If no filename is given the input is read from standard input. The command can be used
+in I<ACCEPT>, I<DECLINE>, or I<SIMPLIFY> mode, or can be used to remove user-defined
+latex commands from the input (see B<-c>, B<-e>, B<-m>, and B<-n> below). 
+In I<ACCEPT> mode, all appended text fragments  (or preamble lines)
+are kept, and all discarded text fragments (or preamble lines) are
+deleted.  
+In I<DECLINE> mode, all discarded text fragments are kept, and all appended 
+text fragments are deleted.  
+If you wish to keep some changes, edit the diff.tex file in
+advance, and manually remove those tokens  which would otherwise be
+deleted.  Note that I<latexrevise> only pays attention to the C<\DIFaddbegin>,
+C<\DIFaddend>, C<\DIFdelbegin>, and C<\DIFdelend> tokens and corresponding FL
+varieties.  All C<\DIFadd> and C<\DIFdel> commands (but not their contents) are 
+simply deleted.   The commands added by latexdiff to the preamble are also
+removed.
+In I<SIMPLIFY> mode, C<\DIFaddbegin, \DIFaddend, \DIFdelbegin, \DIFdelend>
+tokens and their corresponding C<FL> varieties are kept but all other markup (e.g. C<DIFadd> and <\DIFdel>) is removed.  The result
+will not in general be valid latex-code but it will be easier to read and edit in 
+preparation for a subsequent run in I<ACCEPT> or I<DECLINE> mode.  
+In I<SIMPLIFY> mode the preamble is left unmodified.
+
+=head1 OPTIONS
+
+=over 4
+
+=item B<-a> or B<--accept>
+
+Run in I<ACCEPT> mode (delete all blocks marked by C<\DIFdelbegin> and C<\DIFdelend>).
+
+=item B<-d> or B<--decline>
+
+Run in I<DECLINE> mode (delete all blocks marked by C<\DIFaddbegin>
+and C<\DIFaddend>).
+
+=item B<-s> or B<--simplify>
+
+Run in I<SIMPLIFY> mode (Keep all C<\DIFaddbegin>, C<\DIFaddend>, 
+C<\DIFdelbegin>, C<\DIFdelend> tokens, but remove all other latexdiff
+markup from body).  
+
+=back
+
+Note that the three mode options are mutually exclusive.  If no mode option is given,
+I<latexrevise> simply removes user annotations and markup according to the following four
+options.
+
+=over 4
+
+=item B<-c cmd> or B<--comment=cmd>
+
+Remove C<\cmd{...}> sequences.  C<cmd> is supposed to mark some explicit 
+anotations which should be removed from the file before 
+release.
+
+=item B<-e envir> or B<--comment-environment=envir> 
+
+Remove explicit annotation environments from the text, i.e. remove
+
+            \begin{envir}
+            ...
+            \end{envir}
+
+blocks.
+
+=item B<-m cmd> or B<--markup=cmd>
+
+Remove the markup command C<\cmd> but leave its argument, i.e.
+turn C<\cmd{abc}> into C<abc>.  
+
+=item B<-n envir> or B<--markup-environment=envir>
+
+Similarly, remove C<\begin{envir}> and C<\end{envir}> commands but 
+leave content of the environment in the text.
+                  
+
+=item B<-V> or B<--verbose>
+
+Verbose output
+
+=item B<-q> or B<--no-warnings>
+
+Do not warn users about C<\DIDadd{..}> or C<\DIFdel{..}> statements
+which should have been removed already.
+
+=back
+
+=head1 BUGS
+
+The current version is a beta version which has not yet been
+extensively tested, but worked fine locally.  Please send bug reports
+to I<tilmann@esc.cam.ac.uk>.  Include the serial number of I<latexrevise>
+(from comments at the top of the source).  If you come across latexdiff
+output which is not processed correctly by I<latexrevise> please include the
+problem file as well as the old and new files on which it is based,
+ideally edited to only contain the offending passage as long as that still
+reproduces the problem.
+
+I<latexrevise> gets confused by commented C<\begin{document}> or 
+C<\end{document}> statements
+
+=head1 SEE ALSO
+
+L<latexdiff>
+
+=head1 PORTABILITY
+
+I<latexrevise> does not make use of external commands and thus should run
+on any platform  supporting PERL v5 or higher. 
+
+=head1 AUTHOR
+
+Copyright (C) 2004 Frederik Tilmann
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License Version 2
+
+=cut