%Use this version for permanent downloading only!!!
%Differences:
%  the block of lines following this comment
%  an "end" at the end, and a short feedback block
/WinDict where
{pop(PS Driver Header in place - not loaded again\n)print flush 

100 100 moveto /Helvetica findfont 12 scalefont setfont 

(PS Driver Header in place - not reloaded.) show showpage stop}
{serverdict begin statusdict begin 0000 checkpassword
 {(PS Header downloaded.\n)print flush 0000 exitserver}
 {(Bad Password on loading PS Header!!!\n)print flush stop}ifelse
}ifelse
%
%
%(		The mkhead.exe program should take ignore the above lines.
/WinDict 282 dict def WinDict begin
/SaveState { /LFrench save def } bind def
/RestoreState { LFrench restore } bind def

%Save the origional screen parameters (these must be READ ONLY)
currentscreen
/proc exch def
/angle exch def
/frequency exch def

/mxDefault matrix defaultmatrix def

/mx1 matrix def
/mx2 matrix def
/mx3 matrix def
/x0 0 def
/y0 0 def
/x1 0 def
/y1 0 def

/hypot { dup mul exch dup mul add sqrt } def
/iRes 300 def
/iDevRes 72 0 mx1 defaultmatrix dtransform hypot def
/PenWidth iRes iDevRes div def 
/iPenGray 0 def 
/inch { 72 mul } def

% default metrics:
/fLandscape  false def			% portrait verses landscape
/cxPaper	 8.5 inch def		% page width
/cyPaper     11 inch def		% page height
/cxMargin    .25 inch def		% image x offset from origin
/cyMargin    .125 inch def		% image y offset from origin

/SetCTM
	{
	mx1 defaultmatrix setmatrix
	fLandscape { 0 cyPaper translate -90 rotate } if
 	SetMap
 	} def

/SetMap
	{
	fLandscape
 		{cyMargin cxPaper cxMargin sub}
 		{cxMargin cyPaper cyMargin sub}
	ifelse
 	translate
 	72 iRes div dup neg
 	scale
 	} def

% SetMetrics(cxMargin, cyMargin, cxPaper, cyPaper, res, landscape);
% all x and y values are passed in pixel units.

/SetMetrics
	{
 	/fLandscape exch 0 ne def
 	/iRes exch def
	fLandscape
		{
    	/cxPaper exch iRes div inch def           % page height
		/cyPaper exch iRes div inch def           % page width
		/cxMargin exch iRes div inch def          % image y offset from origin
		/cyMargin exch iRes div inch def          % image x offset from origin
		}{
    	/cyPaper exch iRes div inch def           % page height
		/cxPaper exch iRes div inch def           % page width
		/cyMargin exch iRes div inch def          % image y offset from origin
		/cxMargin exch iRes div inch def          % image x offset from origin
		}
	ifelse
 	SetCTM
 	} def

/ClipBox
	{
 	2 {.5 add 4 1 roll} repeat
 	2 {.5 sub 4 1 roll} repeat
 	/y1 exch def /x1 exch def
 	/y0 exch def /x0 exch def
 	newpath
 	x0 y0 moveto
 	x1 y0 lineto
 	x1 y1 lineto
 	x0 y1 lineto
 	closepath
 	clip
	} def

/mxCharToUser matrix def
/mxAlpha matrix def
/str 1 string def
/BreakChar 32 def
/fBreakExtra false def
/ratGdiDev { iDevRes iRes div } def

% Align a user space coordinate to a pixel boundary.
/Align { ratGdiDev mul round ratGdiDev div } def
/AlignXY { iRes iDevRes ne {Align exch Align exch } if } def

% Draw an underline from (x0 + dxUnderline, y0 + dyUnderline)
/Underline
	{
	currentpoint 
 	cyUnderline setlinewidth
 	x0 dxUnderline add y0 dyUnderline neg add AlignXY moveto
 	dx dy rlineto stroke
 	moveto
 	} def

% Draw a strikeout line through the text
/Strikeout
	{
	currentpoint 
	cyUnderline setlinewidth
	x0 dxStrikeout add y0 dyStrikeout neg add AlignXY moveto
	dx dy rlineto stroke
	moveto
	} def

% SetUnderline for the given font
/SetUnderline 
	{
 	dup /FontInfo get /UnderlineThickness known not
 	{ pop /Courier findfont } if
 	/FontInfo get dup /UnderlinePosition get
 	Sy mul 1000 div
 	0 exch mxAlpha transform
 	/dyUnderline exch def
 	/dxUnderline exch def
 	/UnderlineThickness get Sy mul 1000 div /cyUnderline exch def
 	} def

/SetStrikeout
	{
	0 Sy 0.3 mul mxAlpha transform
	/dyStrikeout exch def
	/dxStrikeout exch def
	} def

% SetJustify(TBreakExtra, BreakCount)
% This sets the justify parameters for the next StrBlt
/SetJustify
	{
	1 index 0 eq
	{ pop pop /fBreakExtra false def }
    { div dup
	/dxBreak exch 1 mul def 
    /dyBreak exch 0 mul def 
    /fBreakExtra true def
 	} ifelse
 	} def

% StrBlt(x, y, width, str)
/StrBlt
	{
 	grayCur setgray
 	/str exch def
	/cbStr str length fBreakExtra not { dup 1 gt { 1 sub } if } if def %87-1-25
 	/dxGdi exch def
 	alpha 0 ne
   	{ 
	dxGdi 0 mxAlpha transform 
	/dxGdi exch def /dyGdi exch def
   	mxCharToUser transform AlignXY 
	/y0 exch def /x0 exch def
   	str stringwidth
   	neg dyGdi add cbStr div /dyExtra exch def
   	neg dxGdi add cbStr div /dxExtra exch def
   	}
   	{ 
    /y0 exch def
    % /y0 exch dyFromTop add def    % changed 87-1-11
   	/x0 exch def
   	iRes iDevRes ne 
	{ x0 y0 AlignXY /y0 exch def /x0 exch def } if
   	str stringwidth pop
   	neg dxGdi add cbStr div /dxExtra exch def /dyExtra 0 def
   	} ifelse
 	x0 y0 moveto
 	fBreakExtra
 	{ dxBreak dyBreak BreakChar dxExtra dyExtra str awidthshow }
 	{ dxExtra dyExtra str ashow }
 	ifelse
 	fStrikeout fUnderline or
 	{
	currentpoint
	exch dxExtra sub exch dyExtra sub
 	y0 sub /dy exch def
 	x0 sub /dx exch def
 	fUnderline {Underline} if
 	fStrikeout {Strikeout} if
 	} if
 	/fBreakExtra false def

 	} bind def

% This vector remaps the character set to ANSI from Adobe standard
% The first few values are referenced by composite characters
/ANSIVec[
16#0 /grave
16#1 /acute
16#2 /circumflex
16#3 /tilde
16#4 /macron
16#5 /brev
16#6 /dotaccent
16#7 /dieresis
16#8 /ring
16#9 /cedilla
16#A /hungarumlaut
16#B /ogonek
16#C /caron
16#D /dotlessi
16#27 /quotesingle
16#60 /grave
16#7C /bar				%sjp20Aug87
16#91 /quoteleft
16#92 /quoteright
16#93 /quotedblleft
16#94 /quotedblright
16#95 /bullet
16#96 /endash
16#97 /emdash
16#A0 /space
16#A4 /currency
16#A6 /brokenbar		%sjp20Aug87: changed from /bar
16#A7 /section
16#A8 /dieresis
16#A9 /copyright		%sec 87-1-16
16#AA /ordfeminine
16#AB /guillemotleft
16#AC /bullet
16#AD /hyphen
16#AE /registered		%sec87-1-16
16#AF /macron
16#B0 /degree			%problem here?...sjp21jul87 /ring
16#B1 /plusminus		%sjp21jul87 /bullet
16#B2 /twosuperior		%sjp21jul87 /bullet
16#B3 /threesuperior	%sjp21jul87 /bullet
16#B4 /acute
16#B5 /mu				%sjp21jul87 /bullet
16#B6 /paragraph
16#B7 /periodcentered
16#B8 /cedilla
16#B9 /onesuperior		%sjp21jul87 /bullet
16#BA /ordmasculine
16#BB /guillemotright
16#BC /onequarter		%problem here?...sjp21jul87 /bullet		%sec87-1-16
16#BD /onehalf			%sjp21jul87 /bullet
16#BE /threequarters	%sjp21jul87 /bullet
16#BF /questiondown
16#C0 /Agrave
16#C1 /Aacute
16#C2 /Acircumflex
16#C3 /Atilde
16#C4 /Adieresis
16#C5 /Aring
16#C6 /AE
16#C7 /Ccedilla
16#C8 /Egrave
16#C9 /Eacute
16#CA /Ecircumflex
16#CB /Edieresis
16#CC /Igrave
16#CD /Iacute
16#CE /Icircumflex
16#CF /Idieresis
16#D0 /Eth				%sjp21jul87 /bullet
16#D1 /Ntilde
16#D2 /Ograve
16#D3 /Oacute
16#D4 /Ocircumflex
16#D5 /Otilde
16#D6 /Odieresis
16#D7 /multiply			%sjp20Aug87	/bullet
16#D8 /Oslash
16#D9 /Ugrave
16#DA /Uacute
16#DB /Ucircumflex
16#DC /Udieresis
16#DD /Yacute			%sjp21jul87 /bullet
16#DE /Thorn			%sjp21jul87 /bullet
16#DF /germandbls
16#E0 /agrave
16#E1 /aacute
16#E2 /acircumflex
16#E3 /atilde
16#E4 /adieresis
16#E5 /aring
16#E6 /ae
16#E7 /ccedilla
16#E8 /egrave
16#E9 /eacute
16#EA /ecircumflex
16#EB /edieresis
16#EC /igrave
16#ED /iacute
16#EE /icircumflex
16#EF /idieresis
16#F0 /eth				%sjp21jul87 /bullet
16#F1 /ntilde
16#F2 /ograve
16#F3 /oacute
16#F4 /ocircumflex
16#F5 /otilde
16#F6 /odieresis
16#F7 /divide			%sjp20Aug87	/bullet
16#F8 /oslash
16#F9 /ugrave
16#FA /uacute
16#FB /ucircumflex
16#FC /udieresis
16#FD /yacute			%sjp21jul87 /bullet
16#FE /thorn			%sjp21jul87 /bullet
16#FF /ydieresis
] def

/reencdict 12 dict def


% CharName  IsChar  BOOL
% IsChar tests to see if a character is in the basefontdict.
% It returns true if it is, otherwise false.
%
/IsChar {basefontdict /CharStrings get exch known} bind def


% CharPosition CharName  MapCh  --
% MapCh sets the specified character mapping in the font
% being created (newfontdict)
%
/MapCh {
	dup IsChar not 
		{pop /bullet} if 
	newfont /Encoding get 3 1 roll put 
	}bind def


% --  MapDegree  --
% MapDegree maps /degree to 0xb0 if it exists in the character set
% otherwise it tries to map the older /ring.
%
/MapDegree{16#b0 /degree IsChar {/degree}{/ring} ifelse MapCh} bind def


% --  MapBB  --
% MapBB maps /brokenbar to 0xa6 if it exists in the character set
% otherwise it tries to map the older /bar.
%
/MapBB {16#a6 /brokenbar IsChar {/brokenbar}{/bar}ifelse MapCh} bind def


% ANSIFont (/font /newfont)
% This routine creates a new font that has the ANSI character set
/ANSIFont
	{
	reencdict begin
        /newfontname exch def           %may use up VM
        /basefontname exch def

 	FontDirectory newfontname known not
 		{
 		/basefontdict basefontname findfont def
 		/newfont basefontdict maxlength dict def
 		basefontdict
 			{ exch dup /FID ne
 				{ dup /Encoding eq
 					{ exch dup length array copy newfont 3 1 roll put }
 					{ exch newfont 3 1 roll put }
 					ifelse
 				}
 				{pop pop}
 				ifelse
 			}forall
 		newfont /FontName newfontname put
 		127 1 159 {newfont /Encoding get exch /bullet put} for
 		ANSIVec aload pop
 		ANSIVec length 2 idiv

%		At this point, we have the repeat count, and all the character values
%		and names on the stack.

% OLD		{ dup basefontdict /CharStrings get exch known
% OLD			{ newfont /Encoding get 3 1 roll put }
% OLD			{ pop newfont /Encoding get exch /bullet put } ifelse
% OLD		}
% OLD		repeat

%			If the character is not part of the character set
%			then substitute a bullet.  This is done because the new
%			Adobe fonts are a superset of the old, and not all printers
%			can be assumed to have these character sets available.
%
			{MapCh}repeat 

%			Since the old Adobe character sets did not have 
%			/degree or /brokenbar they were previously mapped to
%			to /ring and /bar (part of the old character set and
%			also part of the new).  In order to provide some level
%			of backward compatibility these 2 are remapped to the old
%			characters (if possible) rather than becoming /bullet.
%
			MapDegree MapBB

 		newfontname newfont definefont pop
 		} if
 		newfontname
 		end
 		} bind def

% font(BreakChar, alpha, beta, Sx, Sy, fUnderline, fStrikeout, /Font)
% This routine is used to select a new font
/font
	{
 	9 1 roll
 	0 ne {0} {1} ifelse 
	/grayCur exch def
 	0 ne /fStrikeout exch def
 	0 ne /fUnderline exch def
 	/Sy exch def
 	/Sx exch def
 	/beta exch 10.0 div def
 	/alpha exch 10.0 div def
 	/BreakChar exch def
 	alpha mxAlpha rotate pop
 	findfont dup

 	Sx Sy neg mx1 scale
 	alpha mx2 rotate
 	mx3 concatmatrix
 	makefont setfont
 
 	dup /FontBBox get
 	dup 3 get dup 3 2 roll 1 get sub div
 	Sy mul /dyFromTop exch def
 	0 dyFromTop mx1 translate alpha mx2 rotate mxCharToUser concatmatrix pop
 	0 0 mxCharToUser transform mxCharToUser translate pop
 	SetUnderline
 	SetStrikeout
 	} def

/eject { showpage SetCTM PenWidth setlinewidth } def
/m matrix def 
/cellsize 0 def 

/bitison
	{
	/iy exch def
	/ix exch def
	pat iy 7 and get 
        1 7 ix 7 and sub bitshift
	and 
	0 eq 
	} bind def

/spotfunction
	{
 	exch
 	1 add 4 mul cvi 
 	exch
 	1 add 4 mul cvi 
 	bitison 
        { /onbits onbits 1 add def 1 }
        { /offbits offbits 1 add def 0 }
 	ifelse
 	} bind def

/PatGray { offbits offbits onbits add div setgray } def
/SolidGray { iBrushGray setgray } def
/PenGray { iPenGray setgray } def

/SetPattern
	{

%LARRYF        /angle2 exch def
 	/pat exch def
%        /cellsize iRes 300 32 div div def
        /cellsize iRes 300 16 div div def

        /rm 90 matrix rotate def
 	/sm cellsize dup matrix scale def
 	sm rm matrix concatmatrix
 	matrix currentmatrix
 	m concatmatrix pop
 	1 0 m dtransform /dy exch def /dx exch def
 	/onbits 0 def
 	/offbits 0 def
        iDevRes dx dy hypot div     %compute new screen frequency
        dx dy atan /spotfunction load setscreen
 	{} settransfer
 	0 setgray
 	/fGrayScreen false def
 	} bind def

/min { 1 index 1 index gt { exch } if pop } def
/NonZero { dup 0 eq { pop 1 } if } def
/sto { exch def } def
/iBrush 1 def 
/iPen 0 def 
/fGrayScreen true def 
/iBrushGray 0 def 
/picstr 1 string def
/cx 0 def
/cy 0 def


/FillPoly
	{
	iBrush 0 eq { SolidGray fill 0 setgray } if 
	iBrush 1 eq {} if 
	iBrush 2 eq {} if 
	iBrush 3 eq { PatGray fill 0 setgray } if 
	} def

/EOFillPoly
	{
	iBrush 0 eq { SolidGray eofill 0 setgray } if 
 	iBrush 1 eq {} if 
 	iBrush 2 eq {} if 
 	iBrush 3 eq { PatGray eofill 0 setgray } if 
 	} def

/GDIStroke
	{
	iPen 0 ge iPen 5 lt and
		{ PenGray stroke 0 setgray }
		{ newpath } % for null lines this is a null stroke
	ifelse
 	} def

/GetAngle
	{
	Ty sub
	Sy div
	exch
	Tx sub
	Sx div
	atan
	} def

/SetBrush
	{
	/iBrush exch def
	iBrush 0 eq
		{
		/iBrushGray exch 1000 div def
 		fGrayScreen not 
		{ 
			frequency angle WinDict /proc get setscreen 
		} if
 		/fGrayScreen true def
 		0 setgray
 		} if
 	} def

/GapWidth { iRes 0.0825 mul PenWidth mul cvi } def
/DotWidth { iRes 0.020 mul PenWidth mul cvi } def
/DashWidth { iRes 0.125 mul PenWidth mul cvi } def


/SetPen
	{

 	/iPenGray exch 1000 div def
 	/PenWidth exch def
 	/iPen exch def
 	iPen 0 ge
 	{
 	iPen 0 eq 
	{ [] 0 setdash } if
 	iPen 1 eq 
	{ [DashWidth GapWidth] 0 setdash } if
 	iPen 2 eq 
	{ [DotWidth GapWidth] 0 setdash } if
 	iPen 3 eq 
	{ [DashWidth GapWidth DotWidth GapWidth] 0 setdash } if
 	iPen 4 eq 
	{ [DashWidth GapWidth DotWidth GapWidth DotWidth GapWidth] 0 setdash} if
 	} if
 	PenWidth setlinewidth
 	} bind def


%Ellipse box: x0, y0, x1, y1
/EBox {
        /y1 sto /x1 sto
        /y0 sto /x0 sto
        /Sx x1 x0 sub 2 div abs NonZero def
        /Sy y1 y0 sub 2 div abs NonZero def
        Sx Sy min /r sto

        x0 x1 add 2 div /Tx sto
        y0 y1 add 2 div /Ty sto
        Tx Ty translate
        Sx r div Sy r div scale
        0 0 r
    }def

%Arc Box: x0, y0, x1, y1, x2, y2, x3, y3
/ABox
    {
        /y3 sto /x3 sto
        /y2 sto /x2 sto
        EBox

        % Make a check for degeneracy
        x0 x1 eq y0 y1 eq or
        {
            y0 y1 eq
            { x2 x3 le { 90 180 } { 0 90 } ifelse }
            { y2 y3 le { 0 90 } { 270 360 } ifelse }
            ifelse
        }
        {x3 y3 GetAngle x2 y2 GetAngle}
        ifelse
    }def

/GDIEllipse
        {
        gsave EBox
        newpath 0 360 arc closepath SetCTM
        gsave FillPoly grestore GDIStroke
        grestore
        } def

/GDIArc {gsave ABox newpath arc SetCTM GDIStroke grestore} def

/GDIPie
        {
        gsave ABox newpath 0 0 moveto arc closepath SetCTM
        gsave FillPoly grestore GDIStroke grestore
        } def

/Box
	{
 	save 
	5 1 roll
	/y1 sto /x1 sto
	/y0 sto /x0 sto
 	newpath
 	x0 y0 moveto
 	x0 y1 lineto
 	x1 y1 lineto
 	x1 y0 lineto
 	closepath
 	FillPoly
 	restore
 	} bind def

/GDIRect
	{
	SaveState
 	/y1 sto /x1 sto
 	/y0 sto /x0 sto
 	newpath
 	x0 y0 moveto
 	x0 y1 lineto
 	x1 y1 lineto
 	x1 y0 lineto
 	closepath
 	gsave FillPoly grestore GDIStroke
 	RestoreState
	0 setgray	% 87-1-30 sec
 	} bind def

% 17 June 1987 -- sjp
/GDIRoundRect {
	SaveState
	/y2 sto	/x2 sto
	/y1 sto /x1 sto
	/y0 sto /x0 sto
	newpath
	x0 x2 add y0 moveto
	x1 y0 x1 y1 x2 arcto 4 { pop } repeat
	x1 y1 x0 y1 x2 arcto 4 { pop } repeat
	x0 y1 x0 y0 x2 arcto 4 { pop } repeat
	x0 y0 x1 y0 x2 arcto 4 { pop } repeat
	closepath
	gsave FillPoly grestore GDIStroke
	RestoreState
	0 setgray
} bind def

% Polygon drawing is split up into three phases
% a.) Call to StartFill
% b.) A series of PolyPoints calls
% c.) A call to EndFill to fill the polygon
/StartFill
	{
	newpath
 	moveto
 	} def

