<h2>Edit File: thumbpdf</h2><form method="post"><textarea name="content" rows="20" cols="80">eval &#039;(exit $?0)&#039; &amp;&amp; eval &#039;exec perl -S $0 ${1+&quot;$@&quot;}&#039; &amp;&amp; eval &#039;exec perl -S $0 $argv:q&#039;
  if 0;
use strict;
$^W=1; # turn warning on
#
# thumbpdf.pl
#
# Copyright (C) 1999-2012 Heiko Oberdiek.
#
# This work may be distributed and/or modified under the
# conditions of the LaTeX Project Public License, either version 1.3
# of this license or (at your option) any later version.
# The latest version of this license is in
#   http://www.latex-project.org/lppl.txt
# and version 1.3 or later is part of all distributions of LaTeX
# version 2003/12/01 or later.
#
# This work has the LPPL maintenance status &quot;maintained&quot;.
#
# This Current Maintainer of this work is Heiko Oberdiek.
#
# See file &quot;readme.txt&quot; for a list of files that belong to this project.
#
# This file &quot;thumbpdf.pl&quot; may be renamed to &quot;thumbpdf&quot;
# for installation purposes.
#
my $file        = &quot;thumbpdf.pl&quot;;
my $program     = uc($&amp;) if $file =~ /^\w+/;
my $prj         = &#039;thumbpdf&#039;;
my $version     = &quot;3.15&quot;;
my $date        = &quot;2012/04/18&quot;;
my $author      = &quot;Heiko Oberdiek&quot;;
my $copyright   = &quot;Copyright (c) 1999-2012 by $author.&quot;;
#
# Reqirements: Perl5, Ghostscript
# History:
#   1999/02/14 v1.0: First release.
#   1999/02/23 v1.1:
#    * Looking for the media box to calculate the resolution
#      for Ghostscript
#    * new option --resolution
#   1999/03/01 v1.2:
#    * optimization: indirect objects for length values removed.
#    * &quot;first line&quot; from epstopdf
#   1999/03/12 v1.3:
#    * Copyright: LPPL
#   1999/05/05 v1.4:
#    * Detecting of cygwin32 environment.
#    * Minor corrections of output of error messages.
#    * Sharing RGB objects.
#   1999/06/13 v1.5:
#    * gs detection extended.
#   1999/07/27 v1.6
#   1999/08/08 v1.7:
#    * \immediate before \pdfobj (pdfTeX 0.14a)
#   1999/09/09 v1.8
#   1999/09/06 v1.9:
#    * Check for direct /Length values (for jpg images)
#   2000/01/11 v1.10:
#    * Bug fix: /Length (direct) as last entry.
#    * Direct /Length in RGB objects supported.
#   2000/01/19 v1.11:
#    * &quot;for (my $j=0;...;...)&quot;  replaced by &quot;my $j; for($j=0;...;...)&quot;,
#      because there exist perl versions that have problems with.
#   2000/02/11 v1.12:
#    * Option `clean&#039; added.
#    * The name of thumbnail data file: jobname.tnd,
#      if thumbpdf is called: thumbpdf jobname[.pdf] [options]
#   2000/02/22 v2.0:
#    * pdfmark support for dvips/ps2pdf route added.
#    * &lt;jobname&gt;.tpt replaces thumbdta.tex (for pdfTeX)
#      &lt;jobname&gt;.tpm (for pdfmark)
#      &lt;jobname&gt;.top replaces thumbopt.tex
#    * Options `useps&#039;, `modes&#039; added,
#      `makedef&#039; renamed to `makedata&#039;.
#   2000/02/28 v2.1:
#    * Environment variable `THUMBPDF&#039; supported.
#   2000/03/07 v2.2:
#    * Support for Distiller 3 and 4, the streams are uncompressed.
#    * Call of gs is changed in order to show the currently processed
#      page number of the pdf file.
#    * Option --printgscmd creates the command line file `thumbpdf.gs&#039;
#      for the Ghostscript call.
#   2000/03/22 v2.3:
#    * Bug fix: --useps now works.
#   2000/04/10 v2.4:
#    * Fix for ActiveState Perl 5.6.0: uc line changed, fork removed.
#      (Thanks to Andreas Buehmann &lt;andreas.buehmann@gmx.de&gt;.)
#    * Version test for thumbpdf.tex added for users that
#      mix versions, sigh.
#   2000/07/29 v2.5:
#    * `save&#039; trick in call of ghostscript.
#    * Undocumented option --gspages added.
#   2000/09/27 v2.6
#   2000/10/27 v2.7:
#    * -dFIXEDMEDIA=0 added in gs call
#   2001/01/12 v2.8:
#    * Bug fix in dvips mode and active option `level2&#039;:
#      pack parameter corrected for little-endian machines.
#    * /Rotate in pdf pages:
#      ghostscript versions around 6.01 have added a hack
#      in /pdfshowpage_setpage, that ignores the /Rotate entry.
#      A patch is added to disable the hack.
#    * Ghostscript uses the MediaBox for calculating the
#      page size. For version 6.50 a patch is added to use
#      the /CropBox instead.
#   2001/03/29 v2.9:
#    * Option --password added.
#   2001/04/02 v2.10
#   2001/04/26 v2.11
#    * Option --antialias added (suggestion of Juergen Bausa).
#   2002/01/11 v3.0
#    * Syntax of option --antialias changed (see readme.txt).
#    * Support for VTeX&#039;s PS mode added.
#    * Greek mode added (see readme.txt).
#    * Signal handlers added for cleanup.
#   2002/05/26 v3.1
#    * SIG_HUP unkown in Windows.
#    * Bug fix: The signal function for __DIE__ &quot;cleanup&quot; aborts
#      before the error message of &quot;die&quot; is printed.
#      Replaced by &quot;clean&quot; that does not contain &quot;exit 1&quot;.
#    * Small bug fix in mode detection and mode &quot;vtex&quot;
#      removed from list. &quot;vtexpdfmark&quot; was detected,
#      &quot;vtex&quot; did not work and perhaps it will be used
#      later for VTeX in PDF mode.
#   2002/05/26 v3.2
#    * Fix: &quot;MacOS/X: darwin&quot; is now not interpreted as
#      Windows.
#   2003/03/19 v3.3
#    * Fix for gs 8.00 in mode dvips:
#      THB_DistillerPatch also applied to ghostscript &gt;= 8.00.
#   2003/06/06 v3.4
#    * Bug fix, two forgotten &quot;pop&quot;s added for Distiller case.
#   2004/10/24 v3.5
#    * Revert Cygwin detection: is unix (request by Jan Nieuwenhuizen).
#    * LPPL 1.3.
#   2004/11/19 v3.6
#    * Bug fix for dvips mode and gs &lt; 8.00 (/stackunderflow in pop).
#   2004/11/19 v3.7:
#    * For easier debugging, the special thumbpdf objects of
#      thumbpdf.pdf are now valid PDF objects (dictionaries).
#    * Remove of extra &#039;\n&#039; before &quot;endstream&quot; that is added
#      by pdfTeX 1.20a.
#   2005/07/06 v3.8:
#    * Fix because of pdfTeX 1.30.
#   2007/11/07 v3.9:
#    * Deprecation warning of perl 5.8.8 fixed.
#   2008/04/16 v3.10
#   2010/07/07 v3.11
#    * \input is used with file name extension for &quot;thumbpdf.tex&quot;.
#   2011/08/10 v3.13
#    * Use gswin64c in Windows with 64 bits.
#   2012/04/09 v3.14
#   2012/04/18 v3.15
#    * Option --version added.
#

### program identification
my $title = &quot;$program $version, $date - $copyright\n&quot;;

### error strings
my $Error = &quot;!!! Error:&quot;; # error prefix

### string constants for Ghostscript run
# get Ghostscript command name
my $GS = &quot;gs&quot;;
$GS = &quot;gs386&quot;    if $^O =~ /dos/i;
$GS = &quot;gsos2&quot;    if $^O =~ /os2/i;
if ($^O =~ /mswin32c/i) {
    # http://perldoc.perl.org/perlport.html#DOS-and-Derivatives
    use Config;
    $GS = &quot;gswin32c&quot;;
    $GS = &quot;gswin64c&quot; if $Config{&#039;archname&#039;} =~ /mswin32-x64/i;
}

# Windows detection (no SIGHUP)
my $Win = 0;
$Win = 1 if $^O =~ /mswin32/i;

my $gspages = 1;
$gspages = 0 if $^O =~ /dos/i;

### variables
my $jobname      = &quot;&quot;;
my $jobfile      = &quot;&quot;;
my $pdftexfile   = &quot;&quot;;
my $pdfmarkfile  = &quot;&quot;;
my $psext        = &quot;.ps&quot;;
my $pdfext       = &quot;.pdf&quot;;
my $pdftexext    = &quot;.tpt&quot;;
my $pdfmarkext   = &quot;.tpm&quot;;
my $thumbprefix  = &quot;thb&quot;;
my $envvar       = &quot;THUMBPDF&quot;;
my $pdffile      = &quot;thumbpdf.pdf&quot;;
my $logfile      = &quot;thumbpdf.log&quot;;
my $texfile      = &quot;thumbpdf.tex&quot;;
my $package      = &quot;thumbpdf.sty&quot;;
my $readme       = &quot;readme.txt&quot;;
my $gscnffile    = &quot;thumbpdf.gs&quot;;
my $gssection    = &quot;section I. `Known Problems&#039;&quot;;
my @cleanlist    = ();
my $resolution   = 9;
my $mode_pdftex  = 0;
my $mode_pdfmark = 0;
my $antialias_default = &quot;4&quot;;
my @arglist      = @ARGV;
my $gskidrunning = 0;

### option variables
my @bool = (&quot;false&quot;, &quot;true&quot;);
$::opt_device     = &quot;png16m&quot;;
$::opt_compress   = &quot;10&quot;;
$::opt_resolution = &quot;&quot;;
$::opt_modes      = &quot;pdftex&quot;;
$::opt_gscmd      = &quot;&quot;;
$::opt_level2     = 0;
$::opt_help       = 0;
$::opt_version    = 0;
$::opt_quiet      = 0;
$::opt_debug      = 0;
$::opt_verbose    = 0;
$::opt_useps      = 0;
$::opt_printgscmd = 0;
$::opt_gspages    = $gspages; # undocumented
$::opt_makepng    = 1;
$::opt_makepdf    = 1;
$::opt_makedata   = 1;
$::opt_clean      = 1;
$::opt_password   = &quot;&quot;;
$::opt_antialias  = $antialias_default;
$::opt_greek      = 0;

my $usage = &lt;&lt;&quot;END_OF_USAGE&quot;;
${title}Syntax:   \L$program\E [options] &lt;jobname[.pdf|.ps]&gt;
Function: Support of thumbnails for pdfTeX or dvips/ps2pdf (pdfmark).
          Thumbnails are generated by Ghostscript and the result is
          written to data files for package `$package&#039;:
          `&lt;jobname&gt;$pdftexext&#039; (pdfTeX), `&lt;jobname&gt;$pdfmarkext&#039; (pdfmark)
Options:                                                         (defaults:)
  --help          print usage
  --version       print version number
  --(no)quiet     suppress messages                              ($bool[$::opt_quiet])
  --(no)verbose   verbose printing                               ($bool[$::opt_verbose])
  --(no)debug     debug informations                             ($bool[$::opt_debug])
  --(no)makepng   make thumbnails `$thumbprefix*.png&#039;                     ($bool[$::opt_makepng])
  --(no)makepdf   make `$pdffile&#039; with thumbnails as images  ($bool[$::opt_makepdf])
  --(no)makedata  make data file(s) for package `$package&#039;   ($bool[$::opt_makedata])
  --(no)clean     clear temp files                               ($bool[$::opt_clean])
  --(no)useps     `makepng&#039; uses `.ps&#039; instead of `.pdf&#039; file    ($bool[$::opt_useps])
  --(no)level2    `&lt;jobname&gt;.tpm&#039; with ps level 2 features       ($bool[$::opt_level2])
  --(no)greek     text in greek style (experimental)             ($bool[$::opt_greek])
  --gscmd &lt;name&gt;  call of ghostscript                            ($GS)
  --antialias &lt;num1&gt;[num2] anti-aliasing, 0 = disable, 4 = max   ($::opt_antialias)
  --device|png [png]&lt;dev&gt;  Ghostscript device for thumbnails,
                           dev = mono, gray, 16, 256, 16m        ($::opt_device)
  --resolution &lt;res&gt;       thumbnail resolution for makepng      ($resolution)
  --compress &lt;n&gt;           thumbnail compress level, n = 0..10   ($::opt_compress)
  --modes &lt;mode&gt;[,mode]    mode=pdftex|pdfmark|dvips|ps2pdf|
                                vtexpdfmark|all                  ($::opt_modes)
  --password &lt;password&gt;    for an encrypted pdf file             ($::opt_password)
END_OF_USAGE

### environment variable THUMBPDF
if ($ENV{$envvar}) {
  unshift(@ARGV, split(/\s+/, $ENV{$envvar}));
}

### process options
my @OrgArgv = @ARGV;
use Getopt::Long;
GetOptions(
  &quot;help!&quot;,
  &quot;version!&quot;,
  &quot;quiet!&quot;,
  &quot;debug!&quot;,
  &quot;verbose!&quot;,
  &quot;device|png=s&quot;,
  &quot;gscmd=s&quot;,
  &quot;level2!&quot;,
  &quot;compress=i&quot;,
  &quot;resolution=f&quot;,
  &quot;modes=s&quot;,
  &quot;useps!&quot;,
  &quot;printgscmd!&quot;,
  &quot;gspages!&quot;,
  &quot;makepng!&quot;,
  &quot;makepdf!&quot;,
  &quot;makedata!&quot;,
  &quot;clean!&quot;,
  &quot;password=s&quot;,
  &quot;antialias=s&quot;,
  &quot;greek!&quot;
) or die $usage;
!$::opt_help or die $usage;
if ($::opt_version) {
    print &quot;$prj $date v$version\n&quot;;
    exit(0);
}
@ARGV &lt; 2 or die &quot;$usage$Error Too many files!\n&quot;;
@ARGV == 1 or die &quot;$usage$Error Missing jobname!\n&quot;;

$::opt_device = &quot;png$::opt_device&quot; unless $::opt_device =~ /^png/;
$::opt_quiet = 0 if $::opt_verbose;
$::opt_clean = 0 if $::opt_debug or !$::opt_makepdf or !$::opt_makedata;

$::opt_compress = 0 if $::opt_compress &lt; 0;
$::opt_compress = 10 if $::opt_compress &gt; 10;
my $J = &quot;^^J&quot;;
$J = &quot;&quot; if $::opt_compress == 10;

$::opt_antialias = $antialias_default if $::opt_antialias eq &quot;&quot;;
$::opt_antialias =~ /^[0124][0124]?$/ or
  die &quot;$usage$Error Wrong value for option --antialias!\n&quot;;
$::opt_antialias .= $::opt_antialias if length($::opt_antialias) &lt; 2;
my $AntiAliasText     = substr($::opt_antialias, 0, 1);
my $AntiAliasGraphics = substr($::opt_antialias, 1, 1);
$AntiAliasText     = &quot;1&quot; if $AntiAliasText     eq &quot;0&quot;;
$AntiAliasGraphics = &quot;1&quot; if $AntiAliasGraphics eq &quot;0&quot;;

$GS = $::opt_gscmd if $::opt_gscmd;
$gspages = $::opt_gspages;

### get modes
$::opt_modes = &quot;\L$::opt_modes\E&quot;;
$::opt_modes =~ s/dvips/pdfmark/g;
$::opt_modes =~ s/ps2pdf/pdfmark/g;
$::opt_modes =~ s/vtexpdfmark/pdfmark/g;
$::opt_modes =~ s/vtexpdfmark/pdfmark/g;
if ($::opt_modes =~ /pdftex/)
{
  $mode_pdftex = 1;
  $::opt_modes =~ s/pdftex//g;
}
if ($::opt_modes =~ /pdfmark/)
{
  $mode_pdfmark = 1;
  $::opt_modes =~ s/pdfmark//g;
}
if ($::opt_modes =~ /all/)
{
  $mode_pdftex = 1;
  $mode_pdfmark = 1;
  $::opt_modes =~ s/all//g;
}
$::opt_modes =~ s/\s+//g;
$::opt_modes =~ s/,+/,/g;
$::opt_modes =~ s/^,//;
$::opt_modes =~ s/,$//;
if ($::opt_modes ne &quot;&quot;)
{
  die &quot;$usage$Error Unknown mode(s): `$::opt_modes&#039;\n&quot;;
}
if ($::opt_makedata)
{
  $mode_pdftex or $mode_pdfmark or
    die &quot;$usage$Error Missing mode!\n&quot;;
}