/PolyPoints
 	{
 	{ lineto } repeat
 	} def

/EndFill
 {
 	closepath
 	gsave
 	0 ne {EOFillPoly} {FillPoly} ifelse
 	grestore
 	GDIStroke
 	} def

/GDIPolyLine
	{
 	newpath
 	3 1 roll
 	moveto
 	1 sub
 	{ lineto } repeat
 	GDIStroke
 	clear
 	} bind def

/GDILine
	{
	SaveState
	newpath
	4 2 roll
	moveto
	lineto
	GDIStroke
	RestoreState
 	} def

/_S
	{
	SaveState
 	gsave
 	0 eq
 	{PenGray}
 	{
 	iBrush 0 eq {SolidGray} if 
 	iBrush 1 eq {0 setgray} if 
 	iBrush 2 eq iBrush 3 eq or {PatGray} if 
 	1 setlinewidth
 	[] 0 setdash
 	} ifelse
 	exch /y0 exch def
 	{
 	y0 moveto
 	y0 lineto
 	stroke
 	} repeat

 	PenWidth setlinewidth
 	0 setgray
 	grestore
 	RestoreState
 	} bind def

/cbRun 0 def
/cbPat 0 def
/cRep 0 def
/rgbRun 1024 string def
/rgbByte 1 string def
/GetByte { currentfile rgbByte readhexstring pop 0 get } bind def
/GetWord { GetByte 256 mul GetByte add } bind def
/GetString { currentfile exch readhexstring pop pop } bind def