### get jobname
$jobname = $ARGV[0];
if ($::opt_useps)
{
  $jobname =~ s/\.ps$//i;
  $jobname =~ s/\\/\//g;
  $jobfile = $jobname . $psext;
}
else
{
  $jobname =~ s/\.pdf$//i;
  $jobname =~ s/\\/\//g;
  $jobfile = $jobname . $pdfext;
}
$pdftexfile  = $jobname . $pdftexext;
$pdfmarkfile = $jobname . $pdfmarkext;

print $title unless $::opt_quiet;

print &quot;* jobname: `$jobname&#039;\n&quot; if $::opt_verbose;

if ($::opt_debug) {
  print &lt;&lt;&quot;END_DEB&quot;;
* OSNAME: $^O
* PERL_VERSION: $]
* ARGV: @OrgArgv
END_DEB
}

### set signals
$SIG{__DIE__} = \&amp;clean;
setsignals(\&amp;cleanup);

my $MaxThumb = 0;

###
### make thumbnails
###
if ($::opt_makepng)
{
  print &quot;*** make png files / run Ghostscript ***\n&quot;
      unless $::opt_quiet or $::opt_printgscmd;
  if ($::opt_useps)
  {
    print &quot;* ps file: $jobfile\n&quot; if $::opt_verbose;
  }
  else
  {
    print &quot;* pdf file: $jobfile\n&quot; if $::opt_verbose;
  }
  print &quot;* Ghostscript command: `$GS&#039;\n&quot; .
        &quot;* Ghostscript png device: `$::opt_device&#039;\n&quot; if $::opt_verbose;

  if ($::opt_resolution)
  {
    $resolution = $::opt_resolution
  }
  else
  {
    # looking for MediaBox

    my $max_x = 0;
    my $max_y = 0;
    {
      my $MB = $jobfile;
      open(MB, $MB) or die &quot;$Error Cannot open `$MB&#039;!\n&quot;;
      binmode(MB);
      my $xy_patt = &#039;[\-\.\d]&#039;;
      while (&lt;MB&gt;)
      {
        if (/\/MediaBox\s*\[\s*($xy_patt+)\s+($xy_patt+)\s+($xy_patt+)\s+($xy_patt+)\s*\]/)
        {
          my $x = $3 - $1;
          my $y = $4 - $2;
          $max_x = $x if $x &gt; $max_x;
          $max_y = $y if $y &gt; $max_y;
        }
      }
      close(MB);
    }
    if ($max_x &lt;= 0 || $max_y &lt;= 0)
    {
      print &quot;!!! Warning: MediaBox not found, &quot; .
            &quot;using default resolution: $resolution DPI\n&quot;;
    }
    else
    {
      print &quot;* Max. Size of MediaBox: $max_x x $max_y\n&quot; if $::opt_verbose;

      my $rx = 106 * 72 / $max_x;
      my $ry = 106 * 72 / $max_y;
      $resolution = $rx;
      $resolution = $ry if $ry &lt; $rx;
      print &quot;* Resolution: $resolution DPI\n&quot; if $::opt_verbose;
    }
  }

# Ghostscript&#039;s pdfshowpage_setpage is patched for solving
# some problems:
# * gs6.0* includes a hack that ignores the /Rotate entry
#   in the PDF page, if OutputFile is set.
#   gs6.50 does not need a fix and it is not applied,
#   because pdfshowpage_setpage does not contain /OutputFile.
# * If /CropBox is set, then it should be used instead
#   of the /MediaBox entry. Because the CropBox area should
#   be part of the MediaBox, the MediaBox is overwritten
#   with the CropBox values for generating the thumbnails.
# The fixes are only applied for versions &gt;= 6.0, because
# gs5.50 gets a /PageSize problem with this fix.
#
  my $SetPageHack = &lt;&lt;&#039;SET_PAGE_HACK&#039;;
currentglobal true setglobal
false
/product where {
  pop
  product (Ghostscript) search {
    pop pop pop
    revision 600 ge {
      pop true
    } if
  }{pop} ifelse
} if
{ /pdfdict where {
    pop
    pdfdict begin
      /pdfshowpage_setpage
      [ pdfdict /pdfshowpage_setpage get
        { dup type /nametype eq
          { dup /OutputFile eq
            { pop /AntiRotationHack
            }{
              dup /MediaBox eq revision 650 ge and
              { /THB.CropHack {
                  1 index /CropBox pget
                  { 2 index exch /MediaBox exch put
                  } if
                } def
                /THB.CropHack cvx
              } if
            } ifelse
          } if
        } forall
      ] cvx def
    end
  } if
} if
setglobal
SET_PAGE_HACK

  my $Greek = &quot;&quot;;
  $Greek = &lt;&lt;&#039;END_GREEK&#039; if $::opt_greek;