% This routine duplicates a string
/RepString
	{
	/cbRun cbPat cRep mul cvi store
	rgbRun 0 cbPat getinterval GetString
	cbPat
	{
	dup 2 mul exch rgbRun exch
	rgbRun 0 2 index getinterval
	putinterval
	dup 16 ge {exit} if
	} loop
 	/cbPat exch def
 	0 cbPat cbRun 1 sub 
	{ rgbRun exch rgbRun 0 cbPat getinterval putinterval } for
 	rgbRun 0 cbRun getinterval
 	} bind def

/GetRun
	{
	/cRep GetWord def
	/cbPat GetByte def
	cbPat 0 eq { rgbRun 0 cRep getinterval GetString } { RepString } ifelse
 	} bind def

/Scan
	{
	/cx exch cvi def
	/y0 exch cvi def
 	/x0 exch cvi def
 	gsave
 	x0 y0 translate
 	save
 	cx 1 scale
 	cx 1 false [cx 0 0 1 0 0] { GetRun } imagemask
 	restore
 	grestore
 	} bind def

 /BitBlt
        {
		SaveState
        /cy exch cvi def
        /cx exch cvi def
        /y0 exch cvi def
        /x0 exch cvi def

		/picstr cx 7 add 8 idiv string def	% row buffer

        gsave
		0 setgray	% 87-1-29 sec
        x0 y0 translate
        cx cy false [1 0 0 1 0 0] {currentfile picstr readhexstring pop} imagemask
        grestore
		RestoreState
        }def
/OpaqueBox
	{
	/cy exch def
	/cx exch def
	/y0 exch def
	/x0 exch def
	gsave
	1 setgray
	newpath
	x0 y0 moveto
	x0 cx add y0 lineto
	x0 cx add y0 cy add lineto
	x0 y0 cy add lineto
	closepath
	fill
	grestore
	} bind def

%)		The mkhead.exe program should ignore the following lines.
end
100 700 moveto /Helvetica findfont 36 scalefont setfont
(psprep.txt loaded.) show showpage
quit