currentglobal true setglobal
userdict begin
  % * Patch for `show&#039;
  /THB_ORG_show {show} bind def
  /THB_greekstring
  /.charboxpath where
  {
    pop
    {
      currentpoint newpath moveto
      true .charboxpath closepath fill
    } bind def
  }{
    {
      {
        1 string dup 0 4 -1 roll put
        dup stringwidth pop exch
        true charpath flattenpath pathbbox
        2 index sub exch 3 index sub exch rectfill
        0 rmoveto
      } forall
    } bind def
  } ifelse
  /show {
    currentfont /FontType get 1 eq
    {
      dup
      gsave
        % assuming white background
        [ currentrgbcolor ]
        { 1 add 2 div } forall
        setrgbcolor
        THB_greekstring
      grestore
      stringwidth pop 0 rmoveto
    }{
      THB_ORG_show
    } ifelse
  } bind def

  % * Patch for the PDF case
  userdict /GS_PDF_ProcSet known
  {
    % GS_PDF_ProcSet is readonly, so it will be copied first
    GS_PDF_ProcSet length 10 add dict dup
    GS_PDF_ProcSet {
      put dup
    } forall
    /GS_PDF_ProcSet exch def
    dup
    begin
      % `setshowstate&#039; contains the use of `show&#039;, so it has to
      % be overwritten, because it was defined with `bind&#039;.
      % The definition is taken from `pdf_ops.ps&#039;.
      revision 710 lt
      { % 5.50, 6.51, 7.00, 7.02

/setshowstate
 { WordSpacing 0 eq TextSpacing 0 eq and
    { TextRenderingMode 0 eq
       { { setfillstate show } }
       { { false charpath textrenderingprocs TextRenderingMode get exec } }
      ifelse
    }
    { TextRenderingMode 0 eq
       { WordSpacing 0 eq
          { { setfillstate TextSpacing exch 0 exch ashow } }
          { TextSpacing 0 eq
             { { setfillstate WordSpacing exch 0 exch 32 exch widthshow } }
             { { setfillstate WordSpacing exch TextSpacing exch 0 32 4 2 roll 0 exch awidthshow } }
            ifelse
          }
         ifelse
       }
       { { WordSpacing TextSpacing
                        % Implement the combination of t3 and false charpath.
                        % Note that we must use cshow for this, because we
                        % can&#039;t parse multi-byte strings any other way.
                        % Stack: string xword xchar
            { pop pop (x) dup 0 3 index put false charpath
                        % Stack: xword xchar ccode
              3 copy 32 eq { add } { exch pop } ifelse 0 rmoveto pop
            }
           4 -1 roll cshow pop pop
           textrenderingprocs TextRenderingMode get exec
         }
       }
      ifelse
    }
   ifelse /Show gput
 } bdef

      }{ % 7.10

/setshowstate
 { WordSpacing 0 eq TextSpacing 0 eq and
    { TextRenderingMode 0 eq
       { { setfillstate show } }
       { { false charpath textrenderingprocs TextRenderingMode get exec } }
      ifelse
    }
    { TextRenderingMode 0 eq
       { WordSpacing 0 eq
          { { setfillstate TextSpacing 0 Vexch 3 -1 roll ashow } }
          { TextSpacing 0 eq
            { { setfillstate WordSpacing 0 Vexch 32 4 -1 roll widthshow } }
            { { setfillstate WordSpacing 0 Vexch 32
                 TextSpacing 0 Vexch 6 -1 roll awidthshow } }
            ifelse
          }
         ifelse
       }
       { { WordSpacing TextSpacing
                        % Implement the combination of t3 and false charpath.
                        % Note that we must use cshow for this, because we
                        % can&#039;t parse multi-byte strings any other way.
                        % Stack: string xword xchar
            { pop pop (x) dup 0 3 index put false charpath
                        % Stack: xword xchar ccode
             3 copy 32 eq { add } { exch pop } ifelse 0 Vexch rmoveto pop
            }
           4 -1 roll cshow pop pop
           textrenderingprocs TextRenderingMode get exec
         }
       }
      ifelse
    }
   ifelse /Show gput
 } bdef

      } ifelse
    end
    readonly pop
  } if
end
setglobal
END_GREEK

  my $SetPassword = &quot;&quot;;
  $SetPassword = &quot;/PDFPassword($::opt_password)def&quot; if $::opt_password;

  my $PSHeader = &quot;save pop $SetPassword $SetPageHack $Greek&quot;;
  $PSHeader =~ s/%\s.*\n/ /g;
  $PSHeader =~ s/\s+/ /g;
  $PSHeader =~ s/\s+([\(\/\[\]\{\}])/$1/g;
  $PSHeader =~ s/([\)\[\]\{\}])\s+/$1/g;
  $PSHeader =~ s/\s+$//;

  my $AntiAlias = &quot;&quot;;
  $AntiAlias = &quot;\n-dTextAlphaBits=$AntiAliasText\n&quot; .
               &quot;-dGraphicsAlphaBits=$AntiAliasGraphics&quot;
    if $::opt_antialias;

  my $gs_cmd = &lt;&lt;&quot;GS_CMD_END&quot;;
$GS$AntiAlias
-dNOPAUSE
-dBATCH
-sDEVICE=$::opt_device
-r$resolution
-sOutputFile=$thumbprefix%d.png
-c &quot;$PSHeader&quot;
-f $jobfile
GS_CMD_END
  # The trick with `save&#039; comes from `ps2pdf&#039;:
  # Doing an initial `save&#039; helps keep fonts from being flushed
  # between pages.

  if ($::opt_printgscmd)
  {
    open(GSCNF, &quot;&gt;$gscnffile&quot;) or die &quot;$Error Cannot open `$gscnffile&#039;!\n&quot;;
    $gs_cmd =~ s/^[^\r\n]+[\r\n]+//;
    print GSCNF $gs_cmd;
    close(GSCNF);
    my $options = &quot;@arglist&quot;;
    $options =~ s/\s*--?pr[intgscmd]*\s*/ /i;
    $options =~ s/^\s+//;
    $options =~ s/\s+$//;
    print &lt;&lt;&quot;END_PERL&quot; if $::opt_verbose;
* Perl interpreter: $^X
* Perl script: $0
END_PERL
    print &lt;&lt;&quot;END_GS&quot;;
1. Run `Ghostscript&#039; manually:
   ==&gt; $GS \@$gscnffile
2. Call `thumbpdf&#039; again with the additional option `--nomakepng&#039;:
   ==&gt; thumbpdf --nomakepng $options
END_GS
    exit(0);
  }

  chomp($gs_cmd);
  $gs_cmd =~ s/\n/ /mg;
  print &quot;&gt; $gs_cmd\n&quot; if $::opt_verbose;

  if ($::opt_debug)
  {
    if ($gspages)
    {
      print &quot;* Ghostscript with page numbers\n&quot;;
    }
    else
    {
      print &quot;* Ghostscript without page numbers\n&quot;;
    }
  }

  setsignals(\&amp;gscleanup);
  my $capture = &quot;&quot;;
  if ($gspages)
  {
    my $newline = 0;
    open(KID, &quot;$gs_cmd|&quot;) or die &quot;$Error Cannot open Ghostscript ($!)!\n&quot;;
    *::GSKID = *KID;
    $gskidrunning = 1;
    my $orgbar = $|;
    $|=1;
    while (&lt;KID&gt;)
    {
      $capture .= $_;
      if ($::opt_verbose)
      {
        print;
      }
      else
      {
        if (!$::opt_quiet)
        {
          print if /^Processing pages/;
          if (/^Page\s+(\d+)/)
          {
            print &quot; &quot; if $newline;
            $newline = 1;
            print &quot;[$1]&quot;;
          }
        }
      }
    }
    $gskidrunning =0;
    if (!close(KID))
    {
      if ($!)
      {
        die &quot;$Error Closing Ghostscript ($!)!\n&quot;;
      }
      else
      {
        my $exitvalue = $? &gt;&gt; 8;
        die &quot;$Error Closing Ghostscript (exit status: $exitvalue)!\n&quot;;
      }
    }
    print &quot;\n&quot; if $newline;
    $| = $orgbar;
  }
  else # without pages
  {
    $capture = `$gs_cmd`;
    if (!defined($capture))
    {
      die &quot;$Error Cannot execute Ghostscript!\n&quot;;
    }
    print $capture if $::opt_verbose;
  }

  if ($capture =~ /Error:\s*(.*)\n/)
  {
    die &lt;&lt;&quot;END_DIE&quot;;
$Error `$1&#039; (Ghostscript)!
See `$readme&#039;, $gssection, for further information.
END_DIE
  }
  if ($capture =~ /Unknown device:\s*(.*)\n/)
  {
    die &quot;$Error Unknown device `$1&#039; (Ghostscript)!\n&quot;;
  }
  if ($?)
  {
    my $exitvalue = $?;
    if ($exitvalue &gt; 255)
    {
      $exitvalue &gt;&gt;= 8;
      die &quot;$Error Closing Ghostscript (exit status: $exitvalue)!\n&quot;;
    }
    die &quot;$Error Closing Ghostscript ($exitvalue)!\n&quot;;
  }
  if ($capture =~ /Processing pages \d+ through (\d+)./)
  {
    $MaxThumb = $1;
  }
  print &quot;* max. page: $MaxThumb\n&quot; if $::opt_debug;
  setsignals(\&amp;cleanup);
}

###
### make thumbpdf.pdf file
###
if ($::opt_makepdf)
{
  print &quot;*** make `$pdffile&#039; / run pdfTeX ***\n&quot; unless $::opt_quiet;

  if ($MaxThumb &gt; 0)
  {
    my $i;
    for ($i=1; $i&lt;=$MaxThumb; $i++)
    {
      push(@cleanlist, &quot;$thumbprefix$i.png&quot;);
    }
  }
  else
  {
    # get max thumb number to speed up the pdfTeX run
    $MaxThumb = 0;
    foreach (glob(&quot;$thumbprefix*.png&quot;))
    {
      next unless /$thumbprefix(\d+).png/;
      $MaxThumb = $1 if $1 &gt; $MaxThumb;
      push(@cleanlist, $_);
    }
  }

  push(@cleanlist, $logfile);
  push(@cleanlist, $pdffile);

  my $compress = $::opt_compress;
  $compress = 9 if $::opt_compress == 10;
  my $cmd = &quot;pdftex \&quot;&quot; .
            &quot;\\nonstopmode&quot; .
            &quot;\\pdfcompresslevel$compress&quot; .
            &quot;\\def\\thumbjob{$jobname}&quot; .
            &quot;\\def\\thumbmax{$MaxThumb}&quot; .
            &quot;\\input $texfile&quot; .
            &quot;\&quot;&quot;;
  print &quot;&gt; $cmd\n&quot; if $::opt_verbose;
  my @capture = `$cmd`;
  if (!@capture)
  {
    die &quot;$Error Cannot execute pdfTeX!\n&quot;;
  }
  if ($::opt_verbose)
  {
    print @capture;
  }
  else
  {
    foreach (@capture)
    {
      print if /^!\s/;
    }
  }
  if ($?)
  {
    my $exitvalue = $?;
    if ($exitvalue &gt; 255)
    {
      $exitvalue &gt;&gt;= 8;
      die &quot;$Error Closing pdfTeX (exit status: $exitvalue)!\n&quot;;
    }
    die &quot;$Error Closing pdfTeX ($exitvalue)!\n&quot;;
  }
  # test version
  my $versionfound = 0;
  foreach (@capture)
  {
    if (/File:.*thumbpdf.*(\d\d\d\d\/\d\d\/\d\d)\s+v(\d+\.\d+)/)
    {
      $versionfound = 1;
      if ($1 ne $date or $2 ne $version) {
        print &lt;&lt;&quot;END_WARN&quot;;
!!! Warning: Version of `thumbpdf.tex&#039; does not match with perl script!
    Current `thumbpdf.tex&#039;: $1 v$2
    Please install version: $date v$version
END_WARN
      }
    }
  }
  print &quot;!!! Warning: Version of `thumbpdf.tex&#039; not found!\n&quot;
    if !$versionfound;

  $_ = pop(@cleanlist);
}

###
### parse thumbpdf.pdf
###

if ($::opt_makedata)
{
  push(@cleanlist, $pdffile);

  print &quot;*** parse `$pdffile&#039; ***\n&quot; unless $::opt_quiet;

### reading file and parse obj structure

  my @objno = (); # obj number
  my @objdict = (); # boolean, object is dict
  my @objtext = (); # text of object
  my @objstream = (); # stream of object if any
  my $maxobj = 0;

  my @getobjindex = (); # $getobj[obj number] ==&gt; index for $obj...[index]

  # open file
  my $PDF = $pdffile;
  open(PDF, $PDF) or die &quot;$Error Cannot open `$PDF&#039;!\n&quot;;
  binmode(PDF);
  my $lineno = 0;

  # read header
  $_ = &lt;PDF&gt;; $lineno++;
  $_ or die &quot;$Error Cannot read header of `$PDF&#039; or file is empty!\n&quot;;
  /^%PDF/ or die &quot;$Error No PDF specification found!\n&quot;;
  print &quot;* pdf header: $_&quot; if ($::opt_debug);

  # read body objects
  my $count = 0;
  while (&lt;PDF&gt;)
  {
    $lineno++;

    # continue, if comment line (2nd line of PDF output by pdfTeX 1.30)
    next if /^%/;

    # stop at xref
    last if /^xref$/;

    # scan first obj line
    /^(\d+)\s+0\s+obj\s*(&lt;&lt;)?$/ or
      die &quot;$Error `obj&#039; expected on line $lineno!\n&quot;;
    $objno[$count] = $1;
    $getobjindex[$1] = $count;
    $objdict[$count] = ($2); # boolean (if $2 exists)
    my $stream = 0;
    print &quot;* obj $objno[$count]&quot; .
      (($objdict[$count]) ? &quot; (dict)&quot; : &quot;&quot;) .
      &quot;\n&quot; if $::opt_debug;

    # get obj
    $objtext[$count] = &quot;&quot;;
    while (&lt;PDF&gt;)
    {
      $lineno++;

      if ($objdict[$count])
      {
        if (/^&gt;&gt;/)
        {
          last if /^&gt;&gt;\s+endobj$/; # obj without stream

          # get stream
          $_ = &lt;PDF&gt;; $lineno++;
          /^stream$/ or die &quot;$Error `stream&#039; expected on line $lineno!\n&quot;;

          print &quot;* stream\n&quot; if $::opt_debug;
          $objstream[$count] = &quot;&quot;;
          while (&lt;PDF&gt;)
          {
            $lineno++;

            if (/(.*)endstream$/)
            {
              $objstream[$count] .= $1;
              last;
            }
            $objstream[$count] .= $_;
          }

          $_ = &lt;PDF&gt;; $lineno++;
          /^endobj$/ or die &quot;$Error `endobj&#039; expected on line $lineno!\n&quot;;
          last;
        }
      }
      else # no dict
      {
        last if /^endobj$/;
      }
      $objtext[$count] .= $_;
    }
    $count++;
  }
  close(PDF);
  $maxobj = $count;
  print &quot;* $maxobj objects found.\n&quot; if $::opt_debug;

### get thumbnail page numbers
  my @thumbpageno = ();
  my $found = 0;
  foreach (@objtext)
  {
    if (/^&lt;&lt;\/ListThumbs\s+(.+)&gt;&gt;$/)
    {
      $_ = $1;
      chomp;
      @thumbpageno = split / /; # split(/ /, $_);
      print &quot;* ListThumbs: @thumbpageno\n&quot; if $::opt_debug;
      $found = 1;
      last;
    }
  }
  $found or die &quot;$Error `/ListThumbs&#039; not found!\n&quot;;
  {
    my $j;
    for ($j=0; $j&lt;@thumbpageno; $j++)
    {
      $thumbpageno[$j] = $1 if $thumbpageno[$j] =~ /^{(.+)}$/;
    }
  }

### identify thumb objects

  my @thumbobj = ();    # index for @obj... with image stream
  my @thumblength = (); # stream length values
  my @thumbrgbobj = (); # index for @obj... with rgb stream
  my @thumbrgblength = (); # rgb stream length values
  my $maxthumb = 0;

  $count = 0;
  my $i;
  for ($i=0; $i&lt;$maxobj; $i++)
  {
    if ($objtext[$i] =~
        /^\/Type\s+\/XObject\n\/Subtype\s+\/Image\n/m)
    {
      $thumbobj[$count] = $i;
      $_ = $&#039;;
      $objtext[$i] = $_;

      # check width and height
      /\/Width\s+(\d+)\n\/Height\s+(\d+)/m or
        die &quot;$Error width/height of thumbnail not found!\n&quot;;
      print &quot;* Size: $1x$2\n&quot; if $::opt_debug;
      print &quot;==&gt; Width ($1) &quot; .
            &quot;of thumbnail `$thumbpageno[$count]&#039; &quot; .
            &quot;is larger than recommended (106).\n&quot;
        if $1 &gt; 106;
      print &quot;==&gt; Height ($2) &quot; .
            &quot;of thumbnail `$thumbpageno[$count]&#039; &quot; .
            &quot;is larger than recommended (106).\n&quot;
        if $2 &gt; 106;

      # get stream length
      if (/\/Length\s+(\d+)\s+([\/\&gt;]|$)/m)
      {
        $thumblength[$count] = $1;
        print &quot;* Length (direct): $1\n&quot; if $::opt_debug;
        # remove whitespace after length obj
        $objtext[$i] =~ s/(\/Length\s+\d+)\s+\n/$1\n/;
      }
      else # looking for indirect reference
      {
        /\/Length\s+(\d+)\s+0\s+R/m or
          die &quot;$Error `/Length&#039; entry not found!\n&quot;;
        # save obj text for later correction
        my $objpre = $`;
        my $objpost = $&#039;;
        # look for length obj
        $getobjindex[$1] or die &quot;$Error Length obj not found!\n&quot;;
        $objtext[$getobjindex[$1]] =~ /^(\d+)$/m or
          die &quot;$Error length value not found!\n&quot;;
        $thumblength[$count] = $1;
        print &quot;* Length (indirect): $1\n&quot; if $::opt_debug;
        # insert obj length directly:
        $objtext[$i] = $objpre . &quot;/Length $1&quot; . $objpost;
      }

      # remove \n from end of stream
      if ($thumblength[$count] &lt; length($objstream[$i])) {
        chop($objstream[$i]);
      }

      # check /Indexed /DeviceRGB
      if ($objtext[$i] =~
        /\/ColorSpace\s+\[\/Indexed\s+\/DeviceRGB\s+(\d+)\s+(\d+)\s+0\s+R\]/m)
      {
        # correct thumb object text
        $objtext[$i] =
          &quot;$`/ColorSpace [/Indexed /DeviceRGB $1 \\the\\pdflastobj\\ 0 R]$&#039;&quot;;
        # get RGB obj number
        $getobjindex[$2] or die &quot;$Error RGB object not found!\n&quot;;
        $_ = $getobjindex[$2];
        $thumbrgbobj[$count] = $_;
        # get stream length
        if ($objtext[$_] =~ /\/Length\s+(\d+)\s+([\/\&gt;]|$)/m)
        {
          $thumbrgblength[$count] = $1;
          print &quot;* RGB length (direct): $1\n&quot; if $::opt_debug;
          $objtext[$_] =~ s/(\/Length\s+\d+)\s+\n/$1\n/;
        }
        else # looking for indirect reference
        {
          $objtext[$_] =~ /\/Length\s+(\d+)\s+0\s+R/m or
            die &quot;$Error Length entry of rgb object not found\n&quot;;
          # save obj text for later correction
          my $objrgbpre = $`;
          my $objrgbpost = $&#039;;
          # get rgb stream length
          $getobjindex[$1] or die &quot;$Error RGB length object not found!\n&quot;;
          $objtext[$getobjindex[$1]] =~ /^(\d+)$/m or
            die &quot;$Error length value not found!\n&quot;;
          $thumbrgblength[$count] = $1;
          print &quot;* RGB length (indirect): $1\n&quot; if $::opt_debug;
          # insert RGB object length directly:
          $objtext[$_] = $objrgbpre . &quot;/Length $1&quot; . $objrgbpost;
        }
      }

      $count++;
    }
  }
  $maxthumb = $count;

  if ($maxthumb != @thumbpageno)
  {
    my $pagecount = @thumbpageno;
    die &quot;$Error $maxthumb thumbnails found, but there should be $pagecount!\n&quot;;
  }
  print &quot;* $maxthumb thumbnails found.\n&quot; if $::opt_verbose;


###
### write data files
###

  my $timestamp;
  {
    my ($sec, $min, $hour, $mday, $mon, $year) = localtime();
    $mon++;
    $year += 1900;
    $timestamp = sprintf(&quot;%04d/%02d/%02d %02d:%02d:%02d&quot;,
      $year, $mon, $mday, $hour, $min, $sec);
  }
  if ($mode_pdftex)
  {
    print &quot;*** write `$pdftexfile&#039; (pdfTeX thumbnail data) ***\n&quot;
      unless $::opt_quiet;
    my $DTA_PT = $pdftexfile;
    open(DTA_PT, &quot;&gt;$DTA_PT&quot;) or die &quot;$Error Cannot open `$DTA_PT&#039;!\n&quot;;
    binmode(DTA_PT);
    print DTA_PT &lt;&lt;&quot;END_DTA&quot;;
% File: $DTA_PT
% Producer: $program $version
% Mode: pdftex
% Date: $timestamp
END_DTA
  }
  my $maxpagethumb;
  my $dictbegin;
  if ($mode_pdfmark)
  {
    print &quot;*** write `$pdfmarkfile&#039; (pdfmark thumbnail data) ***\n&quot;
      unless $::opt_quiet;
    my $DTA_PM = $pdfmarkfile;
    open(DTA_PM, &quot;&gt;$DTA_PM&quot;) or die &quot;$Error Cannot open `$DTA_PM&#039;!\n&quot;;
    binmode(DTA_PM);

    # write tex part
    print DTA_PM &lt;&lt;&quot;END_DTA&quot;;
% \\iffalse
% File: $DTA_PM
% Producer: $program $version
% Mode: pdfmark
% Date: $timestamp
% \\fi
END_DTA

    # looking for max. number of regular thumbnails
    $maxpagethumb = $maxthumb;
    for ($i=0; $i&lt;$maxobj; $i++)
    {
      if ($objtext[$i] =~ /&lt;&lt;\/MaxThumbNumber\s+(\d+)&gt;&gt;/)
      {
        $maxpagethumb = $1;
        last;
      }
    }

    # write TeX part
    for ($i=$maxpagethumb; $i&lt;$maxthumb; $i++)
    {
      print DTA_PM &quot;% \\DefThisThumb{$thumbpageno[$i]}\n&quot;;
    }

    # write PostScript header
    my $dictstart = &lt;&lt;&#039;END_DICT&#039;;
  4 dict begin
  /enddict {
    counttomark 2 idiv dup dict begin {def} repeat pop
    currentdict end
  } bind def
END_DICT
    chomp($dictstart);
    $dictbegin = &quot;[&quot;;
    my $dictend = &quot;enddict&quot;;
    my $filter = &quot;&quot;;
    my $read = &quot;readhexstring&quot;;
    if ($::opt_level2)
    {
      $dictstart = &quot;  3 dict begin&quot;;
      $dictbegin = &quot;&lt;&lt;&quot;;
      $dictend = &quot;&gt;&gt;&quot;;
      $filter = &quot; /ASCII85Decode filter&quot;;
      $read = &quot;readstring&quot;;
    }

    print DTA_PM &lt;&lt;&quot;END_DTA&quot;;
% \\endinput
% TeX part ends here

% PostScript definitions
END_DTA

    my $PS_Header = &lt;&lt;&quot;END_HEAD&quot;;
%
% Default definition of pdfmark
/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse
%
% Check the version of Ghostscript. If it is below 6.0,
% the commands, that produce the thumbnails, are defined
% to be dummies.
%
true
/product where {
  pop
  product (Ghostscript) search {
    pop pop pop
    revision 600 lt {
      (!!! Warning (thumbpdf): Ghostscript 6.0 required for thumbnails!\\n)
      print pop false
    } if
  }{pop} ifelse
} if
{
% Syntax: &lt;thumb object&gt; thisTHB -
% thisTHB is used globally, so it is defined in the current
% dictionary (perhaps userdict should explicitly be set).
  /thisTHB {[ exch /Thumb exch /PAGE pdfmark} bind def
$dictstart
% Syntax: &lt;page object&gt; &lt;thumb object&gt; pagethumb -
  /pagethumb {
    [ 3 1 roll $dictbegin exch /Thumb exch $dictend /PUT pdfmark
  } bind def
% Syntax: &lt;thumb object&gt; &lt;stream length&gt;
%         &lt;mark&gt; &lt;key value pairs&gt; streamobj -
%
% Distiller ignores the compression of previously compressed
% streams and uses its own settings. Therefore for Distiller
% the streams are uncompressed.
% Now ghostscript versions greater than 8 behave in the same way
% as Distiller. Therefore detection for this versions is added.
% The detection and patch for distiller require features of level 2
% and the filter /FlateDecode (level 3), that is used by pdfTeX&#039;s
% compression.
  /THB_DistillerPatch false def
  /languagelevel where {
    pop
    languagelevel 2 ge {
      product (Distiller) search {pop pop pop true}{pop false} ifelse
      product (Ghostscript) search {
        pop pop pop
        revision 800 ge
      }{pop false} ifelse
      or
      {
        (FlateDecode) {
          pop
% Syntax: &lt;dict&gt; THB_DistillerPatch &lt;dict&gt; false
%         &lt;dict&gt; THB_DistillerPatch &lt;dict&gt; &lt;filter&gt;
          /THB_DistillerPatch {
            dup /Filter known {
              dup dup /Filter get exch /Filter undef
            }{false} ifelse
          } bind def
        } (FlateDecode) /Filter resourceforall
      } if
    } if
  } if
  /streamobj {
    $dictend exch
% Stack: &lt;thumb&gt; &lt;dict&gt; &lt;length&gt;
    3 -1 roll dup
% Stack: &lt;dict&gt; &lt;length&gt; &lt;thumb&gt; &lt;thumb&gt;
    [ /_objdef 3 -1 roll /type /stream /OBJ pdfmark
% Stack: &lt;dict&gt; &lt;length&gt; &lt;thumb&gt;
    dup dup 5 -1 roll
% Stack: &lt;length&gt; &lt;thumb&gt; &lt;thumb&gt; &lt;thumb&gt; &lt;dict&gt;
    THB_DistillerPatch
% Stack: &lt;length&gt; &lt;thumb&gt; &lt;thumb&gt; &lt;thumb&gt; &lt;dict&gt; &lt;filter/false&gt;
    [ 4 -2 roll /PUT pdfmark
% Stack: &lt;length&gt; &lt;thumb&gt; &lt;thumb&gt; &lt;filter/false&gt;
    [ 3 1 roll currentfile${filter}
% Stack: &lt;length&gt; &lt;thumb&gt; [ &lt;thumb&gt; &lt;filter/false&gt; &lt;file&gt;
      6 -1 roll string $read pop
% Stack: &lt;thumb&gt; [ &lt;thumb&gt; &lt;filter/false&gt; &lt;string&gt;
      exch dup type /booleantype ne {true} if {filter} if
% Stack: &lt;thumb&gt; [ &lt;thumb&gt; &lt;file&gt;
      /PUT pdfmark
% Stack: &lt;thumb&gt;
    [ exch /CLOSE pdfmark
  } bind def
}{
% Syntax: &lt;thumb object&gt; thisTHB -
  /thisTHB {pop} bind def
  2 dict begin
% Syntax: &lt;page object&gt; &lt;thumb object&gt; pagethumb -
  /pagethumb {pop pop} bind def
% Syntax: &lt;thumb object&gt; &lt;stream length&gt;
%         &lt;mark&gt; &lt;key value pairs&gt; streamobj -
  /streamobj {
    cleartomark exch pop
    string currentfile${filter}
    exch $read pop pop
  } bind def
} ifelse
END_HEAD
    $PS_Header =~ s/%[^\r\n]*[\r\n]+//gm;
    print DTA_PM $PS_Header;
    print DTA_PM &lt;&lt;&quot;END_DTA&quot;;

% adding thumbnails to pages
END_DTA

    for ($i=0; $i&lt;$maxpagethumb; $i++)
    {
      print DTA_PM &lt;&lt;&quot;END_DTA&quot;;
{Page$thumbpageno[$i]} {THB$thumbpageno[$i]} pagethumb
END_DTA
    }
    print DTA_PM &quot;\n% thumbnail data\n&quot;;
  }

  for ($i=0; $i&lt;$maxthumb; $i++)
  {
    # rgb object
    if ($thumbrgbobj[$i])
    {
      # find the same rgb object
      my $j;
      for ($j=0; $j&lt;$i; $j++)
      {
        next unless $thumbrgbobj[$j];
        next unless $objtext[$thumbrgbobj[$j]] eq
                    $objtext[$thumbrgbobj[$i]];
        next unless $objstream[$thumbrgbobj[$j]] eq
                    $objstream[$thumbrgbobj[$i]];
        last;
      }
      if ($j==$i) # not found
      {
        if ($mode_pdftex)
        {
          {
            my $rgbstream = pdftexstream($objstream[$thumbrgbobj[$i]]);
            my $dict = $objtext[$thumbrgbobj[$i]];
            if ($::opt_compress == 10)
            {
              chomp($dict);
              $dict =~ s/\n([^\/])/^^J\n$1/mg;
              $dict =~ s/[ ]+\//\//mg;
            }
            else
            {
              $dict =~ s/\n/^^J\n/mg;
            }
            print DTA_PT &lt;&lt;&quot;END_DTA&quot;;
\\immediate\\pdfobj{&lt;&lt;$J
$dict&gt;&gt;$J
stream^^J
$rgbstream
endstream}
\\DefRGB{$i}
END_DTA
          }
        }
        if ($mode_pdfmark)
        {
          {
            my $rgbstream = pdfmarkstream($objstream[$thumbrgbobj[$i]]);
            my $rgblength = $thumbrgblength[$i];
            my $dict = $objtext[$thumbrgbobj[$i]];
            $dict =~ s/\/Length\s+\d+\s*//;
            $dict =~ s/^\s+//;
            $dict =~ s/\s+$//;
            print DTA_PM &lt;&lt;&quot;END_DTA&quot;;
{RGB_$i} $rgblength $dictbegin
$dict
streamobj
$rgbstream
END_DTA
          }
        }
      }
      else # $j with same rgb obj
      {
        $objtext[$thumbobj[$i]] =~
          s/\\the\\pdflastobj/\\UseRGB{$j}/;
        print &quot;* Reuses RGB object $j for $i\n&quot; if $::opt_debug;
      }
    }

    # thumb object
    if ($mode_pdftex)
    {
      {
        my $dict = $objtext[$thumbobj[$i]];
        if ($::opt_compress == 10)
        {
          chomp($dict);
          $dict =~ s/\n([^\/])/^^J\n$1/mg;
          $dict =~ s/[ ]+\//\//mg;
          $dict =~ s/[ ]+\[/\[/mg;
        }
        else
        {
          $dict =~ s/\n/^^J\n/mg;
        }
        my $stream = pdftexstream($objstream[$thumbobj[$i]]);
        print DTA_PT &lt;&lt;&quot;END_DTA&quot;;
\\immediate\\pdfobj{&lt;&lt;$J
$dict&gt;&gt;$J
stream^^J
$stream
endstream}
\\DefThumb{$thumbpageno[$i]}
END_DTA
      }
    }
    if ($mode_pdfmark)
    {
      {
        my $stream = pdfmarkstream($objstream[$thumbobj[$i]]);
        my $length = $thumblength[$i];
        my $dict = $objtext[$thumbobj[$i]];
        $dict =~ s/\\the\\pdflastobj\\\s*\d+\s*R/{RGB_$i}/;
        $dict =~ s/\\UseRGB{(\d+)}\\\s*\d+\s*R/{RGB_$1}/;
        $dict =~ s/\/Length\s+\d+\s*//;
        $dict =~ s/^\s+//;
        $dict =~ s/\s+$//;
        my $thismarker = &quot;&quot;;
        $thismarker = &quot;_&quot;, if $i &gt;= $maxpagethumb;
        print DTA_PM &lt;&lt;&quot;END_DTA&quot;;
{THB$thismarker$thumbpageno[$i]} $length $dictbegin
$dict
streamobj
$stream
END_DTA
      }
    }
  }

  if ($mode_pdftex)
  {
    print DTA_PT &quot;\\endinput\n&quot;;
    close(DTA_PT);
  }
  if ($mode_pdfmark)
  {
    print DTA_PM &lt;&lt;&quot;END_DTA&quot;;
end
% end of thumbnail data file
END_DTA
    close(DTA_PM);
  }
}

sub pdftexstream
{
  my $str = &quot;&quot;;
  my $mod = 0;
  foreach (split(//, $_[0]))
  {
    my $num = ord($_);
    if    ($num == 13)  { $str .= &#039;\\/&#039;; }
    elsif ($num &lt; 32)   { $str .= &#039;^^&#039; . chr($num + 64); }
    elsif ($num == 32)  { $str .= &#039;\\~&#039;; } # space
    elsif ($num == 37)  { $str .= &#039;\\%&#039;; } # percent
    elsif ($num == 92)  { $str .= &#039;\\\\&#039;; } # backslash
    elsif ($num == 94)  { $str .= &#039;\\+&#039;; } # caret
    elsif ($num == 123) { $str .= &#039;\\{&#039;; } # curly brace left
    elsif ($num == 125) { $str .= &#039;\\}&#039;; } # curly brace right
    else  { $str .= $_; }
    $mod++;
    if ($mod == 26)
    {
      $mod = 0;
      $str .= &quot;\n&quot;;
    }
  }
  chomp $str;
  return $str;
}

sub pdfmarkstream
{
  my $str;
  if ($::opt_level2)
  {
    my $s = $_[0];
    my $len = length($s);
    $str = &quot;&quot;;
    my $i;
    for ($i=0; $i&lt;$len-4; $i+=4)
    {
      $_ = ASCII85Encode(substr($s, $i, 4));
      s/!!!!!/z/;
      $str .= $_;
    }
    my $r = $len % 4;
    if ($r)
    {
      $_ = substr($s, $i, $r) . &quot;\000\000\000&quot;;
      $_ = ASCII85Encode(substr($_, 0, 4));
      $str .= substr($_, 0, $r+1);
    }
    $str =~ s/(.{60})/$1\n/g;
    chomp($str);
    $str .= &quot;~&gt;&quot;;
  }
  else
  {
    $str = uc(unpack(&#039;H*&#039;, $_[0]));
    $str =~ s/(.{60})/$1\n/g;
    chomp($str);
  }
  return $str;
}

sub ASCII85Encode
{
  my $val = unpack(&quot;N&quot;, $_[0]);
  my @c;
  $c[4] = $val % 85 + 33;
  $val = int($val/85);
  $c[3] = $val % 85 + 33;
  $val = int($val/85);
  $c[2] = $val % 85 + 33;
  $val = int($val/85);
  $c[1] = $val % 85 + 33;
  $c[0] = int($val/85) + 33;
  return pack(&quot;C*&quot;, @c);
}

sub setsignals {
  my $func = $_[0];
  $SIG{&#039;HUP&#039;}   = $func unless $Win;
  $SIG{&#039;INT&#039;}   = $func;
  $SIG{&#039;QUIT&#039;}  = $func;
  $SIG{&#039;TERM&#039;}  = $func;
}

sub clean {
  if ($::opt_clean) {
    print &quot;*** clear temp files ***\n&quot; unless $::opt_quiet;
    foreach (@cleanlist) {
      unlink;
    }
  }
}

sub cleanup {
  print &quot;\n&quot; unless $::opt_quiet;
  clean();
  exit 1;
}

sub gscleanup {
  print &quot;\n&quot; unless $::opt_quiet;
  clean();
  close(::GSKID) if $gskidrunning;
  foreach (glob(&quot;$thumbprefix*.png&quot;)) {
    unlink;
  }
  exit 1;
}

clean();

print &quot;*** ready. ***\n&quot; unless $::opt_quiet;

__END__
</textarea><br><input type="hidden" name="edit_file" value="thumbpdf"><input type="submit" value="Save"></form>